README

Gophercloud: an OpenStack SDK for Go

Build Status Coverage Status

Gophercloud is an OpenStack Go SDK.

How to install

Before installing, you need to ensure that your GOPATH environment variable is pointing to an appropriate directory where you want to install Gophercloud:

mkdir $HOME/go
export GOPATH=$HOME/go

To protect yourself against changes in your dependencies, we highly recommend choosing a dependency management solution for your projects, such as godep. Once this is set up, you can install Gophercloud as a dependency like so:

go get github.com/gophercloud/gophercloud

# Edit your code to import relevant packages from "github.com/gophercloud/gophercloud"

godep save ./...

This will install all the source files you need into a Godeps/_workspace directory, which is referenceable from your own source files when you use the godep go command.

Getting started

Credentials

Because you'll be hitting an API, you will need to retrieve your OpenStack credentials and either store them as environment variables or in your local Go files. The first method is recommended because it decouples credential information from source code, allowing you to push the latter to your version control system without any security risk.

You will need to retrieve the following:

  • username
  • password
  • a valid Keystone identity URL

For users that have the OpenStack dashboard installed, there's a shortcut. If you visit the project/access_and_security path in Horizon and click on the "Download OpenStack RC File" button at the top right hand corner, you will download a bash file that exports all of your access details to environment variables. To execute the file, run source admin-openrc.sh and you will be prompted for your password.

Authentication

NOTE: It is now recommended to use the clientconfig package found at https://github.com/gophercloud/utils/tree/master/openstack/clientconfig for all authentication purposes.

The below documentation is still relevant. clientconfig simply implements the below and presents it in an easier and more flexible way.

Once you have access to your credentials, you can begin plugging them into Gophercloud. The next step is authentication, and this is handled by a base "Provider" struct. To get one, you can either pass in your credentials explicitly, or tell Gophercloud to use environment variables:

import (
  "github.com/gophercloud/gophercloud"
  "github.com/gophercloud/gophercloud/openstack"
  "github.com/gophercloud/gophercloud/openstack/utils"
)

// Option 1: Pass in the values yourself
opts := gophercloud.AuthOptions{
  IdentityEndpoint: "https://openstack.example.com:5000/v2.0",
  Username: "{username}",
  Password: "{password}",
}

// Option 2: Use a utility function to retrieve all your environment variables
opts, err := openstack.AuthOptionsFromEnv()

Once you have the opts variable, you can pass it in and get back a ProviderClient struct:

provider, err := openstack.AuthenticatedClient(opts)

The ProviderClient is the top-level client that all of your OpenStack services derive from. The provider contains all of the authentication details that allow your Go code to access the API - such as the base URL and token ID.

Provision a server

Once we have a base Provider, we inject it as a dependency into each OpenStack service. In order to work with the Compute API, we need a Compute service client; which can be created like so:

client, err := openstack.NewComputeV2(provider, gophercloud.EndpointOpts{
  Region: os.Getenv("OS_REGION_NAME"),
})

We then use this client for any Compute API operation we want. In our case, we want to provision a new server - so we invoke the Create method and pass in the flavor ID (hardware specification) and image ID (operating system) we're interested in:

import "github.com/gophercloud/gophercloud/openstack/compute/v2/servers"

server, err := servers.Create(client, servers.CreateOpts{
  Name:      "My new server!",
  FlavorRef: "flavor_id",
  ImageRef:  "image_id",
}).Extract()

The above code sample creates a new server with the parameters, and embodies the new resource in the server variable (a servers.Server struct).

Advanced Usage

Have a look at the FAQ for some tips on customizing the way Gophercloud works.

Backwards-Compatibility Guarantees

None. Vendor it and write tests covering the parts you use.

Contributing

See the contributing guide.

Help and feedback

If you're struggling with something or have spotted a potential bug, feel free to submit an issue to our bug tracker.

Thank You

We'd like to extend special thanks and appreciation to the following:

OpenLab

OpenLab is providing a full CI environment to test each PR and merge for a variety of OpenStack releases.

VEXXHOST

VEXXHOST is providing their services to assist with the development and testing of Gophercloud.

Expand ▾ Collapse ▴

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.

It is now recommended to use the `clientconfig` package found at
https://github.com/gophercloud/utils/tree/master/openstack/clientconfig
for all authentication purposes.

The below documentation is still relevant. clientconfig simply implements
the below and presents it in an easier and more flexible way.

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 can authenticate with a token by doing:

