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 ApplyPropertyChange Uses

func ApplyPropertyChange(obj Reference, changes []types.PropertyChange)

ApplyPropertyChange converts the response of a call to WaitForUpdates and applies it to the given managed object.

func LoadObjectContent Uses

func LoadObjectContent(content []types.ObjectContent, dst interface{}) error

LoadObjectContent converts the response of a call to RetrieveProperties{Ex} to one or more managed objects.

func ObjectContentToType Uses

func ObjectContentToType(o types.ObjectContent, ptr ...bool) (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 References Uses

func References(s interface{}, follow ...bool) []types.ManagedObjectReference

References returns all non-nil moref field values in the given struct. Only Anonymous struct fields are followed by default. The optional follow param will follow any struct fields when true.

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"`
    HciConfig         *types.ClusterComputeResourceHCIConfigInfo `mo:"hciConfig"`
    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 CryptoManagerHost Uses

type CryptoManagerHost struct {
    CryptoManager
}

type CryptoManagerHostKMS Uses

type CryptoManagerHostKMS struct {
    CryptoManagerHost
}

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"`
    SharedGpuCapabilities  []types.HostSharedGpuCapabilities `mo:"sharedGpuCapabilities"`
}

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 HostNvdimmSystem Uses

type HostNvdimmSystem struct {
    Self types.ManagedObjectReference

    NvdimmSystemInfo types.NvdimmSystemInfo `mo:"nvdimmSystemInfo"`
}

func (HostNvdimmSystem) Reference Uses

func (m HostNvdimmSystem) Reference() types.ManagedObjectReference

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

    ValidationState           *string                                 `mo:"validationState"`
    ValidationStateUpdateTime *time.Time                              `mo:"validationStateUpdateTime"`
    ValidationFailureInfo     *types.HostProfileValidationFailureInfo `mo:"validationFailureInfo"`
    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"`
    RemediationState           *types.HostSystemRemediationState          `mo:"remediationState"`
    PrecheckRemediationResult  *types.ApplyHostProfileConfigurationSpec   `mo:"precheckRemediationResult"`
    RemediationResult          *types.ApplyHostProfileConfigurationResult `mo:"remediationResult"`
    ComplianceCheckState       *types.HostSystemComplianceCheckState      `mo:"complianceCheckState"`
    ComplianceCheckResult      *types.ComplianceResult                    `mo:"complianceCheckResult"`
    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"`
    AnswerFileValidationState  *types.AnswerFileStatusResult              `mo:"answerFileValidationState"`
    AnswerFileValidationResult *types.AnswerFileStatusResult              `mo:"answerFileValidationResult"`
}

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"`
    TransferProgress   int32                          `mo:"transferProgress"`
    Mode               string                         `mo:"mode"`
    Capabilities       types.HttpNfcLeaseCapabilities `mo:"capabilities"`
    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"`
}

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.

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 1138 packages. Updated 2019-10-24. Refresh now. Tools for package owners.