common

package
v1.0.0-rc3 Latest Latest
Warning

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

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

Documentation

Index

Constants

View Source 
const (
	SwitchTypeInternal = "Internal"
	SwitchTypePrivate  = "Private"
	DefaultSwitchType  = SwitchTypeInternal
)
View Source 
const BuilderId = "MSOpenTech.hyperv"

This is the common builder ID to all of these artifacts.

View Source 
const (
	FloppyFileName = "assets.vfd"
)
View Source 
const (
	SleepSeconds = 10
)

Variables

This section is empty.

Functions

func CommHost 

func CommHost(state multistep.StateBag) (string, error)

func NewArtifact 

func NewArtifact(dir string) (packer.Artifact, error)

NewArtifact returns a hyperv artifact containing the files in the given directory.

func SSHConfigFunc 

func SSHConfigFunc(config *SSHConfig) func(multistep.StateBag) (*gossh.ClientConfig, error)

Types

type Driver 

type Driver interface {

	// Checks if the VM named is running.
	IsRunning(string) (bool, error)

	// Checks if the VM named is off.
	IsOff(string) (bool, error)

	//How long has VM been on
	Uptime(vmName string) (uint64, error)

	// Start starts a VM specified by the name given.
	Start(string) error

	// Stop stops a VM specified by the name given.
	Stop(string) error

	// Verify checks to make sure that this driver should function
	// properly. If there is any indication the driver can't function,
	// this will return an error.
	Verify() error

	// Finds the MAC address of the NIC nic0
	Mac(string) (string, error)

	// Finds the IP address of a VM connected that uses DHCP by its MAC address
	IpAddress(string) (string, error)

	// Finds the hostname for the ip address
	GetHostName(string) (string, error)

	// Finds the IP address of a host adapter connected to switch
	GetHostAdapterIpAddressForSwitch(string) (string, error)

	// Type scan codes to virtual keyboard of vm
	TypeScanCodes(string, string) error

	//Get the ip address for network adaptor
	GetVirtualMachineNetworkAdapterAddress(string) (string, error)

	//Set the vlan to use for switch
	SetNetworkAdapterVlanId(string, string) error

	//Set the vlan to use for machine
	SetVirtualMachineVlanId(string, string) error

	UntagVirtualMachineNetworkAdapterVlan(string, string) error

	CreateExternalVirtualSwitch(string, string) error

	GetVirtualMachineSwitchName(string) (string, error)

	ConnectVirtualMachineNetworkAdapterToSwitch(string, string) error

	CreateVirtualSwitch(string, string) (bool, error)

	DeleteVirtualSwitch(string) error

	CreateVirtualMachine(string, string, int64, int64, string, uint) error

	DeleteVirtualMachine(string) error

	SetVirtualMachineCpuCount(string, uint) error

	SetVirtualMachineMacSpoofing(string, bool) error

	SetVirtualMachineDynamicMemory(string, bool) error

	SetVirtualMachineSecureBoot(string, bool) error

	SetVirtualMachineVirtualizationExtensions(string, bool) error

	EnableVirtualMachineIntegrationService(string, string) error

	ExportVirtualMachine(string, string) error

	CompactDisks(string, string) error

	CopyExportedVirtualMachine(string, string, string, string) error

	RestartVirtualMachine(string) error

	CreateDvdDrive(string, string, uint) (uint, uint, error)

	MountDvdDrive(string, string, uint, uint) error

	SetBootDvdDrive(string, uint, uint, uint) error

	UnmountDvdDrive(string, uint, uint) error

	DeleteDvdDrive(string, uint, uint) error

	MountFloppyDrive(string, string) error

	UnmountFloppyDrive(string) error
}

A driver is able to talk to HyperV and perform certain operations with it. Some of the operations on here may seem overly specific, but they were built specifically in mind to handle features of the HyperV builder for Packer, and to abstract differences in versions out of the builder steps, so sometimes the methods are extremely specific.

func NewHypervPS4Driver 

func NewHypervPS4Driver() (Driver, error)

type DvdControllerProperties 

type DvdControllerProperties struct {
	ControllerNumber   uint
	ControllerLocation uint
	Existing           bool
}

type FloppyConfig 

type FloppyConfig struct {
	FloppyFiles []string `mapstructure:"floppy_files"`
}

FloppyConfig is configuration related to created floppy disks and attaching them to a Parallels virtual machine.

func (*FloppyConfig) Prepare 

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

type HypervPS4Driver 

type HypervPS4Driver struct {
}

func (*HypervPS4Driver) CompactDisks 

func (d *HypervPS4Driver) CompactDisks(expPath string, vhdDir string) error

func (*HypervPS4Driver) ConnectVirtualMachineNetworkAdapterToSwitch 

