func (vm *VirtualMachine) registerVM(ctx context.Context, path, name string,
vapp, pool, host *types.ManagedObjectReference, vmfolder *object.Folder) (*object.Task, error) {
log.Debugf("Register VM %s", name)
if vapp == nil {
var hostObject *object.HostSystem
if host != nil {
hostObject = object.NewHostSystem(vm.Vim25(), *host)
}
poolObject := object.NewResourcePool(vm.Vim25(), *pool)
return vmfolder.RegisterVM(ctx, path, name, false, poolObject, hostObject)
}
req := types.RegisterChildVM_Task{
This: vapp.Reference(),
Path: path,
Host: host,
}
if name != "" {
req.Name = name
}
res, err := methods.RegisterChildVM_Task(ctx, vm.Vim25(), &req)
if err != nil {
return nil, err
}
return object.NewTask(vm.Vim25(), res.Returnval), nil
}
// NewResourcePool returns a New ResourcePool object
func NewResourcePool(ctx context.Context, session *session.Session, moref types.ManagedObjectReference) *ResourcePool {
return &ResourcePool{
ResourcePool: object.NewResourcePool(
session.Vim25(),
moref,
),
Session: session,
}
}
func (f *Finder) ResourcePoolList(ctx context.Context, path string) ([]*object.ResourcePool, error) {
es, err := f.find(ctx, f.hostFolder, true, path)
if err != nil {
return nil, err
}
var rps []*object.ResourcePool
for _, e := range es {
var rp *object.ResourcePool
switch o := e.Object.(type) {
case mo.ResourcePool:
rp = object.NewResourcePool(f.client, o.Reference())
rp.InventoryPath = e.Path
rps = append(rps, rp)
}
}
if len(rps) == 0 {
return nil, &NotFoundError{"resource pool", path}
}
return rps, nil
}
func (cmd *info) Run(ctx context.Context, f *flag.FlagSet) error {
if f.NArg() == 0 {
return flag.ErrHelp
}
c, err := cmd.Client()
if err != nil {
return err
}
finder, err := cmd.Finder()
if err != nil {
return err
}
var res infoResult
var props []string
if cmd.OutputFlag.JSON {
props = nil
} else {
props = []string{
"name",
"config.cpuAllocation",
"config.memoryAllocation",
"runtime.cpu",
"runtime.memory",
}
}
var vapps []*object.VirtualApp
for _, arg := range f.Args() {
if cmd.pools {
objects, err := finder.ResourcePoolList(ctx, arg)
if err != nil {
if _, ok := err.(*find.NotFoundError); !ok {
return err
}
}
res.objects = append(res.objects, objects...)
}
if cmd.apps {
apps, err := finder.VirtualAppList(ctx, arg)
if err != nil {
if _, ok := err.(*find.NotFoundError); !ok {
return err
}
}
vapps = append(vapps, apps...)
}
}
if len(res.objects) != 0 {
refs := make([]types.ManagedObjectReference, 0, len(res.objects))
for _, o := range res.objects {
refs = append(refs, o.Reference())
}
pc := property.DefaultCollector(c)
err = pc.Retrieve(ctx, refs, props, &res.ResourcePools)
if err != nil {
return err
}
}
if len(vapps) != 0 {
var apps []mo.VirtualApp
refs := make([]types.ManagedObjectReference, 0, len(vapps))
for _, o := range vapps {
refs = append(refs, o.Reference())
p := object.NewResourcePool(c, o.Reference())
p.InventoryPath = o.InventoryPath
res.objects = append(res.objects, p)
}
pc := property.DefaultCollector(c)
err = pc.Retrieve(ctx, refs, props, &apps)
if err != nil {
return err
}
for _, app := range apps {
res.ResourcePools = append(res.ResourcePools, app.ResourcePool)
}
}
return cmd.WriteResult(&res)
}
func TestResourcePool(t *testing.T) {
ctx := context.Background()
m := &Model{
ServiceContent: esx.ServiceContent,
RootFolder: esx.RootFolder,
}
err := m.Create()
if err != nil {
t.Fatal(err)
}
c := m.Service.client
finder := find.NewFinder(c, false)
finder.SetDatacenter(object.NewDatacenter(c, esx.Datacenter.Reference()))
spec := NewResourceConfigSpec()
parent := object.NewResourcePool(c, esx.ResourcePool.Self)
// can't destroy a root pool
task, err := parent.Destroy(ctx)
if err != nil {
t.Fatal(err)
}
if err = task.Wait(ctx); err == nil {
t.Fatal("expected error destroying a root pool")
}
// create a child pool
childName := uuid.New().String()
child, err := parent.Create(ctx, childName, spec)
if err != nil {
t.Fatal(err)
}
if child.Reference() == esx.ResourcePool.Self {
t.Error("expected new pool Self reference")
}
// create a grandchild pool
grandChildName := uuid.New().String()
_, err = child.Create(ctx, grandChildName, spec)
if err != nil {
t.Fatal(err)
}
// create sibling (of the grand child) pool
siblingName := uuid.New().String()
_, err = child.Create(ctx, siblingName, spec)
if err != nil {
t.Fatal(err)
}
// finder should return the 2 grand children
pools, err := finder.ResourcePoolList(ctx, "*/Resources/"+childName+"/*")
if err != nil {
t.Fatal(err)
}
if len(pools) != 2 {
t.Fatalf("len(pools) == %d", len(pools))
}
// destroy the child
task, err = child.Destroy(ctx)
if err != nil {
t.Fatal(err)
}
err = task.Wait(ctx)
if err != nil {
t.Fatal(err)
}
// finder should error not found after destroying the child
_, err = finder.ResourcePoolList(ctx, "*/Resources/"+childName+"/*")
if err == nil {
t.Fatal("expected not found error")
}
// since the child was destroyed, grand child pools should now be children of the root pool
pools, err = finder.ResourcePoolList(ctx, "*/Resources/*")
if err != nil {
t.Fatal(err)
}
if len(pools) != 2 {
t.Fatalf("len(pools) == %d", len(pools))
}
}
