1 files changed, 74 insertions, 13 deletions

diff --git a/cautious_http_client.go b/cautious_http_client.go
index 2f33ae0..34b736f 100644
--- a/cautious_http_client.go
+++ b/cautious_http_client.go
@@ -2,24 +2,29 @@ package main
 
 import (
         "encoding/json"
-        "fmt"
+        "github.com/lox/httpcache"
+        "github.com/pkg/errors"
         "net"
         "net/http"
         "net/url"
+        "strings"
         "time"
 )
 
 type CautiousHTTPClient interface {
         Get(string) (*http.Response, error)
         GetJSON(string, interface{}) error
+        GetJSONExpires(string, interface{}) (time.Duration, error)
 }
 
 type cautiousHttpClient struct {
-        client *http.Client
+        allowHttp bool
+        client    *http.Client
 }
 
-func NewCautiousHTTPClient() CautiousHTTPClient {
-        // May Need: TLSClientConfig *tls.Config
+// allowHttp is UNSAFE and technically validates the spec but it does make it
+// easier to work in dev so leaving it in for now
+func NewCautiousHTTPClient(allowHttp bool) (CautiousHTTPClient, error) {
         CautiousTransport := &http.Transport{
                 Proxy: http.ProxyFromEnvironment,
                 DialContext: (&net.Dialer{
@@ -36,44 +41,100 @@ func NewCautiousHTTPClient() CautiousHTTPClient {
         }
 
         return &cautiousHttpClient{
+                allowHttp: allowHttp,
                 client: &http.Client{
                         Transport: CautiousTransport,
                         Timeout:   30 * time.Second,
                 },
-        }
+        }, nil
 }
 
 func (c *cautiousHttpClient) Get(gurl string) (*http.Response, error) {
         u, err := url.Parse(gurl)
         if err != nil {
-                return nil, err
+                return nil, errors.WithStack(err)
         }
 
-        // TODO
-        if u.Scheme != "https" && false {
-                return nil, fmt.Errorf("URL for GET must be secure")
+        if u.Scheme != "https" && !c.allowHttp {
+                return nil, errors.Errorf("URL for GET must be secure")
         }
 
         r, err := c.client.Get(u.String())
         if err != nil {
-                return nil, err
+                return nil, errors.WithStack(err)
         }
         r.Body = http.MaxBytesReader(nil, r.Body, 1000000)
-        return r, err
+
+        return r, nil
 }
 
 func (c *cautiousHttpClient) GetJSON(url string, rv interface{}) error {
         r, err := c.Get(url)
         if err != nil {
-                return err
+                return errors.WithStack(err)
         }
         defer r.Body.Close()
 
         d := json.NewDecoder(r.Body)
         err = d.Decode(rv)
         if err != nil {
-                return err
+                return errors.WithStack(err)
         }
 
         return nil
 }
+
+func (c *cautiousHttpClient) GetJSONExpires(url string, rv interface{}) (time.Duration, error) {
+        r, err := c.Get(url)
+        if err != nil {
+                return time.Duration(0), errors.WithStack(err)
+        }
+        defer r.Body.Close()
+
+        res := httpcache.NewResource(r.StatusCode, nil, r.Header)
+
+        d := json.NewDecoder(r.Body)
+        err = d.Decode(rv)
+        if err != nil {
+                return time.Duration(0), errors.WithStack(err)
+        }
+
+        return refreshAfter(res), nil
+}
+
+type JSONURL struct {
+        *url.URL
+}
+
+func (u *JSONURL) AsURL() *url.URL {
+        return u.URL
+}
+
+func (u *JSONURL) UnmarshalJSON(data []byte) error {
+        d := strings.Trim(string(data), "\"")
+        pu, err := url.Parse(d)
+        if err != nil {
+                return errors.WithStack(err)
+        }
+
+        u.URL = pu
+        return nil
+}
+
+func refreshAfter(res *httpcache.Resource) time.Duration {
+        maxAge, err := res.MaxAge(false)
+        if err != nil {
+                return time.Duration(0)
+        }
+
+        age, err := res.Age()
+        if err != nil {
+                return time.Duration(0)
+        }
+
+        if hFresh := res.HeuristicFreshness(); hFresh > maxAge {
+                maxAge = hFresh
+        }
+
+        return maxAge - age
+}