govmomi: github.com/vmware/govmomi/vim25/mo Index | Files

package mo

import "github.com/vmware/govmomi/vim25/mo"

Index

Package Files

ancestors.go entity.go extra.go mo.go reference.go registry.go retrieve.go type_info.go

func Ancestors Uses

func Ancestors(ctx context.Context, rt soap.RoundTripper, pc, obj types.ManagedObjectReference) ([]ManagedEntity, error)

Ancestors returns the entire ancestry tree of a specified managed object. The return value includes the root node and the specified object itself.

func LoadRetrievePropertiesResponse Uses

func LoadRetrievePropertiesResponse(res *types.RetrievePropertiesResponse, dst interface{}) error

LoadRetrievePropertiesResponse converts the response of a call to RetrieveProperties to one or more managed objects.

func ObjectContentToType Uses

func ObjectContentToType(o types.ObjectContent) (interface{}, error)

ObjectContentToType loads an ObjectContent value into the value it represents. If the ObjectContent value has a non-empty 'MissingSet' field, it returns the first fault it finds there as error. If the 'MissingSet' field is empty, it returns a pointer to a reflect.Value. It handles contain nested properties, such as 'guest.ipAddress' or 'config.hardware'.

func RetrieveProperties Uses

func RetrieveProperties(ctx context.Context, r soap.RoundTripper, pc, obj types.ManagedObjectReference, dst interface{}) error

RetrieveProperties retrieves the properties of the managed object specified as obj and decodes the response struct into the value pointed to by dst.

func RetrievePropertiesForRequest Uses

func RetrievePropertiesForRequest(ctx context.Context, r soap.RoundTripper, req types.RetrieveProperties, dst interface{}) error

RetrievePropertiesForRequest calls the RetrieveProperties method with the specified request and decodes the response struct into the value pointed to by dst.

type Alarm Uses

type Alarm struct {
    ExtensibleManagedObject

    Info types.AlarmInfo `mo:"info"`
}

type AlarmManager Uses

type AlarmManager struct {
    Self types.ManagedObjectReference

    DefaultExpression []types.BaseAlarmExpression `mo:"defaultExpression"`
    Description       types.AlarmDescription      `mo:"description"`
}

func (AlarmManager) Reference Uses

func (m AlarmManager) Reference() types.ManagedObjectReference

type AuthorizationManager Uses

type AuthorizationManager struct {
    Self types.ManagedObjectReference

    PrivilegeList []types.AuthorizationPrivilege `mo:"privilegeList"`
    RoleList      []types.AuthorizationRole      `mo:"roleList"`
    Description   types.AuthorizationDescription `mo:"description"`
}

func (AuthorizationManager) Reference Uses

func (m AuthorizationManager) Reference() types.ManagedObjectReference

type CertificateManager Uses

type CertificateManager struct {
    Self types.ManagedObjectReference
}

func (CertificateManager) Reference Uses

func (m CertificateManager) Reference() types.ManagedObjectReference

type ClusterComputeResource Uses

type ClusterComputeResource struct {
    ComputeResource

    Configuration     types.ClusterConfigInfo          `mo:"configuration"`
    Recommendation    []types.ClusterRecommendation    `mo:"recommendation"`
    DrsRecommendation []types.ClusterDrsRecommendation `mo:"drsRecommendation"`
    MigrationHistory  []types.ClusterDrsMigration      `mo:"migrationHistory"`
    ActionHistory     []types.ClusterActionHistory     `mo:"actionHistory"`
    DrsFault          []types.ClusterDrsFaults         `mo:"drsFault"`
}

type ClusterEVCManager Uses

type ClusterEVCManager struct {
    ExtensibleManagedObject

    ManagedCluster types.ManagedObjectReference    `mo:"managedCluster"`
    EvcState       types.ClusterEVCManagerEVCState `mo:"evcState"`
}

type ClusterProfile Uses

type ClusterProfile struct {
    Profile
}

type ClusterProfileManager Uses

type ClusterProfileManager struct {
    ProfileManager
}

type ComputeResource Uses

type ComputeResource struct {
    ManagedEntity

    ResourcePool       *types.ManagedObjectReference       `mo:"resourcePool"`
    Host               []types.ManagedObjectReference      `mo:"host"`
    Datastore          []types.ManagedObjectReference      `mo:"datastore"`
    Network            []types.ManagedObjectReference      `mo:"network"`
    Summary            types.BaseComputeResourceSummary    `mo:"summary"`
    EnvironmentBrowser *types.ManagedObjectReference       `mo:"environmentBrowser"`
    ConfigurationEx    types.BaseComputeResourceConfigInfo `mo:"configurationEx"`
}

func (*ComputeResource) Entity Uses

func (m *ComputeResource) Entity() *ManagedEntity

func (ComputeResource) GetManagedEntity Uses

func (m ComputeResource) GetManagedEntity() ManagedEntity

type ContainerView Uses

type ContainerView struct {
    ManagedObjectView

    Container types.ManagedObjectReference `mo:"container"`
    Type      []string                     `mo:"type"`
    Recursive bool                         `mo:"recursive"`
}

type CryptoManager Uses

type CryptoManager struct {
    Self types.ManagedObjectReference

    Enabled bool `mo:"enabled"`
}

func (CryptoManager) Reference Uses

func (m CryptoManager) Reference() types.ManagedObjectReference

type CryptoManagerKmip Uses

type CryptoManagerKmip struct {
    CryptoManager

    KmipServers []types.KmipClusterInfo `mo:"kmipServers"`
}

type CustomFieldsManager Uses

type CustomFieldsManager struct {
    Self types.ManagedObjectReference

    Field []types.CustomFieldDef `mo:"field"`
}

func (CustomFieldsManager) Reference Uses

func (m CustomFieldsManager) Reference() types.ManagedObjectReference

