func (d *Dispatcher) deleteNetworkDevices(vmm *vm.VirtualMachine, conf *config.VirtualContainerHostConfigSpec) error {
defer trace.End(trace.Begin(""))
log.Infof("Removing appliance VM network devices")
power, err := vmm.PowerState(d.ctx)
if err != nil {
log.Errorf("Failed to get vm power status %q: %s", vmm.Reference(), err)
return err
}
if power != types.VirtualMachinePowerStatePoweredOff {
if _, err = tasks.WaitForResult(d.ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return vmm.PowerOff(ctx)
}); err != nil {
log.Errorf("Failed to power off existing appliance for %s", err)
return err
}
}
devices, err := d.networkDevices(vmm)
if err != nil {
log.Errorf("Unable to get network devices: %s", err)
return err
}
if len(devices) == 0 {
log.Infof("No network device attached")
return nil
}
// remove devices
return vmm.RemoveDevice(d.ctx, false, devices...)
}
func (d *Dispatcher) InspectVCH(vch *vm.VirtualMachine, conf *config.VirtualContainerHostConfigSpec) error {
defer trace.End(trace.Begin(conf.Name))
state, err := vch.PowerState(d.ctx)
if err != nil {
log.Errorf("Failed to get VM power state, service might not be available at this moment.")
}
if state != types.VirtualMachinePowerStatePoweredOn {
err = errors.Errorf("VCH is not powered on, state %s", state)
log.Errorf("%s", err)
return err
}
clientIP := conf.ExecutorConfig.Networks["client"].Assigned.IP
externalIP := conf.ExecutorConfig.Networks["external"].Assigned.IP
if ip.IsUnspecifiedIP(clientIP) {
err = errors.Errorf("No client IP address assigned")
log.Errorf("%s", err)
return err
}
if ip.IsUnspecifiedIP(externalIP) {
err = errors.Errorf("No external IP address assigned")
log.Errorf("%s", err)
return err
}
d.HostIP = clientIP.String()
log.Debugf("IP address for client interface: %s", d.HostIP)
if !conf.HostCertificate.IsNil() {
d.VICAdminProto = "https"
d.DockerPort = fmt.Sprintf("%d", opts.DefaultTLSHTTPPort)
} else {
d.VICAdminProto = "http"
d.DockerPort = fmt.Sprintf("%d", opts.DefaultHTTPPort)
}
// try looking up preferred name, irrespective of CAs
if cert, err := conf.HostCertificate.X509Certificate(); err == nil {
name, _ := viableHostAddress([]net.IP{clientIP}, cert, conf.CertificateAuthorities)
if name != "" {
log.Debugf("Retrieved proposed name from host certificate: %q", name)
log.Debugf("Assigning first name from set: %s", name)
if name != d.HostIP {
log.Infof("Using address from host certificate over allocated IP: %s", d.HostIP)
// reassign
d.HostIP = name
}
} else {
log.Warnf("Unable to identify address acceptable to host certificate")
}
} else {
log.Debugf("Failed to load host cert: %s", err)
}
d.ShowVCH(conf, "", "", "", "")
return nil
}
func (d *Dispatcher) InspectVCH(vch *vm.VirtualMachine, conf *config.VirtualContainerHostConfigSpec) error {
defer trace.End(trace.Begin(conf.Name))
state, err := vch.PowerState(d.ctx)
if err != nil {
log.Errorf("Failed to get VM power state, service might not be avaialble at this moment.")
}
if state != types.VirtualMachinePowerStatePoweredOn {
err = errors.Errorf("VCH is not powered on, state %s", state)
log.Errorf("%s", err)
return err
}
if ip.IsUnspecifiedIP(conf.ExecutorConfig.Networks["client"].Assigned.IP) {
err = errors.Errorf("No client IP address assigned")
log.Errorf("%s", err)
return err
}
d.HostIP = conf.ExecutorConfig.Networks["client"].Assigned.IP.String()
log.Debug("IP address for client interface: %s", d.HostIP)
if !conf.HostCertificate.IsNil() {
d.VICAdminProto = "https"
d.DockerPort = fmt.Sprintf("%d", opts.DefaultTLSHTTPPort)
} else {
d.VICAdminProto = "http"
d.DockerPort = fmt.Sprintf("%d", opts.DefaultHTTPPort)
}
d.ShowVCH(conf, "", "")
return nil
}
func (d *Dispatcher) deleteVM(vm *vm.VirtualMachine, force bool) error {
defer trace.End(trace.Begin(fmt.Sprintf("vm %q, force %t", vm.String(), force)))
var err error
power, err := vm.PowerState(d.ctx)
if err != nil || power != types.VirtualMachinePowerStatePoweredOff {
if err != nil {
log.Warnf("Failed to get vm power status %q: %s", vm.Reference(), err)
}
if !force {
if err != nil {
return err
}
name := d.getName(vm)
if name != "" {
err = errors.Errorf("VM %q is powered on", name)
} else {
err = errors.Errorf("VM %q is powered on", vm.Reference())
}
return err
}
if _, err = vm.WaitForResult(d.ctx, func(ctx context.Context) (tasks.Task, error) {
return vm.PowerOff(ctx)
}); err != nil {
log.Debugf("Failed to power off existing appliance for %s, try to remove anyway", err)
}
}
// get the actual folder name before we delete it
folder, err := vm.FolderName(d.ctx)
if err != nil {
// failed to get folder name, might not be able to remove files for this VM
name := d.getName(vm)
if name == "" {
log.Errorf("Unable to automatically remove all files in datastore for VM %q", vm.Reference())
} else {
// try to use the vm name in place of folder
log.Infof("Delete will attempt to remove datastore files for VM %q", name)
folder = name
}
}
_, err = vm.WaitForResult(d.ctx, func(ctx context.Context) (tasks.Task, error) {
return vm.DeleteExceptDisks(ctx)
})
if err != nil {
err = errors.Errorf("Failed to destroy VM %q: %s", vm.Reference(), err)
err2 := vm.Unregister(d.ctx)
if err2 != nil {
return errors.Errorf("%s then failed to unregister VM: %s", err, err2)
}
log.Infof("Unregistered VM to cleanup after failed destroy: %q", vm.Reference())
}
if _, err = d.deleteDatastoreFiles(d.session.Datastore, folder, true); err != nil {
log.Warnf("Failed to remove datastore files for VM path %q: %s", folder, err)
}
return nil
}
func (d *Dispatcher) deleteVM(vm *vm.VirtualMachine, force bool) error {
defer trace.End(trace.Begin(""))
var err error
power, err := vm.PowerState(d.ctx)
if err != nil || power != types.VirtualMachinePowerStatePoweredOff {
if err != nil {
log.Warnf("Failed to get vm power status %s: %s", vm.Reference(), err)
}
if !force {
if err != nil {
return err
}
name, err := vm.Name(d.ctx)
if err != nil {
log.Errorf("VM name is not found, %s", err)
}
if name != "" {
err = errors.Errorf("VM %s is powered on", name)
} else {
err = errors.Errorf("VM %s is powered on", vm.Reference())
}
return err
}
if _, err = tasks.WaitForResult(d.ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return vm.PowerOff(ctx)
}); err != nil {
log.Debugf("Failed to power off existing appliance for %s, try to remove anyway", err)
}
}
// get the actual folder name before we delete it
folder, err := vm.FolderName(d.ctx)
if err != nil {
log.Warnf("Failed to get actual folder name for VM. Will not attempt to delete additional data files in VM directory: %s", err)
}
_, err = tasks.WaitForResult(d.ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return vm.Destroy(ctx)
})
if err != nil {
err = errors.Errorf("Failed to destroy vm %s: %s", vm.Reference(), err)
return err
}
if _, err = d.deleteDatastoreFiles(d.session.Datastore, folder, true); err != nil {
log.Warnf("VM path %s is not removed, %s", folder, err)
}
return nil
}
func (d *Dispatcher) enableSSH(ctx context.Context, vch *vm.VirtualMachine, password, authorizedKey string) error {
op, err := trace.FromContext(ctx)
if err != nil {
op = trace.NewOperation(ctx, "enable ssh in appliance")
}
state, err := vch.PowerState(op)
if err != nil {
log.Errorf("Failed to get appliance power state, service might not be available at this moment.")
}
if state != types.VirtualMachinePowerStatePoweredOn {
err = errors.Errorf("VCH appliance is not powered on, state %s", state)
op.Errorf("%s", err)
return err
}
running, err := vch.IsToolsRunning(op)
if err != nil || !running {
err = errors.New("Tools is not running in the appliance, unable to continue")
op.Errorf("%s", err)
return err
}
manager := guest.NewOperationsManager(d.session.Client.Client, vch.Reference())
processManager, err := manager.ProcessManager(op)
if err != nil {
err = errors.Errorf("Unable to manage processes in appliance VM: %s", err)
op.Errorf("%s", err)
return err
}
auth := types.NamePasswordAuthentication{}
spec := types.GuestProgramSpec{
ProgramPath: "enable-ssh",
Arguments: string(authorizedKey),
WorkingDirectory: "/",
EnvVariables: []string{},
}
_, err = processManager.StartProgram(op, &auth, &spec)
if err != nil {
err = errors.Errorf("Unable to enable SSH in appliance VM: %s", err)
op.Errorf("%s", err)
return err
}
if password == "" {
return nil
}
// set the password as well
spec = types.GuestProgramSpec{
ProgramPath: "passwd",
Arguments: password,
WorkingDirectory: "/",
EnvVariables: []string{},
}
_, err = processManager.StartProgram(op, &auth, &spec)
if err != nil {
err = errors.Errorf("Unable to enable in appliance VM: %s", err)
op.Errorf("%s", err)
return err
}
return nil
}
