gcorecloud

type APITokenAPISettings ¶ added in v0.4.32

type APITokenAPISettings struct {
	APIURL   string `json:"url,omitempty"`
	APIToken string `json:"-"`
	Type     string `json:"type,omitempty"`
	Name     string `json:"name,omitempty"`
	Region   int    `json:"region,omitempty"`
	Project  int    `json:"project,omitempty"`
	Version  string `json:"version,omitempty"`
	Debug    bool   `json:"debug,omitempty"`
}

APITokenAPISettings - settings for api token client building

func (gs APITokenAPISettings) ToAPITokenOptions() APITokenOptions

func (gs APITokenAPISettings) ToEndpointOptions() EndpointOpts

func (gs APITokenAPISettings) Validate() error

type APITokenClientSettings ¶ added in v0.4.32

type APITokenClientSettings interface {
	ToAPITokenOptions() APITokenOptions
	ToEndpointOptions() EndpointOpts
	Validate() error
}

APITokenClientSettings interface

type APITokenOptions ¶ added in v0.4.32

type APITokenOptions struct {
	APIURL   string `json:"-"`
	APIToken string `json:"-"`
}

APITokenOptions gcore API

type AuthClientSettings ¶

type AuthClientSettings interface {
	ToAuthOptions() AuthOptions
	ToEndpointOptions() EndpointOpts
	Validate() error
}

AuthClientSettings interface

type AuthOptions ¶

type AuthOptions struct {
	APIURL      string `json:"-"`
	AuthURL     string `json:"-"`
	Username    string `json:"username,omitempty"`
	Password    string `json:"password,omitempty"`
	AllowReauth bool   `json:"-"`
	ClientID    string `json:"-"`
}

AuthOptions gcore API

func (ao AuthOptions) ToMap() map[string]interface{}

type AuthOptionsBuilder ¶

type AuthOptionsBuilder interface {
	ToMap() map[string]interface{}
}

AuthOptionsBuilder build auth options to map

type AuthResult ¶

type AuthResult interface {
	ExtractAccessToken() (string, error)
	ExtractRefreshToken() (string, error)
	ExtractTokensPair() (string, string, error)
}

AuthResult interface

type BaseError ¶

type BaseError struct {
	DefaultErrString string
	Info             string
}

BaseError is an error type that all other error types embed.

func (e BaseError) Error() string

type CIDR ¶

type CIDR struct {
	net.IPNet
}

func ParseCIDRString(s string) (*CIDR, error)

func ParseCIDRStringOrNil(s string) (*CIDR, error)

func (c CIDR) MarshalJSON() ([]byte, error)

func (c CIDR) String() string

func (c *CIDR) UnmarshalJSON(data []byte) error

type Currency ¶

type Currency struct {
	*currency.Currency
}

func ParseCurrency(s string) (*Currency, error)

func (c Currency) MarshalJSON() ([]byte, error)

func (c Currency) String() string

func (c *Currency) UnmarshalJSON(data []byte) error

type EnabledState ¶

type EnabledState *bool

EnabledState is a convenience type, mostly used in Create and Update operations. Because the zero value of a bool is FALSE, we need to use a pointer instead to indicate zero-ness.

var (
	Enabled  EnabledState = &iTrue
	Disabled EnabledState = &iFalse
)

type EndpointLocator ¶

type EndpointLocator func(EndpointOpts) (string, error)

EndpointLocator is an internal function to be used by provider implementations.

It provides an implementation that locates a single endpoint from a service catalog for a specific ProviderClient based on user-provided EndpointOpts. The provider then uses it to discover related ServiceClients.

func DefaultEndpointLocator(endpoint string) EndpointLocator

type EndpointOpts ¶

type EndpointOpts struct {
	// Type [required] is the service type for the client (e.g., "cluster",
	// "nodegroup", "clustertemplates"). Generally, this will be supplied by the service client
	// function, but a user-given value will be honored if provided.
	Type string

	// Name [optional] is the service name for the client (e.g., "k8s") as it
	// appears in the service catalog. Services can have the same Type but a
	// different Name, which is why both Type and Name are sometimes needed.
	Name string

	// Region [required] is the geographic region in which the endpoint resides,
	// generally specifying which datacenter should house your resources.
	// Required only for services that span multiple regions.
	Region int

	// Project [required] is GCloud project
	Project int

	// version
	Version string
}

EndpointOpts specifies search criteria used by queries against an GCore service. The options must contain enough information to unambiguously identify one, and only one, endpoint within the catalog.

Usually, these are passed to service client factory functions in a provider package, like "gcore.NewClusterTemplateV1()".

func (eo *EndpointOpts) ApplyDefaults(t string)

type EnumValidator ¶

type EnumValidator interface {
	IsValid() error
	StringList() []string
}

type Err400er ¶

type Err400er interface {
	Error400(ErrUnexpectedResponseCode) error
}

Err400er is the interface resource error types implement to override the error message from a 400 error.

type Err401er ¶

type Err401er interface {
	Error401(ErrUnexpectedResponseCode) error
}

Err401er is the interface resource error types implement to override the error message from a 401 error.

type Err403er ¶

type Err403er interface {
	Error403(ErrUnexpectedResponseCode) error
}

Err403er is the interface resource error types implement to override the error message from a 403 error.

type Err404er ¶

type Err404er interface {
	Error404(ErrUnexpectedResponseCode) error
}

Err404er is the interface resource error types implement to override the error message from a 404 error.

type Err405er ¶

type Err405er interface {
	Error405(ErrUnexpectedResponseCode) error
}

Err405er is the interface resource error types implement to override the error message from a 405 error.

type Err408er ¶

type Err408er interface {
	Error408(ErrUnexpectedResponseCode) error
}

Err408er is the interface resource error types implement to override the error message from a 408 error.

type Err409er ¶

type Err409er interface {
	Error409(ErrUnexpectedResponseCode) error
}

Err409er is the interface resource error types implement to override the error message from a 409 error.

type Err429er ¶

type Err429er interface {
	Error429(ErrUnexpectedResponseCode) error
}

Err429er is the interface resource error types implement to override the error message from a 429 error.

type Err500er ¶

type Err500er interface {
	Error500(ErrUnexpectedResponseCode) error
}

Err500er is the interface resource error types implement to override the error message from a 500 error.

type Err502er ¶ added in v0.5.43

type Err502er interface {
	Error502(ErrUnexpectedResponseCode) error
}

Err502er is the interface resource error types implement to override the error message from a 502 error.

type Err503er ¶

type Err503er interface {
	Error503(ErrUnexpectedResponseCode) error
}

Err503er is the interface resource error types implement to override the error message from a 503 error.

type Err504er ¶ added in v0.5.43

type Err504er interface {
	Error504(ErrUnexpectedResponseCode) error
}

Err504er is the interface resource error types implement to override the error message from a 504 error.

type ErrAPIKeyProvided ¶

type ErrAPIKeyProvided struct{ BaseError }

ErrAPIKeyProvided indicates that an APIKey was provided but can't be used.

func (e ErrAPIKeyProvided) Error() string

type ErrAppCredMissingSecret ¶

type ErrAppCredMissingSecret struct{ BaseError }

ErrAppCredMissingSecret indicates that no Application Credential Secret was provided with Application Credential ID or Name

func (e ErrAppCredMissingSecret) Error() string

type ErrDefault400 ¶

type ErrDefault400 struct {
	ErrUnexpectedResponseCode
}

ErrDefault400 is the default error type returned on a 400 HTTP response code.

func (e ErrDefault400) Error() string

type ErrDefault401 ¶

type ErrDefault401 struct {
	ErrUnexpectedResponseCode
}

ErrDefault401 is the default error type returned on a 401 HTTP response code.

func (e ErrDefault401) Error() string

type ErrDefault403 ¶

type ErrDefault403 struct {
	ErrUnexpectedResponseCode
}

ErrDefault403 is the default error type returned on a 403 HTTP response code.

func (e ErrDefault403) Error() string

type ErrDefault404 ¶

type ErrDefault404 struct {
	ErrUnexpectedResponseCode
}

ErrDefault404 is the default error type returned on a 404 HTTP response code.

func (e ErrDefault404) Error() string

type ErrDefault405 ¶

type ErrDefault405 struct {
	ErrUnexpectedResponseCode
}

ErrDefault405 is the default error type returned on a 405 HTTP response code.

func (e ErrDefault405) Error() string

type ErrDefault408 ¶

type ErrDefault408 struct {
	ErrUnexpectedResponseCode
}

ErrDefault408 is the default error type returned on a 408 HTTP response code.

func (e ErrDefault408) Error() string

