func (d *Dispatcher) findApplianceByID(conf *metadata.VirtualContainerHostConfigSpec) (*vm.VirtualMachine, error) {
defer trace.End(trace.Begin(""))
var err error
var vmm *vm.VirtualMachine
moref := new(types.ManagedObjectReference)
if ok := moref.FromString(conf.ID); !ok {
message := "Failed to get appliance VM mob reference"
log.Errorf(message)
return nil, errors.New(message)
}
ref, err := d.session.Finder.ObjectReference(d.ctx, *moref)
if err != nil {
if _, ok := err.(*find.NotFoundError); !ok {
err = errors.Errorf("Failed to query appliance (%s): %s", moref, err)
return nil, err
}
log.Debugf("Appliance is not found")
return nil, nil
}
ovm, ok := ref.(*object.VirtualMachine)
if !ok {
log.Errorf("Failed to find VM %s, %s", moref, err)
return nil, err
}
vmm = vm.NewVirtualMachine(d.ctx, d.session, ovm.Reference())
return vmm, nil
}
func (rp *ResourcePool) GetChildVM(ctx context.Context, s *session.Session, name string) (*vm.VirtualMachine, error) {
searchIndex := object.NewSearchIndex(s.Client.Client)
child, err := searchIndex.FindChild(ctx, rp.Reference(), name)
if err != nil {
return nil, errors.Errorf("Unable to find VM(%s): %s", name, err.Error())
}
if child == nil {
return nil, nil
}
// instantiate the vm object
return vm.NewVirtualMachine(ctx, s, child.Reference()), nil
}
func (rp *ResourcePool) GetChildrenVMs(ctx context.Context, s *session.Session) ([]*vm.VirtualMachine, error) {
var err error
var mrp mo.ResourcePool
var vms []*vm.VirtualMachine
if err = rp.Properties(ctx, rp.Reference(), []string{"vm"}, &mrp); err != nil {
log.Errorf("Unable to get children vm of resource pool %s: %s", rp.Name(), err)
return vms, err
}
for _, o := range mrp.Vm {
v := vm.NewVirtualMachine(ctx, s, o)
vms = append(vms, v)
}
return vms, nil
}
func (d *Dispatcher) findAppliance(conf *metadata.VirtualContainerHostConfigSpec) (*vm.VirtualMachine, error) {
defer trace.End(trace.Begin(""))
ovm, err := d.session.Finder.VirtualMachine(d.ctx, conf.Name)
if err != nil {
_, ok := err.(*find.NotFoundError)
if !ok {
err = errors.Errorf("Failed to query appliance (%s): %s", conf.Name, err)
return nil, err
}
log.Debugf("Appliance is not found")
return nil, nil
}
newVM := vm.NewVirtualMachine(d.ctx, d.session, ovm.Reference())
// workaround here. We lost the value set in ovm cause we wrap the object to another type
newVM.InventoryPath = ovm.InventoryPath
return newVM, nil
}
// GetSelf gets VirtualMachine reference for the VM this process is running on
func GetSelf(ctx context.Context, s *session.Session) (*vm.VirtualMachine, error) {
u, err := UUID()
if err != nil {
return nil, err
}
search := object.NewSearchIndex(s.Vim25())
ref, err := search.FindByUuid(ctx, s.Datacenter, u, true, nil)
if err != nil {
return nil, err
}
if ref == nil {
return nil, fmt.Errorf("can't find the hosting vm")
}
return vm.NewVirtualMachine(ctx, s, ref.Reference()), nil
}
func (d *Dispatcher) NewVCHFromID(id string) (*vm.VirtualMachine, error) {
defer trace.End(trace.Begin(id))
var err error
var vmm *vm.VirtualMachine
moref := new(types.ManagedObjectReference)
if ok := moref.FromString(id); !ok {
message := "Failed to get appliance VM mob reference"
log.Errorf(message)
return nil, errors.New(message)
}
ref, err := d.session.Finder.ObjectReference(d.ctx, *moref)
if err != nil {
if _, ok := err.(*find.NotFoundError); !ok {
err = errors.Errorf("Failed to query appliance (%s): %s", moref, err)
return nil, err
}
log.Debugf("Appliance is not found")
return nil, nil
}
ovm, ok := ref.(*object.VirtualMachine)
if !ok {
log.Errorf("Failed to find VM %s, %s", moref, err)
return nil, err
}
vmm = vm.NewVirtualMachine(d.ctx, d.session, ovm.Reference())
// check if it's VCH
if ok, err = d.isVCH(vmm); err != nil {
log.Errorf("%s", err)
return nil, err
}
if !ok {
err = errors.Errorf("Not a VCH")
log.Errorf("%s", err)
return nil, err
}
return vmm, nil
}
// find the childVM for this resource pool by name
func childVM(ctx context.Context, sess *session.Session, name string) (*vm.VirtualMachine, error) {
// Search container back through instance UUID
uuid, err := instanceUUID(name)
if err != nil {
detail := fmt.Sprintf("unable to get instance UUID: %s", err)
log.Error(detail)
return nil, errors.New(detail)
}
searchIndex := object.NewSearchIndex(sess.Client.Client)
child, err := searchIndex.FindByUuid(ctx, sess.Datacenter, uuid, true, nil)
if err != nil {
return nil, fmt.Errorf("Unable to find container(%s): %s", name, err.Error())
}
if child == nil {
return nil, fmt.Errorf("Unable to find container %s", name)
}
// instantiate the vm object
return vm.NewVirtualMachine(ctx, sess, child.Reference()), nil
}
// convert the infra containers to a container object
func convertInfraContainers(ctx context.Context, sess *session.Session, vms []mo.VirtualMachine) []*Container {
defer trace.End(trace.Begin(fmt.Sprintf("converting %d containers", len(vms))))
var cons []*Container
for _, v := range vms {
vm := vm.NewVirtualMachine(ctx, sess, v.Reference())
base := newBase(vm, v.Config, &v.Runtime)
c := newContainer(base)
id := uid.Parse(c.ExecConfig.ID)
if id == uid.NilUID {
log.Warnf("skipping converting container VM %s: could not parse id", v.Reference())
continue
}
if v.Summary.Storage != nil {
c.VMUnsharedDisk = v.Summary.Storage.Unshared
}
cons = append(cons, c)
}
return cons
}
func (c *Container) Commit(ctx context.Context, sess *session.Session, h *Handle, waitTime *int32) error {
defer trace.End(trace.Begin("Committing handle"))
c.Lock()
defer c.Unlock()
if c.vm == nil {
// the only permissible operation is to create a VM
if h.Spec == nil {
return fmt.Errorf("only create operations can be committed without an existing VM")
}
var res *types.TaskInfo
var err error
if sess.IsVC() && VCHConfig.VirtualApp != nil {
// Create the vm
res, err = tasks.WaitForResult(ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return VCHConfig.VirtualApp.CreateChildVM_Task(ctx, *h.Spec.Spec(), nil)
})
c.State = StateCreated
} else {
// Find the Virtual Machine folder that we use
var folders *object.DatacenterFolders
folders, err = sess.Datacenter.Folders(ctx)
if err != nil {
log.Errorf("Could not get folders")
return err
}
parent := folders.VmFolder
// Create the vm
res, err = tasks.WaitForResult(ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return parent.CreateVM(ctx, *h.Spec.Spec(), VCHConfig.ResourcePool, nil)
})
c.State = StateCreated
}
if err != nil {
log.Errorf("Something failed. Spec was %+v", *h.Spec.Spec())
return err
}
c.vm = vm.NewVirtualMachine(ctx, sess, res.Result.(types.ManagedObjectReference))
// clear the spec as we've acted on it
h.Spec = nil
}
// if we're stopping the VM, do so before the reconfigure to preserve the extraconfig
if h.State != nil && *h.State == StateStopped {
// stop the container
if err := h.Container.stop(ctx, waitTime); err != nil {
return err
}
c.State = *h.State
}
if h.Spec != nil {
// FIXME: add check that the VM is powered off - it should be, but this will destroy the
// extraconfig if it's not.
s := h.Spec.Spec()
_, err := tasks.WaitForResult(ctx, func(ctx context.Context) (tasks.ResultWaiter, error) {
return c.vm.Reconfigure(ctx, *s)
})
if err != nil {
return err
}
}
if h.State != nil && *h.State == StateRunning {
// start the container
if err := h.Container.start(ctx); err != nil {
return err
}
c.State = *h.State
}
c.ExecConfig = &h.ExecConfig
// add or overwrite the container in the cache
containers.Put(c)
return nil
}
// Commit executes the requires steps on the handle
func Commit(ctx context.Context, sess *session.Session, h *Handle, waitTime *int32) error {
defer trace.End(trace.Begin(h.ExecConfig.ID))
c := Containers.Container(h.ExecConfig.ID)
creation := h.vm == nil
if creation {
if h.Spec == nil {
return fmt.Errorf("a spec must be provided for create operations")
}
if sess == nil {
// session must not be nil
return fmt.Errorf("no session provided for create operations")
}
// the only permissible operation is to create a VM
if h.Spec == nil {
return fmt.Errorf("only create operations can be committed without an existing VM")
}
if c != nil {
return fmt.Errorf("a container already exists in the cache with this ID")
}
var res *types.TaskInfo
var err error
if sess.IsVC() && Config.VirtualApp.ResourcePool != nil {
// Create the vm
res, err = tasks.WaitForResult(ctx, func(ctx context.Context) (tasks.Task, error) {
return Config.VirtualApp.CreateChildVM_Task(ctx, *h.Spec.Spec(), nil)
})
} else {
// Find the Virtual Machine folder that we use
var folders *object.DatacenterFolders
folders, err = sess.Datacenter.Folders(ctx)
if err != nil {
log.Errorf("Could not get folders")
return err
}
parent := folders.VmFolder
// Create the vm
res, err = tasks.WaitForResult(ctx, func(ctx context.Context) (tasks.Task, error) {
return parent.CreateVM(ctx, *h.Spec.Spec(), Config.ResourcePool, nil)
})
}
if err != nil {
log.Errorf("Something failed. Spec was %+v", *h.Spec.Spec())
return err
}
h.vm = vm.NewVirtualMachine(ctx, sess, res.Result.(types.ManagedObjectReference))
c = newContainer(&h.containerBase)
Containers.Put(c)
// inform of creation irrespective of remaining operations
publishContainerEvent(c.ExecConfig.ID, time.Now().UTC(), events.ContainerCreated)
// clear the spec as we've acted on it - this prevents a reconfigure from occurring in follow-on
// processing
h.Spec = nil
}
// if we're stopping the VM, do so before the reconfigure to preserve the extraconfig
refresh := true
if h.TargetState() == StateStopped {
if h.Runtime == nil {
log.Warnf("Commit called with incomplete runtime state for %s", h.ExecConfig.ID)
}
if h.Runtime != nil && h.Runtime.PowerState == types.VirtualMachinePowerStatePoweredOff {
log.Infof("Dropping duplicate power off operation for %s", h.ExecConfig.ID)
} else {
// stop the container
if err := c.stop(ctx, waitTime); err != nil {
return err
}
// inform of creation irrespective of remaining operations
publishContainerEvent(h.ExecConfig.ID, time.Now().UTC(), events.ContainerStopped)
// we must refresh now to get the new ChangeVersion - this is used to gate on powerstate in the reconfigure
// because we cannot set the ExtraConfig if the VM is powered on. There is still a race here unfortunately because
// tasks don't appear to contain the new ChangeVersion
// we don't use refresh because we want to keep the extraconfig state
base, err := h.updates(ctx)
if err != nil {
// TODO: can we recover here, or at least set useful state for inspection?
return err
}
h.Runtime = base.Runtime
h.Config = base.Config
refresh = false
}
}
// reconfigure operation
if h.Spec != nil {
if h.Runtime == nil {
log.Errorf("Refusing to perform reconfigure operation with incomplete runtime state for %s", h.ExecConfig.ID)
} else {
// ensure that our logic based on Runtime state remains valid
// NOTE: this inline refresh can be removed when switching away from guestinfo where we have non-persistence issues
// when updating ExtraConfig via the API with a powered on VM - we therefore have to be absolutely certain about the
// power state to decide if we can continue without nilifying extraconfig
for s := h.Spec.Spec(); ; refresh, s = true, h.Spec.Spec() {
// FIXME!!! this is a temporary hack until the concurrent modification retry logic is in place
if refresh {
base, err := h.updates(ctx)
if err == nil {
h.Runtime = base.Runtime
h.Config = base.Config
}
}
s.ChangeVersion = h.Config.ChangeVersion
// nilify ExtraConfig if vm is running
if h.Runtime.PowerState == types.VirtualMachinePowerStatePoweredOn {
log.Errorf("Nilifying ExtraConfig as we are running")
s.ExtraConfig = nil
}
_, err := h.vm.WaitForResult(ctx, func(ctx context.Context) (tasks.Task, error) {
return h.vm.Reconfigure(ctx, *s)
})
if err != nil {
log.Errorf("Reconfigure failed with %#+v", err)
// Check whether we get ConcurrentAccess and wrap it if needed
if f, ok := err.(types.HasFault); ok {
switch f.Fault().(type) {
case *types.ConcurrentAccess:
log.Errorf("We have ConcurrentAccess for version %s", s.ChangeVersion)
continue
// return ConcurrentAccessError{err}
}
}
return err
}
break
}
}
}
// best effort update of container cache using committed state - this will not reflect the power on below, however
// this is primarily for updating ExtraConfig state.
if !creation {
defer c.RefreshFromHandle(ctx, h)
}
if h.TargetState() == StateRunning {
if h.Runtime != nil && h.Runtime.PowerState == types.VirtualMachinePowerStatePoweredOn {
log.Infof("Dropping duplicate power on operation for %s", h.ExecConfig.ID)
return nil
}
if h.Runtime == nil && !creation {
log.Warnf("Commit called with incomplete runtime state for %s", h.ExecConfig.ID)
}
// start the container
if err := c.start(ctx); err != nil {
return err
}
// inform of creation irrespective of remaining operations
publishContainerEvent(h.ExecConfig.ID, time.Now().UTC(), events.ContainerStarted)
}
return nil
}
