huaweicloud

package
v0.0.0-...-b8d4dd8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 19, 2019 License: MPL-2.0 Imports: 50 Imported by: 0

Documentation

Index

Constants

View Source 
const BuilderId = "mitchellh.openstack"

The unique ID for this builder

Variables

View Source 
var REDACT_HEADERS = []string{"x-auth-token", "x-auth-key", "x-service-token",
	"x-storage-token", "x-account-meta-temp-url-key", "x-account-meta-temp-url-key-2",
	"x-container-meta-temp-url-key", "x-container-meta-temp-url-key-2", "set-cookie",
	"x-subject-token"}

List of headers that need to be redacted

Functions

func CheckFloatingIP 

func CheckFloatingIP(client *gophercloud.ServiceClient, id string) (*floatingips.FloatingIP, error)

CheckFloatingIP gets a floating IP by its ID and checks if it is already associated with any internal interface. It returns floating IP if it can be used.

func CheckFloatingIPNetwork 

func CheckFloatingIPNetwork(client *gophercloud.ServiceClient, networkRef string) (string, error)

CheckFloatingIPNetwork checks provided network reference and returns a valid Networking service ID.

func CommHost 

func CommHost(
	host string,
	client *gophercloud.ServiceClient,
	sshinterface string,
	sshipversion string) func(multistep.StateBag) (string, error)

CommHost looks up the host for the communicator.

func FindFreeFloatingIP 

func FindFreeFloatingIP(client *gophercloud.ServiceClient) (*floatingips.FloatingIP, error)

FindFreeFloatingIP returns free unassociated floating IP. It will return first floating IP if there are many.

func FormatHeaders 

func FormatHeaders(headers http.Header, seperator string) string

FormatHeaders processes a headers object plus a deliminator, returning a string

func GetFloatingIPNetworkIDByName 

func GetFloatingIPNetworkIDByName(client *gophercloud.ServiceClient, networkName string) (string, error)

GetFloatingIPNetworkIDByName searches for the external network ID by the provided name.

func GetInstancePortID 

func GetInstancePortID(client *gophercloud.ServiceClient, id string, instance_float_net string) (string, error)

GetInstancePortID returns internal port of the instance that can be used for the association of a floating IP. It will return an ID of a first port if there are many.

func GetVolumeSize 

func GetVolumeSize(imageClient *gophercloud.ServiceClient, imageID string) (int, error)

GetVolumeSize returns volume size in gigabytes based on the image min disk value if it's not empty. Or it calculates needed gigabytes size from the image bytes size.

func GetVolumeStatus 

func GetVolumeStatus(blockStorageClient *gophercloud.ServiceClient, volumeID string) (string, error)

func PropertiesSatisfied 

func PropertiesSatisfied(image *images.Image, props *map[string]string) bool

func RedactHeaders 

func RedactHeaders(headers http.Header) (processedHeaders []string)

RedactHeaders processes a headers object, returning a redacted list

func WaitForImage 

func WaitForImage(ctx context.Context, client *gophercloud.ServiceClient, imageId string) error

WaitForImage waits for the given Image ID to become ready.

func WaitForState 

func WaitForState(conf *StateChangeConf) (i interface{}, err error)

WaitForState watches an object and waits for it to achieve a certain state.

func WaitForVolume 

func WaitForVolume(blockStorageClient *gophercloud.ServiceClient, volumeID string) error

WaitForVolume waits for the given volume to become available.

Types

type AccessConfig 

type AccessConfig struct {
	// The username or id used to connect to the OpenStack service. If not
	// specified, Packer will use the environment variable OS_USERNAME or
	// OS_USERID, if set. This is not required if using access token or
	// application credential instead of password, or if using cloud.yaml.
	Username string `mapstructure:"username" required:"true"`
	// Sets username
	UserID string `mapstructure:"user_id"`
	// The password used to connect to the OpenStack service. If not specified,
	// Packer will use the environment variables OS_PASSWORD, if set. This is
	// not required if using access token or application credential instead of
	// password, or if using cloud.yaml.
	Password string `mapstructure:"password" required:"true"`
	// The URL to the OpenStack Identity service. If not specified, Packer will
	// use the environment variables OS_AUTH_URL, if set. This is not required
	// if using cloud.yaml.
	IdentityEndpoint string `mapstructure:"identity_endpoint" required:"true"`
	// The tenant ID or name to boot the instance into. Some OpenStack
	// installations require this. If not specified, Packer will use the
	// environment variable OS_TENANT_NAME or OS_TENANT_ID, if set. Tenant is
	// also called Project in later versions of OpenStack.
	TenantID   string `mapstructure:"tenant_id" required:"false"`
	TenantName string `mapstructure:"tenant_name"`
	DomainID   string `mapstructure:"domain_id"`
	// The Domain name or ID you are authenticating with. OpenStack
	// installations require this if identity v3 is used. Packer will use the
	// environment variable OS_DOMAIN_NAME or OS_DOMAIN_ID, if set.
	DomainName string `mapstructure:"domain_name" required:"false"`
	// Whether or not the connection to OpenStack can be done over an insecure
	// connection. By default this is false.
	Insecure bool `mapstructure:"insecure" required:"false"`
	// The name of the region, such as "DFW", in which to launch the server to
	// create the image. If not specified, Packer will use the environment
	// variable OS_REGION_NAME, if set.
	Region string `mapstructure:"region" required:"false"`
	// The endpoint type to use. Can be any of "internal", "internalURL",
	// "admin", "adminURL", "public", and "publicURL". By default this is
	// "public".
	EndpointType string `mapstructure:"endpoint_type" required:"false"`
	// Custom CA certificate file path. If omitted the OS_CACERT environment
	// variable can be used.
	CACertFile string `mapstructure:"cacert" required:"false"`
	// Client certificate file path for SSL client authentication. If omitted
	// the OS_CERT environment variable can be used.
	ClientCertFile string `mapstructure:"cert" required:"false"`
	// Client private key file path for SSL client authentication. If omitted
	// the OS_KEY environment variable can be used.
	ClientKeyFile string `mapstructure:"key" required:"false"`
	// the token (id) to use with token based authorization. Packer will use
	// the environment variable OS_TOKEN, if set.
	Token string `mapstructure:"token" required:"false"`
	// The application credential name to use with application credential based
	// authorization. Packer will use the environment variable
	// OS_APPLICATION_CREDENTIAL_NAME, if set.
	ApplicationCredentialName string `mapstructure:"application_credential_name" required:"false"`
	// The application credential id to use with application credential based
	// authorization. Packer will use the environment variable
	// OS_APPLICATION_CREDENTIAL_ID, if set.
	ApplicationCredentialID string `mapstructure:"application_credential_id" required:"false"`
	// The application credential secret to use with application credential
	// based authorization. Packer will use the environment variable
	// OS_APPLICATION_CREDENTIAL_SECRET, if set.
	ApplicationCredentialSecret string `mapstructure:"application_credential_secret" required:"false"`
	// An entry in a `clouds.yaml` file. See the OpenStack os-client-config
	// [documentation](https://docs.openstack.org/os-client-config/latest/user/configuration.html)
	// for more information about `clouds.yaml` files. If omitted, the
	// `OS_CLOUD` environment variable is used.
	Cloud string `mapstructure:"cloud" required:"false"`
	// contains filtered or unexported fields
}

AccessConfig is for common configuration related to openstack access

func (*AccessConfig) Prepare 

func (c *AccessConfig) Prepare(ctx *interpolate.Context) []error

type Artifact 

type Artifact struct {
	// ImageId of built image
	ImageId string

	// BuilderId is the unique ID for the builder that created this image
	BuilderIdValue string

	// OpenStack connection for performing API stuff.
	Client *gophercloud.ServiceClient
}

