Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func AddSubnets

    AddSubnets adds.

    func AllZones

    func AllZones(api NetworkBacking) (params.ZoneResults, error)

      AllZones is defined on the API interface.

      func BackingSubnetToParamsSubnet

      func BackingSubnetToParamsSubnet(subnet BackingSubnet) params.Subnet

      func CopyNetworkConfigs

      func CopyNetworkConfigs(input []params.NetworkConfig) []params.NetworkConfig

        CopyNetworkConfigs returns a copy of the given input

        func CreateSpaces

        func CreateSpaces(backing NetworkBacking, args params.CreateSpacesParams) (results params.ErrorResults, err error)

          CreateSpaces creates a new Juju network space, associating the specified subnets with it (optional; can be empty).

          func GetObservedNetworkConfig

          func GetObservedNetworkConfig() ([]params.NetworkConfig, error)

            GetObservedNetworkConfig discovers what network interfaces exist on the machine, and returns that as a sorted slice of params.NetworkConfig to later update the state network config we have about the machine.

            func ListSubnets

            func ListSubnets(api NetworkBacking, args params.SubnetsFilters) (results params.ListSubnetsResults, err error)

              ListSubnets lists all the available subnets or only those matching all given optional filters.

              func MergeProviderAndObservedNetworkConfigs

              func MergeProviderAndObservedNetworkConfigs(providerConfigs, observedConfigs []params.NetworkConfig) []params.NetworkConfig

                MergeProviderAndObservedNetworkConfigs returns the effective, sorted, network configs after merging providerConfig with observedConfig.

                func NetworkConfigFromInterfaceInfo

                func NetworkConfigFromInterfaceInfo(interfaceInfos []network.InterfaceInfo) []params.NetworkConfig

                  NetworkConfigFromInterfaceInfo converts a slice of network.InterfaceInfo into the equivalent params.NetworkConfig slice.

                  func NetworkConfigsToIndentedJSON

                  func NetworkConfigsToIndentedJSON(input []params.NetworkConfig) (string, error)

                    NetworkConfigsToIndentedJSON returns the given input as an indented JSON string.

                    func NetworkConfigsToStateArgs

                    func NetworkConfigsToStateArgs(networkConfig []params.NetworkConfig) (
                    	[]state.LinkLayerDeviceArgs,
                    	[]state.LinkLayerDeviceAddress,
                    )

                      NetworkConfigsToStateArgs splits the given networkConfig into a slice of state.LinkLayerDeviceArgs and a slice of state.LinkLayerDeviceAddress. The input is expected to come from MergeProviderAndObservedNetworkConfigs and to be sorted.

                      func NetworkingEnvironFromModelConfig

                      func NetworkingEnvironFromModelConfig(configGetter ModelConfigGetter) (environs.NetworkingEnviron, error)

                        NetworkingEnvironFromModelConfig constructs and returns environs.NetworkingEnviron using the given configGetter. Returns an error satisfying errors.IsNotSupported() if the model config does not support networking features.

                        func NewAddSubnetsCache

                        func NewAddSubnetsCache(api NetworkBacking) *addSubnetsCache

                        func NewStateShim

                        func NewStateShim(st *state.State) *stateShim

                        func SortNetworkConfigsByInterfaceName

                        func SortNetworkConfigsByInterfaceName(input []params.NetworkConfig) []params.NetworkConfig

                          SortNetworkConfigsByInterfaceName returns the given input sorted by InterfaceName.

                          func SortNetworkConfigsByParents

                          func SortNetworkConfigsByParents(input []params.NetworkConfig) []params.NetworkConfig

                            SortNetworkConfigsByParents returns the given input sorted, such that any child interfaces appear after their parents.

                            func SupportsSpaces

                            func SupportsSpaces(backing environ.ConfigGetter) error

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

                              Types

                              type BackingSpace

                              type BackingSpace interface {
                              	// Name returns the space name.
                              	Name() string
                              
                              	// Subnets returns the subnets in the space
                              	Subnets() ([]BackingSubnet, error)
                              
                              	// ProviderId returns the network ID of the provider
                              	ProviderId() network.Id
                              
                              	// Zones returns a list of availability zone(s) that this
                              	// space is in. It can be empty if the provider does not support
                              	// availability zones.
                              	Zones() []string
                              
                              	// Life returns the lifecycle state of the space
                              	Life() params.Life
                              }

                                BackingSpace defines the methods supported by a Space entity stored persistently.

                                type BackingSubnet

                                type BackingSubnet interface {
                                	CIDR() string
                                	VLANTag() int
                                	ProviderId() network.Id
                                	AvailabilityZones() []string
                                	Status() string
                                	SpaceName() string
                                	Life() params.Life
                                }

                                  BackingSubnet defines the methods supported by a Subnet entity stored persistently.

                                  TODO(dimitern): Once the state backing is implemented, remove this and just use *state.Subnet.

                                  type BackingSubnetInfo

                                  type BackingSubnetInfo struct {
                                  	// ProviderId is a provider-specific network id. This may be empty.
                                  	ProviderId network.Id
                                  
                                  	// CIDR of the network, in 123.45.67.89/24 format.
                                  	CIDR string
                                  
                                  	// VLANTag needs to be between 1 and 4094 for VLANs and 0 for normal
                                  	// networks. It's defined by IEEE 802.1Q standard.
                                  	VLANTag int
                                  
                                  	// AllocatableIPHigh and Low describe the allocatable portion of the
                                  	// subnet. The remainder, if any, is reserved by the provider.
                                  	// Either both of these must be set or neither, if they're empty it
                                  	// means that none of the subnet is allocatable. If present they must
                                  	// be valid IP addresses within the subnet CIDR.
                                  	AllocatableIPHigh string
                                  	AllocatableIPLow  string
                                  
                                  	// AvailabilityZones describes which availability zone(s) this
                                  	// subnet is in. It can be empty if the provider does not support
                                  	// availability zones.
                                  	AvailabilityZones []string
                                  
                                  	// SpaceName holds the juju network space this subnet is
                                  	// associated with. Can be empty if not supported.
                                  	SpaceName string
                                  
                                  	// Status holds the status of the subnet. Normally this will be
                                  	// calculated from the reference count and Life of a subnet.
                                  	Status string
                                  
                                  	// Live holds the life of the subnet
                                  	Life params.Life
                                  }

                                    BackingSubnetInfo describes a single subnet to be added in the backing store.

                                    TODO(dimitern): Replace state.SubnetInfo with this and remove BackingSubnetInfo, once the rest of state backing methods and the following pre-reqs are done: * subnetDoc.AvailabilityZone becomes subnetDoc.AvailabilityZones,

                                    adding an upgrade step to migrate existing non empty zones on
                                    subnet docs. Also change state.Subnet.AvailabilityZone to
                                    

                                    * add subnetDoc.SpaceName - no upgrade step needed, as it will only

                                    be used for new space-aware subnets.
                                    

                                    * Subnets need a reference count to calculate Status. * ensure EC2 and MAAS providers accept empty IDs as Subnets() args

                                    and return all subnets, including the AvailabilityZones (for EC2;
                                    empty for MAAS as zones are orthogonal to networks).
                                    

                                    type ModelConfigGetter

                                    type ModelConfigGetter interface {
                                    	ModelConfig() (*config.Config, error)
                                    }

                                      ModelConfigGetter is used to get the current model configuration.

                                      type NetworkBacking

                                      type NetworkBacking interface {
                                      	// ModelConfig returns the current environment config.
                                      	ModelConfig() (*config.Config, error)
                                      
                                      	// AvailabilityZones returns all cached availability zones (i.e.
                                      	// not from the provider, but in state).
                                      	AvailabilityZones() ([]providercommon.AvailabilityZone, error)
                                      
                                      	// SetAvailabilityZones replaces the cached list of availability
                                      	// zones with the given zones.
                                      	SetAvailabilityZones([]providercommon.AvailabilityZone) error
                                      
                                      	// AddSpace creates a space
                                      	AddSpace(Name string, ProviderId network.Id, Subnets []string, Public bool) error
                                      
                                      	// AllSpaces returns all known Juju network spaces.
                                      	AllSpaces() ([]BackingSpace, error)
                                      
                                      	// AddSubnet creates a backing subnet for an existing subnet.
                                      	AddSubnet(BackingSubnetInfo) (BackingSubnet, error)
                                      
                                      	// AllSubnets returns all backing subnets.
                                      	AllSubnets() ([]BackingSubnet, error)
                                      }

                                        Backing defines the methods needed by the API facade to store and retrieve information from the underlying persistency layer (state DB).