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 }