Artifact is an artifact implementation that contains built images.

func (*Artifact) BuilderId 

func (a *Artifact) BuilderId() string

func (*Artifact) Destroy 

func (a *Artifact) Destroy() error

func (*Artifact) Files 

func (*Artifact) Files() []string

func (*Artifact) Id 

func (a *Artifact) Id() string

func (*Artifact) State 

func (a *Artifact) State(name string) interface{}

func (*Artifact) String 

func (a *Artifact) String() string

type Builder 

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

func (*Builder) Prepare 

func (b *Builder) Prepare(raws ...interface{}) ([]string, error)

func (*Builder) Run 

func (b *Builder) Run(ctx context.Context, ui packer.Ui, hook packer.Hook) (packer.Artifact, error)

type Config 

type Config struct {
	common.PackerConfig `mapstructure:",squash"`

	AccessConfig `mapstructure:",squash"`
	ImageConfig  `mapstructure:",squash"`
	RunConfig    `mapstructure:",squash"`
	// contains filtered or unexported fields
}

type ExternalNetwork 

type ExternalNetwork struct {
	networks.Network
	external.NetworkExternalExt
}

ExternalNetwork is a network with external router.

type ImageConfig 

type ImageConfig struct {
	// The name of the resulting image.
	ImageName string `mapstructure:"image_name" required:"true"`
	// Glance metadata that will be applied to the image.
	ImageMetadata map[string]string `mapstructure:"metadata" required:"false"`
	// One of "public", "private", "shared", or "community".
	ImageVisibility imageservice.ImageVisibility `mapstructure:"image_visibility" required:"false"`
	// List of members to add to the image after creation. An image member is
	// usually a project (also called the "tenant") with whom the image is
	// shared.
	ImageMembers []string `mapstructure:"image_members" required:"false"`
	// Disk format of the resulting image. This option works if
	// use_blockstorage_volume is true.
	ImageDiskFormat string `mapstructure:"image_disk_format" required:"false"`
	// List of tags to add to the image after creation.
	ImageTags []string `mapstructure:"image_tags" required:"false"`
	// Minimum disk size needed to boot image, in gigabytes.
	ImageMinDisk int `mapstructure:"image_min_disk" required:"false"`
}

ImageConfig is for common configuration related to creating Images.

func (*ImageConfig) Prepare 

func (c *ImageConfig) Prepare(ctx *interpolate.Context) []error

type ImageFilter 

type ImageFilter struct {
	// filters used to select a source_image. NOTE: This will fail unless
	// exactly one image is returned, or most_recent is set to true. Of the
	// filters described in ImageService, the following are valid:
	Filters ImageFilterOptions `mapstructure:"filters" required:"false"`
	// Selects the newest created image when true. This is most useful for
	// selecting a daily distro build.
	MostRecent bool `mapstructure:"most_recent" required:"false"`
}

type ImageFilterOptions 

type ImageFilterOptions struct {
	Name       string            `mapstructure:"name"`
	Owner      string            `mapstructure:"owner"`
	Tags       []string          `mapstructure:"tags"`
	Visibility string            `mapstructure:"visibility"`
	Properties map[string]string `mapstructure:"properties"`
}

func (*ImageFilterOptions) Build 

func (f *ImageFilterOptions) Build() (*images.ListOpts, error)

func (*ImageFilterOptions) Empty 

func (f *ImageFilterOptions) Empty() bool

type LogRoundTripper 

type LogRoundTripper struct {
	Rt    http.RoundTripper
	Debug bool
}

LogRoundTripper satisfies the http.RoundTripper interface and is used to customize the default http client RoundTripper to allow for logging.

func (*LogRoundTripper) RoundTrip 

func (lrt *LogRoundTripper) RoundTrip(request *http.Request) (*http.Response, error)

RoundTrip performs a round-trip HTTP request and logs relevant information about it.

