go/src/google.golang.org/cloud/logging/apiv2/metrics/client.go

// 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.

// AUTO-GENERATED DOCUMENTATION AND SERVICE

package metrics

import (
	"errors"
	"fmt"
	"runtime"
	"time"

	gax "github.com/googleapis/gax-go"
	google_logging_v2 "github.com/googleapis/proto-client-go/logging/v2"
	"golang.org/x/net/context"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/metadata"
)

const (
	gapicNameVersion = "gapic/0.1.0"
)

var (
	// Done is returned by iterators on successful completion.
	Done = errors.New("iterator done")

	projectPathTemplate = gax.MustCompilePathTemplate("projects/{project}")
	metricPathTemplate  = gax.MustCompilePathTemplate("projects/{project}/metrics/{metric}")
)

func defaultClientSettings() gax.ClientSettings {
	return gax.ClientSettings{
		AppName:    "gax",
		AppVersion: gax.Version,
		Endpoint:   "logging.googleapis.com:443",
		Scopes: []string{
			"https://www.googleapis.com/auth/logging.write",
			"https://www.googleapis.com/auth/logging.admin",
			"https://www.googleapis.com/auth/logging.read",
			"https://www.googleapis.com/auth/cloud-platform.read-only",
			"https://www.googleapis.com/auth/cloud-platform",
		},
		CallOptions: map[string][]gax.CallOption{
			"ListLogMetrics":  append([]gax.CallOption{withIdempotentRetryCodes()}, defaultRetryOptions()...),
			"GetLogMetric":    append([]gax.CallOption{withIdempotentRetryCodes()}, defaultRetryOptions()...),
			"CreateLogMetric": append([]gax.CallOption{withNonIdempotentRetryCodes()}, defaultRetryOptions()...),
			"UpdateLogMetric": append([]gax.CallOption{withNonIdempotentRetryCodes()}, defaultRetryOptions()...),
			"DeleteLogMetric": append([]gax.CallOption{withIdempotentRetryCodes()}, defaultRetryOptions()...),
		},
	}
}

func withIdempotentRetryCodes() gax.CallOption {
	return gax.WithRetryCodes([]codes.Code{
		codes.DeadlineExceeded,
		codes.Unavailable,
	})
}

func withNonIdempotentRetryCodes() gax.CallOption {
	return gax.WithRetryCodes([]codes.Code{})
}

func defaultRetryOptions() []gax.CallOption {
	return []gax.CallOption{
		gax.WithTimeout(45000 * time.Millisecond),
		gax.WithDelayTimeoutSettings(100*time.Millisecond, 1000*time.Millisecond, 1.2),
		gax.WithRPCTimeoutSettings(2000*time.Millisecond, 30000*time.Millisecond, 1.5),
	}
}

// Client is a client for interacting with MetricsServiceV2.
type Client struct {
	// The connection to the service.
	conn *grpc.ClientConn

	// The gRPC API client.
	client google_logging_v2.MetricsServiceV2Client

	// The map from the method name to the default call options for the method of this service.
	callOptions map[string][]gax.CallOption

	// The metadata to be sent with each request.
	metadata map[string][]string
}

// NewClient creates a new API service client.
func NewClient(ctx context.Context, opts ...gax.ClientOption) (*Client, error) {
	s := defaultClientSettings()
	for _, opt := range opts {
		opt.Resolve(&s)
	}
	conn, err := gax.DialGRPC(ctx, s)
	if err != nil {
		return nil, err
	}
	return &Client{
		conn:        conn,
		client:      google_logging_v2.NewMetricsServiceV2Client(conn),
		callOptions: s.CallOptions,
		metadata: map[string][]string{
			"x-goog-api-client": []string{fmt.Sprintf("%s/%s %s gax/%s go/%s", s.AppName, s.AppVersion, gapicNameVersion, gax.Version, runtime.Version())},
		},
	}, nil
}

// Close closes the connection to the API service. The user should invoke this when
// the client is no longer required.
func (c *Client) Close() error {
	return c.conn.Close()
}

// Path templates.

// ProjectPath returns the path for the project resource.
func ProjectPath(project string) string {
	path, err := projectPathTemplate.Render(map[string]string{
		"project": project,
	})
	if err != nil {
		panic(err)
	}
	return path
}

// MetricPath returns the path for the metric resource.
func MetricPath(project string, metric string) string {
	path, err := metricPathTemplate.Render(map[string]string{
		"project": project,
		"metric":  metric,
	})
	if err != nil {
		panic(err)
	}
	return path
}

// AUTO-GENERATED DOCUMENTATION AND METHOD -- see instructions at the top of the file for editing.

