github.com/vmware/govmomi@v0.51.0/object/datacenter.go (about)

     1  // © Broadcom. All Rights Reserved.
     2  // The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
     3  // SPDX-License-Identifier: Apache-2.0
     4  
     5  package object
     6  
     7  import (
     8  	"context"
     9  	"path"
    10  
    11  	"github.com/vmware/govmomi/fault"
    12  	"github.com/vmware/govmomi/vim25"
    13  	"github.com/vmware/govmomi/vim25/methods"
    14  	"github.com/vmware/govmomi/vim25/mo"
    15  	"github.com/vmware/govmomi/vim25/types"
    16  )
    17  
    18  type DatacenterFolders struct {
    19  	VmFolder        *Folder
    20  	HostFolder      *Folder
    21  	DatastoreFolder *Folder
    22  	NetworkFolder   *Folder
    23  }
    24  
    25  type Datacenter struct {
    26  	Common
    27  }
    28  
    29  func NewDatacenter(c *vim25.Client, ref types.ManagedObjectReference) *Datacenter {
    30  	return &Datacenter{
    31  		Common: NewCommon(c, ref),
    32  	}
    33  }
    34  
    35  func (d *Datacenter) Folders(ctx context.Context) (*DatacenterFolders, error) {
    36  	var md mo.Datacenter
    37  
    38  	ps := []string{"name", "vmFolder", "hostFolder", "datastoreFolder", "networkFolder"}
    39  	err := d.Properties(ctx, d.Reference(), ps, &md)
    40  	if err != nil {
    41  		return nil, err
    42  	}
    43  
    44  	df := &DatacenterFolders{
    45  		VmFolder:        NewFolder(d.c, md.VmFolder),
    46  		HostFolder:      NewFolder(d.c, md.HostFolder),
    47  		DatastoreFolder: NewFolder(d.c, md.DatastoreFolder),
    48  		NetworkFolder:   NewFolder(d.c, md.NetworkFolder),
    49  	}
    50  
    51  	paths := []struct {
    52  		name string
    53  		path *string
    54  	}{
    55  		{"vm", &df.VmFolder.InventoryPath},
    56  		{"host", &df.HostFolder.InventoryPath},
    57  		{"datastore", &df.DatastoreFolder.InventoryPath},
    58  		{"network", &df.NetworkFolder.InventoryPath},
    59  	}
    60  
    61  	dcPath := d.InventoryPath
    62  	if dcPath == "" {
    63  		dcPath = "/" + md.Name
    64  	}
    65  	for _, p := range paths {
    66  		*p.path = path.Join(dcPath, p.name)
    67  	}
    68  
    69  	return df, nil
    70  }
    71  
    72  func (d Datacenter) Destroy(ctx context.Context) (*Task, error) {
    73  	req := types.Destroy_Task{
    74  		This: d.Reference(),
    75  	}
    76  
    77  	res, err := methods.Destroy_Task(ctx, d.c, &req)
    78  	if err != nil {
    79  		return nil, err
    80  	}
    81  
    82  	return NewTask(d.c, res.Returnval), nil
    83  }
    84  
    85  // PowerOnVM powers on multiple virtual machines with a single vCenter call.
    86  // If called against ESX, serially powers on the list of VMs and the returned *Task will always be nil.
    87  func (d Datacenter) PowerOnVM(ctx context.Context, vm []types.ManagedObjectReference, option ...types.BaseOptionValue) (*Task, error) {
    88  	if d.Client().IsVC() {
    89  		req := types.PowerOnMultiVM_Task{
    90  			This:   d.Reference(),
    91  			Vm:     vm,
    92  			Option: option,
    93  		}
    94  
    95  		res, err := methods.PowerOnMultiVM_Task(ctx, d.c, &req)
    96  		if err != nil {
    97  			return nil, err
    98  		}
    99  
   100  		return NewTask(d.c, res.Returnval), nil
   101  	}
   102  
   103  	for _, ref := range vm {
   104  		obj := NewVirtualMachine(d.Client(), ref)
   105  		task, err := obj.PowerOn(ctx)
   106  		if err != nil {
   107  			return nil, err
   108  		}
   109  
   110  		err = task.Wait(ctx)
   111  		if err != nil {
   112  			// Ignore any InvalidPowerState fault, as it indicates the VM is already powered on
   113  			if !fault.Is(err, &types.InvalidPowerState{}) {
   114  				return nil, err
   115  			}
   116  		}
   117  	}
   118  
   119  	return nil, nil
   120  }