type RunConfig 

type RunConfig struct {
	Comm communicator.Config `mapstructure:",squash"`
	// The type of interface to connect via SSH. Values useful for Rackspace
	// are "public" or "private", and the default behavior is to connect via
	// whichever is returned first from the OpenStack API.
	SSHInterface string `mapstructure:"ssh_interface" required:"false"`
	// The IP version to use for SSH connections, valid values are `4` and `6`.
	// Useful on dual stacked instances where the default behavior is to
	// connect via whichever IP address is returned first from the OpenStack
	// API.
	SSHIPVersion string `mapstructure:"ssh_ip_version" required:"false"`
	// The ID or full URL to the base image to use. This is the image that will
	// be used to launch a new server and provision it. Unless you specify
	// completely custom SSH settings, the source image must have cloud-init
	// installed so that the keypair gets assigned properly.
	SourceImage string `mapstructure:"source_image" required:"true"`
	// The name of the base image to use. This is an alternative way of
	// providing source_image and only either of them can be specified.
	SourceImageName string `mapstructure:"source_image_name" required:"true"`
	// Filters used to populate filter options. Example:
	//
	// “` json {
	//     "source_image_filter": {
	//         "filters": {
	//             "name": "ubuntu-16.04",
	//             "visibility": "protected",
	//             "owner": "d1a588cf4b0743344508dc145649372d1",
	//             "tags": ["prod", "ready"],
	//             "properties": {
	//                 "os_distro": "ubuntu"
	//             }
	//         },
	//         "most_recent": true
	//     }
	// }
	// “`
	//
	// This selects the most recent production Ubuntu 16.04 shared to you by
	// the given owner. NOTE: This will fail unless *exactly* one image is
	// returned, or `most_recent` is set to true. In the example of multiple
	// returned images, `most_recent` will cause this to succeed by selecting
	// the newest image of the returned images.
	//
	// -   `filters` (map of strings) - filters used to select a
	// `source_image`.
	//     NOTE: This will fail unless *exactly* one image is returned, or
	//     `most_recent` is set to true. Of the filters described in
	//     [ImageService](https://developer.openstack.org/api-ref/image/v2/), the
	//     following are valid:
	//
	//     -   name (string)
	//
	//     -   owner (string)
	//
	//     -   tags (array of strings)
	//
	//     -   visibility (string)
	//
	//     -   properties (map of strings to strings) (fields that can be set
	//         with `openstack image set --property key=value`)
	//
	// -   `most_recent` (boolean) - Selects the newest created image when
	// true.
	//     This is most useful for selecting a daily distro build.
	//
	// You may set use this in place of `source_image` If `source_image_filter`
	// is provided alongside `source_image`, the `source_image` will override
	// the filter. The filter will not be used in this case.
	SourceImageFilters ImageFilter `mapstructure:"source_image_filter" required:"true"`
	// The ID, name, or full URL for the desired flavor for the server to be
	// created.
	Flavor string `mapstructure:"flavor" required:"true"`
	// The availability zone to launch the server in. If this isn't specified,
	// the default enforced by your OpenStack cluster will be used. This may be
	// required for some OpenStack clusters.
	AvailabilityZone string `mapstructure:"availability_zone" required:"false"`
	// For rackspace, whether or not to wait for Rackconnect to assign the
	// machine an IP address before connecting via SSH. Defaults to false.
	RackconnectWait bool `mapstructure:"rackconnect_wait" required:"false"`
	// The ID or name of an external network that can be used for creation of a
	// new floating IP.
	FloatingIPNetwork string `mapstructure:"floating_ip_network" required:"false"`
	// The ID of the network to which the instance is attached and which should
	// be used to associate with the floating IP. This provides control over
	// the floating ip association on multi-homed instances. The association
	// otherwise depends on a first-returned-interface policy which could fail
	// if the network to which it is connected is unreachable from the floating
	// IP network.
	InstanceFloatingIPNet string `mapstructure:"instance_floating_ip_net" required:"false"`
	// A specific floating IP to assign to this instance.
	FloatingIP string `mapstructure:"floating_ip" required:"false"`
	// Whether or not to attempt to reuse existing unassigned floating ips in
	// the project before allocating a new one. Note that it is not possible to
	// safely do this concurrently, so if you are running multiple openstack
	// builds concurrently, or if other processes are assigning and using
	// floating IPs in the same openstack project while packer is running, you
	// should not set this to true. Defaults to false.
	ReuseIPs bool `mapstructure:"reuse_ips" required:"false"`
	// The type of eip. See the api doc to get the value.
	EIPType string `mapstructure:"eip_type" required:"false"`
	// The size of eip bandwidth.
	EIPBandwidthSize int `mapstructure:"eip_bandwidth_size" required:"false"`
	// A list of security groups by name to add to this instance.
	SecurityGroups []string `mapstructure:"security_groups" required:"false"`
	// A list of networks by UUID to attach to this instance.
	Networks []string `mapstructure:"networks" required:"false"`
	// A list of ports by UUID to attach to this instance.
	Ports []string `mapstructure:"ports" required:"false"`
	// A vpc id to attach to this instance.
	VpcID string `mapstructure:"vpc_id" required:"false"`
	// A list of subnets by UUID to attach to this instance.
	Subnets []string `mapstructure:"subnets" required:"false"`
	// User data to apply when launching the instance. Note that you need to be
	// careful about escaping characters due to the templates being JSON. It is
	// often more convenient to use user_data_file, instead. Packer will not
	// automatically wait for a user script to finish before shutting down the
	// instance this must be handled in a provisioner.
	UserData string `mapstructure:"user_data" required:"false"`
	// Path to a file that will be used for the user data when launching the
	// instance.
	UserDataFile string `mapstructure:"user_data_file" required:"false"`
	// Name that is applied to the server instance created by Packer. If this
	// isn't specified, the default is same as image_name.
	InstanceName string `mapstructure:"instance_name" required:"false"`
	// Metadata that is applied to the server instance created by Packer. Also
	// called server properties in some documentation. The strings have a max
	// size of 255 bytes each.
	InstanceMetadata map[string]string `mapstructure:"instance_metadata" required:"false"`
	// Whether to force the OpenStack instance to be forcefully deleted. This
	// is useful for environments that have reclaim / soft deletion enabled. By
	// default this is false.
	ForceDelete bool `mapstructure:"force_delete" required:"false"`
	// Whether or not nova should use ConfigDrive for cloud-init metadata.
	ConfigDrive bool `mapstructure:"config_drive" required:"false"`
	// Deprecated use floating_ip_network instead.
	FloatingIPPool string `mapstructure:"floating_ip_pool" required:"false"`
	// Use Block Storage service volume for the instance root volume instead of
	// Compute service local volume (default).
	UseBlockStorageVolume bool `mapstructure:"use_blockstorage_volume" required:"false"`
	// Name of the Block Storage service volume. If this isn't specified,
	// random string will be used.
	VolumeName string `mapstructure:"volume_name" required:"false"`
	// Type of the Block Storage service volume. If this isn't specified, the
	// default enforced by your OpenStack cluster will be used.
	VolumeType string `mapstructure:"volume_type" required:"false"`
	// Size of the Block Storage service volume in GB. If this isn't specified,
	// it is set to source image min disk value (if set) or calculated from the
	// source image bytes size. Note that in some cases this needs to be
	// specified, if use_blockstorage_volume is true.
	VolumeSize int `mapstructure:"volume_size" required:"false"`
	// Availability zone of the Block Storage service volume. If omitted,
	// Compute instance availability zone will be used. If both of Compute
	// instance and Block Storage volume availability zones aren't specified,
	// the default enforced by your OpenStack cluster will be used.
	VolumeAvailabilityZone string `mapstructure:"volume_availability_zone" required:"false"`

	// Not really used, but here for BC
	OpenstackProvider string `mapstructure:"openstack_provider"`
	// *Deprecated* use `floating_ip` or `floating_ip_pool` instead.
	UseFloatingIp bool `mapstructure:"use_floating_ip" required:"false"`
	// contains filtered or unexported fields
}

