mo

package
v0.0.0-...-29a6359 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 15, 2019 License: Apache-2.0 Imports: 10 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ApplyPropertyChange

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 LoadRetrievePropertiesResponse

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

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

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

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.

Types

type Alarm

type Alarm struct {
	ExtensibleManagedObject

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

type AlarmManager

type AlarmManager struct {
	Self types.ManagedObjectReference

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

func (AlarmManager) Reference

type AuthorizationManager

type AuthorizationManager struct {
	Self types.ManagedObjectReference

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

func (AuthorizationManager) Reference

type CertificateManager

type CertificateManager struct {
	Self types.ManagedObjectReference
}

func (CertificateManager) Reference

type ClusterComputeResource

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

type ClusterEVCManager struct {
	ExtensibleManagedObject

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

type ClusterProfile

type ClusterProfile struct {
	Profile
}

type ClusterProfileManager

type ClusterProfileManager struct {
	ProfileManager
}

type ComputeResource

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

func (m *ComputeResource) Entity() *ManagedEntity

func (ComputeResource) GetManagedEntity

func (m ComputeResource) GetManagedEntity() ManagedEntity

type ContainerView

type ContainerView struct {
	ManagedObjectView

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

type CryptoManager

type CryptoManager struct {
	Self types.ManagedObjectReference

	Enabled bool `mo:"enabled"`
}

func (CryptoManager) Reference

type CryptoManagerHost

type CryptoManagerHost struct {
	CryptoManager
}

type CryptoManagerHostKMS

type CryptoManagerHostKMS struct {
	CryptoManagerHost
}

type CryptoManagerKmip

type CryptoManagerKmip struct {
	CryptoManager

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

type CustomFieldsManager

type CustomFieldsManager struct {
	Self types.ManagedObjectReference

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

func (CustomFieldsManager) Reference

type CustomizationSpecManager

type CustomizationSpecManager struct {
	Self types.ManagedObjectReference

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

func (CustomizationSpecManager) Reference

type Datacenter

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

func (m *Datacenter) Entity() *ManagedEntity

func (Datacenter) GetManagedEntity

func (m Datacenter) GetManagedEntity() ManagedEntity

type Datastore

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

func (m *Datastore) Entity() *ManagedEntity

func (Datastore) GetManagedEntity

func (m Datastore) GetManagedEntity() ManagedEntity

type DatastoreNamespaceManager

type DatastoreNamespaceManager struct {
	Self types.ManagedObjectReference
}

func (DatastoreNamespaceManager) Reference

type DiagnosticManager

type DiagnosticManager struct {
	Self types.ManagedObjectReference
}

func (DiagnosticManager) Reference

type DistributedVirtualPortgroup

type DistributedVirtualPortgroup struct {
	Network

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

func (DistributedVirtualPortgroup) GetManagedEntity

func (m DistributedVirtualPortgroup) GetManagedEntity() ManagedEntity

type DistributedVirtualSwitch

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

func (DistributedVirtualSwitch) GetManagedEntity

func (m DistributedVirtualSwitch) GetManagedEntity() ManagedEntity

type DistributedVirtualSwitchManager

type DistributedVirtualSwitchManager struct {
	Self types.ManagedObjectReference
}

func (DistributedVirtualSwitchManager) Reference

type Entity

type Entity interface {
	Reference
	Entity() *ManagedEntity
}

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

type EnvironmentBrowser

type EnvironmentBrowser struct {
	Self types.ManagedObjectReference

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

func (EnvironmentBrowser) Reference

type EventHistoryCollector

type EventHistoryCollector struct {
	HistoryCollector

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

type EventManager

type EventManager struct {
	Self types.ManagedObjectReference

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

func (EventManager) Reference

type ExtensibleManagedObject

type ExtensibleManagedObject struct {
	Self types.ManagedObjectReference

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

func (ExtensibleManagedObject) Reference

type ExtensionManager

type ExtensionManager struct {
	Self types.ManagedObjectReference

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

func (ExtensionManager) Reference

type FailoverClusterConfigurator

type FailoverClusterConfigurator struct {
	Self types.ManagedObjectReference

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

func (FailoverClusterConfigurator) Reference

type FailoverClusterManager

type FailoverClusterManager struct {
	Self types.ManagedObjectReference

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

func (FailoverClusterManager) Reference

type FileManager

type FileManager struct {
	Self types.ManagedObjectReference
}

func (FileManager) Reference

type Folder

type Folder struct {
	ManagedEntity

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

func (*Folder) Entity

func (m *Folder) Entity() *ManagedEntity

func (Folder) GetManagedEntity

func (m Folder) GetManagedEntity() ManagedEntity

type GuestAliasManager

type GuestAliasManager struct {
	Self types.ManagedObjectReference
}

func (GuestAliasManager) Reference

type GuestAuthManager

type GuestAuthManager struct {
	Self types.ManagedObjectReference
}

func (GuestAuthManager) Reference

type GuestFileManager

type GuestFileManager struct {
	Self types.ManagedObjectReference
}

func (GuestFileManager) Reference

type GuestOperationsManager

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

type GuestProcessManager

type GuestProcessManager struct {
	Self types.ManagedObjectReference
}

func (GuestProcessManager) Reference

type GuestWindowsRegistryManager

type GuestWindowsRegistryManager struct {
	Self types.ManagedObjectReference
}

func (GuestWindowsRegistryManager) Reference

type HealthUpdateManager

type HealthUpdateManager struct {
	Self types.ManagedObjectReference
}

func (HealthUpdateManager) Reference

type HistoryCollector

type HistoryCollector struct {
	Self types.ManagedObjectReference

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

func (HistoryCollector) Reference

type HostAccessManager

type HostAccessManager struct {
	Self types.ManagedObjectReference

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

func (HostAccessManager) Reference

type HostActiveDirectoryAuthentication

type HostActiveDirectoryAuthentication struct {
	HostDirectoryStore
}

type HostAuthenticationManager

type HostAuthenticationManager struct {
	Self types.ManagedObjectReference

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

func (HostAuthenticationManager) Reference

type HostAuthenticationStore

type HostAuthenticationStore struct {
	Self types.ManagedObjectReference

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

func (HostAuthenticationStore) Reference

type HostAutoStartManager

type HostAutoStartManager struct {
	Self types.ManagedObjectReference

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

func (HostAutoStartManager) Reference

type HostBootDeviceSystem

type HostBootDeviceSystem struct {
	Self types.ManagedObjectReference
}

func (HostBootDeviceSystem) Reference

type HostCacheConfigurationManager

type HostCacheConfigurationManager struct {
	Self types.ManagedObjectReference

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

func (HostCacheConfigurationManager) Reference

type HostCertificateManager

type HostCertificateManager struct {
	Self types.ManagedObjectReference

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

func (HostCertificateManager) Reference

type HostCpuSchedulerSystem

type HostCpuSchedulerSystem struct {
	ExtensibleManagedObject

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

type HostDatastoreBrowser

type HostDatastoreBrowser struct {
	Self types.ManagedObjectReference

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

func (HostDatastoreBrowser) Reference

type HostDatastoreSystem

type HostDatastoreSystem struct {
	Self types.ManagedObjectReference

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

func (HostDatastoreSystem) Reference

type HostDateTimeSystem

type HostDateTimeSystem struct {
	Self types.ManagedObjectReference

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

func (HostDateTimeSystem) Reference

type HostDiagnosticSystem

type HostDiagnosticSystem struct {
	Self types.ManagedObjectReference

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

func (HostDiagnosticSystem) Reference

type HostDirectoryStore

type HostDirectoryStore struct {
	HostAuthenticationStore
}

type HostEsxAgentHostManager

type HostEsxAgentHostManager struct {
	Self types.ManagedObjectReference

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

func (HostEsxAgentHostManager) Reference

type HostFirewallSystem

type HostFirewallSystem struct {
	ExtensibleManagedObject

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

type HostFirmwareSystem

type HostFirmwareSystem struct {
	Self types.ManagedObjectReference
}

func (HostFirmwareSystem) Reference

type HostGraphicsManager

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

type HostHealthStatusSystem struct {
	Self types.ManagedObjectReference

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

func (HostHealthStatusSystem) Reference

type HostImageConfigManager

type HostImageConfigManager struct {
	Self types.ManagedObjectReference
}

func (HostImageConfigManager) Reference

type HostKernelModuleSystem

type HostKernelModuleSystem struct {
	Self types.ManagedObjectReference
}

func (HostKernelModuleSystem) Reference

type HostLocalAccountManager

type HostLocalAccountManager struct {
	Self types.ManagedObjectReference
}

func (HostLocalAccountManager) Reference

type HostLocalAuthentication

type HostLocalAuthentication struct {
	HostAuthenticationStore
}

type HostMemorySystem

type HostMemorySystem struct {
	ExtensibleManagedObject

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

type HostNetworkSystem

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

type HostNvdimmSystem struct {
	Self types.ManagedObjectReference

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

func (HostNvdimmSystem) Reference

type HostPatchManager

type HostPatchManager struct {
	Self types.ManagedObjectReference
}

func (HostPatchManager) Reference

type HostPciPassthruSystem

type HostPciPassthruSystem struct {
	ExtensibleManagedObject

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

type HostPowerSystem

type HostPowerSystem struct {
	Self types.ManagedObjectReference

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

func (HostPowerSystem) Reference

type HostProfile

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

type HostProfileManager struct {
	ProfileManager
}

type HostServiceSystem

type HostServiceSystem struct {
	ExtensibleManagedObject

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

type HostSnmpSystem

type HostSnmpSystem struct {
	Self types.ManagedObjectReference

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

func (HostSnmpSystem) Reference

type HostSpecificationManager

type HostSpecificationManager struct {
	Self types.ManagedObjectReference
}

func (HostSpecificationManager) Reference

type HostStorageSystem

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

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

func (m *HostSystem) Entity() *ManagedEntity

func (HostSystem) GetManagedEntity

func (m HostSystem) GetManagedEntity() ManagedEntity

type HostVFlashManager

type HostVFlashManager struct {
	Self types.ManagedObjectReference

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

func (HostVFlashManager) Reference

type HostVMotionSystem

type HostVMotionSystem struct {
	ExtensibleManagedObject

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

type HostVStorageObjectManager

type HostVStorageObjectManager struct {
	VStorageObjectManagerBase
}

type HostVirtualNicManager

type HostVirtualNicManager struct {
	ExtensibleManagedObject

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

type HostVsanInternalSystem

type HostVsanInternalSystem struct {
	Self types.ManagedObjectReference
}

func (HostVsanInternalSystem) Reference

type HostVsanSystem

type HostVsanSystem struct {
	Self types.ManagedObjectReference

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

func (HostVsanSystem) Reference

type HttpNfcLease

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

type InventoryView

type InventoryView struct {
	ManagedObjectView
}

type IoFilterManager

type IoFilterManager struct {
	Self types.ManagedObjectReference
}

func (IoFilterManager) Reference

type IpPoolManager

type IpPoolManager struct {
	Self types.ManagedObjectReference
}

func (IpPoolManager) Reference

type IsManagedEntity

type IsManagedEntity interface {
	GetManagedEntity() ManagedEntity
}

type IscsiManager

type IscsiManager struct {
	Self types.ManagedObjectReference
}

func (IscsiManager) Reference

type LicenseAssignmentManager

type LicenseAssignmentManager struct {
	Self types.ManagedObjectReference
}

func (LicenseAssignmentManager) Reference

type LicenseManager

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

type ListView

type ListView struct {
	ManagedObjectView
}

type LocalizationManager

type LocalizationManager struct {
	Self types.ManagedObjectReference

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

func (LocalizationManager) Reference

type ManagedEntity

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

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

type ManagedObjectView struct {
	Self types.ManagedObjectReference

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

func (ManagedObjectView) Reference

type MessageBusProxy

type MessageBusProxy struct {
	Self types.ManagedObjectReference
}

func (MessageBusProxy) Reference

type Network

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

func (m *Network) Entity() *ManagedEntity

func (Network) GetManagedEntity

func (m Network) GetManagedEntity() ManagedEntity

type OpaqueNetwork

type OpaqueNetwork struct {
	Network

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

type OptionManager

type OptionManager struct {
	Self types.ManagedObjectReference

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

func (OptionManager) Reference

type OverheadMemoryManager

type OverheadMemoryManager struct {
	Self types.ManagedObjectReference
}

func (OverheadMemoryManager) Reference

type OvfManager

type OvfManager struct {
	Self types.ManagedObjectReference

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

func (OvfManager) Reference

func (m OvfManager) Reference() types.ManagedObjectReference

type PerformanceManager

type PerformanceManager struct {
	Self types.ManagedObjectReference

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

func (PerformanceManager) Reference

type Profile

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

func (m Profile) Reference() types.ManagedObjectReference

type ProfileComplianceManager

type ProfileComplianceManager struct {
	Self types.ManagedObjectReference
}

func (ProfileComplianceManager) Reference

type ProfileManager

type ProfileManager struct {
	Self types.ManagedObjectReference

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

func (ProfileManager) Reference

type PropertyCollector

type PropertyCollector struct {
	Self types.ManagedObjectReference

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

func (PropertyCollector) Reference

type PropertyFilter

type PropertyFilter struct {
	Self types.ManagedObjectReference

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

func (PropertyFilter) Reference

type Reference

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

type ResourcePlanningManager struct {
	Self types.ManagedObjectReference
}

func (ResourcePlanningManager) Reference

type ResourcePool

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

func (m *ResourcePool) Entity() *ManagedEntity

func (ResourcePool) GetManagedEntity

func (m ResourcePool) GetManagedEntity() ManagedEntity

type ScheduledTask

type ScheduledTask struct {
	ExtensibleManagedObject

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

type ScheduledTaskManager

type ScheduledTaskManager struct {
	Self types.ManagedObjectReference

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

func (ScheduledTaskManager) Reference

type SearchIndex

type SearchIndex struct {
	Self types.ManagedObjectReference
}

func (SearchIndex) Reference

type ServiceInstance

type ServiceInstance struct {
	Self types.ManagedObjectReference

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

func (ServiceInstance) Reference

type ServiceManager

type ServiceManager struct {
	Self types.ManagedObjectReference

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

func (ServiceManager) Reference

type SessionManager

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

type SimpleCommand

type SimpleCommand struct {
	Self types.ManagedObjectReference

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

func (SimpleCommand) Reference

type StoragePod

type StoragePod struct {
	Folder

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

type StorageResourceManager

type StorageResourceManager struct {
	Self types.ManagedObjectReference
}

func (StorageResourceManager) Reference

type Task

type Task struct {
	ExtensibleManagedObject

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

type TaskHistoryCollector

type TaskHistoryCollector struct {
	HistoryCollector

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

type TaskManager

type TaskManager struct {
	Self types.ManagedObjectReference

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

func (TaskManager) Reference

type UserDirectory

type UserDirectory struct {
	Self types.ManagedObjectReference

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

func (UserDirectory) Reference

type VStorageObjectManagerBase

type VStorageObjectManagerBase struct {
	Self types.ManagedObjectReference
}

func (VStorageObjectManagerBase) Reference

type VcenterVStorageObjectManager

type VcenterVStorageObjectManager struct {
	VStorageObjectManagerBase
}

type View

type View struct {
	Self types.ManagedObjectReference
}

func (View) Reference

func (m View) Reference() types.ManagedObjectReference

type ViewManager

type ViewManager struct {
	Self types.ManagedObjectReference

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

func (ViewManager) Reference

type VirtualApp

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

type VirtualDiskManager struct {
	Self types.ManagedObjectReference
}

func (VirtualDiskManager) Reference

type VirtualMachine

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

func (m *VirtualMachine) Entity() *ManagedEntity

func (VirtualMachine) GetManagedEntity

func (m VirtualMachine) GetManagedEntity() ManagedEntity

type VirtualMachineCompatibilityChecker

type VirtualMachineCompatibilityChecker struct {
	Self types.ManagedObjectReference
}

func (VirtualMachineCompatibilityChecker) Reference

type VirtualMachineProvisioningChecker

type VirtualMachineProvisioningChecker struct {
	Self types.ManagedObjectReference
}

func (VirtualMachineProvisioningChecker) Reference

type VirtualMachineSnapshot

type VirtualMachineSnapshot struct {
	ExtensibleManagedObject

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

type VirtualizationManager

type VirtualizationManager struct {
	Self types.ManagedObjectReference
}

func (VirtualizationManager) Reference

type VmwareDistributedVirtualSwitch

type VmwareDistributedVirtualSwitch struct {
	DistributedVirtualSwitch
}

type VsanUpgradeSystem

type VsanUpgradeSystem struct {
	Self types.ManagedObjectReference
}

func (VsanUpgradeSystem) Reference

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL