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() }