vendor: Update vendoring for the exec client and server implementations

Signed-off-by: Jacek J. Łakis <jacek.lakis@intel.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

vendor/cloud.google.com/go/cmd/go-cloud-debug-agent/internal/controller/client.go

@@ -0,0 +1,279 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package controller is a library for interacting with the Google Cloud Debugger's Debuglet Controller service.
+package controller
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"log"
+	"sync"
+
+	"golang.org/x/net/context"
+	"golang.org/x/oauth2"
+	cd "google.golang.org/api/clouddebugger/v2"
+	"google.golang.org/api/googleapi"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+)
+
+const (
+	// agentVersionString identifies the agent to the service.
+	agentVersionString = "google.com/go-gcp/v0.2"
+	// initWaitToken is the wait token sent in the first Update request to a server.
+	initWaitToken = "init"
+)
+
+var (
+	// ErrListUnchanged is returned by List if the server time limit is reached
+	// before the list of breakpoints changes.
+	ErrListUnchanged = errors.New("breakpoint list unchanged")
+	// ErrDebuggeeDisabled is returned by List or Update if the server has disabled
+	// this Debuggee.  The caller can retry later.
+	ErrDebuggeeDisabled = errors.New("debuglet disabled by server")
+)
+
+// Controller manages a connection to the Debuglet Controller service.
+type Controller struct {
+	s serviceInterface
+	// waitToken is sent with List requests so the server knows which set of
+	// breakpoints this client has already seen. Each successful List request
+	// returns a new waitToken to send in the next request.
+	waitToken string
+	// verbose determines whether to do some logging
+	verbose bool
+	// options, uniquifier and description are used in register.
+	options     Options
+	uniquifier  string
+	description string
+	// mu protects debuggeeID
+	mu sync.Mutex
+	// debuggeeID is returned from the server on registration, and is passed back
+	// to the server in List and Update requests.
+	debuggeeID string
+}
+
+// Options controls how the Debuglet Controller client identifies itself to the server.
+// See https://cloud.google.com/storage/docs/projects and
+// https://cloud.google.com/tools/cloud-debugger/setting-up-on-compute-engine
+// for further documentation of these parameters.
+type Options struct {
+	ProjectNumber  string              // GCP Project Number.
+	ProjectID      string              // GCP Project ID.
+	AppModule      string              // Module name for the debugged program.
+	AppVersion     string              // Version number for this module.
+	SourceContexts []*cd.SourceContext // Description of source.
+	Verbose        bool
+	TokenSource    oauth2.TokenSource // Source of Credentials used for Stackdriver Debugger.
+}
+
+type serviceInterface interface {
+	Register(ctx context.Context, req *cd.RegisterDebuggeeRequest) (*cd.RegisterDebuggeeResponse, error)
+	Update(ctx context.Context, debuggeeID, breakpointID string, req *cd.UpdateActiveBreakpointRequest) (*cd.UpdateActiveBreakpointResponse, error)
+	List(ctx context.Context, debuggeeID, waitToken string) (*cd.ListActiveBreakpointsResponse, error)
+}
+
+var newService = func(ctx context.Context, tokenSource oauth2.TokenSource) (serviceInterface, error) {
+	httpClient, endpoint, err := transport.NewHTTPClient(ctx, option.WithTokenSource(tokenSource))
+	if err != nil {
+		return nil, err
+	}
+	s, err := cd.New(httpClient)
+	if err != nil {
+		return nil, err
+	}
+	if endpoint != "" {
+		s.BasePath = endpoint
+	}
+	return &service{s: s}, nil
+}
+
+type service struct {
+	s *cd.Service
+}
+
+func (s service) Register(ctx context.Context, req *cd.RegisterDebuggeeRequest) (*cd.RegisterDebuggeeResponse, error) {
+	call := cd.NewControllerDebuggeesService(s.s).Register(req)
+	return call.Context(ctx).Do()
+}
+
+func (s service) Update(ctx context.Context, debuggeeID, breakpointID string, req *cd.UpdateActiveBreakpointRequest) (*cd.UpdateActiveBreakpointResponse, error) {
+	call := cd.NewControllerDebuggeesBreakpointsService(s.s).Update(debuggeeID, breakpointID, req)
+	return call.Context(ctx).Do()
+}
+
+func (s service) List(ctx context.Context, debuggeeID, waitToken string) (*cd.ListActiveBreakpointsResponse, error) {
+	call := cd.NewControllerDebuggeesBreakpointsService(s.s).List(debuggeeID)
+	call.WaitToken(waitToken)
+	return call.Context(ctx).Do()
+}
+
+// NewController connects to the Debuglet Controller server using the given options,
+// and returns a Controller for that connection.
+// Google Application Default Credentials are used to connect to the Debuglet Controller;
+// see https://developers.google.com/identity/protocols/application-default-credentials
+func NewController(ctx context.Context, o Options) (*Controller, error) {
+	// We build a JSON encoding of o.SourceContexts so we can hash it.
+	scJSON, err := json.Marshal(o.SourceContexts)
+	if err != nil {
+		scJSON = nil
+		o.SourceContexts = nil
+	}
+
+	// Compute a uniquifier string by hashing the project number, app module name,
+	// app module version, debuglet version, and source context.
+	// The choice of hash function is arbitrary.
+	h := sha256.Sum256([]byte(fmt.Sprintf("%d %s %d %s %d %s %d %s %d %s",
+		len(o.ProjectNumber), o.ProjectNumber,
+		len(o.AppModule), o.AppModule,
+		len(o.AppVersion), o.AppVersion,
+		len(agentVersionString), agentVersionString,
+		len(scJSON), scJSON)))
+	uniquifier := fmt.Sprintf("%X", h[0:16]) // 32 hex characters
+
+	description := o.ProjectID
+	if o.AppModule != "" {
+		description += "-" + o.AppModule
+	}
+	if o.AppVersion != "" {
+		description += "-" + o.AppVersion
+	}
+
+	s, err := newService(ctx, o.TokenSource)
+	if err != nil {
+		return nil, err
+	}
+
+	// Construct client.
+	c := &Controller{
+		s:           s,
+		waitToken:   initWaitToken,
+		verbose:     o.Verbose,
+		options:     o,
+		uniquifier:  uniquifier,
+		description: description,
+	}
+
+	return c, nil
+}
+
+func (c *Controller) getDebuggeeID(ctx context.Context) (string, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	if c.debuggeeID != "" {
+		return c.debuggeeID, nil
+	}
+	// The debuglet hasn't been registered yet, or it is disabled and we should try registering again.
+	if err := c.register(ctx); err != nil {
+		return "", err
+	}
+	return c.debuggeeID, nil
+}
+
+// List retrieves the current list of breakpoints from the server.
+// If the set of breakpoints on the server is the same as the one returned in
+// the previous call to List, the server can delay responding until it changes,
+// and return an error instead if no change occurs before a time limit the
+// server sets.  List can't be called concurrently with itself.
+func (c *Controller) List(ctx context.Context) (*cd.ListActiveBreakpointsResponse, error) {
+	id, err := c.getDebuggeeID(ctx)
+	if err != nil {
+		return nil, err
+	}
+	resp, err := c.s.List(ctx, id, c.waitToken)
+	if err != nil {
+		if isAbortedError(err) {
+			return nil, ErrListUnchanged
+		}
+		// For other errors, the protocol requires that we attempt to re-register.
+		c.mu.Lock()
+		defer c.mu.Unlock()
+		if regError := c.register(ctx); regError != nil {
+			return nil, regError
+		}
+		return nil, err
+	}
+	if resp == nil {
+		return nil, errors.New("no response")
+	}
+	if c.verbose {
+		log.Printf("List response: %v", resp)
+	}
+	c.waitToken = resp.NextWaitToken
+	return resp, nil
+}
+
+// isAbortedError tests if err is a *googleapi.Error, that it contains one error
+// in Errors, and that that error's Reason is "aborted".
+func isAbortedError(err error) bool {
+	e, _ := err.(*googleapi.Error)
+	if e == nil {
+		return false
+	}
+	if len(e.Errors) != 1 {
+		return false
+	}
+	return e.Errors[0].Reason == "aborted"
+}
+
+// Update reports information to the server about a breakpoint that was hit.
+// Update can be called concurrently with List and Update.
+func (c *Controller) Update(ctx context.Context, breakpointID string, bp *cd.Breakpoint) error {
+	req := &cd.UpdateActiveBreakpointRequest{Breakpoint: bp}
+	if c.verbose {
+		log.Printf("sending update for %s: %v", breakpointID, req)
+	}
+	id, err := c.getDebuggeeID(ctx)
+	if err != nil {
+		return err
+	}
+	_, err = c.s.Update(ctx, id, breakpointID, req)
+	return err
+}
+
+// register calls the Debuglet Controller Register method, and sets c.debuggeeID.
+// c.mu should be locked while calling this function.  List and Update can't
+// make progress until it returns.
+func (c *Controller) register(ctx context.Context) error {
+	req := cd.RegisterDebuggeeRequest{
+		Debuggee: &cd.Debuggee{
+			AgentVersion:   agentVersionString,
+			Description:    c.description,
+			Project:        c.options.ProjectNumber,
+			SourceContexts: c.options.SourceContexts,
+			Uniquifier:     c.uniquifier,
+		},
+	}
+	resp, err := c.s.Register(ctx, &req)
+	if err != nil {
+		return err
+	}
+	if resp == nil {
+		return errors.New("register: no response")
+	}
+	if resp.Debuggee.IsDisabled {
+		// Setting c.debuggeeID to empty makes sure future List and Update calls
+		// will call register first.
+		c.debuggeeID = ""
+	} else {
+		c.debuggeeID = resp.Debuggee.Id
+	}
+	if c.debuggeeID == "" {
+		return ErrDebuggeeDisabled
+	}
+	return nil
+}