type CustomizationSpecManager Uses

type CustomizationSpecManager struct {
    Self types.ManagedObjectReference

    Info          []types.CustomizationSpecInfo `mo:"info"`
    EncryptionKey []byte                        `mo:"encryptionKey"`
}

func (CustomizationSpecManager) Reference Uses

func (m CustomizationSpecManager) Reference() types.ManagedObjectReference

type Datacenter Uses

type Datacenter struct {
    ManagedEntity

    VmFolder        types.ManagedObjectReference   `mo:"vmFolder"`
    HostFolder      types.ManagedObjectReference   `mo:"hostFolder"`
    DatastoreFolder types.ManagedObjectReference   `mo:"datastoreFolder"`
    NetworkFolder   types.ManagedObjectReference   `mo:"networkFolder"`
    Datastore       []types.ManagedObjectReference `mo:"datastore"`
    Network         []types.ManagedObjectReference `mo:"network"`
    Configuration   types.DatacenterConfigInfo     `mo:"configuration"`
}

func (*Datacenter) Entity Uses

func (m *Datacenter) Entity() *ManagedEntity

func (Datacenter) GetManagedEntity Uses

func (m Datacenter) GetManagedEntity() ManagedEntity

type Datastore Uses

type Datastore struct {
    ManagedEntity

    Info              types.BaseDatastoreInfo        `mo:"info"`
    Summary           types.DatastoreSummary         `mo:"summary"`
    Host              []types.DatastoreHostMount     `mo:"host"`
    Vm                []types.ManagedObjectReference `mo:"vm"`
    Browser           types.ManagedObjectReference   `mo:"browser"`
    Capability        types.DatastoreCapability      `mo:"capability"`
    IormConfiguration *types.StorageIORMInfo         `mo:"iormConfiguration"`
}

func (*Datastore) Entity Uses

func (m *Datastore) Entity() *ManagedEntity

func (Datastore) GetManagedEntity Uses

func (m Datastore) GetManagedEntity() ManagedEntity

type DatastoreNamespaceManager Uses

type DatastoreNamespaceManager struct {
    Self types.ManagedObjectReference
}

func (DatastoreNamespaceManager) Reference Uses

func (m DatastoreNamespaceManager) Reference() types.ManagedObjectReference

type DiagnosticManager Uses

type DiagnosticManager struct {
    Self types.ManagedObjectReference
}

func (DiagnosticManager) Reference Uses

func (m DiagnosticManager) Reference() types.ManagedObjectReference

type DistributedVirtualPortgroup Uses

type DistributedVirtualPortgroup struct {
    Network

    Key      string                      `mo:"key"`
    Config   types.DVPortgroupConfigInfo `mo:"config"`
    PortKeys []string                    `mo:"portKeys"`
}

func (DistributedVirtualPortgroup) GetManagedEntity Uses

func (m DistributedVirtualPortgroup) GetManagedEntity() ManagedEntity

type DistributedVirtualSwitch Uses

type DistributedVirtualSwitch struct {
    ManagedEntity

    Uuid                string                         `mo:"uuid"`
    Capability          types.DVSCapability            `mo:"capability"`
    Summary             types.DVSSummary               `mo:"summary"`
    Config              types.BaseDVSConfigInfo        `mo:"config"`
    NetworkResourcePool []types.DVSNetworkResourcePool `mo:"networkResourcePool"`
    Portgroup           []types.ManagedObjectReference `mo:"portgroup"`
    Runtime             *types.DVSRuntimeInfo          `mo:"runtime"`
}

func (*DistributedVirtualSwitch) Entity Uses

func (m *DistributedVirtualSwitch) Entity() *ManagedEntity

func (DistributedVirtualSwitch) GetManagedEntity Uses

func (m DistributedVirtualSwitch) GetManagedEntity() ManagedEntity

type DistributedVirtualSwitchManager Uses

type DistributedVirtualSwitchManager struct {
    Self types.ManagedObjectReference
}

func (DistributedVirtualSwitchManager) Reference Uses

func (m DistributedVirtualSwitchManager) Reference() types.ManagedObjectReference

type Entity Uses

type Entity interface {
    Reference
    Entity() *ManagedEntity
}

Entity is the interface that is implemented by all managed objects that extend ManagedEntity.

type EnvironmentBrowser Uses

type EnvironmentBrowser struct {
    Self types.ManagedObjectReference

    DatastoreBrowser *types.ManagedObjectReference `mo:"datastoreBrowser"`
}

func (EnvironmentBrowser) Reference Uses

func (m EnvironmentBrowser) Reference() types.ManagedObjectReference

type EventHistoryCollector Uses

type EventHistoryCollector struct {
    HistoryCollector

    LatestPage []types.BaseEvent `mo:"latestPage"`
}

type EventManager Uses

type EventManager struct {
    Self types.ManagedObjectReference

    Description  types.EventDescription `mo:"description"`
    LatestEvent  types.BaseEvent        `mo:"latestEvent"`
    MaxCollector int32                  `mo:"maxCollector"`
}

func (EventManager) Reference Uses

func (m EventManager) Reference() types.ManagedObjectReference

type ExtensibleManagedObject Uses

type ExtensibleManagedObject struct {
    Self types.ManagedObjectReference

    Value          []types.BaseCustomFieldValue `mo:"value"`
    AvailableField []types.CustomFieldDef       `mo:"availableField"`
}

func (ExtensibleManagedObject) Reference Uses

func (m ExtensibleManagedObject) Reference() types.ManagedObjectReference

type ExtensionManager Uses

type ExtensionManager struct {
    Self types.ManagedObjectReference

    ExtensionList []types.Extension `mo:"extensionList"`
}

func (ExtensionManager) Reference Uses

func (m ExtensionManager) Reference() types.ManagedObjectReference

