gistfile1.go

package main
 
import (
  "fmt"
  "github.com/vmware/govmomi"
  "github.com/vmware/govmomi/vim25/mo"
  "github.com/vmware/govmomi/vim25/types"
  "net/url"
)
 
func main() {
  vCenterURL, err := url.Parse("https://user:password@host/sdk")
  if err != nil {
    fmt.Println(err)
    return
  }
 
  vClient, err := govmomi.NewClient(*vCenterURL, true)
  if err != nil {
    fmt.Println(err)
    return
  }
 
  refs, err := vClient.RootFolder().Children()
  if err != nil {
    fmt.Println(err)
    return
  }
 
  for _, v := range refs {
    references, err := recursion(vClient, v)
    if err != nil {
      fmt.Println(err)
      continue
    }

    for _, v := range references {
      if v.Reference().Type == "VirtualMachine" {
        var mvm mo.VirtualMachine
        props := []string{"summary"} // Load summary

        vClient.Properties(v.Reference(), props, &mvm)

        fmt.Printf("%s,%t\n", mvm.Summary.Config.Name, mvm.Summary.Config.Template)
      }
    }
  }
}
 
func recursion(c *govmomi.Client, ref govmomi.Reference) ([]govmomi.Reference, error) {
  var refs []govmomi.Reference
  switch ref.Reference().Type {
  default:
    return []govmomi.Reference{ref}, nil
  case "Datacenter":
    dc := govmomi.NewDatacenter(c, ref.Reference())
    dcFolders, err := dc.Folders()
    if err != nil {
      return nil, err
    }
 
    // Walk the VM folder
    found, err := recursion(c, dcFolders.VmFolder)
    if err != nil {
      return nil, err
    }
 
    refs = append(refs, found...)
 
    // Walk the Host folder
    found, err = recursion(c, dcFolders.HostFolder)
    if err != nil {
      return nil, err
    }
 
    refs = append(refs, found...)
 
    // Walk the Datastore folder
    found, err = recursion(c, dcFolders.DatastoreFolder)
    if err != nil {
      return nil, err
    }
 
    refs = append(refs, found...)
 
    // walk the Network folder
    found, err = recursion(c, dcFolders.NetworkFolder)
    if err != nil {
      return nil, err
    }
 
    refs = append(refs, found...)
 
  case "Folder":
    folder := govmomi.NewFolder(c, ref.Reference())
    children, err := folder.Children()
    if err != nil {
      return nil, err
    }
 
    for _, v := range children {
      found, err := recursion(c, v)
      if err != nil {
        return nil, err
      }
 
      refs = append(refs, found...)
    }
 
  case "StoragePod":
    var sp mo.StoragePod
    c.Properties(ref.Reference(), nil, &sp)
 
    for _, v := range sp.ChildEntity {
      newRef := newReference(v)
      found, err := recursion(c, newRef)
      if err != nil {
        return nil, err
      }
 
      refs = append(refs, found...)
    }
 
  case "ClusterComputeResource", "ComputeResource":
    var ccr mo.ClusterComputeResource
    c.Properties(ref.Reference(), nil, &ccr)
 
    for _, v := range ccr.Host {
      newRef := newReference(v)
      found, err := recursion(c, newRef)
      if err != nil {
        return nil, err
      }
 
      refs = append(refs, found...)
    }
 
  case "VmwareDistributedVirtualSwitch", "DistributedVirtualSwitch":
    var vDVS mo.VmwareDistributedVirtualSwitch
    c.Properties(ref.Reference(), nil, &vDVS)
 
    for _, v := range vDVS.Portgroup {
      newRef := newReference(v)
      found, err := recursion(c, newRef)
      if err != nil {
        return nil, err
      }
 
      refs = append(refs, found...)
    }
  }
 
  return refs, nil
}
 
func newReference(e types.ManagedObjectReference) govmomi.Reference {
  switch e.Type {
  case "Folder":
    return &govmomi.Folder{ManagedObjectReference: e}
  case "StoragePod":
    return &govmomi.StoragePod{
      &govmomi.Folder{ManagedObjectReference: e},
    }
  case "Datacenter":
    return &govmomi.Datacenter{ManagedObjectReference: e}
  case "VirtualMachine":
    return &govmomi.VirtualMachine{ManagedObjectReference: e}
  case "VirtualApp":
    return &govmomi.VirtualApp{
      &govmomi.ResourcePool{ManagedObjectReference: e},
    }
  case "ComputeResource":
    return &govmomi.ComputeResource{ManagedObjectReference: e}
  case "ClusterComputeResource":
    return &govmomi.ClusterComputeResource{
      govmomi.ComputeResource{ManagedObjectReference: e},
    }
  case "HostSystem":
    return &govmomi.HostSystem{ManagedObjectReference: e}
  case "Network":
    return &govmomi.Network{ManagedObjectReference: e}
  case "ResourcePool":
    return &govmomi.ResourcePool{ManagedObjectReference: e}
  case "DistributedVirtualSwitch":
    return &govmomi.DistributedVirtualSwitch{ManagedObjectReference: e}
  case "VmwareDistributedVirtualSwitch":
    return &govmomi.VmwareDistributedVirtualSwitch{
      govmomi.DistributedVirtualSwitch{ManagedObjectReference: e},
    }
  case "DistributedVirtualPortgroup":
    return &govmomi.DistributedVirtualPortgroup{ManagedObjectReference: e}
  case "Datastore":
    return &govmomi.Datastore{ManagedObjectReference: e}
  default:
    panic("Unknown managed entity: " + e.Type)
  }
}