triton

package
v0.12.3 Latest Latest
Warning

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

 Go to latest Published: Mar 2, 2017 License: MPL-2.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	BuilderId = "joyent.triton"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessConfig 

type AccessConfig struct {
	Endpoint    string `mapstructure:"triton_url"`
	Account     string `mapstructure:"triton_account"`
	KeyID       string `mapstructure:"triton_key_id"`
	KeyMaterial string `mapstructure:"triton_key_material"`
}

AccessConfig is for common configuration related to Triton access

func (*AccessConfig) Comm 

func (c *AccessConfig) Comm() communicator.Config

func (*AccessConfig) CreateTritonClient 

func (c *AccessConfig) CreateTritonClient() (*cloudapi.Client, error)

CreateTritonClient returns an SDC client configured with the appropriate client credentials or an error if creating the client fails.

func (*AccessConfig) Prepare 

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

Prepare performs basic validation on the AccessConfig

type Artifact 

type Artifact struct {
	// ImageID is the image ID of the artifact
	ImageID string

	// BuilderIDValue is the unique ID for the builder that created this Image
	BuilderIDValue string

	// SDC connection for cleanup etc
	Driver Driver
}

Artifact is an artifact implementation that contains built Triton 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) Cancel 

func (b *Builder) Cancel()

Cancel cancels a possibly running Builder. This should block until the builder actually cancels and cleans up after itself.

func (*Builder) Prepare 

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

func (*Builder) Run 

func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error)

type Config 

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

	Comm communicator.Config `mapstructure:",squash"`
	// contains filtered or unexported fields
}

type Driver 

type Driver interface {
	CreateImageFromMachine(machineId string, config Config) (string, error)
	CreateMachine(config Config) (string, error)
	DeleteImage(imageId string) error
	DeleteMachine(machineId string) error
	GetMachine(machineId string) (string, error)
	StopMachine(machineId string) error
	WaitForImageCreation(imageId string, timeout time.Duration) error
	WaitForMachineDeletion(machineId string, timeout time.Duration) error
	WaitForMachineState(machineId string, state string, timeout time.Duration) error
}

func NewDriverTriton 

func NewDriverTriton(ui packer.Ui, config Config) (Driver, error)

type DriverMock 

type DriverMock struct {
	CreateImageFromMachineId  string
	CreateImageFromMachineErr error

	CreateMachineId  string
	CreateMachineErr error

	DeleteImageId  string
	DeleteImageErr error

	DeleteMachineId  string
	DeleteMachineErr error

	GetMachineErr error

	StopMachineId  string
	StopMachineErr error

	WaitForImageCreationErr error

	WaitForMachineDeletionErr error

	WaitForMachineStateErr error
}

func (*DriverMock) CreateImageFromMachine 

func (d *DriverMock) CreateImageFromMachine(machineId string, config Config) (string, error)

func (*DriverMock) CreateMachine 

func (d *DriverMock) CreateMachine(config Config) (string, error)

func (*DriverMock) DeleteImage 

func (d *DriverMock) DeleteImage(imageId string) error

func (*DriverMock) DeleteMachine 

func (d *DriverMock) DeleteMachine(machineId string) error

func (*DriverMock) GetMachine 

func (d *DriverMock) GetMachine(machineId string) (string, error)

func (*DriverMock) StopMachine 

func (d *DriverMock) StopMachine(machineId string) error

func (*DriverMock) WaitForImageCreation 

func (d *DriverMock) WaitForImageCreation(machineId string, timeout time.Duration) error

func (*DriverMock) WaitForMachineDeletion 

func (d *DriverMock) WaitForMachineDeletion(machineId string, timeout time.Duration) error

func (*DriverMock) WaitForMachineState 

func (d *DriverMock) WaitForMachineState(machineId string, state string, timeout time.Duration) error

type SourceMachineConfig 

type SourceMachineConfig struct {
	MachineName            string            `mapstructure:"source_machine_name"`
	MachinePackage         string            `mapstructure:"source_machine_package"`
	MachineImage           string            `mapstructure:"source_machine_image"`
	MachineNetworks        []string          `mapstructure:"source_machine_networks"`
	MachineMetadata        map[string]string `mapstructure:"source_machine_metadata"`
	MachineTags            map[string]string `mapstructure:"source_machine_tags"`
	MachineFirewallEnabled bool              `mapstructure:"source_machine_firewall_enabled"`
}

SourceMachineConfig represents the configuration to run a machine using the SDC API in order for provisioning to take place.

func (*SourceMachineConfig) Prepare 

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

Prepare performs basic validation on a SourceMachineConfig struct.

type StepCreateImageFromMachine 

type StepCreateImageFromMachine struct{}

StepCreateImageFromMachine creates an image with the specified attributes from the machine with the given ID, and waits for the image to be created. The machine must be in the "stopped" state prior to this step being run.

func (*StepCreateImageFromMachine) Cleanup 

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

func (*StepCreateImageFromMachine) Run 

func (s *StepCreateImageFromMachine) Run(state multistep.StateBag) multistep.StepAction

type StepCreateSourceMachine 

type StepCreateSourceMachine struct{}

StepCreateSourceMachine creates an machine with the specified attributes and waits for it to become available for provisioners.

func (*StepCreateSourceMachine) Cleanup 

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

func (*StepCreateSourceMachine) Run 

func (s *StepCreateSourceMachine) Run(state multistep.StateBag) multistep.StepAction

type StepDeleteMachine 

type StepDeleteMachine struct{}

StepDeleteMachine deletes the machine with the ID specified in state["machine"]

func (*StepDeleteMachine) Cleanup 

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

func (*StepDeleteMachine) Run 

func (s *StepDeleteMachine) Run(state multistep.StateBag) multistep.StepAction

type StepStopMachine 

type StepStopMachine struct{}

StepStopMachine stops the machine with the given Machine ID, and waits for it to reach the stopped state.

func (*StepStopMachine) Cleanup 

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

func (*StepStopMachine) Run 

func (s *StepStopMachine) Run(state multistep.StateBag) multistep.StepAction

type StepWaitForStopNotToFail 

type StepWaitForStopNotToFail struct{}

StepWaitForStopNotToFail waits for 10 seconds before returning with continue in order to prevent an observed issue where machines stopped immediately after they are started never actually stop.

func (*StepWaitForStopNotToFail) Cleanup 

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

func (*StepWaitForStopNotToFail) Run 

func (s *StepWaitForStopNotToFail) Run(state multistep.StateBag) multistep.StepAction

type TargetImageConfig 

type TargetImageConfig struct {
	ImageName        string            `mapstructure:"image_name"`
	ImageVersion     string            `mapstructure:"image_version"`
	ImageDescription string            `mapstructure:"image_description"`
	ImageHomepage    string            `mapstructure:"image_homepage"`
	ImageEULA        string            `mapstructure:"image_eula_url"`
	ImageACL         []string          `mapstructure:"image_acls"`
	ImageTags        map[string]string `mapstructure:"image_tags"`
}

TargetImageConfig represents the configuration for the image to be created from the source machine.

func (*TargetImageConfig) Prepare 

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

Prepare performs basic validation on a TargetImageConfig struct.

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.