type FailoverClusterConfigurator Uses

type FailoverClusterConfigurator struct {
    Self types.ManagedObjectReference

    DisabledConfigureMethod []string `mo:"disabledConfigureMethod"`
}

func (FailoverClusterConfigurator) Reference Uses

func (m FailoverClusterConfigurator) Reference() types.ManagedObjectReference

type FailoverClusterManager Uses

type FailoverClusterManager struct {
    Self types.ManagedObjectReference

    DisabledClusterMethod []string `mo:"disabledClusterMethod"`
}

func (FailoverClusterManager) Reference Uses

func (m FailoverClusterManager) Reference() types.ManagedObjectReference

type FileManager Uses

type FileManager struct {
    Self types.ManagedObjectReference
}

func (FileManager) Reference Uses

func (m FileManager) Reference() types.ManagedObjectReference

type Folder Uses

type Folder struct {
    ManagedEntity

    ChildType   []string                       `mo:"childType"`
    ChildEntity []types.ManagedObjectReference `mo:"childEntity"`
}

func (*Folder) Entity Uses

func (m *Folder) Entity() *ManagedEntity

func (Folder) GetManagedEntity Uses

func (m Folder) GetManagedEntity() ManagedEntity

type GuestAliasManager Uses

type GuestAliasManager struct {
    Self types.ManagedObjectReference
}

func (GuestAliasManager) Reference Uses

func (m GuestAliasManager) Reference() types.ManagedObjectReference

type GuestAuthManager Uses

type GuestAuthManager struct {
    Self types.ManagedObjectReference
}

func (GuestAuthManager) Reference Uses

func (m GuestAuthManager) Reference() types.ManagedObjectReference

type GuestFileManager Uses

type GuestFileManager struct {
    Self types.ManagedObjectReference
}

func (GuestFileManager) Reference Uses

func (m GuestFileManager) Reference() types.ManagedObjectReference

type GuestOperationsManager Uses

type GuestOperationsManager struct {
    Self types.ManagedObjectReference

    AuthManager                 *types.ManagedObjectReference `mo:"authManager"`
    FileManager                 *types.ManagedObjectReference `mo:"fileManager"`
    ProcessManager              *types.ManagedObjectReference `mo:"processManager"`
    GuestWindowsRegistryManager *types.ManagedObjectReference `mo:"guestWindowsRegistryManager"`
    AliasManager                *types.ManagedObjectReference `mo:"aliasManager"`
}

func (GuestOperationsManager) Reference Uses

func (m GuestOperationsManager) Reference() types.ManagedObjectReference

type GuestProcessManager Uses

type GuestProcessManager struct {
    Self types.ManagedObjectReference
}

func (GuestProcessManager) Reference Uses

func (m GuestProcessManager) Reference() types.ManagedObjectReference

type GuestWindowsRegistryManager Uses

type GuestWindowsRegistryManager struct {
    Self types.ManagedObjectReference
}

func (GuestWindowsRegistryManager) Reference Uses

func (m GuestWindowsRegistryManager) Reference() types.ManagedObjectReference

type HealthUpdateManager Uses

type HealthUpdateManager struct {
    Self types.ManagedObjectReference
}

func (HealthUpdateManager) Reference Uses

func (m HealthUpdateManager) Reference() types.ManagedObjectReference

type HistoryCollector Uses

type HistoryCollector struct {
    Self types.ManagedObjectReference

    Filter types.AnyType `mo:"filter"`
}

func (HistoryCollector) Reference Uses

func (m HistoryCollector) Reference() types.ManagedObjectReference

type HostAccessManager Uses

type HostAccessManager struct {
    Self types.ManagedObjectReference

    LockdownMode types.HostLockdownMode `mo:"lockdownMode"`
}

func (HostAccessManager) Reference Uses

func (m HostAccessManager) Reference() types.ManagedObjectReference

type HostActiveDirectoryAuthentication Uses

type HostActiveDirectoryAuthentication struct {
    HostDirectoryStore
}

type HostAuthenticationManager Uses

type HostAuthenticationManager struct {
    Self types.ManagedObjectReference

    Info           types.HostAuthenticationManagerInfo `mo:"info"`
    SupportedStore []types.ManagedObjectReference      `mo:"supportedStore"`
}

func (HostAuthenticationManager) Reference Uses

func (m HostAuthenticationManager) Reference() types.ManagedObjectReference

type HostAuthenticationStore Uses

type HostAuthenticationStore struct {
    Self types.ManagedObjectReference

    Info types.BaseHostAuthenticationStoreInfo `mo:"info"`
}

func (HostAuthenticationStore) Reference Uses

func (m HostAuthenticationStore) Reference() types.ManagedObjectReference

type HostAutoStartManager Uses

type HostAutoStartManager struct {
    Self types.ManagedObjectReference

    Config types.HostAutoStartManagerConfig `mo:"config"`
}

func (HostAutoStartManager) Reference Uses

func (m HostAutoStartManager) Reference() types.ManagedObjectReference

type HostBootDeviceSystem Uses

type HostBootDeviceSystem struct {
    Self types.ManagedObjectReference
}

func (HostBootDeviceSystem) Reference Uses

func (m HostBootDeviceSystem) Reference() types.ManagedObjectReference

type HostCacheConfigurationManager Uses

type HostCacheConfigurationManager struct {
    Self types.ManagedObjectReference

    CacheConfigurationInfo []types.HostCacheConfigurationInfo `mo:"cacheConfigurationInfo"`
}

func (HostCacheConfigurationManager) Reference Uses

func (m HostCacheConfigurationManager) Reference() types.ManagedObjectReference

type HostCertificateManager Uses

type HostCertificateManager struct {
    Self types.ManagedObjectReference

    CertificateInfo types.HostCertificateManagerCertificateInfo `mo:"certificateInfo"`
}

