| // Copyright 2023 The LUCI Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| // Code generated file. DO NOT EDIT. |
| |
| // Package config provides access to the Configuration Service. |
| // |
| // # Creating a client |
| // |
| // Usage example: |
| // |
| // import "go.chromium.org/luci/common/api/luci_config/config/v1" |
| // ... |
| // ctx := context.Background() |
| // configService, err := config.NewService(ctx) |
| // |
| // In this example, Google Application Default Credentials are used for authentication. |
| // |
| // For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. |
| // |
| // # Other authentication options |
| // |
| // To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey: |
| // |
| // configService, err := config.NewService(ctx, option.WithAPIKey("AIza...")) |
| // |
| // To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource: |
| // |
| // config := &oauth2.Config{...} |
| // // ... |
| // token, err := config.Exchange(ctx, ...) |
| // configService, err := config.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token))) |
| // |
| // See https://godoc.org/google.golang.org/api/option/ for details on options. |
| package config // import "go.chromium.org/luci/common/api/luci_config/config/v1" |
| |
| import ( |
| "bytes" |
| "context" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| |
| googleapi "google.golang.org/api/googleapi" |
| gensupport "go.chromium.org/luci/common/api/internal/gensupport" |
| option "google.golang.org/api/option" |
| internaloption "google.golang.org/api/option/internaloption" |
| htransport "google.golang.org/api/transport/http" |
| ) |
| |
| // 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 _ = internaloption.WithDefaultEndpoint |
| var _ = "luci-go" |
| |
| const apiId = "config:v1" |
| const apiName = "config" |
| const apiVersion = "v1" |
| const basePath = "http://localhost:8080/_ah/api/config/v1" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // https://www.googleapis.com/auth/userinfo.email |
| UserinfoEmailScope = "https://www.googleapis.com/auth/userinfo.email" |
| ) |
| |
| // NewService creates a new Service. |
| func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { |
| scopesOption := internaloption.WithDefaultScopes( |
| "https://www.googleapis.com/auth/userinfo.email", |
| ) |
| // NOTE: prepend, so we don't override user-specified scopes. |
| opts = append([]option.ClientOption{scopesOption}, opts...) |
| opts = append(opts, internaloption.WithDefaultEndpoint(basePath)) |
| client, endpoint, err := htransport.NewClient(ctx, opts...) |
| if err != nil { |
| return nil, err |
| } |
| s, err := New(client) |
| if err != nil { |
| return nil, err |
| } |
| if endpoint != "" { |
| s.BasePath = endpoint |
| } |
| return s, nil |
| } |
| |
| // New creates a new Service. It uses the provided http.Client for requests. |
| // |
| // Deprecated: please use NewService instead. |
| // To provide a custom HTTP client, use option.WithHTTPClient. |
| // If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead. |
| func New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| return s, nil |
| } |
| |
| type Service struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| UserAgent string // optional additional User-Agent fragment |
| } |
| |
| func (s *Service) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| type ComponentsConfigEndpointValidationMessage struct { |
| Path string `json:"path,omitempty"` |
| |
| // Possible values: |
| // "CRITICAL" |
| // "DEBUG" |
| // "ERROR" |
| // "INFO" |
| // "WARNING" |
| Severity string `json:"severity,omitempty"` |
| |
| Text string `json:"text,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Path") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Path") 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 *ComponentsConfigEndpointValidationMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod ComponentsConfigEndpointValidationMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // LuciConfigConfigSet: Describes a config set. |
| type LuciConfigConfigSet struct { |
| ConfigSet string `json:"config_set,omitempty"` |
| |
| // Files: Describes a file. |
| Files []*LuciConfigFile `json:"files,omitempty"` |
| |
| LastImportAttempt *LuciConfigConfigSetImportAttempt `json:"last_import_attempt,omitempty"` |
| |
| Location string `json:"location,omitempty"` |
| |
| Revision *LuciConfigRevision `json:"revision,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ConfigSet") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "ConfigSet") 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 *LuciConfigConfigSet) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigConfigSet |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigConfigSetImportAttempt struct { |
| Message string `json:"message,omitempty"` |
| |
| Revision *LuciConfigRevision `json:"revision,omitempty"` |
| |
| Success bool `json:"success,omitempty"` |
| |
| Timestamp int64 `json:"timestamp,omitempty,string"` |
| |
| ValidationMessages []*ComponentsConfigEndpointValidationMessage `json:"validation_messages,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Message") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Message") 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 *LuciConfigConfigSetImportAttempt) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigConfigSetImportAttempt |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // LuciConfigFile: Describes a file. |
| type LuciConfigFile struct { |
| Path string `json:"path,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Path") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Path") 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 *LuciConfigFile) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigFile |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetConfigByHashResponseMessage struct { |
| Content string `json:"content,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Content") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Content") 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 *LuciConfigGetConfigByHashResponseMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetConfigByHashResponseMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetConfigMultiResponseMessage struct { |
| Configs []*LuciConfigGetConfigMultiResponseMessageConfigEntry `json:"configs,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Configs") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Configs") 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 *LuciConfigGetConfigMultiResponseMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetConfigMultiResponseMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetConfigMultiResponseMessageConfigEntry struct { |
| ConfigSet string `json:"config_set,omitempty"` |
| |
| Content string `json:"content,omitempty"` |
| |
| ContentHash string `json:"content_hash,omitempty"` |
| |
| Revision string `json:"revision,omitempty"` |
| |
| Url string `json:"url,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ConfigSet") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "ConfigSet") 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 *LuciConfigGetConfigMultiResponseMessageConfigEntry) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetConfigMultiResponseMessageConfigEntry |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetConfigResponseMessage struct { |
| Content string `json:"content,omitempty"` |
| |
| ContentHash string `json:"content_hash,omitempty"` |
| |
| IsZlibCompressed bool `json:"is_zlib_compressed,omitempty"` |
| |
| Revision string `json:"revision,omitempty"` |
| |
| Url string `json:"url,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Content") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Content") 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 *LuciConfigGetConfigResponseMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetConfigResponseMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetConfigSetsResponseMessage struct { |
| // ConfigSets: Describes a config set. |
| ConfigSets []*LuciConfigConfigSet `json:"config_sets,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "ConfigSets") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "ConfigSets") 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 *LuciConfigGetConfigSetsResponseMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetConfigSetsResponseMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetMappingResponseMessage struct { |
| Mappings []*LuciConfigGetMappingResponseMessageMapping `json:"mappings,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Mappings") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Mappings") 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 *LuciConfigGetMappingResponseMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetMappingResponseMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetMappingResponseMessageMapping struct { |
| ConfigSet string `json:"config_set,omitempty"` |
| |
| Location string `json:"location,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ConfigSet") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "ConfigSet") 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 *LuciConfigGetMappingResponseMessageMapping) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetMappingResponseMessageMapping |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetProjectsResponseMessage struct { |
| Projects []*LuciConfigProject `json:"projects,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Projects") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Projects") 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 *LuciConfigGetProjectsResponseMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetProjectsResponseMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetRefsResponseMessage struct { |
| Refs []*LuciConfigGetRefsResponseMessageRef `json:"refs,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Refs") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Refs") 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 *LuciConfigGetRefsResponseMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetRefsResponseMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigGetRefsResponseMessageRef struct { |
| Name string `json:"name,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Name") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Name") 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 *LuciConfigGetRefsResponseMessageRef) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigGetRefsResponseMessageRef |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigProject struct { |
| Id string `json:"id,omitempty"` |
| |
| Name string `json:"name,omitempty"` |
| |
| // Possible values: |
| // "GITILES" |
| RepoType string `json:"repo_type,omitempty"` |
| |
| RepoUrl string `json:"repo_url,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Id") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Id") 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 *LuciConfigProject) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigProject |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigRevision struct { |
| CommitterEmail string `json:"committer_email,omitempty"` |
| |
| Id string `json:"id,omitempty"` |
| |
| Timestamp int64 `json:"timestamp,omitempty,string"` |
| |
| Url string `json:"url,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CommitterEmail") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "CommitterEmail") 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 *LuciConfigRevision) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigRevision |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigValidateConfigRequestMessage struct { |
| ConfigSet string `json:"config_set,omitempty"` |
| |
| Files []*LuciConfigValidateConfigRequestMessageFile `json:"files,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ConfigSet") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "ConfigSet") 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 *LuciConfigValidateConfigRequestMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigValidateConfigRequestMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigValidateConfigRequestMessageFile struct { |
| Content string `json:"content,omitempty"` |
| |
| Path string `json:"path,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Content") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Content") 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 *LuciConfigValidateConfigRequestMessageFile) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigValidateConfigRequestMessageFile |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| type LuciConfigValidateConfigResponseMessage struct { |
| Messages []*ComponentsConfigEndpointValidationMessage `json:"messages,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "Messages") to |
| // unconditionally include in API requests. By default, fields with |
| // empty or default 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. "Messages") 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 *LuciConfigValidateConfigResponseMessage) MarshalJSON() ([]byte, error) { |
| type NoMethod LuciConfigValidateConfigResponseMessage |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // method id "config.get_config": |
| |
| type GetConfigCall struct { |
| s *Service |
| configSet string |
| path string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetConfig: Gets a config file. |
| // |
| // - configSet: . |
| // - path: . |
| func (s *Service) GetConfig(configSet string, path string) *GetConfigCall { |
| c := &GetConfigCall{s: s, urlParams_: make(gensupport.URLParams)} |
| c.configSet = configSet |
| c.path = path |
| return c |
| } |
| |
| // HashOnly sets the optional parameter "hash_only": |
| func (c *GetConfigCall) HashOnly(hashOnly bool) *GetConfigCall { |
| c.urlParams_.Set("hash_only", fmt.Sprint(hashOnly)) |
| return c |
| } |
| |
| // Revision sets the optional parameter "revision": |
| func (c *GetConfigCall) Revision(revision string) *GetConfigCall { |
| c.urlParams_.Set("revision", revision) |
| return c |
| } |
| |
| // UseZlib sets the optional parameter "use_zlib": |
| func (c *GetConfigCall) UseZlib(useZlib bool) *GetConfigCall { |
| c.urlParams_.Set("use_zlib", fmt.Sprint(useZlib)) |
| 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 *GetConfigCall) Fields(s ...googleapi.Field) *GetConfigCall { |
| 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 *GetConfigCall) IfNoneMatch(entityTag string) *GetConfigCall { |
| 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 *GetConfigCall) Context(ctx context.Context) *GetConfigCall { |
| 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 *GetConfigCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GetConfigCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| 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) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "config_sets/{config_set}/config/{path}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "config_set": c.configSet, |
| "path": c.path, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.get_config" call. |
| // Exactly one of *LuciConfigGetConfigResponseMessage or error will be |
| // non-nil. Any non-2xx status code is an error. Response headers are in |
| // either *LuciConfigGetConfigResponseMessage.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 *GetConfigCall) Do(opts ...googleapi.CallOption) (*LuciConfigGetConfigResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigGetConfigResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets a config file.", |
| // "httpMethod": "GET", |
| // "id": "config.get_config", |
| // "parameterOrder": [ |
| // "config_set", |
| // "path" |
| // ], |
| // "parameters": { |
| // "config_set": { |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "hash_only": { |
| // "location": "query", |
| // "type": "boolean" |
| // }, |
| // "path": { |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // }, |
| // "revision": { |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "use_zlib": { |
| // "location": "query", |
| // "type": "boolean" |
| // } |
| // }, |
| // "path": "config_sets/{config_set}/config/{path}", |
| // "response": { |
| // "$ref": "LuciConfigGetConfigResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.get_config_by_hash": |
| |
| type GetConfigByHashCall struct { |
| s *Service |
| contentHash string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetConfigByHash: Gets a config file by its hash. |
| // |
| // - contentHash: . |
| func (s *Service) GetConfigByHash(contentHash string) *GetConfigByHashCall { |
| c := &GetConfigByHashCall{s: s, urlParams_: make(gensupport.URLParams)} |
| c.contentHash = contentHash |
| 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 *GetConfigByHashCall) Fields(s ...googleapi.Field) *GetConfigByHashCall { |
| 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 *GetConfigByHashCall) IfNoneMatch(entityTag string) *GetConfigByHashCall { |
| 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 *GetConfigByHashCall) Context(ctx context.Context) *GetConfigByHashCall { |
| 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 *GetConfigByHashCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GetConfigByHashCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| 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) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "config/{content_hash}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "content_hash": c.contentHash, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.get_config_by_hash" call. |
| // Exactly one of *LuciConfigGetConfigByHashResponseMessage or error |
| // will be non-nil. Any non-2xx status code is an error. Response |
| // headers are in either |
| // *LuciConfigGetConfigByHashResponseMessage.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 *GetConfigByHashCall) Do(opts ...googleapi.CallOption) (*LuciConfigGetConfigByHashResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigGetConfigByHashResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets a config file by its hash.", |
| // "httpMethod": "GET", |
| // "id": "config.get_config_by_hash", |
| // "parameterOrder": [ |
| // "content_hash" |
| // ], |
| // "parameters": { |
| // "content_hash": { |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "config/{content_hash}", |
| // "response": { |
| // "$ref": "LuciConfigGetConfigByHashResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.get_config_sets": |
| |
| type GetConfigSetsCall struct { |
| s *Service |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetConfigSets: Returns config sets. |
| func (s *Service) GetConfigSets() *GetConfigSetsCall { |
| c := &GetConfigSetsCall{s: s, urlParams_: make(gensupport.URLParams)} |
| return c |
| } |
| |
| // ConfigSet sets the optional parameter "config_set": |
| func (c *GetConfigSetsCall) ConfigSet(configSet string) *GetConfigSetsCall { |
| c.urlParams_.Set("config_set", configSet) |
| return c |
| } |
| |
| // IncludeFiles sets the optional parameter "include_files": |
| func (c *GetConfigSetsCall) IncludeFiles(includeFiles bool) *GetConfigSetsCall { |
| c.urlParams_.Set("include_files", fmt.Sprint(includeFiles)) |
| return c |
| } |
| |
| // IncludeLastImportAttempt sets the optional parameter |
| // "include_last_import_attempt": |
| func (c *GetConfigSetsCall) IncludeLastImportAttempt(includeLastImportAttempt bool) *GetConfigSetsCall { |
| c.urlParams_.Set("include_last_import_attempt", fmt.Sprint(includeLastImportAttempt)) |
| 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 *GetConfigSetsCall) Fields(s ...googleapi.Field) *GetConfigSetsCall { |
| 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 *GetConfigSetsCall) IfNoneMatch(entityTag string) *GetConfigSetsCall { |
| 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 *GetConfigSetsCall) Context(ctx context.Context) *GetConfigSetsCall { |
| 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 *GetConfigSetsCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GetConfigSetsCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| 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) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "config-sets") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.get_config_sets" call. |
| // Exactly one of *LuciConfigGetConfigSetsResponseMessage or error will |
| // be non-nil. Any non-2xx status code is an error. Response headers are |
| // in either |
| // *LuciConfigGetConfigSetsResponseMessage.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 *GetConfigSetsCall) Do(opts ...googleapi.CallOption) (*LuciConfigGetConfigSetsResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigGetConfigSetsResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Returns config sets.", |
| // "httpMethod": "GET", |
| // "id": "config.get_config_sets", |
| // "parameters": { |
| // "config_set": { |
| // "location": "query", |
| // "type": "string" |
| // }, |
| // "include_files": { |
| // "location": "query", |
| // "type": "boolean" |
| // }, |
| // "include_last_import_attempt": { |
| // "location": "query", |
| // "type": "boolean" |
| // } |
| // }, |
| // "path": "config-sets", |
| // "response": { |
| // "$ref": "LuciConfigGetConfigSetsResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.get_mapping": |
| |
| type GetMappingCall struct { |
| s *Service |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetMapping: DEPRECATED. Use get_config_sets. |
| func (s *Service) GetMapping() *GetMappingCall { |
| c := &GetMappingCall{s: s, urlParams_: make(gensupport.URLParams)} |
| return c |
| } |
| |
| // ConfigSet sets the optional parameter "config_set": |
| func (c *GetMappingCall) ConfigSet(configSet string) *GetMappingCall { |
| c.urlParams_.Set("config_set", configSet) |
| 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 *GetMappingCall) Fields(s ...googleapi.Field) *GetMappingCall { |
| 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 *GetMappingCall) IfNoneMatch(entityTag string) *GetMappingCall { |
| 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 *GetMappingCall) Context(ctx context.Context) *GetMappingCall { |
| 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 *GetMappingCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GetMappingCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| 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) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "mapping") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.get_mapping" call. |
| // Exactly one of *LuciConfigGetMappingResponseMessage or error will be |
| // non-nil. Any non-2xx status code is an error. Response headers are in |
| // either *LuciConfigGetMappingResponseMessage.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 *GetMappingCall) Do(opts ...googleapi.CallOption) (*LuciConfigGetMappingResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigGetMappingResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "DEPRECATED. Use get_config_sets.", |
| // "httpMethod": "GET", |
| // "id": "config.get_mapping", |
| // "parameters": { |
| // "config_set": { |
| // "location": "query", |
| // "type": "string" |
| // } |
| // }, |
| // "path": "mapping", |
| // "response": { |
| // "$ref": "LuciConfigGetMappingResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.get_project_configs": |
| |
| type GetProjectConfigsCall struct { |
| s *Service |
| path string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetProjectConfigs: Gets configs in all project config sets. |
| // |
| // - path: . |
| func (s *Service) GetProjectConfigs(path string) *GetProjectConfigsCall { |
| c := &GetProjectConfigsCall{s: s, urlParams_: make(gensupport.URLParams)} |
| c.path = path |
| return c |
| } |
| |
| // HashesOnly sets the optional parameter "hashes_only": |
| func (c *GetProjectConfigsCall) HashesOnly(hashesOnly bool) *GetProjectConfigsCall { |
| c.urlParams_.Set("hashes_only", fmt.Sprint(hashesOnly)) |
| 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 *GetProjectConfigsCall) Fields(s ...googleapi.Field) *GetProjectConfigsCall { |
| 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 *GetProjectConfigsCall) IfNoneMatch(entityTag string) *GetProjectConfigsCall { |
| 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 *GetProjectConfigsCall) Context(ctx context.Context) *GetProjectConfigsCall { |
| 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 *GetProjectConfigsCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GetProjectConfigsCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| 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) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "configs/projects/{path}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "path": c.path, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.get_project_configs" call. |
| // Exactly one of *LuciConfigGetConfigMultiResponseMessage or error will |
| // be non-nil. Any non-2xx status code is an error. Response headers are |
| // in either |
| // *LuciConfigGetConfigMultiResponseMessage.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 *GetProjectConfigsCall) Do(opts ...googleapi.CallOption) (*LuciConfigGetConfigMultiResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigGetConfigMultiResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets configs in all project config sets.", |
| // "httpMethod": "GET", |
| // "id": "config.get_project_configs", |
| // "parameterOrder": [ |
| // "path" |
| // ], |
| // "parameters": { |
| // "hashes_only": { |
| // "location": "query", |
| // "type": "boolean" |
| // }, |
| // "path": { |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "configs/projects/{path}", |
| // "response": { |
| // "$ref": "LuciConfigGetConfigMultiResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.get_projects": |
| |
| type GetProjectsCall struct { |
| s *Service |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetProjects: Gets list of registered projects. The project list is |
| // stored in services/luci-config:projects.cfg. |
| func (s *Service) GetProjects() *GetProjectsCall { |
| c := &GetProjectsCall{s: s, urlParams_: make(gensupport.URLParams)} |
| 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 *GetProjectsCall) Fields(s ...googleapi.Field) *GetProjectsCall { |
| 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 *GetProjectsCall) IfNoneMatch(entityTag string) *GetProjectsCall { |
| 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 *GetProjectsCall) Context(ctx context.Context) *GetProjectsCall { |
| 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 *GetProjectsCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GetProjectsCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| 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) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.get_projects" call. |
| // Exactly one of *LuciConfigGetProjectsResponseMessage or error will be |
| // non-nil. Any non-2xx status code is an error. Response headers are in |
| // either *LuciConfigGetProjectsResponseMessage.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 *GetProjectsCall) Do(opts ...googleapi.CallOption) (*LuciConfigGetProjectsResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigGetProjectsResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets list of registered projects. The project list is stored in services/luci-config:projects.cfg.", |
| // "httpMethod": "GET", |
| // "id": "config.get_projects", |
| // "path": "projects", |
| // "response": { |
| // "$ref": "LuciConfigGetProjectsResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.get_ref_configs": |
| |
| type GetRefConfigsCall struct { |
| s *Service |
| path string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetRefConfigs: Gets configs in all ref config sets. |
| // |
| // - path: . |
| func (s *Service) GetRefConfigs(path string) *GetRefConfigsCall { |
| c := &GetRefConfigsCall{s: s, urlParams_: make(gensupport.URLParams)} |
| c.path = path |
| return c |
| } |
| |
| // HashesOnly sets the optional parameter "hashes_only": |
| func (c *GetRefConfigsCall) HashesOnly(hashesOnly bool) *GetRefConfigsCall { |
| c.urlParams_.Set("hashes_only", fmt.Sprint(hashesOnly)) |
| 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 *GetRefConfigsCall) Fields(s ...googleapi.Field) *GetRefConfigsCall { |
| 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 *GetRefConfigsCall) IfNoneMatch(entityTag string) *GetRefConfigsCall { |
| 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 *GetRefConfigsCall) Context(ctx context.Context) *GetRefConfigsCall { |
| 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 *GetRefConfigsCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GetRefConfigsCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| 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) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "configs/refs/{path}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "path": c.path, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.get_ref_configs" call. |
| // Exactly one of *LuciConfigGetConfigMultiResponseMessage or error will |
| // be non-nil. Any non-2xx status code is an error. Response headers are |
| // in either |
| // *LuciConfigGetConfigMultiResponseMessage.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 *GetRefConfigsCall) Do(opts ...googleapi.CallOption) (*LuciConfigGetConfigMultiResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigGetConfigMultiResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets configs in all ref config sets.", |
| // "httpMethod": "GET", |
| // "id": "config.get_ref_configs", |
| // "parameterOrder": [ |
| // "path" |
| // ], |
| // "parameters": { |
| // "hashes_only": { |
| // "location": "query", |
| // "type": "boolean" |
| // }, |
| // "path": { |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "configs/refs/{path}", |
| // "response": { |
| // "$ref": "LuciConfigGetConfigMultiResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.get_refs": |
| |
| type GetRefsCall struct { |
| s *Service |
| projectId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetRefs: Gets list of refs of a project. |
| // |
| // - projectId: . |
| func (s *Service) GetRefs(projectId string) *GetRefsCall { |
| c := &GetRefsCall{s: s, urlParams_: make(gensupport.URLParams)} |
| c.projectId = projectId |
| 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 *GetRefsCall) Fields(s ...googleapi.Field) *GetRefsCall { |
| 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 *GetRefsCall) IfNoneMatch(entityTag string) *GetRefsCall { |
| 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 *GetRefsCall) Context(ctx context.Context) *GetRefsCall { |
| 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 *GetRefsCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *GetRefsCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| 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) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "projects/{project_id}/refs") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "project_id": c.projectId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.get_refs" call. |
| // Exactly one of *LuciConfigGetRefsResponseMessage or error will be |
| // non-nil. Any non-2xx status code is an error. Response headers are in |
| // either *LuciConfigGetRefsResponseMessage.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 *GetRefsCall) Do(opts ...googleapi.CallOption) (*LuciConfigGetRefsResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigGetRefsResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "description": "Gets list of refs of a project.", |
| // "httpMethod": "GET", |
| // "id": "config.get_refs", |
| // "parameterOrder": [ |
| // "project_id" |
| // ], |
| // "parameters": { |
| // "project_id": { |
| // "location": "path", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "projects/{project_id}/refs", |
| // "response": { |
| // "$ref": "LuciConfigGetRefsResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.reimport": |
| |
| type ReimportCall struct { |
| s *Service |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Reimport: Reimports a config set. |
| // |
| // - configSet: . |
| func (s *Service) Reimport(configSet string) *ReimportCall { |
| c := &ReimportCall{s: s, urlParams_: make(gensupport.URLParams)} |
| c.urlParams_.Set("config_set", configSet) |
| 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 *ReimportCall) Fields(s ...googleapi.Field) *ReimportCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ReimportCall) Context(ctx context.Context) *ReimportCall { |
| 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 *ReimportCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ReimportCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "reimport") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.reimport" call. |
| func (c *ReimportCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| // { |
| // "description": "Reimports a config set.", |
| // "httpMethod": "POST", |
| // "id": "config.reimport", |
| // "parameterOrder": [ |
| // "config_set" |
| // ], |
| // "parameters": { |
| // "config_set": { |
| // "location": "query", |
| // "required": true, |
| // "type": "string" |
| // } |
| // }, |
| // "path": "reimport", |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |
| |
| // method id "config.validate_config": |
| |
| type ValidateConfigCall struct { |
| s *Service |
| luciconfigvalidateconfigrequestmessage *LuciConfigValidateConfigRequestMessage |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // ValidateConfig: |
| func (s *Service) ValidateConfig(luciconfigvalidateconfigrequestmessage *LuciConfigValidateConfigRequestMessage) *ValidateConfigCall { |
| c := &ValidateConfigCall{s: s, urlParams_: make(gensupport.URLParams)} |
| c.luciconfigvalidateconfigrequestmessage = luciconfigvalidateconfigrequestmessage |
| 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 *ValidateConfigCall) Fields(s ...googleapi.Field) *ValidateConfigCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. Any |
| // pending HTTP request will be aborted if the provided context is |
| // canceled. |
| func (c *ValidateConfigCall) Context(ctx context.Context) *ValidateConfigCall { |
| 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 *ValidateConfigCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *ValidateConfigCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := make(http.Header) |
| reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+"luci-go") |
| for k, v := range c.header_ { |
| reqHeaders[k] = v |
| } |
| reqHeaders.Set("User-Agent", c.s.userAgent()) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.luciconfigvalidateconfigrequestmessage) |
| if err != nil { |
| return nil, err |
| } |
| reqHeaders.Set("Content-Type", "application/json") |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "validate-config") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "config.validate_config" call. |
| // Exactly one of *LuciConfigValidateConfigResponseMessage or error will |
| // be non-nil. Any non-2xx status code is an error. Response headers are |
| // in either |
| // *LuciConfigValidateConfigResponseMessage.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 *ValidateConfigCall) Do(opts ...googleapi.CallOption) (*LuciConfigValidateConfigResponseMessage, 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, gensupport.WrapError(&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, gensupport.WrapError(err) |
| } |
| ret := &LuciConfigValidateConfigResponseMessage{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| // { |
| // "httpMethod": "POST", |
| // "id": "config.validate_config", |
| // "path": "validate-config", |
| // "request": { |
| // "$ref": "LuciConfigValidateConfigRequestMessage", |
| // "parameterName": "resource" |
| // }, |
| // "response": { |
| // "$ref": "LuciConfigValidateConfigResponseMessage" |
| // }, |
| // "scopes": [ |
| // "https://www.googleapis.com/auth/userinfo.email" |
| // ] |
| // } |
| |
| } |