func (d *HypervPS4Driver) ConnectVirtualMachineNetworkAdapterToSwitch(vmName string, switchName string) error

func (*HypervPS4Driver) CopyExportedVirtualMachine 

func (d *HypervPS4Driver) CopyExportedVirtualMachine(expPath string, outputPath string, vhdDir string, vmDir string) error

func (*HypervPS4Driver) CreateDvdDrive 

func (d *HypervPS4Driver) CreateDvdDrive(vmName string, isoPath string, generation uint) (uint, uint, error)

func (*HypervPS4Driver) CreateExternalVirtualSwitch 

func (d *HypervPS4Driver) CreateExternalVirtualSwitch(vmName string, switchName string) error

func (*HypervPS4Driver) CreateVirtualMachine 

func (d *HypervPS4Driver) CreateVirtualMachine(vmName string, path string, ram int64, diskSize int64, switchName string, generation uint) error

func (*HypervPS4Driver) CreateVirtualSwitch 

func (d *HypervPS4Driver) CreateVirtualSwitch(switchName string, switchType string) (bool, error)

func (*HypervPS4Driver) DeleteDvdDrive 

func (d *HypervPS4Driver) DeleteDvdDrive(vmName string, controllerNumber uint, controllerLocation uint) error

func (*HypervPS4Driver) DeleteVirtualMachine 

func (d *HypervPS4Driver) DeleteVirtualMachine(vmName string) error

func (*HypervPS4Driver) DeleteVirtualSwitch 

func (d *HypervPS4Driver) DeleteVirtualSwitch(switchName string) error

func (*HypervPS4Driver) EnableVirtualMachineIntegrationService 

func (d *HypervPS4Driver) EnableVirtualMachineIntegrationService(vmName string, integrationServiceName string) error

func (*HypervPS4Driver) ExportVirtualMachine 

func (d *HypervPS4Driver) ExportVirtualMachine(vmName string, path string) error

func (*HypervPS4Driver) GetHostAdapterIpAddressForSwitch 

func (d *HypervPS4Driver) GetHostAdapterIpAddressForSwitch(switchName string) (string, error)

Finds the IP address of a host adapter connected to switch

func (*HypervPS4Driver) GetHostName 

func (d *HypervPS4Driver) GetHostName(ip string) (string, error)

Get host name from ip address

func (*HypervPS4Driver) GetVirtualMachineNetworkAdapterAddress 

func (d *HypervPS4Driver) GetVirtualMachineNetworkAdapterAddress(vmName string) (string, error)

Get network adapter address

func (*HypervPS4Driver) GetVirtualMachineSwitchName 

func (d *HypervPS4Driver) GetVirtualMachineSwitchName(vmName string) (string, error)

func (*HypervPS4Driver) IpAddress 

func (d *HypervPS4Driver) IpAddress(mac string) (string, error)

Get ip address for mac address.

func (*HypervPS4Driver) IsOff 

func (d *HypervPS4Driver) IsOff(vmName string) (bool, error)

func (*HypervPS4Driver) IsRunning 

func (d *HypervPS4Driver) IsRunning(vmName string) (bool, error)

func (*HypervPS4Driver) Mac 

func (d *HypervPS4Driver) Mac(vmName string) (string, error)

Get mac address for VM.

func (*HypervPS4Driver) MountDvdDrive 

func (d *HypervPS4Driver) MountDvdDrive(vmName string, path string, controllerNumber uint, controllerLocation uint) error

func (*HypervPS4Driver) MountFloppyDrive 

func (d *HypervPS4Driver) MountFloppyDrive(vmName string, path string) error

func (*HypervPS4Driver) RestartVirtualMachine 

func (d *HypervPS4Driver) RestartVirtualMachine(vmName string) error

func (*HypervPS4Driver) SetBootDvdDrive 

func (d *HypervPS4Driver) SetBootDvdDrive(vmName string, controllerNumber uint, controllerLocation uint, generation uint) error

func (*HypervPS4Driver) SetNetworkAdapterVlanId 

func (d *HypervPS4Driver) SetNetworkAdapterVlanId(switchName string, vlanId string) error

Set the vlan to use for switch

func (*HypervPS4Driver) SetVirtualMachineCpuCount 

func (d *HypervPS4Driver) SetVirtualMachineCpuCount(vmName string, cpu uint) error

func (*HypervPS4Driver) SetVirtualMachineDynamicMemory 

func (d *HypervPS4Driver) SetVirtualMachineDynamicMemory(vmName string, enable bool) error

func (*HypervPS4Driver) SetVirtualMachineMacSpoofing 

func (d *HypervPS4Driver) SetVirtualMachineMacSpoofing(vmName string, enable bool) error

func (*HypervPS4Driver) SetVirtualMachineSecureBoot 

func (d *HypervPS4Driver) SetVirtualMachineSecureBoot(vmName string, enable bool) error