RunConfig contains configuration for running an instance from a source image and details on how to access that launched image.

func (*RunConfig) Prepare 

func (c *RunConfig) Prepare(ctx *interpolate.Context) []error

type StateChangeConf 

type StateChangeConf struct {
	Pending   []string
	Refresh   StateRefreshFunc
	StepState multistep.StateBag
	Target    []string
}

StateChangeConf is the configuration struct used for `WaitForState`.

type StateChangeConf1 

type StateChangeConf1 struct {
	Delay          time.Duration     // Wait this time before starting checks
	Pending        []string          // States that are "allowed" and will continue trying
	Refresh        StateRefreshFunc1 // Refreshes the current state
	Target         []string          // Target state
	Timeout        time.Duration     // The amount of time to wait before timeout
	MinTimeout     time.Duration     // Smallest time to wait before refreshes
	PollInterval   time.Duration     // Override MinTimeout/backoff and only poll this often
	NotFoundChecks int               // Number of times to allow not found
	StateBag       multistep.StateBag

	// This is to work around inconsistent APIs
	ContinuousTargetOccurence int // Number of times the Target state has to occur continuously
}

StateChangeConf is the configuration struct used for `WaitForState`.

func (*StateChangeConf1) WaitForState 

func (conf *StateChangeConf1) WaitForState() (interface{}, error)

