gophercloud: github.com/gophercloud/gophercloud Index | Files | Directories

package gophercloud

import "github.com/gophercloud/gophercloud"

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 := gophercloud.AuthOptions{
  IdentityEndpoint: "https://openstack.example.com:5000/v2.0",
  Username: "{username}",
  Password: "{password}",
  TenantID: "{tenant_id}",
}

provider, err := openstack.AuthenticatedClient(opts)

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

Package Files

auth_options.go doc.go endpoint_search.go errors.go params.go provider_client.go results.go service_client.go util.go

Constants

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).

func BuildHeaders Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 IntToPointer Uses

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 Uses

func IntWithinRange(val, min, max int) bool

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

func MaybeInt Uses

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 Uses

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 NormalizePathURL Uses

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 Uses

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 WaitFor Uses

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.

type AuthOptions Uses

type AuthOptions struct {
    // IdentityEndpoint specifies the HTTP endpoint that is required to work with
    // the Identity API of the appropriate version. While it's ultimately needed by
    // all of the identity services, it will often be populated by a provider-level
    // function.
    //
    // The IdentityEndpoint is typically referred to as the "auth_url" or
    // "OS_AUTH_URL" in the information provided by the cloud operator.
    IdentityEndpoint string `json:"-"`

    // Username is required if using Identity V2 API. Consult with your provider's
    // control panel to discover your account's username. In Identity V3, either
    // UserID or a combination of Username and DomainID or DomainName are needed.
    Username string `json:"username,omitempty"`
    UserID   string `json:"-"`

    Password string `json:"password,omitempty"`

    // At most one of DomainID and DomainName must be provided if using Username
    // with Identity V3. Otherwise, either are optional.
    DomainID   string `json:"-"`
    DomainName string `json:"name,omitempty"`

    // The TenantID and TenantName fields are optional for the Identity V2 API.
    // The same fields are known as project_id and project_name in the Identity
    // V3 API, but are collected as TenantID and TenantName here in both cases.
    // Some providers allow you to specify a TenantName instead of the TenantId.
    // Some require both. Your provider's authentication policies will determine
    // how these fields influence authentication.
    // If DomainID or DomainName are provided, they will also apply to TenantName.
    // It is not currently possible to authenticate with Username and a Domain
    // and scope to a Project in a different Domain by using TenantName. To
    // accomplish that, the ProjectID will need to be provided as the TenantID
    // option.
    TenantID   string `json:"tenantId,omitempty"`
    TenantName string `json:"tenantName,omitempty"`

    // AllowReauth should be set to true if you grant permission for Gophercloud to
    // cache your credentials in memory, and to allow Gophercloud to attempt to
    // re-authenticate automatically if/when your token expires.  If you set it to
    // false, it will not cache these settings, but re-authentication will not be
    // possible.  This setting defaults to false.
    //
    // NOTE: The reauth function will try to re-authenticate endlessly if left
    // unchecked. The way to limit the number of attempts is to provide a custom
    // HTTP client to the provider client and provide a transport that implements
    // the RoundTripper interface and stores the number of failed retries. For an
    // example of this, see here:
    // https://github.com/rackspace/rack/blob/1.0.0/auth/clients.go#L311
    AllowReauth bool `json:"-"`

    // TokenID allows users to authenticate (possibly as another user) with an
    // authentication token ID.
    TokenID string `json:"-"`
}

AuthOptions stores information needed to authenticate to an OpenStack Cloud. You can populate one manually, or use a provider's AuthOptionsFromEnv() function to read relevant information from the standard environment variables. Pass one to a provider's AuthenticatedClient function to authenticate and obtain a ProviderClient representing an active session on that provider.

Its fields are the union of those recognized by each identity implementation and provider.

An example of manually providing authentication information:

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

provider, err := openstack.AuthenticatedClient(opts)

An example of using AuthOptionsFromEnv(), where the environment variables can be read from a file, such as a standard openrc file:

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

func (AuthOptions) CanReauth Uses

func (opts AuthOptions) CanReauth() bool

func (AuthOptions) ToTokenV2CreateMap Uses

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

ToTokenV2CreateMap allows AuthOptions to satisfy the AuthOptionsBuilder interface in the v2 tokens package

func (*AuthOptions) ToTokenV3CreateMap Uses

func (opts *AuthOptions) ToTokenV3CreateMap(scope map[string]interface{}) (map[string]interface{}, error)

func (*AuthOptions) ToTokenV3ScopeMap Uses

func (opts *AuthOptions) ToTokenV3ScopeMap() (map[string]interface{}, error)

type Availability Uses

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 BaseError Uses

type BaseError struct {
    DefaultErrString string
    Info             string
}

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

func (BaseError) Error Uses

func (e BaseError) Error() string

type EnabledState Uses

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 Uses

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 Uses

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 Uses

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 Err400er Uses

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 Uses

type Err401er interface {
    Error401(ErrUnexpectedResponseCode) error
}

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

type Err404er Uses

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 Uses

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 Uses

type Err408er interface {
    Error408(ErrUnexpectedResponseCode) error
}

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

type Err429er Uses

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 Uses

type Err500er interface {
    Error500(ErrUnexpectedResponseCode) error
}

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

type Err503er Uses

type Err503er interface {
    Error503(ErrUnexpectedResponseCode) error
}

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

type ErrAPIKeyProvided Uses

type ErrAPIKeyProvided struct{ BaseError }

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

func (ErrAPIKeyProvided) Error Uses

func (e ErrAPIKeyProvided) Error() string

type ErrDefault400 Uses

type ErrDefault400 struct {
    ErrUnexpectedResponseCode
}

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

func (ErrDefault400) Error Uses

func (e ErrDefault400) Error() string

type ErrDefault401 Uses

type ErrDefault401 struct {
    ErrUnexpectedResponseCode
}

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

func (ErrDefault401) Error Uses

func (e ErrDefault401) Error() string

type ErrDefault404 Uses

type ErrDefault404 struct {
    ErrUnexpectedResponseCode
}

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

func (ErrDefault404) Error Uses

func (e ErrDefault404) Error() string

type ErrDefault405 Uses

type ErrDefault405 struct {
    ErrUnexpectedResponseCode
}

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

func (ErrDefault405) Error Uses

func (e ErrDefault405) Error() string

type ErrDefault408 Uses

type ErrDefault408 struct {
    ErrUnexpectedResponseCode
}

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

func (ErrDefault408) Error Uses

func (e ErrDefault408) Error() string

type ErrDefault429 Uses

type ErrDefault429 struct {
    ErrUnexpectedResponseCode
}

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

func (ErrDefault429) Error Uses

func (e ErrDefault429) Error() string

type ErrDefault500 Uses

type ErrDefault500 struct {
    ErrUnexpectedResponseCode
}

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

func (ErrDefault500) Error Uses

func (e ErrDefault500) Error() string

type ErrDefault503 Uses

type ErrDefault503 struct {
    ErrUnexpectedResponseCode
}

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

func (ErrDefault503) Error Uses

func (e ErrDefault503) Error() string

type ErrDomainIDOrDomainName Uses

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 (ErrDomainIDOrDomainName) Error Uses

func (e ErrDomainIDOrDomainName) Error() string

type ErrDomainIDWithToken Uses

type ErrDomainIDWithToken struct{ BaseError }

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

func (ErrDomainIDWithToken) Error Uses

func (e ErrDomainIDWithToken) Error() string

type ErrDomainIDWithUserID Uses

type ErrDomainIDWithUserID struct{ BaseError }

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

func (ErrDomainIDWithUserID) Error Uses

func (e ErrDomainIDWithUserID) Error() string

type ErrDomainNameWithToken Uses

type ErrDomainNameWithToken struct{ BaseError }

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

func (ErrDomainNameWithToken) Error Uses

func (e ErrDomainNameWithToken) Error() string

