| // Package appengine provides access to the Google App Engine Admin API. |
| // |
| // See https://cloud.google.com/appengine/docs/admin-api/ |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/appengine/v1alpha" |
| // ... |
| // appengineService, err := appengine.New(oauthHttpClient) |
| package appengine // import "google.golang.org/api/appengine/v1alpha" |
| |
| 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 = "appengine:v1alpha" |
| const apiName = "appengine" |
| const apiVersion = "v1alpha" |
| const basePath = "https://appengine.googleapis.com/" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // View and manage your applications deployed on Google App Engine |
| AppengineAdminScope = "https://www.googleapis.com/auth/appengine.admin" |
| |
| // View and manage your data across Google Cloud Platform services |
| CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" |
| |
| // View your data across Google Cloud Platform services |
| CloudPlatformReadOnlyScope = "https://www.googleapis.com/auth/cloud-platform.read-only" |
| ) |
| |
| func New(client *http.Client) (*APIService, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &APIService{client: client, BasePath: basePath} |
| s.Apps = NewAppsService(s) |
| return s, nil |
| } |
| |
| type APIService struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| UserAgent string // optional additional User-Agent fragment |
| |
| Apps *AppsService |
| } |
| |
| func (s *APIService) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| func NewAppsService(s *APIService) *AppsService { |
| rs := &AppsService{s: s} |
| rs.Locations = NewAppsLocationsService(s) |
| rs.Operations = NewAppsOperationsService(s) |
| return rs |
| } |
| |
| type AppsService struct { |
| s *APIService |
| |
| Locations *AppsLocationsService |
| |
| Operations *AppsOperationsService |
| } |
| |
| func NewAppsLocationsService(s *APIService) *AppsLocationsService { |
| rs := &AppsLocationsService{s: s} |
| return rs |
| } |
| |
| type AppsLocationsService struct { |
| s *APIService |
| } |
| |
| func NewAppsOperationsService(s *APIService) *AppsOperationsService { |
| rs := &AppsOperationsService{s: s} |
| return rs |
| } |
| |
| type AppsOperationsService struct { |
| s *APIService |
| } |
| |
| // ListLocationsResponse: The response message for |
| // Locations.ListLocations. |
| type ListLocationsResponse struct { |
| // Locations: A list of locations that matches the specified filter in |
| // the request. |
| Locations []*Location `json:"locations,omitempty"` |
| |
| // NextPageToken: The standard List next-page token. |
| 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. "Locations") 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:"-"` |
| |
| // NullFields is a list of field names (e.g. "Locations") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListLocationsResponse) MarshalJSON() ([]byte, error) { |
| type noMethod ListLocationsResponse |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // 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:"-"` |
| |
| // NullFields is a list of field names (e.g. "NextPageToken") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) { |
| type noMethod ListOperationsResponse |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Location: A resource that represents Google Cloud Platform location. |
| type Location struct { |
| // Labels: Cross-service attributes for the location. For example |
| // {"cloud.googleapis.com/region": "us-east1"} |
| Labels map[string]string `json:"labels,omitempty"` |
| |
| // LocationId: The canonical id for this location. For example: |
| // "us-east1". |
| LocationId string `json:"locationId,omitempty"` |
| |
| // Metadata: Service-specific metadata. For example the available |
| // capacity at the given location. |
| Metadata googleapi.RawMessage `json:"metadata,omitempty"` |
| |
| // Name: Resource name for the location, which may vary between |
| // implementations. For example: |
| // "projects/example-project/locations/us-east1" |
| Name string `json:"name,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Labels") 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:"-"` |
| |
| // NullFields is a list of field names (e.g. "Labels") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Location) MarshalJSON() ([]byte, error) { |
| type noMethod Location |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // LocationMetadata: Metadata for the given |
| // google.cloud.location.Location. |
| type LocationMetadata struct { |
| // FlexibleEnvironmentAvailable: App Engine Flexible Environment is |
| // available in the given location.@OutputOnly |
| FlexibleEnvironmentAvailable bool `json:"flexibleEnvironmentAvailable,omitempty"` |
| |
| // StandardEnvironmentAvailable: App Engine Standard Environment is |
| // available in the given location.@OutputOnly |
| StandardEnvironmentAvailable bool `json:"standardEnvironmentAvailable,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "FlexibleEnvironmentAvailable") 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:"-"` |
| |
| // NullFields is a list of field names (e.g. |
| // "FlexibleEnvironmentAvailable") to include in API requests with the |
| // JSON null value. By default, fields with empty values are omitted |
| // from API requests. However, any field with an empty value appearing |
| // in NullFields will be sent to the server as null. It is an error if a |
| // field in this list has a non-empty value. This may be used to include |
| // null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LocationMetadata) MarshalJSON() ([]byte, error) { |
| type noMethod LocationMetadata |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // 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 or |
| // cancellation. |
| 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 googleapi.RawMessage `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 googleapi.RawMessage `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:"-"` |
| |
| // NullFields is a list of field names (e.g. "Done") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Operation) MarshalJSON() ([]byte, error) { |
| type noMethod Operation |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // OperationMetadata: Metadata for the given |
| // google.longrunning.Operation. |
| type OperationMetadata struct { |
| // EndTime: Timestamp that this operation completed.@OutputOnly |
| EndTime string `json:"endTime,omitempty"` |
| |
| // InsertTime: Timestamp that this operation was created.@OutputOnly |
| InsertTime string `json:"insertTime,omitempty"` |
| |
| // Method: API method that initiated this operation. Example: |
| // google.appengine.v1beta4.Version.CreateVersion.@OutputOnly |
| Method string `json:"method,omitempty"` |
| |
| // OperationType: Type of this operation. Deprecated, use method field |
| // instead. Example: "create_version".@OutputOnly |
| OperationType string `json:"operationType,omitempty"` |
| |
| // Target: Name of the resource that this operation is acting on. |
| // Example: apps/myapp/modules/default.@OutputOnly |
| Target string `json:"target,omitempty"` |
| |
| // User: User who requested this operation.@OutputOnly |
| User string `json:"user,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "EndTime") 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:"-"` |
| |
| // NullFields is a list of field names (e.g. "EndTime") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *OperationMetadata) MarshalJSON() ([]byte, error) { |
| type noMethod OperationMetadata |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // OperationMetadataExperimental: Metadata for the given |
| // google.longrunning.Operation. |
| type OperationMetadataExperimental struct { |
| // EndTime: Time that this operation completed.@OutputOnly |
| EndTime string `json:"endTime,omitempty"` |
| |
| // InsertTime: Time that this operation was created.@OutputOnly |
| InsertTime string `json:"insertTime,omitempty"` |
| |
| // Method: API method that initiated this operation. Example: |
| // google.appengine.experimental.CustomDomains.CreateCustomDomain.@Output |
| // Only |
| Method string `json:"method,omitempty"` |
| |
| // Target: Name of the resource that this operation is acting on. |
| // Example: apps/myapp/customDomains/example.com.@OutputOnly |
| Target string `json:"target,omitempty"` |
| |
| // User: User who requested this operation.@OutputOnly |
| User string `json:"user,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "EndTime") 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:"-"` |
| |
| // NullFields is a list of field names (e.g. "EndTime") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *OperationMetadataExperimental) MarshalJSON() ([]byte, error) { |
| type noMethod OperationMetadataExperimental |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // OperationMetadataV1: Metadata for the given |
| // google.longrunning.Operation. |
| type OperationMetadataV1 struct { |
| // EndTime: Time that this operation completed.@OutputOnly |
| EndTime string `json:"endTime,omitempty"` |
| |
| // EphemeralMessage: Ephemeral message that may change every time the |
| // operation is polled. @OutputOnly |
| EphemeralMessage string `json:"ephemeralMessage,omitempty"` |
| |
| // InsertTime: Time that this operation was created.@OutputOnly |
| InsertTime string `json:"insertTime,omitempty"` |
| |
| // Method: API method that initiated this operation. Example: |
| // google.appengine.v1.Versions.CreateVersion.@OutputOnly |
| Method string `json:"method,omitempty"` |
| |
| // Target: Name of the resource that this operation is acting on. |
| // Example: apps/myapp/services/default.@OutputOnly |
| Target string `json:"target,omitempty"` |
| |
| // User: User who requested this operation.@OutputOnly |
| User string `json:"user,omitempty"` |
| |
| // Warning: Durable messages that persist on every operation poll. |
| // @OutputOnly |
| Warning []string `json:"warning,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "EndTime") 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:"-"` |
| |
| // NullFields is a list of field names (e.g. "EndTime") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *OperationMetadataV1) MarshalJSON() ([]byte, error) { |
| type noMethod OperationMetadataV1 |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // OperationMetadataV1Beta: Metadata for the given |
| // google.longrunning.Operation. |
| type OperationMetadataV1Beta struct { |
| // EndTime: Time that this operation completed.@OutputOnly |
| EndTime string `json:"endTime,omitempty"` |
| |
| // EphemeralMessage: Ephemeral message that may change every time the |
| // operation is polled. @OutputOnly |
| EphemeralMessage string `json:"ephemeralMessage,omitempty"` |
| |
| // InsertTime: Time that this operation was created.@OutputOnly |
| InsertTime string `json:"insertTime,omitempty"` |
| |
| // Method: API method that initiated this operation. Example: |
| // google.appengine.v1beta.Versions.CreateVersion.@OutputOnly |
| Method string `json:"method,omitempty"` |
| |
| // Target: Name of the resource that this operation is acting on. |
| // Example: apps/myapp/services/default.@OutputOnly |
| Target string `json:"target,omitempty"` |
| |
| // User: User who requested this operation.@OutputOnly |
| User string `json:"user,omitempty"` |
| |
| // Warning: Durable messages that persist on every operation poll. |
| // @OutputOnly |
| Warning []string `json:"warning,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "EndTime") 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:"-"` |
| |
| // NullFields is a list of field names (e.g. "EndTime") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *OperationMetadataV1Beta) MarshalJSON() ([]byte, error) { |
| type noMethod OperationMetadataV1Beta |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // OperationMetadataV1Beta5: Metadata for the given |
| // google.longrunning.Operation. |
| type OperationMetadataV1Beta5 struct { |
| // EndTime: Timestamp that this operation completed.@OutputOnly |
| EndTime string `json:"endTime,omitempty"` |
| |
| // InsertTime: Timestamp that this operation was created.@OutputOnly |
| InsertTime string `json:"insertTime,omitempty"` |
| |
| // Method: API method name that initiated this operation. Example: |
| // google.appengine.v1beta5.Version.CreateVersion.@OutputOnly |
| Method string `json:"method,omitempty"` |
| |
| // Target: Name of the resource that this operation is acting on. |
| // Example: apps/myapp/services/default.@OutputOnly |
| Target string `json:"target,omitempty"` |
| |
| // User: User who requested this operation.@OutputOnly |
| User string `json:"user,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "EndTime") 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:"-"` |
| |
| // NullFields is a list of field names (e.g. "EndTime") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *OperationMetadataV1Beta5) MarshalJSON() ([]byte, error) { |
| type noMethod OperationMetadataV1Beta5 |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // 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 needsOverviewThe 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 mappingThe 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 usesThe 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 []googleapi.RawMessage `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:"-"` |
| |
| // NullFields is a list of field names (e.g. "Code") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Status) MarshalJSON() ([]byte, error) { |
| type noMethod Status |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // method id "appengine.apps.locations.get": |
| |
| type AppsLocationsGetCall struct { |
| s *APIService |
| appsId string |
| locationsId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Get information about a location. |
| func (r *AppsLocationsService) Get(appsId string, locationsId string) *AppsLocationsGetCall { |
| c := &AppsLocationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.appsId = appsId |
| c.locationsId = locationsId |
| 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 *AppsLocationsGetCall) Fields(s ...googleapi.Field) *AppsLocationsGetCall { |
| 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 *AppsLocationsGetCall) IfNoneMatch(entityTag string) *AppsLocationsGetCall { |
| 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 *AppsLocationsGetCall) Context(ctx context.Context) *AppsLocationsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *AppsLocationsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *AppsLocationsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/apps/{appsId}/locations/{locationsId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "appsId": c.appsId, |
| "locationsId": c.locationsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "appengine.apps.locations.get" call. |
| // Exactly one of *Location or error will be non-nil. Any non-2xx status |
| // code is an error. Response headers are in either |
| // *Location.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 *AppsLocationsGetCall) Do(opts ...googleapi.CallOption) (*Location, 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 := &Location{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Get information about a location.", |
| // "httpMethod": "GET", |
| // "id": "appengine.apps.locations.get", |
| // "parameterOrder": [ |
| // "appsId", |
| // "locationsId" |
| // ], |
| // "parameters": { |
| // "appsId": { |
| // "description": "Part of `name`. Resource name for the location.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "locationsId": { |
| // "description": "Part of `name`. See documentation of `appsId`.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v1alpha/apps/{appsId}/locations/{locationsId}", |
| // "response": { |
| // "$ref": "Location" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/appengine.admin", |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only" |
| // ] |
| // } |
| |
| } |
| |
| // method id "appengine.apps.locations.list": |
| |
| type AppsLocationsListCall struct { |
| s *APIService |
| appsId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists information about the supported locations for this |
| // service. |
| func (r *AppsLocationsService) List(appsId string) *AppsLocationsListCall { |
| c := &AppsLocationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.appsId = appsId |
| return c |
| } |
| |
| // Filter sets the optional parameter "filter": The standard list |
| // filter. |
| func (c *AppsLocationsListCall) Filter(filter string) *AppsLocationsListCall { |
| c.urlParams_.Set("filter", filter) |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": The standard list |
| // page size. |
| func (c *AppsLocationsListCall) PageSize(pageSize int64) *AppsLocationsListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": The standard list |
| // page token. |
| func (c *AppsLocationsListCall) PageToken(pageToken string) *AppsLocationsListCall { |
| 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 *AppsLocationsListCall) Fields(s ...googleapi.Field) *AppsLocationsListCall { |
| 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 *AppsLocationsListCall) IfNoneMatch(entityTag string) *AppsLocationsListCall { |
| 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 *AppsLocationsListCall) Context(ctx context.Context) *AppsLocationsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *AppsLocationsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *AppsLocationsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/apps/{appsId}/locations") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "appsId": c.appsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "appengine.apps.locations.list" call. |
| // Exactly one of *ListLocationsResponse or error will be non-nil. Any |
| // non-2xx status code is an error. Response headers are in either |
| // *ListLocationsResponse.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 *AppsLocationsListCall) Do(opts ...googleapi.CallOption) (*ListLocationsResponse, 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 := &ListLocationsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists information about the supported locations for this service.", |
| // "httpMethod": "GET", |
| // "id": "appengine.apps.locations.list", |
| // "parameterOrder": [ |
| // "appsId" |
| // ], |
| // "parameters": { |
| // "appsId": { |
| // "description": "Part of `name`. The resource that owns the locations collection, if applicable.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "filter": { |
| // "description": "The standard list filter.", |
| // "location": "query", |
| // "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": "v1alpha/apps/{appsId}/locations", |
| // "response": { |
| // "$ref": "ListLocationsResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/appengine.admin", |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only" |
| // ] |
| // } |
| |
| } |
| |
| // 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 *AppsLocationsListCall) Pages(ctx context.Context, f func(*ListLocationsResponse) 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 "appengine.apps.operations.get": |
| |
| type AppsOperationsGetCall struct { |
| s *APIService |
| appsId string |
| operationsId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // 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 *AppsOperationsService) Get(appsId string, operationsId string) *AppsOperationsGetCall { |
| c := &AppsOperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.appsId = appsId |
| c.operationsId = operationsId |
| 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 *AppsOperationsGetCall) Fields(s ...googleapi.Field) *AppsOperationsGetCall { |
| 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 *AppsOperationsGetCall) IfNoneMatch(entityTag string) *AppsOperationsGetCall { |
| 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 *AppsOperationsGetCall) Context(ctx context.Context) *AppsOperationsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *AppsOperationsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *AppsOperationsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/apps/{appsId}/operations/{operationsId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "appsId": c.appsId, |
| "operationsId": c.operationsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "appengine.apps.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 *AppsOperationsGetCall) 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "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.", |
| // "httpMethod": "GET", |
| // "id": "appengine.apps.operations.get", |
| // "parameterOrder": [ |
| // "appsId", |
| // "operationsId" |
| // ], |
| // "parameters": { |
| // "appsId": { |
| // "description": "Part of `name`. The name of the operation resource.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "operationsId": { |
| // "description": "Part of `name`. See documentation of `appsId`.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "v1alpha/apps/{appsId}/operations/{operationsId}", |
| // "response": { |
| // "$ref": "Operation" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/appengine.admin", |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only" |
| // ] |
| // } |
| |
| } |
| |
| // method id "appengine.apps.operations.list": |
| |
| type AppsOperationsListCall struct { |
| s *APIService |
| appsId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // 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 *AppsOperationsService) List(appsId string) *AppsOperationsListCall { |
| c := &AppsOperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.appsId = appsId |
| return c |
| } |
| |
| // Filter sets the optional parameter "filter": The standard list |
| // filter. |
| func (c *AppsOperationsListCall) Filter(filter string) *AppsOperationsListCall { |
| c.urlParams_.Set("filter", filter) |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": The standard list |
| // page size. |
| func (c *AppsOperationsListCall) PageSize(pageSize int64) *AppsOperationsListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": The standard list |
| // page token. |
| func (c *AppsOperationsListCall) PageToken(pageToken string) *AppsOperationsListCall { |
| 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 *AppsOperationsListCall) Fields(s ...googleapi.Field) *AppsOperationsListCall { |
| 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 *AppsOperationsListCall) IfNoneMatch(entityTag string) *AppsOperationsListCall { |
| 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 *AppsOperationsListCall) Context(ctx context.Context) *AppsOperationsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns an http.Header that can be modified by the caller to |
| // add HTTP headers to the request. |
| func (c *AppsOperationsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *AppsOperationsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha/apps/{appsId}/operations") |
| urls += "?" + c.urlParams_.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "appsId": c.appsId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "appengine.apps.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 *AppsOperationsListCall) 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, |
| }, |
| } |
| target := &ret |
| if err := json.NewDecoder(res.Body).Decode(target); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "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.", |
| // "httpMethod": "GET", |
| // "id": "appengine.apps.operations.list", |
| // "parameterOrder": [ |
| // "appsId" |
| // ], |
| // "parameters": { |
| // "appsId": { |
| // "description": "Part of `name`. The name of the operation collection.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "filter": { |
| // "description": "The standard list filter.", |
| // "location": "query", |
| // "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": "v1alpha/apps/{appsId}/operations", |
| // "response": { |
| // "$ref": "ListOperationsResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/appengine.admin", |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/cloud-platform.read-only" |
| // ] |
| // } |
| |
| } |
| |
| // 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 *AppsOperationsListCall) 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) |
| } |
| } |