func (HostCertificateManager) Reference Uses

func (m HostCertificateManager) Reference() types.ManagedObjectReference

type HostCpuSchedulerSystem Uses

type HostCpuSchedulerSystem struct {
    ExtensibleManagedObject

    HyperthreadInfo *types.HostHyperThreadScheduleInfo `mo:"hyperthreadInfo"`
}

type HostDatastoreBrowser Uses

type HostDatastoreBrowser struct {
    Self types.ManagedObjectReference

    Datastore     []types.ManagedObjectReference `mo:"datastore"`
    SupportedType []types.BaseFileQuery          `mo:"supportedType"`
}

func (HostDatastoreBrowser) Reference Uses

func (m HostDatastoreBrowser) Reference() types.ManagedObjectReference

type HostDatastoreSystem Uses

type HostDatastoreSystem struct {
    Self types.ManagedObjectReference

    Datastore    []types.ManagedObjectReference        `mo:"datastore"`
    Capabilities types.HostDatastoreSystemCapabilities `mo:"capabilities"`
}

func (HostDatastoreSystem) Reference Uses

func (m HostDatastoreSystem) Reference() types.ManagedObjectReference

type HostDateTimeSystem Uses

type HostDateTimeSystem struct {
    Self types.ManagedObjectReference

    DateTimeInfo types.HostDateTimeInfo `mo:"dateTimeInfo"`
}

func (HostDateTimeSystem) Reference Uses

func (m HostDateTimeSystem) Reference() types.ManagedObjectReference

type HostDiagnosticSystem Uses

type HostDiagnosticSystem struct {
    Self types.ManagedObjectReference

    ActivePartition *types.HostDiagnosticPartition `mo:"activePartition"`
}

func (HostDiagnosticSystem) Reference Uses

func (m HostDiagnosticSystem) Reference() types.ManagedObjectReference

type HostDirectoryStore Uses

type HostDirectoryStore struct {
    HostAuthenticationStore
}

type HostEsxAgentHostManager Uses

type HostEsxAgentHostManager struct {
    Self types.ManagedObjectReference

    ConfigInfo types.HostEsxAgentHostManagerConfigInfo `mo:"configInfo"`
}

func (HostEsxAgentHostManager) Reference Uses

func (m HostEsxAgentHostManager) Reference() types.ManagedObjectReference

type HostFirewallSystem Uses

type HostFirewallSystem struct {
    ExtensibleManagedObject

    FirewallInfo *types.HostFirewallInfo `mo:"firewallInfo"`
}

type HostFirmwareSystem Uses

type HostFirmwareSystem struct {
    Self types.ManagedObjectReference
}

func (HostFirmwareSystem) Reference Uses

func (m HostFirmwareSystem) Reference() types.ManagedObjectReference

type HostGraphicsManager Uses

type HostGraphicsManager struct {
    ExtensibleManagedObject

    GraphicsInfo           []types.HostGraphicsInfo  `mo:"graphicsInfo"`
    GraphicsConfig         *types.HostGraphicsConfig `mo:"graphicsConfig"`
    SharedPassthruGpuTypes []string                  `mo:"sharedPassthruGpuTypes"`
}

type HostHealthStatusSystem Uses

type HostHealthStatusSystem struct {
    Self types.ManagedObjectReference

    Runtime types.HealthSystemRuntime `mo:"runtime"`
}

func (HostHealthStatusSystem) Reference Uses

func (m HostHealthStatusSystem) Reference() types.ManagedObjectReference

type HostImageConfigManager Uses

type HostImageConfigManager struct {
    Self types.ManagedObjectReference
}

func (HostImageConfigManager) Reference Uses

func (m HostImageConfigManager) Reference() types.ManagedObjectReference

type HostKernelModuleSystem Uses

type HostKernelModuleSystem struct {
    Self types.ManagedObjectReference
}

func (HostKernelModuleSystem) Reference Uses

func (m HostKernelModuleSystem) Reference() types.ManagedObjectReference

type HostLocalAccountManager Uses

type HostLocalAccountManager struct {
    Self types.ManagedObjectReference
}

func (HostLocalAccountManager) Reference Uses

func (m HostLocalAccountManager) Reference() types.ManagedObjectReference

type HostLocalAuthentication Uses

type HostLocalAuthentication struct {
    HostAuthenticationStore
}

type HostMemorySystem Uses

type HostMemorySystem struct {
    ExtensibleManagedObject

    ConsoleReservationInfo        *types.ServiceConsoleReservationInfo       `mo:"consoleReservationInfo"`
    VirtualMachineReservationInfo *types.VirtualMachineMemoryReservationInfo `mo:"virtualMachineReservationInfo"`
}

type HostNetworkSystem Uses

type HostNetworkSystem struct {
    ExtensibleManagedObject

    Capabilities         *types.HostNetCapabilities        `mo:"capabilities"`
    NetworkInfo          *types.HostNetworkInfo            `mo:"networkInfo"`
    OffloadCapabilities  *types.HostNetOffloadCapabilities `mo:"offloadCapabilities"`
    NetworkConfig        *types.HostNetworkConfig          `mo:"networkConfig"`
    DnsConfig            types.BaseHostDnsConfig           `mo:"dnsConfig"`
    IpRouteConfig        types.BaseHostIpRouteConfig       `mo:"ipRouteConfig"`
    ConsoleIpRouteConfig types.BaseHostIpRouteConfig       `mo:"consoleIpRouteConfig"`
}

type HostPatchManager Uses

type HostPatchManager struct {
    Self types.ManagedObjectReference
}

func (HostPatchManager) Reference Uses

func (m HostPatchManager) Reference() types.ManagedObjectReference

type HostPciPassthruSystem Uses