type ErrDefault409 ¶

type ErrDefault409 struct {
	ErrUnexpectedResponseCode
}

ErrDefault409 is the default error type returned on a 409 HTTP response code.

func (e ErrDefault409) Error() string

type ErrDefault429 ¶

type ErrDefault429 struct {
	ErrUnexpectedResponseCode
}

ErrDefault429 is the default error type returned on a 429 HTTP response code.

func (e ErrDefault429) Error() string

type ErrDefault500 ¶

type ErrDefault500 struct {
	ErrUnexpectedResponseCode
}

ErrDefault500 is the default error type returned on a 500 HTTP response code.

func (e ErrDefault500) Error() string

type ErrDefault502 ¶ added in v0.5.43

type ErrDefault502 struct {
	ErrUnexpectedResponseCode
}

ErrDefault502 is the default error type returned on a 502 HTTP response code.

type ErrDefault503 ¶

type ErrDefault503 struct {
	ErrUnexpectedResponseCode
}

ErrDefault503 is the default error type returned on a 503 HTTP response code.

func (e ErrDefault503) Error() string

type ErrDefault504 ¶ added in v0.5.43

type ErrDefault504 struct {
	ErrUnexpectedResponseCode
}

ErrDefault504 is the default error type returned on a 504 HTTP response code.

type ErrDomainIDOrDomainName ¶

type ErrDomainIDOrDomainName struct{ BaseError }

ErrDomainIDOrDomainName indicates that a username was provided, but no domain to scope it. It may also indicate that both a DomainID and a DomainName were provided at once.

func (e ErrDomainIDOrDomainName) Error() string

type ErrDomainIDWithToken ¶

type ErrDomainIDWithToken struct{ BaseError }

ErrDomainIDWithToken indicates that a DomainID was provided, but token authentication is being used instead.

func (e ErrDomainIDWithToken) Error() string

type ErrDomainIDWithUserID ¶

type ErrDomainIDWithUserID struct{ BaseError }

ErrDomainIDWithUserID indicates that a DomainID was provided, but unnecessary because a UserID is being used.

func (e ErrDomainIDWithUserID) Error() string

type ErrDomainNameWithToken ¶

type ErrDomainNameWithToken struct{ BaseError }

ErrDomainNameWithToken indicates that a DomainName was provided, but token authentication is being used instead.s

func (e ErrDomainNameWithToken) Error() string

type ErrDomainNameWithUserID ¶

type ErrDomainNameWithUserID struct{ BaseError }

ErrDomainNameWithUserID indicates that a DomainName was provided, but unnecessary because a UserID is being used.

func (e ErrDomainNameWithUserID) Error() string

type ErrEndpointNotFound ¶

type ErrEndpointNotFound struct {
	BaseError
}

ErrEndpointNotFound is returned when no available endpoints match the provided EndpointOpts. This is also generally returned by provider service factory methods, and usually indicates that a region was specified incorrectly.

func (e ErrEndpointNotFound) Error() string

type ErrErrorAfterReauthentication ¶

type ErrErrorAfterReauthentication struct {
	BaseError
	ErrOriginal error
}

ErrErrorAfterReauthentication is the error type returned when reauthentication succeeds, but an error occurs afterword (usually an HTTP error).

func (e ErrErrorAfterReauthentication) Error() string

type ErrInvalidInput ¶

type ErrInvalidInput struct {
	ErrMissingInput
	Value interface{}
}

ErrInvalidInput is an error type used for most non-HTTP Gophercloud errors.

func (e ErrInvalidInput) Error() string

type ErrMissingAnyoneOfEnvironmentVariables ¶

type ErrMissingAnyoneOfEnvironmentVariables struct {
	BaseError
	EnvironmentVariables []string
}

ErrMissingAnyoneOfEnvironmentVariables is the error when anyone of the environment variables is required in a particular situation but not provided by the user

func (e ErrMissingAnyoneOfEnvironmentVariables) Error() string

type ErrMissingEnvironmentVariable ¶

type ErrMissingEnvironmentVariable struct {
	BaseError
	EnvironmentVariable string
}

ErrMissingEnvironmentVariable is the error when environment variable is required in a particular situation but not provided by the user

func (e ErrMissingEnvironmentVariable) Error() string

type ErrMissingInput ¶

type ErrMissingInput struct {
	BaseError
	Argument string
}

ErrMissingInput is the error when input is required in a particular situation but not provided by the user

func (e ErrMissingInput) Error() string

type ErrMissingPassword ¶

type ErrMissingPassword struct{ BaseError }

ErrMissingPassword indicates that no password was provided and no token is available.

func (e ErrMissingPassword) Error() string

type ErrMultipleResourcesFound ¶

type ErrMultipleResourcesFound struct {
	BaseError
	Name         string
	Count        int
	ResourceType string
}

ErrMultipleResourcesFound is the error when trying to retrieve a resource's ID by name and multiple resources have the user-provided name.

func (e ErrMultipleResourcesFound) Error() string

type ErrResourceNotFound ¶

type ErrResourceNotFound struct {
	BaseError
	Name         string
	ResourceType string
}

ErrResourceNotFound is the error when trying to retrieve a resource's ID by name and the resource doesn't exist.

func (e ErrResourceNotFound) Error() string

type ErrResult ¶

type ErrResult struct {
	Result
}

ErrResult is an internal type to be used by individual resource packages, but its methods will be available on a wide variety of user-facing embedding types.

It represents results that only contain a potential error and nothing else. Usually, if the operation executed successfully, the Err field will be nil; otherwise it will be stocked with a relevant error. Use the ExtractErr method to cleanly pull it out.

func (r ErrResult) ExtractErr() error

type ErrScopeDomainIDOrDomainName ¶

type ErrScopeDomainIDOrDomainName struct{ BaseError }

ErrScopeDomainIDOrDomainName indicates that a domain ID or Name was required in a Scope, but not present.

func (e ErrScopeDomainIDOrDomainName) Error() string

type ErrScopeEmpty ¶

type ErrScopeEmpty struct{ BaseError }

ErrScopeEmpty indicates that no credentials were provided in a Scope.

func (e ErrScopeEmpty) Error() string

type ErrScopeProjectIDAlone ¶

type ErrScopeProjectIDAlone struct{ BaseError }

ErrScopeProjectIDAlone indicates that a ProjectID was provided with other constraints in a Scope.

func (e ErrScopeProjectIDAlone) Error() string

type ErrScopeProjectIDOrProjectName ¶

type ErrScopeProjectIDOrProjectName struct{ BaseError }

ErrScopeProjectIDOrProjectName indicates that both a ProjectID and a ProjectName were provided in a Scope.

func (e ErrScopeProjectIDOrProjectName) Error() string

type ErrServiceNotFound ¶

type ErrServiceNotFound struct {
	BaseError
}

ErrServiceNotFound is returned when no service in a service catalog matches the provided EndpointOpts. This is generally returned by provider service factory methods like "NewComputeV2()" and can mean that a service is not enabled for your account.

func (e ErrServiceNotFound) Error() string

type ErrTenantIDProvided ¶

type ErrTenantIDProvided struct{ BaseError }

ErrTenantIDProvided indicates that a TenantID was provided but can't be used.

func (e ErrTenantIDProvided) Error() string

type ErrTenantNameProvided ¶

type ErrTenantNameProvided struct{ BaseError }

ErrTenantNameProvided indicates that a TenantName was provided but can't be used.

func (e ErrTenantNameProvided) Error() string

type ErrTimeOut ¶

type ErrTimeOut struct {
	BaseError
}

ErrTimeOut is the error type returned when an operations times out.

func (e ErrTimeOut) Error() string

type ErrUnableToReauthenticate ¶

type ErrUnableToReauthenticate struct {
	BaseError
	ErrOriginal error
}

ErrUnableToReauthenticate is the error type returned when reauthentication fails.

func (e ErrUnableToReauthenticate) Error() string

type ErrUnexpectedResponseCode ¶

type ErrUnexpectedResponseCode struct {
	BaseError
	URL      string
	Method   string
	Expected []int
	Actual   int
	Body     []byte
}

ErrUnexpectedResponseCode is returned by the Request method when a response code other than those listed in OkCodes is encountered.

func (e ErrUnexpectedResponseCode) Error() string

func (e ErrUnexpectedResponseCode) GetStatusCode() int

func (e *ErrUnexpectedResponseCode) ReadGcoreError()

type ErrUnexpectedType ¶

type ErrUnexpectedType struct {
	BaseError
	Expected string
	Actual   string
}

ErrUnexpectedType is the error when an unexpected type is encountered

func (e ErrUnexpectedType) Error() string

type ErrUserIDWithToken ¶

type ErrUserIDWithToken struct{ BaseError }

ErrUserIDWithToken indicates that a UserID was provided, but token authentication is being used instead.

func (e ErrUserIDWithToken) Error() string

type ErrUsernameOrUserID ¶

type ErrUsernameOrUserID struct{ BaseError }

ErrUsernameOrUserID indicates that neither username nor userID are specified, or both are at once.

func (e ErrUsernameOrUserID) Error() string

type ErrUsernameWithToken ¶

type ErrUsernameWithToken struct{ BaseError }

ErrUsernameWithToken indicates that a Username was provided, but token authentication is being used instead.

func (e ErrUsernameWithToken) Error() string

type GcoreErrorType ¶

type GcoreErrorType struct {
	ExceptionClass string `json:"exception_class"`
	Message        string `json:"message"`
	Traceback      string `json:"traceback"`
	RequestID      string `json:"request_id"`
}

type HeaderResult ¶

type HeaderResult struct {
	Result
}

HeaderResult is an internal type to be used by individual resource packages, but its methods will be available on a wide variety of user-facing embedding types.

It represents a result that only contains an error (possibly nil) and an http.Header. This is used, for example, by the objectstorage packages in openstack, because most of the operations don't return response bodies, but do have relevant information in headers.

func (r HeaderResult) ExtractInto(to interface{}) error

type IPVersion ¶

type IPVersion int

IPVersion is a type for the possible IP address versions. Valid instances are IPv4 and IPv6

const (
	// IPv4 is used for IP version 4 addresses
	IPv4 IPVersion = 4
	// IPv6 is used for IP version 6 addresses
	IPv6 IPVersion = 6
)

type ItemID ¶

type ItemID struct {
	ID string `json:"id"`
}

type ItemIDName ¶

type ItemIDName struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

type ItemName ¶

type ItemName struct {
	Name string `json:"name"`
}

type JSONRFC1123 ¶

type JSONRFC1123 time.Time

JSONRFC1123 describes time.Time in time.RFC1123 format.

func (jt *JSONRFC1123) UnmarshalJSON(data []byte) error

type JSONRFC3339Date ¶ added in v0.4.32

type JSONRFC3339Date struct {
	time.Time
}

JSONRFC3339Date describes time.Time in RFC3339Date format

func (jt *JSONRFC3339Date) MarshalJSON() ([]byte, error)

func (jt *JSONRFC3339Date) UnmarshalJSON(data []byte) error

type JSONRFC3339Milli ¶

type JSONRFC3339Milli time.Time

JSONRFC3339Milli describes time.Time in RFC3339Milli format.

func (jt *JSONRFC3339Milli) UnmarshalJSON(data []byte) error

type JSONRFC3339MilliNoZ ¶

type JSONRFC3339MilliNoZ struct {
	time.Time
}

JSONRFC3339MilliNoZ describes time.Time in RFC3339MilliNoZ format.

func (jt *JSONRFC3339MilliNoZ) UnmarshalJSON(data []byte) error

type JSONRFC3339NoZ ¶

type JSONRFC3339NoZ struct {
	time.Time
}

JSONRFC3339NoZ describes time.Time in RFC3339NoZ format.

func (jt *JSONRFC3339NoZ) MarshalJSON() ([]byte, error)

func (jt *JSONRFC3339NoZ) String() string

func (jt *JSONRFC3339NoZ) UnmarshalJSON(data []byte) error

type JSONRFC3339Z ¶

type JSONRFC3339Z struct {
	time.Time
}

JSONRFC3339Z describes time.Time in RFC3339Z format.

func (jt *JSONRFC3339Z) MarshalJSON() ([]byte, error)

func (jt *JSONRFC3339Z) UnmarshalJSON(data []byte) error

type JSONRFC3339ZColon ¶ added in v0.4.7

type JSONRFC3339ZColon struct {
	time.Time
}

JSONRFC3339ZColon describes time.Time in RFC3339ZColon format.

func (jt *JSONRFC3339ZColon) MarshalJSON() ([]byte, error)

func (jt *JSONRFC3339ZColon) UnmarshalJSON(data []byte) error

type JSONRFC3339ZNoT ¶

type JSONRFC3339ZNoT time.Time

JSONRFC3339ZNoT describes time.Time in RFC3339ZNoT format.

func (jt *JSONRFC3339ZNoT) UnmarshalJSON(data []byte) error

type JSONRFC3339ZNoTNoZ ¶

type JSONRFC3339ZNoTNoZ time.Time

JSONRFC3339ZNoTNoZ describes time.Time in RFC3339ZNoTNoZ format.

func (jt *JSONRFC3339ZNoTNoZ) UnmarshalJSON(data []byte) error

type JSONRFC3339ZZ ¶

type JSONRFC3339ZZ struct {
	time.Time
}

JSONRFC3339ZZ describes time.Time in RFC3339ZZ format

func (jt *JSONRFC3339ZZ) MarshalJSON() ([]byte, error)

func (jt *JSONRFC3339ZZ) UnmarshalJSON(data []byte) error

type JSONUnix ¶

type JSONUnix time.Time

JSONUnix describes time.Time in unix format.

func (jt *JSONUnix) UnmarshalJSON(data []byte) error

type Link ¶

type Link struct {
	Href string `json:"href"`
	Rel  string `json:"rel"`
}

Link is an internal type to be used in packages of collection resources that are paginated in a certain way.

It's a response substructure common to many paginated collection results that is used to point to related pages. Usually, the one we care about is the one with Rel field set to "next".

type MAC ¶

type MAC struct {
	net.HardwareAddr
}

func ParseMacString(s string) (*MAC, error)

func (m MAC) MarshalJSON() ([]byte, error)

func (m MAC) String() string

func (m *MAC) UnmarshalJSON(data []byte) error

type PasswordAPISettings ¶

type PasswordAPISettings struct {
	APIURL      string `json:"api-url,omitempty"`
	AuthURL     string `json:"auth-url,omitempty"`
	Username    string `json:"username,omitempty"`
	Password    string `json:"password,omitempty"`
	AllowReauth bool   `json:"-"`
	Type        string `json:"type,omitempty"`
	Name        string `json:"name,omitempty"`
	Region      int    `json:"region,omitempty"`
	Project     int    `json:"project,omitempty"`
	Version     string `json:"version,omitempty"`
	Debug       bool   `json:"debug,omitempty"`
}

PasswordAPISettings - settings for password client building

func (gs PasswordAPISettings) ToAuthOptions() AuthOptions

func (gs PasswordAPISettings) ToEndpointOptions() EndpointOpts

func (gs PasswordAPISettings) Validate() error

type ProviderClient ¶

type ProviderClient struct {
	// IdentityBase is the base URL used for a particular provider's identity
	// service - it will be used when issuing authentication requests. It
	// should point to the root resource of the identity service, not a specific
	// identity version.
	IdentityBase string

	// APIURL is the identity endpoint. This may be a specific version
	// of the identity service. If this is the case, this endpoint is used rather
	// than querying versions first.
	IdentityEndpoint string

	// AccessTokenID and RefreshTokenID is the IDs of the most recently issued valid tokens.
	// NOTE: Aside from within a custom ReauthFunc, this field shouldn't be set by an application.
	// To safely read or write this value, call `AccessToken` or `SetAccessToken`
	// call `RefreshToken` or `SetRefreshToken`, respectively
	AccessTokenID  string
	RefreshTokenID string

	// EndpointLocator describes how this provider discovers the endpoints for
	// its constituent services.
	EndpointLocator EndpointLocator

	// HTTPClient allows users to interject arbitrary http, https, or other transit behaviors.
	HTTPClient http.Client

	// UserAgent represents the User-Agent header in the HTTP request.
	UserAgent UserAgent

	// ReauthFunc is the function used to re-authenticate the user if the request
	// fails with a 401 HTTP response code. This a needed because there may be multiple
	// authentication functions for different Identity service versions.
	ReauthFunc func() error

	// Throwaway determines whether if this client is a throw-away client. It's a copy of user's provider client
	// with the token and reauth func zeroed. Such client can be used to perform reauthorization.
	Throwaway bool

	// Context is the context passed to the HTTP request.
	Context context.Context

	APIToken string
	APIBase  string
	// contains filtered or unexported fields
}

ProviderClient stores details that are required to interact with any services within a specific provider's API.

Generally, you acquire a ProviderClient by calling the NewClient method in the appropriate provider's child package, providing whatever authentication credentials are required.

func NewProviderClient() *ProviderClient

func (client *ProviderClient) AccessToken() string

func (client *ProviderClient) AuthenticatedHeaders() (m map[string]string)

func (client *ProviderClient) CopyTokensFrom(other *ProviderClient)

func (client *ProviderClient) EnableGetRetriesOn5XX(attempts int, interval int)

func (client *ProviderClient) GetAuthResult() AuthResult

func (client *ProviderClient) IsDebug() bool

func (client *ProviderClient) IsThrowaway() bool

func (client *ProviderClient) Reauthenticate(previousToken string) error

func (client *ProviderClient) RefreshToken() string

func (client *ProviderClient) Request(method, url string, options *RequestOpts) (*http.Response, error)

func (client *ProviderClient) SetAPIToken(opt APITokenOptions) error

func (client *ProviderClient) SetDebug(debug bool)

func (client *ProviderClient) SetThrowaway(v bool)

func (client *ProviderClient) SetTokensAndAuthResult(r AuthResult) error

func (client ProviderClient) ToTokenOptions() TokenOptions

func (client *ProviderClient) UseTokenLock()

type RequestOpts ¶

type RequestOpts struct {
	// JSONBody, if provided, will be encoded as JSON and used as the body of the HTTP request. The
	// content type of the request will default to "application/json" unless overridden by MoreHeaders.
	// It's an error to specify both a JSONBody and a RawBody.
	JSONBody interface{}
	// RawBody contains an io.Reader that will be consumed by the request directly. No content-type
	// will be set unless one is provided explicitly by MoreHeaders.
	RawBody io.Reader
	// JSONResponse, if provided, will be populated with the contents of the response body parsed as
	// JSON.
	JSONResponse interface{}
	// OkCodes contains a list of numeric HTTP status codes that should be interpreted as success. If
	// the response has a different code, an error will be returned.
	OkCodes []int
	// MoreHeaders specifies additional HTTP headers to be provide on the request. If a header is
	// provided with a blank value (""), that header will be *omitted* instead: use this to suppress
	// the default Accept header or an inferred Content-Type, for example.
	MoreHeaders map[string]string
	// ErrorContext specifies the resource error type to return if an error is encountered.
	// This lets resources override default error messages based on the response status code.
	ErrorContext error
	// ConflictRetryAmount specifies number of retries to perform in case of encountering conflict
	// during performed request
	ConflictRetryAmount int
	// ConflictRetryInterval specifies time (in seconds) between next retry requests
	ConflictRetryInterval int
}

RequestOpts customizes the behavior of the provider.Request() method.

type Result ¶

type Result struct {
	// Body is the payload of the HTTP response from the server. In most cases,
	// this will be the deserialized JSON structure.
	Body interface{}

	// Header contains the HTTP header structure from the original response.
	Header http.Header

	// Err is an error that occurred during the operation. It's deferred until
	// extraction to make it easier to chain the Extract call.
	Err error
}

Result is an internal type to be used by individual resource packages, but its methods will be available on a wide variety of user-facing embedding types.

It acts as a base struct that other Result types, returned from request functions, can embed for convenience. All Results capture basic information from the HTTP transaction that was performed, including the response body, HTTP headers, and any errors that happened.

Generally, each Result type will have an Extract method that can be used to further interpret the result's payload in a specific context. Extensions or providers can then provide additional extraction functions to pull out provider- or extension-specific information as well.

func (r Result) ExtractInto(to interface{}) error

func (r Result) ExtractIntoMapPtr(to interface{}, label string) error

func (r Result) ExtractIntoSlicePtr(to interface{}, label string) error

func (r Result) ExtractIntoStructPtr(to interface{}, label string) error

func (r Result) PrettyPrintJSON() string

type ServiceClient ¶

type ServiceClient struct {
	// ProviderClient is a reference to the provider that implements this service.
	*ProviderClient

	// Endpoint is the base URL of the service's API, acquired from a service catalog.
	// It MUST end with a /.
	Endpoint string

	// ResourceBase is the base URL shared by the resources within a service's API. It should include
	// the API version and, like Endpoint, MUST end with a / if set. If not set, the Endpoint is used
	// as-is, instead.
	ResourceBase string

	// This is the service client type (e.g. cluster, clustertemplates, nodegroup).
	// NOTE: FOR INTERNAL USE ONLY. DO NOT SET. GCORE CLOUD WILL SET THIS.
	// It is only exported because it gets set in a different package.
	Type string

	// MoreHeaders allows users (or GCore cloud) to set service-wide headers on requests. Put another way,
	// values set in this field will be set on all the HTTP requests the service client sends.
	MoreHeaders map[string]string

	// RegionID is an id of chosen region
	RegionID int

	// ProjectID is an id of chosen project
	ProjectID int
}

