github.com/vmware/govmomi@v0.51.0/cli/vm/target/info.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 target
     6  
     7  import (
     8  	"context"
     9  	"flag"
    10  	"fmt"
    11  	"io"
    12  	"text/tabwriter"
    13  
    14  	"github.com/vmware/govmomi/cli"
    15  	"github.com/vmware/govmomi/cli/flags"
    16  	"github.com/vmware/govmomi/units"
    17  	"github.com/vmware/govmomi/vim25/types"
    18  )
    19  
    20  type info struct {
    21  	flags.EnvBrowser
    22  
    23  	datastore bool
    24  	network   bool
    25  	disk      bool
    26  	device    bool
    27  }
    28  
    29  func init() {
    30  	cli.Register("vm.target.info", &info{})
    31  }
    32  
    33  func (cmd *info) Register(ctx context.Context, f *flag.FlagSet) {
    34  	cmd.EnvBrowser.Register(ctx, f)
    35  
    36  	f.BoolVar(&cmd.datastore, "datastore", true, "Include Datastores")
    37  	f.BoolVar(&cmd.network, "network", true, "Include Networks")
    38  	f.BoolVar(&cmd.disk, "disk", false, "Include Disks")
    39  	f.BoolVar(&cmd.device, "device", true, "Include Devices")
    40  }
    41  
    42  func (cmd *info) Description() string {
    43  	return `VM config target info.
    44  
    45  The config target data contains information about the execution environment for a VM
    46  in the given CLUSTER, and optionally for a specific HOST.
    47  
    48  Examples:
    49    govc vm.target.info -cluster C0
    50    govc vm.target.info -host my_hostname
    51    govc vm.target.info -vm my_vm`
    52  }
    53  
    54  func (cmd *info) Run(ctx context.Context, f *flag.FlagSet) error {
    55  	b, err := cmd.Browser(ctx)
    56  	if err != nil {
    57  		return err
    58  	}
    59  
    60  	host, err := cmd.HostSystemIfSpecified()
    61  	if err != nil {
    62  		return err
    63  	}
    64  
    65  	target, err := b.QueryConfigTarget(ctx, host)
    66  	if err != nil {
    67  		return err
    68  	}
    69  
    70  	if cmd.network == false {
    71  		target.Network = nil
    72  		target.DistributedVirtualPortgroup = nil
    73  		target.DistributedVirtualSwitch = nil
    74  		target.OpaqueNetwork = nil
    75  		target.LegacyNetworkInfo = nil
    76  	}
    77  
    78  	if cmd.datastore == false {
    79  		target.Datastore = nil
    80  	}
    81  
    82  	if cmd.disk == false {
    83  		target.ScsiDisk = nil
    84  		target.IdeDisk = nil
    85  	}
    86  
    87  	return cmd.VirtualMachineFlag.WriteResult(&infoResult{target})
    88  }
    89  
    90  type infoResult struct {
    91  	*types.ConfigTarget
    92  }
    93  
    94  func (r *infoResult) Write(w io.Writer) error {
    95  	tw := tabwriter.NewWriter(w, 2, 0, 2, ' ', 0)
    96  
    97  	fmt.Fprintf(tw, "CPUs:\t%d\n", r.ConfigTarget.NumCpus)
    98  	fmt.Fprintf(tw, "CPU cores:\t%d\n", r.ConfigTarget.NumCpuCores)
    99  
   100  	for _, ds := range r.ConfigTarget.Datastore {
   101  		fmt.Fprintf(tw, "Datastore:\t%s\n", ds.Name)
   102  		fmt.Fprintf(tw, "  Capacity:\t%s\n", units.ByteSize(ds.Datastore.Capacity))
   103  		fmt.Fprintf(tw, "  Free:\t%s\n", units.ByteSize(ds.Datastore.FreeSpace))
   104  		fmt.Fprintf(tw, "  Uncommitted:\t%s\n", units.ByteSize(ds.Datastore.Uncommitted))
   105  	}
   106  
   107  	for _, net := range r.ConfigTarget.Network {
   108  		fmt.Fprintf(tw, "Network:\t%s\n", net.Name)
   109  	}
   110  
   111  	for _, net := range r.ConfigTarget.DistributedVirtualPortgroup {
   112  		if net.UplinkPortgroup {
   113  			continue
   114  		}
   115  		fmt.Fprintf(tw, "Network:\t%s\n", net.PortgroupName)
   116  		fmt.Fprintf(tw, "  Switch:\t%s\n", net.SwitchName)
   117  	}
   118  
   119  	for _, disk := range r.ConfigTarget.ScsiPassthrough {
   120  		fmt.Fprintf(tw, "SCSI passthrough:\t%s\n", disk.Name)
   121  		fmt.Fprintf(tw, "  Unit:\t%d\n", disk.PhysicalUnitNumber)
   122  	}
   123  
   124  	for _, clock := range r.ConfigTarget.PrecisionClockInfo {
   125  		fmt.Fprintf(tw, "PrecisionClock:\t%s\n", clock.SystemClockProtocol)
   126  	}
   127  
   128  	return tw.Flush()
   129  }
   130  
   131  func (r *infoResult) Dump() any {
   132  	return r.ConfigTarget
   133  }