[monorail go api] add IssuesList rpc

go/src/infra/monorail/endpoints.go

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package monorail
 
 import (
         "bytes"
         "encoding/json"
         "fmt"
@@ skipping 28 matching lines @@
 //
 // Methods do not implement retries.
 // Use "github.com/luci/luci-go/common/errors".IsTransient to check
 // if an error is transient.
 //
 // Client methods return an error on any grpc.CallOption.
 func NewEndpointsClient(client *http.Client, url string) MonorailClient {
         return &epClient{HTTP: client, url: strings.TrimSuffix(url, "/")}
 }
 
+func (c *epClient) get(ctx context.Context, urlSuffix string, response interface{}) error {
+        client := c.HTTP
+        if client == nil {
+                client = http.DefaultClient
+        }
+
+        // Limit ctx deadline to timeout set in client.
+        if client.Timeout > 0 {
+                clientDeadline := clock.Now(ctx).Add(client.Timeout)
+                if deadline, ok := ctx.Deadline(); !ok || deadline.After(clientDeadline) {
+                        ctx, _ = context.WithDeadline(ctx, clientDeadline)
+                }
+        }
+
+        // Make an HTTP request.
+        req, err := http.NewRequest("GET", c.url+urlSuffix, nil)
+        if err != nil {
+                return fmt.Errorf("could not make a request to %s: %s", req.URL, err)
+        }
+        req.Header.Set("Accept", "application/json")
+
+        // Send the request.
+        logging.Debugf(ctx, "GET %s %s", req.URL)
+        res, err := ctxhttp.Do(ctx, client, req)
+        if err != nil {
+                return errors.WrapTransient(err)
+        }
+        defer res.Body.Close()
+
+        // Check HTTP status code.
+        if res.StatusCode != http.StatusOK {
+                text, _ := ioutil.ReadAll(io.LimitReader(res.Body, 1024))
+                err := fmt.Errorf("unexpected status %q. Response: %s", res.Status, text)
+                if res.StatusCode == http.StatusNotFound || res.StatusCode > 500 {
+                        // Cloud Endpoints often flake with HTTP 404.
+                        // Treat such responses transient errors.
+                        err = errors.WrapTransient(err)
+                }
+                return err
+        }
+
+        if response == nil {
+                return nil
+        }
+        return json.NewDecoder(res.Body).Decode(response)
+}
+

[nodir, 2016/06/09 04:09:28]

Please don't copy paste code such big chunks of code so close. Add "method
string" parameter to call()

[seanmccullough1, 2016/06/09 15:01:32]

Done.

 func (c *epClient) call(ctx context.Context, urlSuffix string, request, response interface{}) error {
         client := c.HTTP
         if client == nil {
                 client = http.DefaultClient
         }
 
         // Limit ctx deadline to timeout set in client.
         if client.Timeout > 0 {
                 clientDeadline := clock.Now(ctx).Add(client.Timeout)
                 if deadline, ok := ctx.Deadline(); !ok || deadline.After(clientDeadline) {
                         ctx, _ = context.WithDeadline(ctx, clientDeadline)
                 }
         }
 
         // Convert request object to JSON.
         reqBuf := &bytes.Buffer{}
         if request != nil {
                 if err := json.NewEncoder(reqBuf).Encode(request); err != nil {
                         return err
                 }
         }
 
         // Make an HTTP request.
-        req, err := http.NewRequest("POST", c.url + urlSuffix, reqBuf)
+        req, err := http.NewRequest("POST", c.url+urlSuffix, reqBuf)
         if err != nil {
                 return fmt.Errorf("could not make a request to %s: %s", req.URL, err)
         }
         req.Header.Set("Content-Type", "application/json")
         req.Header.Set("Accept", "application/json")
 
         // Send the request.
         logging.Debugf(ctx, "POST %s %s", req.URL, reqBuf.Bytes())
         res, err := ctxhttp.Do(ctx, client, req)
         if err != nil {
@@ skipping 32 matching lines @@
 }
 
 func (c *epClient) InsertComment(ctx context.Context, req *InsertCommentRequest, options ...grpc.CallOption) (*InsertCommentResponse, error) {
         if err := checkOptions(options); err != nil {
                 return nil, err
         }
         url := fmt.Sprintf("/projects/%s/issues/%d/comments", req.Issue.ProjectId, req.Issue.IssueId)
         return &InsertCommentResponse{}, c.call(ctx, url, req.Comment, nil)
 }
 
+func (c *epClient) IssuesList(ctx context.Context, req *IssuesListRequest, options ...grpc.CallOption) (*IssuesListResponse, error) {
+        if err := checkOptions(options); err != nil {
+                return nil, err
+        }
+        url := fmt.Sprintf("/projects/%s/issues?can=open&q=%s", req.ProjectId, req.Q)

[nodir, 2016/06/09 04:09:28]

What about all the other fields? Either don't declare them, or pass them here.
Consider using url.Values type

[nodir, 2016/06/09 04:09:28]

req.Can should be used instead of hardcoded open

[seanmccullough1, 2016/06/09 15:01:32]

Done.

[seanmccullough1, 2016/06/09 15:01:32]

Done.

+        res := &IssuesListResponse{}
+        err := c.get(ctx, url, res)
+        if err != nil {
+                return nil, err
+        }
+        return res, nil
+}
+
 func checkOptions(options []grpc.CallOption) error {
         if len(options) > 0 {
                 return errGrpcOptions
         }
         return nil
 }