type ErrDomainNameWithUserID Uses

type ErrDomainNameWithUserID struct{ BaseError }

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

func (ErrDomainNameWithUserID) Error Uses

func (e ErrDomainNameWithUserID) Error() string

type ErrEndpointNotFound Uses

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 (ErrEndpointNotFound) Error Uses

func (e ErrEndpointNotFound) Error() string

type ErrErrorAfterReauthentication Uses

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 (ErrErrorAfterReauthentication) Error Uses

func (e ErrErrorAfterReauthentication) Error() string

type ErrInvalidInput Uses

type ErrInvalidInput struct {
    ErrMissingInput
    Value interface{}
}

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

func (ErrInvalidInput) Error Uses

func (e ErrInvalidInput) Error() string

type ErrMissingInput Uses

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 (ErrMissingInput) Error Uses

func (e ErrMissingInput) Error() string

type ErrMissingPassword Uses

type ErrMissingPassword struct{ BaseError }

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

func (ErrMissingPassword) Error Uses

func (e ErrMissingPassword) Error() string

type ErrMultipleResourcesFound Uses

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 (ErrMultipleResourcesFound) Error Uses

func (e ErrMultipleResourcesFound) Error() string

type ErrResourceNotFound Uses

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 (ErrResourceNotFound) Error Uses

func (e ErrResourceNotFound) Error() string

type ErrResult Uses

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 Uses

func (r ErrResult) ExtractErr() error

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

type ErrScopeDomainIDOrDomainName Uses

type ErrScopeDomainIDOrDomainName struct{ BaseError }

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

func (ErrScopeDomainIDOrDomainName) Error Uses

func (e ErrScopeDomainIDOrDomainName) Error() string

type ErrScopeEmpty Uses

type ErrScopeEmpty struct{ BaseError }

ErrScopeEmpty indicates that no credentials were provided in a Scope.

func (ErrScopeEmpty) Error Uses

func (e ErrScopeEmpty) Error() string

type ErrScopeProjectIDAlone Uses

type ErrScopeProjectIDAlone struct{ BaseError }

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

func (ErrScopeProjectIDAlone) Error Uses

func (e ErrScopeProjectIDAlone) Error() string

type ErrScopeProjectIDOrProjectName Uses

type ErrScopeProjectIDOrProjectName struct{ BaseError }

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

func (ErrScopeProjectIDOrProjectName) Error Uses

func (e ErrScopeProjectIDOrProjectName) Error() string

type ErrServiceNotFound Uses

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 (ErrServiceNotFound) Error Uses

func (e ErrServiceNotFound) Error() string

type ErrTenantIDProvided Uses

type ErrTenantIDProvided struct{ BaseError }

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

func (ErrTenantIDProvided) Error Uses

func (e ErrTenantIDProvided) Error() string

type ErrTenantNameProvided Uses

type ErrTenantNameProvided struct{ BaseError }

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

func (ErrTenantNameProvided) Error Uses

func (e ErrTenantNameProvided) Error() string

type ErrTimeOut Uses

type ErrTimeOut struct {
    BaseError
}

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

func (ErrTimeOut) Error Uses

func (e ErrTimeOut) Error() string

type ErrUnableToReauthenticate Uses

type ErrUnableToReauthenticate struct {
    BaseError
    ErrOriginal error
}

ErrUnableToReauthenticate is the error type returned when reauthentication fails.

func (ErrUnableToReauthenticate) Error Uses

func (e ErrUnableToReauthenticate) Error() string

type ErrUnexpectedResponseCode Uses

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 (ErrUnexpectedResponseCode) Error Uses

func (e ErrUnexpectedResponseCode) Error() string

type ErrUnexpectedType Uses

type ErrUnexpectedType struct {
    BaseError
    Expected string
    Actual   string
}

ErrUnexpectedType is the error when an unexpected type is encountered

func (ErrUnexpectedType) Error Uses

func (e ErrUnexpectedType) Error() string

type ErrUserIDWithToken Uses

type ErrUserIDWithToken struct{ BaseError }

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

func (ErrUserIDWithToken) Error Uses

func (e ErrUserIDWithToken) Error() string

type ErrUsernameOrUserID Uses

type ErrUsernameOrUserID struct{ BaseError }

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

func (ErrUsernameOrUserID) Error Uses

func (e ErrUsernameOrUserID) Error() string

type ErrUsernameWithToken Uses

type ErrUsernameWithToken struct{ BaseError }

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

func (ErrUsernameWithToken) Error Uses

func (e ErrUsernameWithToken) Error() string

type HeaderResult Uses

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 Uses

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 Uses

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 Uses

type JSONRFC1123 time.Time

func (*JSONRFC1123) UnmarshalJSON Uses

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

type JSONRFC3339Milli Uses

type JSONRFC3339Milli time.Time

func (*JSONRFC3339Milli) UnmarshalJSON Uses

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

type JSONRFC3339MilliNoZ Uses

type JSONRFC3339MilliNoZ time.Time

func (*JSONRFC3339MilliNoZ) UnmarshalJSON Uses

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

type JSONRFC3339NoZ Uses

type JSONRFC3339NoZ time.Time

func (*JSONRFC3339NoZ) UnmarshalJSON Uses

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

type JSONUnix Uses

type JSONUnix time.Time

func (*JSONUnix) UnmarshalJSON Uses

func (jt *JSONUnix) UnmarshalJSON(data []byte) error
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 ProviderClient Uses

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.
    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

    Debug bool
}

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 Uses

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

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

func (*ProviderClient) Request Uses

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.

type RequestOpts Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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
}

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 Uses

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

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

func (*ServiceClient) Get Uses

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

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

func (*ServiceClient) Patch Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

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

type UserAgent Uses

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

UserAgent represents a User-Agent header.

func (*UserAgent) Join Uses

func (ua *UserAgent) Join() string

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

func (*UserAgent) Prepend Uses

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.

Directories

PathSynopsis
internal
internal/testing
openstackPackage openstack contains resources for the individual OpenStack projects supported in Gophercloud.
openstack/blockstorage/extensions/schedulerstatsPackage schedulerstats returns information about block storage pool capacity and utilisation.
openstack/blockstorage/extensions/schedulerstats/testing
openstack/blockstorage/extensions/volumeactionsPackage volumeactions provides information and interaction with volumes in the OpenStack Block Storage service.
openstack/blockstorage/extensions/volumeactions/testingvolumeactions unit tests
openstack/blockstorage/extensions/volumetenantsPackage volumetenants provides the ability to extend a volume result with tenant/project information.
openstack/blockstorage/v1/apiversionsPackage apiversions provides information and interaction with the different API versions for the OpenStack Block Storage service, code-named Cinder.
openstack/blockstorage/v1/apiversions/testingapiversions_v1
openstack/blockstorage/v1/snapshotsPackage snapshots provides information and interaction with snapshots in the OpenStack Block Storage service.
openstack/blockstorage/v1/snapshots/testingsnapshots_v1
openstack/blockstorage/v1/volumesPackage volumes provides information and interaction with volumes in the OpenStack Block Storage service.
openstack/blockstorage/v1/volumes/testingvolumes_v1
openstack/blockstorage/v1/volumetypesPackage volumetypes provides information and interaction with volume types in the OpenStack Block Storage service.
openstack/blockstorage/v1/volumetypes/testingvolumetypes_v1
openstack/blockstorage/v2/snapshotsPackage snapshots provides information and interaction with snapshots in the OpenStack Block Storage service.
openstack/blockstorage/v2/snapshots/testingsnapshots_v2
openstack/blockstorage/v2/volumesPackage volumes provides information and interaction with volumes in the OpenStack Block Storage service.
openstack/blockstorage/v2/volumes/testingvolumes_v2
openstack/common/extensionsPackage extensions provides information and interaction with the different extensions available for an OpenStack service.
openstack/common/extensions/testingcommon extensions unit tests
openstack/compute/v2/extensionsPackage extensions provides information and interaction with the different extensions available for the OpenStack Compute service.
openstack/compute/v2/extensions/attachinterfacesPackage attachinterfaces provides the ability to retrieve and manage network interfaces through Nova.
openstack/compute/v2/extensions/attachinterfaces/testingattachinterfaces unit tests
openstack/compute/v2/extensions/availabilityzonesPackage availabilityzones provides the ability to extend a server result with availability zone information.
openstack/compute/v2/extensions/bootfromvolumePackage bootfromvolume extends a server create request with the ability to specify block device options.
openstack/compute/v2/extensions/bootfromvolume/testingbootfromvolume unit tests
openstack/compute/v2/extensions/defsecrulesPackage defsecrules enables management of default security group rules.
openstack/compute/v2/extensions/defsecrules/testingdefsecrules unit tests
openstack/compute/v2/extensions/diskconfigPackage diskconfig provides information and interaction with the Disk Config extension that works with the OpenStack Compute service.
openstack/compute/v2/extensions/diskconfig/testingdiskconfig unit tests
openstack/compute/v2/extensions/evacuatePackage evacuate provides functionality to evacuates servers that have been provisioned by the OpenStack Compute service from a failed host to a new host.
openstack/compute/v2/extensions/evacuate/testingcompute_extensions_evacuate_v2
openstack/compute/v2/extensions/floatingipsPackage floatingips provides the ability to manage floating ips through the Nova API.
openstack/compute/v2/extensions/floatingips/testingfloatingips unit tests
openstack/compute/v2/extensions/hypervisorsPackage hypervisors returns details about the hypervisors in the OpenStack cloud.
openstack/compute/v2/extensions/hypervisors/testing
openstack/compute/v2/extensions/keypairsPackage keypairs provides the ability to manage key pairs as well as create servers with a specified key pair.
openstack/compute/v2/extensions/keypairs/testingkeypairs unit tests
openstack/compute/v2/extensions/limitsPackage limits shows rate and limit information for a tenant/project.
openstack/compute/v2/extensions/limits/testing
openstack/compute/v2/extensions/lockunlockPackage lockunlock provides functionality to lock and unlock servers that have been provisioned by the OpenStack Compute service.
openstack/compute/v2/extensions/lockunlock/testingunlocklock unit tests
openstack/compute/v2/extensions/migratePackage migrate provides functionality to migrate servers that have been provisioned by the OpenStack Compute service.
openstack/compute/v2/extensions/migrate/testingcompute_extensions_startstop_v2
openstack/compute/v2/extensions/networksPackage networks provides the ability to create and manage networks in cloud environments using nova-network.
openstack/compute/v2/extensions/networks/testingcompute_extensions_networks_v2
openstack/compute/v2/extensions/pauseunpausePackage pauseunpause provides functionality to pause and unpause servers that have been provisioned by the OpenStack Compute service.
openstack/compute/v2/extensions/pauseunpause/testingpauseunpause unit tests
openstack/compute/v2/extensions/quotasetsPackage quotasets enables retrieving and managing Compute quotas.
openstack/compute/v2/extensions/quotasets/testingquotasets unit tests
openstack/compute/v2/extensions/resetstatePackage resetstate provides functionality to reset the state of a server that has been provisioned by the OpenStack Compute service.
openstack/compute/v2/extensions/resetstate/testing
openstack/compute/v2/extensions/schedulerhintsPackage schedulerhints extends the server create request with the ability to specify additional parameters which determine where the server will be created in the OpenStack cloud.
openstack/compute/v2/extensions/schedulerhints/testingschedulerhints unit tests
openstack/compute/v2/extensions/secgroupsPackage secgroups provides the ability to manage security groups through the Nova API.
openstack/compute/v2/extensions/secgroups/testingsecgroups unit tests
openstack/compute/v2/extensions/servergroupsPackage servergroups provides the ability to manage server groups.
openstack/compute/v2/extensions/servergroups/testingservergroups unit tests
openstack/compute/v2/extensions/startstopPackage startstop provides functionality to start and stop servers that have been provisioned by the OpenStack Compute service.
openstack/compute/v2/extensions/startstop/testingstartstop unit tests
openstack/compute/v2/extensions/suspendresumePackage suspendresume provides functionality to suspend and resume servers that have been provisioned by the OpenStack Compute service.
openstack/compute/v2/extensions/suspendresume/testingsuspendresume unit tests
openstack/compute/v2/extensions/tenantnetworksPackage tenantnetworks provides the ability for tenants to see information about the networks they have access to.
openstack/compute/v2/extensions/tenantnetworks/testingtenantnetworks unit tests
openstack/compute/v2/extensions/testingextensions unit tests
openstack/compute/v2/extensions/volumeattachPackage volumeattach provides the ability to attach and detach volumes from servers.
openstack/compute/v2/extensions/volumeattach/testingvolumeattach unit tests
openstack/compute/v2/flavorsPackage flavors provides information and interaction with the flavor API in the OpenStack Compute service.
openstack/compute/v2/flavors/testingflavors unit tests
openstack/compute/v2/imagesPackage images provides information and interaction with the images through the OpenStack Compute service.
openstack/compute/v2/images/testingimages unit tests
openstack/compute/v2/serversPackage servers provides information and interaction with the server API resource in the OpenStack Compute service.
openstack/compute/v2/servers/testingservers unit tests
openstack/dns/v2/recordsetsPackage recordsets provides information and interaction with the zone API resource for the OpenStack DNS service.
openstack/dns/v2/recordsets/testingrecordsets unit tests
openstack/dns/v2/zonesPackage zones provides information and interaction with the zone API resource for the OpenStack DNS service.
openstack/dns/v2/zones/testingzones unit tests
openstack/identity/v2/extensionsPackage extensions provides information and interaction with the different extensions available for the OpenStack Identity service.
openstack/identity/v2/extensions/admin/rolesPackage roles provides functionality to interact with and control roles on the API.
openstack/identity/v2/extensions/admin/roles/testingroles unit tests
openstack/identity/v2/extensions/testingextensions unit tests
openstack/identity/v2/tenantsPackage tenants provides information and interaction with the tenants API resource for the OpenStack Identity service.
openstack/identity/v2/tenants/testingtenants unit tests
openstack/identity/v2/tokensPackage tokens provides information and interaction with the token API resource for the OpenStack Identity service.
openstack/identity/v2/tokens/testingtokens unit tests
openstack/identity/v2/usersPackage users provides information and interaction with the users API resource for the OpenStack Identity Service.
openstack/identity/v2/users/testingusers unit tests
openstack/identity/v3/endpointsPackage endpoints provides information and interaction with the service endpoints API resource in the OpenStack Identity service.
openstack/identity/v3/endpoints/testingendpoints unit tests
openstack/identity/v3/extensions/trustsPackage trusts enables management of OpenStack Identity Trusts.
openstack/identity/v3/extensions/trusts/testingtrusts unit tests
openstack/identity/v3/groupsPackage groups manages and retrieves Groups in the OpenStack Identity Service.
openstack/identity/v3/groups/testing
openstack/identity/v3/projectsPackage projects manages and retrieves Projects in the OpenStack Identity Service.
openstack/identity/v3/projects/testing
openstack/identity/v3/rolesPackage roles provides information and interaction with the roles API resource for the OpenStack Identity service.
openstack/identity/v3/roles/testingroles unit tests
openstack/identity/v3/servicesPackage services provides information and interaction with the services API resource for the OpenStack Identity service.
openstack/identity/v3/services/testingservices unit tests
openstack/identity/v3/tokensPackage tokens provides information and interaction with the token API resource for the OpenStack Identity service.
openstack/identity/v3/tokens/testingtokens unit tests
openstack/identity/v3/usersPackage users manages and retrieves Users in the OpenStack Identity Service.
openstack/identity/v3/users/testing
openstack/imageservice/v2/imagedataPackage imagedata enables management of image data.
openstack/imageservice/v2/imagedata/testingimagedata unit tests
openstack/imageservice/v2/imagesPackage images enables management and retrieval of images from the OpenStack Image Service.
openstack/imageservice/v2/images/testingimages unit tests
openstack/imageservice/v2/membersPackage members enables management and retrieval of image members.
openstack/imageservice/v2/members/testingmembers unit tests
openstack/networking/v2/apiversionsPackage apiversions provides information and interaction with the different API versions for the OpenStack Neutron service.
openstack/networking/v2/apiversions/testingapiversions unit tests
openstack/networking/v2/common
openstack/networking/v2/extensions
openstack/networking/v2/extensions/externalPackage external provides information and interaction with the external extension for the OpenStack Networking service.
openstack/networking/v2/extensions/external/testingnetworking_extensions_external_v2
openstack/networking/v2/extensions/fwaasPackage fwaas provides information and interaction with the Firewall as a Service extension for the OpenStack Networking service.
openstack/networking/v2/extensions/fwaas/firewallsPackage firewalls allows management and retrieval of firewalls from the OpenStack Networking Service.
openstack/networking/v2/extensions/fwaas/firewalls/testingfirewalls unit tests
openstack/networking/v2/extensions/fwaas/policies
openstack/networking/v2/extensions/fwaas/policies/testingpolicies unit tests
openstack/networking/v2/extensions/fwaas/routerinsertionPackage routerinsertion implements the fwaasrouterinsertion Firewall extension.
openstack/networking/v2/extensions/fwaas/routerinsertion/testingrouterinsertion unit tests
openstack/networking/v2/extensions/fwaas/rulesPackage rules enables management and retrieval of Firewall Rules in the OpenStack Networking Service.
openstack/networking/v2/extensions/fwaas/rules/testingnetworking_extensions_fwaas_rules_v2
openstack/networking/v2/extensions/layer3Package layer3 provides access to the Layer-3 networking extension for the OpenStack Neutron service.
openstack/networking/v2/extensions/layer3/floatingipspackage floatingips enables management and retrieval of Floating IPs from the OpenStack Networking service.
openstack/networking/v2/extensions/layer3/floatingips/testingfloatingips unit tests
openstack/networking/v2/extensions/layer3/routersPackage routers enables management and retrieval of Routers from the OpenStack Networking service.
openstack/networking/v2/extensions/layer3/routers/testingrouters unit tests
openstack/networking/v2/extensions/lbaasPackage lbaas provides information and interaction with the Load Balancer as a Service extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas/membersPackage members provides information and interaction with Members of the Load Balancer as a Service extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas/members/testingmembers unit tests
openstack/networking/v2/extensions/lbaas/monitorsPackage monitors provides information and interaction with the Monitors of the Load Balancer as a Service extension for the OpenStack Networking Service.
openstack/networking/v2/extensions/lbaas/monitors/testingmonitors unit tests
openstack/networking/v2/extensions/lbaas/poolsPackage pools provides information and interaction with the Pools of the Load Balancing as a Service extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas/pools/testingpools unit tests
openstack/networking/v2/extensions/lbaas_v2Package lbaas_v2 provides information and interaction with the Load Balancer as a Service v2 extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas_v2/listenersPackage listeners provides information and interaction with Listeners of the LBaaS v2 extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas_v2/listeners/testingnetworking_extensions_lbaas_v2_listeners_v2
openstack/networking/v2/extensions/lbaas_v2/loadbalancersPackage loadbalancers provides information and interaction with Load Balancers of the LBaaS v2 extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas_v2/loadbalancers/testingloadbalancers unit tests
openstack/networking/v2/extensions/lbaas_v2/monitorsPackage monitors provides information and interaction with Monitors of the LBaaS v2 extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas_v2/monitors/testingmonitors unit tests
openstack/networking/v2/extensions/lbaas_v2/poolsPackage pools provides information and interaction with Pools and Members of the LBaaS v2 extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas_v2/pools/testingnetworking_extensions_lbaas_v2_pools_v2
openstack/networking/v2/extensions/lbaas/vipsPackage vips provides information and interaction with the Virtual IPs of the Load Balancing as a Service extension for the OpenStack Networking service.
openstack/networking/v2/extensions/lbaas/vips/testingnetworking_extensions_lbaas_vips_v2
openstack/networking/v2/extensions/portsbindingPackage portsbinding provides information and interaction with the port binding extension for the OpenStack Networking service.
openstack/networking/v2/extensions/portsbinding/testingportsbindings unit tests
openstack/networking/v2/extensions/providerPackage provider gives access to the provider Neutron plugin, allowing network extended attributes.
openstack/networking/v2/extensions/provider/testingprovider unit tests
openstack/networking/v2/extensions/securityPackage security contains functionality to work with security group and security group rules Neutron resources.
openstack/networking/v2/extensions/security/groupsPackage groups provides information and interaction with Security Groups for the OpenStack Networking service.
openstack/networking/v2/extensions/security/groups/testingnetworking_extensions_security_groups_v2
openstack/networking/v2/extensions/security/rulesPackage rules provides information and interaction with Security Group Rules for the OpenStack Networking service.
openstack/networking/v2/extensions/security/rules/testingrules unit tests
openstack/networking/v2/extensions/testingextensions unit tests
openstack/networking/v2/networksPackage networks contains functionality for working with Neutron network resources.
openstack/networking/v2/networks/testingnetworks unit tests
openstack/networking/v2/portsPackage ports contains functionality for working with Neutron port resources.
openstack/networking/v2/ports/testingports unit tests
openstack/networking/v2/subnetsPackage subnets contains functionality for working with Neutron subnet resources.
openstack/networking/v2/subnets/testingsubnets unit tests
openstack/objectstorage/v1/accountsPackage accounts contains functionality for working with Object Storage account resources.
openstack/objectstorage/v1/accounts/testingaccounts unit tests
openstack/objectstorage/v1/containersPackage containers contains functionality for working with Object Storage container resources.
openstack/objectstorage/v1/containers/testingcontainers unit tests
openstack/objectstorage/v1/objectsPackage objects contains functionality for working with Object Storage object resources.
openstack/objectstorage/v1/objects/testingobjects unit tests
openstack/objectstorage/v1/swauthPackage swauth implements Swift's built-in authentication.
openstack/objectstorage/v1/swauth/testingswauth unit tests
openstack/sharedfilesystems/apiversionsPackage apiversions provides information and interaction with the different API versions for the Shared File System service, code-named Manila.
openstack/sharedfilesystems/apiversions/testingapiversions_v1
openstack/sharedfilesystems/v2/availabilityzones
openstack/sharedfilesystems/v2/availabilityzones/testing
openstack/sharedfilesystems/v2/securityservices
openstack/sharedfilesystems/v2/securityservices/testing
openstack/sharedfilesystems/v2/sharenetworks
openstack/sharedfilesystems/v2/sharenetworks/testing
openstack/sharedfilesystems/v2/shares
openstack/sharedfilesystems/v2/shares/testing
openstack/sharedfilesystems/v2/sharetypes
openstack/sharedfilesystems/v2/sharetypes/testing
openstack/testingopenstack
openstack/utils
openstack/utils/testingutils
paginationPackage pagination contains utilities and convenience structs that implement common pagination idioms within OpenStack APIs.
pagination/testingpagination
testhelperPackage testhelper container methods that are useful for writing unit tests.
testhelper/client
testhelper/fixture
testinggophercloud

Package gophercloud imports 12 packages (graph) and is imported by 156 packages. Updated 2017-11-21. Refresh now. Tools for package owners.