func (*HypervPS4Driver) SetVirtualMachineVirtualizationExtensions 

func (d *HypervPS4Driver) SetVirtualMachineVirtualizationExtensions(vmName string, enable bool) error

func (*HypervPS4Driver) SetVirtualMachineVlanId 

func (d *HypervPS4Driver) SetVirtualMachineVlanId(vmName string, vlanId string) error

Set the vlan to use for machine

func (*HypervPS4Driver) Start 

func (d *HypervPS4Driver) Start(vmName string) error

Start starts a VM specified by the name given.

func (*HypervPS4Driver) Stop 

func (d *HypervPS4Driver) Stop(vmName string) error

Stop stops a VM specified by the name given.

func (*HypervPS4Driver) TypeScanCodes 

func (d *HypervPS4Driver) TypeScanCodes(vmName string, scanCodes string) error

Type scan codes to virtual keyboard of vm

func (*HypervPS4Driver) UnmountDvdDrive 

func (d *HypervPS4Driver) UnmountDvdDrive(vmName string, controllerNumber uint, controllerLocation uint) error

func (*HypervPS4Driver) UnmountFloppyDrive 

func (d *HypervPS4Driver) UnmountFloppyDrive(vmName string) error

func (*HypervPS4Driver) UntagVirtualMachineNetworkAdapterVlan 

func (d *HypervPS4Driver) UntagVirtualMachineNetworkAdapterVlan(vmName string, switchName string) error

func (*HypervPS4Driver) Uptime 

func (d *HypervPS4Driver) Uptime(vmName string) (uint64, error)

func (*HypervPS4Driver) Verify 

func (d *HypervPS4Driver) Verify() error

type OutputConfig 

type OutputConfig struct {
	OutputDir string `mapstructure:"output_directory"`
}

func (*OutputConfig) Prepare 

func (c *OutputConfig) Prepare(ctx *interpolate.Context, pc *common.PackerConfig) []error

type RunConfig 

type RunConfig struct {
	RawBootWait string `mapstructure:"boot_wait"`

	BootWait time.Duration ``
}

func (*RunConfig) Prepare 

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

type SSHConfig 

type SSHConfig struct {
	Comm communicator.Config `mapstructure:",squash"`
}

func (*SSHConfig) Prepare 

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

type ShutdownConfig 

type ShutdownConfig struct {
	ShutdownCommand    string `mapstructure:"shutdown_command"`
	RawShutdownTimeout string `mapstructure:"shutdown_timeout"`

	ShutdownTimeout time.Duration ``
}

func (*ShutdownConfig) Prepare 

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

type StepConfigureIp 

type StepConfigureIp struct {
}

func (*StepConfigureIp) Cleanup 

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

func (*StepConfigureIp) Run 

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

type StepConfigureVlan 

type StepConfigureVlan struct {
	VlanId       string
	SwitchVlanId string
}

func (*StepConfigureVlan) Cleanup 

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

func (*StepConfigureVlan) Run 

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

type StepCreateExternalSwitch 

type StepCreateExternalSwitch struct {
	SwitchName string
	// contains filtered or unexported fields
}

This step creates switch for VM.

Produces: 

SwitchName string - The name of the Switch

func (*StepCreateExternalSwitch) Cleanup 

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

func (*StepCreateExternalSwitch) Run 

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

type StepCreateSwitch 

type StepCreateSwitch struct {
	// Specifies the name of the switch to be created.
	SwitchName string
	// Specifies the type of the switch to be created. Allowed values are Internal and Private. To create an External
	// virtual switch, specify either the NetAdapterInterfaceDescription or the NetAdapterName parameter, which
	// implicitly set the type of the virtual switch to External.
	SwitchType string
	// Specifies the name of the network adapter to be bound to the switch to be created.
	NetAdapterName string
	// Specifies the interface description of the network adapter to be bound to the switch to be created.
	NetAdapterInterfaceDescription string
	// contains filtered or unexported fields
}

This step creates switch for VM.

Produces: 

SwitchName string - The name of the Switch

func (*StepCreateSwitch) Cleanup 

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

func (*StepCreateSwitch) Run 

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

type StepCreateTempDir 

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

func (*StepCreateTempDir) Cleanup 

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

func (*StepCreateTempDir) Run 

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

type StepCreateVM 

type StepCreateVM struct {
	VMName                         string
	SwitchName                     string
	RamSize                        uint
	DiskSize                       uint
	Generation                     uint
	Cpu                            uint
	EnableMacSpoofing              bool
	EnableDynamicMemory            bool
	EnableSecureBoot               bool
	EnableVirtualizationExtensions bool
}

This step creates the actual virtual machine.

Produces: 

VMName string - The name of the VM

func (*StepCreateVM) Cleanup 

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

