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 (v *Validator) dpgMorefHelper(ctx context.Context, ref string) (string, error) { defer trace.End(trace.Begin(ref)) moref := new(types.ManagedObjectReference) ok := moref.FromString(ref) if !ok { // TODO: error message about no such match and how to get a network list return "", errors.New("could not restore serialized managed object reference: " + ref) } net, err := v.Session.Finder.ObjectReference(ctx, *moref) if err != nil { // TODO: error message about no such match and how to get a network list return "", errors.New("unable to locate network from moref: " + ref) } // ensure that the type of the network is a Distributed Port Group if the target is a vCenter // if it's not then any network suffices if v.IsVC() { _, dpg := net.(*object.DistributedVirtualPortgroup) if !dpg { return "", fmt.Errorf("%q is not a Distributed Port Group", ref) } } return ref, nil }
// registeredVMCallback will process registeredVMEvent func registeredVMCallback(sess *session.Session, ie events.Event) { // check container registered event if this container is not found in container cache // grab the container from the cache container := Containers.Container(ie.Reference()) if container != nil { // if container exists, ingore it return } switch ie.String() { case events.ContainerRegistered: moref := new(types.ManagedObjectReference) if ok := moref.FromString(ie.Reference()); !ok { log.Errorf("Failed to get event VM mobref: %s", ie.Reference()) return } if !isManagedbyVCH(sess, *moref) { return } log.Debugf("Register container VM %s", moref) ctx := context.Background() vms, err := populateVMAttributes(ctx, sess, []types.ManagedObjectReference{*moref}) if err != nil { log.Error(err) return } registeredContainers := convertInfraContainers(ctx, sess, vms) for i := range registeredContainers { Containers.put(registeredContainers[i]) log.Debugf("Registered container %q", registeredContainers[i].Config.Name) } } return }
func Init(ctx context.Context, sess *session.Session, source extraconfig.DataSource, sink extraconfig.DataSink) error { trace.End(trace.Begin("")) initializer.once.Do(func() { var err error defer func() { initializer.err = err }() f := find.NewFinder(sess.Vim25(), false) var config Configuration config.sink = sink config.source = source config.Decode() config.PortGroups = make(map[string]object.NetworkReference) log.Debugf("Decoded VCH config for network: %#v", config) for nn, n := range config.ContainerNetworks { pgref := new(types.ManagedObjectReference) if !pgref.FromString(n.ID) { log.Warnf("Could not reacquire object reference from id for network %s: %s", nn, n.ID) } var r object.Reference if r, err = f.ObjectReference(ctx, *pgref); err != nil { log.Warnf("could not get network reference for %s network: %s", nn, err) err = nil continue } config.PortGroups[nn] = r.(object.NetworkReference) } // make sure a NIC attached to the bridge network exists config.BridgeLink, err = getBridgeLink(&config) if err != nil { return } var kv kvstore.KeyValueStore kv, err = store.NewDatastoreKeyValue(ctx, sess, "network.contexts.default") if err != nil { return } var netctx *Context if netctx, err = NewContext(&config, kv); err != nil { return } if err = engageContext(ctx, netctx, exec.Config.EventManager); err == nil { DefaultContext = netctx log.Infof("Default network context allocated") } }) return initializer.err }
// Blacklist object from callbacks func (mgr *vSphereManager) Blacklist(ref string) error { moRef := types.ManagedObjectReference{} if !moRef.FromString(ref) { return fmt.Errorf("Invalid Managed Object provided to Blacklist(%s)", ref) } mgr.blacklist[moRef] = ref return nil }
func (mgr *vSphereManager) AddMonitoredObject(ref string) error { log.Debugf("EventManager added (%s) to monitor", ref) moRef := types.ManagedObjectReference{} if !moRef.FromString(ref) { return fmt.Errorf("Invalid Managed Object provided for Montioring(%s)", ref) } mgr.objects[ref] = moRef return nil }
func (d *Dispatcher) addNetworkDevices(conf *metadata.VirtualContainerHostConfigSpec, cspec *spec.VirtualMachineConfigSpec, devices object.VirtualDeviceList) (object.VirtualDeviceList, error) { defer trace.End(trace.Begin("")) // network name:alias, to avoid create multiple devices for same network slots := make(map[int32]bool) nets := make(map[string]*metadata.NetworkEndpoint) for name, endpoint := range conf.ExecutorConfig.Networks { if pnic, ok := nets[endpoint.Network.Common.ID]; ok { // there's already a NIC on this network endpoint.Common.ID = pnic.Common.ID log.Infof("Network role %s is sharing NIC with %s", name, pnic.Network.Common.Name) continue } moref := new(types.ManagedObjectReference) if ok := moref.FromString(endpoint.Network.ID); !ok { return nil, fmt.Errorf("serialized managed object reference in unexpected format: %s", endpoint.Network.ID) } obj, err := d.session.Finder.ObjectReference(d.ctx, *moref) if err != nil { return nil, fmt.Errorf("unable to reacquire reference for network %s from serialized form: %s", endpoint.Network.Name, endpoint.Network.ID) } network, ok := obj.(object.NetworkReference) if !ok { return nil, fmt.Errorf("reacquired reference for network %s, from serialized form %s, was not a network: %T", endpoint.Network.Name, endpoint.Network.ID, obj) } backing, err := network.EthernetCardBackingInfo(d.ctx) if err != nil { err = errors.Errorf("Failed to get network backing info for %s: %s", network, err) return nil, err } nic, err := devices.CreateEthernetCard("vmxnet3", backing) if err != nil { err = errors.Errorf("Failed to create Ethernet Card spec for %s", err) return nil, err } slot := cspec.AssignSlotNumber(nic, slots) if slot == spec.NilSlot { err = errors.Errorf("Failed to assign stable PCI slot for %s network card", name) } endpoint.Common.ID = strconv.Itoa(int(slot)) slots[slot] = true log.Debugf("Setting %s to slot %d", name, slot) devices = append(devices, nic) nets[endpoint.Network.Common.ID] = endpoint } return devices, nil }
func (ec *EventCollector) AddMonitoredObject(ref string) error { ec.mos.mu.Lock() defer ec.mos.mu.Unlock() moRef := types.ManagedObjectReference{} if !moRef.FromString(ref) { return fmt.Errorf("%s received an invalid Object to monitor(%s)", name, ref) } ec.mos.mos[ref] = moRef return nil }
func (f *PermissionFlag) ManagedObjects(ctx context.Context, args []string) ([]types.ManagedObjectReference, error) { if !f.asRef { return f.DatacenterFlag.ManagedObjects(ctx, args) } var refs []types.ManagedObjectReference for _, arg := range args { var ref types.ManagedObjectReference if ref.FromString(arg) { refs = append(refs, ref) } else { return nil, fmt.Errorf("invalid moref: %s", arg) } } return refs, nil }
func (cmd *ls) Run(ctx context.Context, f *flag.FlagSet) error { finder, err := cmd.Finder() if err != nil { return err } lr := listResult{ ls: cmd, Elements: nil, } args := f.Args() if len(args) == 0 { args = []string{"."} } var ref = new(types.ManagedObjectReference) for _, arg := range args { if cmd.DeRef && ref.FromString(arg) { e, err := finder.Element(ctx, *ref) if err == nil { if cmd.typeMatch(*ref) { lr.Elements = append(lr.Elements, *e) } continue } } es, err := finder.ManagedObjectListChildren(ctx, arg) if err != nil { return err } for _, e := range es { if cmd.typeMatch(e.Object.Reference()) { lr.Elements = append(lr.Elements, e) } } } return cmd.WriteResult(lr) }
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 }
func Init(ctx context.Context, sess *session.Session) error { source, err := extraconfig.GuestInfoSource() if err != nil { return err } f := find.NewFinder(sess.Vim25(), false) extraconfig.Decode(source, &exec.VCHConfig) log.Debugf("Decoded VCH config for execution: %#v", exec.VCHConfig) ccount := len(exec.VCHConfig.ComputeResources) if ccount != 1 { detail := fmt.Sprintf("expected singular compute resource element, found %d", ccount) log.Errorf(detail) return err } cr := exec.VCHConfig.ComputeResources[0] r, err := f.ObjectReference(ctx, cr) if err != nil { detail := fmt.Sprintf("could not get resource pool or virtual app reference from %q: %s", cr.String(), err) log.Errorf(detail) return err } switch o := r.(type) { case *object.VirtualApp: exec.VCHConfig.VirtualApp = o exec.VCHConfig.ResourcePool = o.ResourcePool case *object.ResourcePool: exec.VCHConfig.ResourcePool = o default: detail := fmt.Sprintf("could not get resource pool or virtual app from reference %q: object type is wrong", cr.String()) log.Errorf(detail) return errors.New(detail) } // we have a resource pool, so lets create the event manager for monitoring exec.VCHConfig.EventManager = vsphere.NewEventManager(sess) // configure event manager to monitor the resource pool exec.VCHConfig.EventManager.AddMonitoredObject(exec.VCHConfig.ResourcePool.Reference().String()) // instantiate the container cache now exec.NewContainerCache() // need to blacklist the VCH from eventlistening - too many reconfigures vch, err := guest.GetSelf(ctx, sess) if err != nil { return fmt.Errorf("Unable to get a reference to the VCH: %s", err.Error()) } exec.VCHConfig.EventManager.Blacklist(vch.Reference().String()) // other managed objects could be added for the event stream, but for now the resource pool will do exec.VCHConfig.EventManager.Start() //FIXME: temporary injection of debug network for debug nic ne := exec.VCHConfig.Networks["client"] if ne == nil { detail := fmt.Sprintf("could not get client network reference for debug nic - this code can be removed once network mapping/dhcp client is present") log.Errorf(detail) return err } nr := new(types.ManagedObjectReference) nr.FromString(ne.Network.ID) r, err = f.ObjectReference(ctx, *nr) if err != nil { detail := fmt.Sprintf("could not get client network reference from %s: %s", nr.String(), err) log.Errorf(detail) return err } exec.VCHConfig.DebugNetwork = r.(object.NetworkReference) extraconfig.Decode(source, &network.Config) log.Debugf("Decoded VCH config for network: %#v", network.Config) for nn, n := range network.Config.ContainerNetworks { pgref := new(types.ManagedObjectReference) if !pgref.FromString(n.ID) { log.Errorf("Could not reacquire object reference from id for network %s: %s", nn, n.ID) } r, err = f.ObjectReference(ctx, *pgref) if err != nil { log.Warnf("could not get network reference for %s network", nn) continue } n.PortGroup = r.(object.NetworkReference) } // Grab the storage layer config blobs from extra config extraconfig.Decode(source, &storage.Config) log.Debugf("Decoded VCH config for storage: %#v", storage.Config) // Grab the AboutInfo about our host environment about := sess.Vim25().ServiceContent.About exec.VCHConfig.VCHMhz = exec.NCPU(ctx) exec.VCHConfig.VCHMemoryLimit = exec.MemTotal(ctx) exec.VCHConfig.HostOS = about.OsType exec.VCHConfig.HostOSVersion = about.Version exec.VCHConfig.HostProductName = about.Name log.Debugf("Host - OS (%s), version (%s), name (%s)", about.OsType, about.Version, about.Name) log.Debugf("VCH limits - %d Mhz, %d MB", exec.VCHConfig.VCHMhz, exec.VCHConfig.VCHMemoryLimit) return nil }
// Unblacklist removes object blacklisting and will allow callbacks to occur func (mgr *vSphereManager) Unblacklist(ref string) { moRef := types.ManagedObjectReference{} moRef.FromString(ref) delete(mgr.blacklist, moRef) }
func Init(ctx context.Context, sess *session.Session) error { source, err := extraconfig.GuestInfoSource() if err != nil { return err } f := find.NewFinder(sess.Vim25(), false) extraconfig.Decode(source, &exec.Config) log.Debugf("Decoded VCH config for execution: %#v", exec.Config) ccount := len(exec.Config.ComputeResources) if ccount != 1 { detail := fmt.Sprintf("expected singular compute resource element, found %d", ccount) log.Errorf(detail) return err } cr := exec.Config.ComputeResources[0] r, err := f.ObjectReference(ctx, cr) if err != nil { detail := fmt.Sprintf("could not get resource pool reference from %s: %s", cr.String(), err) log.Errorf(detail) return err } exec.Config.ResourcePool = r.(*object.ResourcePool) //FIXME: temporary injection of debug network for debug nic ne := exec.Config.Networks["client"] if ne == nil { detail := fmt.Sprintf("could not get client network reference for debug nic - this code can be removed once network mapping/dhcp client is present") log.Errorf(detail) return err } nr := new(types.ManagedObjectReference) nr.FromString(ne.Network.ID) r, err = f.ObjectReference(ctx, *nr) if err != nil { detail := fmt.Sprintf("could not get client network reference from %s: %s", nr.String(), err) log.Errorf(detail) return err } exec.Config.DebugNetwork = r.(object.NetworkReference) extraconfig.Decode(source, &network.Config) log.Debugf("Decoded VCH config for network: %#v", network.Config) for nn, n := range network.Config.ContainerNetworks { pgref := new(types.ManagedObjectReference) if !pgref.FromString(n.ID) { log.Errorf("Could not reacquire object reference from id for network %s: %s", nn, n.ID) } r, err = f.ObjectReference(ctx, *pgref) if err != nil { log.Warnf("could not get network reference for %s network", nn) continue } n.PortGroup = r.(object.NetworkReference) } return nil }