| // Package sqladmin provides access to the Cloud SQL Administration API. |
| // |
| // See https://developers.google.com/cloud-sql/docs/admin-api/ |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/sqladmin/v1beta1" |
| // ... |
| // sqladminService, err := sqladmin.New(oauthHttpClient) |
| package sqladmin |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "golang.org/x/net/context" |
| "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 _ = googleapi.Version |
| var _ = errors.New |
| var _ = strings.Replace |
| var _ = context.Background |
| |
| const apiId = "sqladmin:v1beta1" |
| const apiName = "sqladmin" |
| const apiVersion = "v1beta1" |
| const basePath = "https://www.googleapis.com/sql/v1beta1/" |
| |
| // 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" |
| |
| // Manage your Google SQL Service instances |
| SqlserviceAdminScope = "https://www.googleapis.com/auth/sqlservice.admin" |
| ) |
| |
| func New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| s.BackupRuns = NewBackupRunsService(s) |
| s.Instances = NewInstancesService(s) |
| s.Operations = NewOperationsService(s) |
| s.Tiers = NewTiersService(s) |
| return s, nil |
| } |
| |
| type Service struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| |
| BackupRuns *BackupRunsService |
| |
| Instances *InstancesService |
| |
| Operations *OperationsService |
| |
| Tiers *TiersService |
| } |
| |
| func NewBackupRunsService(s *Service) *BackupRunsService { |
| rs := &BackupRunsService{s: s} |
| return rs |
| } |
| |
| type BackupRunsService struct { |
| s *Service |
| } |
| |
| func NewInstancesService(s *Service) *InstancesService { |
| rs := &InstancesService{s: s} |
| return rs |
| } |
| |
| type InstancesService struct { |
| s *Service |
| } |
| |
| func NewOperationsService(s *Service) *OperationsService { |
| rs := &OperationsService{s: s} |
| return rs |
| } |
| |
| type OperationsService struct { |
| s *Service |
| } |
| |
| func NewTiersService(s *Service) *TiersService { |
| rs := &TiersService{s: s} |
| return rs |
| } |
| |
| type TiersService struct { |
| s *Service |
| } |
| |
| type BackupConfiguration struct { |
| // Enabled: Whether this configuration is enabled. |
| Enabled bool `json:"enabled,omitempty"` |
| |
| // Id: Identifier for this configuration. This gets generated |
| // automatically when a backup configuration is created. |
| Id string `json:"id,omitempty"` |
| |
| // Kind: This is always sql#backupConfiguration. |
| Kind string `json:"kind,omitempty"` |
| |
| // StartTime: Start time for the daily backup configuration in UTC |
| // timezone in the 24 hour format - HH:MM. |
| StartTime string `json:"startTime,omitempty"` |
| } |
| |
| type BackupRun struct { |
| // BackupConfiguration: Backup Configuration identifier. |
| BackupConfiguration string `json:"backupConfiguration,omitempty"` |
| |
| // DueTime: The due time of this run in UTC timezone in RFC 3339 format, |
| // for example 2012-11-15T16:19:00.094Z. |
| DueTime string `json:"dueTime,omitempty"` |
| |
| // EndTime: The time the backup operation completed in UTC timezone in |
| // RFC 3339 format, for example 2012-11-15T16:19:00.094Z. |
| EndTime string `json:"endTime,omitempty"` |
| |
| // EnqueuedTime: The time the run was enqueued in UTC timezone in RFC |
| // 3339 format, for example 2012-11-15T16:19:00.094Z. |
| EnqueuedTime string `json:"enqueuedTime,omitempty"` |
| |
| // Error: Information about why the backup operation failed. This is |
| // only present if the run has the FAILED status. |
| Error *OperationError `json:"error,omitempty"` |
| |
| // Instance: Name of the database instance. |
| Instance string `json:"instance,omitempty"` |
| |
| // Kind: This is always sql#backupRun. |
| Kind string `json:"kind,omitempty"` |
| |
| // StartTime: The time the backup operation actually started in UTC |
| // timezone in RFC 3339 format, for example 2012-11-15T16:19:00.094Z. |
| StartTime string `json:"startTime,omitempty"` |
| |
| // Status: The status of this run. |
| Status string `json:"status,omitempty"` |
| } |
| |
| type BackupRunsListResponse struct { |
| // Items: A list of backup runs in reverse chronological order of the |
| // enqueued time. |
| Items []*BackupRun `json:"items,omitempty"` |
| |
| // Kind: This is always sql#backupRunsList. |
| Kind string `json:"kind,omitempty"` |
| |
| // NextPageToken: The continuation token, used to page through large |
| // result sets. Provide this value in a subsequent request to return the |
| // next page of results. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| } |
| |
| type DatabaseInstance struct { |
| // CurrentDiskSize: The current disk usage of the instance in bytes. |
| CurrentDiskSize int64 `json:"currentDiskSize,omitempty,string"` |
| |
| // DatabaseVersion: The database engine type and version, for example |
| // MYSQL_5_5 for MySQL 5.5. |
| DatabaseVersion string `json:"databaseVersion,omitempty"` |
| |
| // Etag: Etag for this resource - a version number for the settings |
| // object in this resource. This field has no effect when passed as a |
| // request parameter. Instead, the contents of this field should be |
| // passed in an 'If-Match' http header for use in optimistic locking. |
| Etag string `json:"etag,omitempty"` |
| |
| // Instance: Name of the Cloud SQL instance. This does not include the |
| // project ID. |
| Instance string `json:"instance,omitempty"` |
| |
| // Kind: This is always sql#instance. |
| Kind string `json:"kind,omitempty"` |
| |
| // MaxDiskSize: The maximum disk size of the instance in bytes. |
| MaxDiskSize int64 `json:"maxDiskSize,omitempty,string"` |
| |
| // Project: The project ID of the project containing the Cloud SQL |
| // instance. The Google apps domain is prefixed if applicable. |
| Project string `json:"project,omitempty"` |
| |
| // Region: The geographical region. Can be us-central or europe-west1. |
| // Defaults to us-central. The region can not be changed after instance |
| // creation. |
| Region string `json:"region,omitempty"` |
| |
| // Settings: The user settings. |
| Settings *Settings `json:"settings,omitempty"` |
| |
| // State: The current serving state of the Cloud SQL instance. This can |
| // be one of the following. |
| // RUNNABLE: The instance is running, or is |
| // ready to run when accessed. |
| // SUSPENDED: The instance is not available, |
| // for example due to problems with billing. |
| // PENDING_CREATE: The |
| // instance is being created. |
| // MAINTENANCE: The instance is down for |
| // maintenance. |
| // UNKNOWN_STATE: The state of the instance is unknown. |
| State string `json:"state,omitempty"` |
| } |
| |
| type ExportContext struct { |
| // Database: Databases (for example, guestbook) from which the export is |
| // made. If unspecified, all databases are exported. |
| Database []string `json:"database,omitempty"` |
| |
| // Kind: This is always sql#exportContext. |
| Kind string `json:"kind,omitempty"` |
| |
| // Table: Tables to export, or that were exported, from the specified |
| // database. If you specify tables, specify one and only one database. |
| Table []string `json:"table,omitempty"` |
| |
| // Uri: The path to the file in Google Cloud Storage where the export |
| // will be stored, or where it was already stored. The URI is in the |
| // form gs://bucketName/fileName. If the file already exists, the |
| // operation fails. If the filename ends with .gz, the contents are |
| // compressed. |
| Uri string `json:"uri,omitempty"` |
| } |
| |
| type ImportContext struct { |
| // Database: The database (for example, guestbook) to which the import |
| // is made. If not set, it is assumed that the database is specified in |
| // the file to be imported. |
| Database string `json:"database,omitempty"` |
| |
| // Kind: This is always sql#importContext. |
| Kind string `json:"kind,omitempty"` |
| |
| // Uri: A path to the MySQL dump file in Google Cloud Storage from which |
| // the import is made. The URI is in the form gs://bucketName/fileName. |
| // Compressed gzip files (.gz) are also supported. |
| Uri []string `json:"uri,omitempty"` |
| } |
| |
| type InstanceOperation struct { |
| // EndTime: The time this operation finished in UTC timezone in RFC 3339 |
| // format, for example 2012-11-15T16:19:00.094Z. |
| EndTime string `json:"endTime,omitempty"` |
| |
| // EnqueuedTime: The time this operation was enqueued in UTC timezone in |
| // RFC 3339 format, for example 2012-11-15T16:19:00.094Z. |
| EnqueuedTime string `json:"enqueuedTime,omitempty"` |
| |
| // Error: The error(s) encountered by this operation. Only set if the |
| // operation results in an error. |
| Error []*OperationError `json:"error,omitempty"` |
| |
| // ExportContext: The context for export operation, if applicable. |
| ExportContext *ExportContext `json:"exportContext,omitempty"` |
| |
| // ImportContext: The context for import operation, if applicable. |
| ImportContext *ImportContext `json:"importContext,omitempty"` |
| |
| // Instance: Name of the database instance. |
| Instance string `json:"instance,omitempty"` |
| |
| // Kind: This is always sql#instanceOperation. |
| Kind string `json:"kind,omitempty"` |
| |
| // Operation: An identifier that uniquely identifies the operation. You |
| // can use this identifier to retrieve the Operations resource that has |
| // information about the operation. |
| Operation string `json:"operation,omitempty"` |
| |
| // OperationType: The type of the operation. Valid values are CREATE, |
| // DELETE, UPDATE, RESTART, IMPORT, EXPORT, BACKUP_VOLUME, |
| // RESTORE_VOLUME. |
| OperationType string `json:"operationType,omitempty"` |
| |
| // StartTime: The time this operation actually started in UTC timezone |
| // in RFC 3339 format, for example 2012-11-15T16:19:00.094Z. |
| StartTime string `json:"startTime,omitempty"` |
| |
| // State: The state of an operation. Valid values are PENDING, RUNNING, |
| // DONE, UNKNOWN. |
| State string `json:"state,omitempty"` |
| |
| // UserEmailAddress: The email address of the user who initiated this |
| // operation. |
| UserEmailAddress string `json:"userEmailAddress,omitempty"` |
| } |
| |
| type InstancesDeleteResponse struct { |
| // Kind: This is always sql#instancesDelete. |
| Kind string `json:"kind,omitempty"` |
| |
| // Operation: An identifier that uniquely identifies the operation. You |
| // can use this identifier to retrieve the Operations resource that has |
| // information about the operation. |
| Operation string `json:"operation,omitempty"` |
| } |
| |
| type InstancesExportRequest struct { |
| // ExportContext: Contains details about the export operation. |
| ExportContext *ExportContext `json:"exportContext,omitempty"` |
| } |
| |
| type InstancesExportResponse struct { |
| // Kind: This is always sql#instancesExport. |
| Kind string `json:"kind,omitempty"` |
| |
| // Operation: An identifier that uniquely identifies the operation. You |
| // can use this identifier to retrieve the Operations resource that has |
| // information about the operation. |
| Operation string `json:"operation,omitempty"` |
| } |
| |
| type InstancesImportRequest struct { |
| // ImportContext: Contains details about the import operation. |
| ImportContext *ImportContext `json:"importContext,omitempty"` |
| } |
| |
| type InstancesImportResponse struct { |
| // Kind: This is always sql#instancesImport. |
| Kind string `json:"kind,omitempty"` |
| |
| // Operation: An identifier that uniquely identifies the operation. You |
| // can use this identifier to retrieve the Operations resource that has |
| // information about the operation. |
| Operation string `json:"operation,omitempty"` |
| } |
| |
| type InstancesInsertResponse struct { |
| // Kind: This is always sql#instancesInsert. |
| Kind string `json:"kind,omitempty"` |
| |
| // Operation: An identifier that uniquely identifies the operation. You |
| // can use this identifier to retrieve the Operations resource that has |
| // information about the operation. |
| Operation string `json:"operation,omitempty"` |
| } |
| |
| type InstancesListResponse struct { |
| // Items: List of database instance resources. |
| Items []*DatabaseInstance `json:"items,omitempty"` |
| |
| // Kind: This is always sql#instancesList. |
| Kind string `json:"kind,omitempty"` |
| |
| // NextPageToken: The continuation token, used to page through large |
| // result sets. Provide this value in a subsequent request to return the |
| // next page of results. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| } |
| |
| type InstancesRestartResponse struct { |
| // Kind: This is always sql#instancesRestart. |
| Kind string `json:"kind,omitempty"` |
| |
| // Operation: An identifier that uniquely identifies the operation. You |
| // can use this identifier to retrieve the Operations resource that has |
| // information about the operation. |
| Operation string `json:"operation,omitempty"` |
| } |
| |
| type InstancesRestoreBackupResponse struct { |
| // Kind: This is always sql#instancesRestoreBackup. |
| Kind string `json:"kind,omitempty"` |
| |
| // Operation: An identifier that uniquely identifies the operation. You |
| // can use this identifier to retrieve the Operations resource that has |
| // information about the operation. |
| Operation string `json:"operation,omitempty"` |
| } |
| |
| type InstancesUpdateResponse struct { |
| // Kind: This is always sql#instancesUpdate. |
| Kind string `json:"kind,omitempty"` |
| |
| // Operation: An identifier that uniquely identifies the operation. You |
| // can use this identifier to retrieve information about the operation. |
| Operation string `json:"operation,omitempty"` |
| } |
| |
| type OperationError struct { |
| // Code: Identifies the specific error that occurred. |
| Code string `json:"code,omitempty"` |
| |
| // Kind: This is always sql#operationError. |
| Kind string `json:"kind,omitempty"` |
| } |
| |
| type OperationsListResponse struct { |
| // Items: List of operation resources. |
| Items []*InstanceOperation `json:"items,omitempty"` |
| |
| // Kind: This is always sql#operationsList. |
| Kind string `json:"kind,omitempty"` |
| |
| // NextPageToken: The continuation token, used to page through large |
| // result sets. Provide this value in a subsequent request to return the |
| // next page of results. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| } |
| |
| type Settings struct { |
| // ActivationPolicy: The activation policy for this instance. This |
| // specifies when the instance should be activated and is applicable |
| // only when the instance state is RUNNABLE. This can be one of the |
| // following. |
| // ALWAYS: The instance should always be active. |
| // NEVER: The |
| // instance should never be activated. |
| // ON_DEMAND: The instance is |
| // activated upon receiving requests. |
| ActivationPolicy string `json:"activationPolicy,omitempty"` |
| |
| // AuthorizedGaeApplications: The AppEngine app ids that can access this |
| // instance. |
| AuthorizedGaeApplications []string `json:"authorizedGaeApplications,omitempty"` |
| |
| // BackupConfiguration: The daily backup configuration for the instance. |
| BackupConfiguration []*BackupConfiguration `json:"backupConfiguration,omitempty"` |
| |
| // Kind: This is always sql#settings. |
| Kind string `json:"kind,omitempty"` |
| |
| // PricingPlan: The pricing plan for this instance. This can be either |
| // PER_USE or PACKAGE. |
| PricingPlan string `json:"pricingPlan,omitempty"` |
| |
| // ReplicationType: The type of replication this instance uses. This can |
| // be either ASYNCHRONOUS or SYNCHRONOUS. |
| ReplicationType string `json:"replicationType,omitempty"` |
| |
| // Tier: The tier of service for this instance, for example D1, D2. For |
| // more information, see pricing. |
| Tier string `json:"tier,omitempty"` |
| } |
| |
| type Tier struct { |
| // DiskQuota: The maximum disk size of this tier in bytes. |
| DiskQuota int64 `json:"DiskQuota,omitempty,string"` |
| |
| // RAM: The maximum RAM usage of this tier in bytes. |
| RAM int64 `json:"RAM,omitempty,string"` |
| |
| // Kind: This is always sql#tier. |
| Kind string `json:"kind,omitempty"` |
| |
| // Region: The applicable regions for this tier. Can be us-east1 and |
| // europe-west1. |
| Region []string `json:"region,omitempty"` |
| |
| // Tier: An identifier for the service tier, for example D1, D2 etc. For |
| // related information, see Pricing. |
| Tier string `json:"tier,omitempty"` |
| } |
| |
| type TiersListResponse struct { |
| // Items: List of tiers. |
| Items []*Tier `json:"items,omitempty"` |
| |
| // Kind: This is always sql#tiersList. |
| Kind string `json:"kind,omitempty"` |
| } |
| |
| // method id "sql.backupRuns.get": |
| |
| type BackupRunsGetCall struct { |
| s *Service |
| project string |
| instance string |
| backupConfiguration string |
| dueTime string |
| opt_ map[string]interface{} |
| } |
| |
| // Get: Retrieves a resource containing information about a backup run. |
| func (r *BackupRunsService) Get(project string, instance string, backupConfiguration string, dueTime string) *BackupRunsGetCall { |
| c := &BackupRunsGetCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| c.backupConfiguration = backupConfiguration |
| c.dueTime = dueTime |
| 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 *BackupRunsGetCall) Fields(s ...googleapi.Field) *BackupRunsGetCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *BackupRunsGetCall) Do() (*BackupRun, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| params.Set("dueTime", fmt.Sprintf("%v", c.dueTime)) |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}/backupRuns/{backupConfiguration}") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| "backupConfiguration": c.backupConfiguration, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *BackupRun |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a resource containing information about a backup run.", |
| // "httpMethod": "GET", |
| // "id": "sql.backupRuns.get", |
| // "parameterOrder": [ |
| // "project", |
| // "instance", |
| // "backupConfiguration", |
| // "dueTime" |
| // ], |
| // "parameters": { |
| // "backupConfiguration": { |
| // "description": "Identifier for the backup configuration. This gets generated automatically when a backup configuration is created.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "dueTime": { |
| // "description": "The start time of the four-hour backup window. The backup can occur any time in the window. The time is in RFC 3339 format, for example 2012-11-15T16:19:00.094Z.", |
| // "location": "query", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}/backupRuns/{backupConfiguration}", |
| // "response": { |
| // "$ref": "BackupRun" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.backupRuns.list": |
| |
| type BackupRunsListCall struct { |
| s *Service |
| project string |
| instance string |
| backupConfiguration string |
| opt_ map[string]interface{} |
| } |
| |
| // List: Lists all backup runs associated with a given instance and |
| // configuration in the reverse chronological order of the enqueued |
| // time. |
| func (r *BackupRunsService) List(project string, instance string, backupConfiguration string) *BackupRunsListCall { |
| c := &BackupRunsListCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| c.backupConfiguration = backupConfiguration |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of backup runs per response. |
| func (c *BackupRunsListCall) MaxResults(maxResults int64) *BackupRunsListCall { |
| c.opt_["maxResults"] = maxResults |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": A |
| // previously-returned page token representing part of the larger set of |
| // results to view. |
| func (c *BackupRunsListCall) PageToken(pageToken string) *BackupRunsListCall { |
| c.opt_["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 *BackupRunsListCall) Fields(s ...googleapi.Field) *BackupRunsListCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *BackupRunsListCall) Do() (*BackupRunsListResponse, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| params.Set("backupConfiguration", fmt.Sprintf("%v", c.backupConfiguration)) |
| if v, ok := c.opt_["maxResults"]; ok { |
| params.Set("maxResults", fmt.Sprintf("%v", v)) |
| } |
| if v, ok := c.opt_["pageToken"]; ok { |
| params.Set("pageToken", fmt.Sprintf("%v", v)) |
| } |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}/backupRuns") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *BackupRunsListResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists all backup runs associated with a given instance and configuration in the reverse chronological order of the enqueued time.", |
| // "httpMethod": "GET", |
| // "id": "sql.backupRuns.list", |
| // "parameterOrder": [ |
| // "project", |
| // "instance", |
| // "backupConfiguration" |
| // ], |
| // "parameters": { |
| // "backupConfiguration": { |
| // "description": "Identifier for the backup configuration. This gets generated automatically when a backup configuration is created.", |
| // "location": "query", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of backup runs per response.", |
| // "format": "int32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "A previously-returned page token representing part of the larger set of results to view.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}/backupRuns", |
| // "response": { |
| // "$ref": "BackupRunsListResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.delete": |
| |
| type InstancesDeleteCall struct { |
| s *Service |
| project string |
| instance string |
| opt_ map[string]interface{} |
| } |
| |
| // Delete: Deletes a Cloud SQL instance. |
| func (r *InstancesService) Delete(project string, instance string) *InstancesDeleteCall { |
| c := &InstancesDeleteCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| 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 *InstancesDeleteCall) Fields(s ...googleapi.Field) *InstancesDeleteCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesDeleteCall) Do() (*InstancesDeleteResponse, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("DELETE", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesDeleteResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Deletes a Cloud SQL instance.", |
| // "httpMethod": "DELETE", |
| // "id": "sql.instances.delete", |
| // "parameterOrder": [ |
| // "project", |
| // "instance" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance to be deleted.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}", |
| // "response": { |
| // "$ref": "InstancesDeleteResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.export": |
| |
| type InstancesExportCall struct { |
| s *Service |
| project string |
| instance string |
| instancesexportrequest *InstancesExportRequest |
| opt_ map[string]interface{} |
| } |
| |
| // Export: Exports data from a Cloud SQL instance to a Google Cloud |
| // Storage bucket as a MySQL dump file. |
| func (r *InstancesService) Export(project string, instance string, instancesexportrequest *InstancesExportRequest) *InstancesExportCall { |
| c := &InstancesExportCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| c.instancesexportrequest = instancesexportrequest |
| 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 *InstancesExportCall) Fields(s ...googleapi.Field) *InstancesExportCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesExportCall) Do() (*InstancesExportResponse, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.instancesexportrequest) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}/export") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesExportResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Exports data from a Cloud SQL instance to a Google Cloud Storage bucket as a MySQL dump file.", |
| // "httpMethod": "POST", |
| // "id": "sql.instances.export", |
| // "parameterOrder": [ |
| // "project", |
| // "instance" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance to be exported.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}/export", |
| // "request": { |
| // "$ref": "InstancesExportRequest" |
| // }, |
| // "response": { |
| // "$ref": "InstancesExportResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.get": |
| |
| type InstancesGetCall struct { |
| s *Service |
| project string |
| instance string |
| opt_ map[string]interface{} |
| } |
| |
| // Get: Retrieves a resource containing information about a Cloud SQL |
| // instance. |
| func (r *InstancesService) Get(project string, instance string) *InstancesGetCall { |
| c := &InstancesGetCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| 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 *InstancesGetCall) Fields(s ...googleapi.Field) *InstancesGetCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesGetCall) Do() (*DatabaseInstance, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *DatabaseInstance |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves a resource containing information about a Cloud SQL instance.", |
| // "httpMethod": "GET", |
| // "id": "sql.instances.get", |
| // "parameterOrder": [ |
| // "project", |
| // "instance" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}", |
| // "response": { |
| // "$ref": "DatabaseInstance" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.import": |
| |
| type InstancesImportCall struct { |
| s *Service |
| project string |
| instance string |
| instancesimportrequest *InstancesImportRequest |
| opt_ map[string]interface{} |
| } |
| |
| // Import: Imports data into a Cloud SQL instance from a MySQL dump file |
| // in Google Cloud Storage. |
| func (r *InstancesService) Import(project string, instance string, instancesimportrequest *InstancesImportRequest) *InstancesImportCall { |
| c := &InstancesImportCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| c.instancesimportrequest = instancesimportrequest |
| 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 *InstancesImportCall) Fields(s ...googleapi.Field) *InstancesImportCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesImportCall) Do() (*InstancesImportResponse, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.instancesimportrequest) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}/import") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesImportResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Imports data into a Cloud SQL instance from a MySQL dump file in Google Cloud Storage.", |
| // "httpMethod": "POST", |
| // "id": "sql.instances.import", |
| // "parameterOrder": [ |
| // "project", |
| // "instance" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}/import", |
| // "request": { |
| // "$ref": "InstancesImportRequest" |
| // }, |
| // "response": { |
| // "$ref": "InstancesImportResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.insert": |
| |
| type InstancesInsertCall struct { |
| s *Service |
| project string |
| databaseinstance *DatabaseInstance |
| opt_ map[string]interface{} |
| } |
| |
| // Insert: Creates a new Cloud SQL instance. |
| func (r *InstancesService) Insert(project string, databaseinstance *DatabaseInstance) *InstancesInsertCall { |
| c := &InstancesInsertCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.databaseinstance = databaseinstance |
| 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 *InstancesInsertCall) Fields(s ...googleapi.Field) *InstancesInsertCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesInsertCall) Do() (*InstancesInsertResponse, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.databaseinstance) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesInsertResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Creates a new Cloud SQL instance.", |
| // "httpMethod": "POST", |
| // "id": "sql.instances.insert", |
| // "parameterOrder": [ |
| // "project" |
| // ], |
| // "parameters": { |
| // "project": { |
| // "description": "Project ID of the project to which the newly created Cloud SQL instances should belong.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances", |
| // "request": { |
| // "$ref": "DatabaseInstance" |
| // }, |
| // "response": { |
| // "$ref": "InstancesInsertResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.list": |
| |
| type InstancesListCall struct { |
| s *Service |
| project string |
| opt_ map[string]interface{} |
| } |
| |
| // List: Lists instances under a given project in the alphabetical order |
| // of the instance name. |
| func (r *InstancesService) List(project string) *InstancesListCall { |
| c := &InstancesListCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": The maximum |
| // number of results to return per response. |
| func (c *InstancesListCall) MaxResults(maxResults int64) *InstancesListCall { |
| c.opt_["maxResults"] = maxResults |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": A |
| // previously-returned page token representing part of the larger set of |
| // results to view. |
| func (c *InstancesListCall) PageToken(pageToken string) *InstancesListCall { |
| c.opt_["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 *InstancesListCall) Fields(s ...googleapi.Field) *InstancesListCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesListCall) Do() (*InstancesListResponse, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["maxResults"]; ok { |
| params.Set("maxResults", fmt.Sprintf("%v", v)) |
| } |
| if v, ok := c.opt_["pageToken"]; ok { |
| params.Set("pageToken", fmt.Sprintf("%v", v)) |
| } |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesListResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists instances under a given project in the alphabetical order of the instance name.", |
| // "httpMethod": "GET", |
| // "id": "sql.instances.list", |
| // "parameterOrder": [ |
| // "project" |
| // ], |
| // "parameters": { |
| // "maxResults": { |
| // "description": "The maximum number of results to return per response.", |
| // "format": "uint32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "A previously-returned page token representing part of the larger set of results to view.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project for which to list Cloud SQL instances.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances", |
| // "response": { |
| // "$ref": "InstancesListResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.patch": |
| |
| type InstancesPatchCall struct { |
| s *Service |
| project string |
| instance string |
| databaseinstance *DatabaseInstance |
| opt_ map[string]interface{} |
| } |
| |
| // Patch: Updates settings of a Cloud SQL instance. Caution: This is not |
| // a partial update, so you must include values for all the settings |
| // that you want to retain. For partial updates, use patch.. This method |
| // supports patch semantics. |
| func (r *InstancesService) Patch(project string, instance string, databaseinstance *DatabaseInstance) *InstancesPatchCall { |
| c := &InstancesPatchCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| c.databaseinstance = databaseinstance |
| 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 *InstancesPatchCall) Fields(s ...googleapi.Field) *InstancesPatchCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesPatchCall) Do() (*InstancesUpdateResponse, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.databaseinstance) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("PATCH", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesUpdateResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates settings of a Cloud SQL instance. Caution: This is not a partial update, so you must include values for all the settings that you want to retain. For partial updates, use patch.. This method supports patch semantics.", |
| // "httpMethod": "PATCH", |
| // "id": "sql.instances.patch", |
| // "parameterOrder": [ |
| // "project", |
| // "instance" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}", |
| // "request": { |
| // "$ref": "DatabaseInstance" |
| // }, |
| // "response": { |
| // "$ref": "InstancesUpdateResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.restart": |
| |
| type InstancesRestartCall struct { |
| s *Service |
| project string |
| instance string |
| opt_ map[string]interface{} |
| } |
| |
| // Restart: Restarts a Cloud SQL instance. |
| func (r *InstancesService) Restart(project string, instance string) *InstancesRestartCall { |
| c := &InstancesRestartCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| 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 *InstancesRestartCall) Fields(s ...googleapi.Field) *InstancesRestartCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesRestartCall) Do() (*InstancesRestartResponse, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}/restart") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesRestartResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Restarts a Cloud SQL instance.", |
| // "httpMethod": "POST", |
| // "id": "sql.instances.restart", |
| // "parameterOrder": [ |
| // "project", |
| // "instance" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance to be restarted.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}/restart", |
| // "response": { |
| // "$ref": "InstancesRestartResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.restoreBackup": |
| |
| type InstancesRestoreBackupCall struct { |
| s *Service |
| project string |
| instance string |
| backupConfigurationid string |
| dueTime string |
| opt_ map[string]interface{} |
| } |
| |
| // RestoreBackup: Restores a backup of a Cloud SQL instance. |
| func (r *InstancesService) RestoreBackup(project string, instance string, backupConfigurationid string, dueTime string) *InstancesRestoreBackupCall { |
| c := &InstancesRestoreBackupCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| c.backupConfigurationid = backupConfigurationid |
| c.dueTime = dueTime |
| 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 *InstancesRestoreBackupCall) Fields(s ...googleapi.Field) *InstancesRestoreBackupCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesRestoreBackupCall) Do() (*InstancesRestoreBackupResponse, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| params.Set("backupConfiguration", fmt.Sprintf("%v", c.backupConfigurationid)) |
| params.Set("dueTime", fmt.Sprintf("%v", c.dueTime)) |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}/restoreBackup") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("POST", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesRestoreBackupResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Restores a backup of a Cloud SQL instance.", |
| // "httpMethod": "POST", |
| // "id": "sql.instances.restoreBackup", |
| // "parameterOrder": [ |
| // "project", |
| // "instance", |
| // "backupConfiguration", |
| // "dueTime" |
| // ], |
| // "parameters": { |
| // "backupConfiguration": { |
| // "description": "The identifier of the backup configuration. This gets generated automatically when a backup configuration is created.", |
| // "location": "query", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "dueTime": { |
| // "description": "The start time of the four-hour backup window. The backup can occur any time in the window. The time is in RFC 3339 format, for example 2012-11-15T16:19:00.094Z.", |
| // "location": "query", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}/restoreBackup", |
| // "response": { |
| // "$ref": "InstancesRestoreBackupResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.instances.update": |
| |
| type InstancesUpdateCall struct { |
| s *Service |
| project string |
| instance string |
| databaseinstance *DatabaseInstance |
| opt_ map[string]interface{} |
| } |
| |
| // Update: Updates settings of a Cloud SQL instance. Caution: This is |
| // not a partial update, so you must include values for all the settings |
| // that you want to retain. For partial updates, use patch. |
| func (r *InstancesService) Update(project string, instance string, databaseinstance *DatabaseInstance) *InstancesUpdateCall { |
| c := &InstancesUpdateCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| c.databaseinstance = databaseinstance |
| 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 *InstancesUpdateCall) Fields(s ...googleapi.Field) *InstancesUpdateCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *InstancesUpdateCall) Do() (*InstancesUpdateResponse, error) { |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.databaseinstance) |
| if err != nil { |
| return nil, err |
| } |
| ctype := "application/json" |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("PUT", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("Content-Type", ctype) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstancesUpdateResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Updates settings of a Cloud SQL instance. Caution: This is not a partial update, so you must include values for all the settings that you want to retain. For partial updates, use patch.", |
| // "etagRequired": true, |
| // "httpMethod": "PUT", |
| // "id": "sql.instances.update", |
| // "parameterOrder": [ |
| // "project", |
| // "instance" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}", |
| // "request": { |
| // "$ref": "DatabaseInstance" |
| // }, |
| // "response": { |
| // "$ref": "InstancesUpdateResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.operations.get": |
| |
| type OperationsGetCall struct { |
| s *Service |
| project string |
| instance string |
| operation string |
| opt_ map[string]interface{} |
| } |
| |
| // Get: Retrieves an instance operation that has been performed on an |
| // instance. |
| func (r *OperationsService) Get(project string, instance string, operation string) *OperationsGetCall { |
| c := &OperationsGetCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| c.operation = operation |
| 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.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *OperationsGetCall) Do() (*InstanceOperation, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}/operations/{operation}") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| "operation": c.operation, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *InstanceOperation |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Retrieves an instance operation that has been performed on an instance.", |
| // "httpMethod": "GET", |
| // "id": "sql.operations.get", |
| // "parameterOrder": [ |
| // "project", |
| // "instance", |
| // "operation" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "operation": { |
| // "description": "Instance operation ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}/operations/{operation}", |
| // "response": { |
| // "$ref": "InstanceOperation" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.operations.list": |
| |
| type OperationsListCall struct { |
| s *Service |
| project string |
| instance string |
| opt_ map[string]interface{} |
| } |
| |
| // List: Lists all instance operations that have been performed on the |
| // given Cloud SQL instance in the reverse chronological order of the |
| // start time. |
| func (r *OperationsService) List(project string, instance string) *OperationsListCall { |
| c := &OperationsListCall{s: r.s, opt_: make(map[string]interface{})} |
| c.project = project |
| c.instance = instance |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number |
| // of operations per response. |
| func (c *OperationsListCall) MaxResults(maxResults int64) *OperationsListCall { |
| c.opt_["maxResults"] = maxResults |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": A |
| // previously-returned page token representing part of the larger set of |
| // results to view. |
| func (c *OperationsListCall) PageToken(pageToken string) *OperationsListCall { |
| c.opt_["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.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *OperationsListCall) Do() (*OperationsListResponse, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["maxResults"]; ok { |
| params.Set("maxResults", fmt.Sprintf("%v", v)) |
| } |
| if v, ok := c.opt_["pageToken"]; ok { |
| params.Set("pageToken", fmt.Sprintf("%v", v)) |
| } |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project}/instances/{instance}/operations") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.Expand(req.URL, map[string]string{ |
| "project": c.project, |
| "instance": c.instance, |
| }) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *OperationsListResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists all instance operations that have been performed on the given Cloud SQL instance in the reverse chronological order of the start time.", |
| // "httpMethod": "GET", |
| // "id": "sql.operations.list", |
| // "parameterOrder": [ |
| // "project", |
| // "instance" |
| // ], |
| // "parameters": { |
| // "instance": { |
| // "description": "Cloud SQL instance ID. This does not include the project ID.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "maxResults": { |
| // "description": "Maximum number of operations per response.", |
| // "format": "uint32", |
| // "location": "query", |
| // "type": "integer" |
| // }, |
| // "pageToken": { |
| // "description": "A previously-returned page token representing part of the larger set of results to view.", |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "project": { |
| // "description": "Project ID of the project that contains the instance.", |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project}/instances/{instance}/operations", |
| // "response": { |
| // "$ref": "OperationsListResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |
| |
| // method id "sql.tiers.list": |
| |
| type TiersListCall struct { |
| s *Service |
| opt_ map[string]interface{} |
| } |
| |
| // List: Lists all available service tiers for Google Cloud SQL, for |
| // example D1, D2. For related information, see Pricing. |
| func (r *TiersService) List() *TiersListCall { |
| c := &TiersListCall{s: r.s, opt_: make(map[string]interface{})} |
| 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 *TiersListCall) Fields(s ...googleapi.Field) *TiersListCall { |
| c.opt_["fields"] = googleapi.CombineFields(s) |
| return c |
| } |
| |
| func (c *TiersListCall) Do() (*TiersListResponse, error) { |
| var body io.Reader = nil |
| params := make(url.Values) |
| params.Set("alt", "json") |
| if v, ok := c.opt_["fields"]; ok { |
| params.Set("fields", fmt.Sprintf("%v", v)) |
| } |
| urls := googleapi.ResolveRelative(c.s.BasePath, "tiers") |
| urls += "?" + params.Encode() |
| req, _ := http.NewRequest("GET", urls, body) |
| googleapi.SetOpaque(req.URL) |
| req.Header.Set("User-Agent", "google-api-go-client/0.5") |
| res, err := c.s.client.Do(req) |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, err |
| } |
| var ret *TiersListResponse |
| if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Lists all available service tiers for Google Cloud SQL, for example D1, D2. For related information, see Pricing.", |
| // "httpMethod": "GET", |
| // "id": "sql.tiers.list", |
| // "path": "tiers", |
| // "response": { |
| // "$ref": "TiersListResponse" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/cloud-platform", |
| // "https://www.googleapis.com/auth/sqlservice.admin" |
| // ] |
| // } |
| |
| } |