type HostPciPassthruSystem struct {
    ExtensibleManagedObject

    PciPassthruInfo     []types.BaseHostPciPassthruInfo     `mo:"pciPassthruInfo"`
    SriovDevicePoolInfo []types.BaseHostSriovDevicePoolInfo `mo:"sriovDevicePoolInfo"`
}

type HostPowerSystem Uses

type HostPowerSystem struct {
    Self types.ManagedObjectReference

    Capability types.PowerSystemCapability `mo:"capability"`
    Info       types.PowerSystemInfo       `mo:"info"`
}

func (HostPowerSystem) Reference Uses

func (m HostPowerSystem) Reference() types.ManagedObjectReference

type HostProfile Uses

type HostProfile struct {
    Profile

    ReferenceHost *types.ManagedObjectReference `mo:"referenceHost"`
}

type HostProfileManager Uses

type HostProfileManager struct {
    ProfileManager
}

type HostServiceSystem Uses

type HostServiceSystem struct {
    ExtensibleManagedObject

    ServiceInfo types.HostServiceInfo `mo:"serviceInfo"`
}

type HostSnmpSystem Uses

type HostSnmpSystem struct {
    Self types.ManagedObjectReference

    Configuration types.HostSnmpConfigSpec        `mo:"configuration"`
    Limits        types.HostSnmpSystemAgentLimits `mo:"limits"`
}

func (HostSnmpSystem) Reference Uses

func (m HostSnmpSystem) Reference() types.ManagedObjectReference

type HostSpecificationManager Uses

type HostSpecificationManager struct {
    Self types.ManagedObjectReference
}

func (HostSpecificationManager) Reference Uses

func (m HostSpecificationManager) Reference() types.ManagedObjectReference

type HostStorageSystem Uses

type HostStorageSystem struct {
    ExtensibleManagedObject

    StorageDeviceInfo    *types.HostStorageDeviceInfo   `mo:"storageDeviceInfo"`
    FileSystemVolumeInfo types.HostFileSystemVolumeInfo `mo:"fileSystemVolumeInfo"`
    SystemFile           []string                       `mo:"systemFile"`
    MultipathStateInfo   *types.HostMultipathStateInfo  `mo:"multipathStateInfo"`
}

type HostSystem Uses

type HostSystem struct {
    ManagedEntity

    Runtime            types.HostRuntimeInfo            `mo:"runtime"`
    Summary            types.HostListSummary            `mo:"summary"`
    Hardware           *types.HostHardwareInfo          `mo:"hardware"`
    Capability         *types.HostCapability            `mo:"capability"`
    LicensableResource types.HostLicensableResourceInfo `mo:"licensableResource"`
    ConfigManager      types.HostConfigManager          `mo:"configManager"`
    Config             *types.HostConfigInfo            `mo:"config"`
    Vm                 []types.ManagedObjectReference   `mo:"vm"`
    Datastore          []types.ManagedObjectReference   `mo:"datastore"`
    Network            []types.ManagedObjectReference   `mo:"network"`
    DatastoreBrowser   types.ManagedObjectReference     `mo:"datastoreBrowser"`
    SystemResources    *types.HostSystemResourceInfo    `mo:"systemResources"`
}

func (*HostSystem) Entity Uses

func (m *HostSystem) Entity() *ManagedEntity

func (HostSystem) GetManagedEntity Uses

func (m HostSystem) GetManagedEntity() ManagedEntity

type HostVFlashManager Uses

type HostVFlashManager struct {
    Self types.ManagedObjectReference

    VFlashConfigInfo *types.HostVFlashManagerVFlashConfigInfo `mo:"vFlashConfigInfo"`
}

func (HostVFlashManager) Reference Uses

func (m HostVFlashManager) Reference() types.ManagedObjectReference

type HostVMotionSystem Uses

type HostVMotionSystem struct {
    ExtensibleManagedObject

    NetConfig *types.HostVMotionNetConfig `mo:"netConfig"`
    IpConfig  *types.HostIpConfig         `mo:"ipConfig"`
}

type HostVStorageObjectManager Uses

type HostVStorageObjectManager struct {
    VStorageObjectManagerBase
}

type HostVirtualNicManager Uses

type HostVirtualNicManager struct {
    ExtensibleManagedObject

    Info types.HostVirtualNicManagerInfo `mo:"info"`
}

type HostVsanInternalSystem Uses

type HostVsanInternalSystem struct {
    Self types.ManagedObjectReference
}

func (HostVsanInternalSystem) Reference Uses

func (m HostVsanInternalSystem) Reference() types.ManagedObjectReference

type HostVsanSystem Uses

type HostVsanSystem struct {
    Self types.ManagedObjectReference

    Config types.VsanHostConfigInfo `mo:"config"`
}

func (HostVsanSystem) Reference Uses

func (m HostVsanSystem) Reference() types.ManagedObjectReference

type HttpNfcLease Uses

type HttpNfcLease struct {
    Self types.ManagedObjectReference

    InitializeProgress int32                       `mo:"initializeProgress"`
    Info               *types.HttpNfcLeaseInfo     `mo:"info"`
    State              types.HttpNfcLeaseState     `mo:"state"`
    Error              *types.LocalizedMethodFault `mo:"error"`
}

func (HttpNfcLease) Reference Uses

func (m HttpNfcLease) Reference() types.ManagedObjectReference

type InventoryView Uses

type InventoryView struct {
    ManagedObjectView
}

type IoFilterManager Uses

type IoFilterManager struct {
    Self types.ManagedObjectReference
}

func (IoFilterManager) Reference Uses

func (m IoFilterManager) Reference() types.ManagedObjectReference

type IpPoolManager Uses

type IpPoolManager struct {
    Self types.ManagedObjectReference
}

func (IpPoolManager) Reference Uses

func (m IpPoolManager) Reference() types.ManagedObjectReference

