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
}