Drover's back, baby!

go/src/infra/libs/gitiles/gitiles.go

+package gitiles
+
+import "bufio"
+import "bytes"
+import "encoding/base64"
+import "encoding/json"
+import "fmt"
+import "io"
+import "io/ioutil"
+import "net/http"
+import "reflect"
+import "strings"
+
+// Gitiles wraps one Gitiles server. Use NewGitiles to create one.
+type Gitiles struct {
+        url      string
+        requests chan<- request
+}
+
+// URL returns the base url for this Gitiles service wrapper
+func (g Gitiles) URL() string { return g.url }
+
+// NewGitiles creates a new Gitiles instance for the given |url|, and a maximum
+// number of concurrent requests.
+func NewGitiles(url string, maxConnections int) *Gitiles {
+        // TODO(riannucci): make a separate http.Client?
+        // TODO(riannucci): have a way to destroy the Gitiles instance?
+        requestChan := make(chan request, maxConnections)
+        ret := &Gitiles{
+                url:      strings.TrimRight(url, "/"),
+                requests: requestChan,
+        }
+        for i := 0; i < maxConnections; i++ {
+                go ret.requestProcessor(requestChan)
+        }
+        return ret
+}
+
+// StatusError is a simple error type which wraps a Http StatusCode.
+type StatusError int
+
+// Bad returns true iff the status code is not 2XX
+func (s StatusError) Bad() bool     { return !(s >= 200 && s < 300) }

[M-A Ruel, 2014/10/18 00:47:06]

return s < 200 || s >= 300
is actually shorter and IMHO more readable

[iannucci, 2014/10/20 21:11:58]

Done.

+func (s StatusError) Error() string { return fmt.Sprintf("got status code %d", s) }
+
+// TextResult is object you get back from JSON(). If Err is nil, DataPtr
+// contains an instance of whatever type you passed to |target|, unmarshalled
+// from the json response from gitiles.
+type TextResult struct {
+        Err  error
+        Data []byte
+}
+
+// JSONResult is object you get back from JSON(). If Err is nil, DataPtr
+// contains an instance of whatever type you passed to |target|, unmarshalled
+// from the json response from gitiles.
+type JSONResult struct {

[M-A Ruel, 2014/10/18 00:47:06]

Personally I had used specialized handlers, e.g. line 54
https://github.com/maruel/gddo/commit/b6c003e8c8e3dfc2d4c3800b79a003e389b5a9d2

[iannucci, 2014/10/20 21:11:58]

Made this struct private. no reason to expose to caller.

+        Err     error
+        DataPtr interface{}
+}
+
+// JSON Returns a channel to a JSONResult where DataPtr is a pointer to
+// a datatype described by target.
+//
+// Example:
+//   data := map[string]int{}
+//   result := g.JSON(data, "some", "url", "pieces")
+//   if result.Err != nil { panic(result.Err) }
+//   data = *result.DataPtr.(*map[string]int)
+func (g *Gitiles) JSON(target interface{}, pieces ...string) <-chan JSONResult {
+        reply := make(chan JSONResult, 1)
+        g.requests <- jsonRequest{
+                strings.Join(pieces, "/"),
+                reflect.TypeOf(target),
+                reply,
+        }
+        return reply
+}
+
+// Text returns a channel to a TextResult. It will load the given path with
+// format=TEXT and return the decoded data.
+func (g *Gitiles) Text(pieces ...string) <-chan TextResult {
+        reply := make(chan TextResult, 1)
+        g.requests <- textRequest{
+                strings.Join(pieces, "/"),
+                reply,
+        }
+        return reply
+}
+
+// private decoders
+
+type request interface {
+        Process(rsp *http.Response, err error)
+        Method() string
+        URLPath() string
+        Body() io.Reader
+}
+
+type jsonRequest struct {
+        urlPath    string
+        typ        reflect.Type
+        resultChan chan<- JSONResult
+}
+
+func (j jsonRequest) URLPath() string { return j.urlPath + "?format=JSON" }
+func (j jsonRequest) Method() string  { return "GET" }
+func (j jsonRequest) Body() io.Reader { return nil }
+
+func (j jsonRequest) Process(resp *http.Response, err error) {
+        var rslt JSONResult
+        if err != nil {
+                rslt.Err = err
+        } else {
+                bufreader := bufio.NewReader(resp.Body)
+                firstFour, err := bufreader.Peek(4)
+                if err != nil {
+                        rslt.Err = err
+                } else {
+                        if bytes.Equal(firstFour, []byte(")]}'")) {
+                                bufreader.Read(make([]byte, 4))
+                        }
+
+                        data := reflect.New(j.typ).Interface()
+                        err = json.NewDecoder(bufreader).Decode(data)
+                        if err != nil {
+                                rslt.Err = err
+                        } else {
+                                rslt.DataPtr = data
+                        }
+                }
+        }
+        j.resultChan <- rslt
+}
+
+type textRequest struct {
+        urlPath    string
+        resultChan chan<- TextResult
+}
+
+func (t textRequest) URLPath() string { return t.urlPath + "?format=TEXT" }
+func (t textRequest) Method() string  { return "GET" }
+func (t textRequest) Body() io.Reader { return nil }
+
+func (t textRequest) internalProcess(rsp *http.Response, err error) ([]byte, error) {
+        if err != nil {
+                return nil, err
+        }
+        return ioutil.ReadAll(base64.NewDecoder(base64.StdEncoding, rsp.Body))
+}
+
+func (t textRequest) Process(rsp *http.Response, err error) {
+        if data, err := t.internalProcess(rsp, err); err != nil {
+                t.resultChan <- TextResult{Err: err}
+        } else {
+                t.resultChan <- TextResult{Data: data}
+        }
+}
+
+func (g *Gitiles) requestProcessor(queue <-chan request) {
+        // Lanched as a goroutine to avoid blocking the request processor.

[M-A Ruel, 2014/10/18 00:47:06]

Launched

[iannucci, 2014/10/20 21:11:58]

Done.

+        for r := range queue {
+                r := r
+                if r == nil {
+                        continue
+                }
+
+                var req *http.Request
+                req, err := http.NewRequest(r.Method(), g.url+"/"+r.URLPath(), r.Body())
+                if err != nil {
+                        r.Process(nil, err)
+                        continue
+                }
+
+                rsp, err := http.DefaultClient.Do(req)
+                if err != nil {
+                        r.Process(nil, err)
+                        continue
+                }
+
+                e := StatusError(rsp.StatusCode)
+                if e.Bad() {
+                        err = &e

[M-A Ruel, 2014/10/18 00:47:06]

why not?
err = e

[iannucci, 2014/10/20 21:11:58]

Oops, done.

+                }
+                func() {
+                        defer rsp.Body.Close()
+                        r.Process(rsp, err)
+                }()
+        }
+}