// updates acquires updates from the infrastructure without holding a lock
func (c *containerBase) updates(ctx context.Context) (*containerBase, error) {
defer trace.End(trace.Begin(c.ExecConfig.ID))
var o mo.VirtualMachine
// make sure we have vm
if c.vm == nil {
return nil, NotYetExistError{c.ExecConfig.ID}
}
if err := c.vm.Properties(ctx, c.vm.Reference(), []string{"config", "runtime"}, &o); err != nil {
return nil, err
}
base := &containerBase{
vm: c.vm,
Config: o.Config,
Runtime: &o.Runtime,
ExecConfig: &executor.ExecutorConfig{},
}
// Get the ExtraConfig
extraconfig.Decode(vmomi.OptionValueSource(o.Config.ExtraConfig), base.ExecConfig)
return base, nil
}
func newBase(vm *vm.VirtualMachine, c *types.VirtualMachineConfigInfo, r *types.VirtualMachineRuntimeInfo) *containerBase {
base := &containerBase{
ExecConfig: &executor.ExecutorConfig{},
Config: c,
Runtime: r,
vm: vm,
}
// construct a working copy of the exec config
if c != nil && c.ExtraConfig != nil {
src := vmomi.OptionValueSource(c.ExtraConfig)
extraconfig.Decode(src, base.ExecConfig)
}
return base
}
// convert the infra containers to a container object
func convertInfraContainers(vms []mo.VirtualMachine, all bool) []*Container {
var containerVMs []*Container
for i := range vms {
// poweredOn or all states
if !all && vms[i].Runtime.PowerState == types.VirtualMachinePowerStatePoweredOff {
// don't want it
log.Debugf("Skipping poweredOff VM %s", vms[i].Config.Name)
continue
}
container := &Container{ExecConfig: &executor.ExecutorConfig{}}
source := vmomi.OptionValueSource(vms[i].Config.ExtraConfig)
extraconfig.Decode(source, container.ExecConfig)
// check extraConfig to see if we have a containerVM -- assumes
// that ID will always be populated for each containerVM
if container.ExecConfig == nil || container.ExecConfig.ID == "" {
log.Debugf("Skipping non-container vm %s", vms[i].Config.Name)
continue
}
// set state
if vms[i].Runtime.PowerState == types.VirtualMachinePowerStatePoweredOn {
container.State = StateRunning
} else {
// look in the container cache and check state
// if it's created we'll take that as it's been created, but
// not started
cached := containers.Container(container.ExecConfig.ID)
if cached != nil && cached.State == StateCreated {
container.State = StateCreated
} else {
container.State = StateStopped
}
}
if vms[i].Summary.Storage != nil {
container.VMUnsharedDisk = vms[i].Summary.Storage.Unshared
}
containerVMs = append(containerVMs, container)
}
return containerVMs
}
func (c *Container) Update(ctx context.Context, sess *session.Session) (*executor.ExecutorConfig, error) {
defer trace.End(trace.Begin("Container.Update"))
c.Lock()
defer c.Unlock()
if c.vm == nil {
return nil, fmt.Errorf("container does not have a vm")
}
var vm []mo.VirtualMachine
if err := sess.Retrieve(ctx, []types.ManagedObjectReference{c.vm.Reference()}, []string{"config"}, &vm); err != nil {
return nil, err
}
extraconfig.Decode(vmomi.OptionValueSource(vm[0].Config.ExtraConfig), c.ExecConfig)
return c.ExecConfig, nil
}
func (d *Dispatcher) GetVCHConfig(vm *vm.VirtualMachine) (*config.VirtualContainerHostConfigSpec, error) {
defer trace.End(trace.Begin(""))
//this is the appliance vm
mapConfig, err := vm.FetchExtraConfigBaseOptions(d.ctx)
if err != nil {
err = errors.Errorf("Failed to get VM extra config of %q: %s", vm.Reference(), err)
log.Error(err)
return nil, err
}
data := vmomi.OptionValueSource(mapConfig)
vchConfig := &config.VirtualContainerHostConfigSpec{}
result := extraconfig.Decode(data, vchConfig)
if result == nil {
err = errors.Errorf("Failed to decode VM configuration %q: %s", vm.Reference(), err)
log.Error(err)
return nil, err
}
// vchConfig.ID
return vchConfig, nil
}