WaitForState watches an object and waits for it to achieve the state specified in the configuration using the specified Refresh() func, waiting the number of seconds specified in the timeout configuration.

If the Refresh function returns an error, exit immediately with that error.

If the Refresh function returns a state other than the Target state or one listed in Pending, return immediately with an error.

If the Timeout is exceeded before reaching the Target state, return an error.

Otherwise, the result is the result of the first call to the Refresh function to reach the target state.

type StateRefreshFunc 

type StateRefreshFunc func() (result interface{}, state string, progress int, err error)

StateRefreshFunc is a function type used for StateChangeConf that is responsible for refreshing the item being watched for a state change.

It returns three results. `result` is any object that will be returned as the final object after waiting for state change. This allows you to return the final updated object, for example an openstack instance after refreshing it.

`state` is the latest state of that object. And `err` is any error that may have happened while refreshing the state.

func ServerStateRefreshFunc 

func ServerStateRefreshFunc(
	client *gophercloud.ServiceClient, s *servers.Server) StateRefreshFunc

ServerStateRefreshFunc returns a StateRefreshFunc that is used to watch an openstack server.

type StateRefreshFunc1 

type StateRefreshFunc1 func() (result interface{}, state string, err error)

StateRefreshFunc is a function type used for StateChangeConf that is responsible for refreshing the item being watched for a state change.

It returns three results. `result` is any object that will be returned as the final object after waiting for state change. This allows you to return the final updated object, for example an EC2 instance after refreshing it.

`state` is the latest state of that object. And `err` is any error that may have happened while refreshing the state.

type StepAllocateIp 

type StepAllocateIp struct {
	FloatingIPNetwork     string
	FloatingIP            string
	ReuseIPs              bool
	InstanceFloatingIPNet string
	EIPType               string
	EIPBandwidthSize      int
}

func (*StepAllocateIp) Cleanup 

func (s *StepAllocateIp) Cleanup(state multistep.StateBag)

func (*StepAllocateIp) Run 

func (s *StepAllocateIp) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepCreateVolume 

type StepCreateVolume struct {
	UseBlockStorageVolume  bool
	VolumeName             string
	VolumeType             string
	VolumeAvailabilityZone string
	// contains filtered or unexported fields
}

