github.com/vmware/govmomi@v0.51.0/cli/host/vnic/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 vnic
     6  
     7  import (
     8  	"context"
     9  	"flag"
    10  	"fmt"
    11  	"io"
    12  	"os"
    13  	"strings"
    14  	"text/tabwriter"
    15  
    16  	"github.com/vmware/govmomi/cli"
    17  	"github.com/vmware/govmomi/cli/flags"
    18  	"github.com/vmware/govmomi/object"
    19  	"github.com/vmware/govmomi/vim25/mo"
    20  	"github.com/vmware/govmomi/vim25/types"
    21  )
    22  
    23  type info struct {
    24  	*flags.HostSystemFlag
    25  }
    26  
    27  func init() {
    28  	cli.Register("host.vnic.info", &info{})
    29  }
    30  
    31  func (cmd *info) Register(ctx context.Context, f *flag.FlagSet) {
    32  	cmd.HostSystemFlag, ctx = flags.NewHostSystemFlag(ctx)
    33  	cmd.HostSystemFlag.Register(ctx, f)
    34  }
    35  
    36  func (cmd *info) Process(ctx context.Context) error {
    37  	if err := cmd.HostSystemFlag.Process(ctx); err != nil {
    38  		return err
    39  	}
    40  	return nil
    41  }
    42  
    43  type Info struct {
    44  	Device   string   `json:"device"`
    45  	Network  string   `json:"network"`
    46  	Switch   string   `json:"switch"`
    47  	Address  string   `json:"address"`
    48  	Stack    string   `json:"stack"`
    49  	Services []string `json:"services"`
    50  }
    51  
    52  type infoResult struct {
    53  	Info []Info `json:"info"`
    54  }
    55  
    56  func (i *infoResult) Write(w io.Writer) error {
    57  	tw := tabwriter.NewWriter(os.Stdout, 2, 0, 2, ' ', 0)
    58  
    59  	for _, info := range i.Info {
    60  		fmt.Fprintf(tw, "Device:\t%s\n", info.Device)
    61  		fmt.Fprintf(tw, "Network label:\t%s\n", info.Network)
    62  		fmt.Fprintf(tw, "Switch:\t%s\n", info.Switch)
    63  		fmt.Fprintf(tw, "IP address:\t%s\n", info.Address)
    64  		fmt.Fprintf(tw, "TCP/IP stack:\t%s\n", info.Stack)
    65  		fmt.Fprintf(tw, "Enabled services:\t%s\n", strings.Join(info.Services, ", "))
    66  	}
    67  
    68  	return tw.Flush()
    69  }
    70  
    71  func (cmd *info) Run(ctx context.Context, f *flag.FlagSet) error {
    72  	host, err := cmd.HostSystem()
    73  	if err != nil {
    74  		return err
    75  	}
    76  
    77  	ns, err := cmd.HostNetworkSystem()
    78  	if err != nil {
    79  		return err
    80  	}
    81  
    82  	var mns mo.HostNetworkSystem
    83  
    84  	m, err := host.ConfigManager().VirtualNicManager(ctx)
    85  	if err != nil {
    86  		return err
    87  	}
    88  
    89  	minfo, err := m.Info(ctx)
    90  	if err != nil {
    91  		return err
    92  	}
    93  
    94  	err = ns.Properties(ctx, ns.Reference(), []string{"networkInfo"}, &mns)
    95  	if err != nil {
    96  		return err
    97  	}
    98  
    99  	type dnet struct {
   100  		dvp mo.DistributedVirtualPortgroup
   101  		dvs mo.VmwareDistributedVirtualSwitch
   102  	}
   103  
   104  	dnets := make(map[string]*dnet)
   105  	var res infoResult
   106  
   107  	for _, nic := range mns.NetworkInfo.Vnic {
   108  		info := Info{Device: nic.Device}
   109  
   110  		if dvp := nic.Spec.DistributedVirtualPort; dvp != nil {
   111  			dn, ok := dnets[dvp.PortgroupKey]
   112  
   113  			if !ok {
   114  				dn = new(dnet)
   115  				o := object.NewDistributedVirtualPortgroup(host.Client(), types.ManagedObjectReference{
   116  					Type:  "DistributedVirtualPortgroup",
   117  					Value: dvp.PortgroupKey,
   118  				})
   119  
   120  				err = o.Properties(ctx, o.Reference(), []string{"name", "config.distributedVirtualSwitch"}, &dn.dvp)
   121  				if err != nil {
   122  					return err
   123  				}
   124  
   125  				err = o.Properties(ctx, *dn.dvp.Config.DistributedVirtualSwitch, []string{"name"}, &dn.dvs)
   126  				if err != nil {
   127  					return err
   128  				}
   129  
   130  				dnets[dvp.PortgroupKey] = dn
   131  			}
   132  
   133  			info.Network = dn.dvp.Name
   134  			info.Switch = dn.dvs.Name
   135  		} else {
   136  			info.Network = nic.Portgroup
   137  			for _, pg := range mns.NetworkInfo.Portgroup {
   138  				if pg.Spec.Name == nic.Portgroup {
   139  					info.Switch = pg.Spec.VswitchName
   140  					break
   141  				}
   142  			}
   143  		}
   144  
   145  		info.Address = nic.Spec.Ip.IpAddress
   146  		info.Stack = nic.Spec.NetStackInstanceKey
   147  
   148  		for _, nc := range minfo.NetConfig {
   149  			for _, dev := range nc.SelectedVnic {
   150  				key := nc.NicType + "." + nic.Key
   151  				if dev == key {
   152  					info.Services = append(info.Services, nc.NicType)
   153  				}
   154  			}
   155  
   156  		}
   157  
   158  		res.Info = append(res.Info, info)
   159  	}
   160  
   161  	return cmd.WriteResult(&res)
   162  }