func (*StepCreateVM) Run 

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

type StepDisableVlan 

type StepDisableVlan struct {
}

func (*StepDisableVlan) Cleanup 

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

func (*StepDisableVlan) Run 

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

type StepEnableIntegrationService 

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

func (*StepEnableIntegrationService) Cleanup 

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

func (*StepEnableIntegrationService) Run 

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

type StepExportVm 

type StepExportVm struct {
	OutputDir      string
	SkipCompaction bool
}

func (*StepExportVm) Cleanup 

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

func (*StepExportVm) Run 

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

type StepMountDvdDrive 

type StepMountDvdDrive struct {
	Generation uint
}

func (*StepMountDvdDrive) Cleanup 

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

func (*StepMountDvdDrive) Run 

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

type StepMountFloppydrive 

type StepMountFloppydrive struct {
	Generation uint
	// contains filtered or unexported fields
}

func (*StepMountFloppydrive) Cleanup 

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

func (*StepMountFloppydrive) Run 

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

type StepMountGuestAdditions 

type StepMountGuestAdditions struct {
	GuestAdditionsMode string
	GuestAdditionsPath string
	Generation         uint
}

func (*StepMountGuestAdditions) Cleanup 

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

func (*StepMountGuestAdditions) Run 

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

type StepMountSecondaryDvdImages 

type StepMountSecondaryDvdImages struct {
	IsoPaths   []string
	Generation uint
}

func (*StepMountSecondaryDvdImages) Cleanup 

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

func (*StepMountSecondaryDvdImages) Run 

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

type StepOutputDir 

type StepOutputDir struct {
	Force bool
	Path  string
	// contains filtered or unexported fields
}

StepOutputDir sets up the output directory by creating it if it does not exist, deleting it if it does exist and we're forcing, and cleaning it up when we're done with it.

func (*StepOutputDir) Cleanup 

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

func (*StepOutputDir) Run 

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

type StepPollingInstalation 

type StepPollingInstalation struct {
}

func (*StepPollingInstalation) Cleanup 

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

func (*StepPollingInstalation) Run 

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

type StepRebootVm 

type StepRebootVm struct {
}

func (*StepRebootVm) Cleanup 

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

func (*StepRebootVm) Run 

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

type StepRun 

type StepRun struct {
	BootWait time.Duration
	// contains filtered or unexported fields
}

func (*StepRun) Cleanup 

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

func (*StepRun) Run 

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

type StepShutdown 

type StepShutdown struct {
	Command string
	Timeout time.Duration
}

This step shuts down the machine. It first attempts to do so gracefully, but ultimately forcefully shuts it down if that fails.

Uses: 

communicator packer.Communicator
dir OutputDir
driver Driver
ui     packer.Ui
vmx_path string

Produces: 

<nothing>

func (*StepShutdown) Cleanup 

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

func (*StepShutdown) Run 

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

type StepSleep 

type StepSleep struct {
	Minutes    time.Duration
	ActionName string
}

func (*StepSleep) Cleanup 

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

func (*StepSleep) Run 

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

type StepTypeBootCommand 

type StepTypeBootCommand struct {
	BootCommand []string
	SwitchName  string
	Ctx         interpolate.Context
}

This step "types" the boot command into the VM via the Hyper-V virtual keyboard

func (*StepTypeBootCommand) Cleanup 

func (*StepTypeBootCommand) Cleanup(multistep.StateBag)

func (*StepTypeBootCommand) Run 

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

type StepUnmountDvdDrive 

type StepUnmountDvdDrive struct {
}

func (*StepUnmountDvdDrive) Cleanup 

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

func (*StepUnmountDvdDrive) Run 

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

type StepUnmountFloppyDrive 

type StepUnmountFloppyDrive struct {
	Generation uint
}

func (*StepUnmountFloppyDrive) Cleanup 

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

func (*StepUnmountFloppyDrive) Run 

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

type StepUnmountGuestAdditions 

type StepUnmountGuestAdditions struct {
}

func (*StepUnmountGuestAdditions) Cleanup 

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

func (*StepUnmountGuestAdditions) Run 

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

type StepUnmountSecondaryDvdImages 

type StepUnmountSecondaryDvdImages struct {
}

func (*StepUnmountSecondaryDvdImages) Cleanup 

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

func (*StepUnmountSecondaryDvdImages) Run 

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

type StepWaitForInstallToComplete 

type StepWaitForInstallToComplete struct {
	ExpectedRebootCount uint
	ActionName          string
}

func (*StepWaitForInstallToComplete) Cleanup 

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

func (*StepWaitForInstallToComplete) Run 

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

type StepWaitForPowerOff 

type StepWaitForPowerOff struct {
}

func (*StepWaitForPowerOff) Cleanup 

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

func (*StepWaitForPowerOff) Run 

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

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.