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< 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))) }