// ListLogMetrics lists logs-based metrics.
func (c *Client) ListLogMetrics(ctx context.Context, req *google_logging_v2.ListLogMetricsRequest) *LogMetricIterator {
	ctx = metadata.NewContext(ctx, c.metadata)
	it := &LogMetricIterator{}
	it.apiCall = func() error {
		if it.atLastPage {
			return Done
		}
		var resp *google_logging_v2.ListLogMetricsResponse
		err := gax.Invoke(ctx, func(ctx context.Context) error {
			var err error
			req.PageToken = it.nextPageToken
			req.PageSize = it.pageSize
			resp, err = c.client.ListLogMetrics(ctx, req)
			return err
		}, c.callOptions["ListLogMetrics"]...)
		if err != nil {
			return err
		}
		if resp.NextPageToken == "" {
			it.atLastPage = true
		} else {
			it.nextPageToken = resp.NextPageToken
		}
		it.items = resp.Metrics
		return nil
	}
	return it
}

// AUTO-GENERATED DOCUMENTATION AND METHOD -- see instructions at the top of the file for editing.

// GetLogMetric gets a logs-based metric.
func (c *Client) GetLogMetric(ctx context.Context, req *google_logging_v2.GetLogMetricRequest) (*google_logging_v2.LogMetric, error) {
	ctx = metadata.NewContext(ctx, c.metadata)
	var resp *google_logging_v2.LogMetric
	err := gax.Invoke(ctx, func(ctx context.Context) error {
		var err error
		resp, err = c.client.GetLogMetric(ctx, req)
		return err
	}, c.callOptions["GetLogMetric"]...)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

// AUTO-GENERATED DOCUMENTATION AND METHOD -- see instructions at the top of the file for editing.

// CreateLogMetric creates a logs-based metric.
func (c *Client) CreateLogMetric(ctx context.Context, req *google_logging_v2.CreateLogMetricRequest) (*google_logging_v2.LogMetric, error) {
	ctx = metadata.NewContext(ctx, c.metadata)
	var resp *google_logging_v2.LogMetric
	err := gax.Invoke(ctx, func(ctx context.Context) error {
		var err error
		resp, err = c.client.CreateLogMetric(ctx, req)
		return err
	}, c.callOptions["CreateLogMetric"]...)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

// AUTO-GENERATED DOCUMENTATION AND METHOD -- see instructions at the top of the file for editing.

// UpdateLogMetric creates or updates a logs-based metric.
func (c *Client) UpdateLogMetric(ctx context.Context, req *google_logging_v2.UpdateLogMetricRequest) (*google_logging_v2.LogMetric, error) {
	ctx = metadata.NewContext(ctx, c.metadata)
	var resp *google_logging_v2.LogMetric
	err := gax.Invoke(ctx, func(ctx context.Context) error {
		var err error
		resp, err = c.client.UpdateLogMetric(ctx, req)
		return err
	}, c.callOptions["UpdateLogMetric"]...)
	if err != nil {
		return nil, err
	}
	return resp, nil
}

// AUTO-GENERATED DOCUMENTATION AND METHOD -- see instructions at the top of the file for editing.

// DeleteLogMetric deletes a logs-based metric.
func (c *Client) DeleteLogMetric(ctx context.Context, req *google_logging_v2.DeleteLogMetricRequest) error {
	ctx = metadata.NewContext(ctx, c.metadata)
	err := gax.Invoke(ctx, func(ctx context.Context) error {
		var err error
		_, err = c.client.DeleteLogMetric(ctx, req)
		return err
	}, c.callOptions["DeleteLogMetric"]...)
	return err
}

// Iterators.
//

// LogMetricIterator manages a stream of *google_logging_v2.LogMetric.
type LogMetricIterator struct {
	// The current page data.
	items         []*google_logging_v2.LogMetric
	atLastPage    bool
	currentIndex  int
	pageSize      int32
	nextPageToken string
	apiCall       func() error
}

// NextPage moves to the next page and updates its internal data.
// It returns Done if no more pages exist.
func (it *LogMetricIterator) NextPage() ([]*google_logging_v2.LogMetric, error) {
	err := it.apiCall()
	if err != nil {
		return nil, err
	}
	return it.items, err
}

// Next returns the next element in the stream. It returns Done at
// the end of the stream.
func (it *LogMetricIterator) Next() (*google_logging_v2.LogMetric, error) {
	for it.currentIndex >= len(it.items) {
		_, err := it.NextPage()
		if err != nil {
			return nil, err
		}
		it.currentIndex = 0
	}
	result := it.items[it.currentIndex]
	it.currentIndex++
	return result, nil
}

// SetPageSize sets the maximum size of the next page to be
// retrieved.
func (it *LogMetricIterator) SetPageSize(pageSize int32) {
	it.pageSize = pageSize
}

// SetPageToken sets the next page token to be retrieved. Note, it
// does not retrieve the next page, or modify the cached page. If
// Next is called, there is no guarantee that the result returned
// will be from the next page until NextPage is called.
func (it *LogMetricIterator) SetPageToken(token string) {
	it.nextPageToken = token
}

// NextPageToken returns the next page token.
func (it *LogMetricIterator) NextPageToken() string {
	return it.nextPageToken
}