type IsManagedEntity Uses

type IsManagedEntity interface {
    GetManagedEntity() ManagedEntity
}

type IscsiManager Uses

type IscsiManager struct {
    Self types.ManagedObjectReference
}

func (IscsiManager) Reference Uses

func (m IscsiManager) Reference() types.ManagedObjectReference

type LicenseAssignmentManager Uses

type LicenseAssignmentManager struct {
    Self types.ManagedObjectReference
}

func (LicenseAssignmentManager) Reference Uses

func (m LicenseAssignmentManager) Reference() types.ManagedObjectReference

type LicenseManager Uses

type LicenseManager struct {
    Self types.ManagedObjectReference

    Source                   types.BaseLicenseSource            `mo:"source"`
    SourceAvailable          bool                               `mo:"sourceAvailable"`
    Diagnostics              *types.LicenseDiagnostics          `mo:"diagnostics"`
    FeatureInfo              []types.LicenseFeatureInfo         `mo:"featureInfo"`
    LicensedEdition          string                             `mo:"licensedEdition"`
    Licenses                 []types.LicenseManagerLicenseInfo  `mo:"licenses"`
    LicenseAssignmentManager *types.ManagedObjectReference      `mo:"licenseAssignmentManager"`
    Evaluation               types.LicenseManagerEvaluationInfo `mo:"evaluation"`
}

func (LicenseManager) Reference Uses

func (m LicenseManager) Reference() types.ManagedObjectReference

type ListView Uses

type ListView struct {
    ManagedObjectView
}

type LocalizationManager Uses

type LocalizationManager struct {
    Self types.ManagedObjectReference

    Catalog []types.LocalizationManagerMessageCatalog `mo:"catalog"`
}

func (LocalizationManager) Reference Uses

func (m LocalizationManager) Reference() types.ManagedObjectReference

type ManagedEntity Uses

type ManagedEntity struct {
    ExtensibleManagedObject

    Parent              *types.ManagedObjectReference  `mo:"parent"`
    CustomValue         []types.BaseCustomFieldValue   `mo:"customValue"`
    OverallStatus       types.ManagedEntityStatus      `mo:"overallStatus"`
    ConfigStatus        types.ManagedEntityStatus      `mo:"configStatus"`
    ConfigIssue         []types.BaseEvent              `mo:"configIssue"`
    EffectiveRole       []int32                        `mo:"effectiveRole"`
    Permission          []types.Permission             `mo:"permission"`
    Name                string                         `mo:"name"`
    DisabledMethod      []string                       `mo:"disabledMethod"`
    RecentTask          []types.ManagedObjectReference `mo:"recentTask"`
    DeclaredAlarmState  []types.AlarmState             `mo:"declaredAlarmState"`
    TriggeredAlarmState []types.AlarmState             `mo:"triggeredAlarmState"`
    AlarmActionsEnabled *bool                          `mo:"alarmActionsEnabled"`
    Tag                 []types.Tag                    `mo:"tag"`
}

type ManagedObjectView Uses

type ManagedObjectView struct {
    Self types.ManagedObjectReference

    View []types.ManagedObjectReference `mo:"view"`
}

func (ManagedObjectView) Reference Uses

func (m ManagedObjectView) Reference() types.ManagedObjectReference

type MessageBusProxy Uses

type MessageBusProxy struct {
    Self types.ManagedObjectReference
}

func (MessageBusProxy) Reference Uses

func (m MessageBusProxy) Reference() types.ManagedObjectReference

type Network Uses

type Network struct {
    ManagedEntity

    Name    string                         `mo:"name"`
    Summary types.BaseNetworkSummary       `mo:"summary"`
    Host    []types.ManagedObjectReference `mo:"host"`
    Vm      []types.ManagedObjectReference `mo:"vm"`
}

func (*Network) Entity Uses

func (m *Network) Entity() *ManagedEntity

func (Network) GetManagedEntity Uses

func (m Network) GetManagedEntity() ManagedEntity

type OpaqueNetwork Uses

type OpaqueNetwork struct {
    Network

    Capability  *types.OpaqueNetworkCapability `mo:"capability"`
    ExtraConfig []types.BaseOptionValue        `mo:"extraConfig"`
}

type OptionManager Uses

type OptionManager struct {
    Self types.ManagedObjectReference

    SupportedOption []types.OptionDef       `mo:"supportedOption"`
    Setting         []types.BaseOptionValue `mo:"setting"`
}

func (OptionManager) Reference Uses

func (m OptionManager) Reference() types.ManagedObjectReference

type OverheadMemoryManager Uses

type OverheadMemoryManager struct {
    Self types.ManagedObjectReference
}

func (OverheadMemoryManager) Reference Uses

func (m OverheadMemoryManager) Reference() types.ManagedObjectReference

type OvfManager Uses

type OvfManager struct {
    Self types.ManagedObjectReference

    OvfImportOption []types.OvfOptionInfo `mo:"ovfImportOption"`
    OvfExportOption []types.OvfOptionInfo `mo:"ovfExportOption"`
}

func (OvfManager) Reference Uses

func (m OvfManager) Reference() types.ManagedObjectReference

type PerformanceManager Uses

type PerformanceManager struct {
    Self types.ManagedObjectReference

    Description        types.PerformanceDescription `mo:"description"`
    HistoricalInterval []types.PerfInterval         `mo:"historicalInterval"`
    PerfCounter        []types.PerfCounterInfo      `mo:"perfCounter"`
}

func (PerformanceManager) Reference Uses

func (m PerformanceManager) Reference() types.ManagedObjectReference

type Profile Uses

