From 430d388c578c6c68a98581c5ee1f6c337ddc74c5 Mon Sep 17 00:00:00 2001
From: Tom Andrade <wolvie@gmail.com>
Date: Thu, 26 Mar 2020 11:41:41 +0100
Subject: [PATCH] I'm bad at commits...
---
main.go | 416 ++++++++++++++++++++++++++++----------------------------
1 file changed, 208 insertions(+), 208 deletions(-)
diff --git a/main.go b/main.go
index 2d9929f..ff0491a 100644
--- a/main.go
+++ b/main.go
@@ -3,6 +3,7 @@ package main
import (
"encoding/json"
"flag"
+ "fmt"
"html/template"
"io/ioutil"
"log"
@@ -12,7 +13,6 @@ import (
"net/url"
"os"
"regexp"
- "strconv"
"strings"
"time"
@@ -22,20 +22,6 @@ import (
"github.com/patrickmn/go-cache"
)
-type config struct {
- addr string
- domain string
- dumpFile string
- path string
- proto string
- hostSuf string
- listenAddr string
- port int
- urlSize int
- version bool
- templates *template.Template
-}
-
type body struct {
FullHeader bool
IsGhost bool
@@ -52,75 +38,20 @@ const (
letterIdxBits = 6 // 6 bits to represent a letter index
letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
letterIdxMax = 63 / letterIdxBits // # of letter indices fitting in 63 bits
- appVersion = "1.2.1"
+ appVersion = "1.3.0"
)
var (
- cfg config
- src = rand.NewSource(time.Now().UnixNano())
- pool = cache.New(240*time.Hour, 1*time.Hour)
+ // tiny entropy pool
+ src = rand.NewSource(time.Now().UnixNano())
+ // KV memory DB
+ pool *cache.Cache
+ // Error codes
+ errBadRequest = fmt.Errorf("Bad Request")
+ errNotFound = fmt.Errorf("Not Found")
)
-func init() {
- flag.StringVar(&cfg.addr, "addr", "localhost", "Address to listen for connections")
- flag.StringVar(&cfg.domain, "domain", "localhost", "Domain to write to the URLs")
- flag.StringVar(&cfg.dumpFile, "dump", "urls.json", "Path to the file to dump the kv db")
- flag.StringVar(&cfg.path, "path", "", "Path to the base URL (https://localhost/PATH/... remember to append a / at the end")
- flag.StringVar(&cfg.proto, "proto", "https", "proto to the base URL (HTTPS://localhost/path/... no real https here just to set the url (for like a proxy offloading https")
- flag.IntVar(&cfg.port, "port", 8080, "Port to listen for connections")
- flag.IntVar(&cfg.urlSize, "urlsize", 10, "Define the size of the shortened String, default 10")
- flag.BoolVar(&cfg.version, "v", false, "prints current version")
- flag.Parse()
-
- if cfg.version {
- log.SetFlags(0)
- log.Println(appVersion)
- os.Exit(0)
- }
-
- if cfg.port > 65535 || cfg.port < 1 {
- log.Fatalln("Invalid port number")
- }
- if cfg.path != "" && !strings.HasSuffix(cfg.path, "/") {
- cfg.path = cfg.path + "/"
- }
-
- if cfg.port != 80 && cfg.proto == "http" {
- cfg.hostSuf = ":" + strconv.Itoa(cfg.port) + "/"
- } else if cfg.port != 443 && cfg.proto == "https" {
- cfg.hostSuf = ":" + strconv.Itoa(cfg.port) + "/"
- } else if cfg.port == 443 || cfg.port == 80 {
- cfg.hostSuf = "/"
- }
-
- ip := net.ParseIP(cfg.addr)
- if ip != nil {
- cfg.listenAddr = ip.String() + ":" + strconv.Itoa(cfg.port)
- } else {
- if govalidator.IsDNSName(cfg.addr) {
- cfg.listenAddr = cfg.addr + ":" + strconv.Itoa(cfg.port)
- } else {
- log.Fatalln("Invalid ip address")
- }
- }
-
- if !govalidator.IsDNSName(cfg.domain) {
- log.Fatalln("Invalid domain address")
- }
-
- cfg.templates = template.Must(template.ParseFiles("templates/response.html"))
-}
-
-func (c config) index(w http.ResponseWriter, r *http.Request) {
- b := body{
- HasForm: true,
- Line1: "Welcome to Short, the simple URL shortener,",
- Line2: "Type an URL below to shorten it",
- }
- c.templates.Execute(w, b)
-}
-
-// get executes the GET command
+// get executes the GET command
func get(key string) (string, bool) {
value, status := pool.Get(key)
if !status {
@@ -134,76 +65,42 @@ func set(key, suffix string) {
pool.Set(suffix, key, 0)
}
-// redirect reads the key from the requests url (GET /key) searches the
-// kv database for it and if found redirects the user to value, if not
-// found return a 404.
-func (c config) redirect(w http.ResponseWriter, r *http.Request) {
- vals := mux.Vars(r)
- key := vals["key"]
- b := body{
- FullHeader: true,
- IsGhost: true,
- HasForm: true,
- H1: "404",
- H3: "page not found",
- Line1: "Boo, looks like this ghost stole this page!",
- Line2: "But you can type an URL below to shorten it",
- }
- if c.path != "" {
- key = strings.Replace(key, c.path, "", 1)
- }
+// redirect receives a key searches the kv database for it and if
+// found returns the value, or a error if not found
+func redirect(k string) (string, error) {
rgx, _ := regexp.Compile("[a-zA-Z0-9]+")
- key = rgx.FindString(key)
+ key := rgx.FindString(k)
key, status := get(key)
if !status {
- w.WriteHeader(http.StatusNotFound)
- c.templates.Execute(w, b)
- return
+ return "", errNotFound
}
u, _ := url.Parse(key)
if u.Scheme == "" {
u.Scheme = "https"
}
- http.Redirect(w, r, u.String(), http.StatusFound)
+ return u.String(), nil
}
-// shortner reads url from a POST request, validates the url, generate a
-// random suffix string of urlSize size, checks if the suffix string is
-// unique on the kv database and if not unique regenerates it and checks again,
-// then if writes the kv pair suffix, url to the database and return the
-// shortened url to the user
-func (c config) shortner(w http.ResponseWriter, r *http.Request) {
- if !govalidator.IsURL(r.FormValue("url")) {
- b := body{
- FullHeader: true,
- IsGhost: true,
- HasForm: true,
- H1: "400",
- H3: "bad request",
- Line1: "Boo, looks like this ghost stole this page!",
- Line2: "But you can type an URL below to shorten it",
- }
- w.WriteHeader(http.StatusBadRequest)
- c.templates.Execute(w, b)
- return
+// shortener receive a url, validates the url, generate a random suffix string
+// of urlSize size, checks if the suffix string is ensure on the kv database
+// and then writes the kv pair (suffix, url) to the database, returning the suffix
+func shortener(u string, s int) (string, error) {
+ var su string
+ if !govalidator.IsURL(u) {
+ return su, errBadRequest
}
- u, _ := url.Parse(r.FormValue("url"))
- suffix := randStringBytesMaskImprSrc(c.urlSize)
+ pu, _ := url.Parse(u)
for {
- _, status := get(suffix)
+ su = randStringBytesMaskImprSrc(s)
+ _, status := get(su)
if !status {
break
}
- suffix = randStringBytesMaskImprSrc(c.urlSize)
}
- set(u.String(), suffix)
- shortend := c.proto + "://" + c.domain + c.hostSuf + c.path + suffix
- b := body{
- IsLink: true,
- Line1: shortend,
- }
- c.templates.Execute(w, b)
+
+ set(pu.String(), su)
+ return su, nil
}
// randStringBytesMaskImprSrc Generate random string of n size
@@ -224,108 +121,211 @@ func randStringBytesMaskImprSrc(n int) string {
return string(b)
}
-// internalError receives a http.ResponseWriter, msg and error and
-// return a internal error page with http code 500 to the user
-func (c config) internalError(w http.ResponseWriter, msg string, err error) {
- b := body{
+func internalError(msg string, err error) body {
+ log.Println(err)
+ return body{
FullHeader: true,
IsGhost: true,
HasForm: true,
H1: "500",
- H3: "internal erver error",
+ H3: msg,
Line1: "Boo, the ghost is broken :(",
Line2: "His last words where: " + err.Error(),
}
- log.Println(err)
- w.WriteHeader(http.StatusInternalServerError)
- c.templates.Execute(w, b)
}
-// itemsCount returns the number of kv pairs on the in meomry database
-func (c config) itemsCount(w http.ResponseWriter, r *http.Request) {
- w.Write(
- []byte(
- strconv.Itoa(
- pool.ItemCount(),
- ),
- ),
- )
-}
-
-// itemsDump returns a json with all the kv pairs on the in memory database
-func (c config) itemsDump(w http.ResponseWriter, r *http.Request) {
- dumpObj, err := json.Marshal(
- pool.Items(),
- )
+// loadFromFile loads kv pairs from the dumpFile json to the in memory database
+func loadFromFile(file string, e, c int) (int, error) {
+ dumpObj := make(map[string]cache.Item)
+ jsonFile, err := ioutil.ReadFile(file)
if err != nil {
- c.internalError(w, "Unable to dump key value db: ", err)
+ return 0, err
}
- w.Write(
- []byte(dumpObj),
- )
-}
-// itemsFromFile loads kv pairs from the dumpFile json to the in memory database
-func (c config) itemsFromFile(w http.ResponseWriter, r *http.Request) {
- jsonFile, err := ioutil.ReadFile(c.dumpFile)
- var dumpObj map[string]cache.Item
- json.Unmarshal([]byte(jsonFile), &dumpObj)
+ err = json.Unmarshal([]byte(jsonFile), &dumpObj)
if err != nil {
- c.internalError(w, "Cannot open file "+c.dumpFile+": ", err)
- return
+ return 0, err
}
- pool = cache.NewFrom(240*time.Hour, 1*time.Hour, dumpObj)
- b := body{
- Line1: "Imported " + strconv.Itoa(len(dumpObj)) + " items to the DB",
- }
- c.templates.Execute(w, b)
+
+ pool = cache.NewFrom(time.Duration(e)*time.Hour, time.Duration(c)*time.Hour, dumpObj)
+ return len(dumpObj), err
}
// itemsFromPost loads kv pairs from a json POST to the in memory database
-func (c config) itemsFromPost(w http.ResponseWriter, r *http.Request) {
- decoder := json.NewDecoder(r.Body)
- var dumpObj map[string]cache.Item
- err := decoder.Decode(&dumpObj)
+func loadFromJSON(j []byte, e, c int) (int, error) {
+ dumpObj := make(map[string]cache.Item)
+ err := json.Unmarshal(j, &dumpObj)
if err != nil {
- c.internalError(w, "Cannot parse JSON: ", err)
- return
+ return 0, err
}
- pool = cache.NewFrom(240*time.Hour, 1*time.Hour, dumpObj)
- b := body{
- Line1: "Imported " + strconv.Itoa(len(dumpObj)) + " items to the DB",
- }
- c.templates.Execute(w, b)
+
+ pool = cache.NewFrom(time.Duration(e)*time.Hour, time.Duration(c)*time.Hour, dumpObj)
+ return len(dumpObj), nil
}
-// itemsDumpToFile dumps the kv pairs from the in memory database to the dumpFile
-func (c config) itemsDumpToFile(w http.ResponseWriter, r *http.Request) {
- dumpObj, _ := json.Marshal(
- pool.Items(),
- )
- err := ioutil.WriteFile(c.dumpFile, dumpObj, 0644)
- if err != nil {
- c.internalError(w, "Failed to open json file: ", err)
- return
- }
- b := body{
- Line1: "Imported " + "Dump writen to: " + c.dumpFile,
- }
- c.templates.Execute(w, b)
+// dumpDbToFile dumps the kv pairs from the in memory database to file
+func dumpDbTOFile(file string) (int, error) {
+ i := pool.Items()
+ dumpObj, _ := json.Marshal(i)
+ return len(i), ioutil.WriteFile(file, dumpObj, 0644)
}
func main() {
+ var (
+ addr = flag.String("addr", "localhost", "Address to listen for connections")
+ domain = flag.String("domain", "localhost", "Domain to write to the URLs")
+ dumpFile = flag.String("dump", "urls.json", "Path to the file to dump the kv db")
+ path = flag.String("path", "", "Path to the base URL (https://localhost/PATH/...")
+ proto = flag.String("proto", "https", "proto to the base URL (HTTPS://localhost/path/... no real https here just to set the url (for like a proxy offloading https")
+ port = flag.Int("port", 8080, "Port to listen for connections")
+ urlSize = flag.Int("urlsize", 10, "Define the size of the shortened String, default 10")
+ exp = flag.Int("exp", 240, "Default expiration time in hours, default 240")
+ cleanup = flag.Int("cleanup", 1, "Cleanup interval in hours, default 1")
+ version = flag.Bool("v", false, "prints current version")
+ listenAddr string
+ )
+ flag.Parse()
+
+ if *version {
+ fmt.Println(appVersion)
+ os.Exit(0)
+ }
+
+ if *port > 65535 || *port < 1 {
+ log.Fatalln("Invalid port number")
+ }
+ if *path != "" && !strings.HasSuffix(*path, "/") {
+ *path = *path + "/"
+ }
+
+ ip := net.ParseIP(*addr)
+ if ip != nil {
+ listenAddr = fmt.Sprintf("%s:%v", ip.String(), *port)
+ } else {
+ if govalidator.IsDNSName(*addr) {
+ listenAddr = fmt.Sprintf("%s:%v", *addr, *port)
+ } else {
+ log.Fatalln("Invalid ip address")
+ }
+ }
+
+ if !govalidator.IsDNSName(*domain) {
+ log.Fatalln("Invalid domain address")
+ }
+
+ pool = cache.New(time.Duration(*exp)*time.Hour, time.Duration(*cleanup)*time.Hour)
+ t := template.Must(template.ParseFiles("templates/response.html"))
r := mux.NewRouter()
- r.HandleFunc("/", cfg.index).Methods("GET")
- r.HandleFunc("/", cfg.shortner).Methods("POST")
- r.HandleFunc("/{key}", cfg.redirect).Methods("GET")
- r.HandleFunc("/v1/dumpToFile", cfg.itemsDumpToFile).Methods("GET")
- r.HandleFunc("/v1/fromFile", cfg.itemsFromFile).Methods("GET")
- r.HandleFunc("/v1/count", cfg.itemsCount).Methods("GET")
- r.HandleFunc("/v1/dump", cfg.itemsDump).Methods("GET")
- r.HandleFunc("/v1/fromPost", cfg.itemsFromPost).Methods("POST")
+ // Index
+ r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+ t.Execute(w, body{
+ HasForm: true,
+ Line1: "Welcome to Short, the simple URL shortener,",
+ Line2: "Type an URL below to shorten it",
+ })
+ }).Methods("GET")
- log.Printf("Domain: %s, URL Proto: %s, Listen Address: %s\n", cfg.domain, cfg.proto, cfg.listenAddr)
- log.Fatal(http.ListenAndServe(cfg.listenAddr, handlers.CombinedLoggingHandler(os.Stdout, r)))
+ // URL Shortener
+ r.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+ suf, err := shortener(r.FormValue("url"), *urlSize)
+ if err != nil {
+ w.WriteHeader(http.StatusBadRequest)
+ t.Execute(w, body{
+ FullHeader: true,
+ IsGhost: true,
+ HasForm: true,
+ H1: "400",
+ H3: err.Error(),
+ Line1: "Boo, looks like this ghost stole this page!",
+ Line2: "But you can type an URL below to shorten it",
+ })
+ return
+ }
+ ru, _ := url.Parse(fmt.Sprintf("%s://%s:%v/%s%s", *proto, *domain, *port, *path, suf))
+ t.Execute(w, body{
+ IsLink: true,
+ Line1: ru.String(),
+ })
+ }).Methods("POST")
+
+ // URL Redirect
+ r.HandleFunc("/{key}", func(w http.ResponseWriter, r *http.Request) {
+ vals := mux.Vars(r)
+ key := vals["key"]
+ if *path != "" {
+ key = strings.Replace(key, *path, "", 1)
+ }
+ u, err := redirect(key)
+ if err != nil {
+ w.WriteHeader(http.StatusNotFound)
+ t.Execute(w, body{
+ FullHeader: true,
+ IsGhost: true,
+ HasForm: true,
+ H1: "404",
+ H3: err.Error(),
+ Line1: "Boo, looks like this ghost stole this page!",
+ Line2: "But you can type an URL below to shorten it",
+ })
+ return
+ }
+ http.Redirect(w, r, u, http.StatusFound)
+ }).Methods("GET")
+
+ // Dump DB to file
+ r.HandleFunc("/v1/toFile", func(w http.ResponseWriter, r *http.Request) {
+ i, err := dumpDbTOFile(*dumpFile)
+ if err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ t.Execute(w, internalError("Failed to dump kv DB to file", err))
+ return
+ }
+ t.Execute(w, body{Line1: fmt.Sprintf("Exported %v items to %v", i, dumpFile)})
+ }).Methods("GET")
+
+ // Read DB from file
+ r.HandleFunc("/v1/fromFile", func(w http.ResponseWriter, r *http.Request) {
+ i, err := loadFromFile(*dumpFile, *exp, *cleanup)
+ if err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ t.Execute(w, internalError("Error loading DB from file", err))
+ return
+ }
+ t.Execute(w, body{Line1: fmt.Sprintf("Imported %v items to the DB", i)})
+ }).Methods("GET")
+
+ // Count items on DB
+ r.HandleFunc("/v1/count", func(w http.ResponseWriter, r *http.Request) {
+ fmt.Fprintf(w, "%v", pool.ItemCount())
+ }).Methods("GET")
+
+ r.HandleFunc("/v1/dump", func(w http.ResponseWriter, r *http.Request) {
+ dumpObj, err := json.Marshal(pool.Items())
+ if err != nil {
+ t.Execute(w, internalError("Unable to dump key value db: ", err))
+ return
+ }
+ fmt.Fprintf(w, "%s", dumpObj)
+ }).Methods("GET")
+
+ // Loads DB from json POST
+ r.HandleFunc("/v1/fromPost", func(w http.ResponseWriter, r *http.Request) {
+ b, err := ioutil.ReadAll(r.Body)
+ if err != nil {
+ t.Execute(w, internalError("Unable to dump key value db: ", err))
+ return
+ }
+ i, err := loadFromJSON(b, *exp, *cleanup)
+ if err != nil {
+ w.WriteHeader(http.StatusInternalServerError)
+ t.Execute(w, internalError("Error loading DB", err))
+ return
+ }
+ t.Execute(w, body{Line1: fmt.Sprintf("Imported %v items to the DB", i)})
+ }).Methods("POST")
+
+ log.Printf("Domain: %s, URL Proto: %s, Listen Address: %s\n", *domain, *proto, listenAddr)
+ log.Fatal(http.ListenAndServe(listenAddr, handlers.CombinedLoggingHandler(os.Stdout, r)))
}