mo

package
v0.0.0-...-dbc992d Latest Latest
Warning

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

Go to latest
Published: Nov 18, 2014 License: Apache-2.0 Imports: 9 Imported by: 0

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 RetrieveProperties

func RetrieveProperties(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(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 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

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

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"`
}

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

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

func (m Folder) GetManagedEntity() ManagedEntity

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"`
}

func (GuestOperationsManager) Reference

type GuestProcessManager

type GuestProcessManager struct {
	Self types.ManagedObjectReference
}

func (GuestProcessManager) Reference

type HistoryCollector

type HistoryCollector struct {
	Self types.ManagedObjectReference

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

func (HistoryCollector) 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 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"`
}

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 HostPatchManager

type HostPatchManager struct {
	Self types.ManagedObjectReference
}

func (HostPatchManager) Reference

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

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

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

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

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 int                         `mo:"initializeProgress"`
	Info               *types.HttpNfcLeaseInfo     `mo:"info"`
	State              types.HttpNfcLeaseState     `mo:"state"`
	Error              *types.LocalizedMethodFault `mo:"error"`
}

func (HttpNfcLease) Reference

type InternalDynamicTypeManager

type InternalDynamicTypeManager struct {
	Self types.ManagedObjectReference
}

func (InternalDynamicTypeManager) Reference

type InventoryView

type InventoryView struct {
	ManagedObjectView
}

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       []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"`
}

type ManagedObjectView

type ManagedObjectView struct {
	Self types.ManagedObjectReference

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

func (ManagedObjectView) 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) 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

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 ReflectManagedMethodExecuter

type ReflectManagedMethodExecuter struct {
	Self types.ManagedObjectReference
}

func (ReflectManagedMethodExecuter) Reference

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

func (TaskManager) Reference

type UserDirectory

type UserDirectory struct {
	Self types.ManagedObjectReference

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

func (UserDirectory) Reference

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

type VirtualizationManager

type VirtualizationManager struct {
	Self types.ManagedObjectReference
}

func (VirtualizationManager) Reference

type VmwareDistributedVirtualSwitch

type VmwareDistributedVirtualSwitch struct {
	DistributedVirtualSwitch
}

Jump to

Keyboard shortcuts

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