func (f *Finder) NetworkList(ctx context.Context, path string) ([]object.NetworkReference, error) {
es, err := f.find(ctx, f.networkFolder, false, path)
if err != nil {
return nil, err
}
var ns []object.NetworkReference
for _, e := range es {
ref := e.Object.Reference()
switch ref.Type {
case "Network":
r := object.NewNetwork(f.client, ref)
r.InventoryPath = e.Path
ns = append(ns, r)
case "DistributedVirtualPortgroup":
r := object.NewDistributedVirtualPortgroup(f.client, ref)
r.InventoryPath = e.Path
ns = append(ns, r)
case "DistributedVirtualSwitch", "VmwareDistributedVirtualSwitch":
r := object.NewDistributedVirtualSwitch(f.client, ref)
r.InventoryPath = e.Path
ns = append(ns, r)
}
}
if len(ns) == 0 {
return nil, &NotFoundError{"network", path}
}
return ns, nil
}
// isDVSUplink determines if the DVP is an uplink
func (v *Validator) isDVSUplink(ref types.ManagedObjectReference) bool {
defer trace.End(trace.Begin(ref.Value))
var dvp mo.DistributedVirtualPortgroup
r := object.NewDistributedVirtualPortgroup(v.Session.Client.Client, ref)
if err := r.Properties(v.Context, r.Reference(), []string{"tag"}, &dvp); err != nil {
log.Errorf("Unable to check tags on %q: %s", ref, err)
return false
}
for _, t := range dvp.Tag {
if strings.Contains(t.Key, "UPLINKPG") {
return true
}
}
return false
}
func (vm *VirtualMachine) getNetworkName(ctx context.Context, nic types.BaseVirtualEthernetCard) (string, error) {
if card, ok := nic.GetVirtualEthernetCard().Backing.(*types.VirtualEthernetCardDistributedVirtualPortBackingInfo); ok {
pg := card.Port.PortgroupKey
pgref := object.NewDistributedVirtualPortgroup(vm.Session.Client.Client, types.ManagedObjectReference{
Type: "DistributedVirtualPortgroup",
Value: pg,
})
var pgo mo.DistributedVirtualPortgroup
err := pgref.Properties(ctx, pgref.Reference(), []string{"config"}, &pgo)
if err != nil {
log.Errorf("Failed to query portgroup %s for %s", pg, err)
return "", err
}
return pgo.Config.Name, nil
}
return nic.GetVirtualEthernetCard().DeviceInfo.GetDescription().Summary, nil
}
func (f *Finder) DVSWSList(ctx context.Context, path string, recursive bool) ([]object.DistributedVirtualPortgroup, error) {
es, err := f.find(ctx, f.networkFolder, recursive, path)
if err != nil {
return nil, err
}
var ns []object.DistributedVirtualPortgroup
for _, e := range es {
ref := e.Object.Reference()
switch ref.Type {
case "DistributedVirtualPortgroup":
r := object.NewDistributedVirtualPortgroup(f.client, ref)
r.InventoryPath = e.Path
ns = append(ns, *r)
}
}
return ns, nil
}
// checkVDSMembership verifes all hosts in the vCenter are connected to the vDS
func (v *Validator) checkVDSMembership(ctx context.Context, network types.ManagedObjectReference, netName string) error {
defer trace.End(trace.Begin(network.Value))
var dvp mo.DistributedVirtualPortgroup
var nonMembers []string
if !v.IsVC() {
return nil
}
if v.Session.Cluster == nil {
return errors.New("Invalid cluster. Check --compute-resource")
}
clusterHosts, err := v.Session.Cluster.Hosts(ctx)
if err != nil {
return err
}
r := object.NewDistributedVirtualPortgroup(v.Session.Client.Client, network)
if err := r.Properties(ctx, r.Reference(), []string{"name", "host"}, &dvp); err != nil {
return err
}
for _, h := range clusterHosts {
if !v.inDVP(h.Reference(), dvp.Host) {
nonMembers = append(nonMembers, h.InventoryPath)
}
}
if len(nonMembers) > 0 {
log.Errorf("vDS configuration incorrect on %q. All cluster hosts must be in the vDS.", netName)
log.Errorf(" %q is missing hosts:", netName)
for _, hs := range nonMembers {
log.Errorf(" %q", hs)
}
errMsg := fmt.Sprintf("All cluster hosts must be in the vDS. %q is missing hosts: %s", netName, nonMembers)
v.NoteIssue(errors.New(errMsg))
} else {
log.Infof("vDS configuration OK on %q", netName)
}
return nil
}
func (cmd *info) Run(ctx context.Context, f *flag.FlagSet) error {
host, err := cmd.HostSystem()
if err != nil {
return err
}
ns, err := cmd.HostNetworkSystem()
if err != nil {
return err
}
var mns mo.HostNetworkSystem
m, err := host.ConfigManager().VirtualNicManager(ctx)
if err != nil {
return err
}
info, err := m.Info(ctx)
if err != nil {
return err
}
err = ns.Properties(ctx, ns.Reference(), []string{"networkInfo"}, &mns)
if err != nil {
return err
}
tw := tabwriter.NewWriter(os.Stdout, 2, 0, 2, ' ', 0)
type dnet struct {
dvp mo.DistributedVirtualPortgroup
dvs mo.VmwareDistributedVirtualSwitch
}
dnets := make(map[string]*dnet)
for _, nic := range mns.NetworkInfo.Vnic {
fmt.Fprintf(tw, "Device:\t%s\n", nic.Device)
if dvp := nic.Spec.DistributedVirtualPort; dvp != nil {
dn, ok := dnets[dvp.PortgroupKey]
if !ok {
dn = new(dnet)
o := object.NewDistributedVirtualPortgroup(host.Client(), types.ManagedObjectReference{
Type: "DistributedVirtualPortgroup",
Value: dvp.PortgroupKey,
})
err = o.Properties(ctx, o.Reference(), []string{"name", "config.distributedVirtualSwitch"}, &dn.dvp)
if err != nil {
return err
}
err = o.Properties(ctx, *dn.dvp.Config.DistributedVirtualSwitch, []string{"name"}, &dn.dvs)
if err != nil {
return err
}
dnets[dvp.PortgroupKey] = dn
}
fmt.Fprintf(tw, "Network label:\t%s\n", dn.dvp.Name)
fmt.Fprintf(tw, "Switch:\t%s\n", dn.dvs.Name)
} else {
fmt.Fprintf(tw, "Network label:\t%s\n", nic.Portgroup)
for _, pg := range mns.NetworkInfo.Portgroup {
if pg.Spec.Name == nic.Portgroup {
fmt.Fprintf(tw, "Switch:\t%s\n", pg.Spec.VswitchName)
break
}
}
}
fmt.Fprintf(tw, "IP address:\t%s\n", nic.Spec.Ip.IpAddress)
fmt.Fprintf(tw, "TCP/IP stack:\t%s\n", nic.Spec.NetStackInstanceKey)
var services []string
for _, nc := range info.NetConfig {
for _, dev := range nc.SelectedVnic {
key := nc.NicType + "." + nic.Key
if dev == key {
services = append(services, nc.NicType)
}
}
}
fmt.Fprintf(tw, "Enabled services:\t%s\n", strings.Join(services, ", "))
}
return tw.Flush()
}