ServiceClient stores details required to interact with a specific service API implemented by a provider. Generally, you'll acquire these by calling the appropriate `New` method on a ProviderClient.

func (client *ServiceClient) BaseServiceURL(parts ...string) string

func (client *ServiceClient) Delete(url string, opts *RequestOpts) (*http.Response, error)

func (client *ServiceClient) DeleteWithResponse(url string, jsonResponse interface{}, opts *RequestOpts) (*http.Response, error)

func (client *ServiceClient) Get(url string, jsonResponse interface{}, opts *RequestOpts) (*http.Response, error)

func (client *ServiceClient) Head(url string, opts *RequestOpts) (*http.Response, error)

func (client *ServiceClient) Patch(url string, jsonBody interface{}, jsonResponse interface{}, opts *RequestOpts) (*http.Response, error)

func (client *ServiceClient) Post(url string, jsonBody interface{}, jsonResponse interface{}, opts *RequestOpts) (*http.Response, error)

func (client *ServiceClient) Put(url string, jsonBody interface{}, jsonResponse interface{}, opts *RequestOpts) (*http.Response, error)

func (client *ServiceClient) Request(method, url string, options *RequestOpts) (*http.Response, error)

func (client *ServiceClient) ResourceBaseURL() string

func (client *ServiceClient) ServiceURL(parts ...string) string

type StatusCodeError ¶

type StatusCodeError interface {
	Error() string
	GetStatusCode() int
}

StatusCodeError is a convenience interface to easily allow access to the status code field of the various ErrDefault* types.

By using this interface, you only have to make a single type cast of the returned error to err.(StatusCodeError) and then call GetStatusCode() instead of having a large switch statement checking for each of the ErrDefault* types.

type TokenAPISettings ¶

type TokenAPISettings struct {
	APIURL       string `json:"url,omitempty"`
	AccessToken  string `json:"access,omitempty"`
	RefreshToken string `json:"refresh,omitempty"`
	AllowReauth  bool   `json:"-"`
	Type         string `json:"type,omitempty"`
	Name         string `json:"name,omitempty"`
	Region       int    `json:"region,omitempty"`
	Project      int    `json:"project,omitempty"`
	Version      string `json:"version,omitempty"`
	Debug        bool   `json:"debug,omitempty"`
}

TokenAPISettings - settings for token client building

func (gs TokenAPISettings) ToEndpointOptions() EndpointOpts

func (gs TokenAPISettings) ToTokenOptions() TokenOptions

func (gs TokenAPISettings) Validate() error

type TokenClientSettings ¶

type TokenClientSettings interface {
	ToTokenOptions() TokenOptions
	ToEndpointOptions() EndpointOpts
	Validate() error
}

TokenClientSettings interface

type TokenOptions ¶

type TokenOptions struct {
	APIURL       string `json:"-"`
	AccessToken  string `json:"access,omitempty"`
	RefreshToken string `json:"refresh,omitempty"`
	AllowReauth  bool   `json:"-"`
}

TokenOptions gcore API

func (to TokenOptions) ExtractAccessToken() (string, error)

func (to TokenOptions) ExtractRefreshToken() (string, error)

func (to TokenOptions) ExtractTokensPair() (string, string, error)

func (to TokenOptions) ToMap() map[string]interface{}

type TokenOptionsBuilder ¶

type TokenOptionsBuilder interface {
	ToMap() map[string]interface{}
}

TokenOptionsBuilder build token options to map

type URL ¶

type URL struct {
	*url.URL
}

func MustParseURL(s string) *URL

func ParseURL(s string) (*URL, error)

func ParseURLNonMandatory(s string) (*URL, error)

func (u URL) MarshalJSON() ([]byte, error)

func (u URL) String() string

func (u *URL) UnmarshalJSON(data []byte) error

type UserAgent ¶

type UserAgent struct {
	// contains filtered or unexported fields
}

UserAgent represents a User-Agent header.

func (ua *UserAgent) Join() string

func (ua *UserAgent) Prepend(s ...string)