vendor/cloud.google.com/go/cmd/go-cloud-debug-agent/internal/controller/client_test.go

@@ -0,0 +1,218 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package controller
+
+import (
+	"testing"
+
+	"golang.org/x/net/context"
+	"golang.org/x/oauth2"
+
+	cd "google.golang.org/api/clouddebugger/v2"
+	"google.golang.org/api/googleapi"
+)
+
+const (
+	testDebuggeeID   = "d12345"
+	testBreakpointID = "bp12345"
+)
+
+var (
+	// The sequence of wait tokens in List requests and responses.
+	expectedWaitToken = []string{"init", "token1", "token2", "token1", "token1"}
+	// The set of breakpoints returned from each List call.
+	expectedBreakpoints = [][]*cd.Breakpoint{
+		nil,
+		{
+			&cd.Breakpoint{
+				Id:           testBreakpointID,
+				IsFinalState: false,
+				Location:     &cd.SourceLocation{Line: 42, Path: "foo.go"},
+			},
+		},
+		nil,
+	}
+	abortedError error = &googleapi.Error{
+		Code:    409,
+		Message: "Conflict",
+		Body: `{
+		 "error": {
+		  "errors": [
+		   {
+		    "domain": "global",
+		    "reason": "aborted",
+		    "message": "Conflict"
+		   }
+		  ],
+		  "code": 409,
+		  "message": "Conflict"
+		 }
+		}`,
+		Errors: []googleapi.ErrorItem{
+			{Reason: "aborted", Message: "Conflict"},
+		},
+	}
+	backendError error = &googleapi.Error{
+		Code:    503,
+		Message: "Backend Error",
+		Body: `{
+		 "error": {
+		  "errors": [
+		   {
+		    "domain": "global",
+		    "reason": "backendError",
+		    "message": "Backend Error"
+		   }
+		  ],
+		  "code": 503,
+		  "message": "Backend Error"
+		 }
+		}`,
+		Errors: []googleapi.ErrorItem{
+			{Reason: "backendError", Message: "Backend Error"},
+		},
+	}
+)
+
+type mockService struct {
+	t                 *testing.T
+	listCallsSeen     int
+	registerCallsSeen int
+}
+
+func (s *mockService) Register(ctx context.Context, req *cd.RegisterDebuggeeRequest) (*cd.RegisterDebuggeeResponse, error) {
+	s.registerCallsSeen++
+	if req.Debuggee == nil {
+		s.t.Errorf("missing debuggee")
+		return nil, nil
+	}
+	if req.Debuggee.AgentVersion == "" {
+		s.t.Errorf("missing agent version")
+	}
+	if req.Debuggee.Description == "" {
+		s.t.Errorf("missing debuglet description")
+	}
+	if req.Debuggee.Project == "" {
+		s.t.Errorf("missing project id")
+	}
+	if req.Debuggee.Uniquifier == "" {
+		s.t.Errorf("missing uniquifier")
+	}
+	return &cd.RegisterDebuggeeResponse{
+		Debuggee: &cd.Debuggee{Id: testDebuggeeID},
+	}, nil
+}
+
+func (s *mockService) Update(ctx context.Context, id, breakpointID string, req *cd.UpdateActiveBreakpointRequest) (*cd.UpdateActiveBreakpointResponse, error) {
+	if id != testDebuggeeID {
+		s.t.Errorf("got debuggee ID %s want %s", id, testDebuggeeID)
+	}
+	if breakpointID != testBreakpointID {
+		s.t.Errorf("got breakpoint ID %s want %s", breakpointID, testBreakpointID)
+	}
+	if !req.Breakpoint.IsFinalState {
+		s.t.Errorf("got IsFinalState = false, want true")
+	}
+	return nil, nil
+}
+
+func (s *mockService) List(ctx context.Context, id, waitToken string) (*cd.ListActiveBreakpointsResponse, error) {
+	if id != testDebuggeeID {
+		s.t.Errorf("got debuggee ID %s want %s", id, testDebuggeeID)
+	}
+	if waitToken != expectedWaitToken[s.listCallsSeen] {
+		s.t.Errorf("got wait token %s want %s", waitToken, expectedWaitToken[s.listCallsSeen])
+	}
+	s.listCallsSeen++
+	if s.listCallsSeen == 4 {
+		return nil, backendError
+	}
+	if s.listCallsSeen == 5 {
+		return nil, abortedError
+	}
+	resp := &cd.ListActiveBreakpointsResponse{
+		Breakpoints:   expectedBreakpoints[s.listCallsSeen-1],
+		NextWaitToken: expectedWaitToken[s.listCallsSeen],
+	}
+	return resp, nil
+}
+
+func TestDebugletControllerClientLibrary(t *testing.T) {
+	var (
+		m    *mockService
+		c    *Controller
+		list *cd.ListActiveBreakpointsResponse
+		err  error
+	)
+	m = &mockService{t: t}
+	newService = func(context.Context, oauth2.TokenSource) (serviceInterface, error) { return m, nil }
+	opts := Options{
+		ProjectNumber: "5",
+		ProjectID:     "p1",
+		AppModule:     "mod1",
+		AppVersion:    "v1",
+	}
+	ctx := context.Background()
+	if c, err = NewController(ctx, opts); err != nil {
+		t.Fatal("Initializing Controller client:", err)
+	}
+	if list, err = c.List(ctx); err != nil {
+		t.Fatal("List:", err)
+	}
+	if m.registerCallsSeen != 1 {
+		t.Errorf("saw %d Register calls, want 1", m.registerCallsSeen)
+	}
+	if list, err = c.List(ctx); err != nil {
+		t.Fatal("List:", err)
+	}
+	if len(list.Breakpoints) != 1 {
+		t.Fatalf("got %d breakpoints, want 1", len(list.Breakpoints))
+	}
+	if err = c.Update(ctx, list.Breakpoints[0].Id, &cd.Breakpoint{Id: testBreakpointID, IsFinalState: true}); err != nil {
+		t.Fatal("Update:", err)
+	}
+	if list, err = c.List(ctx); err != nil {
+		t.Fatal("List:", err)
+	}
+	if m.registerCallsSeen != 1 {
+		t.Errorf("saw %d Register calls, want 1", m.registerCallsSeen)
+	}
+	// The next List call produces an error that should cause a Register call.
+	if list, err = c.List(ctx); err == nil {
+		t.Fatal("List should have returned an error")
+	}
+	if m.registerCallsSeen != 2 {
+		t.Errorf("saw %d Register calls, want 2", m.registerCallsSeen)
+	}
+	// The next List call produces an error that should not cause a Register call.
+	if list, err = c.List(ctx); err == nil {
+		t.Fatal("List should have returned an error")
+	}
+	if m.registerCallsSeen != 2 {
+		t.Errorf("saw %d Register calls, want 2", m.registerCallsSeen)
+	}
+	if m.listCallsSeen != 5 {
+		t.Errorf("saw %d list calls, want 5", m.listCallsSeen)
+	}
+}
+
+func TestIsAbortedError(t *testing.T) {
+	if !isAbortedError(abortedError) {
+		t.Errorf("isAborted(%+v): got false, want true", abortedError)
+	}
+	if isAbortedError(backendError) {
+		t.Errorf("isAborted(%+v): got true, want false", backendError)
+	}
+}