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) 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
}
// retrieves the uuid of the appliance vm to create a unique vsphere extension name
func (d *Dispatcher) GenerateExtensionName(conf *config.VirtualContainerHostConfigSpec, vm *vm.VirtualMachine) error {
defer trace.End(trace.Begin(conf.ExtensionName))
var o mo.VirtualMachine
err := vm.Properties(d.ctx, vm.Reference(), []string{"config.uuid"}, &o)
if err != nil {
return errors.Errorf("Could not get VM UUID from appliance VM due to error: %s", err)
}
conf.ExtensionName = "com.vmware.vic." + o.Config.Uuid
return nil
}
func (d *Dispatcher) GetVCHConfig(vm *vm.VirtualMachine) (*metadata.VirtualContainerHostConfigSpec, error) {
defer trace.End(trace.Begin(""))
//this is the appliance vm
mapConfig, err := vm.FetchExtraConfig(d.ctx)
if err != nil {
err = errors.Errorf("Failed to get VM extra config of %s, %s", vm.Reference(), err)
log.Errorf("%s", err)
return nil, err
}
data := extraconfig.MapSource(mapConfig)
vchConfig := &metadata.VirtualContainerHostConfigSpec{}
result := extraconfig.Decode(data, vchConfig)
if result == nil {
err = errors.Errorf("Failed to decode VM configuration %s, %s", vm.Reference(), err)
log.Errorf("%s", err)
return nil, err
}
// vchConfig.ID
return vchConfig, nil
}
func (d *Dispatcher) isVCH(vm *vm.VirtualMachine) (bool, error) {
if vm == nil {
return false, errors.New("nil parameter")
}
defer trace.End(trace.Begin(vm.InventoryPath))
info, err := vm.FetchExtraConfig(d.ctx)
if err != nil {
err = errors.Errorf("Failed to fetch guest info of appliance vm: %s", err)
return false, err
}
var remoteConf config.VirtualContainerHostConfigSpec
extraconfig.Decode(extraconfig.MapSource(info), &remoteConf)
// if the moref of the target matches where we expect to find it for a VCH, run with it
if remoteConf.ExecutorConfig.ID == vm.Reference().String() {
return true, nil
}
return false, nil
}
func (d *Uninstall) Run(cli *cli.Context) (err error) {
if err = d.processParams(); err != nil {
return err
}
if d.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Removing VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), d.Timeout)
defer cancel()
defer func() {
if ctx.Err() != nil && ctx.Err() == context.DeadlineExceeded {
//context deadline exceeded, replace returned error message
err = errors.Errorf("Delete timed out: use --timeout to add more time")
}
}()
validator, err := validate.NewValidator(ctx, d.Data)
if err != nil {
log.Errorf("Delete cannot continue - failed to create validator: %s", err)
return errors.New("delete failed")
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, d.Force)
var vch *vm.VirtualMachine
if d.Data.ID != "" {
vch, err = executor.NewVCHFromID(d.Data.ID)
} else {
vch, err = executor.NewVCHFromComputePath(d.Data.ComputeResourcePath, d.Data.DisplayName, validator)
}
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", d.DisplayName)
log.Error(err)
return errors.New("delete failed")
}
log.Infof("")
log.Infof("VCH ID: %s", vch.Reference().String())
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Error("Failed to get Virtual Container Host configuration")
log.Error(err)
return errors.New("delete failed")
}
executor.InitDiagnosticLogs(vchConfig)
if err = executor.DeleteVCH(vchConfig); err != nil {
executor.CollectDiagnosticLogs()
log.Errorf("%s", err)
return errors.New("delete failed")
}
log.Infof("Completed successfully")
return nil
}
func (i *Inspect) Run(cli *cli.Context) error {
var err error
if err = i.processParams(); err != nil {
return err
}
if i.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Inspecting VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), i.Timeout)
defer cancel()
validator, err := validate.NewValidator(ctx, i.Data)
if err != nil {
log.Errorf("Inspect cannot continue - failed to create validator: %s", err)
return errors.New("inspect failed")
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, i.Force)
var vch *vm.VirtualMachine
if i.Data.ID != "" {
vch, err = executor.NewVCHFromID(i.Data.ID)
} else {
vch, err = executor.NewVCHFromComputePath(i.Data.ComputeResourcePath, i.Data.DisplayName, validator)
}
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", i.DisplayName)
log.Error(err)
return errors.New("inspect failed")
}
log.Infof("")
log.Infof("VCH ID: %s", vch.Reference().String())
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Error("Failed to get Virtual Container Host configuration")
log.Error(err)
return errors.New("inspect failed")
}
executor.InitDiagnosticLogs(vchConfig)
if err = executor.InspectVCH(vch, vchConfig); err != nil {
executor.CollectDiagnosticLogs()
log.Errorf("%s", err)
return errors.New("inspect failed")
}
log.Infof("Completed successfully")
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
}
func (u *Upgrade) Run(cli *cli.Context) error {
var err error
if err = u.processParams(); err != nil {
return err
}
if u.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
var images map[string]string
if images, err = u.CheckImagesFiles(u.Force); err != nil {
return err
}
log.Infof("### Upgrading VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), u.Timeout)
defer cancel()
validator, err := validate.NewValidator(ctx, u.Data)
if err != nil {
log.Errorf("Upgrade cannot continue - failed to create validator: %s", err)
return errors.New("upgrade failed")
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, u.Force)
var vch *vm.VirtualMachine
if u.Data.ID != "" {
vch, err = executor.NewVCHFromID(u.Data.ID)
} else {
vch, err = executor.NewVCHFromComputePath(u.Data.ComputeResourcePath, u.Data.DisplayName, validator)
}
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", u.DisplayName)
log.Error(err)
return errors.New("upgrade failed")
}
log.Infof("")
log.Infof("VCH ID: %s", vch.Reference().String())
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Error("Failed to get Virtual Container Host configuration")
log.Error(err)
return errors.New("upgrade failed")
}
executor.InitDiagnosticLogs(vchConfig)
vConfig := validator.AddDeprecatedFields(ctx, vchConfig, u.Data)
vConfig.ImageFiles = images
vConfig.ApplianceISO = path.Base(u.ApplianceISO)
vConfig.BootstrapISO = path.Base(u.BootstrapISO)
vConfig.RollbackTimeout = u.Timeout
if vchConfig, err = validator.MigrateConfig(ctx, vchConfig); err != nil {
log.Errorf("Failed to migrate Virtual Container Host configuration %s", u.DisplayName)
log.Error(err)
return errors.New("upgrade failed")
}
if err = executor.Upgrade(vch, vchConfig, vConfig); err != nil {
// upgrade failed
executor.CollectDiagnosticLogs()
if err == nil {
err = errors.New("upgrade failed")
}
return err
}
// check the docker endpoint is responsive
if err = executor.CheckDockerAPI(vchConfig, nil); err != nil {
executor.CollectDiagnosticLogs()
return err
}
log.Infof("Completed successfully")
return nil
}
func (d *Debug) Run(cli *cli.Context) error {
var err error
if err = d.processParams(); err != nil {
return err
}
if d.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Configuring VCH for debug ####")
ctx, cancel := context.WithTimeout(context.Background(), d.Timeout)
defer cancel()
validator, err := validate.NewValidator(ctx, d.Data)
if err != nil {
log.Errorf("Debug cannot continue - failed to create validator: %s", err)
return errors.New("Debug failed")
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, d.Force)
var vch *vm.VirtualMachine
if d.Data.ID != "" {
vch, err = executor.NewVCHFromID(d.Data.ID)
} else {
vch, err = executor.NewVCHFromComputePath(d.Data.ComputeResourcePath, d.Data.DisplayName, validator)
}
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", d.DisplayName)
log.Error(err)
return errors.New("Debug failed")
}
log.Infof("")
log.Infof("VCH ID: %s", vch.Reference().String())
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Error("Failed to get Virtual Container Host configuration")
log.Error(err)
return errors.New("Debug failed")
}
executor.InitDiagnosticLogs(vchConfig)
installerVer := version.GetBuild()
log.Info("")
log.Infof("Installer version: %s", installerVer.ShortVersion())
log.Infof("VCH version: %s", vchConfig.Version.ShortVersion())
// load the key file if set
var key []byte
if d.authorizedKey != "" {
key, err = ioutil.ReadFile(d.authorizedKey)
if err != nil {
log.Errorf("Unable to read public key from %s: %s", d.authorizedKey, err)
return errors.New("unable to load public key")
}
}
if err = executor.DebugVCH(vch, vchConfig, d.password, string(key)); err != nil {
executor.CollectDiagnosticLogs()
log.Errorf("%s", err)
return errors.New("Debug failed")
}
// display the VCH endpoints again for convenience
if err = executor.InspectVCH(vch, vchConfig); err != nil {
executor.CollectDiagnosticLogs()
log.Errorf("%s", err)
return errors.New("inspect failed")
}
log.Infof("Completed successfully")
return nil
}
