mo

package
v0.3.0 Latest Latest
Warning

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

 Go to latest Published: Jan 15, 2016 License: Apache-2.0 Imports: 10 Imported by: 2,610

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

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 

func (m AlarmManager) Reference() types.ManagedObjectReference

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 

func (m AuthorizationManager) Reference() types.ManagedObjectReference

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 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) 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 CustomFieldsManager 

type CustomFieldsManager struct {
	Self types.ManagedObjectReference

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

func (CustomFieldsManager) Reference 

func (m CustomFieldsManager) Reference() types.ManagedObjectReference

type CustomizationSpecManager 

type CustomizationSpecManager struct {
	Self types.ManagedObjectReference

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

func (CustomizationSpecManager) Reference 

func (m CustomizationSpecManager) Reference() types.ManagedObjectReference

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) 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) GetManagedEntity 

func (m Datastore) GetManagedEntity() ManagedEntity

type DatastoreNamespaceManager 

type DatastoreNamespaceManager struct {
	Self types.ManagedObjectReference
}

func (DatastoreNamespaceManager) Reference 

func (m DatastoreNamespaceManager) Reference() types.ManagedObjectReference

type DiagnosticManager 

type DiagnosticManager struct {
	Self types.ManagedObjectReference
}

func (DiagnosticManager) Reference 

func (m DiagnosticManager) Reference() types.ManagedObjectReference

type DistributedVirtualPortgroup 

type DistributedVirtualPortgroup struct {
	Network

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

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) GetManagedEntity 

func (m DistributedVirtualSwitch) GetManagedEntity() ManagedEntity

type DistributedVirtualSwitchManager 

type DistributedVirtualSwitchManager struct {
	Self types.ManagedObjectReference
}

func (DistributedVirtualSwitchManager) Reference 

func (m DistributedVirtualSwitchManager) Reference() types.ManagedObjectReference

type EnvironmentBrowser 

type EnvironmentBrowser struct {
	Self types.ManagedObjectReference

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

func (EnvironmentBrowser) Reference 

func (m EnvironmentBrowser) Reference() types.ManagedObjectReference

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 int                    `mo:"maxCollector"`
}

func (EventManager) Reference 

func (m EventManager) Reference() types.ManagedObjectReference

type ExtensibleManagedObject 

