| // Package cloudbuild provides access to the Google Cloud Container Builder API. |
| // |
| // See https://cloud.google.com/container-builder/docs/ |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/cloudbuild/v1" |
| // ... |
| // cloudbuildService, err := cloudbuild.New(oauthHttpClient) |
| package cloudbuild // import "google.golang.org/api/cloudbuild/v1" |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "errors" |
| "fmt" |
| context "golang.org/x/net/context" |
| ctxhttp "golang.org/x/net/context/ctxhttp" |
| gensupport "google.golang.org/api/gensupport" |
| googleapi "google.golang.org/api/googleapi" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| ) |
| |
| // Always reference these packages, just in case the auto-generated code |
| // below doesn't. |
| var _ = bytes.NewBuffer |
| var _ = strconv.Itoa |
| var _ = fmt.Sprintf |
| var _ = json.NewDecoder |
| var _ = io.Copy |
| var _ = url.Parse |
| var _ = gensupport.MarshalJSON |
| var _ = googleapi.Version |
| var _ = errors.New |
| var _ = strings.Replace |
| var _ = context.Canceled |
| var _ = ctxhttp.Do |
| |
| const apiId = "cloudbuild:v1" |
| const apiName = "cloudbuild" |
| const apiVersion = "v1" |
| const basePath = "https://cloudbuild.googleapis.com/" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // View and manage your data across Google Cloud Platform services |
| CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" |
| ) |
| |
| func New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| s.Operations = NewOperationsService(s) |
| s.Projects = NewProjectsService(s) |
| return s, nil |
| } |
| |
| type Service struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| UserAgent string // optional additional User-Agent fragment |
| |
| Operations *OperationsService |
| |
| Projects *ProjectsService |
| } |
| |
| func (s *Service) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| func NewOperationsService(s *Service) *OperationsService { |
| rs := &OperationsService{s: s} |
| return rs |
| } |
| |
| type OperationsService struct { |
| s *Service |
| } |
| |
| func NewProjectsService(s *Service) *ProjectsService { |
| rs := &ProjectsService{s: s} |
| rs.Builds = NewProjectsBuildsService(s) |
| return rs |
| } |
| |
| type ProjectsService struct { |
| s *Service |
| |
| Builds *ProjectsBuildsService |
| } |
| |
| func NewProjectsBuildsService(s *Service) *ProjectsBuildsService { |
| rs := &ProjectsBuildsService{s: s} |
| return rs |
| } |
| |
| type ProjectsBuildsService struct { |
| s *Service |
| } |
| |
| // Build: A build resource in the Container Builder API. |
| // |
| // At a high level, a Build describes where to find source code, how to |
| // build |
| // it (for example, the builder image to run on the source), and what |
| // tag to |
| // apply to the built image when it is pushed to Google Container |
| // Registry. |
| type Build struct { |
| // CreateTime: Time at which the build was created. |
| // @OutputOnly |
| CreateTime string `json:"createTime,omitempty"` |
| |
| // FinishTime: Time at whihc execution of the build was |
| // finished. |
| // @OutputOnly |
| FinishTime string `json:"finishTime,omitempty"` |
| |
| // Id: Unique identifier of the build. |
| // @OutputOnly |
| Id string `json:"id,omitempty"` |
| |
| // Images: List of images expected to be built and pushed to Google |
| // Container |
| // Registry. If an image is listed here and the image is not produced |
| // by |
| // one of the build steps, the build will fail. Any images present |
| // when |
| // the build steps are complete will be pushed to Container Registry. |
| Images []string `json:"images,omitempty"` |
| |
| // LogsBucket: Google Cloud Storage bucket where logs should be written |
| // (see |
| // [Bucket |
| // Name |
| // Requirements](https://cloud.google.com/storage/docs/bucket-naming |
| // #requirements)). |
| // Logs file names will be of the format |
| // `${logs_bucket}/log-${build_id}.txt`. |
| LogsBucket string `json:"logsBucket,omitempty"` |
| |
| // ProjectId: ID of the project. |
| // @OutputOnly. |
| ProjectId string `json:"projectId,omitempty"` |
| |
| // Results: Results of the build. |
| // @OutputOnly |
| Results *Results `json:"results,omitempty"` |
| |
| // Source: Describes where to find the source files to build. |
| Source *Source `json:"source,omitempty"` |
| |
| // StartTime: Time at which execution of the build was |
| // started. |
| // @OutputOnly |
| StartTime string `json:"startTime,omitempty"` |
| |
| // Status: Status of the build. |
| // @OutputOnly |
| // |
| // Possible values: |
| // "STATUS_UNKNOWN" - Status of the build is unknown. |
| // "QUEUED" - Build is queued, work has not yet begun. |
| // "WORKING" - Build is being executed. |
| // "SUCCESS" - Build finished successfully. |
| // "FAILURE" - Build failed to complete successfully. |
| // "INTERNAL_ERROR" - Build failed due to an internal cause. |
| // "TIMEOUT" - Build took longer than was allowed. |
| // "CANCELLED" - Build was canceled by a user. |
| Status string `json:"status,omitempty"` |
| |
| // Steps: Describes the operations to be performed on the workspace. |
| Steps []*BuildStep `json:"steps,omitempty"` |
| |
| // Timeout: Amount of time that this build should be allowed to run, to |
| // second |
| // granularity. If this amount of time elapses, work on the build will |
| // cease |
| // and the build status will be TIMEOUT. |
| // |
| // Default time is ten minutes. |
| Timeout string `json:"timeout,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "CreateTime") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *Build) MarshalJSON() ([]byte, error) { |
| type noMethod Build |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // BuildOperationMetadata: Metadata for build operations. |
| type BuildOperationMetadata struct { |
| // Build: The build that the operation is tracking. |
| Build *Build `json:"build,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Build") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *BuildOperationMetadata) MarshalJSON() ([]byte, error) { |
| type noMethod BuildOperationMetadata |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // BuildStep: BuildStep describes a step to perform in the build |
| // pipeline. |
| type BuildStep struct { |
| // Args: Command-line arguments to use when running this step's |
| // container. |
| Args []string `json:"args,omitempty"` |
| |
| // Dir: Working directory (relative to project source root) to use when |
| // running |
| // this operation's container. |
| Dir string `json:"dir,omitempty"` |
| |
| // Env: Additional environment variables to set for this step's |
| // container. |
| Env []string `json:"env,omitempty"` |
| |
| // Name: Name of the container image to use for creating this stage in |
| // the |
| // pipeline, as presented to `docker pull`. |
| Name string `json:"name,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Args") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *BuildStep) MarshalJSON() ([]byte, error) { |
| type noMethod BuildStep |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // BuiltImage: BuiltImage describes an image built by the pipeline. |
| type BuiltImage struct { |
| // Digest: Docker Registry 2.0 digest. |
| Digest string `json:"digest,omitempty"` |
| |
| // Name: Name used to push the container image to Google Container |
| // Registry, as |
| // presented to `docker push`. |
| Name string `json:"name,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Digest") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *BuiltImage) MarshalJSON() ([]byte, error) { |
| type noMethod BuiltImage |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // CancelBuildRequest: Request to cancel an ongoing build. |
| type CancelBuildRequest struct { |
| } |
| |
| // ListBuildsResponse: Response including listed builds. |
| type ListBuildsResponse struct { |
| // Builds: Builds will be sorted by create_time, descending. |
| Builds []*Build `json:"builds,omitempty"` |
| |
| // NextPageToken: Token to receive the next page of results. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Builds") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *ListBuildsResponse) MarshalJSON() ([]byte, error) { |
| type noMethod ListBuildsResponse |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // ListOperationsResponse: The response message for |
| // Operations.ListOperations. |
| type ListOperationsResponse struct { |
| // NextPageToken: The standard List next-page token. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // Operations: A list of operations that matches the specified filter in |
| // the request. |
| Operations []*Operation `json:"operations,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) { |
| type noMethod ListOperationsResponse |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // Operation: This resource represents a long-running operation that is |
| // the result of a |
| // network API call. |
| type Operation struct { |
| // Done: If the value is `false`, it means the operation is still in |
| // progress. |
| // If true, the operation is completed, and either `error` or `response` |
| // is |
| // available. |
| Done bool `json:"done,omitempty"` |
| |
| // Error: The error result of the operation in case of failure. |
| Error *Status `json:"error,omitempty"` |
| |
| // Metadata: Service-specific metadata associated with the operation. |
| // It typically |
| // contains progress information and common metadata such as create |
| // time. |
| // Some services might not provide such metadata. Any method that |
| // returns a |
| // long-running operation should document the metadata type, if any. |
| Metadata OperationMetadata `json:"metadata,omitempty"` |
| |
| // Name: The server-assigned name, which is only unique within the same |
| // service that |
| // originally returns it. If you use the default HTTP mapping, |
| // the |
| // `name` should have the format of `operations/some/unique/name`. |
| Name string `json:"name,omitempty"` |
| |
| // Response: The normal response of the operation in case of success. |
| // If the original |
| // method returns no data on success, such as `Delete`, the response |
| // is |
| // `google.protobuf.Empty`. If the original method is |
| // standard |
| // `Get`/`Create`/`Update`, the response should be the resource. For |
| // other |
| // methods, the response should have the type `XxxResponse`, where |
| // `Xxx` |
| // is the original method name. For example, if the original method |
| // name |
| // is `TakeSnapshot()`, the inferred response type |
| // is |
| // `TakeSnapshotResponse`. |
| Response OperationResponse `json:"response,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Done") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *Operation) MarshalJSON() ([]byte, error) { |
| type noMethod Operation |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| type OperationMetadata interface{} |
| |
| type OperationResponse interface{} |
| |
| // Results: Results describes the artifacts created by the build |
| // pipeline. |
| type Results struct { |
| // Images: Images that were built as a part of the build. |
| Images []*BuiltImage `json:"images,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Images") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *Results) MarshalJSON() ([]byte, error) { |
| type noMethod Results |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // Source: Source describes the location of the source in a supported |
| // storage |
| // service. |
| type Source struct { |
| // StorageSource: If provided, get the source from this location in in |
| // Google Cloud Storage. |
| StorageSource *StorageSource `json:"storageSource,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "StorageSource") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *Source) MarshalJSON() ([]byte, error) { |
| type noMethod Source |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // Status: The `Status` type defines a logical error model that is |
| // suitable for different |
| // programming environments, including REST APIs and RPC APIs. It is |
| // used by |
| // [gRPC](https://github.com/grpc). The error model is designed to |
| // be: |
| // |
| // - Simple to use and understand for most users |
| // - Flexible enough to meet unexpected needs |
| // |
| // # Overview |
| // |
| // The `Status` message contains three pieces of data: error code, error |
| // message, |
| // and error details. The error code should be an enum value |
| // of |
| // google.rpc.Code, but it may accept additional error codes if needed. |
| // The |
| // error message should be a developer-facing English message that |
| // helps |
| // developers *understand* and *resolve* the error. If a localized |
| // user-facing |
| // error message is needed, put the localized message in the error |
| // details or |
| // localize it in the client. The optional error details may contain |
| // arbitrary |
| // information about the error. There is a predefined set of error |
| // detail types |
| // in the package `google.rpc` which can be used for common error |
| // conditions. |
| // |
| // # Language mapping |
| // |
| // The `Status` message is the logical representation of the error |
| // model, but it |
| // is not necessarily the actual wire format. When the `Status` message |
| // is |
| // exposed in different client libraries and different wire protocols, |
| // it can be |
| // mapped differently. For example, it will likely be mapped to some |
| // exceptions |
| // in Java, but more likely mapped to some error codes in C. |
| // |
| // # Other uses |
| // |
| // The error model and the `Status` message can be used in a variety |
| // of |
| // environments, either with or without APIs, to provide a |
| // consistent developer experience across different |
| // environments. |
| // |
| // Example uses of this error model include: |
| // |
| // - Partial errors. If a service needs to return partial errors to the |
| // client, |
| // it may embed the `Status` in the normal response to indicate the |
| // partial |
| // errors. |
| // |
| // - Workflow errors. A typical workflow has multiple steps. Each step |
| // may |
| // have a `Status` message for error reporting purpose. |
| // |
| // - Batch operations. If a client uses batch request and batch |
| // response, the |
| // `Status` message should be used directly inside batch response, |
| // one for |
| // each error sub-response. |
| // |
| // - Asynchronous operations. If an API call embeds asynchronous |
| // operation |
| // results in its response, the status of those operations should |
| // be |
| // represented directly using the `Status` message. |
| // |
| // - Logging. If some API errors are stored in logs, the message |
| // `Status` could |
| // be used directly after any stripping needed for security/privacy |
| // reasons. |
| type Status struct { |
| // Code: The status code, which should be an enum value of |
| // google.rpc.Code. |
| Code int64 `json:"code,omitempty"` |
| |
| // Details: A list of messages that carry the error details. There will |
| // be a |
| // common set of message types for APIs to use. |
| Details []StatusDetails `json:"details,omitempty"` |
| |
| // Message: A developer-facing error message, which should be in |
| // English. Any |
| // user-facing error message should be localized and sent in |
| // the |
| // google.rpc.Status.details field, or localized by the client. |
| Message string `json:"message,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Code") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *Status) MarshalJSON() ([]byte, error) { |
| type noMethod Status |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| type StatusDetails interface{} |
| |
| // StorageSource: StorageSource describes the location of the source in |
| // an archive file in |
| // Google Cloud Storage. |
| type StorageSource struct { |
| // Bucket: Google Cloud Storage bucket containing source (see |
| // [Bucket |
| // Name |
| // Requirements](https://cloud.google.com/storage/docs/bucket-naming |
| // #requirements)). |
| Bucket string `json:"bucket,omitempty"` |
| |
| // Generation: Google Cloud Storage generation for the object. If the |
| // generation is |
| // omitted, the latest generation will be used. |
| Generation int64 `json:"generation,omitempty,string"` |
| |
| // Object: Google Cloud Storage object containing source. |
| // |
| // This object must be a gzipped archive file (.tar.gz) containing |
| // source to |
| // build. |
| Object string `json:"object,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Bucket") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| } |
| |
| func (s *StorageSource) MarshalJSON() ([]byte, error) { |
| type noMethod StorageSource |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields) |
| } |
| |
| // method id "cloudbuild.operations.get": |
| |
| type OperationsGetCall struct { |
| s *Service |
| name string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // Get: Gets the latest state of a long-running operation. Clients can |
| // use this |
| // method to poll the operation result at intervals as recommended by |
| // the API |
| // service. |
| func (r *OperationsService) Get(name string) *OperationsGetCall { |
| c := &OperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.name = name |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *OperationsGetCall) Fields(s ...googleapi.Field) *OperationsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *OperationsGetCall) IfNoneMatch(entityTag string) *OperationsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *OperationsGetCall) Context(ctx context.Context) *OperationsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *OperationsGetCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "name": c.name, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "cloudbuild.operations.get" call. |
| // Exactly one of *Operation or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *Operation.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *OperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Operation{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets the latest state of a long-running operation. Clients can use this\nmethod to poll the operation result at intervals as recommended by the API\nservice.", |
| // "flatPath": "v1/operations/{operationsId}", |
| // "httpMethod": "GET", |
| // "id": "cloudbuild.operations.get", |
| // "parameterOrder": [ |
| // "name" |
| // ], |
| // "parameters": { |
| // "name": { |
| // "description": "The name of the operation resource.", |
| // "location": "path", |
| // "pattern": "^operations/.*$", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v1/{+name}", |
| // "response": { |
| // "$ref": "Operation" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform" |
| // ] |
| // } |
| |
| } |
| |
| // method id "cloudbuild.operations.list": |
| |
| type OperationsListCall struct { |
| s *Service |
| name string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // List: Lists operations that match the specified filter in the |
| // request. If the |
| // server doesn't support this method, it returns |
| // `UNIMPLEMENTED`. |
| // |
| // NOTE: the `name` binding below allows API services to override the |
| // binding |
| // to use different resource name schemes, such as `users/*/operations`. |
| func (r *OperationsService) List(name string) *OperationsListCall { |
| c := &OperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.name = name |
| return c |
| } |
| |
| // Filter sets the optional parameter "filter": The standard list |
| // filter. |
| func (c *OperationsListCall) Filter(filter string) *OperationsListCall { |
| c.urlParams_.Set("filter", filter) |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": The standard list |
| // page size. |
| func (c *OperationsListCall) PageSize(pageSize int64) *OperationsListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": The standard list |
| // page token. |
| func (c *OperationsListCall) PageToken(pageToken string) *OperationsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *OperationsListCall) Fields(s ...googleapi.Field) *OperationsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *OperationsListCall) IfNoneMatch(entityTag string) *OperationsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *OperationsListCall) Context(ctx context.Context) *OperationsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *OperationsListCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1/{+name}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "name": c.name, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "cloudbuild.operations.list" call. |
| // Exactly one of *ListOperationsResponse or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *ListOperationsResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *OperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ListOperationsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists operations that match the specified filter in the request. If the\nserver doesn't support this method, it returns `UNIMPLEMENTED`.\n\nNOTE: the `name` binding below allows API services to override the binding\nto use different resource name schemes, such as `users/*/operations`.", |
| // "flatPath": "v1/operations", |
| // "httpMethod": "GET", |
| // "id": "cloudbuild.operations.list", |
| // "parameterOrder": [ |
| // "name" |
| // ], |
| // "parameters": { |
| // "filter": { |
| // "description": "The standard list filter.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "name": { |
| // "description": "The name of the operation collection.", |
| // "location": "path", |
| // "pattern": "^operations$", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "pageSize": { |
| // "description": "The standard list page size.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "The standard list page token.", |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v1/{+name}", |
| // "response": { |
| // "$ref": "ListOperationsResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *OperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| // method id "cloudbuild.projects.builds.cancel": |
| |
| type ProjectsBuildsCancelCall struct { |
| s *Service |
| projectId string |
| id string |
| cancelbuildrequest *CancelBuildRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Cancel: Cancels a requested build in progress. |
| func (r *ProjectsBuildsService) Cancel(projectId string, id string, cancelbuildrequest *CancelBuildRequest) *ProjectsBuildsCancelCall { |
| c := &ProjectsBuildsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectId = projectId |
| c.id = id |
| c.cancelbuildrequest = cancelbuildrequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsBuildsCancelCall) Fields(s ...googleapi.Field) *ProjectsBuildsCancelCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsBuildsCancelCall) Context(ctx context.Context) *ProjectsBuildsCancelCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsBuildsCancelCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.cancelbuildrequest) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1/projects/{projectId}/builds/{id}:cancel") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectId": c.projectId, |
| "id": c.id, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "cloudbuild.projects.builds.cancel" call. |
| // Exactly one of *Build or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Build.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *ProjectsBuildsCancelCall) Do(opts ...googleapi.CallOption) (*Build, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Build{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Cancels a requested build in progress.", |
| // "flatPath": "v1/projects/{projectId}/builds/{id}:cancel", |
| // "httpMethod": "POST", |
| // "id": "cloudbuild.projects.builds.cancel", |
| // "parameterOrder": [ |
| // "projectId", |
| // "id" |
| // ], |
| // "parameters": { |
| // "id": { |
| // "description": "ID of the build.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "projectId": { |
| // "description": "ID of the project.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v1/projects/{projectId}/builds/{id}:cancel", |
| // "request": { |
| // "$ref": "CancelBuildRequest" |
| // }, |
| // "response": { |
| // "$ref": "Build" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform" |
| // ] |
| // } |
| |
| } |
| |
| // method id "cloudbuild.projects.builds.create": |
| |
| type ProjectsBuildsCreateCall struct { |
| s *Service |
| projectId string |
| build *Build |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| } |
| |
| // Create: Starts a build with the specified configuration. |
| // |
| // The long-running Operation returned by this method will include the |
| // ID of |
| // the build, which can be passed to GetBuild to determine its status |
| // (e.g., |
| // success or failure). |
| func (r *ProjectsBuildsService) Create(projectId string, build *Build) *ProjectsBuildsCreateCall { |
| c := &ProjectsBuildsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectId = projectId |
| c.build = build |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsBuildsCreateCall) Fields(s ...googleapi.Field) *ProjectsBuildsCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsBuildsCreateCall) Context(ctx context.Context) *ProjectsBuildsCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsBuildsCreateCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.build) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1/projects/{projectId}/builds") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectId": c.projectId, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "cloudbuild.projects.builds.create" call. |
| // Exactly one of *Operation or error will be non-nil. Any non-2xx |
| // status code is an error. Response headers are in either |
| // *Operation.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified |
| // to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *ProjectsBuildsCreateCall) Do(opts ...googleapi.CallOption) (*Operation, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Operation{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Starts a build with the specified configuration.\n\nThe long-running Operation returned by this method will include the ID of\nthe build, which can be passed to GetBuild to determine its status (e.g.,\nsuccess or failure).", |
| // "flatPath": "v1/projects/{projectId}/builds", |
| // "httpMethod": "POST", |
| // "id": "cloudbuild.projects.builds.create", |
| // "parameterOrder": [ |
| // "projectId" |
| // ], |
| // "parameters": { |
| // "projectId": { |
| // "description": "ID of the project.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v1/projects/{projectId}/builds", |
| // "request": { |
| // "$ref": "Build" |
| // }, |
| // "response": { |
| // "$ref": "Operation" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform" |
| // ] |
| // } |
| |
| } |
| |
| // method id "cloudbuild.projects.builds.get": |
| |
| type ProjectsBuildsGetCall struct { |
| s *Service |
| projectId string |
| id string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // Get: Returns information about a previously requested build. |
| // |
| // The Build that is returned includes its status (e.g., success or |
| // failure, |
| // or in-progress), and timing information. |
| func (r *ProjectsBuildsService) Get(projectId string, id string) *ProjectsBuildsGetCall { |
| c := &ProjectsBuildsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectId = projectId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsBuildsGetCall) Fields(s ...googleapi.Field) *ProjectsBuildsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ProjectsBuildsGetCall) IfNoneMatch(entityTag string) *ProjectsBuildsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsBuildsGetCall) Context(ctx context.Context) *ProjectsBuildsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsBuildsGetCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1/projects/{projectId}/builds/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectId": c.projectId, |
| "id": c.id, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "cloudbuild.projects.builds.get" call. |
| // Exactly one of *Build or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Build.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified |
| // was returned. |
| func (c *ProjectsBuildsGetCall) Do(opts ...googleapi.CallOption) (*Build, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &Build{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Returns information about a previously requested build.\n\nThe Build that is returned includes its status (e.g., success or failure,\nor in-progress), and timing information.", |
| // "flatPath": "v1/projects/{projectId}/builds/{id}", |
| // "httpMethod": "GET", |
| // "id": "cloudbuild.projects.builds.get", |
| // "parameterOrder": [ |
| // "projectId", |
| // "id" |
| // ], |
| // "parameters": { |
| // "id": { |
| // "description": "ID of the build.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "projectId": { |
| // "description": "ID of the project.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v1/projects/{projectId}/builds/{id}", |
| // "response": { |
| // "$ref": "Build" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform" |
| // ] |
| // } |
| |
| } |
| |
| // method id "cloudbuild.projects.builds.list": |
| |
| type ProjectsBuildsListCall struct { |
| s *Service |
| projectId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| } |
| |
| // List: Lists previously requested builds. |
| // |
| // Previously requested builds may still be in-progress, or may have |
| // finished |
| // successfully or unsuccessfully. |
| func (r *ProjectsBuildsService) List(projectId string) *ProjectsBuildsListCall { |
| c := &ProjectsBuildsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.projectId = projectId |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": Number of results to |
| // return in the list. |
| func (c *ProjectsBuildsListCall) PageSize(pageSize int64) *ProjectsBuildsListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Token to provide |
| // to skip to a particular spot in the list. |
| func (c *ProjectsBuildsListCall) PageToken(pageToken string) *ProjectsBuildsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse |
| // for more information. |
| func (c *ProjectsBuildsListCall) Fields(s ...googleapi.Field) *ProjectsBuildsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets the optional parameter which makes the operation |
| // fail if the object's ETag matches the given value. This is useful for |
| // getting updates only after the object has changed since the last |
| // request. Use googleapi.IsNotModified to check whether the response |
| // error from Do is the result of In-None-Match. |
| func (c *ProjectsBuildsListCall) IfNoneMatch(entityTag string) *ProjectsBuildsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ProjectsBuildsListCall) Context(ctx context.Context) *ProjectsBuildsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| func (c *ProjectsBuildsListCall) doRequest(alt string) (*http.Response, error) { |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1/projects/{projectId}/builds") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "projectId": c.projectId, |
| }) |
| req.Header.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| req.Header.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| if c.ctx_ != nil { |
| return ctxhttp.Do(c.ctx_, c.s.client, req) |
| } |
| return c.s.client.Do(req) |
| } |
| |
| // Do executes the "cloudbuild.projects.builds.list" call. |
| // Exactly one of *ListBuildsResponse or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *ListBuildsResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was |
| // because http.StatusNotModified was returned. |
| func (c *ProjectsBuildsListCall) Do(opts ...googleapi.CallOption) (*ListBuildsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, &googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| } |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| ret := &ListBuildsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists previously requested builds.\n\nPreviously requested builds may still be in-progress, or may have finished\nsuccessfully or unsuccessfully.", |
| // "flatPath": "v1/projects/{projectId}/builds", |
| // "httpMethod": "GET", |
| // "id": "cloudbuild.projects.builds.list", |
| // "parameterOrder": [ |
| // "projectId" |
| // ], |
| // "parameters": { |
| // "pageSize": { |
| // "description": "Number of results to return in the list.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "Token to provide to skip to a particular spot in the list.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "projectId": { |
| // "description": "ID of the project.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v1/projects/{projectId}/builds", |
| // "response": { |
| // "$ref": "ListBuildsResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform" |
| // ] |
| // } |
| |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *ProjectsBuildsListCall) Pages(ctx context.Context, f func(*ListBuildsResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |