gophercloud

README

Go SDK

The following services' SDK are included.
- IAM
- IMS
- VPC
- ECS
- EVS
- CES
- ELB
- DNS
- AS
- BSS

Documentation

Overview

Package gophercloud provides a multi-vendor interface to OpenStack-compatible clouds. The library has a three-level hierarchy: providers, services, and resources.

Authenticating with Providers

Provider structs represent the cloud providers that offer and manage a collection of services. You will generally want to create one Provider client per OpenStack cloud.

Use your OpenStack credentials to create a Provider client. The IdentityEndpoint is typically refered to as "auth_url" or "OS_AUTH_URL" in information provided by the cloud operator. Additionally, the cloud may refer to TenantID or TenantName as project_id and project_name. Credentials are specified like so:

opts := token.TokenOptions{
  IdentityEndpoint: "https://openstack.example.com:5000/v2.0",
  Username: "{username}",
  Password: "{password}",
  TenantID: "{tenant_id}",
}

provider, err := openstack.AuthenticatedClient(opts)

You can also use AK/SK authentication to construct provider:

akSkOptions := aksk.AkSkOptions{
	IdentityEndpoint: "https://openstack.example.com:5000/v2.0",
	ProjectId:        "{projectId}",
	AccessKey:        "{accKey}",
	SecretKey:        "{secretKey}",
	Domain:           "yyy.com",
}
provider, err := openstack.AuthenticatedClient(akSkOptions)

You may also use the openstack.AuthOptionsFromEnv() helper function. This function reads in standard environment variables frequently found in an OpenStack `openrc` file. Again note that Gophercloud currently uses "tenant" instead of "project".

opts, err := openstack.AuthOptionsFromEnv()
provider, err := openstack.AuthenticatedClient(opts)

Service Clients

Service structs are specific to a provider and handle all of the logic and operations for a particular OpenStack service. Examples of services include: Compute, Object Storage, Block Storage. In order to define one, you need to pass in the parent provider, like so:

opts := gophercloud.EndpointOpts{Region: "RegionOne"}

client := openstack.NewComputeV2(provider, opts)

Resources

Resource structs are the domain models that services make use of in order to work with and represent the state of API resources:

server, err := servers.Get(client, "{serverId}").Extract()

Intermediate Result structs are returned for API operations, which allow generic access to the HTTP headers, response body, and any errors associated with the network transaction. To turn a result into a usable resource struct, you must call the Extract method which is chained to the response, or an Extract function from an applicable extension:

result := servers.Get(client, "{serverId}")

// Attempt to extract the disk configuration from the OS-DCF disk config
// extension:
config, err := diskconfig.ExtractGet(result)

All requests that enumerate a collection return a Pager struct that is used to iterate through the results one page at a time. Use the EachPage method on that Pager to handle each successive Page in a closure, then use the appropriate extraction method from that request's package to interpret that Page as a slice of results:

err := servers.List(client, nil).EachPage(func (page pagination.Page) (bool, error) {
  s, err := servers.ExtractServers(page)
  if err != nil {
    return false, err
  }

  // Handle the []servers.Server slice.

  // Return "false" or an error to prematurely stop fetching new pages.
  return true, nil
})

If you want to obtain the entire collection of pages without doing any intermediary processing on each page, you can use the AllPages method:

allPages, err := servers.List(client, nil).AllPages()
allServers, err := servers.ExtractServers(allPages)

This top-level package contains utility functions and data types that are used throughout the provider and service packages. Of particular note for end users are the AuthOptions and EndpointOpts structs.

Index

• Constants
• Variables
• func BuildHeaders(opts interface{}) (map[string]string, error)
• func BuildQueryString(opts interface{}) (*url.URL, error)
• func BuildRequestBody(opts interface{}, parent string) (map[string]interface{}, error)
• func ExtractNextURL(links []Link) (string, error)
• func IDSliceToQueryString(name string, ids []int) string
• func InitStructWithDefaultTag(bean interface{})
• func IntToPointer(i int) *int
• func IntWithinRange(val, min, max int) bool
• func IsInStrSlice(sliceStr []string, s string) bool
• func MatchErrorCode(httpStatus int, message string) string
• func MaybeInt(original int) *int
• func MaybeString(original string) *string
• func NewSystemCommonError(code, message string) error
• func NewSystemServerError(httpStatus int, responseContent string) error
• func NormalizePathURL(basePath, rawPath string) (string, error)
• func NormalizeURL(url string) string
• func ParseSeverError(httpStatus int, responseContent string) error
• func WaitFor(timeout int, predicate func() (bool, error)) error
• type Availability
• type Config
  • func NewConfig() (config *Config)
  • func (c *Config) WithHttpTransport(httpTransport *http.Transport) *Config
  • func (c *Config) WithTimeout(timeout time.Duration) *Config
• type EnabledState
• type EndpointLocator
• type EndpointOpts
  • func (eo *EndpointOpts) ApplyDefaults(t string)
• type ErrResult
  • func (r ErrResult) ExtractErr() error
• type HeaderResult
  • func (r HeaderResult) ExtractInto(to interface{}) error
• type IPVersion
• type JSONRFC1123
  • func (jt *JSONRFC1123) UnmarshalJSON(data []byte) error
• type JSONRFC3339Milli
  • func (jt *JSONRFC3339Milli) UnmarshalJSON(data []byte) error
• type JSONRFC3339MilliNoZ
  • func (jt *JSONRFC3339MilliNoZ) UnmarshalJSON(data []byte) error
• type JSONRFC3339NoZ
  • func (jt *JSONRFC3339NoZ) UnmarshalJSON(data []byte) error
• type JSONUnix
  • func (jt *JSONUnix) UnmarshalJSON(data []byte) error
• type Link
• type Logger
  • func GetLogger() *Logger
  • func (log *Logger) Debug(format string, v ...interface{})
• type OneLevelError
• type ProviderClient
  • func (client *ProviderClient) AuthenticatedHeaders() (m map[string]string)
  • func (client *ProviderClient) GetProjectID() string
  • func (client *ProviderClient) Reauthenticate(previousToken string) (err error)
  • func (client *ProviderClient) Request(method, url string, options *RequestOpts) (*http.Response, error)
  • func (client *ProviderClient) SetToken(t string)
  • func (client *ProviderClient) Token() string
  • func (client *ProviderClient) UseTokenLock()
• type RequestOpts
• type Result
  • func (r Result) ExtractInto(to interface{}) 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
  • func (client *ServiceClient) Delete(url string, 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) ResourceBaseURL() string
  • func (client *ServiceClient) ServiceURL(parts ...string) string
  • func (client *ServiceClient) SetMicroversion(microversion string)
  • func (client *ServiceClient) UnsetMicroversion()
• type UnifiedError
  • func (e UnifiedError) Error() string
  • func (e UnifiedError) ErrorCode() string
  • func (e UnifiedError) Message() string
• type UserAgent
  • func (ua *UserAgent) Join() string
  • func (ua *UserAgent) Prepend(s ...string)

Constants

const (
	//ECS
	EcsAuthRequired          = "Authentication required"
	EcsPoilcyNotAllow        = "Policy doesn't allow .*. to be performed"
	EcsTokenRoleEmpty        = "token role is empty, forbidden to perform this action"
	EcsTokenRoleForbidden    = "token role * is forbidden to perform this action"
	EcsErrorRoleToPerform    = "do not have the required roles, forbbiden to perform this action"
	EcsQuotaExceeded         = "Quota exceeded for instances"
	EcsPortNumberExceed      = "Maximum number of ports exceeded"
	EcsVolumeNumberOver      = "Volume number is over limit"
	EcsBlockImageNotFound    = "Block Device Mapping is Invalid: failed to get image.*."
	EcsImageNotFound         = "Image * could not be found."
	EcsFlavorNotFound        = "Flavor .*. could not be found"
	EcsNetworkNotFound       = "Network.*.could not be found"
	EcsBlockDevInvalid       = "Block Device Mapping is Invalid"
	EcsAZUnavailable         = "The requested availability zone is not available"
	EcsSecurityGroupNotFound = "Security group .*. not found"
	EcsKeyPairNotFound       = "Keypair .*. not found for user *"
	EcsInstanceGroupNotFound = "Instance group .*. could not be found"
	EcsInvalidMetadata       = "Invalid metadata.*"
	EcsUserDataBase64        = "User data needs to be valid base 64"
	EcsUserDataTooLarge      = "User data too large. User data must be no larger than .*"
	EcsInstanceDiskExceed    = "The created instance's disk would be too small"
	EcsFlavorMemoryNotEnough = "Flavor's memory is too small for requested image"
	EcsInstanceNotFound      = "Instance .*. could not be found"
	EcsInstanceIsLocked      = "Instance .*. is locked"
	EcsInstCantBeOperated    = "Cannot .*. instance .*. while it is in .*"
	EcsUnexpectedApiERROR    = "Unexpected API Error"
	EcsServerCantComply      = "The server could not comply with the request since it is either malformed.*."
	EcsInvalidFlavorRef      = "Invalid flavorRef provided"
	EcsInvalidKeyName        = "Invalid key_name provided"
	EcsInvalidInputField     = "Invalid input for field/attribute"
	EcsResourceSoldOut       = "Instance resource is temporarily sold out."

	//IMS
	Ims0027NoImageFoundWithId = "No image found with ID"
	Ims0144FailedFindImage    = "Failed to find image"

	//ELB
	ELB2001AdminStateUpFalse    = "Admin_state_up is not allowed with False"
	ELB2002IpNotValid           = "IP address .*. is not a valid IP for the specified subnet."
	ELB2003PoolNotFound         = "pool .*. could not be found"
	ELB2004MemberNotSupportPort = "Member not support protocol port *"
	ELB2005SubnetMismatch       = "Router of member's subnet .*. and router of loadbalancer's subnet .*. mismatch"
	ELB2006IpPortAlreadyPresent = "Member with address .*. and protocol_port .*. already present in pool .*."
	ELB2007MemberNotFound       = "member .*. could not be found"

	ELB6101QuotaExceeded = "Quota exceeded for resources: \\['listener'\\]"
	ELB2541QuotaExceeded = "Quota exceeded for resources: \\['pool'\\]"
	ELBb015QuotaExceeded = "Quota exceeded for resources: \\['l7policy'\\]"
	ELB1071QuotaExceeded = "Quota exceeded for resources: \\['loadbalancer'\\]"
)

Define Service error information.

const (
	//Com1000
	CE_MissingInputCode    = "Com.1000" //client error
	CE_MissingInputMessage = "Missing input for argument [%s]"

	//Com1001
	CE_StreamControlApiCode    = "Com.1001" //server error
	CE_StreamControlApiMessage = "The maximum request receiving rate is exceeded"

	//Com1002
	CE_InvalidInputCode    = "Com.1002" //client error
	CE_InvalidInputMessage = "Invalid input provided for argument [%s]"

	CE_OptionTypeNotStructCode    = "Com.1002" //client error
	CE_OptionTypeNotStructMessage = "Options type is not a struct"

	//Com1003
	CE_ResourceNotFoundCode    = "Com.1003" //client error
	CE_ResourceNotFoundMessage = "Unable to find %s with name %s"

	CE_MultipleResourcesFoundCode    = "Com.1003" //client error
	CE_MultipleResourcesFoundMessage = "Found %d %ss matching %s"

	CE_ErrUnexpectedTypeCode    = "Com.1003" //client error
	CE_ErrUnexpectedTypeMessage = "Expected %s but got %s"

	//Com1004
	CE_NoClientProvidedCode    = "Com.1004" //client error
	CE_NoClientProvidedMessage = "A service client must be provided to find a resource ID by name"

	CE_NoEndPointInCatalogCode    = "Com.1004" //client error
	CE_NoEndPointInCatalogMessage = "No suitable endpoint could be found in the service catalog."

	//Com1005
	CE_ApiNotFoundCode    = "Com.1005" //server error
	CE_ApiNotFoundMessage = "API not found"

	//1006
	CE_TimeoutErrorCode    = "Com.1006" //client error
	CE_TimeoutErrorMessage = "The request timed out %s times(%s for retry), perhaps we should have the threshold raised a little?"

	CE_ReauthExceedCode    = "Com.1006" //client error
	CE_ReauthExceedMessage = "Tried to re-authenticate 3 times with no success."

	CE_ReauthFuncErrorCode    = "Com.1006" //client error
	CE_ReauthFuncErrorMessage = "Get reauth function error [%s]"
)

Common Error.

const DefaultUserAgent = "gophercloud/2.0.0"

DefaultUserAgent is the default User-Agent string set in the request header.

const RFC3339Milli = "2006-01-02T15:04:05.999999Z"

RFC3339Milli describes a common time format used by some API responses.

const RFC3339MilliNoZ = "2006-01-02T15:04:05.999999"

const RFC3339NoZ = "2006-01-02T15:04:05"

RFC3339NoZ is the time format used in Heat (Orchestration).

Variables

var EnableDebug bool

EnableDebug, SDK log switch defaults value is false.

Functions

func BuildHeaders

func BuildHeaders(opts interface{}) (map[string]string, error)

BuildHeaders is an internal function to be used by request methods in individual resource packages.

It accepts an arbitrary tagged structure and produces a string map that's suitable for use as the HTTP headers of an outgoing request. Field names are mapped to header names based in "h" tags.

type struct Something {
  Bar string `h:"x_bar"`
  Baz int    `h:"lorem_ipsum"`
}

instance := Something{
  Bar: "AAA",
  Baz: "BBB",
}

will be converted into:

map[string]string{
  "x_bar": "AAA",
  "lorem_ipsum": "BBB",
}

Untagged fields and fields left at their zero values are skipped. Integers, booleans and string values are supported.

func BuildQueryString

func BuildQueryString(opts interface{}) (*url.URL, error)

BuildQueryString is an internal function to be used by request methods in individual resource packages.

It accepts a tagged structure and expands it into a URL struct. Field names are converted into query parameters based on a "q" tag. For example:

type struct Something {
   Bar string `q:"x_bar"`
   Baz int    `q:"lorem_ipsum"`
}

instance := Something{
   Bar: "AAA",
   Baz: "BBB",
}

will be converted into "?x_bar=AAA&lorem_ipsum=BBB".

The struct's fields may be strings, integers, or boolean values. Fields left at their type's zero value will be omitted from the query.

func BuildRequestBody

func BuildRequestBody(opts interface{}, parent string) (map[string]interface{}, error)

BuildRequestBody builds a map[string]interface from the given `struct`. If parent is not an empty string, the final map[string]interface returned will encapsulate the built one. For example:

disk := 1
createOpts := flavors.CreateOpts{
  ID:         "1",
  Name:       "m1.tiny",
  Disk:       &disk,
  RAM:        512,
  VCPUs:      1,
  RxTxFactor: 1.0,
}

body, err := gophercloud.BuildRequestBody(createOpts, "flavor")

The above example can be run as-is, however it is recommended to look at how BuildRequestBody is used within Gophercloud to more fully understand how it fits within the request process as a whole rather than use it directly as shown above.

func ExtractNextURL

func ExtractNextURL(links []Link) (string, error)

ExtractNextURL is an internal function useful for packages of collection resources that are paginated in a certain way.

It attempts to extract the "next" URL from slice of Link structs, or "" if no such URL is present.

func IDSliceToQueryString

func IDSliceToQueryString(name string, ids []int) string

IDSliceToQueryString takes a slice of elements and converts them into a query string. For example, if name=foo and slice=[]int{20, 40, 60}, then the result would be `?name=20&name=40&name=60'

func InitStructWithDefaultTag

func InitStructWithDefaultTag(bean interface{})

InitStructWithDefaultTag,Initialize the structure instance using the structure tag.

func IntToPointer

func IntToPointer(i int) *int

IntToPointer is a function for converting integers into integer pointers. This is useful when passing in options to operations.

func IntWithinRange

func IntWithinRange(val, min, max int) bool

IntWithinRange returns TRUE if an integer falls within a defined range, and FALSE if not.

func IsInStrSlice

func IsInStrSlice(sliceStr []string, s string) bool

IsInStrSlice, Determine if the string is in the array.

func MatchErrorCode

func MatchErrorCode(httpStatus int, message string) string

MatchErrorCode,Match the error code according to the error message

func MaybeInt

func MaybeInt(original int) *int

MaybeInt is an internal function to be used by request methods in individual resource packages.

Like MaybeString, it accepts an int that may or may not be a zero value, and returns either a pointer to its address or nil. It's intended to hint that the JSON serializer should omit its field.

func MaybeString

func MaybeString(original string) *string

MaybeString is an internal function to be used by request methods in individual resource packages.

It takes a string that might be a zero value and returns either a pointer to its address or nil. This is useful for allowing users to conveniently omit values from an options struct by leaving them zeroed, but still pass nil to the JSON serializer so they'll be omitted from the request body.

func NewSystemCommonError

func NewSystemCommonError(code, message string) error

Initialize SDK client error.

func NewSystemServerError

func NewSystemServerError(httpStatus int, responseContent string) error

NewSystemServerError,Handle background API error codes.

func NormalizePathURL

func NormalizePathURL(basePath, rawPath string) (string, error)

NormalizePathURL is used to convert rawPath to a fqdn, using basePath as a reference in the filesystem, if necessary. basePath is assumed to contain either '.' when first used, or the file:// type fqdn of the parent resource. e.g. myFavScript.yaml => file://opt/lib/myFavScript.yaml

func NormalizeURL

func NormalizeURL(url string) string

NormalizeURL is an internal function to be used by provider clients.

It ensures that each endpoint URL has a closing `/`, as expected by ServiceClient's methods.

func ParseSeverError

func ParseSeverError(httpStatus int, responseContent string) error

ParseSeverError,This function uses json serialization to parse background API error codes.

func WaitFor

func WaitFor(timeout int, predicate func() (bool, error)) error

WaitFor polls a predicate function, once per second, up to a timeout limit. This is useful to wait for a resource to transition to a certain state. To handle situations when the predicate might hang indefinitely, the predicate will be prematurely cancelled after the timeout. Resource packages will wrap this in a more convenient function that's specific to a certain resource, but it can also be useful on its own.

Types

type Availability

type Availability string

Availability indicates to whom a specific service endpoint is accessible: the internet at large, internal networks only, or only to administrators. Different identity services use different terminology for these. Identity v2 lists them as different kinds of URLs within the service catalog ("adminURL", "internalURL", and "publicURL"), while v3 lists them as "Interfaces" in an endpoint's response.

const (
	// AvailabilityAdmin indicates that an endpoint is only available to
	// administrators.
	AvailabilityAdmin Availability = "admin"

	// AvailabilityPublic indicates that an endpoint is available to everyone on
	// the internet.
	AvailabilityPublic Availability = "public"

	// AvailabilityInternal indicates that an endpoint is only available within
	// the cluster's internal network.
	AvailabilityInternal Availability = "internal"
)

type Config

type Config struct {
	// Timeout specifies a time limit for requests made by this
	// Client. The timeout includes connection time, any
	// redirects, and reading the response body. The timer remains
	// running after Get, Head, Post, or Do return and will
	// interrupt reading of the Response.Body.
	//
	// A Timeout of zero means no timeout.
	Timeout time.Duration `default:"10000000000"`
	// Transport specifies the mechanism by which individual
	// HTTP requests are made.
	// If nil, DefaultTransport is used.
	HttpTransport *http.Transport `default:""`
}

Config define the configs parameter of the provider client .

func NewConfig

func NewConfig() (config *Config)

NewConfig return Config instance with its default tag.

func (*Config) WithHttpTransport

func (c *Config) WithHttpTransport(httpTransport *http.Transport) *Config

WithHttpTransport customizes the http transport.

func (*Config) WithTimeout

func (c *Config) WithTimeout(timeout time.Duration) *Config

WithTimeout customizes the http connection timeout.

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
)

Convenience vars for EnabledState values.

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.

type EndpointOpts

type EndpointOpts struct {
	// Type [required] is the service type for the client (e.g., "compute",
	// "object-store"). 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., "nova") 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 string

	// Availability [optional] is the visibility of the endpoint to be returned.
	// Valid types include the constants AvailabilityPublic, AvailabilityInternal,
	// or AvailabilityAdmin from this package.
	//
	// Availability is not required, and defaults to AvailabilityPublic. Not all
	// providers or services offer all Availability options.
	Availability Availability
}

EndpointOpts specifies search criteria used by queries against an OpenStack service catalog. 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 "openstack.NewComputeV2()".

func (*EndpointOpts) ApplyDefaults

func (eo *EndpointOpts) ApplyDefaults(t string)

ApplyDefaults is an internal method to be used by provider implementations.

It sets EndpointOpts fields if not already set, including a default type. Currently, EndpointOpts.Availability defaults to the public endpoint.

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 (ErrResult) ExtractErr

func (r ErrResult) ExtractErr() error

ExtractErr is a function that extracts error information, or nil, from a result.

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 (HeaderResult) ExtractInto

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

ExtractInto allows users to provide an object into which `Extract` will extract the http.Header headers of the result.

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 JSONRFC1123

type JSONRFC1123 time.Time

func (*JSONRFC1123) UnmarshalJSON

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

type JSONRFC3339Milli

type JSONRFC3339Milli time.Time

func (*JSONRFC3339Milli) UnmarshalJSON

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

type JSONRFC3339MilliNoZ

type JSONRFC3339MilliNoZ time.Time

func (*JSONRFC3339MilliNoZ) UnmarshalJSON

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

type JSONRFC3339NoZ

type JSONRFC3339NoZ time.Time

func (*JSONRFC3339NoZ) UnmarshalJSON

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

type JSONUnix

type JSONUnix time.Time

func (*JSONUnix) UnmarshalJSON

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 Logger

type Logger struct {
	DebugEnable bool `default:"false"`
}

Logger, define the logger struct.

func GetLogger

func GetLogger() *Logger

GetLogger ,Return log initialization structure instance.

func (*Logger) Debug

func (log *Logger) Debug(format string, v ...interface{})

Debug, Format the log information and print the information to the console.

type OneLevelError

type OneLevelError struct {
	Message    string
	Request_id string
	ErrCode    string `json:"error_code"`
	ErrMsg     string `json:"error_msg"`
	Code       string `json:"code"`
}

OneLevelError,Define the error code structure and match the error code of one layer of json structure

type ProviderClient

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

	// IdentityEndpoint 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

	// TokenID is the ID of the most recently issued valid token.
	// NOTE: Aside from within a custom ReauthFunc, this field shouldn't be set by an application.
	// To safely read or write this value, call `Token` or `SetToken`, respectively
	TokenID 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

	// DomainID
	DomainID string

	// ProjectID
	ProjectID string

	// Conf define the configs parameter of the provider client
	Conf *Config

	// AKSKAuthOptions provides the value for AK/SK authentication, it should be nil if you use token authentication,
	// Otherwise, it must have a value
	AKSKOptions aksk.AKSKOptions
	// 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 (*ProviderClient) AuthenticatedHeaders

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

AuthenticatedHeaders returns a map of HTTP headers that are common for all authenticated service requests.

func (*ProviderClient) GetProjectID

func (client *ProviderClient) GetProjectID() string

GetProjectID,Implement the GetProjectID() interface, return client projectID.

func (*ProviderClient) Reauthenticate

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

Reauthenticate calls client.ReauthFunc in a thread-safe way. If this is called because of a 401 response, the caller may pass the previous token. In this case, the reauthentication can be skipped if another thread has already reauthenticated in the meantime. If no previous token is known, an empty string should be passed instead to force unconditional reauthentication.

func (*ProviderClient) Request

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

Request performs an HTTP request using the ProviderClient's current HTTPClient. An authentication header will automatically be provided.

func (*ProviderClient) SetToken

func (client *ProviderClient) SetToken(t string)

SetToken safely sets the value of the auth token in the ProviderClient. Applications may use this method in a custom ReauthFunc

func (*ProviderClient) Token

func (client *ProviderClient) Token() string

Token safely reads the value of the auth token from the ProviderClient. Applications should call this method to access the token instead of the TokenID field

func (*ProviderClient) UseTokenLock

func (client *ProviderClient) UseTokenLock()

UseTokenLock creates a mutex that is used to allow safe concurrent access to the auth token. If the application's ProviderClient is not used concurrently, this doesn't need to be called.

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
}

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 (Result) ExtractInto

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

ExtractInto allows users to provide an object into which `Extract` will extract the `Result.Body`. This would be useful for OpenStack providers that have different fields in the response object than OpenStack proper.

func (Result) ExtractIntoSlicePtr

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

ExtractIntoSlicePtr will unmarshal the Result (r) into the provided interface{} (to).

NOTE: For internal use only

`to` must be a pointer to an underlying slice type

If provided, `label` will be filtered out of the response body prior to `r` being unmarshalled into `to`.

func (Result) ExtractIntoStructPtr

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

ExtractIntoStructPtr will unmarshal the Result (r) into the provided interface{} (to).

NOTE: For internal use only

`to` must be a pointer to an underlying struct type

If provided, `label` will be filtered out of the response body prior to `r` being unmarshalled into `to`.

func (Result) PrettyPrintJSON

func (r Result) PrettyPrintJSON() string

PrettyPrintJSON creates a string containing the full response body as pretty-printed JSON. It's useful for capturing test fixtures and for debugging extraction bugs. If you include its output in an issue related to a buggy extraction function, we will all love you forever.

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. compute, sharev2).
	// NOTE: FOR INTERNAL USE ONLY. DO NOT SET. GOPHERCLOUD WILL SET THIS.
	// It is only exported because it gets set in a different package.
	Type string

	// The microversion of the service to use. Set this to use a particular microversion.
	Microversion string
	// contains filtered or unexported fields
}

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 (*ServiceClient) Delete

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

Delete calls `Request` with the "DELETE" HTTP verb.

func (*ServiceClient) Get

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

Get calls `Request` with the "GET" HTTP verb.

func (*ServiceClient) Head

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

Head calls `Request` with the "HEAD" HTTP verb.

func (*ServiceClient) Patch

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

Patch calls `Request` with the "PATCH" HTTP verb.

func (*ServiceClient) Post

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

Post calls `Request` with the "POST" HTTP verb.

func (*ServiceClient) Put

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

Put calls `Request` with the "PUT" HTTP verb.

func (*ServiceClient) ResourceBaseURL

func (client *ServiceClient) ResourceBaseURL() string

ResourceBaseURL returns the base URL of any resources used by this service. It MUST end with a /.

func (*ServiceClient) ServiceURL

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

ServiceURL constructs a URL for a resource belonging to this provider.

func (*ServiceClient) SetMicroversion

func (client *ServiceClient) SetMicroversion(microversion string)

SetMicroversion,Set the service micro version field.

func (*ServiceClient) UnsetMicroversion

func (client *ServiceClient) UnsetMicroversion()

UnsetMicroversion,Unset the service micro version field.

type UnifiedError

type UnifiedError struct {
	ErrCode    interface{} `json:"code"`
	ErrMessage string      `json:"message"`
}

UnifiedError, Unified definition of backend errors.

func (UnifiedError) Error

func (e UnifiedError) Error() string

Error,Implement the Error() interface.

func (UnifiedError) ErrorCode

func (e UnifiedError) ErrorCode() string

ErrorCode,Error code converted to string type.

func (UnifiedError) Message

func (e UnifiedError) Message() string

Message,Return error message.

type UserAgent

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

UserAgent represents a User-Agent header.

func (*UserAgent) Join

func (ua *UserAgent) Join() string

Join concatenates all the user-defined User-Agend strings with the default Gophercloud User-Agent string.

func (*UserAgent) Prepend

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

Prepend prepends a user-defined string to the default User-Agent string. Users may pass in one or more strings to prepend.