Documentation

Index

Constants

View Source
const AdminUser = "admin@local"

    AdminUser is the initial admin user created for all controllers.

    Variables

    View Source
    var (
    	ErrNotBootstrapped  = errors.New("model is not bootstrapped")
    	ErrNoInstances      = errors.NotFoundf("instances")
    	ErrPartialInstances = errors.New("only some instances were found")
    )
    View Source
    var AddressesRefreshAttempt = utils.AttemptStrategy{
    	Total: 3 * time.Minute,
    	Delay: 1 * time.Second,
    }

      AddressesRefreshAttempt is the attempt strategy used when refreshing instance addresses.

      View Source
      var SupportsNetworking = supportsNetworking

        SupportsNetworking is a convenience helper to check if an environment supports networking. It returns an interface containing Environ and Networking in this case.

        Functions

        func APIInfo

        func APIInfo(controllerUUID, modelUUID, caCert string, apiPort int, env Environ) (*api.Info, error)

          APIInfo returns an api.Info for the environment. The result is populated with addresses and CA certificate, but no tag or password.

          func CheckProviderAPI

          func CheckProviderAPI(env Environ) error

            CheckProviderAPI returns an error if a simple API call to check a basic response from the specified environ fails.

            func Destroy

            func Destroy(
            	controllerName string,
            	env Environ,
            	store jujuclient.ControllerStore,
            ) error

              Destroy destroys the controller and, if successful, its associated configuration data from the given store.

              func ImageMetadataSources

              func ImageMetadataSources(env Environ) ([]simplestreams.DataSource, error)

                ImageMetadataSources returns the sources to use when looking for simplestreams image id metadata for the given stream.

                func RegisterImageDataSourceFunc

                func RegisterImageDataSourceFunc(id string, f ImageDataSourceFunc)

                  RegisterImageDataSourceFunc registers an ImageDataSourceFunc with the specified id, overwriting any function previously registered with the same id.

                  func RegisterProvider

                  func RegisterProvider(name string, p EnvironProvider, alias ...string)

                    RegisterProvider registers a new environment provider. Name gives the name of the provider, and p the interface to that provider.

                    RegisterProvider will panic if the provider name or any of the aliases are registered more than once.

                    func RegisterUserImageDataSourceFunc

                    func RegisterUserImageDataSourceFunc(id string, f ImageDataSourceFunc)

                      RegisterUserImageDataSourceFunc registers an ImageDataSourceFunc with the specified id at the start of the search path, overwriting any function previously registered with the same id.

                      func RegisteredProviders

                      func RegisteredProviders() []string

                        RegisteredProviders enumerate all the environ providers which have been registered.

                        func SupportsSpaces

                        func SupportsSpaces(env Environ) bool

                          SupportsSpaces checks if the environment implements NetworkingEnviron and also if it supports spaces.

                          func UnregisterImageDataSourceFunc

                          func UnregisterImageDataSourceFunc(id string)

                            UnregisterImageDataSourceFunc unregisters an ImageDataSourceFunc with the specified id.

                            Types

                            type BootstrapContext

                            type BootstrapContext interface {
                            	GetStdin() io.Reader
                            	GetStdout() io.Writer
                            	GetStderr() io.Writer
                            	Infof(format string, params ...interface{})
                            	Verbosef(format string, params ...interface{})
                            
                            	// InterruptNotify starts watching for interrupt signals
                            	// on behalf of the caller, sending them to the supplied
                            	// channel.
                            	InterruptNotify(sig chan<- os.Signal)
                            
                            	// StopInterruptNotify undoes the effects of a previous
                            	// call to InterruptNotify with the same channel. After
                            	// StopInterruptNotify returns, no more signals will be
                            	// delivered to the channel.
                            	StopInterruptNotify(chan<- os.Signal)
                            
                            	// ShouldVerifyCredentials indicates whether the caller's cloud
                            	// credentials should be verified.
                            	ShouldVerifyCredentials() bool
                            }

                              BootstrapContext is an interface that is passed to Environ.Bootstrap, providing a means of obtaining information about and manipulating the context in which it is being invoked.

                              type BootstrapDialOpts

                              type BootstrapDialOpts struct {
                              	// Timeout is the amount of time to wait contacting a state
                              	// server.
                              	Timeout time.Duration
                              
                              	// RetryDelay is the amount of time between attempts to connect to
                              	// an address.
                              	RetryDelay time.Duration
                              
                              	// AddressesDelay is the amount of time between refreshing the
                              	// addresses.
                              	AddressesDelay time.Duration
                              }

                                BootstrapDialOpts contains the options for the synchronous part of the bootstrap procedure, where the CLI connects to the bootstrap machine to complete the process.

                                type BootstrapFinalizer

                                  BootstrapFinalizer is a function returned from Environ.Bootstrap. The caller must pass a InstanceConfig with the Tools field set.

                                  type BootstrapParams

                                  type BootstrapParams struct {
                                  	// Cloud contains the name of the cloud that Juju will be
                                  	// bootstrapped in. Used for printing feedback during bootstrap.
                                  	CloudName string
                                  
                                  	// CloudRegion is the name of the cloud region that Juju will be
                                  	// bootstrapped in. Used for printing feedback during bootstrap.
                                  	CloudRegion string
                                  
                                  	// ControllerConfig contains the configuration attributes for the
                                  	// bootstrapped controller.
                                  	ControllerConfig controller.Config
                                  
                                  	// ModelConstraints are merged with the bootstrap constraints
                                  	// to choose the initial instance, and will be stored in the new
                                  	// environment's state.
                                  	ModelConstraints constraints.Value
                                  
                                  	// BootstrapConstraints, in conjunction with ModelConstraints,
                                  	// are used to choose the initial instance. BootstrapConstraints
                                  	// will not be stored in state for the environment.
                                  	BootstrapConstraints constraints.Value
                                  
                                  	// BootstrapSeries, if specified, is the series to use for the
                                  	// initial bootstrap machine.
                                  	BootstrapSeries string
                                  
                                  	// Placement, if non-empty, holds an environment-specific placement
                                  	// directive used to choose the initial instance.
                                  	Placement string
                                  
                                  	// AvailableTools is a collection of tools which the Bootstrap method
                                  	// may use to decide which architecture/series to instantiate.
                                  	AvailableTools tools.List
                                  
                                  	// ContainerBridgeName, if non-empty, overrides the default
                                  	// network bridge device to use for LXC and KVM containers. See
                                  	// also instancecfg.DefaultBridgeName.
                                  	ContainerBridgeName string
                                  
                                  	// ImageMetadata contains simplestreams image metadata for providers
                                  	// that rely on it for selecting images. This will be empty for
                                  	// providers that do not implements simplestreams.HasRegion.
                                  	ImageMetadata []*imagemetadata.ImageMetadata
                                  }

                                    BootstrapParams holds the parameters for bootstrapping an environment.

                                    type BootstrapResult

                                    type BootstrapResult struct {
                                    	// Arch is the instance's architecture.
                                    	Arch string
                                    
                                    	// Series is the instance's series.
                                    	Series string
                                    
                                    	// Finalize is a function that must be called to finalize the
                                    	// bootstrap process by transferring the tools and installing the
                                    	// initial Juju controller.
                                    	Finalize BootstrapFinalizer
                                    }

                                      BootstrapResult holds the data returned by calls to Environ.Bootstrap.

                                      type CloudRegionDetector

                                      type CloudRegionDetector interface {
                                      	// DetectRetions automatically detects one or more regions
                                      	// from the environment. This may involve, for example, inspecting
                                      	// environment variables, or returning special hard-coded regions
                                      	// (e.g. "localhost" for lxd). The first item in the list will be
                                      	// considered the default region for bootstrapping if the user
                                      	// does not specify one.
                                      	//
                                      	// If no regions can be detected, DetectRegions should return
                                      	// an error satisfying errors.IsNotFound.
                                      	DetectRegions() ([]cloud.Region, error)
                                      }

                                        CloudRegionDetector is an interface that an EnvironProvider implements in order to automatically detect cloud regions from the environment.

                                        type CloudSpec

                                        type CloudSpec struct {
                                        	// Type is the type of cloud, eg aws, openstack etc.
                                        	Type string
                                        
                                        	// Name is the name of the cloud.
                                        	Name string
                                        
                                        	// Region is the name of the cloud region, if the cloud supports
                                        	// regions.
                                        	Region string
                                        
                                        	// Endpoint is the endpoint for the cloud (region).
                                        	Endpoint string
                                        
                                        	// IdentityEndpoint is the identity endpoint for the cloud (region).
                                        	IdentityEndpoint string
                                        
                                        	// StorageEndpoint is the storage endpoint for the cloud (region).
                                        	StorageEndpoint string
                                        
                                        	// Credential is the cloud credential to use to authenticate
                                        	// with the cloud, or nil if the cloud does not require any
                                        	// credentials.
                                        	Credential *jujucloud.Credential
                                        }

                                          CloudSpec describes a specific cloud configuration, for the purpose of opening an Environ to manage the cloud resources.

                                          func MakeCloudSpec

                                          func MakeCloudSpec(cloud jujucloud.Cloud, cloudName, cloudRegionName string, credential *jujucloud.Credential) (CloudSpec, error)

                                            MakeCloudSpec returns a CloudSpec from the given Cloud, cloud and region names, and credential.

                                            func (CloudSpec) Validate

                                            func (cs CloudSpec) Validate() error

                                              Validate validates that the CloudSpec is well-formed. It does not ensure that the cloud type and credentials are valid.

                                              type ConfigGetter

                                              type ConfigGetter interface {
                                              	// Config returns the configuration data with which the Environ was created.
                                              	// Note that this is not necessarily current; the canonical location
                                              	// for the configuration data is stored in the state.
                                              	Config() *config.Config
                                              }

                                                ConfigGetter implements access to an environment's configuration.

                                                type CreateParams

                                                type CreateParams struct {
                                                	// ControllerUUID is the UUID of the controller to be that is creating
                                                	// the Environ.
                                                	ControllerUUID string
                                                }

                                                  CreateParams contains the parameters for Environ.Create.

                                                  type Environ

                                                  type Environ interface {
                                                  	// Environ implements storage.ProviderRegistry for acquiring
                                                  	// environ-scoped storage providers supported by the Environ.
                                                  	// StorageProviders returned from Environ.StorageProvider will
                                                  	// be scoped specifically to that Environ.
                                                  	storage.ProviderRegistry
                                                  
                                                  	// PrepareForBootstrap prepares an environment for bootstrapping.
                                                  	//
                                                  	// This will be called very early in the bootstrap procedure, to
                                                  	// give an Environ a chance to perform interactive operations that
                                                  	// are required for bootstrapping.
                                                  	PrepareForBootstrap(ctx BootstrapContext) error
                                                  
                                                  	// Bootstrap creates a new environment, and an instance to host the
                                                  	// controller for that environment. The instnace will have have the
                                                  	// series and architecture of the Environ's choice, constrained to
                                                  	// those of the available tools. Bootstrap will return the instance's
                                                  	// architecture, series, and a function that must be called to finalize
                                                  	// the bootstrap process by transferring the tools and installing the
                                                  	// initial Juju controller.
                                                  	//
                                                  	// It is possible to direct Bootstrap to use a specific architecture
                                                  	// (or fail if it cannot start an instance of that architecture) by
                                                  	// using an architecture constraint; this will have the effect of
                                                  	// limiting the available tools to just those matching the specified
                                                  	// architecture.
                                                  	Bootstrap(ctx BootstrapContext, params BootstrapParams) (*BootstrapResult, error)
                                                  
                                                  	// Create creates the environment for a new hosted model.
                                                  	//
                                                  	// This will be called before any workers begin operating on the
                                                  	// Environ, to give an Environ a chance to perform operations that
                                                  	// are required for further use.
                                                  	//
                                                  	// Create is not called for the initial controller model; it is
                                                  	// the Bootstrap method's job to create the controller model.
                                                  	Create(CreateParams) error
                                                  
                                                  	// InstanceBroker defines methods for starting and stopping
                                                  	// instances.
                                                  	InstanceBroker
                                                  
                                                  	// ConfigGetter allows the retrieval of the configuration data.
                                                  	ConfigGetter
                                                  
                                                  	// ConstraintsValidator returns a Validator instance which
                                                  	// is used to validate and merge constraints.
                                                  	ConstraintsValidator() (constraints.Validator, error)
                                                  
                                                  	// SetConfig updates the Environ's configuration.
                                                  	//
                                                  	// Calls to SetConfig do not affect the configuration of
                                                  	// values previously obtained from Storage.
                                                  	SetConfig(cfg *config.Config) error
                                                  
                                                  	// Instances returns a slice of instances corresponding to the
                                                  	// given instance ids.  If no instances were found, but there
                                                  	// was no other error, it will return ErrNoInstances.  If
                                                  	// some but not all the instances were found, the returned slice
                                                  	// will have some nil slots, and an ErrPartialInstances error
                                                  	// will be returned.
                                                  	Instances(ids []instance.Id) ([]instance.Instance, error)
                                                  
                                                  	// ControllerInstances returns the IDs of instances corresponding
                                                  	// to Juju controller, having the specified controller UUID.
                                                  	// If there are no controller instances, ErrNoInstances is returned.
                                                  	// If it can be determined that the environment has not been bootstrapped,
                                                  	// then ErrNotBootstrapped should be returned instead.
                                                  	ControllerInstances(controllerUUID string) ([]instance.Id, error)
                                                  
                                                  	// Destroy shuts down all known machines and destroys the
                                                  	// rest of the environment. Note that on some providers,
                                                  	// very recently started instances may not be destroyed
                                                  	// because they are not yet visible.
                                                  	//
                                                  	// When Destroy has been called, any Environ referring to the
                                                  	// same remote environment may become invalid.
                                                  	Destroy() error
                                                  
                                                  	// DestroyController is similar to Destroy() in that it destroys
                                                  	// the model, which in this case will be the controller model.
                                                  	//
                                                  	// In addition, this method also destroys any resources relating
                                                  	// to hosted models on the controller on which it is invoked.
                                                  	// This ensures that "kill-controller" can clean up hosted models
                                                  	// when the Juju controller process is unavailable.
                                                  	DestroyController(controllerUUID string) error
                                                  
                                                  	Firewaller
                                                  
                                                  	// Provider returns the EnvironProvider that created this Environ.
                                                  	Provider() EnvironProvider
                                                  
                                                  	// PrecheckInstance performs a preflight check on the specified
                                                  	// series and constraints, ensuring that they are possibly valid for
                                                  	// creating an instance in this model.
                                                  	//
                                                  	// PrecheckInstance is best effort, and not guaranteed to eliminate
                                                  	// all invalid parameters. If PrecheckInstance returns nil, it is not
                                                  	// guaranteed that the constraints are valid; if a non-nil error is
                                                  	// returned, then the constraints are definitely invalid.
                                                  	//
                                                  	// TODO(axw) find a home for state.Prechecker that isn't state and
                                                  	// isn't environs, so both packages can refer to it. Maybe the
                                                  	// constraints package? Can't be instance, because constraints
                                                  	// import instance...
                                                  	PrecheckInstance(series string, cons constraints.Value, placement string) error
                                                  }

                                                    An Environ represents a Juju environment.

                                                    Due to the limitations of some providers (for example ec2), the results of the Environ methods may not be fully sequentially consistent. In particular, while a provider may retry when it gets an error for an operation, it will not retry when an operation succeeds, even if that success is not consistent with a previous operation.

                                                    Even though Juju takes care not to share an Environ between concurrent workers, it does allow concurrent method calls into the provider implementation. The typical provider implementation needs locking to avoid undefined behaviour when the configuration changes.

                                                    func GetEnviron

                                                    func GetEnviron(st EnvironConfigGetter, newEnviron NewEnvironFunc) (Environ, error)

                                                      GetEnviron returns the environs.Environ ("provider") associated with the model.

                                                      func New

                                                      func New(args OpenParams) (Environ, error)

                                                        New returns a new environment based on the provided configuration.

                                                        type EnvironConfigGetter

                                                        type EnvironConfigGetter interface {
                                                        	ModelConfig() (*config.Config, error)
                                                        	CloudSpec(names.ModelTag) (CloudSpec, error)
                                                        }

                                                          EnvironConfigGetter exposes a model configuration to its clients.

                                                          type EnvironProvider

                                                          type EnvironProvider interface {
                                                          	config.Validator
                                                          	ProviderCredentials
                                                          
                                                          	// PrepareConfig prepares the configuration for a new model, based on
                                                          	// the provided arguments. PrepareConfig is expected to produce a
                                                          	// deterministic output. Any unique values should be based on the
                                                          	// "uuid" attribute of the base configuration. This is called for the
                                                          	// controller model during bootstrap, and also for new hosted models.
                                                          	PrepareConfig(PrepareConfigParams) (*config.Config, error)
                                                          
                                                          	// Open opens the environment and returns it. The configuration must
                                                          	// have passed through PrepareConfig at some point in its lifecycle.
                                                          	//
                                                          	// Open should not perform any expensive operations, such as querying
                                                          	// the cloud API, as it will be called frequently.
                                                          	Open(OpenParams) (Environ, error)
                                                          }

                                                            A EnvironProvider represents a computing and storage provider.

                                                            func Provider

                                                            func Provider(providerType string) (EnvironProvider, error)

                                                              Provider returns the previously registered provider with the given type.

                                                              type FinalizeCredentialContext

                                                              type FinalizeCredentialContext interface {
                                                              	GetStderr() io.Writer
                                                              }

                                                                FinalizeCredentialContext is an interface passed into FinalizeCredential to provide a means of interacting with the user when finalizing credentials.

                                                                type FinalizeCredentialParams

                                                                type FinalizeCredentialParams struct {
                                                                	// Credential is the credential that the provider should finalize.`
                                                                	Credential cloud.Credential
                                                                
                                                                	// CloudEndpoint is the endpoint for the cloud that the credentials are
                                                                	// for. This may be used by the provider to communicate with the cloud
                                                                	// to finalize the credentials.
                                                                	CloudEndpoint string
                                                                
                                                                	// CloudIdentityEndpoint is the identity endpoint for the cloud that the
                                                                	// credentials are for. This may be used by the provider to communicate
                                                                	// with the cloud to finalize the credentials.
                                                                	CloudIdentityEndpoint string
                                                                }

                                                                  FinalizeCredentialParams contains the parameters for ProviderCredentials.FinalizeCredential.

                                                                  type Firewaller

                                                                  type Firewaller interface {
                                                                  	// OpenPorts opens the given port ranges for the whole environment.
                                                                  	// Must only be used if the environment was setup with the
                                                                  	// FwGlobal firewall mode.
                                                                  	OpenPorts(ports []network.PortRange) error
                                                                  
                                                                  	// ClosePorts closes the given port ranges for the whole environment.
                                                                  	// Must only be used if the environment was setup with the
                                                                  	// FwGlobal firewall mode.
                                                                  	ClosePorts(ports []network.PortRange) error
                                                                  
                                                                  	// Ports returns the port ranges opened for the whole environment.
                                                                  	// Must only be used if the environment was setup with the
                                                                  	// FwGlobal firewall mode.
                                                                  	Ports() ([]network.PortRange, error)
                                                                  }

                                                                    Firewaller exposes methods for managing network ports.

                                                                    type ImageDataSourceFunc

                                                                    type ImageDataSourceFunc func(Environ) (simplestreams.DataSource, error)

                                                                      ImageDataSourceFunc is a function type that takes an environment and returns a simplestreams datasource.

                                                                      ImageDataSourceFunc will be used in ImageMetadataSources. Any error satisfying errors.IsNotSupported will be ignored; any other error will be cause ImageMetadataSources to fail.

                                                                      type InstanceBroker

                                                                      type InstanceBroker interface {
                                                                      	// StartInstance asks for a new instance to be created, associated with
                                                                      	// the provided config in machineConfig. The given config describes the juju
                                                                      	// state for the new instance to connect to. The config MachineNonce, which must be
                                                                      	// unique within an environment, is used by juju to protect against the
                                                                      	// consequences of multiple instances being started with the same machine
                                                                      	// id.
                                                                      	StartInstance(args StartInstanceParams) (*StartInstanceResult, error)
                                                                      
                                                                      	// StopInstances shuts down the instances with the specified IDs.
                                                                      	// Unknown instance IDs are ignored, to enable idempotency.
                                                                      	StopInstances(...instance.Id) error
                                                                      
                                                                      	// AllInstances returns all instances currently known to the broker.
                                                                      	AllInstances() ([]instance.Instance, error)
                                                                      
                                                                      	// MaintainInstance is used to run actions on jujud startup for existing
                                                                      	// instances. It is currently only used to ensure that LXC hosts have the
                                                                      	// correct network configuration.
                                                                      	MaintainInstance(args StartInstanceParams) error
                                                                      }

                                                                        TODO(wallyworld) - we want this in the environs/instance package but import loops stop that from being possible right now.

                                                                        type InstanceTagger

                                                                        type InstanceTagger interface {
                                                                        	// TagInstance tags the given instance with the specified tags.
                                                                        	//
                                                                        	// The specified tags will replace any existing ones with the
                                                                        	// same names, but other existing tags will be left alone.
                                                                        	TagInstance(id instance.Id, tags map[string]string) error
                                                                        }

                                                                          InstanceTagger is an interface that can be used for tagging instances.

                                                                          type ModelConfigUpgrader

                                                                          type ModelConfigUpgrader interface {
                                                                          	// UpgradeConfig upgrades an old environment configuration by adding,
                                                                          	// updating or removing attributes. UpgradeConfig must be idempotent,
                                                                          	// as it may be called multiple times in the event of a partial upgrade.
                                                                          	//
                                                                          	// NOTE(axw) this is currently only called when upgrading to 1.25.
                                                                          	// We should update the upgrade machinery to call this for every
                                                                          	// version upgrade, so the upgrades package is not tightly coupled
                                                                          	// to provider upgrades.
                                                                          	UpgradeConfig(cfg *config.Config) (*config.Config, error)
                                                                          }

                                                                            ModelConfigUpgrader is an interface that an EnvironProvider may implement in order to modify environment configuration on agent upgrade.

                                                                            type Networking

                                                                            type Networking interface {
                                                                            	// Subnets returns basic information about subnets known
                                                                            	// by the provider for the environment.
                                                                            	Subnets(inst instance.Id, subnetIds []network.Id) ([]network.SubnetInfo, error)
                                                                            
                                                                            	// NetworkInterfaces requests information about the network
                                                                            	// interfaces on the given instance.
                                                                            	NetworkInterfaces(instId instance.Id) ([]network.InterfaceInfo, error)
                                                                            
                                                                            	// SupportsSpaces returns whether the current environment supports
                                                                            	// spaces. The returned error satisfies errors.IsNotSupported(),
                                                                            	// unless a general API failure occurs.
                                                                            	SupportsSpaces() (bool, error)
                                                                            
                                                                            	// SupportsSpaceDiscovery returns whether the current environment
                                                                            	// supports discovering spaces from the provider. The returned error
                                                                            	// satisfies errors.IsNotSupported(), unless a general API failure occurs.
                                                                            	SupportsSpaceDiscovery() (bool, error)
                                                                            
                                                                            	// Spaces returns a slice of network.SpaceInfo with info, including
                                                                            	// details of all associated subnets, about all spaces known to the
                                                                            	// provider that have subnets available.
                                                                            	Spaces() ([]network.SpaceInfo, error)
                                                                            
                                                                            	// AllocateContainerAddresses allocates a static address for each of the
                                                                            	// container NICs in preparedInfo, hosted by the hostInstanceID. Returns the
                                                                            	// network config including all allocated addresses on success.
                                                                            	AllocateContainerAddresses(hostInstanceID instance.Id, containerTag names.MachineTag, preparedInfo []network.InterfaceInfo) ([]network.InterfaceInfo, error)
                                                                            
                                                                            	// ReleaseContainerAddresses releases the previously allocated
                                                                            	// addresses matching the interface details passed in.
                                                                            	ReleaseContainerAddresses(interfaces []network.ProviderInterfaceInfo) error
                                                                            }

                                                                              Networking interface defines methods that environments with networking capabilities must implement.

                                                                              type NetworkingEnviron

                                                                              type NetworkingEnviron interface {
                                                                              	// Environ represents a juju environment.
                                                                              	Environ
                                                                              
                                                                              	// Networking defines the methods of networking capable environments.
                                                                              	Networking
                                                                              }

                                                                                NetworkingEnviron combines the standard Environ interface with the functionality for networking.

                                                                                type NewEnvironFunc

                                                                                type NewEnvironFunc func(OpenParams) (Environ, error)

                                                                                  NewEnvironFunc is the type of a function that, given a model config, returns an Environ. This will typically be environs.New.

                                                                                  type OpenParams

                                                                                  type OpenParams struct {
                                                                                  	// Cloud is the cloud specification to use to connect to the cloud.
                                                                                  	Cloud CloudSpec
                                                                                  
                                                                                  	// Config is the base configuration for the provider.
                                                                                  	Config *config.Config
                                                                                  }

                                                                                    OpenParams contains the parameters for EnvironProvider.Open.

                                                                                    type PrepareConfigParams

                                                                                    type PrepareConfigParams struct {
                                                                                    	// Cloud is the cloud specification to use to connect to the cloud.
                                                                                    	Cloud CloudSpec
                                                                                    
                                                                                    	// Config is the base configuration for the provider. This should
                                                                                    	// be updated with the region, endpoint and credentials.
                                                                                    	Config *config.Config
                                                                                    }

                                                                                      PrepareConfigParams contains the parameters for EnvironProvider.PrepareConfig.

                                                                                      type ProviderCredentials

                                                                                      type ProviderCredentials interface {
                                                                                      	// CredentialSchemas returns credential schemas, keyed on
                                                                                      	// authentication type. These may be used to validate existing
                                                                                      	// credentials, or to generate new ones (e.g. to create an
                                                                                      	// interactive form.)
                                                                                      	CredentialSchemas() map[cloud.AuthType]cloud.CredentialSchema
                                                                                      
                                                                                      	// DetectCredentials automatically detects one or more credentials
                                                                                      	// from the environment. This may involve, for example, inspecting
                                                                                      	// environment variables, or reading configuration files in
                                                                                      	// well-defined locations.
                                                                                      	//
                                                                                      	// If no credentials can be detected, DetectCredentials should
                                                                                      	// return an error satisfying errors.IsNotFound.
                                                                                      	DetectCredentials() (*cloud.CloudCredential, error)
                                                                                      
                                                                                      	// FinalizeCredential finalizes a credential, updating any attributes
                                                                                      	// as necessary. This is always done client-side, when adding the
                                                                                      	// credential to credentials.yaml and before uploading credentials to
                                                                                      	// the controller. The provider may completely alter a credential, even
                                                                                      	// going as far as changing the auth-type, but the output must be a
                                                                                      	// fully formed credential.
                                                                                      	FinalizeCredential(
                                                                                      		FinalizeCredentialContext,
                                                                                      		FinalizeCredentialParams,
                                                                                      	) (*cloud.Credential, error)
                                                                                      }

                                                                                        ProviderCredentials is an interface that an EnvironProvider implements in order to validate and automatically detect credentials for clouds supported by the provider.

                                                                                        TODO(axw) replace CredentialSchemas with an updated environschema. The GUI also needs to be able to handle multiple credential types, and dependencies in config attributes.

                                                                                        type ProviderRegistry

                                                                                        type ProviderRegistry interface {
                                                                                        	// RegisterProvider registers a new environment provider with the given
                                                                                        	// name, and zero or more aliases. If a provider already exists with the
                                                                                        	// given name or alias, an error will be returned.
                                                                                        	RegisterProvider(p EnvironProvider, providerType string, providerTypeAliases ...string) error
                                                                                        
                                                                                        	// RegisteredProviders returns the names of the registered environment
                                                                                        	// providers.
                                                                                        	RegisteredProviders() []string
                                                                                        
                                                                                        	// Provider returns the environment provider with the specified name.
                                                                                        	Provider(providerType string) (EnvironProvider, error)
                                                                                        }

                                                                                          ProviderRegistry is an interface that provides methods for registering and obtaining environment providers by provider name.

                                                                                          func GlobalProviderRegistry

                                                                                          func GlobalProviderRegistry() ProviderRegistry

                                                                                            GlobalProviderRegistry returns the global provider registry.

                                                                                            type ProviderSchema

                                                                                            type ProviderSchema interface {
                                                                                            	// Schema returns the schema for the provider. It should
                                                                                            	// include all fields defined in environs/config, conventionally
                                                                                            	// by calling config.Schema.
                                                                                            	Schema() environschema.Fields
                                                                                            }

                                                                                              ProviderSchema can be implemented by a provider to provide access to its configuration schema. Once all providers implement this, it will be included in the EnvironProvider type and the information made available over the API.

                                                                                              type RegionSpec

                                                                                              type RegionSpec struct {
                                                                                              	// Cloud is the name of the cloud.
                                                                                              	Cloud string
                                                                                              
                                                                                              	// Region is the name of the cloud region.
                                                                                              	Region string
                                                                                              }

                                                                                                RegionSpec contains the information needed to lookup specific region configuration. This is for use in calling state/modelconfig.(ComposeNewModelConfig) so there is no need to serialize it.

                                                                                                func NewRegionSpec

                                                                                                func NewRegionSpec(cloud, region string) (*RegionSpec, error)

                                                                                                  NewRegionSpec returns a RegionSpec ensuring neither arg is empty.

                                                                                                  type StartInstanceParams

                                                                                                  type StartInstanceParams struct {
                                                                                                  	// ControllerUUID is the uuid of the controller.
                                                                                                  	ControllerUUID string
                                                                                                  
                                                                                                  	// Constraints is a set of constraints on
                                                                                                  	// the kind of instance to create.
                                                                                                  	Constraints constraints.Value
                                                                                                  
                                                                                                  	// Tools is a list of tools that may be used
                                                                                                  	// to start a Juju agent on the machine.
                                                                                                  	Tools tools.List
                                                                                                  
                                                                                                  	// InstanceConfig describes the machine's configuration.
                                                                                                  	InstanceConfig *instancecfg.InstanceConfig
                                                                                                  
                                                                                                  	// Placement, if non-empty, contains an environment-specific
                                                                                                  	// placement directive that may be used to decide how the
                                                                                                  	// instance should be started.
                                                                                                  	Placement string
                                                                                                  
                                                                                                  	// DistributionGroup, if non-nil, is a function
                                                                                                  	// that returns a slice of instance.Ids that belong
                                                                                                  	// to the same distribution group as the machine
                                                                                                  	// being provisioned. The InstanceBroker may use
                                                                                                  	// this information to distribute instances for
                                                                                                  	// high availability.
                                                                                                  	DistributionGroup func() ([]instance.Id, error)
                                                                                                  
                                                                                                  	// Volumes is a set of parameters for volumes that should be created.
                                                                                                  	//
                                                                                                  	// StartInstance need not check the value of the Attachment field,
                                                                                                  	// as it is guaranteed that any volumes in this list are designated
                                                                                                  	// for attachment to the instance being started.
                                                                                                  	Volumes []storage.VolumeParams
                                                                                                  
                                                                                                  	// NetworkInfo is an optional list of network interface details,
                                                                                                  	// necessary to configure on the instance.
                                                                                                  	NetworkInfo []network.InterfaceInfo
                                                                                                  
                                                                                                  	// SubnetsToZones is an optional map of provider-specific subnet
                                                                                                  	// id to a list of availability zone names the subnet is available
                                                                                                  	// in. It is only populated when valid positive spaces constraints
                                                                                                  	// are present.
                                                                                                  	SubnetsToZones map[network.Id][]string
                                                                                                  
                                                                                                  	// EndpointBindings holds the mapping between service endpoint names to
                                                                                                  	// provider-specific space IDs. It is populated when provisioning a machine
                                                                                                  	// to host a unit of a service with endpoint bindings.
                                                                                                  	EndpointBindings map[string]network.Id
                                                                                                  	// ImageMetadata is a collection of image metadata
                                                                                                  	// that may be used to start this instance.
                                                                                                  	ImageMetadata []*imagemetadata.ImageMetadata
                                                                                                  
                                                                                                  	// StatusCallback is a callback to be used by the instance to report
                                                                                                  	// changes in status. Its signature is consistent with other
                                                                                                  	// status-related functions to allow them to be used as callbacks.
                                                                                                  	StatusCallback func(settableStatus status.Status, info string, data map[string]interface{}) error
                                                                                                  
                                                                                                  	// CleanupCallback is a callback to be used to clean up any residual
                                                                                                  	// status-reporting output from StatusCallback.
                                                                                                  	CleanupCallback func(info string) error
                                                                                                  }

                                                                                                    StartInstanceParams holds parameters for the InstanceBroker.StartInstance method.

                                                                                                    type StartInstanceResult

                                                                                                    type StartInstanceResult struct {
                                                                                                    	// Instance is an interface representing a cloud instance.
                                                                                                    	Instance instance.Instance
                                                                                                    
                                                                                                    	// Config holds the environment config to be used for any further
                                                                                                    	// operations, if the instance is for a controller.
                                                                                                    	Config *config.Config
                                                                                                    
                                                                                                    	// HardwareCharacteristics represents the hardware characteristics
                                                                                                    	// of the newly created instance.
                                                                                                    	Hardware *instance.HardwareCharacteristics
                                                                                                    
                                                                                                    	// NetworkInfo contains information about how to configure network
                                                                                                    	// interfaces on the instance. Depending on the provider, this
                                                                                                    	// might be the same StartInstanceParams.NetworkInfo or may be
                                                                                                    	// modified as needed.
                                                                                                    	NetworkInfo []network.InterfaceInfo
                                                                                                    
                                                                                                    	// Volumes contains a list of volumes created, each one having the
                                                                                                    	// same Name as one of the VolumeParams in StartInstanceParams.Volumes.
                                                                                                    	// VolumeAttachment information is reported separately.
                                                                                                    	Volumes []storage.Volume
                                                                                                    
                                                                                                    	// VolumeAttachments contains a attachment-specific information about
                                                                                                    	// volumes that were attached to the started instance.
                                                                                                    	VolumeAttachments []storage.VolumeAttachment
                                                                                                    }

                                                                                                      StartInstanceResult holds the result of an InstanceBroker.StartInstance method call.

                                                                                                      Directories

                                                                                                      Path Synopsis
                                                                                                      The imagemetadata package supports locating, parsing, and filtering Ubuntu image metadata in simplestreams format.
                                                                                                      The imagemetadata package supports locating, parsing, and filtering Ubuntu image metadata in simplestreams format.
                                                                                                      The simplestreams package supports locating, parsing, and filtering metadata in simplestreams format.
                                                                                                      The simplestreams package supports locating, parsing, and filtering metadata in simplestreams format.
                                                                                                      The tools package supports locating, parsing, and filtering Ubuntu tools metadata in simplestreams format.
                                                                                                      The tools package supports locating, parsing, and filtering Ubuntu tools metadata in simplestreams format.