communicator

Documentation

Index

• Constants
• func SSHFileSigner(path string) (ssh.Signer, error)
• func TestPEM(t *testing.T) string
• type Config
  • func (c *Config) Host() string
  • func (c *Config) Password() string
  • func (c *Config) Port() int
  • func (c *Config) Prepare(ctx *interpolate.Context) []error
  • func (c *Config) User() string
• type StepConnect
  • func (s *StepConnect) Cleanup(state multistep.StateBag)
  • func (s *StepConnect) Run(ctx context.Context, state multistep.StateBag) multistep.StepAction
• type StepConnectSSH
  • func (s *StepConnectSSH) Cleanup(multistep.StateBag)
  • func (s *StepConnectSSH) Run(_ context.Context, state multistep.StateBag) multistep.StepAction
• type StepConnectWinRM
  • func (s *StepConnectWinRM) Cleanup(multistep.StateBag)
  • func (s *StepConnectWinRM) Run(_ context.Context, state multistep.StateBag) multistep.StepAction
• type WinRMConfig

Constants

const TestPEMContents = `` /* 1680-byte string literal not displayed */

Functions

func SSHFileSigner

func SSHFileSigner(path string) (ssh.Signer, error)

SSHFileSigner returns an ssh.Signer for a key file.

func TestPEM

func TestPEM(t *testing.T) string

Types

type Config

type Config struct {
	Type string `mapstructure:"communicator"`

	// SSH
	SSHHost                   string        `mapstructure:"ssh_host"`
	SSHPort                   int           `mapstructure:"ssh_port"`
	SSHUsername               string        `mapstructure:"ssh_username"`
	SSHPassword               string        `mapstructure:"ssh_password"`
	SSHPrivateKey             string        `mapstructure:"ssh_private_key_file"`
	SSHPty                    bool          `mapstructure:"ssh_pty"`
	SSHTimeout                time.Duration `mapstructure:"ssh_timeout"`
	SSHAgentAuth              bool          `mapstructure:"ssh_agent_auth"`
	SSHDisableAgentForwarding bool          `mapstructure:"ssh_disable_agent_forwarding"`
	SSHHandshakeAttempts      int           `mapstructure:"ssh_handshake_attempts"`
	SSHBastionHost            string        `mapstructure:"ssh_bastion_host"`
	SSHBastionPort            int           `mapstructure:"ssh_bastion_port"`
	SSHBastionAgentAuth       bool          `mapstructure:"ssh_bastion_agent_auth"`
	SSHBastionUsername        string        `mapstructure:"ssh_bastion_username"`
	SSHBastionPassword        string        `mapstructure:"ssh_bastion_password"`
	SSHBastionPrivateKey      string        `mapstructure:"ssh_bastion_private_key_file"`
	SSHFileTransferMethod     string        `mapstructure:"ssh_file_transfer_method"`
	SSHProxyHost              string        `mapstructure:"ssh_proxy_host"`
	SSHProxyPort              int           `mapstructure:"ssh_proxy_port"`
	SSHProxyUsername          string        `mapstructure:"ssh_proxy_username"`
	SSHProxyPassword          string        `mapstructure:"ssh_proxy_password"`
	SSHKeepAliveInterval      time.Duration `mapstructure:"ssh_keep_alive_interval"`
	SSHReadWriteTimeout       time.Duration `mapstructure:"ssh_read_write_timeout"`

	// WinRM
	WinRMUser               string        `mapstructure:"winrm_username"`
	WinRMPassword           string        `mapstructure:"winrm_password"`
	WinRMHost               string        `mapstructure:"winrm_host"`
	WinRMPort               int           `mapstructure:"winrm_port"`
	WinRMTimeout            time.Duration `mapstructure:"winrm_timeout"`
	WinRMUseSSL             bool          `mapstructure:"winrm_use_ssl"`
	WinRMInsecure           bool          `mapstructure:"winrm_insecure"`
	WinRMUseNTLM            bool          `mapstructure:"winrm_use_ntlm"`
	WinRMTransportDecorator func() winrm.Transporter
}

Config is the common configuration that communicators allow within a builder.

func (*Config) Host

func (c *Config) Host() string

Host returns the port that will be used for access based on config.

func (*Config) Password

func (c *Config) Password() string

Password returns the port that will be used for access based on config.

func (*Config) Port

func (c *Config) Port() int

Port returns the port that will be used for access based on config.

func (*Config) Prepare

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

func (*Config) User

func (c *Config) User() string

User returns the port that will be used for access based on config.

type StepConnect

type StepConnect struct {
	// Config is the communicator config struct
	Config *Config

	// Host should return a host that can be connected to for communicator
	// connections.
	Host func(multistep.StateBag) (string, error)

	// The fields below are callbacks to assist with connecting to SSH.
	//
	// SSHConfig should return the default configuration for
	// connecting via SSH.
	SSHConfig func(multistep.StateBag) (*gossh.ClientConfig, error)
	SSHPort   func(multistep.StateBag) (int, error)

	// The fields below are callbacks to assist with connecting to WinRM.
	//
	// WinRMConfig should return the default configuration for
	// connecting via WinRM.
	WinRMConfig func(multistep.StateBag) (*WinRMConfig, error)
	WinRMPort   func(multistep.StateBag) (int, error)

	// CustomConnect can be set to have custom connectors for specific
	// types. These take highest precedence so you can also override
	// existing types.
	CustomConnect map[string]multistep.Step
	// contains filtered or unexported fields
}

StepConnect is a multistep Step implementation that connects to the proper communicator and stores it in the "communicator" key in the state bag.

func (*StepConnect) Cleanup

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

func (*StepConnect) Run

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

type StepConnectSSH

type StepConnectSSH struct {
	// All the fields below are documented on StepConnect
	Config    *Config
	Host      func(multistep.StateBag) (string, error)
	SSHConfig func(multistep.StateBag) (*gossh.ClientConfig, error)
	SSHPort   func(multistep.StateBag) (int, error)
}

StepConnectSSH is a step that only connects to SSH.

In general, you should use StepConnect.

func (*StepConnectSSH) Cleanup

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

func (*StepConnectSSH) Run

func (s *StepConnectSSH) Run(_ context.Context, state multistep.StateBag) multistep.StepAction

type StepConnectWinRM

type StepConnectWinRM struct {
	// All the fields below are documented on StepConnect
	Config      *Config
	Host        func(multistep.StateBag) (string, error)
	WinRMConfig func(multistep.StateBag) (*WinRMConfig, error)
	WinRMPort   func(multistep.StateBag) (int, error)
}

StepConnectWinRM is a multistep Step implementation that waits for WinRM to become available. It gets the connection information from a single configuration when creating the step.

Uses:

ui packer.Ui

Produces:

communicator packer.Communicator

func (*StepConnectWinRM) Cleanup

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

func (*StepConnectWinRM) Run

func (s *StepConnectWinRM) Run(_ context.Context, state multistep.StateBag) multistep.StepAction

type WinRMConfig

type WinRMConfig struct {
	Username string
	Password string
}

WinRMConfig is configuration that can be returned at runtime to dynamically configure WinRM.