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 }