opts := gophercloud.AuthOptions{
	IdentityEndpoint: "https://openstack.example.com:5000/v2.0",
	TokenID:  "{token_id}",
	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, err := 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.

An example retry backoff function, which respects the 429 HTTP response code and a "Retry-After" header:

endpoint := "http://localhost:5000"
provider, err := openstack.NewClient(endpoint)
if err != nil {
	panic(err)
}
provider.MaxBackoffRetries = 3 // max three retries
provider.RetryBackoffFunc = func(ctx context.Context, respErr *ErrUnexpectedResponseCode, e error, retries uint) error {
	retryAfter := respErr.ResponseHeader.Get("Retry-After")
	if retryAfter == "" {
		return e
	}

	var sleep time.Duration

	// Parse delay seconds or HTTP date
	if v, err := strconv.ParseUint(retryAfter, 10, 32); err == nil {
		sleep = time.Duration(v) * time.Second
	} else if v, err := time.Parse(http.TimeFormat, retryAfter); err == nil {
		sleep = time.Until(v)
	} else {
		return e
	}

	if ctx != nil {
		select {
		case <-time.After(sleep):
		case <-ctx.Done():
			return e
		}
	} else {
		time.Sleep(sleep)
	}

	return nil
}

Index

Constants

View Source
const (
	DefaultUserAgent         = "gophercloud/2.0.0"
	DefaultMaxBackoffRetries = 60
)

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

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

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

      View Source
      const RFC3339MilliNoZ = "2006-01-02T15:04:05.999999"
      View Source
      const RFC3339NoZ = "2006-01-02T15:04:05"

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

        View Source
        const RFC3339ZNoT = "2006-01-02 15:04:05-07:00"

          RFC3339ZNoT is the time format used in Zun (Containers Service).

          View Source
          const RFC3339ZNoTNoZ = "2006-01-02 15:04:05"

            RFC3339ZNoTNoZ is another time format used in Zun (Containers Service).

            Variables

            This section is empty.

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

                                  func ParseResponse(resp *http.Response, err error) (io.ReadCloser, http.Header, error)

                                    ParseResponse is a helper function to parse http.Response to constituents.

                                    func RemainingKeys

                                    func RemainingKeys(s interface{}, m map[string]interface{}) (extras map[string]interface{})

                                      RemainingKeys will inspect a struct and compare it to a map. Any struct field that does not have a JSON tag that matches a key in the map or a matching lower-case field in the map will be returned as an extra.

                                      This is useful for determining the extra fields returned in response bodies for resources that can contain an arbitrary or dynamic number of fields.

                                      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 AuthOptions

                                        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"`
                                        
                                        	// Passcode is used in TOTP authentication method
                                        	Passcode string `json:"passcode,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:"-"`
                                        
                                        	// Scope determines the scoping of the authentication request.
                                        	Scope *AuthScope `json:"-"`
                                        
                                        	// Authentication through Application Credentials requires supplying name, project and secret
                                        	// For project we can use TenantID
                                        	ApplicationCredentialID     string `json:"-"`
                                        	ApplicationCredentialName   string `json:"-"`
                                        	ApplicationCredentialSecret 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

                                          func (opts AuthOptions) CanReauth() bool

                                          func (AuthOptions) ToTokenV2CreateMap

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

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

                                            func (*AuthOptions) ToTokenV3CreateMap

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

                                              ToTokenV3CreateMap allows AuthOptions to satisfy the AuthOptionsBuilder interface in the v3 tokens package

                                              func (*AuthOptions) ToTokenV3HeadersMap

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

                                                ToTokenV3HeadersMap allows AuthOptions to satisfy the AuthOptionsBuilder interface in the v3 tokens package.

                                                func (*AuthOptions) ToTokenV3ScopeMap

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

                                                  ToTokenV3ScopeMap builds a scope from AuthOptions and satisfies interface in the v3 tokens package.

                                                  type AuthResult

                                                  type AuthResult interface {
                                                  	ExtractTokenID() (string, error)
                                                  }

                                                    AuthResult is the result from the request that was used to obtain a provider client's Keystone token. It is returned from ProviderClient.GetAuthResult().

                                                    The following types satisfy this interface:

                                                    github.com/gophercloud/gophercloud/openstack/identity/v2/tokens.CreateResult
                                                    github.com/gophercloud/gophercloud/openstack/identity/v3/tokens.CreateResult
                                                    

                                                    Usage example:

                                                    import (
                                                    	"github.com/gophercloud/gophercloud"
                                                    	tokens2 "github.com/gophercloud/gophercloud/openstack/identity/v2/tokens"
                                                    	tokens3 "github.com/gophercloud/gophercloud/openstack/identity/v3/tokens"
                                                    )
                                                    
                                                    func GetAuthenticatedUserID(providerClient *gophercloud.ProviderClient) (string, error) {
                                                    	r := providerClient.GetAuthResult()
                                                    	if r == nil {
                                                    		//ProviderClient did not use openstack.Authenticate(), e.g. because token
                                                    		//was set manually with ProviderClient.SetToken()
                                                    		return "", errors.New("no AuthResult available")
                                                    	}
                                                    	switch r := r.(type) {
                                                    	case tokens2.CreateResult:
                                                    		u, err := r.ExtractUser()
                                                    		if err != nil {
                                                    			return "", err
                                                    		}
                                                    		return u.ID, nil
                                                    	case tokens3.CreateResult:
                                                    		u, err := r.ExtractUser()
                                                    		if err != nil {
                                                    			return "", err
                                                    		}
                                                    		return u.ID, nil
                                                    	default:
                                                    		panic(fmt.Sprintf("got unexpected AuthResult type %t", r))
                                                    	}
                                                    }
                                                    

                                                    Both implementing types share a lot of methods by name, like ExtractUser() in this example. But those methods cannot be part of the AuthResult interface because the return types are different (in this case, type tokens2.User vs. type tokens3.User).

                                                    type AuthScope

                                                    type AuthScope struct {
                                                    	ProjectID   string
                                                    	ProjectName string
                                                    	DomainID    string
                                                    	DomainName  string
                                                    	System      bool
                                                    }

                                                      AuthScope allows a created token to be limited to a specific domain or project.

                                                      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 BaseError

                                                        type BaseError struct {
                                                        	DefaultErrString string
                                                        	Info             string
                                                        }

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

                                                          func (BaseError) Error

                                                          func (e BaseError) Error() string

                                                          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 Err400er

                                                                    type Err400er interface {
                                                                    	Error400(ErrUnexpectedResponseCode) error
                                                                    }

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

                                                                      type Err401er

                                                                      type Err401er interface {
                                                                      	Error401(ErrUnexpectedResponseCode) error
                                                                      }

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

                                                                        type Err403er

                                                                        type Err403er interface {
                                                                        	Error403(ErrUnexpectedResponseCode) error
                                                                        }

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

                                                                          type Err404er

                                                                          type Err404er interface {
                                                                          	Error404(ErrUnexpectedResponseCode) error
                                                                          }

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

                                                                            type Err405er

                                                                            type Err405er interface {
                                                                            	Error405(ErrUnexpectedResponseCode) error
                                                                            }

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

                                                                              type Err408er

                                                                              type Err408er interface {
                                                                              	Error408(ErrUnexpectedResponseCode) error
                                                                              }

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

                                                                                type Err409er

                                                                                type Err409er interface {
                                                                                	Error409(ErrUnexpectedResponseCode) error
                                                                                }

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

                                                                                  type Err429er

                                                                                  type Err429er interface {
                                                                                  	Error429(ErrUnexpectedResponseCode) error
                                                                                  }

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

                                                                                    type Err500er

                                                                                    type Err500er interface {
                                                                                    	Error500(ErrUnexpectedResponseCode) error
                                                                                    }

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

                                                                                      type Err503er

                                                                                      type Err503er interface {
                                                                                      	Error503(ErrUnexpectedResponseCode) error
                                                                                      }

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

                                                                                        type ErrAPIKeyProvided

                                                                                        type ErrAPIKeyProvided struct{ BaseError }

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

                                                                                          func (ErrAPIKeyProvided) Error

                                                                                          func (e ErrAPIKeyProvided) Error() string

                                                                                          type ErrAppCredMissingSecret

                                                                                          type ErrAppCredMissingSecret struct{ BaseError }

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

                                                                                            func (ErrAppCredMissingSecret) Error

                                                                                            func (e ErrAppCredMissingSecret) Error() string

                                                                                            type ErrDefault400

                                                                                            type ErrDefault400 struct {
                                                                                            	ErrUnexpectedResponseCode
                                                                                            }

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

                                                                                              func (ErrDefault400) Error

                                                                                              func (e ErrDefault400) Error() string

                                                                                              type ErrDefault401

                                                                                              type ErrDefault401 struct {
                                                                                              	ErrUnexpectedResponseCode
                                                                                              }

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

                                                                                                func (ErrDefault401) Error

                                                                                                func (e ErrDefault401) Error() string

                                                                                                type ErrDefault403

                                                                                                type ErrDefault403 struct {
                                                                                                	ErrUnexpectedResponseCode
                                                                                                }

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

                                                                                                  func (ErrDefault403) Error

                                                                                                  func (e ErrDefault403) Error() string

                                                                                                  type ErrDefault404

                                                                                                  type ErrDefault404 struct {
                                                                                                  	ErrUnexpectedResponseCode
                                                                                                  }

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

                                                                                                    func (ErrDefault404) Error

                                                                                                    func (e ErrDefault404) Error() string

                                                                                                    type ErrDefault405

                                                                                                    type ErrDefault405 struct {
                                                                                                    	ErrUnexpectedResponseCode
                                                                                                    }

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

                                                                                                      func (ErrDefault405) Error

                                                                                                      func (e ErrDefault405) Error() string

                                                                                                      type ErrDefault408

                                                                                                      type ErrDefault408 struct {
                                                                                                      	ErrUnexpectedResponseCode
                                                                                                      }

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

                                                                                                        func (ErrDefault408) Error

                                                                                                        func (e ErrDefault408) Error() string

                                                                                                        type ErrDefault409

                                                                                                        type ErrDefault409 struct {
                                                                                                        	ErrUnexpectedResponseCode
                                                                                                        }

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

                                                                                                          type ErrDefault429

                                                                                                          type ErrDefault429 struct {
                                                                                                          	ErrUnexpectedResponseCode
                                                                                                          }

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

                                                                                                            func (ErrDefault429) Error

                                                                                                            func (e ErrDefault429) Error() string

                                                                                                            type ErrDefault500

                                                                                                            type ErrDefault500 struct {
                                                                                                            	ErrUnexpectedResponseCode
                                                                                                            }

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

                                                                                                              func (ErrDefault500) Error

                                                                                                              func (e ErrDefault500) Error() string

                                                                                                              type ErrDefault503

                                                                                                              type ErrDefault503 struct {
                                                                                                              	ErrUnexpectedResponseCode
                                                                                                              }

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

                                                                                                                func (ErrDefault503) Error

                                                                                                                func (e ErrDefault503) Error() string

                                                                                                                type ErrDomainIDOrDomainName

                                                                                                                type ErrDomainIDOrDomainName struct{ BaseError }

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

                                                                                                                  func (ErrDomainIDOrDomainName) Error

                                                                                                                  func (e ErrDomainIDOrDomainName) Error() string

                                                                                                                  type ErrDomainIDWithToken

                                                                                                                  type ErrDomainIDWithToken struct{ BaseError }

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

                                                                                                                    func (ErrDomainIDWithToken) Error

                                                                                                                    func (e ErrDomainIDWithToken) Error() string

                                                                                                                    type ErrDomainIDWithUserID

                                                                                                                    type ErrDomainIDWithUserID struct{ BaseError }

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

                                                                                                                      func (ErrDomainIDWithUserID) Error

                                                                                                                      func (e ErrDomainIDWithUserID) Error() string

                                                                                                                      type ErrDomainNameWithToken

                                                                                                                      type ErrDomainNameWithToken struct{ BaseError }

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

                                                                                                                        func (ErrDomainNameWithToken) Error

                                                                                                                        func (e ErrDomainNameWithToken) Error() string

                                                                                                                        type ErrDomainNameWithUserID

                                                                                                                        type ErrDomainNameWithUserID struct{ BaseError }

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

                                                                                                                          func (ErrDomainNameWithUserID) Error

                                                                                                                          func (e ErrDomainNameWithUserID) Error() string

                                                                                                                          type ErrEndpointNotFound

                                                                                                                          type ErrEndpointNotFound struct {
                                                                                                                          	BaseError
                                                                                                                          }

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

                                                                                                                            func (ErrEndpointNotFound) Error

                                                                                                                            func (e ErrEndpointNotFound) Error() string

                                                                                                                            type ErrErrorAfterReauthentication

                                                                                                                            type ErrErrorAfterReauthentication struct {
                                                                                                                            	BaseError
                                                                                                                            	ErrOriginal error
                                                                                                                            }

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

                                                                                                                              func (ErrErrorAfterReauthentication) Error

                                                                                                                              type ErrInvalidInput

                                                                                                                              type ErrInvalidInput struct {
                                                                                                                              	ErrMissingInput
                                                                                                                              	Value interface{}
                                                                                                                              }

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

                                                                                                                                func (ErrInvalidInput) Error

                                                                                                                                func (e ErrInvalidInput) Error() string

                                                                                                                                type ErrMissingAnyoneOfEnvironmentVariables

                                                                                                                                type ErrMissingAnyoneOfEnvironmentVariables struct {
                                                                                                                                	BaseError
                                                                                                                                	EnvironmentVariables []string
                                                                                                                                }

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

                                                                                                                                  func (ErrMissingAnyoneOfEnvironmentVariables) Error

                                                                                                                                  type ErrMissingEnvironmentVariable

                                                                                                                                  type ErrMissingEnvironmentVariable struct {
                                                                                                                                  	BaseError
                                                                                                                                  	EnvironmentVariable string
                                                                                                                                  }

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

                                                                                                                                    func (ErrMissingEnvironmentVariable) Error

                                                                                                                                    type ErrMissingInput

                                                                                                                                    type ErrMissingInput struct {
                                                                                                                                    	BaseError
                                                                                                                                    	Argument string
                                                                                                                                    }

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

                                                                                                                                      func (ErrMissingInput) Error

                                                                                                                                      func (e ErrMissingInput) Error() string

                                                                                                                                      type ErrMissingPassword

                                                                                                                                      type ErrMissingPassword struct{ BaseError }

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

                                                                                                                                        func (ErrMissingPassword) Error

                                                                                                                                        func (e ErrMissingPassword) Error() string

                                                                                                                                        type ErrMultipleResourcesFound

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

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

                                                                                                                                          func (ErrMultipleResourcesFound) Error

                                                                                                                                          type ErrResourceNotFound

                                                                                                                                          type ErrResourceNotFound struct {
                                                                                                                                          	BaseError
                                                                                                                                          	Name         string
                                                                                                                                          	ResourceType string
                                                                                                                                          }

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

                                                                                                                                            func (ErrResourceNotFound) Error

                                                                                                                                            func (e ErrResourceNotFound) Error() string

                                                                                                                                            type ErrResult

                                                                                                                                            type ErrResult struct {
                                                                                                                                            	Result
                                                                                                                                            }

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

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

                                                                                                                                              func (ErrResult) ExtractErr

                                                                                                                                              func (r ErrResult) ExtractErr() error

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

                                                                                                                                                type ErrScopeDomainIDOrDomainName

                                                                                                                                                type ErrScopeDomainIDOrDomainName struct{ BaseError }

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

                                                                                                                                                  func (ErrScopeDomainIDOrDomainName) Error

                                                                                                                                                  type ErrScopeEmpty

                                                                                                                                                  type ErrScopeEmpty struct{ BaseError }

                                                                                                                                                    ErrScopeEmpty indicates that no credentials were provided in a Scope.

                                                                                                                                                    func (ErrScopeEmpty) Error

                                                                                                                                                    func (e ErrScopeEmpty) Error() string

                                                                                                                                                    type ErrScopeProjectIDAlone

                                                                                                                                                    type ErrScopeProjectIDAlone struct{ BaseError }

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

                                                                                                                                                      func (ErrScopeProjectIDAlone) Error

                                                                                                                                                      func (e ErrScopeProjectIDAlone) Error() string

                                                                                                                                                      type ErrScopeProjectIDOrProjectName

                                                                                                                                                      type ErrScopeProjectIDOrProjectName struct{ BaseError }

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

                                                                                                                                                        func (ErrScopeProjectIDOrProjectName) Error

                                                                                                                                                        type ErrServiceNotFound

                                                                                                                                                        type ErrServiceNotFound struct {
                                                                                                                                                        	BaseError
                                                                                                                                                        }

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

                                                                                                                                                          func (ErrServiceNotFound) Error

                                                                                                                                                          func (e ErrServiceNotFound) Error() string

                                                                                                                                                          type ErrTenantIDProvided

                                                                                                                                                          type ErrTenantIDProvided struct{ BaseError }

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

                                                                                                                                                            func (ErrTenantIDProvided) Error

                                                                                                                                                            func (e ErrTenantIDProvided) Error() string

                                                                                                                                                            type ErrTenantNameProvided

                                                                                                                                                            type ErrTenantNameProvided struct{ BaseError }

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

                                                                                                                                                              func (ErrTenantNameProvided) Error

                                                                                                                                                              func (e ErrTenantNameProvided) Error() string

                                                                                                                                                              type ErrTimeOut

                                                                                                                                                              type ErrTimeOut struct {
                                                                                                                                                              	BaseError
                                                                                                                                                              }

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

                                                                                                                                                                func (ErrTimeOut) Error

                                                                                                                                                                func (e ErrTimeOut) Error() string

                                                                                                                                                                type ErrUnableToReauthenticate

                                                                                                                                                                type ErrUnableToReauthenticate struct {
                                                                                                                                                                	BaseError
                                                                                                                                                                	ErrOriginal error
                                                                                                                                                                }

                                                                                                                                                                  ErrUnableToReauthenticate is the error type returned when reauthentication fails.

                                                                                                                                                                  func (ErrUnableToReauthenticate) Error

                                                                                                                                                                  type ErrUnexpectedResponseCode

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

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

                                                                                                                                                                    func (ErrUnexpectedResponseCode) Error

                                                                                                                                                                    func (ErrUnexpectedResponseCode) GetStatusCode

                                                                                                                                                                    func (e ErrUnexpectedResponseCode) GetStatusCode() int

                                                                                                                                                                      GetStatusCode returns the actual status code of the error.

                                                                                                                                                                      type ErrUnexpectedType

                                                                                                                                                                      type ErrUnexpectedType struct {
                                                                                                                                                                      	BaseError
                                                                                                                                                                      	Expected string
                                                                                                                                                                      	Actual   string
                                                                                                                                                                      }

                                                                                                                                                                        ErrUnexpectedType is the error when an unexpected type is encountered

                                                                                                                                                                        func (ErrUnexpectedType) Error

                                                                                                                                                                        func (e ErrUnexpectedType) Error() string

                                                                                                                                                                        type ErrUserIDWithToken

                                                                                                                                                                        type ErrUserIDWithToken struct{ BaseError }

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

                                                                                                                                                                          func (ErrUserIDWithToken) Error

                                                                                                                                                                          func (e ErrUserIDWithToken) Error() string

                                                                                                                                                                          type ErrUsernameOrUserID

                                                                                                                                                                          type ErrUsernameOrUserID struct{ BaseError }

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

                                                                                                                                                                            func (ErrUsernameOrUserID) Error

                                                                                                                                                                            func (e ErrUsernameOrUserID) Error() string

                                                                                                                                                                            type ErrUsernameWithToken

                                                                                                                                                                            type ErrUsernameWithToken struct{ BaseError }

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

                                                                                                                                                                              func (ErrUsernameWithToken) Error

                                                                                                                                                                              func (e ErrUsernameWithToken) Error() string

                                                                                                                                                                              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 JSONRFC3339ZNoT

                                                                                                                                                                                    type JSONRFC3339ZNoT time.Time

                                                                                                                                                                                    func (*JSONRFC3339ZNoT) UnmarshalJSON

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

                                                                                                                                                                                    type JSONRFC3339ZNoTNoZ

                                                                                                                                                                                    type JSONRFC3339ZNoTNoZ time.Time

                                                                                                                                                                                    func (*JSONRFC3339ZNoTNoZ) UnmarshalJSON

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

                                                                                                                                                                                    type JSONUnix

                                                                                                                                                                                    type JSONUnix time.Time

                                                                                                                                                                                    func (*JSONUnix) UnmarshalJSON

                                                                                                                                                                                    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

                                                                                                                                                                                      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
                                                                                                                                                                                      
                                                                                                                                                                                      	// Throwaway determines whether if this client is a throw-away client. It's a copy of user's provider client
                                                                                                                                                                                      	// with the token and reauth func zeroed. Such client can be used to perform reauthorization.
                                                                                                                                                                                      	Throwaway bool
                                                                                                                                                                                      
                                                                                                                                                                                      	// Context is the context passed to the HTTP request.
                                                                                                                                                                                      	Context context.Context
                                                                                                                                                                                      
                                                                                                                                                                                      	// Retry backoff func
                                                                                                                                                                                      	RetryBackoffFunc RetryFunc
                                                                                                                                                                                      
                                                                                                                                                                                      	// MaxBackoffRetries set the maximum number of backoffs. When not set, defaults to DefaultMaxBackoffRetries
                                                                                                                                                                                      	MaxBackoffRetries uint
                                                                                                                                                                                      	// 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. Blocks if Reauthenticate is in progress.

                                                                                                                                                                                          func (*ProviderClient) CopyTokenFrom

                                                                                                                                                                                          func (client *ProviderClient) CopyTokenFrom(other *ProviderClient)

                                                                                                                                                                                            CopyTokenFrom safely copies the token from another ProviderClient into the this one.

                                                                                                                                                                                            func (*ProviderClient) GetAuthResult

                                                                                                                                                                                            func (client *ProviderClient) GetAuthResult() AuthResult

                                                                                                                                                                                              GetAuthResult returns the result from the request that was used to obtain a provider client's Keystone token.

                                                                                                                                                                                              The result is nil when authentication has not yet taken place, when the token was set manually with SetToken(), or when a ReauthFunc was used that does not record the AuthResult.

                                                                                                                                                                                              func (*ProviderClient) IsThrowaway

                                                                                                                                                                                              func (client *ProviderClient) IsThrowaway() bool

                                                                                                                                                                                                IsThrowaway safely reads the value of the client Throwaway field.

                                                                                                                                                                                                func (*ProviderClient) Reauthenticate

                                                                                                                                                                                                func (client *ProviderClient) Reauthenticate(previousToken string) 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) SetThrowaway

                                                                                                                                                                                                    func (client *ProviderClient) SetThrowaway(v bool)

                                                                                                                                                                                                      SetThrowaway safely sets the value of the client Throwaway field.

                                                                                                                                                                                                      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.

                                                                                                                                                                                                        WARNING: This function is deprecated. Use SetTokenAndAuthResult() instead.

                                                                                                                                                                                                        func (*ProviderClient) SetTokenAndAuthResult

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

                                                                                                                                                                                                          SetTokenAndAuthResult safely sets the value of the auth token in the ProviderClient and also records the AuthResult that was returned from the token creation request. Applications may call this 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
                                                                                                                                                                                                              	// KeepResponseBody specifies whether to keep the HTTP response body. Usually used, when the HTTP
                                                                                                                                                                                                              	// response body is considered for further use. Valid when JSONResponse is nil.
                                                                                                                                                                                                              	KeepResponseBody bool
                                                                                                                                                                                                              }

                                                                                                                                                                                                                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
                                                                                                                                                                                                                          
                                                                                                                                                                                                                          	// MoreHeaders allows users (or Gophercloud) to set service-wide headers on requests. Put another way,
                                                                                                                                                                                                                          	// values set in this field will be set on all the HTTP requests the service client sends.
                                                                                                                                                                                                                          	MoreHeaders map[string]string
                                                                                                                                                                                                                          }

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

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

                                                                                                                                                                                                                                          Request carries out the HTTP operation for the service client

                                                                                                                                                                                                                                          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.

                                                                                                                                                                                                                                              type StatusCodeError

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

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

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

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

                                                                                                                                                                                                                                                      Directories

                                                                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                                                                      acceptance
                                                                                                                                                                                                                                                      clients
                                                                                                                                                                                                                                                      Package clients contains functions for creating OpenStack service clients for use in acceptance tests.
                                                                                                                                                                                                                                                      Package clients contains functions for creating OpenStack service clients for use in acceptance tests.
                                                                                                                                                                                                                                                      openstack
                                                                                                                                                                                                                                                      Package openstack contains common functions that can be used across all OpenStack components for acceptance testing.
                                                                                                                                                                                                                                                      Package openstack contains common functions that can be used across all OpenStack components for acceptance testing.
                                                                                                                                                                                                                                                      openstack/blockstorage/extensions
                                                                                                                                                                                                                                                      Package extensions contains common functions for creating block storage resources that are extensions of the block storage API.
                                                                                                                                                                                                                                                      Package extensions contains common functions for creating block storage resources that are extensions of the block storage API.
                                                                                                                                                                                                                                                      openstack/blockstorage/noauth
                                                                                                                                                                                                                                                      Package noauth contains common functions for creating block storage based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      Package noauth contains common functions for creating block storage based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      openstack/blockstorage/v1
                                                                                                                                                                                                                                                      Package v1 contains common functions for creating block storage based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      Package v1 contains common functions for creating block storage based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      openstack/blockstorage/v2
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating block storage based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating block storage based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      openstack/blockstorage/v3
                                                                                                                                                                                                                                                      Package v3 contains common functions for creating block storage based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      Package v3 contains common functions for creating block storage based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      openstack/clustering/v1
                                                                                                                                                                                                                                                      Package v1 package contains acceptance tests for the Openstack Clustering V1 service.
                                                                                                                                                                                                                                                      Package v1 package contains acceptance tests for the Openstack Clustering V1 service.
                                                                                                                                                                                                                                                      openstack/compute/v2
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating compute-based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating compute-based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      openstack/db/v1
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating db resources for use in acceptance tests.
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating db resources for use in acceptance tests.
                                                                                                                                                                                                                                                      openstack/identity/v2
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating identity-based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating identity-based resources for use in acceptance tests.
                                                                                                                                                                                                                                                      openstack/imageservice/v2
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating imageservice resources for use in acceptance tests.
                                                                                                                                                                                                                                                      Package v2 contains common functions for creating imageservice resources for use in acceptance tests.
                                                                                                                                                                                                                                                      agents acceptance tests
                                                                                                                                                                                                                                                      openstack/placement/v1
                                                                                                                                                                                                                                                      Package placement contains acceptance tests for the Openstack Placement service.
                                                                                                                                                                                                                                                      Package placement contains acceptance tests for the Openstack Placement service.
                                                                                                                                                                                                                                                      Package openstack contains resources for the individual OpenStack projects supported in Gophercloud.
                                                                                                                                                                                                                                                      Package openstack contains resources for the individual OpenStack projects supported in Gophercloud.
                                                                                                                                                                                                                                                      baremetal/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information about the versions supported by a specific Ironic API.
                                                                                                                                                                                                                                                      Package apiversions provides information about the versions supported by a specific Ironic API.
                                                                                                                                                                                                                                                      baremetal/httpbasic
                                                                                                                                                                                                                                                      Package httpbasic provides support for http_basic bare metal endpoints.
                                                                                                                                                                                                                                                      Package httpbasic provides support for http_basic bare metal endpoints.
                                                                                                                                                                                                                                                      baremetal/noauth
                                                                                                                                                                                                                                                      Package noauth provides support for noauth bare metal endpoints.
                                                                                                                                                                                                                                                      Package noauth provides support for noauth bare metal endpoints.
                                                                                                                                                                                                                                                      baremetal/v1/drivers
                                                                                                                                                                                                                                                      Package drivers contains the functionality for Listing drivers, driver details, driver properties and driver logical disk properties API reference: https://developer.openstack.org/api-ref/baremetal/#drivers-drivers Example to List Drivers drivers.ListDrivers(client.ServiceClient(), drivers.ListDriversOpts{}).EachPage(func(page pagination.Page) (bool, error) { driversList, err := drivers.ExtractDrivers(page) if err != nil { return false, err } for _, n := range driversList { // Do something } return true, nil }) Example to Get single Driver Details showDriverDetails, err := drivers.GetDriverDetails(client, "ipmi").Extract() if err != nil { panic(err) } Example to Get single Driver Properties showDriverProperties, err := drivers.GetDriverProperties(client, "ipmi").Extract() if err != nil { panic(err) } Example to Get single Driver Logical Disk Properties showDriverDiskProperties, err := drivers.GetDriverDiskProperties(client, "ipmi").Extract() if err != nil { panic(err) }
                                                                                                                                                                                                                                                      Package drivers contains the functionality for Listing drivers, driver details, driver properties and driver logical disk properties API reference: https://developer.openstack.org/api-ref/baremetal/#drivers-drivers Example to List Drivers drivers.ListDrivers(client.ServiceClient(), drivers.ListDriversOpts{}).EachPage(func(page pagination.Page) (bool, error) { driversList, err := drivers.ExtractDrivers(page) if err != nil { return false, err } for _, n := range driversList { // Do something } return true, nil }) Example to Get single Driver Details showDriverDetails, err := drivers.GetDriverDetails(client, "ipmi").Extract() if err != nil { panic(err) } Example to Get single Driver Properties showDriverProperties, err := drivers.GetDriverProperties(client, "ipmi").Extract() if err != nil { panic(err) } Example to Get single Driver Logical Disk Properties showDriverDiskProperties, err := drivers.GetDriverDiskProperties(client, "ipmi").Extract() if err != nil { panic(err) }
                                                                                                                                                                                                                                                      baremetal/v1/drivers/testing
                                                                                                                                                                                                                                                      Package testing contains drivers unit tests
                                                                                                                                                                                                                                                      Package testing contains drivers unit tests
                                                                                                                                                                                                                                                      baremetal/v1/nodes
                                                                                                                                                                                                                                                      Package nodes provides information and interaction with the nodes API resource in the OpenStack Bare Metal service.
                                                                                                                                                                                                                                                      Package nodes provides information and interaction with the nodes API resource in the OpenStack Bare Metal service.
                                                                                                                                                                                                                                                      baremetal/v1/nodes/testing
                                                                                                                                                                                                                                                      nodes unit tests
                                                                                                                                                                                                                                                      nodes unit tests
                                                                                                                                                                                                                                                      baremetal/v1/ports
                                                                                                                                                                                                                                                      Package ports contains the functionality to Listing, Searching, Creating, Updating, and Deleting of bare metal Port resources API reference: https://developer.openstack.org/api-ref/baremetal/#ports-ports Example to List Ports with Detail ports.ListDetail(client, nil).EachPage(func(page pagination.Page) (bool, error) { portList, err := ports.ExtractPorts(page) if err != nil { return false, err } for _, n := range portList { // Do something } return true, nil }) Example to List Ports listOpts := ports.ListOpts{ Limit: 10, } ports.List(client, listOpts).EachPage(func(page pagination.Page) (bool, error) { portList, err := ports.ExtractPorts(page) if err != nil { return false, err } for _, n := range portList { // Do something } return true, nil }) Example to Create a Port createOpts := ports.CreateOpts{ NodeUUID: "e8920409-e07e-41bb-8cc1-72acb103e2dd", Address: "00:1B:63:84:45:E6", PhysicalNetwork: "my-network", } createPort, err := ports.Create(client, createOpts).Extract() if err != nil { panic(err) } Example to Get a Port showPort, err := ports.Get(client, "c9afd385-5d89-4ecb-9e1c-68194da6b474").Extract() if err != nil { panic(err) } Example to Update a Port updateOpts := ports.UpdateOpts{ ports.UpdateOperation{ Op: ReplaceOp, Path: "/address", Value: "22:22:22:22:22:22", }, } updatePort, err := ports.Update(client, "c9afd385-5d89-4ecb-9e1c-68194da6b474", updateOpts).Extract() if err != nil { panic(err) } Example to Delete a Port err = ports.Delete(client, "c9afd385-5d89-4ecb-9e1c-68194da6b474").ExtractErr() if err != nil { panic(err) }
                                                                                                                                                                                                                                                      Package ports contains the functionality to Listing, Searching, Creating, Updating, and Deleting of bare metal Port resources API reference: https://developer.openstack.org/api-ref/baremetal/#ports-ports Example to List Ports with Detail ports.ListDetail(client, nil).EachPage(func(page pagination.Page) (bool, error) { portList, err := ports.ExtractPorts(page) if err != nil { return false, err } for _, n := range portList { // Do something } return true, nil }) Example to List Ports listOpts := ports.ListOpts{ Limit: 10, } ports.List(client, listOpts).EachPage(func(page pagination.Page) (bool, error) { portList, err := ports.ExtractPorts(page) if err != nil { return false, err } for _, n := range portList { // Do something } return true, nil }) Example to Create a Port createOpts := ports.CreateOpts{ NodeUUID: "e8920409-e07e-41bb-8cc1-72acb103e2dd", Address: "00:1B:63:84:45:E6", PhysicalNetwork: "my-network", } createPort, err := ports.Create(client, createOpts).Extract() if err != nil { panic(err) } Example to Get a Port showPort, err := ports.Get(client, "c9afd385-5d89-4ecb-9e1c-68194da6b474").Extract() if err != nil { panic(err) } Example to Update a Port updateOpts := ports.UpdateOpts{ ports.UpdateOperation{ Op: ReplaceOp, Path: "/address", Value: "22:22:22:22:22:22", }, } updatePort, err := ports.Update(client, "c9afd385-5d89-4ecb-9e1c-68194da6b474", updateOpts).Extract() if err != nil { panic(err) } Example to Delete a Port err = ports.Delete(client, "c9afd385-5d89-4ecb-9e1c-68194da6b474").ExtractErr() if err != nil { panic(err) }
                                                                                                                                                                                                                                                      baremetal/v1/ports/testing
                                                                                                                                                                                                                                                      ports unit tests
                                                                                                                                                                                                                                                      ports unit tests
                                                                                                                                                                                                                                                      baremetalintrospection/httpbasic
                                                                                                                                                                                                                                                      Package httpbasic provides support for http_basic bare metal introspection endpoints.
                                                                                                                                                                                                                                                      Package httpbasic provides support for http_basic bare metal introspection endpoints.
                                                                                                                                                                                                                                                      baremetalintrospection/noauth
                                                                                                                                                                                                                                                      Package noauth provides support for noauth bare metal introspection endpoints.
                                                                                                                                                                                                                                                      Package noauth provides support for noauth bare metal introspection endpoints.
                                                                                                                                                                                                                                                      baremetalintrospection/v1/introspection
                                                                                                                                                                                                                                                      Package introspection contains the functionality for Starting introspection, Get introspection status, List all introspection statuses, Abort an introspection, Get stored introspection data and reapply introspection on stored data.
                                                                                                                                                                                                                                                      Package introspection contains the functionality for Starting introspection, Get introspection status, List all introspection statuses, Abort an introspection, Get stored introspection data and reapply introspection on stored data.
                                                                                                                                                                                                                                                      blockstorage/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Block Storage service, code-named Cinder.
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Block Storage service, code-named Cinder.
                                                                                                                                                                                                                                                      apiversions_v1
                                                                                                                                                                                                                                                      blockstorage/extensions/availabilityzones
                                                                                                                                                                                                                                                      Package availabilityzones provides the ability to get lists of available volume availability zones.
                                                                                                                                                                                                                                                      Package availabilityzones provides the ability to get lists of available volume availability zones.
                                                                                                                                                                                                                                                      availabilityzones unittests
                                                                                                                                                                                                                                                      blockstorage/extensions/backups
                                                                                                                                                                                                                                                      Package backups provides information and interaction with backups in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package backups provides information and interaction with backups in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      blockstorage/extensions/limits
                                                                                                                                                                                                                                                      Package limits shows rate and limit information for a project you authorized for.
                                                                                                                                                                                                                                                      Package limits shows rate and limit information for a project you authorized for.
                                                                                                                                                                                                                                                      blockstorage/extensions/quotasets
                                                                                                                                                                                                                                                      Package quotasets enables retrieving and managing Block Storage quotas.
                                                                                                                                                                                                                                                      Package quotasets enables retrieving and managing Block Storage quotas.
                                                                                                                                                                                                                                                      quotasets unit tests
                                                                                                                                                                                                                                                      blockstorage/extensions/schedulerhints
                                                                                                                                                                                                                                                      Package schedulerhints extends the volume create request with the ability to specify additional parameters which determine where the volume will be created in the OpenStack cloud.
                                                                                                                                                                                                                                                      Package schedulerhints extends the volume create request with the ability to specify additional parameters which determine where the volume will be created in the OpenStack cloud.
                                                                                                                                                                                                                                                      schedulerhints unit tests
                                                                                                                                                                                                                                                      blockstorage/extensions/schedulerstats
                                                                                                                                                                                                                                                      Package schedulerstats returns information about block storage pool capacity and utilisation.
                                                                                                                                                                                                                                                      Package schedulerstats returns information about block storage pool capacity and utilisation.
                                                                                                                                                                                                                                                      blockstorage/extensions/volumeactions
                                                                                                                                                                                                                                                      Package volumeactions provides information and interaction with volumes in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package volumeactions provides information and interaction with volumes in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      volumeactions unit tests
                                                                                                                                                                                                                                                      blockstorage/extensions/volumetenants
                                                                                                                                                                                                                                                      Package volumetenants provides the ability to extend a volume result with tenant/project information.
                                                                                                                                                                                                                                                      Package volumetenants provides the ability to extend a volume result with tenant/project information.
                                                                                                                                                                                                                                                      blockstorage/extensions/volumetransfers
                                                                                                                                                                                                                                                      Package volumetransfers provides an interaction with volume transfers in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package volumetransfers provides an interaction with volume transfers in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      blockstorage/noauth
                                                                                                                                                                                                                                                      Package noauth creates a "noauth" *gophercloud.ServiceClient for use in Cinder environments configured with the noauth authentication middleware.
                                                                                                                                                                                                                                                      Package noauth creates a "noauth" *gophercloud.ServiceClient for use in Cinder environments configured with the noauth authentication middleware.
                                                                                                                                                                                                                                                      blockstorage/noauth/testing
                                                                                                                                                                                                                                                      noauth unit tests
                                                                                                                                                                                                                                                      noauth unit tests
                                                                                                                                                                                                                                                      blockstorage/v1/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Block Storage service, code-named Cinder.
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Block Storage service, code-named Cinder.
                                                                                                                                                                                                                                                      apiversions_v1
                                                                                                                                                                                                                                                      blockstorage/v1/snapshots
                                                                                                                                                                                                                                                      Package snapshots provides information and interaction with snapshots in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package snapshots provides information and interaction with snapshots in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      snapshots_v1
                                                                                                                                                                                                                                                      blockstorage/v1/volumes
                                                                                                                                                                                                                                                      Package volumes provides information and interaction with volumes in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package volumes provides information and interaction with volumes in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      volumes_v1
                                                                                                                                                                                                                                                      blockstorage/v1/volumetypes
                                                                                                                                                                                                                                                      Package volumetypes provides information and interaction with volume types in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package volumetypes provides information and interaction with volume types in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      volumetypes_v1
                                                                                                                                                                                                                                                      blockstorage/v2/snapshots
                                                                                                                                                                                                                                                      Package snapshots provides information and interaction with snapshots in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package snapshots provides information and interaction with snapshots in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      snapshots_v2
                                                                                                                                                                                                                                                      blockstorage/v2/volumes
                                                                                                                                                                                                                                                      Package volumes provides information and interaction with volumes in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package volumes provides information and interaction with volumes in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      volumes_v2
                                                                                                                                                                                                                                                      blockstorage/v3/attachments
                                                                                                                                                                                                                                                      Package attachments provides access to OpenStack Block Storage Attachment API's.
                                                                                                                                                                                                                                                      Package attachments provides access to OpenStack Block Storage Attachment API's.
                                                                                                                                                                                                                                                      blockstorage/v3/qos
                                                                                                                                                                                                                                                      Package qos provides information and interaction with the QoS specifications for the Openstack Blockstorage service.
                                                                                                                                                                                                                                                      Package qos provides information and interaction with the QoS specifications for the Openstack Blockstorage service.
                                                                                                                                                                                                                                                      blockstorage/v3/qos/testing
                                                                                                                                                                                                                                                      Package testing for qos_v3
                                                                                                                                                                                                                                                      Package testing for qos_v3
                                                                                                                                                                                                                                                      blockstorage/v3/snapshots
                                                                                                                                                                                                                                                      Package snapshots provides information and interaction with snapshots in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package snapshots provides information and interaction with snapshots in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      blockstorage/v3/snapshots/testing
                                                                                                                                                                                                                                                      Package testing for snapshots_v3
                                                                                                                                                                                                                                                      Package testing for snapshots_v3
                                                                                                                                                                                                                                                      blockstorage/v3/volumes
                                                                                                                                                                                                                                                      Package volumes provides information and interaction with volumes in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package volumes provides information and interaction with volumes in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      volumes_v3
                                                                                                                                                                                                                                                      blockstorage/v3/volumetypes
                                                                                                                                                                                                                                                      Package volumetypes provides information and interaction with volume types in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      Package volumetypes provides information and interaction with volume types in the OpenStack Block Storage service.
                                                                                                                                                                                                                                                      volume_types
                                                                                                                                                                                                                                                      cdn/v1/base
                                                                                                                                                                                                                                                      Package base provides information and interaction with the base API resource in the OpenStack CDN service.
                                                                                                                                                                                                                                                      Package base provides information and interaction with the base API resource in the OpenStack CDN service.
                                                                                                                                                                                                                                                      cdn/v1/base/testing
                                                                                                                                                                                                                                                      cdn_base_v1
                                                                                                                                                                                                                                                      cdn_base_v1
                                                                                                                                                                                                                                                      cdn/v1/flavors
                                                                                                                                                                                                                                                      Package flavors provides information and interaction with the flavors API resource in the OpenStack CDN service.
                                                                                                                                                                                                                                                      Package flavors provides information and interaction with the flavors API resource in the OpenStack CDN service.
                                                                                                                                                                                                                                                      cdn/v1/flavors/testing
                                                                                                                                                                                                                                                      cdn_flavors_v1
                                                                                                                                                                                                                                                      cdn_flavors_v1
                                                                                                                                                                                                                                                      cdn/v1/serviceassets
                                                                                                                                                                                                                                                      Package serviceassets provides information and interaction with the serviceassets API resource in the OpenStack CDN service.
                                                                                                                                                                                                                                                      Package serviceassets provides information and interaction with the serviceassets API resource in the OpenStack CDN service.
                                                                                                                                                                                                                                                      cdn/v1/serviceassets/testing
                                                                                                                                                                                                                                                      cdn_serviceassets_v1
                                                                                                                                                                                                                                                      cdn_serviceassets_v1
                                                                                                                                                                                                                                                      cdn/v1/services
                                                                                                                                                                                                                                                      Package services provides information and interaction with the services API resource in the OpenStack CDN service.
                                                                                                                                                                                                                                                      Package services provides information and interaction with the services API resource in the OpenStack CDN service.
                                                                                                                                                                                                                                                      cdn/v1/services/testing
                                                                                                                                                                                                                                                      cdn_services_v1
                                                                                                                                                                                                                                                      cdn_services_v1
                                                                                                                                                                                                                                                      clustering/v1/actions
                                                                                                                                                                                                                                                      Package actions provides listing and retrieving of senlin actions for the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      Package actions provides listing and retrieving of senlin actions for the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      clustering/v1/actions/testing
                                                                                                                                                                                                                                                      clustering_actions_v1
                                                                                                                                                                                                                                                      clustering_actions_v1
                                                                                                                                                                                                                                                      clustering/v1/clusters
                                                                                                                                                                                                                                                      Package clusters provides information and interaction with the clusters through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      Package clusters provides information and interaction with the clusters through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      clustering/v1/clusters/testing
                                                                                                                                                                                                                                                      clustering_clusters_v1
                                                                                                                                                                                                                                                      clustering_clusters_v1
                                                                                                                                                                                                                                                      clustering/v1/events
                                                                                                                                                                                                                                                      Package events provides listing and retrieving of senlin events for the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      Package events provides listing and retrieving of senlin events for the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      clustering/v1/events/testing
                                                                                                                                                                                                                                                      clustering_events_v1
                                                                                                                                                                                                                                                      clustering_events_v1
                                                                                                                                                                                                                                                      clustering/v1/nodes
                                                                                                                                                                                                                                                      Package nodes provides information and interaction with the nodes through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      Package nodes provides information and interaction with the nodes through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      clustering/v1/nodes/testing
                                                                                                                                                                                                                                                      clustering_nodes_v1
                                                                                                                                                                                                                                                      clustering_nodes_v1
                                                                                                                                                                                                                                                      clustering/v1/policies
                                                                                                                                                                                                                                                      Package policies provides information and interaction with the policies through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      Package policies provides information and interaction with the policies through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      clustering/v1/policies/testing
                                                                                                                                                                                                                                                      clustering_policies_v1
                                                                                                                                                                                                                                                      clustering_policies_v1
                                                                                                                                                                                                                                                      clustering/v1/policytypes
                                                                                                                                                                                                                                                      Package policytypes lists all policy types and shows details for a policy type from the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      Package policytypes lists all policy types and shows details for a policy type from the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      clustering/v1/policytypes/testing
                                                                                                                                                                                                                                                      clustering_policytypes_v1
                                                                                                                                                                                                                                                      clustering_policytypes_v1
                                                                                                                                                                                                                                                      clustering/v1/profiles
                                                                                                                                                                                                                                                      Package profiles provides information and interaction with profiles through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      Package profiles provides information and interaction with profiles through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      clustering/v1/profiles/testing
                                                                                                                                                                                                                                                      clustering_profiles_v1
                                                                                                                                                                                                                                                      clustering_profiles_v1
                                                                                                                                                                                                                                                      clustering/v1/profiletypes
                                                                                                                                                                                                                                                      Package profiletypes lists all profile types and shows details for a profile type from the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      Package profiletypes lists all profile types and shows details for a profile type from the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      clustering/v1/profiletypes/testing
                                                                                                                                                                                                                                                      clustering_profiletypes_v1
                                                                                                                                                                                                                                                      clustering_profiletypes_v1
                                                                                                                                                                                                                                                      clustering/v1/receivers
                                                                                                                                                                                                                                                      Package receivers provides information and interaction with the receivers through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      Package receivers provides information and interaction with the receivers through the OpenStack Clustering service.
                                                                                                                                                                                                                                                      clustering/v1/receivers/testing
                                                                                                                                                                                                                                                      clustering_receivers_v1
                                                                                                                                                                                                                                                      clustering_receivers_v1
                                                                                                                                                                                                                                                      clustering/v1/webhooks
                                                                                                                                                                                                                                                      Package webhooks provides the ability to trigger an action represented by a webhook from the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      Package webhooks provides the ability to trigger an action represented by a webhook from the OpenStack Clustering Service.
                                                                                                                                                                                                                                                      clustering/v1/webhooks/testing
                                                                                                                                                                                                                                                      clustering_webhooks_v1
                                                                                                                                                                                                                                                      clustering_webhooks_v1
                                                                                                                                                                                                                                                      common/extensions
                                                                                                                                                                                                                                                      Package extensions provides information and interaction with the different extensions available for an OpenStack service.
                                                                                                                                                                                                                                                      Package extensions provides information and interaction with the different extensions available for an OpenStack service.
                                                                                                                                                                                                                                                      common/extensions/testing
                                                                                                                                                                                                                                                      common extensions unit tests
                                                                                                                                                                                                                                                      common extensions unit tests
                                                                                                                                                                                                                                                      compute/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the Compute service, code-named Nova.
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the Compute service, code-named Nova.
                                                                                                                                                                                                                                                      compute/v2/extensions
                                                                                                                                                                                                                                                      Package extensions provides information and interaction with the different extensions available for the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package extensions provides information and interaction with the different extensions available for the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/extensions/aggregates
                                                                                                                                                                                                                                                      Package aggregates manages information about the host aggregates in the OpenStack cloud.
                                                                                                                                                                                                                                                      Package aggregates manages information about the host aggregates in the OpenStack cloud.
                                                                                                                                                                                                                                                      compute/v2/extensions/attachinterfaces
                                                                                                                                                                                                                                                      Package attachinterfaces provides the ability to retrieve and manage network interfaces through Nova.
                                                                                                                                                                                                                                                      Package attachinterfaces provides the ability to retrieve and manage network interfaces through Nova.
                                                                                                                                                                                                                                                      attachinterfaces unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/availabilityzones
                                                                                                                                                                                                                                                      Package availabilityzones provides the ability to get lists and detailed availability zone information and to extend a server result with availability zone information.
                                                                                                                                                                                                                                                      Package availabilityzones provides the ability to get lists and detailed availability zone information and to extend a server result with availability zone information.
                                                                                                                                                                                                                                                      availabilityzones unittests
                                                                                                                                                                                                                                                      compute/v2/extensions/bootfromvolume
                                                                                                                                                                                                                                                      Package bootfromvolume extends a server create request with the ability to specify block device options.
                                                                                                                                                                                                                                                      Package bootfromvolume extends a server create request with the ability to specify block device options.
                                                                                                                                                                                                                                                      bootfromvolume unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/defsecrules
                                                                                                                                                                                                                                                      Package defsecrules enables management of default security group rules.
                                                                                                                                                                                                                                                      Package defsecrules enables management of default security group rules.
                                                                                                                                                                                                                                                      defsecrules unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/diagnostics
                                                                                                                                                                                                                                                      Package diagnostics returns details about a nova instance diagnostics Example of Show Diagnostics diags, err := diagnostics.Get(computeClient, serverId).Extract() if err != nil { panic(err) } fmt.Printf("%+v\n", diags)
                                                                                                                                                                                                                                                      Package diagnostics returns details about a nova instance diagnostics Example of Show Diagnostics diags, err := diagnostics.Get(computeClient, serverId).Extract() if err != nil { panic(err) } fmt.Printf("%+v\n", diags)
                                                                                                                                                                                                                                                      compute/v2/extensions/diskconfig
                                                                                                                                                                                                                                                      Package diskconfig provides information and interaction with the Disk Config extension that works with the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package diskconfig provides information and interaction with the Disk Config extension that works with the OpenStack Compute service.
                                                                                                                                                                                                                                                      diskconfig unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/evacuate
                                                                                                                                                                                                                                                      Package evacuate provides functionality to evacuates servers that have been provisioned by the OpenStack Compute service from a failed host to a new host.
                                                                                                                                                                                                                                                      Package evacuate provides functionality to evacuates servers that have been provisioned by the OpenStack Compute service from a failed host to a new host.
                                                                                                                                                                                                                                                      compute/v2/extensions/evacuate/testing
                                                                                                                                                                                                                                                      compute_extensions_evacuate_v2
                                                                                                                                                                                                                                                      compute_extensions_evacuate_v2
                                                                                                                                                                                                                                                      compute/v2/extensions/extendedserverattributes
                                                                                                                                                                                                                                                      Package extendedserverattributes provides the ability to extend a server result with the extended usage information.
                                                                                                                                                                                                                                                      Package extendedserverattributes provides the ability to extend a server result with the extended usage information.
                                                                                                                                                                                                                                                      compute/v2/extensions/extendedstatus
                                                                                                                                                                                                                                                      Package extendedstatus provides the ability to extend a server result with the extended status information.
                                                                                                                                                                                                                                                      Package extendedstatus provides the ability to extend a server result with the extended status information.
                                                                                                                                                                                                                                                      compute/v2/extensions/floatingips
                                                                                                                                                                                                                                                      Package floatingips provides the ability to manage floating ips through the Nova API.
                                                                                                                                                                                                                                                      Package floatingips provides the ability to manage floating ips through the Nova API.
                                                                                                                                                                                                                                                      floatingips unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/hypervisors
                                                                                                                                                                                                                                                      Package hypervisors returns details about list of hypervisors, shows details for a hypervisor and shows summary statistics for all hypervisors over all compute nodes in the OpenStack cloud.
                                                                                                                                                                                                                                                      Package hypervisors returns details about list of hypervisors, shows details for a hypervisor and shows summary statistics for all hypervisors over all compute nodes in the OpenStack cloud.
                                                                                                                                                                                                                                                      compute/v2/extensions/injectnetworkinfo
                                                                                                                                                                                                                                                      Package injectnetworkinfo provides functionality to inject the network info into a server that has been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package injectnetworkinfo provides functionality to inject the network info into a server that has been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      instanceactions unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/keypairs
                                                                                                                                                                                                                                                      Package keypairs provides the ability to manage key pairs as well as create servers with a specified key pair.
                                                                                                                                                                                                                                                      Package keypairs provides the ability to manage key pairs as well as create servers with a specified key pair.
                                                                                                                                                                                                                                                      keypairs unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/limits
                                                                                                                                                                                                                                                      Package limits shows rate and limit information for a tenant/project.
                                                                                                                                                                                                                                                      Package limits shows rate and limit information for a tenant/project.
                                                                                                                                                                                                                                                      compute/v2/extensions/lockunlock
                                                                                                                                                                                                                                                      Package lockunlock provides functionality to lock and unlock servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package lockunlock provides functionality to lock and unlock servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      unlocklock unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/migrate
                                                                                                                                                                                                                                                      Package migrate provides functionality to migrate servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package migrate provides functionality to migrate servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/extensions/migrate/testing
                                                                                                                                                                                                                                                      compute_extensions_startstop_v2
                                                                                                                                                                                                                                                      compute_extensions_startstop_v2
                                                                                                                                                                                                                                                      compute/v2/extensions/networks
                                                                                                                                                                                                                                                      Package networks provides the ability to create and manage networks in cloud environments using nova-network.
                                                                                                                                                                                                                                                      Package networks provides the ability to create and manage networks in cloud environments using nova-network.
                                                                                                                                                                                                                                                      networks unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/pauseunpause
                                                                                                                                                                                                                                                      Package pauseunpause provides functionality to pause and unpause servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package pauseunpause provides functionality to pause and unpause servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      pauseunpause unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/quotasets
                                                                                                                                                                                                                                                      Package quotasets enables retrieving and managing Compute quotas.
                                                                                                                                                                                                                                                      Package quotasets enables retrieving and managing Compute quotas.
                                                                                                                                                                                                                                                      quotasets unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/remoteconsoles
                                                                                                                                                                                                                                                      Package remoteconsoles provides the ability to create server remote consoles through the Compute API.
                                                                                                                                                                                                                                                      Package remoteconsoles provides the ability to create server remote consoles through the Compute API.
                                                                                                                                                                                                                                                      compute/v2/extensions/rescueunrescue
                                                                                                                                                                                                                                                      Package rescueunrescue provides the ability to place a server into rescue mode and to return it back.
                                                                                                                                                                                                                                                      Package rescueunrescue provides the ability to place a server into rescue mode and to return it back.
                                                                                                                                                                                                                                                      compute/v2/extensions/resetnetwork
                                                                                                                                                                                                                                                      Package resetnetwork provides functionality to reset the network of a server that has been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package resetnetwork provides functionality to reset the network of a server that has been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/extensions/resetstate
                                                                                                                                                                                                                                                      Package resetstate provides functionality to reset the state of a server that has been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package resetstate provides functionality to reset the state of a server that has been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/extensions/schedulerhints
                                                                                                                                                                                                                                                      Package 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.
                                                                                                                                                                                                                                                      Package 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.
                                                                                                                                                                                                                                                      schedulerhints unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/secgroups
                                                                                                                                                                                                                                                      Package secgroups provides the ability to manage security groups through the Nova API.
                                                                                                                                                                                                                                                      Package secgroups provides the ability to manage security groups through the Nova API.
                                                                                                                                                                                                                                                      secgroups unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/servergroups
                                                                                                                                                                                                                                                      Package servergroups provides the ability to manage server groups.
                                                                                                                                                                                                                                                      Package servergroups provides the ability to manage server groups.
                                                                                                                                                                                                                                                      servergroups unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/serverusage
                                                                                                                                                                                                                                                      Package serverusage provides the ability the ability to extend a server result with the extended usage information.
                                                                                                                                                                                                                                                      Package serverusage provides the ability the ability to extend a server result with the extended usage information.
                                                                                                                                                                                                                                                      compute/v2/extensions/shelveunshelve
                                                                                                                                                                                                                                                      Package shelveunshelve provides functionality to start and stop servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package shelveunshelve provides functionality to start and stop servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/extensions/startstop
                                                                                                                                                                                                                                                      Package startstop provides functionality to start and stop servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package startstop provides functionality to start and stop servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      startstop unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/suspendresume
                                                                                                                                                                                                                                                      Package suspendresume provides functionality to suspend and resume servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package suspendresume provides functionality to suspend and resume servers that have been provisioned by the OpenStack Compute service.
                                                                                                                                                                                                                                                      suspendresume unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/tags
                                                                                                                                                                                                                                                      Package tags manages Tags on Compute V2 servers.
                                                                                                                                                                                                                                                      Package tags manages Tags on Compute V2 servers.
                                                                                                                                                                                                                                                      tags unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/tenantnetworks
                                                                                                                                                                                                                                                      Package tenantnetworks provides the ability for tenants to see information about the networks they have access to.
                                                                                                                                                                                                                                                      Package tenantnetworks provides the ability for tenants to see information about the networks they have access to.
                                                                                                                                                                                                                                                      tenantnetworks unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/testing
                                                                                                                                                                                                                                                      extensions unit tests
                                                                                                                                                                                                                                                      extensions unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/usage
                                                                                                                                                                                                                                                      Package usage provides information and interaction with the SimpleTenantUsage extension for the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package usage provides information and interaction with the SimpleTenantUsage extension for the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/extensions/usage/testing
                                                                                                                                                                                                                                                      simple tenant usage unit tests
                                                                                                                                                                                                                                                      simple tenant usage unit tests
                                                                                                                                                                                                                                                      compute/v2/extensions/volumeattach
                                                                                                                                                                                                                                                      Package volumeattach provides the ability to attach and detach volumes from servers.
                                                                                                                                                                                                                                                      Package volumeattach provides the ability to attach and detach volumes from servers.
                                                                                                                                                                                                                                                      volumeattach unit tests
                                                                                                                                                                                                                                                      compute/v2/flavors
                                                                                                                                                                                                                                                      Package flavors provides information and interaction with the flavor API in the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package flavors provides information and interaction with the flavor API in the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/flavors/testing
                                                                                                                                                                                                                                                      flavors unit tests
                                                                                                                                                                                                                                                      flavors unit tests
                                                                                                                                                                                                                                                      compute/v2/images
                                                                                                                                                                                                                                                      Package images provides information and interaction with the images through the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package images provides information and interaction with the images through the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/images/testing
                                                                                                                                                                                                                                                      images unit tests
                                                                                                                                                                                                                                                      images unit tests
                                                                                                                                                                                                                                                      compute/v2/servers
                                                                                                                                                                                                                                                      Package servers provides information and interaction with the server API resource in the OpenStack Compute service.
                                                                                                                                                                                                                                                      Package servers provides information and interaction with the server API resource in the OpenStack Compute service.
                                                                                                                                                                                                                                                      compute/v2/servers/testing
                                                                                                                                                                                                                                                      servers unit tests
                                                                                                                                                                                                                                                      servers unit tests
                                                                                                                                                                                                                                                      container/v1/capsules
                                                                                                                                                                                                                                                      Package capsules contains functionality for working with Zun capsule resources.
                                                                                                                                                                                                                                                      Package capsules contains functionality for working with Zun capsule resources.
                                                                                                                                                                                                                                                      containerinfra/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the Container Infra service, code-named Magnum.
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the Container Infra service, code-named Magnum.
                                                                                                                                                                                                                                                      apiversions_v1
                                                                                                                                                                                                                                                      containerinfra/v1/certificates
                                                                                                                                                                                                                                                      Package certificates contains functionality for working with Magnum Certificate resources.
                                                                                                                                                                                                                                                      Package certificates contains functionality for working with Magnum Certificate resources.
                                                                                                                                                                                                                                                      containerinfra/v1/clusters
                                                                                                                                                                                                                                                      Package clusters contains functionality for working with Magnum Cluster resources.
                                                                                                                                                                                                                                                      Package clusters contains functionality for working with Magnum Cluster resources.
                                                                                                                                                                                                                                                      containerinfra/v1/clustertemplates
                                                                                                                                                                                                                                                      Package clustertemplates contains functionality for working with Magnum Cluster Templates resources.
                                                                                                                                                                                                                                                      Package clustertemplates contains functionality for working with Magnum Cluster Templates resources.
                                                                                                                                                                                                                                                      containerinfra/v1/nodegroups
                                                                                                                                                                                                                                                      Package nodegroups provides methods for interacting with the Magnum node group API.
                                                                                                                                                                                                                                                      Package nodegroups provides methods for interacting with the Magnum node group API.
                                                                                                                                                                                                                                                      containerinfra/v1/quotas
                                                                                                                                                                                                                                                      Package quotas contains functionality for working with Magnum Quota API.
                                                                                                                                                                                                                                                      Package quotas contains functionality for working with Magnum Quota API.
                                                                                                                                                                                                                                                      db/v1/configurations
                                                                                                                                                                                                                                                      Package configurations provides information and interaction with the configuration API resource in the Rackspace Database service.
                                                                                                                                                                                                                                                      Package configurations provides information and interaction with the configuration API resource in the Rackspace Database service.
                                                                                                                                                                                                                                                      db/v1/configurations/testing
                                                                                                                                                                                                                                                      db_configurations_v1
                                                                                                                                                                                                                                                      db_configurations_v1
                                                                                                                                                                                                                                                      db/v1/databases
                                                                                                                                                                                                                                                      Package flavors provides information and interaction with the database API resource in the OpenStack Database service.
                                                                                                                                                                                                                                                      Package flavors provides information and interaction with the database API resource in the OpenStack Database service.
                                                                                                                                                                                                                                                      db/v1/databases/testing
                                                                                                                                                                                                                                                      db_databases_v1
                                                                                                                                                                                                                                                      db_databases_v1
                                                                                                                                                                                                                                                      db/v1/datastores
                                                                                                                                                                                                                                                      Package datastores provides information and interaction with the datastore API resource in the Rackspace Database service.
                                                                                                                                                                                                                                                      Package datastores provides information and interaction with the datastore API resource in the Rackspace Database service.
                                                                                                                                                                                                                                                      db/v1/datastores/testing
                                                                                                                                                                                                                                                      db_datastores_v1
                                                                                                                                                                                                                                                      db_datastores_v1
                                                                                                                                                                                                                                                      db/v1/flavors
                                                                                                                                                                                                                                                      Package flavors provides information and interaction with the flavor API resource in the OpenStack Database service.
                                                                                                                                                                                                                                                      Package flavors provides information and interaction with the flavor API resource in the OpenStack Database service.
                                                                                                                                                                                                                                                      db/v1/flavors/testing
                                                                                                                                                                                                                                                      db_flavors_v1
                                                                                                                                                                                                                                                      db_flavors_v1
                                                                                                                                                                                                                                                      db/v1/instances
                                                                                                                                                                                                                                                      Package instances provides information and interaction with the instance API resource in the OpenStack Database service.
                                                                                                                                                                                                                                                      Package instances provides information and interaction with the instance API resource in the OpenStack Database service.
                                                                                                                                                                                                                                                      db/v1/instances/testing
                                                                                                                                                                                                                                                      db_instances_v1
                                                                                                                                                                                                                                                      db_instances_v1
                                                                                                                                                                                                                                                      db/v1/users
                                                                                                                                                                                                                                                      Package users provides information and interaction with the user API resource in the OpenStack Database service.
                                                                                                                                                                                                                                                      Package users provides information and interaction with the user API resource in the OpenStack Database service.
                                                                                                                                                                                                                                                      db/v1/users/testing
                                                                                                                                                                                                                                                      db_users_v1
                                                                                                                                                                                                                                                      db_users_v1
                                                                                                                                                                                                                                                      dns/v2/recordsets
                                                                                                                                                                                                                                                      Package recordsets provides information and interaction with the zone API resource for the OpenStack DNS service.
                                                                                                                                                                                                                                                      Package recordsets provides information and interaction with the zone API resource for the OpenStack DNS service.
                                                                                                                                                                                                                                                      dns/v2/recordsets/testing
                                                                                                                                                                                                                                                      recordsets unit tests
                                                                                                                                                                                                                                                      recordsets unit tests
                                                                                                                                                                                                                                                      dns/v2/transfer/accept
                                                                                                                                                                                                                                                      Package zones provides information and interaction with the zone API resource for the OpenStack DNS service.
                                                                                                                                                                                                                                                      Package zones provides information and interaction with the zone API resource for the OpenStack DNS service.
                                                                                                                                                                                                                                                      dns/v2/transfer/accept/testing
                                                                                                                                                                                                                                                      transfer requests unit tests
                                                                                                                                                                                                                                                      transfer requests unit tests
                                                                                                                                                                                                                                                      dns/v2/transfer/request
                                                                                                                                                                                                                                                      Package zones provides information and interaction with the zone API resource for the OpenStack DNS service.
                                                                                                                                                                                                                                                      Package zones provides information and interaction with the zone API resource for the OpenStack DNS service.
                                                                                                                                                                                                                                                      dns/v2/transfer/request/testing
                                                                                                                                                                                                                                                      transfer requests unit tests
                                                                                                                                                                                                                                                      transfer requests unit tests
                                                                                                                                                                                                                                                      dns/v2/zones
                                                                                                                                                                                                                                                      Package zones provides information and interaction with the zone API resource for the OpenStack DNS service.
                                                                                                                                                                                                                                                      Package zones provides information and interaction with the zone API resource for the OpenStack DNS service.
                                                                                                                                                                                                                                                      dns/v2/zones/testing
                                                                                                                                                                                                                                                      zones unit tests
                                                                                                                                                                                                                                                      zones unit tests
                                                                                                                                                                                                                                                      identity/v2/extensions
                                                                                                                                                                                                                                                      Package extensions provides information and interaction with the different extensions available for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package extensions provides information and interaction with the different extensions available for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v2/extensions/admin/roles
                                                                                                                                                                                                                                                      Package roles provides functionality to interact with and control roles on the API.
                                                                                                                                                                                                                                                      Package roles provides functionality to interact with and control roles on the API.
                                                                                                                                                                                                                                                      roles unit tests
                                                                                                                                                                                                                                                      identity/v2/extensions/testing
                                                                                                                                                                                                                                                      extensions unit tests
                                                                                                                                                                                                                                                      extensions unit tests
                                                                                                                                                                                                                                                      identity/v2/tenants
                                                                                                                                                                                                                                                      Package tenants provides information and interaction with the tenants API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package tenants provides information and interaction with the tenants API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v2/tenants/testing
                                                                                                                                                                                                                                                      tenants unit tests
                                                                                                                                                                                                                                                      tenants unit tests
                                                                                                                                                                                                                                                      identity/v2/tokens
                                                                                                                                                                                                                                                      Package tokens provides information and interaction with the token API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package tokens provides information and interaction with the token API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v2/tokens/testing
                                                                                                                                                                                                                                                      tokens unit tests
                                                                                                                                                                                                                                                      tokens unit tests
                                                                                                                                                                                                                                                      identity/v2/users
                                                                                                                                                                                                                                                      Package users provides information and interaction with the users API resource for the OpenStack Identity Service.
                                                                                                                                                                                                                                                      Package users provides information and interaction with the users API resource for the OpenStack Identity Service.
                                                                                                                                                                                                                                                      identity/v2/users/testing
                                                                                                                                                                                                                                                      users unit tests
                                                                                                                                                                                                                                                      users unit tests
                                                                                                                                                                                                                                                      identity/v3/domains
                                                                                                                                                                                                                                                      Package domains manages and retrieves Domains in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      Package domains manages and retrieves Domains in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      identity/v3/endpoints
                                                                                                                                                                                                                                                      Package endpoints provides information and interaction with the service endpoints API resource in the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package endpoints provides information and interaction with the service endpoints API resource in the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v3/endpoints/testing
                                                                                                                                                                                                                                                      endpoints unit tests
                                                                                                                                                                                                                                                      endpoints unit tests
                                                                                                                                                                                                                                                      identity/v3/extensions/ec2credentials
                                                                                                                                                                                                                                                      Package ec2credentials provides information and interaction with the EC2 credentials API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package ec2credentials provides information and interaction with the EC2 credentials API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v3/extensions/ec2tokens
                                                                                                                                                                                                                                                      Package tokens provides information and interaction with the EC2 token API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package tokens provides information and interaction with the EC2 token API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v3/extensions/oauth1
                                                                                                                                                                                                                                                      Package oauth1 enables management of OpenStack OAuth1 tokens and Authentication.
                                                                                                                                                                                                                                                      Package oauth1 enables management of OpenStack OAuth1 tokens and Authentication.
                                                                                                                                                                                                                                                      identity/v3/extensions/trusts
                                                                                                                                                                                                                                                      Package trusts enables management of OpenStack Identity Trusts.
                                                                                                                                                                                                                                                      Package trusts enables management of OpenStack Identity Trusts.
                                                                                                                                                                                                                                                      trusts unit tests
                                                                                                                                                                                                                                                      identity/v3/groups
                                                                                                                                                                                                                                                      Package groups manages and retrieves Groups in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      Package groups manages and retrieves Groups in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      identity/v3/policies
                                                                                                                                                                                                                                                      Package policies provides information and interaction with the policies API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package policies provides information and interaction with the policies API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v3/policies/testing
                                                                                                                                                                                                                                                      Package testing contains policies unit tests
                                                                                                                                                                                                                                                      Package testing contains policies unit tests
                                                                                                                                                                                                                                                      identity/v3/projects
                                                                                                                                                                                                                                                      Package projects manages and retrieves Projects in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      Package projects manages and retrieves Projects in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      identity/v3/regions
                                                                                                                                                                                                                                                      Package regions manages and retrieves Regions in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      Package regions manages and retrieves Regions in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      identity/v3/roles
                                                                                                                                                                                                                                                      Package roles provides information and interaction with the roles API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package roles provides information and interaction with the roles API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v3/roles/testing
                                                                                                                                                                                                                                                      roles unit tests
                                                                                                                                                                                                                                                      roles unit tests
                                                                                                                                                                                                                                                      identity/v3/services
                                                                                                                                                                                                                                                      Package services provides information and interaction with the services API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package services provides information and interaction with the services API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v3/services/testing
                                                                                                                                                                                                                                                      services unit tests
                                                                                                                                                                                                                                                      services unit tests
                                                                                                                                                                                                                                                      identity/v3/tokens
                                                                                                                                                                                                                                                      Package tokens provides information and interaction with the token API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      Package tokens provides information and interaction with the token API resource for the OpenStack Identity service.
                                                                                                                                                                                                                                                      identity/v3/tokens/testing
                                                                                                                                                                                                                                                      tokens unit tests
                                                                                                                                                                                                                                                      tokens unit tests
                                                                                                                                                                                                                                                      identity/v3/users
                                                                                                                                                                                                                                                      Package users manages and retrieves Users in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      Package users manages and retrieves Users in the OpenStack Identity Service.
                                                                                                                                                                                                                                                      imageservice/v2/imagedata
                                                                                                                                                                                                                                                      Package imagedata enables management of image data.
                                                                                                                                                                                                                                                      Package imagedata enables management of image data.
                                                                                                                                                                                                                                                      imageservice/v2/imagedata/testing
                                                                                                                                                                                                                                                      imagedata unit tests
                                                                                                                                                                                                                                                      imagedata unit tests
                                                                                                                                                                                                                                                      imageservice/v2/imageimport
                                                                                                                                                                                                                                                      Package imageimport enables management of images import and retrieval of the Imageservice Import API information.
                                                                                                                                                                                                                                                      Package imageimport enables management of images import and retrieval of the Imageservice Import API information.
                                                                                                                                                                                                                                                      imageservice/v2/images
                                                                                                                                                                                                                                                      Package images enables management and retrieval of images from the OpenStack Image Service.
                                                                                                                                                                                                                                                      Package images enables management and retrieval of images from the OpenStack Image Service.
                                                                                                                                                                                                                                                      imageservice/v2/images/testing
                                                                                                                                                                                                                                                      images unit tests
                                                                                                                                                                                                                                                      images unit tests
                                                                                                                                                                                                                                                      imageservice/v2/members
                                                                                                                                                                                                                                                      Package members enables management and retrieval of image members.
                                                                                                                                                                                                                                                      Package members enables management and retrieval of image members.
                                                                                                                                                                                                                                                      imageservice/v2/members/testing
                                                                                                                                                                                                                                                      members unit tests
                                                                                                                                                                                                                                                      members unit tests
                                                                                                                                                                                                                                                      imageservice/v2/tasks
                                                                                                                                                                                                                                                      Package tasks enables management and retrieval of tasks from the OpenStack Imageservice.
                                                                                                                                                                                                                                                      Package tasks enables management and retrieval of tasks from the OpenStack Imageservice.
                                                                                                                                                                                                                                                      tasks unit tests
                                                                                                                                                                                                                                                      keymanager/v1/acls
                                                                                                                                                                                                                                                      Package acls manages acls in the OpenStack Key Manager Service.
                                                                                                                                                                                                                                                      Package acls manages acls in the OpenStack Key Manager Service.
                                                                                                                                                                                                                                                      keymanager/v1/containers
                                                                                                                                                                                                                                                      Package containers manages and retrieves containers in the OpenStack Key Manager Service.
                                                                                                                                                                                                                                                      Package containers manages and retrieves containers in the OpenStack Key Manager Service.
                                                                                                                                                                                                                                                      keymanager/v1/orders
                                                                                                                                                                                                                                                      Package orders manages and retrieves orders in the OpenStack Key Manager Service.
                                                                                                                                                                                                                                                      Package orders manages and retrieves orders in the OpenStack Key Manager Service.
                                                                                                                                                                                                                                                      keymanager/v1/secrets
                                                                                                                                                                                                                                                      Package secrets manages and retrieves secrets in the OpenStack Key Manager Service.
                                                                                                                                                                                                                                                      Package secrets manages and retrieves secrets in the OpenStack Key Manager Service.
                                                                                                                                                                                                                                                      loadbalancer/v2
                                                                                                                                                                                                                                                      Package lbaas_v2 provides information and interaction with the Load Balancer as a Service v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package lbaas_v2 provides information and interaction with the Load Balancer as a Service v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      loadbalancer/v2/amphorae
                                                                                                                                                                                                                                                      Package amphorae provides information and interaction with Amphorae of OpenStack Load-balancing service.
                                                                                                                                                                                                                                                      Package amphorae provides information and interaction with Amphorae of OpenStack Load-balancing service.
                                                                                                                                                                                                                                                      loadbalancer/v2/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Load Balancer service.
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Load Balancer service.
                                                                                                                                                                                                                                                      loadbalancer/v2/apiversions/testing
                                                                                                                                                                                                                                                      apiversions unit tests
                                                                                                                                                                                                                                                      apiversions unit tests
                                                                                                                                                                                                                                                      loadbalancer/v2/l7policies
                                                                                                                                                                                                                                                      Package l7policies provides information and interaction with L7Policies and Rules of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package l7policies provides information and interaction with L7Policies and Rules of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      loadbalancer/v2/l7policies/testing
                                                                                                                                                                                                                                                      l7policies unit tests
                                                                                                                                                                                                                                                      l7policies unit tests
                                                                                                                                                                                                                                                      loadbalancer/v2/listeners
                                                                                                                                                                                                                                                      Package listeners provides information and interaction with Listeners of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package listeners provides information and interaction with Listeners of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      loadbalancer/v2/listeners/testing
                                                                                                                                                                                                                                                      listeners unit tests
                                                                                                                                                                                                                                                      listeners unit tests
                                                                                                                                                                                                                                                      loadbalancer/v2/loadbalancers
                                                                                                                                                                                                                                                      Package loadbalancers provides information and interaction with Load Balancers of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package loadbalancers provides information and interaction with Load Balancers of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      loadbalancer/v2/loadbalancers/testing
                                                                                                                                                                                                                                                      loadbalancers unit tests
                                                                                                                                                                                                                                                      loadbalancers unit tests
                                                                                                                                                                                                                                                      loadbalancer/v2/monitors
                                                                                                                                                                                                                                                      Package monitors provides information and interaction with Monitors of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package monitors provides information and interaction with Monitors of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      loadbalancer/v2/monitors/testing
                                                                                                                                                                                                                                                      monitors unit tests
                                                                                                                                                                                                                                                      monitors unit tests
                                                                                                                                                                                                                                                      loadbalancer/v2/pools
                                                                                                                                                                                                                                                      Package pools provides information and interaction with Pools and Members of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package pools provides information and interaction with Pools and Members of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      pools unit tests
                                                                                                                                                                                                                                                      loadbalancer/v2/providers
                                                                                                                                                                                                                                                      Package providers provides information about the supported providers at OpenStack Octavia Load Balancing service.
                                                                                                                                                                                                                                                      Package providers provides information about the supported providers at OpenStack Octavia Load Balancing service.
                                                                                                                                                                                                                                                      loadbalancer/v2/providers/testing
                                                                                                                                                                                                                                                      providers unit tests
                                                                                                                                                                                                                                                      providers unit tests
                                                                                                                                                                                                                                                      loadbalancer/v2/quotas
                                                                                                                                                                                                                                                      Package quotas provides the ability to retrieve and manage Load Balancer quotas Example to Get project quotas projectID = "23d5d3f79dfa4f73b72b8b0b0063ec55" quotasInfo, err := quotas.Get(networkClient, projectID).Extract() if err != nil { log.Fatal(err) } fmt.Printf("quotas: %#v\n", quotasInfo) Example to Update project quotas projectID = "23d5d3f79dfa4f73b72b8b0b0063ec55" updateOpts := quotas.UpdateOpts{ Loadbalancer: gophercloud.IntToPointer(20), Listener: gophercloud.IntToPointer(40), Member: gophercloud.IntToPointer(200), Pool: gophercloud.IntToPointer(20), Healthmonitor: gophercloud.IntToPointer(1), L7Policy: gophercloud.IntToPointer(50), L7Rule: gophercloud.IntToPointer(100), } quotasInfo, err := quotas.Update(networkClient, projectID) if err != nil { log.Fatal(err) } fmt.Printf("quotas: %#v\n", quotasInfo)
                                                                                                                                                                                                                                                      Package quotas provides the ability to retrieve and manage Load Balancer quotas Example to Get project quotas projectID = "23d5d3f79dfa4f73b72b8b0b0063ec55" quotasInfo, err := quotas.Get(networkClient, projectID).Extract() if err != nil { log.Fatal(err) } fmt.Printf("quotas: %#v\n", quotasInfo) Example to Update project quotas projectID = "23d5d3f79dfa4f73b72b8b0b0063ec55" updateOpts := quotas.UpdateOpts{ Loadbalancer: gophercloud.IntToPointer(20), Listener: gophercloud.IntToPointer(40), Member: gophercloud.IntToPointer(200), Pool: gophercloud.IntToPointer(20), Healthmonitor: gophercloud.IntToPointer(1), L7Policy: gophercloud.IntToPointer(50), L7Rule: gophercloud.IntToPointer(100), } quotasInfo, err := quotas.Update(networkClient, projectID) if err != nil { log.Fatal(err) } fmt.Printf("quotas: %#v\n", quotasInfo)
                                                                                                                                                                                                                                                      loadbalancer/v2/quotas/testing
                                                                                                                                                                                                                                                      quotas unit tests
                                                                                                                                                                                                                                                      quotas unit tests
                                                                                                                                                                                                                                                      messaging/v2/claims
                                                                                                                                                                                                                                                      Package claims provides information and interaction with the Zaqar API claims resource for the OpenStack Messaging service.
                                                                                                                                                                                                                                                      Package claims provides information and interaction with the Zaqar API claims resource for the OpenStack Messaging service.
                                                                                                                                                                                                                                                      messaging/v2/claims/testing
                                                                                                                                                                                                                                                      Claims unit tests
                                                                                                                                                                                                                                                      Claims unit tests
                                                                                                                                                                                                                                                      messaging/v2/messages
                                                                                                                                                                                                                                                      Package messages provides information and interaction with the messages through the OpenStack Messaging(Zaqar) service.
                                                                                                                                                                                                                                                      Package messages provides information and interaction with the messages through the OpenStack Messaging(Zaqar) service.
                                                                                                                                                                                                                                                      messaging/v2/messages/testing
                                                                                                                                                                                                                                                      messages unit tests
                                                                                                                                                                                                                                                      messages unit tests
                                                                                                                                                                                                                                                      messaging/v2/queues
                                                                                                                                                                                                                                                      Package queues provides information and interaction with the queues through the OpenStack Messaging (Zaqar) service.
                                                                                                                                                                                                                                                      Package queues provides information and interaction with the queues through the OpenStack Messaging (Zaqar) service.
                                                                                                                                                                                                                                                      messaging/v2/queues/testing
                                                                                                                                                                                                                                                      queues unit tests
                                                                                                                                                                                                                                                      queues unit tests
                                                                                                                                                                                                                                                      networking/v2/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Neutron service.
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Neutron service.
                                                                                                                                                                                                                                                      networking/v2/apiversions/testing
                                                                                                                                                                                                                                                      apiversions unit tests
                                                                                                                                                                                                                                                      apiversions unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/agents
                                                                                                                                                                                                                                                      Package agents provides the ability to retrieve and manage Agents through the Neutron API.
                                                                                                                                                                                                                                                      Package agents provides the ability to retrieve and manage Agents through the Neutron API.
                                                                                                                                                                                                                                                      agents unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/attributestags
                                                                                                                                                                                                                                                      Package attributestags manages Tags on Resources created by the OpenStack Neutron Service.
                                                                                                                                                                                                                                                      Package attributestags manages Tags on Resources created by the OpenStack Neutron Service.
                                                                                                                                                                                                                                                      networking/v2/extensions/external
                                                                                                                                                                                                                                                      Package external provides information and interaction with the external extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package external provides information and interaction with the external extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      external unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/extradhcpopts
                                                                                                                                                                                                                                                      Package extradhcpopts allow to work with extra DHCP functionality of Neutron ports.
                                                                                                                                                                                                                                                      Package extradhcpopts allow to work with extra DHCP functionality of Neutron ports.
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas
                                                                                                                                                                                                                                                      Package fwaas provides information and interaction with the Firewall as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package fwaas provides information and interaction with the Firewall as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas/firewalls
                                                                                                                                                                                                                                                      Package firewalls allows management and retrieval of firewalls from the OpenStack Networking Service.
                                                                                                                                                                                                                                                      Package firewalls allows management and retrieval of firewalls from the OpenStack Networking Service.
                                                                                                                                                                                                                                                      firewalls unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas/policies
                                                                                                                                                                                                                                                      Package policies allows management and retrieval of Firewall Policies in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      Package policies allows management and retrieval of Firewall Policies in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      policies unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas/routerinsertion
                                                                                                                                                                                                                                                      Package routerinsertion implements the fwaasrouterinsertion Firewall extension.
                                                                                                                                                                                                                                                      Package routerinsertion implements the fwaasrouterinsertion Firewall extension.
                                                                                                                                                                                                                                                      routerinsertion unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas/rules
                                                                                                                                                                                                                                                      Package rules enables management and retrieval of Firewall Rules in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      Package rules enables management and retrieval of Firewall Rules in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      rules unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas_v2
                                                                                                                                                                                                                                                      Package fwaas provides information and interaction with the Firewall as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package fwaas provides information and interaction with the Firewall as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas_v2/groups/testing
                                                                                                                                                                                                                                                      networking_extensions_fwaas_groups_v2
                                                                                                                                                                                                                                                      networking_extensions_fwaas_groups_v2
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas_v2/policies/testing
                                                                                                                                                                                                                                                      networking_extensions_fwaas_policies_v2
                                                                                                                                                                                                                                                      networking_extensions_fwaas_policies_v2
                                                                                                                                                                                                                                                      networking/v2/extensions/fwaas_v2/rules/testing
                                                                                                                                                                                                                                                      networking_extensions_fwaas_rules_v2
                                                                                                                                                                                                                                                      networking_extensions_fwaas_rules_v2
                                                                                                                                                                                                                                                      networking/v2/extensions/layer3
                                                                                                                                                                                                                                                      Package layer3 provides access to the Layer-3 networking extension for the OpenStack Neutron service.
                                                                                                                                                                                                                                                      Package layer3 provides access to the Layer-3 networking extension for the OpenStack Neutron service.
                                                                                                                                                                                                                                                      networking/v2/extensions/layer3/addressscopes
                                                                                                                                                                                                                                                      Package addressscopes provides the ability to retrieve and manage Address scopes through the Neutron API.
                                                                                                                                                                                                                                                      Package addressscopes provides the ability to retrieve and manage Address scopes through the Neutron API.
                                                                                                                                                                                                                                                      subnetpools unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/layer3/floatingips
                                                                                                                                                                                                                                                      package floatingips enables management and retrieval of Floating IPs from the OpenStack Networking service.
                                                                                                                                                                                                                                                      package floatingips enables management and retrieval of Floating IPs from the OpenStack Networking service.
                                                                                                                                                                                                                                                      floatingips unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/layer3/portforwarding
                                                                                                                                                                                                                                                      package portforwarding enables management and retrieval of port forwarding resources for Floating IPs from the OpenStack Networking service.
                                                                                                                                                                                                                                                      package portforwarding enables management and retrieval of port forwarding resources for Floating IPs from the OpenStack Networking service.
                                                                                                                                                                                                                                                      port forwarding unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/layer3/routers
                                                                                                                                                                                                                                                      Package routers enables management and retrieval of Routers from the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package routers enables management and retrieval of Routers from the OpenStack Networking service.
                                                                                                                                                                                                                                                      routers unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas
                                                                                                                                                                                                                                                      Package lbaas provides information and interaction with the Load Balancer as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package lbaas provides information and interaction with the Load Balancer as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas/members
                                                                                                                                                                                                                                                      Package members provides information and interaction with Members of the Load Balancer as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package members provides information and interaction with Members of the Load Balancer as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      members unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas/monitors
                                                                                                                                                                                                                                                      Package monitors provides information and interaction with the Monitors of the Load Balancer as a Service extension for the OpenStack Networking Service.
                                                                                                                                                                                                                                                      Package monitors provides information and interaction with the Monitors of the Load Balancer as a Service extension for the OpenStack Networking Service.
                                                                                                                                                                                                                                                      monitors unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas/pools
                                                                                                                                                                                                                                                      Package pools provides information and interaction with the Pools of the Load Balancing as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package pools provides information and interaction with the Pools of the Load Balancing as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      pools unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas/vips
                                                                                                                                                                                                                                                      Package vips provides information and interaction with the Virtual IPs of the Load Balancing as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package vips provides information and interaction with the Virtual IPs of the Load Balancing as a Service extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      vips unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas_v2
                                                                                                                                                                                                                                                      Package lbaas_v2 provides information and interaction with the Load Balancer as a Service v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package lbaas_v2 provides information and interaction with the Load Balancer as a Service v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas_v2/l7policies
                                                                                                                                                                                                                                                      Package l7policies provides information and interaction with L7Policies and Rules of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package l7policies provides information and interaction with L7Policies and Rules of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      l7policies unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas_v2/listeners
                                                                                                                                                                                                                                                      Package listeners provides information and interaction with Listeners of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package listeners provides information and interaction with Listeners of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      listeners unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas_v2/loadbalancers
                                                                                                                                                                                                                                                      Package loadbalancers provides information and interaction with Load Balancers of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package loadbalancers provides information and interaction with Load Balancers of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      loadbalancers unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas_v2/monitors
                                                                                                                                                                                                                                                      Package monitors provides information and interaction with Monitors of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package monitors provides information and interaction with Monitors of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      monitors unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/lbaas_v2/pools
                                                                                                                                                                                                                                                      Package pools provides information and interaction with Pools and Members of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package pools provides information and interaction with Pools and Members of the LBaaS v2 extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      pools unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/networkipavailabilities
                                                                                                                                                                                                                                                      Package networkipavailabilities provides the ability to retrieve and manage networkipavailabilities through the Neutron API.
                                                                                                                                                                                                                                                      Package networkipavailabilities provides the ability to retrieve and manage networkipavailabilities through the Neutron API.
                                                                                                                                                                                                                                                      networkipavailabilities unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/portsbinding
                                                                                                                                                                                                                                                      Package portsbinding provides information and interaction with the port binding extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package portsbinding provides information and interaction with the port binding extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      portsbindings unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/portsecurity
                                                                                                                                                                                                                                                      Package portsecurity provides information and interaction with the port security extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package portsecurity provides information and interaction with the port security extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      networking/v2/extensions/provider
                                                                                                                                                                                                                                                      Package provider gives access to the provider Neutron plugin, allowing network extended attributes.
                                                                                                                                                                                                                                                      Package provider gives access to the provider Neutron plugin, allowing network extended attributes.
                                                                                                                                                                                                                                                      provider unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/qos/policies
                                                                                                                                                                                                                                                      Package policies provides information and interaction with the QoS policy extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package policies provides information and interaction with the QoS policy extension for the OpenStack Networking service.
                                                                                                                                                                                                                                                      networking/v2/extensions/qos/rules
                                                                                                                                                                                                                                                      Package rules provides the ability to retrieve and manage QoS policy rules through the Neutron API.
                                                                                                                                                                                                                                                      Package rules provides the ability to retrieve and manage QoS policy rules through the Neutron API.
                                                                                                                                                                                                                                                      networking/v2/extensions/qos/rules/testing
                                                                                                                                                                                                                                                      QoS policy rules unit tests
                                                                                                                                                                                                                                                      QoS policy rules unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/qos/ruletypes
                                                                                                                                                                                                                                                      Package ruletypes contains functionality for working with Neutron 'quality of service' rule-type resources.
                                                                                                                                                                                                                                                      Package ruletypes contains functionality for working with Neutron 'quality of service' rule-type resources.
                                                                                                                                                                                                                                                      qos unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/quotas
                                                                                                                                                                                                                                                      Package quotas provides the ability to retrieve and manage Networking quotas through the Neutron API.
                                                                                                                                                                                                                                                      Package quotas provides the ability to retrieve and manage Networking quotas through the Neutron API.
                                                                                                                                                                                                                                                      quotas unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/rbacpolicies
                                                                                                                                                                                                                                                      Package rbacpolicies contains functionality for working with Neutron RBAC Policies.
                                                                                                                                                                                                                                                      Package rbacpolicies contains functionality for working with Neutron RBAC Policies.
                                                                                                                                                                                                                                                      networking/v2/extensions/rbacpolicies/testing
                                                                                                                                                                                                                                                      Package testing includes rbac unit tests
                                                                                                                                                                                                                                                      Package testing includes rbac unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/security
                                                                                                                                                                                                                                                      Package security contains functionality to work with security group and security group rules Neutron resources.
                                                                                                                                                                                                                                                      Package security contains functionality to work with security group and security group rules Neutron resources.
                                                                                                                                                                                                                                                      networking/v2/extensions/security/groups
                                                                                                                                                                                                                                                      Package groups provides information and interaction with Security Groups for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package groups provides information and interaction with Security Groups for the OpenStack Networking service.
                                                                                                                                                                                                                                                      groups unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/security/rules
                                                                                                                                                                                                                                                      Package rules provides information and interaction with Security Group Rules for the OpenStack Networking service.
                                                                                                                                                                                                                                                      Package rules provides information and interaction with Security Group Rules for the OpenStack Networking service.
                                                                                                                                                                                                                                                      rules unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/subnetpools
                                                                                                                                                                                                                                                      Package subnetpools provides the ability to retrieve and manage subnetpools through the Neutron API.
                                                                                                                                                                                                                                                      Package subnetpools provides the ability to retrieve and manage subnetpools through the Neutron API.
                                                                                                                                                                                                                                                      subnetpools unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/testing
                                                                                                                                                                                                                                                      extensions unit tests
                                                                                                                                                                                                                                                      extensions unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/trunks
                                                                                                                                                                                                                                                      Package trunks provides the ability to retrieve and manage trunks through the Neutron API.
                                                                                                                                                                                                                                                      Package trunks provides the ability to retrieve and manage trunks through the Neutron API.
                                                                                                                                                                                                                                                      trunks unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/vlantransparent
                                                                                                                                                                                                                                                      Package vlantransparent provides the ability to retrieve and manage networks with the vlan-transparent extension through the Neutron API.
                                                                                                                                                                                                                                                      Package vlantransparent provides the ability to retrieve and manage networks with the vlan-transparent extension through the Neutron API.
                                                                                                                                                                                                                                                      networking/v2/extensions/vlantransparent/testing
                                                                                                                                                                                                                                                      vlantransparent extension unit tests
                                                                                                                                                                                                                                                      vlantransparent extension unit tests
                                                                                                                                                                                                                                                      networking/v2/extensions/vpnaas/endpointgroups
                                                                                                                                                                                                                                                      Package endpointgroups allows management of endpoint groups in the Openstack Network Service Example to create an Endpoint Group createOpts := endpointgroups.CreateOpts{ Name: groupName, Type: endpointgroups.TypeCIDR, Endpoints: []string{ "10.2.0.0/24", "10.3.0.0/24", }, } group, err := endpointgroups.Create(client, createOpts).Extract() if err != nil { return group, err } Example to retrieve an Endpoint Group group, err := endpointgroups.Get(client, "6ecd9cf3-ca64-46c7-863f-f2eb1b9e838a").Extract() if err != nil { panic(err) } Example to Delete an Endpoint Group err := endpointgroups.Delete(client, "5291b189-fd84-46e5-84bd-78f40c05d69c").ExtractErr() if err != nil { panic(err) } Example to List Endpoint groups allPages, err := endpointgroups.List(client, nil).AllPages() if err != nil { panic(err) } allGroups, err := endpointgroups.ExtractEndpointGroups(allPages) if err != nil { panic(err) } Example to Update an endpoint group name := "updatedname" description := "updated description" updateOpts := endpointgroups.UpdateOpts{ Name: &name, Description: &description, } updatedPolicy, err := endpointgroups.Update(client, "5c561d9d-eaea-45f6-ae3e-08d1a7080828", updateOpts).Extract() if err != nil { panic(err) }
                                                                                                                                                                                                                                                      Package endpointgroups allows management of endpoint groups in the Openstack Network Service Example to create an Endpoint Group createOpts := endpointgroups.CreateOpts{ Name: groupName, Type: endpointgroups.TypeCIDR, Endpoints: []string{ "10.2.0.0/24", "10.3.0.0/24", }, } group, err := endpointgroups.Create(client, createOpts).Extract() if err != nil { return group, err } Example to retrieve an Endpoint Group group, err := endpointgroups.Get(client, "6ecd9cf3-ca64-46c7-863f-f2eb1b9e838a").Extract() if err != nil { panic(err) } Example to Delete an Endpoint Group err := endpointgroups.Delete(client, "5291b189-fd84-46e5-84bd-78f40c05d69c").ExtractErr() if err != nil { panic(err) } Example to List Endpoint groups allPages, err := endpointgroups.List(client, nil).AllPages() if err != nil { panic(err) } allGroups, err := endpointgroups.ExtractEndpointGroups(allPages) if err != nil { panic(err) } Example to Update an endpoint group name := "updatedname" description := "updated description" updateOpts := endpointgroups.UpdateOpts{ Name: &name, Description: &description, } updatedPolicy, err := endpointgroups.Update(client, "5c561d9d-eaea-45f6-ae3e-08d1a7080828", updateOpts).Extract() if err != nil { panic(err) }
                                                                                                                                                                                                                                                      networking/v2/extensions/vpnaas/ikepolicies
                                                                                                                                                                                                                                                      Package ikepolicies allows management and retrieval of IKE policies in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      Package ikepolicies allows management and retrieval of IKE policies in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      networking/v2/extensions/vpnaas/ipsecpolicies
                                                                                                                                                                                                                                                      Package ipsecpolicies allows management and retrieval of IPSec Policies in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      Package ipsecpolicies allows management and retrieval of IPSec Policies in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      networking/v2/extensions/vpnaas/services
                                                                                                                                                                                                                                                      Package services allows management and retrieval of VPN services in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      Package services allows management and retrieval of VPN services in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      networking/v2/extensions/vpnaas/siteconnections
                                                                                                                                                                                                                                                      Package siteconnections allows management and retrieval of IPSec site connections in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      Package siteconnections allows management and retrieval of IPSec site connections in the OpenStack Networking Service.
                                                                                                                                                                                                                                                      networking/v2/networks
                                                                                                                                                                                                                                                      Package networks contains functionality for working with Neutron network resources.
                                                                                                                                                                                                                                                      Package networks contains functionality for working with Neutron network resources.
                                                                                                                                                                                                                                                      networking/v2/networks/testing
                                                                                                                                                                                                                                                      networks unit tests
                                                                                                                                                                                                                                                      networks unit tests
                                                                                                                                                                                                                                                      networking/v2/ports
                                                                                                                                                                                                                                                      Package ports contains functionality for working with Neutron port resources.
                                                                                                                                                                                                                                                      Package ports contains functionality for working with Neutron port resources.
                                                                                                                                                                                                                                                      networking/v2/ports/testing
                                                                                                                                                                                                                                                      ports unit tests
                                                                                                                                                                                                                                                      ports unit tests
                                                                                                                                                                                                                                                      networking/v2/subnets
                                                                                                                                                                                                                                                      Package subnets contains functionality for working with Neutron subnet resources.
                                                                                                                                                                                                                                                      Package subnets contains functionality for working with Neutron subnet resources.
                                                                                                                                                                                                                                                      networking/v2/subnets/testing
                                                                                                                                                                                                                                                      subnets unit tests
                                                                                                                                                                                                                                                      subnets unit tests
                                                                                                                                                                                                                                                      objectstorage/v1/accounts
                                                                                                                                                                                                                                                      Package accounts contains functionality for working with Object Storage account resources.
                                                                                                                                                                                                                                                      Package accounts contains functionality for working with Object Storage account resources.
                                                                                                                                                                                                                                                      objectstorage/v1/accounts/testing
                                                                                                                                                                                                                                                      accounts unit tests
                                                                                                                                                                                                                                                      accounts unit tests
                                                                                                                                                                                                                                                      objectstorage/v1/containers
                                                                                                                                                                                                                                                      Package containers contains functionality for working with Object Storage container resources.
                                                                                                                                                                                                                                                      Package containers contains functionality for working with Object Storage container resources.
                                                                                                                                                                                                                                                      objectstorage/v1/containers/testing
                                                                                                                                                                                                                                                      containers unit tests
                                                                                                                                                                                                                                                      containers unit tests
                                                                                                                                                                                                                                                      objectstorage/v1/objects
                                                                                                                                                                                                                                                      Package objects contains functionality for working with Object Storage object resources.
                                                                                                                                                                                                                                                      Package objects contains functionality for working with Object Storage object resources.
                                                                                                                                                                                                                                                      objects unit tests
                                                                                                                                                                                                                                                      objectstorage/v1/swauth
                                                                                                                                                                                                                                                      Package swauth implements Swift's built-in authentication.
                                                                                                                                                                                                                                                      Package swauth implements Swift's built-in authentication.
                                                                                                                                                                                                                                                      swauth unit tests
                                                                                                                                                                                                                                                      orchestration/v1/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Heat service.
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the OpenStack Heat service.
                                                                                                                                                                                                                                                      orchestration/v1/apiversions/testing
                                                                                                                                                                                                                                                      orchestration_apiversions_v1
                                                                                                                                                                                                                                                      orchestration_apiversions_v1
                                                                                                                                                                                                                                                      orchestration/v1/buildinfo
                                                                                                                                                                                                                                                      Package buildinfo provides build information about heat deployments.
                                                                                                                                                                                                                                                      Package buildinfo provides build information about heat deployments.
                                                                                                                                                                                                                                                      orchestration/v1/buildinfo/testing
                                                                                                                                                                                                                                                      orchestration_buildinfo_v1
                                                                                                                                                                                                                                                      orchestration_buildinfo_v1
                                                                                                                                                                                                                                                      orchestration/v1/resourcetypes
                                                                                                                                                                                                                                                      Package resourcetypes provides operations for listing available resource types, obtaining their properties schema, and generating example templates that can be customised to use as provider templates.
                                                                                                                                                                                                                                                      Package resourcetypes provides operations for listing available resource types, obtaining their properties schema, and generating example templates that can be customised to use as provider templates.
                                                                                                                                                                                                                                                      orchestration/v1/stackevents
                                                                                                                                                                                                                                                      Package stackevents provides operations for finding, listing, and retrieving stack events.
                                                                                                                                                                                                                                                      Package stackevents provides operations for finding, listing, and retrieving stack events.
                                                                                                                                                                                                                                                      orchestration/v1/stackevents/testing
                                                                                                                                                                                                                                                      orchestration_stackevents_v1
                                                                                                                                                                                                                                                      orchestration_stackevents_v1
                                                                                                                                                                                                                                                      orchestration/v1/stackresources
                                                                                                                                                                                                                                                      Package stackresources provides operations for working with stack resources.
                                                                                                                                                                                                                                                      Package stackresources provides operations for working with stack resources.
                                                                                                                                                                                                                                                      orchestration/v1/stackresources/testing
                                                                                                                                                                                                                                                      orchestration_stackresources_v1
                                                                                                                                                                                                                                                      orchestration_stackresources_v1
                                                                                                                                                                                                                                                      orchestration/v1/stacks
                                                                                                                                                                                                                                                      Package stacks provides operation for working with Heat stacks.
                                                                                                                                                                                                                                                      Package stacks provides operation for working with Heat stacks.
                                                                                                                                                                                                                                                      orchestration/v1/stacks/testing
                                                                                                                                                                                                                                                      orchestration_stacks_v1
                                                                                                                                                                                                                                                      orchestration_stacks_v1
                                                                                                                                                                                                                                                      orchestration/v1/stacktemplates
                                                                                                                                                                                                                                                      Package stacktemplates provides operations for working with Heat templates.
                                                                                                                                                                                                                                                      Package stacktemplates provides operations for working with Heat templates.
                                                                                                                                                                                                                                                      orchestration/v1/stacktemplates/testing
                                                                                                                                                                                                                                                      orchestration_stacktemplates_v1
                                                                                                                                                                                                                                                      orchestration_stacktemplates_v1
                                                                                                                                                                                                                                                      placement/v1/resourceproviders
                                                                                                                                                                                                                                                      Package resourceproviders creates and lists all resource providers from the OpenStack Placement service.
                                                                                                                                                                                                                                                      Package resourceproviders creates and lists all resource providers from the OpenStack Placement service.
                                                                                                                                                                                                                                                      placement/v1/resourceproviders/testing
                                                                                                                                                                                                                                                      placement resource providers
                                                                                                                                                                                                                                                      placement resource providers
                                                                                                                                                                                                                                                      sharedfilesystems/apiversions
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the Shared File System service, code-named Manila.
                                                                                                                                                                                                                                                      Package apiversions provides information and interaction with the different API versions for the Shared File System service, code-named Manila.
                                                                                                                                                                                                                                                      apiversions_v1
                                                                                                                                                                                                                                                      sharedfilesystems/v2/shares
                                                                                                                                                                                                                                                      Package shares provides information and interaction with the different API versions for the Shared File System service, code-named Manila.
                                                                                                                                                                                                                                                      Package shares provides information and interaction with the different API versions for the Shared File System service, code-named Manila.
                                                                                                                                                                                                                                                      testing
                                                                                                                                                                                                                                                      openstack
                                                                                                                                                                                                                                                      openstack
                                                                                                                                                                                                                                                      utils
                                                                                                                                                                                                                                                      workflow/v2/crontriggers
                                                                                                                                                                                                                                                      Package crontriggers provides interaction with the cron triggers API in the OpenStack Mistral service.
                                                                                                                                                                                                                                                      Package crontriggers provides interaction with the cron triggers API in the OpenStack Mistral service.
                                                                                                                                                                                                                                                      workflow/v2/executions
                                                                                                                                                                                                                                                      Package executions provides interaction with the execution API in the OpenStack Mistral service.
                                                                                                                                                                                                                                                      Package executions provides interaction with the execution API in the OpenStack Mistral service.
                                                                                                                                                                                                                                                      workflow/v2/workflows
                                                                                                                                                                                                                                                      Package workflows provides interaction with the workflows API in the OpenStack Mistral service.
                                                                                                                                                                                                                                                      Package workflows provides interaction with the workflows API in the OpenStack Mistral service.
                                                                                                                                                                                                                                                      Package pagination contains utilities and convenience structs that implement common pagination idioms within OpenStack APIs.
                                                                                                                                                                                                                                                      Package pagination contains utilities and convenience structs that implement common pagination idioms within OpenStack APIs.
                                                                                                                                                                                                                                                      testing
                                                                                                                                                                                                                                                      pagination
                                                                                                                                                                                                                                                      pagination
                                                                                                                                                                                                                                                      Package testhelper container methods that are useful for writing unit tests.
                                                                                                                                                                                                                                                      Package testhelper container methods that are useful for writing unit tests.
                                                                                                                                                                                                                                                      gophercloud
                                                                                                                                                                                                                                                      gophercloud