func (*StepCreateVolume) Cleanup 

func (s *StepCreateVolume) Cleanup(state multistep.StateBag)

func (*StepCreateVolume) Run 

func (s *StepCreateVolume) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepDetachVolume 

type StepDetachVolume struct {
	UseBlockStorageVolume bool
}

func (*StepDetachVolume) Cleanup 

func (s *StepDetachVolume) Cleanup(multistep.StateBag)

func (*StepDetachVolume) Run 

func (s *StepDetachVolume) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepGetPassword 

type StepGetPassword struct {
	Debug     bool
	Comm      *communicator.Config
	BuildName string
}

StepGetPassword reads the password from a booted OpenStack server and sets it on the WinRM config.

func (*StepGetPassword) Cleanup 

func (s *StepGetPassword) Cleanup(multistep.StateBag)

func (*StepGetPassword) Run 

func (s *StepGetPassword) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepKeyPair 

type StepKeyPair struct {
	Debug        bool
	Comm         *communicator.Config
	DebugKeyPath string
	// contains filtered or unexported fields
}

func (*StepKeyPair) Cleanup 

func (s *StepKeyPair) Cleanup(state multistep.StateBag)

func (*StepKeyPair) Run 

func (s *StepKeyPair) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepLoadAZ 

type StepLoadAZ struct {
}

func (*StepLoadAZ) Cleanup 

func (s *StepLoadAZ) Cleanup(state multistep.StateBag)

func (*StepLoadAZ) Run 

func (s *StepLoadAZ) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepLoadFlavor 

type StepLoadFlavor struct {
	Flavor string
}

StepLoadFlavor gets the FlavorRef from a Flavor. It first assumes that the Flavor is a ref and verifies it. Otherwise, it tries to find the flavor by name.

func (*StepLoadFlavor) Cleanup 

func (s *StepLoadFlavor) Cleanup(state multistep.StateBag)

func (*StepLoadFlavor) Run 

func (s *StepLoadFlavor) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepRunSourceServer 

type StepRunSourceServer struct {
	Name                  string
	SecurityGroups        []string
	Networks              []string
	Ports                 []string
	VpcID                 string
	Subnets               []string
	AvailabilityZone      string
	UserData              string
	UserDataFile          string
	ConfigDrive           bool
	InstanceMetadata      map[string]string
	UseBlockStorageVolume bool
	ForceDelete           bool
	// contains filtered or unexported fields
}

func (*StepRunSourceServer) Cleanup 

func (s *StepRunSourceServer) Cleanup(state multistep.StateBag)

func (*StepRunSourceServer) Run 

func (s *StepRunSourceServer) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepSourceImageInfo 

type StepSourceImageInfo struct {
	SourceImage      string
	SourceImageName  string
	SourceImageOpts  images.ListOpts
	SourceMostRecent bool
	SourceProperties map[string]string
}

func (*StepSourceImageInfo) Cleanup 

func (s *StepSourceImageInfo) Cleanup(state multistep.StateBag)

func (*StepSourceImageInfo) Run 

func (s *StepSourceImageInfo) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepStopServer 

type StepStopServer struct{}

func (*StepStopServer) Cleanup 

func (s *StepStopServer) Cleanup(state multistep.StateBag)

func (*StepStopServer) Run 

func (s *StepStopServer) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type StepWaitForRackConnect 

type StepWaitForRackConnect struct {
	Wait bool
}

func (*StepWaitForRackConnect) Cleanup 

func (s *StepWaitForRackConnect) Cleanup(state multistep.StateBag)

func (*StepWaitForRackConnect) Run 

func (s *StepWaitForRackConnect) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction

type TimeoutError 

type TimeoutError struct {
	LastError     error
	LastState     string
	Timeout       time.Duration
	ExpectedState []string
}

func (*TimeoutError) Error 

func (e *TimeoutError) Error() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.