1 files changed, 117 insertions, 0 deletions

diff --git a/web/utils.go b/web/utils.go
new file mode 100644
index 0000000..5467132
--- /dev/null
+++ b/web/utils.go
@@ -0,0 +1,117 @@
+package web
+
+import (
+        "context"
+        "fmt"
+        "log"
+        "net"
+        "net/http"
+        "net/url"
+        "os"
+        "os/signal"
+        "regexp"
+
+        "github.com/gin-gonic/gin"
+)
+
+// Parses an IPv4 or IPv6 address with an optional port on the end. Returns
+// match groups for the addresses. The first match is the IPv6 address and the
+// second the IPv4 address.
+var ipRegexp = regexp.MustCompile(`(?:\[([0-9a-f:]+)\]|(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}))(?::\d+)?`)
+
+// TODO: use from a common package
+func ParseIP(s string) net.IP {
+        ips := ipRegexp.FindStringSubmatch(s)
+        if ips == nil {
+                return nil
+        }
+
+        if v6, v4 := ips[1], ips[2]; v6 != "" {
+                return net.ParseIP(v6)
+        } else {
+                return net.ParseIP(v4)
+        }
+}
+
+// TODO: use from a common package
+func GetRequestIP(c *gin.Context) net.IP {
+        if xff := c.Request.Header.Get("X-Forwarded-For"); xff != "" {
+                return ParseIP(xff)
+        }
+        return ParseIP(c.Request.RemoteAddr)
+}
+
+// TODO: use from a common package
+func MakeURL(r *http.Request, path string, subs ...interface{}) *url.URL {
+        scheme := "https"
+        if r.TLS == nil {
+                scheme = "http"
+        }
+
+        // Always defer to whatever the proxy told us it was doing because this
+        // could be a mullet-VIP in either direction.
+        if fwProto := r.Header.Get("X-Forwarded-Proto"); fwProto != "" {
+                scheme = fwProto
+        }
+
+        return &url.URL{
+                Scheme: scheme,
+                Host:   r.Host,
+                Path:   fmt.Sprintf(path, subs...),
+        }
+}
+
+// TODO: use from a common package
+// Copied from: https://github.com/gin-gonic/gin/blob/59ab588bf597f9f41faee4f217b5659893c2e925/utils.go#L137
+func resolveAddress(addr []string) string {
+        switch len(addr) {
+        case 0:
+                if port := os.Getenv("PORT"); port != "" {
+                        log.Printf("Environment variable PORT=\"%s\"", port)
+                        return ":" + port
+                }
+                log.Printf("Environment variable PORT is undefined. Using port :8080 by default")
+                return ":8080"
+        case 1:
+                return addr[0]
+        default:
+                panic("too many parameters")
+        }
+}
+
+// TODO: use from a common package
+// Runs a gin.Engine instance in a way that can be canceled by an SIGINT
+func GinRun(e *gin.Engine, debug bool, a ...string) {
+        if debug {
+                gin.SetMode(gin.DebugMode)
+        } else {
+                gin.SetMode(gin.ReleaseMode)
+        }
+
+        srv := &http.Server{
+                Addr:    resolveAddress(a),
+                Handler: e,
+        }
+
+        idleConnsClosed := make(chan struct{})
+
+        go func() {
+                sigint := make(chan os.Signal, 1)
+                signal.Notify(sigint, os.Interrupt)
+                <-sigint
+
+                log.Println("Caught SIGINT, shutting down")
+                if err := srv.Shutdown(context.Background()); err != nil {
+                        log.Printf("HTTP server Shutdown: %v", err)
+                }
+
+                close(idleConnsClosed)
+        }()
+
+        log.Printf("Listening and serving HTTP on %s\n", srv.Addr)
+        if err := srv.ListenAndServe(); err != http.ErrServerClosed {
+                log.Fatalf("HTTP server ListenAndServe: %v", err)
+        }
+
+        <-idleConnsClosed
+}