// NewHTTPClient returns an HTTP client for use communicating with a Google cloud // service, configured with the given ClientOptions. It also returns the endpoint // for the service as specified in the options. func NewHTTPClient(ctx context.Context, opt ...cloud.ClientOption) (*http.Client, string, error) { o := make([]option.ClientOption, 0, len(opt)) for _, opt := range opt { o = append(o, opt.Resolve()) } return transport.NewHTTPClient(ctx, o...) }
// NewClient creates a new PubSub client. func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) { var o []option.ClientOption // Environment variables for gcloud emulator: // https://option.google.com/sdk/gcloud/reference/beta/emulators/pubsub/ if addr := os.Getenv("PUBSUB_EMULATOR_HOST"); addr != "" { o = []option.ClientOption{ option.WithEndpoint("http://" + addr + "/"), option.WithHTTPClient(http.DefaultClient), } } else { o = []option.ClientOption{ option.WithEndpoint(prodAddr), option.WithScopes(raw.PubsubScope, raw.CloudPlatformScope), option.WithUserAgent(userAgent), } } o = append(o, opts...) httpClient, endpoint, err := transport.NewHTTPClient(ctx, o...) if err != nil { return nil, fmt.Errorf("dialing: %v", err) } s, err := newPubSubService(httpClient, endpoint) if err != nil { return nil, fmt.Errorf("constructing pubsub client: %v", err) } c := &Client{ projectID: projectID, s: s, } return c, nil }
// NewClient creates a new Google Container Engine client. func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) { o := []option.ClientOption{ option.WithEndpoint(prodAddr), option.WithScopes(raw.CloudPlatformScope), option.WithUserAgent(userAgent), } o = append(o, opts...) httpClient, endpoint, err := transport.NewHTTPClient(ctx, o...) if err != nil { return nil, fmt.Errorf("dialing: %v", err) } svc, err := raw.New(httpClient) if err != nil { return nil, fmt.Errorf("constructing container client: %v", err) } svc.BasePath = endpoint c := &Client{ projectID: projectID, svc: svc, } return c, nil }
// NewClient returns a new log client, logging to the named log in the // provided project. // // The exported fields on the returned client may be modified before // the client is used for logging. Once log entries are in flight, // the fields must not be modified. func NewClient(ctx context.Context, projectID, logName string, opts ...option.ClientOption) (*Client, error) { httpClient, endpoint, err := transport.NewHTTPClient(ctx, append([]option.ClientOption{ option.WithEndpoint(prodAddr), option.WithScopes(Scope), option.WithUserAgent(userAgent), }, opts...)...) if err != nil { return nil, err } svc, err := api.New(httpClient) if err != nil { return nil, err } svc.BasePath = endpoint c := &Client{ svc: svc, logs: api.NewProjectsLogsEntriesService(svc), logName: logName, projID: projectID, } for i := range c.writer { level := Level(i) c.writer[level] = levelWriter{level, c} c.logger[level] = log.New(c.writer[level], "", 0) } return c, nil }
// NewClient constructs a new Client that can perform Translate operations. // // You can find or create API key for your project from the Credentials page of // the Developers Console (console.developers.google.com). func NewClient(ctx context.Context, opts ...option.ClientOption) (*Client, error) { o := []option.ClientOption{ option.WithEndpoint(prodAddr), option.WithScopes(Scope), option.WithUserAgent(userAgent), } o = append(o, opts...) httpClient, endpoint, err := transport.NewHTTPClient(ctx, o...) if err != nil { return nil, fmt.Errorf("dialing: %v", err) } rawService, err := raw.New(httpClient) if err != nil { return nil, fmt.Errorf("translate client: %v", err) } rawService.BasePath = endpoint return &Client{raw: rawService}, nil }
// NewClient creates a new Google Cloud Storage client. // The default scope is ScopeFullControl. To use a different scope, like ScopeReadOnly, use option.WithScopes. func NewClient(ctx context.Context, opts ...option.ClientOption) (*Client, error) { o := []option.ClientOption{ option.WithScopes(ScopeFullControl), option.WithUserAgent(userAgent), } opts = append(o, opts...) hc, _, err := transport.NewHTTPClient(ctx, opts...) if err != nil { return nil, fmt.Errorf("dialing: %v", err) } rawService, err := raw.New(hc) if err != nil { return nil, fmt.Errorf("storage client: %v", err) } return &Client{ hc: hc, raw: rawService, }, nil }
// NewClient creates a new Google Stackdriver Trace client. func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) { o := []option.ClientOption{ option.WithScopes(cloudPlatformScope), option.WithUserAgent(userAgent), } o = append(o, opts...) hc, basePath, err := transport.NewHTTPClient(ctx, o...) if err != nil { return nil, fmt.Errorf("creating HTTP client for Google Stackdriver Trace API: %v", err) } apiService, err := api.New(hc) if err != nil { return nil, fmt.Errorf("creating Google Stackdriver Trace API client: %v", err) } if basePath != "" { // An option set a basepath, so override api.New's default. apiService.BasePath = basePath } c := &Client{ service: apiService, projectID: projectID, } bundler := bundler.NewBundler((*api.Trace)(nil), func(bundle interface{}) { traces := bundle.([]*api.Trace) err := c.upload(traces) if err != nil { log.Printf("failed to upload %d traces to the Cloud Trace server.", len(traces)) } }) bundler.DelayThreshold = 2 * time.Second bundler.BundleCountThreshold = 100 // We're not measuring bytes here, we're counting traces and spans as one "byte" each. bundler.BundleByteThreshold = 1000 bundler.BundleByteLimit = 1000 bundler.BufferedByteLimit = 10000 c.bundler = bundler return c, nil }
// NewClient constructs a new Client which can perform BigQuery operations. // Operations performed via the client are billed to the specified GCP project. func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) { o := []option.ClientOption{ option.WithEndpoint(prodAddr), option.WithScopes(Scope), option.WithUserAgent(userAgent), } o = append(o, opts...) httpClient, endpoint, err := transport.NewHTTPClient(ctx, o...) if err != nil { return nil, fmt.Errorf("dialing: %v", err) } s, err := newBigqueryService(httpClient, endpoint) if err != nil { return nil, fmt.Errorf("constructing bigquery client: %v", err) } c := &Client{ service: s, projectID: projectID, } return c, nil }
// NewClient creates a new Google Stackdriver Trace client. func NewClient(ctx context.Context, projectID string, opts ...option.ClientOption) (*Client, error) { o := []option.ClientOption{ option.WithScopes(cloudPlatformScope), option.WithUserAgent(userAgent), } o = append(o, opts...) hc, basePath, err := transport.NewHTTPClient(ctx, o...) if err != nil { return nil, fmt.Errorf("creating HTTP client for Google Stackdriver Trace API: %v", err) } apiService, err := api.New(hc) if err != nil { return nil, fmt.Errorf("creating Google Stackdriver Trace API client: %v", err) } if basePath != "" { // An option set a basepath, so override api.New's default. apiService.BasePath = basePath } return &Client{ service: apiService, projectID: projectID, }, nil }
Verbose bool ServiceAccountFile string // File containing service account credentials. } type serviceInterface interface { Register(req *cd.RegisterDebuggeeRequest) (*cd.RegisterDebuggeeResponse, error) Update(debuggeeID, breakpointID string, req *cd.UpdateActiveBreakpointRequest) (*cd.UpdateActiveBreakpointResponse, error) List(debuggeeID, waitToken string) (*cd.ListActiveBreakpointsResponse, error) } var newService = func(serviceAccountFile string) (serviceInterface, error) { opts := []option.ClientOption{option.WithScopes(cd.CloudDebuggerScope)} if serviceAccountFile != "" { opts = append(opts, option.WithServiceAccountFile(serviceAccountFile)) } httpClient, endpoint, err := transport.NewHTTPClient(context.Background(), opts...) 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