type Profile struct {
    Self types.ManagedObjectReference

    Config           types.BaseProfileConfigInfo    `mo:"config"`
    Description      *types.ProfileDescription      `mo:"description"`
    Name             string                         `mo:"name"`
    CreatedTime      time.Time                      `mo:"createdTime"`
    ModifiedTime     time.Time                      `mo:"modifiedTime"`
    Entity           []types.ManagedObjectReference `mo:"entity"`
    ComplianceStatus string                         `mo:"complianceStatus"`
}

func (Profile) Reference Uses

func (m Profile) Reference() types.ManagedObjectReference

type ProfileComplianceManager Uses

type ProfileComplianceManager struct {
    Self types.ManagedObjectReference
}

func (ProfileComplianceManager) Reference Uses

func (m ProfileComplianceManager) Reference() types.ManagedObjectReference

type ProfileManager Uses

type ProfileManager struct {
    Self types.ManagedObjectReference

    Profile []types.ManagedObjectReference `mo:"profile"`
}

func (ProfileManager) Reference Uses

func (m ProfileManager) Reference() types.ManagedObjectReference

type PropertyCollector Uses

type PropertyCollector struct {
    Self types.ManagedObjectReference

    Filter []types.ManagedObjectReference `mo:"filter"`
}

func (PropertyCollector) Reference Uses

func (m PropertyCollector) Reference() types.ManagedObjectReference

type PropertyFilter Uses

type PropertyFilter struct {
    Self types.ManagedObjectReference

    Spec           types.PropertyFilterSpec `mo:"spec"`
    PartialUpdates bool                     `mo:"partialUpdates"`
}

func (PropertyFilter) Reference Uses

func (m PropertyFilter) Reference() types.ManagedObjectReference

type Reference Uses

type Reference interface {
    Reference() types.ManagedObjectReference
}

Reference is the interface that is implemented by all the managed objects defined in this package. It specifies that these managed objects have a function that returns the managed object reference to themselves.

type ResourcePlanningManager Uses

type ResourcePlanningManager struct {
    Self types.ManagedObjectReference
}

func (ResourcePlanningManager) Reference Uses

func (m ResourcePlanningManager) Reference() types.ManagedObjectReference

type ResourcePool Uses

type ResourcePool struct {
    ManagedEntity

    Summary            types.BaseResourcePoolSummary  `mo:"summary"`
    Runtime            types.ResourcePoolRuntimeInfo  `mo:"runtime"`
    Owner              types.ManagedObjectReference   `mo:"owner"`
    ResourcePool       []types.ManagedObjectReference `mo:"resourcePool"`
    Vm                 []types.ManagedObjectReference `mo:"vm"`
    Config             types.ResourceConfigSpec       `mo:"config"`
    ChildConfiguration []types.ResourceConfigSpec     `mo:"childConfiguration"`
}

func (*ResourcePool) Entity Uses

func (m *ResourcePool) Entity() *ManagedEntity

func (ResourcePool) GetManagedEntity Uses

func (m ResourcePool) GetManagedEntity() ManagedEntity

type ScheduledTask Uses

type ScheduledTask struct {
    ExtensibleManagedObject

    Info types.ScheduledTaskInfo `mo:"info"`
}

type ScheduledTaskManager Uses

type ScheduledTaskManager struct {
    Self types.ManagedObjectReference

    ScheduledTask []types.ManagedObjectReference `mo:"scheduledTask"`
    Description   types.ScheduledTaskDescription `mo:"description"`
}

func (ScheduledTaskManager) Reference Uses

func (m ScheduledTaskManager) Reference() types.ManagedObjectReference

type SearchIndex Uses

type SearchIndex struct {
    Self types.ManagedObjectReference
}

func (SearchIndex) Reference Uses

func (m SearchIndex) Reference() types.ManagedObjectReference

type ServiceInstance Uses

type ServiceInstance struct {
    Self types.ManagedObjectReference

    ServerClock time.Time            `mo:"serverClock"`
    Capability  types.Capability     `mo:"capability"`
    Content     types.ServiceContent `mo:"content"`
}

func (ServiceInstance) Reference Uses

func (m ServiceInstance) Reference() types.ManagedObjectReference

type ServiceManager Uses

type ServiceManager struct {
    Self types.ManagedObjectReference

    Service []types.ServiceManagerServiceInfo `mo:"service"`
}

func (ServiceManager) Reference Uses

func (m ServiceManager) Reference() types.ManagedObjectReference

type SessionManager Uses

type SessionManager struct {
    Self types.ManagedObjectReference

    SessionList         []types.UserSession `mo:"sessionList"`
    CurrentSession      *types.UserSession  `mo:"currentSession"`
    Message             *string             `mo:"message"`
    MessageLocaleList   []string            `mo:"messageLocaleList"`
    SupportedLocaleList []string            `mo:"supportedLocaleList"`
    DefaultLocale       string              `mo:"defaultLocale"`
}

func (SessionManager) Reference Uses

func (m SessionManager) Reference() types.ManagedObjectReference

type SimpleCommand Uses

type SimpleCommand struct {
    Self types.ManagedObjectReference

    EncodingType types.SimpleCommandEncoding     `mo:"encodingType"`
    Entity       types.ServiceManagerServiceInfo `mo:"entity"`
}

func (SimpleCommand) Reference Uses

func (m SimpleCommand) Reference() types.ManagedObjectReference

type StoragePod Uses

type StoragePod struct {
    Folder

    Summary            *types.StoragePodSummary  `mo:"summary"`
    PodStorageDrsEntry *types.PodStorageDrsEntry `mo:"podStorageDrsEntry"`
}

type StorageResourceManager Uses

type StorageResourceManager struct {
    Self types.ManagedObjectReference
}

func (StorageResourceManager) Reference Uses

func (m StorageResourceManager) Reference() types.ManagedObjectReference

type Task Uses

type Task struct {
    ExtensibleManagedObject

    Info types.TaskInfo `mo:"info"`
}

type TaskHistoryCollector Uses