type ExtensibleManagedObject struct {
	Self types.ManagedObjectReference

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

func (ExtensibleManagedObject) Reference 

func (m ExtensibleManagedObject) Reference() types.ManagedObjectReference

type ExtensionManager 

type ExtensionManager struct {
	Self types.ManagedObjectReference

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

func (ExtensionManager) Reference 

func (m ExtensionManager) Reference() types.ManagedObjectReference

type FileManager 

type FileManager struct {
	Self types.ManagedObjectReference
}

func (FileManager) Reference 

func (m FileManager) Reference() types.ManagedObjectReference

type Folder 

type Folder struct {
	ManagedEntity

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

func (Folder) GetManagedEntity 

func (m Folder) GetManagedEntity() ManagedEntity

type GuestAuthManager 

type GuestAuthManager struct {
	Self types.ManagedObjectReference
}

func (GuestAuthManager) Reference 

func (m GuestAuthManager) Reference() types.ManagedObjectReference

type GuestFileManager 

type GuestFileManager struct {
	Self types.ManagedObjectReference
}

func (GuestFileManager) Reference 

func (m GuestFileManager) Reference() types.ManagedObjectReference

type GuestOperationsManager 

type GuestOperationsManager struct {
	Self types.ManagedObjectReference

	AuthManager    *types.ManagedObjectReference `mo:"authManager"`
	FileManager    *types.ManagedObjectReference `mo:"fileManager"`
	ProcessManager *types.ManagedObjectReference `mo:"processManager"`
}

func (GuestOperationsManager) Reference 

func (m GuestOperationsManager) Reference() types.ManagedObjectReference

type GuestProcessManager 

type GuestProcessManager struct {
	Self types.ManagedObjectReference
}

func (GuestProcessManager) Reference 

func (m GuestProcessManager) Reference() types.ManagedObjectReference

type HistoryCollector 

type HistoryCollector struct {
	Self types.ManagedObjectReference

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

func (HistoryCollector) Reference 

func (m HistoryCollector) Reference() types.ManagedObjectReference

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 

func (m HostAuthenticationManager) Reference() types.ManagedObjectReference

type HostAuthenticationStore 

type HostAuthenticationStore struct {
	Self types.ManagedObjectReference

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

func (HostAuthenticationStore) Reference 

func (m HostAuthenticationStore) Reference() types.ManagedObjectReference

type HostAutoStartManager 

type HostAutoStartManager struct {
	Self types.ManagedObjectReference

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

func (HostAutoStartManager) Reference 

func (m HostAutoStartManager) Reference() types.ManagedObjectReference

type HostBootDeviceSystem 

type HostBootDeviceSystem struct {
	Self types.ManagedObjectReference
}

func (HostBootDeviceSystem) Reference 

func (m HostBootDeviceSystem) Reference() types.ManagedObjectReference

type HostCacheConfigurationManager 

type HostCacheConfigurationManager struct {
	Self types.ManagedObjectReference

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

func (HostCacheConfigurationManager) Reference 

func (m HostCacheConfigurationManager) Reference() types.ManagedObjectReference

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 

func (m HostDatastoreBrowser) Reference() types.ManagedObjectReference

type HostDatastoreSystem 

type HostDatastoreSystem struct {
	Self types.ManagedObjectReference

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

func (HostDatastoreSystem) Reference 

func (m HostDatastoreSystem) Reference() types.ManagedObjectReference

type HostDateTimeSystem 

type HostDateTimeSystem struct {
	Self types.ManagedObjectReference

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

func (HostDateTimeSystem) Reference 

func (m HostDateTimeSystem) Reference() types.ManagedObjectReference

type HostDiagnosticSystem 

type HostDiagnosticSystem struct {
	Self types.ManagedObjectReference

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

func (HostDiagnosticSystem) Reference 

func (m HostDiagnosticSystem) Reference() types.ManagedObjectReference

type HostDirectoryStore 

type HostDirectoryStore struct {
	HostAuthenticationStore
}

type HostEsxAgentHostManager 

type HostEsxAgentHostManager struct {
	Self types.ManagedObjectReference

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

func (HostEsxAgentHostManager) Reference 

func (m HostEsxAgentHostManager) Reference() types.ManagedObjectReference

type HostFirewallSystem 

type HostFirewallSystem struct {
	ExtensibleManagedObject

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

type HostFirmwareSystem 

type HostFirmwareSystem struct {
	Self types.ManagedObjectReference
}

func (HostFirmwareSystem) Reference 

func (m HostFirmwareSystem) Reference() types.ManagedObjectReference

type HostGraphicsManager 

type HostGraphicsManager struct {
	ExtensibleManagedObject

	GraphicsInfo []types.HostGraphicsInfo `mo:"graphicsInfo"`
}

type HostHealthStatusSystem 

type HostHealthStatusSystem struct {
	Self types.ManagedObjectReference

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

func (HostHealthStatusSystem) Reference 

func (m HostHealthStatusSystem) Reference() types.ManagedObjectReference

type HostImageConfigManager 

type HostImageConfigManager struct {
	Self types.ManagedObjectReference
}

func (HostImageConfigManager) Reference 

func (m HostImageConfigManager) Reference() types.ManagedObjectReference

type HostKernelModuleSystem 

type HostKernelModuleSystem struct {
	Self types.ManagedObjectReference
}

func (HostKernelModuleSystem) Reference 

func (m HostKernelModuleSystem) Reference() types.ManagedObjectReference

type HostLocalAccountManager 

type HostLocalAccountManager struct {
	Self types.ManagedObjectReference
}

func (HostLocalAccountManager) Reference 

func (m HostLocalAccountManager) Reference() types.ManagedObjectReference

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 HostPatchManager 

type HostPatchManager struct {
	Self types.ManagedObjectReference
}

func (HostPatchManager) Reference 

func (m HostPatchManager) Reference() types.ManagedObjectReference

type HostPciPassthruSystem 

type HostPciPassthruSystem struct {
	ExtensibleManagedObject

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

type HostPowerSystem 

type HostPowerSystem struct {
	Self types.ManagedObjectReference

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

func (HostPowerSystem) Reference 

func (m HostPowerSystem) Reference() types.ManagedObjectReference

type HostProfile 

type HostProfile struct {
	Profile

	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 

func (m HostSnmpSystem) Reference() types.ManagedObjectReference

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"`
	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) GetManagedEntity 

func (m HostSystem) GetManagedEntity() ManagedEntity

type HostVFlashManager 

type HostVFlashManager struct {
	Self types.ManagedObjectReference

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

func (HostVFlashManager) Reference 

func (m HostVFlashManager) Reference() types.ManagedObjectReference

type HostVMotionSystem 

type HostVMotionSystem struct {
	ExtensibleManagedObject

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

type HostVirtualNicManager 

type HostVirtualNicManager struct {
	ExtensibleManagedObject

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

type HostVsanInternalSystem 

type HostVsanInternalSystem struct {
	Self types.ManagedObjectReference
}

func (HostVsanInternalSystem) Reference 

func (m HostVsanInternalSystem) Reference() types.ManagedObjectReference

type HostVsanSystem 

type HostVsanSystem struct {
	Self types.ManagedObjectReference

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

func (HostVsanSystem) Reference 

func (m HostVsanSystem) Reference() types.ManagedObjectReference

type HttpNfcLease 

type HttpNfcLease struct {
	Self types.ManagedObjectReference

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

func (HttpNfcLease) Reference 

func (m HttpNfcLease) Reference() types.ManagedObjectReference

type InternalDynamicTypeManager 

type InternalDynamicTypeManager struct {
	Self types.ManagedObjectReference
}

func (InternalDynamicTypeManager) Reference 

func (m InternalDynamicTypeManager) Reference() types.ManagedObjectReference

type InventoryView 

type InventoryView struct {
	ManagedObjectView
}

type IpPoolManager 

type IpPoolManager struct {
	Self types.ManagedObjectReference
}

func (IpPoolManager) Reference 

func (m IpPoolManager) Reference() types.ManagedObjectReference

type IsManagedEntity 

type IsManagedEntity interface {
	GetManagedEntity() ManagedEntity
}

type IscsiManager 

type IscsiManager struct {
	Self types.ManagedObjectReference
}

func (IscsiManager) Reference 

func (m IscsiManager) Reference() types.ManagedObjectReference

type LicenseAssignmentManager 

type LicenseAssignmentManager struct {
	Self types.ManagedObjectReference
}

func (LicenseAssignmentManager) Reference 

func (m LicenseAssignmentManager) Reference() types.ManagedObjectReference

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 

func (m LicenseManager) Reference() types.ManagedObjectReference

type ListView 

type ListView struct {
	ManagedObjectView
}

type LocalizationManager 

type LocalizationManager struct {
	Self types.ManagedObjectReference

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

func (LocalizationManager) Reference 

func (m LocalizationManager) Reference() types.ManagedObjectReference

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       []int                          `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 

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 

type ManagedObjectView struct {
	Self types.ManagedObjectReference

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

func (ManagedObjectView) Reference 

func (m ManagedObjectView) Reference() types.ManagedObjectReference

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) GetManagedEntity 

func (m Network) GetManagedEntity() ManagedEntity

type OpaqueNetwork 

type OpaqueNetwork struct {
	Network
}

type OptionManager 

type OptionManager struct {
	Self types.ManagedObjectReference

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

func (OptionManager) Reference 

func (m OptionManager) Reference() types.ManagedObjectReference

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 

func (m PerformanceManager) Reference() types.ManagedObjectReference

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 

func (m ProfileComplianceManager) Reference() types.ManagedObjectReference

type ProfileManager 

type ProfileManager struct {
	Self types.ManagedObjectReference

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

func (ProfileManager) Reference 

func (m ProfileManager) Reference() types.ManagedObjectReference

type PropertyCollector 

type PropertyCollector struct {
	Self types.ManagedObjectReference

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

func (PropertyCollector) Reference 

func (m PropertyCollector) Reference() types.ManagedObjectReference

type PropertyFilter 

type PropertyFilter struct {
	Self types.ManagedObjectReference

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

func (PropertyFilter) Reference 

func (m PropertyFilter) Reference() types.ManagedObjectReference

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 ReflectManagedMethodExecuter 

type ReflectManagedMethodExecuter struct {
	Self types.ManagedObjectReference
}

func (ReflectManagedMethodExecuter) Reference 

func (m ReflectManagedMethodExecuter) Reference() types.ManagedObjectReference

type ResourcePlanningManager 

type ResourcePlanningManager struct {
	Self types.ManagedObjectReference
}

func (ResourcePlanningManager) Reference 

func (m ResourcePlanningManager) Reference() types.ManagedObjectReference

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

func (m ScheduledTaskManager) Reference() types.ManagedObjectReference

type SearchIndex 

type SearchIndex struct {
	Self types.ManagedObjectReference
}

func (SearchIndex) Reference 

func (m SearchIndex) Reference() types.ManagedObjectReference

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 

func (m ServiceInstance) Reference() types.ManagedObjectReference

type ServiceManager 

type ServiceManager struct {
	Self types.ManagedObjectReference

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

func (ServiceManager) Reference 

func (m ServiceManager) Reference() types.ManagedObjectReference

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 

func (m SessionManager) Reference() types.ManagedObjectReference

type SimpleCommand 

type SimpleCommand struct {
	Self types.ManagedObjectReference

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

func (SimpleCommand) Reference 

func (m SimpleCommand) Reference() types.ManagedObjectReference

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 

func (m StorageResourceManager) Reference() types.ManagedObjectReference

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 int                            `mo:"maxCollector"`
}

func (TaskManager) Reference 

func (m TaskManager) Reference() types.ManagedObjectReference

type UserDirectory 

type UserDirectory struct {
	Self types.ManagedObjectReference

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

func (UserDirectory) Reference 

func (m UserDirectory) Reference() types.ManagedObjectReference

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 

func (m ViewManager) Reference() types.ManagedObjectReference

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 

func (m VirtualDiskManager) Reference() types.ManagedObjectReference

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) GetManagedEntity 

func (m VirtualMachine) GetManagedEntity() ManagedEntity

type VirtualMachineCompatibilityChecker 

type VirtualMachineCompatibilityChecker struct {
	Self types.ManagedObjectReference
}

func (VirtualMachineCompatibilityChecker) Reference 

func (m VirtualMachineCompatibilityChecker) Reference() types.ManagedObjectReference

type VirtualMachineProvisioningChecker 

type VirtualMachineProvisioningChecker struct {
	Self types.ManagedObjectReference
}

func (VirtualMachineProvisioningChecker) Reference 

func (m VirtualMachineProvisioningChecker) Reference() types.ManagedObjectReference

type VirtualMachineSnapshot 

type VirtualMachineSnapshot struct {
	ExtensibleManagedObject

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

type VirtualizationManager 

type VirtualizationManager struct {
	Self types.ManagedObjectReference
}

func (VirtualizationManager) Reference 

func (m VirtualizationManager) Reference() types.ManagedObjectReference

type VmwareDistributedVirtualSwitch 

type VmwareDistributedVirtualSwitch struct {
	DistributedVirtualSwitch
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.