type TaskHistoryCollector struct {
    HistoryCollector

    LatestPage []types.TaskInfo `mo:"latestPage"`
}

type TaskManager Uses

type TaskManager struct {
    Self types.ManagedObjectReference

    RecentTask   []types.ManagedObjectReference `mo:"recentTask"`
    Description  types.TaskDescription          `mo:"description"`
    MaxCollector int32                          `mo:"maxCollector"`
}

func (TaskManager) Reference Uses

func (m TaskManager) Reference() types.ManagedObjectReference

type UserDirectory Uses

type UserDirectory struct {
    Self types.ManagedObjectReference

    DomainList []string `mo:"domainList"`
}

func (UserDirectory) Reference Uses

func (m UserDirectory) Reference() types.ManagedObjectReference

type VStorageObjectManagerBase Uses

type VStorageObjectManagerBase struct {
    Self types.ManagedObjectReference
}

func (VStorageObjectManagerBase) Reference Uses

func (m VStorageObjectManagerBase) Reference() types.ManagedObjectReference

type VcenterVStorageObjectManager Uses

type VcenterVStorageObjectManager struct {
    VStorageObjectManagerBase
}

type View Uses

type View struct {
    Self types.ManagedObjectReference
}

func (View) Reference Uses

func (m View) Reference() types.ManagedObjectReference

type ViewManager Uses

type ViewManager struct {
    Self types.ManagedObjectReference

    ViewList []types.ManagedObjectReference `mo:"viewList"`
}

func (ViewManager) Reference Uses

func (m ViewManager) Reference() types.ManagedObjectReference

type VirtualApp Uses

type VirtualApp struct {
    ResourcePool

    ParentFolder *types.ManagedObjectReference  `mo:"parentFolder"`
    Datastore    []types.ManagedObjectReference `mo:"datastore"`
    Network      []types.ManagedObjectReference `mo:"network"`
    VAppConfig   *types.VAppConfigInfo          `mo:"vAppConfig"`
    ParentVApp   *types.ManagedObjectReference  `mo:"parentVApp"`
    ChildLink    []types.VirtualAppLinkInfo     `mo:"childLink"`
}

type VirtualDiskManager Uses

type VirtualDiskManager struct {
    Self types.ManagedObjectReference
}

func (VirtualDiskManager) Reference Uses

func (m VirtualDiskManager) Reference() types.ManagedObjectReference

type VirtualMachine Uses

type VirtualMachine struct {
    ManagedEntity

    Capability           types.VirtualMachineCapability    `mo:"capability"`
    Config               *types.VirtualMachineConfigInfo   `mo:"config"`
    Layout               *types.VirtualMachineFileLayout   `mo:"layout"`
    LayoutEx             *types.VirtualMachineFileLayoutEx `mo:"layoutEx"`
    Storage              *types.VirtualMachineStorageInfo  `mo:"storage"`
    EnvironmentBrowser   types.ManagedObjectReference      `mo:"environmentBrowser"`
    ResourcePool         *types.ManagedObjectReference     `mo:"resourcePool"`
    ParentVApp           *types.ManagedObjectReference     `mo:"parentVApp"`
    ResourceConfig       *types.ResourceConfigSpec         `mo:"resourceConfig"`
    Runtime              types.VirtualMachineRuntimeInfo   `mo:"runtime"`
    Guest                *types.GuestInfo                  `mo:"guest"`
    Summary              types.VirtualMachineSummary       `mo:"summary"`
    Datastore            []types.ManagedObjectReference    `mo:"datastore"`
    Network              []types.ManagedObjectReference    `mo:"network"`
    Snapshot             *types.VirtualMachineSnapshotInfo `mo:"snapshot"`
    RootSnapshot         []types.ManagedObjectReference    `mo:"rootSnapshot"`
    GuestHeartbeatStatus types.ManagedEntityStatus         `mo:"guestHeartbeatStatus"`
}

func (*VirtualMachine) Entity Uses

func (m *VirtualMachine) Entity() *ManagedEntity

func (VirtualMachine) GetManagedEntity Uses

func (m VirtualMachine) GetManagedEntity() ManagedEntity

type VirtualMachineCompatibilityChecker Uses

type VirtualMachineCompatibilityChecker struct {
    Self types.ManagedObjectReference
}

func (VirtualMachineCompatibilityChecker) Reference Uses

func (m VirtualMachineCompatibilityChecker) Reference() types.ManagedObjectReference

type VirtualMachineProvisioningChecker Uses

type VirtualMachineProvisioningChecker struct {
    Self types.ManagedObjectReference
}

func (VirtualMachineProvisioningChecker) Reference Uses

func (m VirtualMachineProvisioningChecker) Reference() types.ManagedObjectReference

type VirtualMachineSnapshot Uses

type VirtualMachineSnapshot struct {
    ExtensibleManagedObject

    Config        types.VirtualMachineConfigInfo `mo:"config"`
    ChildSnapshot []types.ManagedObjectReference `mo:"childSnapshot"`
    Vm            types.ManagedObjectReference   `mo:"vm"`
}

type VirtualizationManager Uses

type VirtualizationManager struct {
    Self types.ManagedObjectReference
}

func (VirtualizationManager) Reference Uses

func (m VirtualizationManager) Reference() types.ManagedObjectReference

type VmwareDistributedVirtualSwitch Uses

type VmwareDistributedVirtualSwitch struct {
    DistributedVirtualSwitch
}

type VsanUpgradeSystem Uses

type VsanUpgradeSystem struct {
    Self types.ManagedObjectReference
}

func (VsanUpgradeSystem) Reference Uses

func (m VsanUpgradeSystem) Reference() types.ManagedObjectReference

Package mo imports 10 packages (graph) and is imported by 167 packages. Updated 2017-04-20. Refresh now. Tools for package owners.