types

package
v0.34.0 Latest Latest
Warning

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

 Go to latest Published: Dec 12, 2023 License: Apache-2.0 Imports: 3 Imported by: 8

Documentation

Index

Constants

View Source 
const (
	// Denotes no specific VM anti-affinity policy.
	AgencyVMPlacementPolicyVMAntiAffinityNone = AgencyVMPlacementPolicyVMAntiAffinity("none")
	// Best effort is made the VMs to run on different hosts as long as
	// this does not impact the ability of the host to satisfy current CPU
	// or memory requirements for virtual machines on the system.
	//
	// NOTE: Currently not supported - i.e. the agency configuration is
	// considered as invalid.
	AgencyVMPlacementPolicyVMAntiAffinitySoft = AgencyVMPlacementPolicyVMAntiAffinity("soft")
)
View Source 
const (
	// Denotes no specific VM data affinity policy.
	AgencyVMPlacementPolicyVMDataAffinityNone = AgencyVMPlacementPolicyVMDataAffinity("none")
	// Best effort is made the VM to run on the same host it is deployed on
	// as long as this does not impact the ability of the host to satisfy
	// current CPU or memory requirements for virtual machines on the
	// system.
	//
	// NOTE: Currently not supported - i.e. the agency configuration is
	// considered as invalid.
	AgencyVMPlacementPolicyVMDataAffinitySoft = AgencyVMPlacementPolicyVMDataAffinity("soft")
)
View Source 
const (
	// Denotes no specific type for disk provisioning.
	//
	// Disks will be
	// provisioned as defaulted by vSphere.
	AgentConfigInfoOvfDiskProvisioningNone = AgentConfigInfoOvfDiskProvisioning("none")
	// Disks will be provisioned with only used space allocated.
	AgentConfigInfoOvfDiskProvisioningThin = AgentConfigInfoOvfDiskProvisioning("thin")
	// Disks will be provisioned with full size allocated.
	AgentConfigInfoOvfDiskProvisioningThick = AgentConfigInfoOvfDiskProvisioning("thick")
)
View Source 
const (
	// The VM is provisioned and not powered-on.
	AgentVmHookVmStateProvisioned = AgentVmHookVmState("provisioned")
	// The VM is powered on.
	AgentVmHookVmStatePoweredOn = AgentVmHookVmState("poweredOn")
	// The VM is about to be powered on as part of a VM upgrade workflow.
	AgentVmHookVmStatePrePowerOn = AgentVmHookVmState("prePowerOn")
)
View Source 
const (
	// The entity should be fully deployed and active.
	//
	// If the entity is an
	// `Agency`, it should install VIBs and deploy and power on all agent
	// virtual machines. If the entity is an `Agent`, its VIB should be installed and its
	// agent virtual machine should be deployed and powered on.
	EamObjectRuntimeInfoGoalStateEnabled = EamObjectRuntimeInfoGoalState("enabled")
	// The entity should be fully deployed but inactive.
	//
	// f the entity is an
	// `Agency`, the behavior is similar to the <code>enabled</code> goal state, but
	// agents are not powered on (if they have been powered on they are powered
	// off).
	EamObjectRuntimeInfoGoalStateDisabled = EamObjectRuntimeInfoGoalState("disabled")
	// The entity should be completely removed from the vCenter Server.
	//
	// If the entity is an
	// `Agency`, no more VIBs or agent virtual machines are deployed. All installed VIBs
	// installed by the `Agency` are uninstalled and any deployed agent virtual machines
	// are powered off (if they have been powered on) and deleted.
	// If the entity is an `Agent`, its VIB is uninstalled and the virtual machine is
	// powered off and deleted.
	EamObjectRuntimeInfoGoalStateUninstalled = EamObjectRuntimeInfoGoalState("uninstalled")
)
View Source 
const (
	// The entity is in perfect compliance with the goal state.
	EamObjectRuntimeInfoStatusGreen = EamObjectRuntimeInfoStatus("green")
	// The entity is actively working to reach the desired goal state.
	EamObjectRuntimeInfoStatusYellow = EamObjectRuntimeInfoStatus("yellow")
	// The entity has reached an issue which prevents it from reaching the desired goal
	// state.
	//
	// To remediate any offending issues, look at `EamObjectRuntimeInfo.issue`
	// and use either `EamObject.Resolve` or
	// `EamObject.ResolveAll`.
	EamObjectRuntimeInfoStatusRed = EamObjectRuntimeInfoStatus("red")
)
View Source 
const (
	// Only a single host at a time will be put into maintenance mode.
	EsxAgentManagerMaintenanceModePolicySingleHost = EsxAgentManagerMaintenanceModePolicy("singleHost")
	// Hosts will be put into maintenance mode simultaneously.
	//
	// If vSphere DRS
	// is enabled, its recommendations will be used. Otherwise, it will be
	// attempted to put in maintenance mode simultaneously as many host as
	// possible.
	EsxAgentManagerMaintenanceModePolicyMultipleHosts = EsxAgentManagerMaintenanceModePolicy("multipleHosts")
)
View Source 
const (
	// Hook raised for an agent immediately after a Virtual Machine was
	// created.
	HooksHookTypePOST_PROVISIONING = HooksHookType("POST_PROVISIONING")
	// Hook raised for an agent immediately after a Virtual Machine was
	// powered on.
	HooksHookTypePOST_POWER_ON = HooksHookType("POST_POWER_ON")
)
View Source 
const (
	// The OVF descriptor provided in the VM source is invalid.
	SolutionsInvalidReasonINVALID_OVF_DESCRIPTOR = SolutionsInvalidReason("INVALID_OVF_DESCRIPTOR")
	// The provided VM source is inaccessible from ESX Agent Manager.
	SolutionsInvalidReasonINACCESSBLE_VM_SOURCE = SolutionsInvalidReason("INACCESSBLE_VM_SOURCE")
	// The provided networks are not suitable for application purposes.
	SolutionsInvalidReasonINVALID_NETWORKS = SolutionsInvalidReason("INVALID_NETWORKS")
	// The provided datastores are not suitable for application purposes.
	SolutionsInvalidReasonINVALID_DATASTORES = SolutionsInvalidReason("INVALID_DATASTORES")
	// The provided resource pool is not accessible or part of the cluster.
	SolutionsInvalidReasonINVALID_RESOURCE_POOL = SolutionsInvalidReason("INVALID_RESOURCE_POOL")
	// The provided folder is inaccessible or not part of the same datacenter
	// with the cluster.
	SolutionsInvalidReasonINVALID_FOLDER = SolutionsInvalidReason("INVALID_FOLDER")
	// The provided OVF properties are insufficient to satisfy the required
	// user configurable properties in the VM described in the vmSource.
	SolutionsInvalidReasonINVALID_PROPERTIES = SolutionsInvalidReason("INVALID_PROPERTIES")
	// The legacy agency requested for transition is not valid/cannot be
	// mapped to systm Virtual Machines solution.
	SolutionsInvalidReasonINVALID_TRANSITION = SolutionsInvalidReason("INVALID_TRANSITION")
)
View Source 
const (
	// There is ongoing work to acheive the desired state.
	SolutionsNonComplianceReasonWORKING = SolutionsNonComplianceReason("WORKING")
	// ESX Agent Manager has ecnountered am issue attempting to acheive the
	// desired state.
	SolutionsNonComplianceReasonISSUE = SolutionsNonComplianceReason("ISSUE")
	// ESX Agent Manager is awaiting user input to continue attempting to
	// acheive the desired state.
	SolutionsNonComplianceReasonIN_HOOK = SolutionsNonComplianceReason("IN_HOOK")
	// An obsoleted spec is currently in application for this solution.
	//
	// This state should take precedence over:
	// `WORKING`
	// `ISSUE`
	// `IN_HOOK`
	SolutionsNonComplianceReasonOBSOLETE_SPEC = SolutionsNonComplianceReason("OBSOLETE_SPEC")
	// Application for this solutiona has never been requested with
	// `Solutions.Apply`.
	SolutionsNonComplianceReasonNO_SPEC = SolutionsNonComplianceReason("NO_SPEC")
)
View Source 
const (
	// Utilizes all cloning methods available, will create initial snapshots
	// on the Virtual Machines.
	SolutionsVMDeploymentOptimizationALL_CLONES = SolutionsVMDeploymentOptimization("ALL_CLONES")
	// Utilize only full copy cloning menthods, will create initial snapshots
	// on the Virtual Machines.
	SolutionsVMDeploymentOptimizationFULL_CLONES_ONLY = SolutionsVMDeploymentOptimization("FULL_CLONES_ONLY")
	// Virtual Machiness will not be cloned from pre-existing deployment.
	SolutionsVMDeploymentOptimizationNO_CLONES = SolutionsVMDeploymentOptimization("NO_CLONES")
)
View Source 
const (
	// Disks will be provisioned with only used space allocated.
	SolutionsVMDiskProvisioningTHIN = SolutionsVMDiskProvisioning("THIN")
	// Disks will be provisioned with full size allocated.
	SolutionsVMDiskProvisioningTHICK = SolutionsVMDiskProvisioning("THICK")
)

Variables

This section is empty.

Functions

This section is empty.

Types

type AddIssue 

type AddIssue AddIssueRequestType

type AddIssueRequestType 

type AddIssueRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// A new issue.
	Issue BaseIssue `xml:"issue,typeattr" json:"issue"`
}

The parameters of `Agency.AddIssue`.

type AddIssueResponse 

type AddIssueResponse struct {
	Returnval BaseIssue `xml:"returnval,typeattr" json:"returnval"`
}

type AgencyComputeResourceScope 

type AgencyComputeResourceScope struct {
	AgencyScope

	// Compute resources on which to deploy the agents.
	//
	// If `ConfigInfo#vmPlacementPolicy` is set, the array needs to
	// contain exactly one cluster compute resource.
	//
	// Refers instances of `ComputeResource`.
	ComputeResource []types.ManagedObjectReference `xml:"computeResource,omitempty" json:"computeResource,omitempty"`
}

Scope specifies on which compute resources to deploy a solution's agents.

This structure may be used only with operations rendered under `/eam`.

type AgencyConfigInfo 

type AgencyConfigInfo struct {
	types.DynamicData

	// A list of `AgentConfigInfo`s for hosts covered by this
	// <code>Agency</code>.
	//
	// When provisioning a new agent to a host, vSphere
	// ESX Agent Manager tries to find, from left to right in the array, a
	// match for an `AgentConfigInfo` and stops searching at the first
	// one that it finds.
	// If `#vmPlacementPolicy` is set, the array needs to contain only a
	// single agent config. In that case the agent config is not bound to a
	// specific host, but to the whole cluster.
	AgentConfig []AgentConfigInfo `xml:"agentConfig,omitempty" json:"agentConfig,omitempty"`
	// The scope of the <code>Agency</code>.
	Scope BaseAgencyScope `xml:"scope,omitempty,typeattr" json:"scope,omitempty"`
	// If set to <code>true</code>, the client of this agency must manually
	// mark the agent as ready after the agent virtual machine has been
	// provisioned.
	//
	// This is useful if the client of this solution performs
	// some extra reconfiguration of the agent virtual machine before it is
	// powered on.
	//
	// See also `Agent.MarkAsAvailable`.
	ManuallyMarkAgentVmAvailableAfterProvisioning *bool `xml:"manuallyMarkAgentVmAvailableAfterProvisioning" json:"manuallyMarkAgentVmAvailableAfterProvisioning,omitempty"`
	// If set to <code>true</code>, the client of this agency must manually
	// mark the agent as ready after the agent virtual machine has been
	// powered on.
	//
	// In this case, DRS will not regard the agent virtual machine
	// as ready until the client has marked the agent as ready.
	//
	// See also `Agent.MarkAsAvailable`.
	ManuallyMarkAgentVmAvailableAfterPowerOn *bool `xml:"manuallyMarkAgentVmAvailableAfterPowerOn" json:"manuallyMarkAgentVmAvailableAfterPowerOn,omitempty"`
	// If set to <code>true</code>, ESX Agent Manager will use vSphere Linked
	// Clones to speed up the deployment of agent virtual machines.
	//
	// Using
	// linked clones implies that the agent virtual machines cannot use
	// Storage vMotion to move to another vSphere datastore.
	// If set to <code>false</code>, ESX Agent Manager will use Full VM
	// Cloning.
	// If unset default is <code>true<code>.
	OptimizedDeploymentEnabled *bool `xml:"optimizedDeploymentEnabled" json:"optimizedDeploymentEnabled,omitempty"`
	// An optional name to use when naming agent virtual machines.
	//
	// For
	// example, if set to "example-agent", each agent virtual machine will be
	// named "example-agent (1)", "example-agent (2)", and so on. The maximum
	// length of <code>agentName</code> is 70 characters.
	AgentName string `xml:"agentName,omitempty" json:"agentName,omitempty"`
	// Name of the agency.
	//
	// Must be set when creating the agency.
	AgencyName string `xml:"agencyName,omitempty" json:"agencyName,omitempty"`
	// Property <code>agentName</code> is required if this property is set to
	// <code>true</code>.
	//
	// If set to <code>true</code>, ESX Agent Manager will name virtual
	// machines with UUID suffix. For example, "example-agent-UUID".
	// In this case, the maximum length of <code>agentName</code> is 43
	// characters.
	//
	// If not set or is set to <code>false</code>, virtual
	// machines will not contain UUID in their name.
	UseUuidVmName *bool `xml:"useUuidVmName" json:"useUuidVmName,omitempty" vim:"7.5"`
	// Deprecated use automatically provisioned VMs and register hooks to
	// have control post provisioning and power on.
	//
	// Set to true if agent VMs are manually provisioned.
	//
	// If unset, defaults
	// to false.
	ManuallyProvisioned *bool `xml:"manuallyProvisioned" json:"manuallyProvisioned,omitempty" vim:"2.0"`
	// Deprecated use automatically provisioned VMs and register hooks to
	// have control post provisioning and power on.
	//
	// Set to true if agent VMs are manually monitored.
	//
	// If unset, defaults to
	// false. This can only be set to true if
	// `AgencyConfigInfo.manuallyProvisioned` is set to true.
	ManuallyMonitored *bool `xml:"manuallyMonitored" json:"manuallyMonitored,omitempty" vim:"2.0"`
	// Deprecated vUM is no more consulted so this property has no sense
	// anymore.
	//
	// Set to true will install VIBs directly on the hosts even if VMware
	// Update Manager is installed.
	//
	// If unset, defaults to false.
	BypassVumEnabled *bool `xml:"bypassVumEnabled" json:"bypassVumEnabled,omitempty" vim:"2.0"`
	// Specifies the networks which to be configured on the agent VMs.
	//
	// This property is only applicable for pinned to host VMs - i.e.
	// (`#vmPlacementPolicy`) is not set.
	//
	// If not set or `AgencyConfigInfo.preferHostConfiguration` is set to true, the
	// default host agent VM network (configured through
	// vim.host.EsxAgentHostManager) is used, otherwise the first network from
	// the array that is present on the host is used.
	//
	// At most one of `AgencyConfigInfo.agentVmNetwork` and `#vmNetworkMapping`
	// needs to be set.
	//
	// Refers instances of `Network`.
	AgentVmNetwork []types.ManagedObjectReference `xml:"agentVmNetwork,omitempty" json:"agentVmNetwork,omitempty" vim:"2.0"`
	// The datastores used to configure the storage on the agent VMs.
	//
	// This property is required if `#vmPlacementPolicy` is set and
	// `#datastoreSelectionPolicy` is not set. In that case the first
	// element from the list is used.
	//
	// If not set or `AgencyConfigInfo.preferHostConfiguration` is set to true and
	// `#vmPlacementPolicy` is not set, the default host agent VM
	// datastore (configured through vim.host.EsxAgentHostManager) is used,
	// otherwise the first datastore from the array that is present on the
	// host is used.
	//
	// If `#vmPlacementPolicy` is set at most one of
	// `AgencyConfigInfo.agentVmDatastore` and `#datastoreSelectionPolicy` needs
	// to be set. If `#vmPlacementPolicy` is not set
	// `#datastoreSelectionPolicy` takes precedence over
	// `AgencyConfigInfo.agentVmDatastore` .
	//
	// Refers instances of `Datastore`.
	AgentVmDatastore []types.ManagedObjectReference `xml:"agentVmDatastore,omitempty" json:"agentVmDatastore,omitempty" vim:"2_5"`
	// If set to true the default agent VM datastore and network will take
	// precedence over `Agency.ConfigInfo.agentVmNetwork` and
	// `Agency.ConfigInfo.agentVmDatastore` when configuring the agent
	// VMs.
	//
	// This property is not used if `#vmPlacementPolicy` is set.
	PreferHostConfiguration *bool `xml:"preferHostConfiguration" json:"preferHostConfiguration,omitempty" vim:"2_5"`
	// Deprecated that is a custom configuration that should be setup by the
	// agency owner. One way is to use
	// `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterPowerOn` or
	// `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning`
	// hooks.
	//
	// If set, a property with id "ip" and value an IP from the pool is added
	// to the vApp configuration of the deployed VMs.
	IpPool *types.IpPool `xml:"ipPool,omitempty" json:"ipPool,omitempty" vim:"3.0"`
	// Defines the resource pools where VMs to be deployed.
	//
	// If specified, the VMs for every compute resouce in the scope will be
	// deployed to its corresponding resource pool.
	// If not specified, the agent VMs for each compute resource will be
	// deployed under top level nested resource pool created for the agent
	// VMs. If unable to create a nested resource pool, the root resource pool
	// of the compute resource will be used.
	ResourcePools []AgencyVMResourcePool `xml:"resourcePools,omitempty" json:"resourcePools,omitempty" vim:"6.9"`
	// Defines the folders where VMs to be deployed.
	//
	// If specified, the VMs for every compute resouce in the scope will be
	// deployed to its corresponding folder. The link is made between the
	// compute resource parent and the datacenter the folder belongs to
	// `AgencyVMFolder.datacenterId`.
	// If not specified, the agent VMs for each compute resource will be
	// deployed in top level folder created in each datacenter for the agent
	// VMs.
	Folders []AgencyVMFolder `xml:"folders,omitempty" json:"folders,omitempty" vim:"6.9"`
}

This is the configuration of an <code>Agency</code>.

It determines on which compute resources to deploy the agents, which VIB to install, which OVF package to install, and how to configure these items by setting the OVF environment properties.

This structure may be used only with operations rendered under `/eam`.

func (*AgencyConfigInfo) GetAgencyConfigInfo added in v0.26.1 

func (b *AgencyConfigInfo) GetAgencyConfigInfo() *AgencyConfigInfo

type AgencyDisabled added in v0.27.0 

type AgencyDisabled struct {
	AgencyIssue
}

Agency is disabled - one or more ClusterComputeResources from it's scope are disabled.

This is not a remediable issue. To remediate, re-enable the cluster.

This structure may be used only with operations rendered under `/eam`.

type AgencyIssue 

type AgencyIssue struct {
	Issue

	// The agency to which this issue belongs.
	//
	// Refers instance of `Agency`.
	Agency types.ManagedObjectReference `xml:"agency" json:"agency"`
	// The name of the agency.
	AgencyName string `xml:"agencyName" json:"agencyName"`
	// The ID of the solution to which this issue belongs.
	SolutionId string `xml:"solutionId" json:"solutionId"`
	// The name of the solution to which this issue belongs.
	SolutionName string `xml:"solutionName" json:"solutionName"`
}

Base class for all agency issues.

This structure may be used only with operations rendered under `/eam`.

func (*AgencyIssue) GetAgencyIssue 

func (b *AgencyIssue) GetAgencyIssue() *AgencyIssue

type AgencyQueryRuntime 

type AgencyQueryRuntime AgencyQueryRuntimeRequestType

type AgencyQueryRuntimeRequestType 

type AgencyQueryRuntimeRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type AgencyQueryRuntimeResponse 

type AgencyQueryRuntimeResponse struct {
	Returnval BaseEamObjectRuntimeInfo `xml:"returnval,typeattr" json:"returnval"`
}

type AgencyScope 

type AgencyScope struct {
	types.DynamicData
}

Scope specifies which where to deploy agents.

This structure may be used only with operations rendered under `/eam`.

func (*AgencyScope) GetAgencyScope 

func (b *AgencyScope) GetAgencyScope() *AgencyScope

type AgencyVMFolder 

type AgencyVMFolder struct {
	types.DynamicData

	// Folder identifier.
	//
	// The folder must be present in the corresponding
	// datacenter.
	//
	// Refers instance of `Folder`.
	FolderId types.ManagedObjectReference `xml:"folderId" json:"folderId"`
	// Datacenter identifier.
	//
	// Refers instance of `Datacenter`.
	DatacenterId types.ManagedObjectReference `xml:"datacenterId" json:"datacenterId"`
}

Represents the mapping of a VM folder to a datacenter.

This structure may be used only with operations rendered under `/eam`.

type AgencyVMPlacementPolicyVMAntiAffinity 

type AgencyVMPlacementPolicyVMAntiAffinity string

Defines if the deployed VMs needs to run on different hosts.

type AgencyVMPlacementPolicyVMDataAffinity 

type AgencyVMPlacementPolicyVMDataAffinity string

Defines if the deployed VM is affinied to run on the same host it is deployed on.

type AgencyVMResourcePool 

type AgencyVMResourcePool struct {
	types.DynamicData

	// Resource pool identifier.
	//
	// The resource pool must be present in the
	// corresponding compute resource.
	//
	// Refers instance of `ResourcePool`.
	ResourcePoolId types.ManagedObjectReference `xml:"resourcePoolId" json:"resourcePoolId"`
	// Compute resource identifier.
	//
	// Refers instance of `ComputeResource`.
	ComputeResourceId types.ManagedObjectReference `xml:"computeResourceId" json:"computeResourceId"`
}

Represents the mapping of a VM resource pool to a compute resource.

This structure may be used only with operations rendered under `/eam`.

type Agency_Disable added in v0.27.0 

type Agency_Disable Agency_DisableRequestType

type Agency_DisableRequestType added in v0.27.0 

type Agency_DisableRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type Agency_DisableResponse added in v0.27.0 

type Agency_DisableResponse struct {
}

type Agency_Enable added in v0.27.0 

type Agency_Enable Agency_EnableRequestType

type Agency_EnableRequestType added in v0.27.0 

type Agency_EnableRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type Agency_EnableResponse added in v0.27.0 

type Agency_EnableResponse struct {
}

type AgentAnyCertificate added in v0.31.0 

type AgentAnyCertificate struct {
	AgentSslTrust
}

Specifies an SSL policy that trusts any SSL certificate.

This structure may be used only with operations rendered under `/eam`.

type AgentConfigInfo 

type AgentConfigInfo struct {
	types.DynamicData

	// The product line ID of the host.
	//
	// Examples of values are "esx" or
	// "embeddedEsx". If omitted, the host's product line ID is not considered
	// when matching an <code>AgentPackage</code> against a host.
	ProductLineId string `xml:"productLineId,omitempty" json:"productLineId,omitempty"`
	// A dot-separated string of the host version.
	//
	// Examples of values are
	// "4.1.0" "3.5", "4.\*" where \* is a wildcard meaning any version minor
	// version of the major version 4. If omitted, the host version will not
	// be considered when matching an <code>AgentPackage</code> against a
	// host.
	// This property is not used if
	// `Agency.ConfigInfo#vmPlacementPolicy` is set. It is client's
	// responsibility to trigger an agency upgrade with a new
	// `AgentConfigInfo.ovfPackageUrl`.
	HostVersion string `xml:"hostVersion,omitempty" json:"hostVersion,omitempty"`
	// The URL of the solution's agent OVF package.
	//
	// If not set, no agent
	// virtual machines are installed on the hosts covered by the scope.
	// If `Agency.ConfigInfo#vmPlacementPolicy` is set, the VM needs to
	// be agnostic to the different host versions inside the cluster.
	OvfPackageUrl string `xml:"ovfPackageUrl,omitempty" json:"ovfPackageUrl,omitempty"`
	// Specifies an SSL trust policy to be use for verification of the
	// server that hosts the `AgentConfigInfo.ovfPackageUrl`.
	//
	// If not set, the server
	// certificate is validated against the trusted root certificates of the
	// OS (Photon) and VECS (TRUSTED\_ROOTS).
	OvfSslTrust BaseAgentSslTrust `xml:"ovfSslTrust,omitempty,typeattr" json:"ovfSslTrust,omitempty" vim:"8.2"`
	// The part of the OVF environment that can be set by the solution.
	//
	// This
	// is where Properties that the agent virtual machine's OVF descriptor
	// specifies are set here. All properties that are specified as
	// user-configurable must be set.
	OvfEnvironment *AgentOvfEnvironmentInfo `xml:"ovfEnvironment,omitempty" json:"ovfEnvironment,omitempty"`
	// An optional URL to an offline bundle.
	//
	// If not set, no VIB is installed
	// on the hosts in the scope. Offline bundles are only supported on 4.0
	// hosts and later.
	//
	// VIB downgrade is not permitted - in case a VIB with the same name, but
	// lower version is installed on a host in the scope the VIB installation
	// on that host will not succeed.
	//
	// If two or more agents have the same VIB with different versions on the
	// same host, the install/uninstall behaviour is undefined (the VIB may
	// remain installed, etc.).
	//
	// The property is not used if `Agency.ConfigInfo#vmPlacementPolicy`
	// is set.
	VibUrl string `xml:"vibUrl,omitempty" json:"vibUrl,omitempty"`
	// Specifies an SSL trust policy to be use for verification of the
	// server that hosts the `AgentConfigInfo.vibUrl`.
	//
	// If not set, the server
	// certificate is validated against the trusted root certificates of the
	// OS (Photon) and VECS (TRUSTED\_ROOTS).
	VibSslTrust BaseAgentSslTrust `xml:"vibSslTrust,omitempty,typeattr" json:"vibSslTrust,omitempty" vim:"8.2"`
	// Deprecated vIB matching rules are no longer supported by EAM. Same
	// overlaps with VIB dependency requirements which reside in
	// each VIB's metadata.
	//
	// Optional Vib matching rules.
	//
	// If set, the Vib, specified by vibUrl, will
	// be installed either
	//     - if there is installed Vib on the host which name and version match
	//       the regular expressions in the corresponding rule
	//     - or there isn't any installed Vib on the host with name which
	//       matches the Vib name regular expression in the corresponding rule. Vib
	//       matching rules are usually used for controlling VIB upgrades, in which
	//       case the name regular expression matches any previous versions of the
	//       agency Vib and version regular expression determines whether the
	//       existing Vib should be upgraded.
	//
	// For every Vib in the Vib package, only one Vib matching rule can be
	// defined. If specified more than one, it is not determined which one
	// will be used. The Vib name regular expression in the Vib matching rule
	// will be matched against the name of the Vib which will be installed.
	// Only rules for Vibs which are defined in the Vib package metadata will
	// be taken in account.
	VibMatchingRules []AgentVibMatchingRule `xml:"vibMatchingRules,omitempty" json:"vibMatchingRules,omitempty" vim:"2_5"`
	// Deprecated use VIB metadata to add such dependency.
	//
	// An optional name of a VIB.
	//
	// If set, no VIB is installed on the host. The
	// host is checked if a VIB with vibName is already installed on it. Also
	// the vibUrl must not be set together with the vibUrl.
	VibName string `xml:"vibName,omitempty" json:"vibName,omitempty" vim:"2.0"`
	// Deprecated that is a custom setup specific for a particular agency.
	// The agency owner should do it using other means, e.g.
	// `#manuallyMarkAgentVmAvailableAfterPowerOn` or
	// `#manuallyMarkAgentVmAvailableAfterProvisioning`
	// hooks. Support for this has been removed. Seting this to
	// <code>true</code> will no longer have any effect.
	//
	// If set to <code>true</code>, the hosts in the scope must be configured
	// for DvFilter before VIBs and agent virtual machines are deployed on
	// them.
	//
	// If not set or set to <code>false</code>, no DvFilter
	// configuration is done on the hosts.
	DvFilterEnabled *bool `xml:"dvFilterEnabled" json:"dvFilterEnabled,omitempty"`
	// Deprecated express that requirement in the VIB descriptor with
	// 'live-remove-allowed=false'.
	//
	// An optional boolean flag to specify whether the agent's host is
	// rebooted after the VIB is uninstalled.
	//
	// If not set, the default value is
	// <code>false</code>. If set to <code>true</code>, the agent gets a
	// `VibRequiresHostReboot` issue after a successful
	// uninstallation.
	RebootHostAfterVibUninstall *bool `xml:"rebootHostAfterVibUninstall" json:"rebootHostAfterVibUninstall,omitempty"`
	// If set the virtual machine will be configured with the services and
	// allow VMCI access from the virtual machine to the installed VIB.
	VmciService []string `xml:"vmciService,omitempty" json:"vmciService,omitempty"`
	// AgentVM disk provisioning type.
	//
	// Defaults to `none` if not specified.
	OvfDiskProvisioning string `xml:"ovfDiskProvisioning,omitempty" json:"ovfDiskProvisioning,omitempty" vim:"6.9"`
	// Defines the storage policies configured on Agent VMs.
	//
	// Storage policies
	// are configured on all VM related objects including disks.
	// NOTE: The property needs to be configured on each update, otherwise
	// vSphere ESX Agent Manager will unset this configuration for all future
	// agent VMs.
	VmStoragePolicies []BaseAgentStoragePolicy `xml:"vmStoragePolicies,omitempty,typeattr" json:"vmStoragePolicies,omitempty" vim:"7.0"`
}

A description of what should be put on a host.

By setting the <code>productLineId</code> and <code>hostVersion</code>, you can specify the types of hosts for which to use the <code>ConfigInfo</code>.

This structure may be used only with operations rendered under `/eam`.

type AgentConfigInfoOvfDiskProvisioning 

type AgentConfigInfoOvfDiskProvisioning string

type AgentIssue 

type AgentIssue struct {
	AgencyIssue

	// The agent that has this issue.
	//
	// Refers instance of `Agent`.
	Agent types.ManagedObjectReference `xml:"agent" json:"agent"`
	// The name of the agent.
	AgentName string `xml:"agentName" json:"agentName"`
	// The managed object reference to the host on which this agent is located.
	//
	// Refers instance of `HostSystem`.
	Host types.ManagedObjectReference `xml:"host" json:"host"`
	// The name of the host on which this agent is located.
	HostName string `xml:"hostName" json:"hostName"`
}

Base class for all agent issues.

This structure may be used only with operations rendered under `/eam`.

func (*AgentIssue) GetAgentIssue 

func (b *AgentIssue) GetAgentIssue() *AgentIssue

type AgentOvfEnvironmentInfo 

type AgentOvfEnvironmentInfo struct {
	types.DynamicData

	// The OVF properties that are assigned to the agent virtual machine's OVF
	// environment when it is powered on.
	OvfProperty []AgentOvfEnvironmentInfoOvfProperty `xml:"ovfProperty,omitempty" json:"ovfProperty,omitempty"`
}

The <code>OvfEnvironment</code> is used to assign OVF environment properties in the `AgentConfigInfo`.

It specifies the values that map to properties in the agent virtual machine's OVF descriptor.

This structure may be used only with operations rendered under `/eam`.

type AgentOvfEnvironmentInfoOvfProperty 

type AgentOvfEnvironmentInfoOvfProperty struct {
	types.DynamicData

	// The name of the property in the OVF descriptor.
	Key string `xml:"key" json:"key"`
	// The value of the property.
	Value string `xml:"value" json:"value"`
}

One OVF property.

This structure may be used only with operations rendered under `/eam`.

type AgentPinnedPemCertificate added in v0.31.0 

type AgentPinnedPemCertificate struct {
	AgentSslTrust

	// PEM encoded pinned SSL certificate of the server that needs to be
	// trusted.
	SslCertificate string `xml:"sslCertificate" json:"sslCertificate"`
}

Specifies an SSL policy that trusts one specific pinned PEM encoded SSL certificate.

This structure may be used only with operations rendered under `/eam`.

type AgentQueryConfig 

type AgentQueryConfig AgentQueryConfigRequestType

type AgentQueryConfigRequestType 

type AgentQueryConfigRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type AgentQueryConfigResponse 

type AgentQueryConfigResponse struct {
	Returnval AgentConfigInfo `xml:"returnval" json:"returnval"`
}

type AgentQueryRuntime 

type AgentQueryRuntime AgentQueryRuntimeRequestType

type AgentQueryRuntimeRequestType 

type AgentQueryRuntimeRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type AgentQueryRuntimeResponse 

type AgentQueryRuntimeResponse struct {
	Returnval AgentRuntimeInfo `xml:"returnval" json:"returnval"`
}

type AgentRuntimeInfo 

type AgentRuntimeInfo struct {
	EamObjectRuntimeInfo

	// Deprecated get that info calling the virtual machine VIM API.
	//
	// The power state of an agent virtual machine.
	VmPowerState types.VirtualMachinePowerState `xml:"vmPowerState" json:"vmPowerState"`
	// Deprecated get that info calling the virtual machine VIM API.
	//
	// True if the vSphere ESX Agent Manager is receiving heartbeats from the
	// agent virtual machine.
	ReceivingHeartBeat bool `xml:"receivingHeartBeat" json:"receivingHeartBeat"`
	// The agent host.
	//
	// Refers instance of `HostSystem`.
	Host *types.ManagedObjectReference `xml:"host,omitempty" json:"host,omitempty"`
	// The agent virtual machine.
	//
	// Refers instance of `VirtualMachine`.
	Vm *types.ManagedObjectReference `xml:"vm,omitempty" json:"vm,omitempty"`
	// Deprecated get that info calling the virtual machine VIM API.
	//
	// The IP address of the agent virtual machine
	VmIp string `xml:"vmIp,omitempty" json:"vmIp,omitempty"`
	// Deprecated get that info calling the virtual machine VIM API.
	//
	// The name of the agent virtual machine.
	VmName string `xml:"vmName" json:"vmName"`
	// Deprecated in order to retrieve agent resource pool use VIM API.
	//
	// The ESX agent resource pool in which the agent virtual machine resides.
	//
	// Refers instance of `ResourcePool`.
	EsxAgentResourcePool *types.ManagedObjectReference `xml:"esxAgentResourcePool,omitempty" json:"esxAgentResourcePool,omitempty"`
	// Deprecated in order to retrieve agent VM folder use VIM API.
	//
	// The ESX agent folder in which the agent virtual machine resides.
	//
	// Refers instance of `Folder`.
	EsxAgentFolder *types.ManagedObjectReference `xml:"esxAgentFolder,omitempty" json:"esxAgentFolder,omitempty"`
	// Deprecated use `AgentRuntimeInfo.installedVibs` instead.
	//
	// An optional array of IDs of installed bulletins for this agent.
	InstalledBulletin []string `xml:"installedBulletin,omitempty" json:"installedBulletin,omitempty"`
	// Information about the installed vibs on the host.
	InstalledVibs []VibVibInfo `xml:"installedVibs,omitempty" json:"installedVibs,omitempty" vim:"6.0"`
	// The agency this agent belongs to.
	//
	// Refers instance of `Agency`.
	Agency *types.ManagedObjectReference `xml:"agency,omitempty" json:"agency,omitempty" vim:"2.0"`
	// Active VM hook.
	//
	// If present agent is actively waiting for `Agent.MarkAsAvailable`.
	// See `AgentVmHook`.
	VmHook *AgentVmHook `xml:"vmHook,omitempty" json:"vmHook,omitempty" vim:"6.7"`
}

Extends <code>RuntimeInfo</code> with information regarding the deployment of an agent on a specific host.

This structure may be used only with operations rendered under `/eam`.

type AgentSslTrust added in v0.31.0 

type AgentSslTrust struct {
	types.DynamicData
}

Specifies an SSL trust policy.

This structure may be used only with operations rendered under `/eam`.

func (*AgentSslTrust) GetAgentSslTrust added in v0.31.0 

func (b *AgentSslTrust) GetAgentSslTrust() *AgentSslTrust

type AgentStoragePolicy 

type AgentStoragePolicy struct {
	types.DynamicData
}

Specifies the storage policies configured on Agent VMs.

This structure may be used only with operations rendered under `/eam`.

func (*AgentStoragePolicy) GetAgentStoragePolicy 

func (b *AgentStoragePolicy) GetAgentStoragePolicy() *AgentStoragePolicy

type AgentVibMatchingRule 

type AgentVibMatchingRule struct {
	types.DynamicData

	// Vib name regular expression.
	VibNameRegex string `xml:"vibNameRegex" json:"vibNameRegex"`
	// Vib version regular expression.
	VibVersionRegex string `xml:"vibVersionRegex" json:"vibVersionRegex"`
}

Deprecated vIB matching rules are no longer supported by EAM. Same overlaps with VIB dependency requirements which reside in each VIB's metadata.

Specifies regular expressions for Vib name and version.

This structure may be used only with operations rendered under `/eam`.

type AgentVmHook 

type AgentVmHook struct {
	types.DynamicData

	// The VM for which lifecycle is this hook.
	//
	// This VM may differ from `AgentRuntimeInfo.vm` while an upgrade
	// of the agent VM is in progress.
	//
	// Refers instance of `VirtualMachine`.
	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
	// The current VM lifecycle state.
	VmState string `xml:"vmState" json:"vmState"`
}

Represents an active hook of the VM lifecycle which EAM is waiting on to be processed by the client.

The supported hooks are defined by `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning` and `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning`. See `Agent.MarkAsAvailable`

This structure may be used only with operations rendered under `/eam`.

type AgentVmHookVmState 

type AgentVmHookVmState string

Represents the state of the VM lifecycle.

type AgentVsanStoragePolicy 

type AgentVsanStoragePolicy struct {
	AgentStoragePolicy

	// ID of a storage policy profile created by the user.
	//
	// The type of the
	// profile must be `VirtualMachineDefinedProfileSpec`. The ID must be valid
	// `VirtualMachineDefinedProfileSpec.profileId`.
	ProfileId string `xml:"profileId" json:"profileId"`
}

Specifies vSAN specific storage policy configured on Agent VMs.

This structure may be used only with operations rendered under `/eam`.

type ArrayOfAgencyVMFolder 

type ArrayOfAgencyVMFolder struct {
	AgencyVMFolder []AgencyVMFolder `xml:"AgencyVMFolder,omitempty" json:"_value"`
}

A boxed array of `AgencyVMFolder`. To be used in `Any` placeholders.

type ArrayOfAgencyVMResourcePool 

type ArrayOfAgencyVMResourcePool struct {
	AgencyVMResourcePool []AgencyVMResourcePool `xml:"AgencyVMResourcePool,omitempty" json:"_value"`
}

A boxed array of `AgencyVMResourcePool`. To be used in `Any` placeholders.

type ArrayOfAgentConfigInfo 

type ArrayOfAgentConfigInfo struct {
	AgentConfigInfo []AgentConfigInfo `xml:"AgentConfigInfo,omitempty" json:"_value"`
}

A boxed array of `AgentConfigInfo`. To be used in `Any` placeholders.

type ArrayOfAgentOvfEnvironmentInfoOvfProperty 

type ArrayOfAgentOvfEnvironmentInfoOvfProperty struct {
	AgentOvfEnvironmentInfoOvfProperty []AgentOvfEnvironmentInfoOvfProperty `xml:"AgentOvfEnvironmentInfoOvfProperty,omitempty" json:"_value"`
}

A boxed array of `AgentOvfEnvironmentInfoOvfProperty`. To be used in `Any` placeholders.

type ArrayOfAgentStoragePolicy 

type ArrayOfAgentStoragePolicy struct {
	AgentStoragePolicy []BaseAgentStoragePolicy `xml:"AgentStoragePolicy,omitempty,typeattr" json:"_value"`
}

A boxed array of `AgentStoragePolicy`. To be used in `Any` placeholders.

type ArrayOfAgentVibMatchingRule 

type ArrayOfAgentVibMatchingRule struct {
	AgentVibMatchingRule []AgentVibMatchingRule `xml:"AgentVibMatchingRule,omitempty" json:"_value"`
}

A boxed array of `AgentVibMatchingRule`. To be used in `Any` placeholders.

type ArrayOfHooksHookInfo added in v0.31.0 

type ArrayOfHooksHookInfo struct {
	HooksHookInfo []HooksHookInfo `xml:"HooksHookInfo,omitempty" json:"_value"`
}

A boxed array of `HooksHookInfo`. To be used in `Any` placeholders.

type ArrayOfIssue 

type ArrayOfIssue struct {
	Issue []BaseIssue `xml:"Issue,omitempty,typeattr" json:"_value"`
}

A boxed array of `Issue`. To be used in `Any` placeholders.

type ArrayOfSolutionsHookConfig added in v0.31.0 

type ArrayOfSolutionsHookConfig struct {
	SolutionsHookConfig []SolutionsHookConfig `xml:"SolutionsHookConfig,omitempty" json:"_value"`
}

A boxed array of `SolutionsHookConfig`. To be used in `Any` placeholders.

type ArrayOfSolutionsHostComplianceResult added in v0.31.0 

type ArrayOfSolutionsHostComplianceResult struct {
	SolutionsHostComplianceResult []SolutionsHostComplianceResult `xml:"SolutionsHostComplianceResult,omitempty" json:"_value"`
}

A boxed array of `SolutionsHostComplianceResult`. To be used in `Any` placeholders.

type ArrayOfSolutionsOvfProperty added in v0.31.0 

type ArrayOfSolutionsOvfProperty struct {
	SolutionsOvfProperty []SolutionsOvfProperty `xml:"SolutionsOvfProperty,omitempty" json:"_value"`
}

A boxed array of `SolutionsOvfProperty`. To be used in `Any` placeholders.

type ArrayOfSolutionsSolutionComplianceResult added in v0.31.0 

type ArrayOfSolutionsSolutionComplianceResult struct {
	SolutionsSolutionComplianceResult []SolutionsSolutionComplianceResult `xml:"SolutionsSolutionComplianceResult,omitempty" json:"_value"`
}

A boxed array of `SolutionsSolutionComplianceResult`. To be used in `Any` placeholders.

type ArrayOfSolutionsSolutionConfig added in v0.31.0 

type ArrayOfSolutionsSolutionConfig struct {
	SolutionsSolutionConfig []SolutionsSolutionConfig `xml:"SolutionsSolutionConfig,omitempty" json:"_value"`
}

A boxed array of `SolutionsSolutionConfig`. To be used in `Any` placeholders.

type ArrayOfSolutionsSolutionValidationResult added in v0.31.0 

type ArrayOfSolutionsSolutionValidationResult struct {
	SolutionsSolutionValidationResult []SolutionsSolutionValidationResult `xml:"SolutionsSolutionValidationResult,omitempty" json:"_value"`
}

A boxed array of `SolutionsSolutionValidationResult`. To be used in `Any` placeholders.

type ArrayOfSolutionsStoragePolicy added in v0.31.0 

type ArrayOfSolutionsStoragePolicy struct {
	SolutionsStoragePolicy []BaseSolutionsStoragePolicy `xml:"SolutionsStoragePolicy,omitempty,typeattr" json:"_value"`
}

A boxed array of `SolutionsStoragePolicy`. To be used in `Any` placeholders.

type ArrayOfVibVibInfo 

type ArrayOfVibVibInfo struct {
	VibVibInfo []VibVibInfo `xml:"VibVibInfo,omitempty" json:"_value"`
}

A boxed array of `VibVibInfo`. To be used in `Any` placeholders.

type BaseAgencyConfigInfo added in v0.26.1 

type BaseAgencyConfigInfo interface {
	GetAgencyConfigInfo() *AgencyConfigInfo
}

type BaseAgencyIssue 

type BaseAgencyIssue interface {
	GetAgencyIssue() *AgencyIssue
}

type BaseAgencyScope 

type BaseAgencyScope interface {
	GetAgencyScope() *AgencyScope
}

type BaseAgentIssue 

type BaseAgentIssue interface {
	GetAgentIssue() *AgentIssue
}

type BaseAgentSslTrust added in v0.31.0 

type BaseAgentSslTrust interface {
	GetAgentSslTrust() *AgentSslTrust
}

type BaseAgentStoragePolicy 

type BaseAgentStoragePolicy interface {
	GetAgentStoragePolicy() *AgentStoragePolicy
}

type BaseClusterAgentAgentIssue 

type BaseClusterAgentAgentIssue interface {
	GetClusterAgentAgentIssue() *ClusterAgentAgentIssue
}

type BaseClusterAgentVmIssue 

type BaseClusterAgentVmIssue interface {
	GetClusterAgentVmIssue() *ClusterAgentVmIssue
}

type BaseClusterAgentVmNotDeployed 

type BaseClusterAgentVmNotDeployed interface {
	GetClusterAgentVmNotDeployed() *ClusterAgentVmNotDeployed
}

type BaseClusterAgentVmPoweredOff 

type BaseClusterAgentVmPoweredOff interface {
	GetClusterAgentVmPoweredOff() *ClusterAgentVmPoweredOff
}

type BaseEamAppFault 

type BaseEamAppFault interface {
	GetEamAppFault() *EamAppFault
}

type BaseEamFault 

type BaseEamFault interface {
	GetEamFault() *EamFault
}

type BaseEamObjectRuntimeInfo 

type BaseEamObjectRuntimeInfo interface {
	GetEamObjectRuntimeInfo() *EamObjectRuntimeInfo
}

type BaseEamRuntimeFault 

type BaseEamRuntimeFault interface {
	GetEamRuntimeFault() *EamRuntimeFault
}

type BaseHostIssue 

type BaseHostIssue interface {
	GetHostIssue() *HostIssue
}

type BaseIntegrityAgencyVUMIssue 

type BaseIntegrityAgencyVUMIssue interface {
	GetIntegrityAgencyVUMIssue() *IntegrityAgencyVUMIssue
}

type BaseIssue 

type BaseIssue interface {
	GetIssue() *Issue
}

type BaseNoAgentVmDatastore 

type BaseNoAgentVmDatastore interface {
	GetNoAgentVmDatastore() *NoAgentVmDatastore
}

type BaseNoAgentVmNetwork 

type BaseNoAgentVmNetwork interface {
	GetNoAgentVmNetwork() *NoAgentVmNetwork
}

type BasePersonalityAgencyDepotIssue 

type BasePersonalityAgencyDepotIssue interface {
	GetPersonalityAgencyDepotIssue() *PersonalityAgencyDepotIssue
}

type BasePersonalityAgencyPMIssue 

type BasePersonalityAgencyPMIssue interface {
	GetPersonalityAgencyPMIssue() *PersonalityAgencyPMIssue
}

type BasePersonalityAgentPMIssue 

type BasePersonalityAgentPMIssue interface {
	GetPersonalityAgentPMIssue() *PersonalityAgentPMIssue
}

type BaseSolutionsHookAcknowledgeConfig added in v0.31.0 

type BaseSolutionsHookAcknowledgeConfig interface {
	GetSolutionsHookAcknowledgeConfig() *SolutionsHookAcknowledgeConfig
}

type BaseSolutionsStoragePolicy added in v0.31.0 

type BaseSolutionsStoragePolicy interface {
	GetSolutionsStoragePolicy() *SolutionsStoragePolicy
}

type BaseSolutionsTypeSpecificSolutionConfig added in v0.31.0 

type BaseSolutionsTypeSpecificSolutionConfig interface {
	GetSolutionsTypeSpecificSolutionConfig() *SolutionsTypeSpecificSolutionConfig
}

type BaseSolutionsVMSource added in v0.31.0 

type BaseSolutionsVMSource interface {
	GetSolutionsVMSource() *SolutionsVMSource
}

type BaseVibIssue 

type BaseVibIssue interface {
	GetVibIssue() *VibIssue
}

type BaseVibNotInstalled 

type BaseVibNotInstalled interface {
	GetVibNotInstalled() *VibNotInstalled
}

type BaseVibVibServicesSslTrust added in v0.31.0 

type BaseVibVibServicesSslTrust interface {
	GetVibVibServicesSslTrust() *VibVibServicesSslTrust
}

type BaseVmDeployed 

type BaseVmDeployed interface {
	GetVmDeployed() *VmDeployed
}

type BaseVmIssue 

type BaseVmIssue interface {
	GetVmIssue() *VmIssue
}

type BaseVmNotDeployed 

type BaseVmNotDeployed interface {
	GetVmNotDeployed() *VmNotDeployed
}

type BaseVmPoweredOff 

type BaseVmPoweredOff interface {
	GetVmPoweredOff() *VmPoweredOff
}

type CannotAccessAgentOVF 

type CannotAccessAgentOVF struct {
	VmNotDeployed

	// The URL from which the OVF could not be downloaded.
	DownloadUrl string `xml:"downloadUrl" json:"downloadUrl"`
}

An agent virtual machine is expected to be deployed on a host, but the agent virtual machine cannot be deployed because the vSphere ESX Agent Manager is unable to access the OVF package for the agent.

This typically happens because the Web server providing the OVF package is down. The Web server is often internal to the solution that created the Agency.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent.

This structure may be used only with operations rendered under `/eam`.

type CannotAccessAgentVib 

type CannotAccessAgentVib struct {
	VibNotInstalled

	// The URL from which the VIB package could not be downloaded.
	DownloadUrl string `xml:"downloadUrl" json:"downloadUrl"`
}

An agent VIB module is expected to be deployed on a host, but the VIM module cannot be deployed because the vSphere ESX Agent Manager is unable to access the VIB package for the agent.

This typically happens because the Web server providing the VIB package is down. The Web server is often internal to the solution that created the Agency.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager reinstalls the VIB module.

This structure may be used only with operations rendered under `/eam`.

type CertificateNotTrusted added in v0.31.0 

type CertificateNotTrusted struct {
	AgentIssue

	Url string `xml:"url" json:"url"`
}

This exception is thrown if the certificate provided by the provider is not trusted.

This structure may be used only with operations rendered under `/sms`.

type CertificateNotTrustedFault added in v0.31.0 

type CertificateNotTrustedFault struct {
	EamAppFault

	// The URL that failed the SSL trust verification.
	Url string `xml:"url,omitempty" json:"url,omitempty"`
}

An CertificateNotTrusted fault is thrown when an Agency's configuration contains OVF package URL or VIB URL for that vSphere ESX Agent Manager is not able to make successful SSL trust verification of the server's certificate.

Reasons for this might be that the certificate provided via the API `Agent.ConfigInfo.ovfSslTrust` and `Agent.ConfigInfo.vibSslTrust` or via the script /usr/lib/vmware-eam/bin/eam-utility.py

  • is invalid.
  • does not match the server's certificate.

If there is no provided certificate, the fault is thrown when the server's certificate is not trusted by the system or is invalid - @see `Agent.ConfigInfo.ovfSslTrust` and `Agent.ConfigInfo.vibSslTrust`. To enable Agency creation 1) provide a valid certificate used by the server hosting the `Agent.ConfigInfo.ovfPackageUrl` or `Agent.ConfigInfo#vibUrl` or 2) ensure the server's certificate is signed by a CA trusted by the system. Then retry the operation, vSphere ESX Agent Manager will retry the SSL trust verification and proceed with reaching the desired state.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentAgentIssue 

type ClusterAgentAgentIssue struct {
	AgencyIssue

	// The agent that has this issue.
	//
	// Refers instance of `Agent`.
	Agent types.ManagedObjectReference `xml:"agent" json:"agent"`
	// The cluster for which this issue is raised.
	//
	// Migth be null if the cluster
	// is missing in vCenter Server inventory.
	//
	// Refers instance of `ComputeResource`.
	Cluster *types.ManagedObjectReference `xml:"cluster,omitempty" json:"cluster,omitempty"`
}

Base class for all cluster bound agents.

This structure may be used only with operations rendered under `/eam`.

func (*ClusterAgentAgentIssue) GetClusterAgentAgentIssue 

func (b *ClusterAgentAgentIssue) GetClusterAgentAgentIssue() *ClusterAgentAgentIssue

type ClusterAgentCertificateNotTrusted added in v0.31.0 

type ClusterAgentCertificateNotTrusted struct {
	ClusterAgentVmNotDeployed

	// The URL that failed the SSL trust verification.
	Url string `xml:"url" json:"url"`
}

The cluster agent Virtual Machine cannot be deployed, because vSphere ESX Agent Manager is not able to make successful SSL trust verification of the server's certificate, when establishing connection to the provided `Agent.ConfigInfo#ovfPackageUrl`.

Reasons for this might be that the certificate provided via the API `Agent.ConfigInfo.ovfSslTrust` or via the script /usr/lib/vmware-eam/bin/eam-utility.py

  • is invalid.
  • does not match the server's certificate.

If there is no provided certificate, the issue is raised when the server's certificate is not trusted by the system or invalid - @see `Agent.ConfigInfo.ovfSslTrust`. To remediate the cluster agent Virtual Machine deployment 1) provide a valid certificate used by the server hosting the `Agent.ConfigInfo.ovfPackageUrl` or 2) ensure the server's certificate is signed by a CA trusted by the system. Then resolve this issue, vSphere ESX Agent Manager will retry the SSL trust verification and proceed with reaching the desired state.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentInsufficientClusterResources 

type ClusterAgentInsufficientClusterResources struct {
	ClusterAgentVmPoweredOff
}

The cluster agent Virtual Machine could not be powered-on, because the cluster does not have enough CPU or memory resources.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers on the agent Virtual Machine. However, the problem is likely to persist until enough CPU and memory resources are made available.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentInsufficientClusterSpace 

type ClusterAgentInsufficientClusterSpace struct {
	ClusterAgentVmNotDeployed
}

The cluster agent Virtual Machine cannot be deployed, because any of the configured datastores does not have enough disk space.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent Virtual Machine. However, the problem is likely to persist until enough disk space is freed up on the cluster datastore.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentInvalidConfig 

type ClusterAgentInvalidConfig struct {
	ClusterAgentVmIssue

	// The error, that caused this issue.
	//
	// It must be either MethodFault or
	// RuntimeFault.
	Error types.AnyType `xml:"error,typeattr" json:"error"`
}

Invalid configuration is preventing a cluster agent virtual machine operation.

Typically the attached error indicates the particular reason why vSphere ESX Agent Manager is unable to power on or reconfigure the agent virtual machine.

This is a passive remediable issue. To remediate update the virtual machine configuration.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentMissingClusterVmDatastore 

type ClusterAgentMissingClusterVmDatastore struct {
	ClusterAgentVmNotDeployed

	// A non-empty array of cluster agent VM datastores that are missing on the
	// cluster.
	//
	// Refers instances of `Datastore`.
	MissingDatastores []types.ManagedObjectReference `xml:"missingDatastores,omitempty" json:"missingDatastores,omitempty"`
}

The cluster agent Virtual Machine cannot be deployed, because any of the configured datastores does not exist on the cluster.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent Virtual Machine. However, the problem is likely to persist until required Virtual Machine datastores are configured on the cluster.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentMissingClusterVmNetwork 

type ClusterAgentMissingClusterVmNetwork struct {
	ClusterAgentVmNotDeployed

	// A non-empty array of cluster agent VM networks that are required on the
	// cluster.
	//
	// Refers instances of `Network`.
	MissingNetworks []types.ManagedObjectReference `xml:"missingNetworks,omitempty" json:"missingNetworks,omitempty"`
	// The names of the cluster agent VM networks.
	NetworkNames []string `xml:"networkNames,omitempty" json:"networkNames,omitempty"`
}

The cluster agent Virtual Machine cannot be deployed, because the configured networks do not exist on the cluster.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent Virtual Machine. However, the problem is likely to persist until required Virtual Machine networks are configured on the cluster.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentOvfInvalidProperty 

type ClusterAgentOvfInvalidProperty struct {
	ClusterAgentAgentIssue

	// An optional list of errors that caused this issue.
	//
	// These errors are
	// generated by the vCenter server.
	Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
}

A cluster agent virtual machine needs to be provisioned, but an OVF property is either missing or has an invalid value.

This is a passive remediable issue. To remediate, update the OVF environment in the agent configuration used to provision the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentVmIssue 

type ClusterAgentVmIssue struct {
	ClusterAgentAgentIssue

	// The Virtual Machine to which this issue is related.
	//
	// Refers instance of `VirtualMachine`.
	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
}

Base class for all cluster bound Virtual Machines.

This structure may be used only with operations rendered under `/eam`.

func (*ClusterAgentVmIssue) GetClusterAgentVmIssue 

func (b *ClusterAgentVmIssue) GetClusterAgentVmIssue() *ClusterAgentVmIssue

type ClusterAgentVmNotDeployed 

type ClusterAgentVmNotDeployed struct {
	ClusterAgentAgentIssue
}

A cluster agent Virtual Machine is expected to be deployed on a cluster, but the cluster agent Virtual Machine has not been deployed or has been exlicitly deleted from the cluster.

Typically more specific issue (a subclass of this issue) indicates the particular reason why vSphere ESX Agent Manager was unable to deploy the cluster agent Virtual Machine.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the cluster agent Virtual Machine.

This structure may be used only with operations rendered under `/eam`.

func (*ClusterAgentVmNotDeployed) GetClusterAgentVmNotDeployed 

func (b *ClusterAgentVmNotDeployed) GetClusterAgentVmNotDeployed() *ClusterAgentVmNotDeployed

type ClusterAgentVmNotRemoved 

type ClusterAgentVmNotRemoved struct {
	ClusterAgentVmIssue
}

The cluster agent Virtual Machine can not be removed from a cluster.

Typically the description indicates the particular reason why vSphere ESX Agent Manager was unable to remove the cluster agent Virtual Machine.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager removes the cluster agent Virtual Machine.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentVmPoweredOff 

type ClusterAgentVmPoweredOff struct {
	ClusterAgentVmIssue
}

A cluster agent Virtual Machine is expected to be powered on, but the agent Virtual Machine is powered off.

Typically more specific issue (a subclass of this issue) indicates the particular reason why vSphere ESX Agent Manager was unable to power on the cluster agent Virtual Machine.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers on the cluster agent Virtual Machine.

This structure may be used only with operations rendered under `/eam`.

func (*ClusterAgentVmPoweredOff) GetClusterAgentVmPoweredOff 

func (b *ClusterAgentVmPoweredOff) GetClusterAgentVmPoweredOff() *ClusterAgentVmPoweredOff

type ClusterAgentVmPoweredOn 

type ClusterAgentVmPoweredOn struct {
	ClusterAgentVmIssue
}

A cluster agent virtual machine is expected to be powered off, but the agent virtual machine is powered on.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers off the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type ClusterAgentVmSuspended 

type ClusterAgentVmSuspended struct {
	ClusterAgentVmIssue
}

A cluster agent Virtual Machine is expected to be powered on, but the agent Virtual Machine is suspended.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers on the cluster agent Virtual Machine.

This structure may be used only with operations rendered under `/eam`.

type CreateAgency 

type CreateAgency CreateAgencyRequestType

type CreateAgencyRequestType 

type CreateAgencyRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The configuration that describes how to deploy the agents in the
	// created agency.
	AgencyConfigInfo BaseAgencyConfigInfo `xml:"agencyConfigInfo,typeattr" json:"agencyConfigInfo"`
	// Deprecated. No sence to create agency in other state than
	// <code>enabled</code>. <code>disabled</code> is deprecated
	// whereas <code>uninstalled</code> is useless.
	// The initial goal state of the agency. See
	// `EamObjectRuntimeInfoGoalState_enum`.
	InitialGoalState string `xml:"initialGoalState" json:"initialGoalState"`
}

The parameters of `EsxAgentManager.CreateAgency`.

type CreateAgencyResponse 

type CreateAgencyResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

type DestroyAgency 

type DestroyAgency DestroyAgencyRequestType

type DestroyAgencyRequestType 

type DestroyAgencyRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type DestroyAgencyResponse 

type DestroyAgencyResponse struct {
}

type DisabledClusterFault added in v0.27.0 

type DisabledClusterFault struct {
	EamAppFault

	// The MoRefs of the disabled compute resources.
	//
	// Refers instances of `ComputeResource`.
	DisabledComputeResource []types.ManagedObjectReference `xml:"disabledComputeResource,omitempty" json:"disabledComputeResource,omitempty"`
}

Thrown when trying to modify state over disabled clusters.

This structure may be used only with operations rendered under `/eam`.

type EamAppFault 

type EamAppFault struct {
	EamRuntimeFault
}

Application related error As opposed to system errors, application ones are always function of the input and the current state.

They occur always upon same conditions. In most of the cases they are recoverable, i.e. the client can determine what is wrong and know how to recover. NOTE: Since there is not yet need to distinguish among specific error sub-types then we define a common type. Tomorrow, if necessary, we can add an additional level of detailed exception types and make this one abstract.

This structure may be used only with operations rendered under `/eam`.

func (*EamAppFault) GetEamAppFault 

func (b *EamAppFault) GetEamAppFault() *EamAppFault

type EamAppFaultFault 

type EamAppFaultFault BaseEamAppFault

type EamFault 

type EamFault struct {
	types.MethodFault
}

The common base type for all vSphere ESX Agent Manager exceptions.

TODO migrate to EamRuntimeFault

This structure may be used only with operations rendered under `/eam`.

func (*EamFault) GetEamFault 

func (b *EamFault) GetEamFault() *EamFault

type EamFaultFault 

type EamFaultFault BaseEamFault

type EamIOFault 

type EamIOFault struct {
	EamRuntimeFault
}

IO error NOTE: Since this type is a first of system-type errors we do not introduce a common base type for them.

Once add a second system type exception though, it should be introduced.

This structure may be used only with operations rendered under `/eam`.

type EamIOFaultFault 

type EamIOFaultFault EamIOFault

type EamInvalidLogin 

type EamInvalidLogin struct {
	EamRuntimeFault
}

Thrown when a user cannot be authenticated.

This structure may be used only with operations rendered under `/eam`.

type EamInvalidLoginFault 

type EamInvalidLoginFault EamInvalidLogin

type EamInvalidState 

type EamInvalidState struct {
	EamAppFault
}

Thrown when a user is not allowed to execute an operation.

This structure may be used only with operations rendered under `/eam`.

type EamInvalidVibPackage 

type EamInvalidVibPackage struct {
	EamRuntimeFault
}

Indicates for an invalid or unknown Vib package structure and/or format.

This structure may be used only with operations rendered under `/eam`.

type EamInvalidVibPackageFault 

type EamInvalidVibPackageFault EamInvalidVibPackage

type EamObjectRuntimeInfo 

type EamObjectRuntimeInfo struct {
	types.DynamicData

	// The health of the managed entity.
	//
	// This denotes how well the entity conforms to the
	// goal state.
	//
	// See also `EamObjectRuntimeInfoStatus_enum`.
	Status string `xml:"status" json:"status"`
	// Current issues that have been detected for this entity.
	//
	// Each issue can be remediated
	// by invoking `EamObject.Resolve` or `EamObject.ResolveAll`.
	Issue []BaseIssue `xml:"issue,omitempty,typeattr" json:"issue,omitempty"`
	// The desired state of the entity.
	//
	// See also `EamObjectRuntimeInfoGoalState_enum`.
	GoalState string `xml:"goalState" json:"goalState"`
	// The `Agent` or `Agency` with which this <code>RuntimeInfo</code> object is associated.
	//
	// Refers instance of `EamObject`.
	Entity types.ManagedObjectReference `xml:"entity" json:"entity"`
}

The <code>RuntimeInfo</code> represents the runtime information of the vSphere ESX Agent Manager managed objects `Agency` and `Agent`.

The runtime information provides two kinds of information, namely, the desired goal state of the entity and the status with regards to conforming to that goal state.

This structure may be used only with operations rendered under `/eam`.

func (*EamObjectRuntimeInfo) GetEamObjectRuntimeInfo 

func (b *EamObjectRuntimeInfo) GetEamObjectRuntimeInfo() *EamObjectRuntimeInfo

type EamObjectRuntimeInfoGoalState 

type EamObjectRuntimeInfoGoalState string

The <code>GoalState</code> enumeration defines the goal of the entity.

type EamObjectRuntimeInfoStatus 

type EamObjectRuntimeInfoStatus string

<code>Status</code> defines a health value that denotes how well the entity conforms to the goal state.

type EamRuntimeFault 

type EamRuntimeFault struct {
	types.RuntimeFault
}

The common base type for all vSphere ESX Agent Manager runtime exceptions.

This structure may be used only with operations rendered under `/eam`.

func (*EamRuntimeFault) GetEamRuntimeFault 

func (b *EamRuntimeFault) GetEamRuntimeFault() *EamRuntimeFault

type EamRuntimeFaultFault 

type EamRuntimeFaultFault BaseEamRuntimeFault

type EamServiceNotInitialized 

type EamServiceNotInitialized struct {
	EamRuntimeFault
}

Thrown when calling vSphere ESX Agent Manager when it is not fully initialized.

This structure may be used only with operations rendered under `/eam`.

type EamServiceNotInitializedFault 

type EamServiceNotInitializedFault EamServiceNotInitialized

type EamSystemFault 

type EamSystemFault struct {
	EamRuntimeFault
}

System fault.

This structure may be used only with operations rendered under `/eam`.

type EamSystemFaultFault 

type EamSystemFaultFault EamSystemFault

type EsxAgentManagerMaintenanceModePolicy 

type EsxAgentManagerMaintenanceModePolicy string

<code>MaintenanceModePolicy</code> defines how ESX Agent Manager is going to put into maintenance mode hosts which are part of a cluster not managed

type ExtensibleIssue 

type ExtensibleIssue struct {
	Issue

	// Unique string for this type of issue.
	//
	// The type must match an event registered
	// by the solution as part of its extension.
	TypeId string `xml:"typeId" json:"typeId"`
	// Arguments associated with the typeId.
	Argument []types.KeyAnyValue `xml:"argument,omitempty" json:"argument,omitempty"`
	// A managed object reference to the object this issue is related to.
	//
	// Refers instance of `ManagedEntity`.
	Target *types.ManagedObjectReference `xml:"target,omitempty" json:"target,omitempty"`
	// An optional agent this issue pertains
	//
	// Refers instance of `Agent`.
	Agent *types.ManagedObjectReference `xml:"agent,omitempty" json:"agent,omitempty"`
	// An optional agency this issue pertains
	//
	// Refers instance of `Agency`.
	Agency *types.ManagedObjectReference `xml:"agency,omitempty" json:"agency,omitempty"`
}

Extensible issue class used by solutions to add custom issues to agents.

When resolved, the issue is removed from the agent and an event is generated.

This structure may be used only with operations rendered under `/eam`.

type GetMaintenanceModePolicyRequestType 

type GetMaintenanceModePolicyRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type HooksHookInfo added in v0.31.0 

type HooksHookInfo struct {
	types.DynamicData

	// Virtual Machine, the hook was raised for.
	//
	// Refers instance of `VirtualMachine`.
	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
	// Solution the Virtual Machine belongs to.
	Solution string `xml:"solution" json:"solution"`
	// Type of the hook `HooksHookType_enum`.
	HookType string `xml:"hookType" json:"hookType"`
	// Time the hook was raised.
	RaisedAt time.Time `xml:"raisedAt" json:"raisedAt"`
}

Contains information for a raised hook.

This structure may be used only with operations rendered under `/eam`.

type HooksHookListSpec added in v0.31.0 

type HooksHookListSpec struct {
	types.DynamicData

	// If specified - will report hooks only for agents from the specified
	// solutions, otherwise - will report hooks for agents from all solutions.
	Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"`
	// If specified - will report hooks only for agents on the specified
	// hosts, otherwise - will report hooks for agents on all hosts.
	//
	// Refers instances of `HostSystem`.
	Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"`
}

Limits the hooks reported to the user.

This structure may be used only with operations rendered under `/eam`.

type HooksHookType added in v0.31.0 

type HooksHookType string

Supported types of hooks for agents.

type HooksMarkAsProcessedSpec added in v0.31.0 

type HooksMarkAsProcessedSpec struct {
	types.DynamicData

	// Virtual Machine to mark a hook as processed.
	//
	// Refers instance of `VirtualMachine`.
	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
	// Type of hook to be marked as processed `HooksHookType_enum`.
	HookType string `xml:"hookType" json:"hookType"`
	// `True` - if the hook was processed successfully, `False` -
	// if the hook could not be processed.
	Success bool `xml:"success" json:"success"`
}

Specification for marking a raised hook on an agent Virtual Machine as processed.

This structure may be used only with operations rendered under `/eam`.

type HostInMaintenanceMode 

type HostInMaintenanceMode struct {
	VmDeployed
}

An agent virtual machine operation is expected to be initiated on host, but the agent virtual machine operation has not been initiated.

The reason is that the host is in maintenance mode.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager takes the host out of maintenance mode and initiates the agent virtual machine operation.

Resolving this issue in vSphere Lifecyle Manager environemnt will be no-op. In those cases user must take the host out of Maintenance Mode manually or wait vSphere Lifecycle Maanger cluster remediation to complete (if any).

This structure may be used only with operations rendered under `/eam`.

type HostInStandbyMode 

type HostInStandbyMode struct {
	VmDeployed
}

An agent virtual machine is expected to be removed from a host, but the agent virtual machine has not been removed.

The reason is that the host is in standby mode.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host in standby mode and removes the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type HostIssue 

type HostIssue struct {
	Issue

	// The host to which the issue is related.
	//
	// Refers instance of `HostSystem`.
	Host types.ManagedObjectReference `xml:"host" json:"host"`
}

Deprecated all host issues were removed.

Base class for all host issues.

This structure may be used only with operations rendered under `/eam`.

func (*HostIssue) GetHostIssue 

func (b *HostIssue) GetHostIssue() *HostIssue

type HostPoweredOff 

type HostPoweredOff struct {
	VmDeployed
}

Deprecated hostPoweredOff will no longer be used, instead `ManagedHostNotReachable` will be raised.

An agent virtual machine is expected to be removed from a host, but the agent virtual machine has not been removed.

The reason is that the host is powered off.

This is not a remediable issue. To remediate, power on the host.

This structure may be used only with operations rendered under `/eam`.

type ImmediateHostRebootRequired 

type ImmediateHostRebootRequired struct {
	VibIssue
}

Live VIB operation failed.

An immediate reboot is required to clear live VIB operation failure.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host into maintenance mode and reboots it.

This structure may be used only with operations rendered under `/eam`.

type IncompatibleHostVersion 

type IncompatibleHostVersion struct {
	VmNotDeployed
}

An agent virtual machine is expected to be deployed on a host, but the agent could not be deployed because it was incompatible with the host.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeployes the agent. However, the problem is likely to persist until either the host or the solution has been upgraded, so that the agent will become compatible with the host.

This structure may be used only with operations rendered under `/eam`.

type InsufficientIpAddresses 

type InsufficientIpAddresses struct {
	VmPoweredOff

	// The agent virtual machine network.
	//
	// Refers instance of `Network`.
	Network types.ManagedObjectReference `xml:"network" json:"network"`
}

Deprecated this issue is no longer raised by EAM. It is replaced by `InvalidConfig`.

An agent virtual machine is expected to be powered on, but there are no free IP addresses in the agent's pool of virtual machine IP addresses.

To remediate, free some IP addresses or add some more to the IP pool and invoke <code>resolve</code>.

This structure may be used only with operations rendered under `/eam`.

type InsufficientResources 

type InsufficientResources struct {
	VmNotDeployed
}

An agent virtual machine is expected to be deployed on a host, but the agent virtual machine could not be deployed because the host does not have enough free CPU or memory resources.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine. However, the problem is likely to persist until enough CPU and memory resources are made available.

This structure may be used only with operations rendered under `/eam`.

type InsufficientSpace 

type InsufficientSpace struct {
	VmNotDeployed
}

An agent virtual machine is expected to be deployed on a host, but the agent virtual machine could not be deployed because the host's agent datastore did not have enough free space.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine. However, the problem is likely to persist until either space is freed up on the host's agent virtual machine datastore or a new agent virtual machine datastore with enough free space is configured.

This structure may be used only with operations rendered under `/eam`.

type IntegrityAgencyCannotDeleteSoftware 

type IntegrityAgencyCannotDeleteSoftware struct {
	IntegrityAgencyVUMIssue
}

Cannot remove the Baseline associated with an Agency from VUM.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager retries the delete operation. Note: In future this issue will denote also the removal of the Agency software (VIBs) from VUM software depot once VUM provides an API for that.

This structure may be used only with operations rendered under `/eam`.

type IntegrityAgencyCannotStageSoftware 

type IntegrityAgencyCannotStageSoftware struct {
	IntegrityAgencyVUMIssue
}

The software defined by an Agency cannot be staged in VUM.

The staging operation consists of the following steps:

  • Upload the Agency software (VIBs) to the VUM depot.
  • Create or update a VUM Baseline with the Agency software and scope.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager retries the stage operation.

This structure may be used only with operations rendered under `/eam`.

type IntegrityAgencyVUMIssue 

type IntegrityAgencyVUMIssue struct {
	AgencyIssue
}

Base class for all issues which occurred during EAM communication with vSphere Update Manager (VUM).

This structure may be used only with operations rendered under `/eam`.

func (*IntegrityAgencyVUMIssue) GetIntegrityAgencyVUMIssue 

func (b *IntegrityAgencyVUMIssue) GetIntegrityAgencyVUMIssue() *IntegrityAgencyVUMIssue

type IntegrityAgencyVUMUnavailable 

type IntegrityAgencyVUMUnavailable struct {
	IntegrityAgencyVUMIssue
}

VUM service is not available - its registered SOAP endpoint cannot be accessed or it is malfunctioning.

This is an active and passive remediable issue. To remediate, vSphere ESX Agent Manager retries to access VUM service.

This structure may be used only with operations rendered under `/eam`.

type InvalidAgencyScope 

type InvalidAgencyScope struct {
	EamFault

	// The MoRefs of the unknown compute resources.
	//
	// Refers instances of `ComputeResource`.
	UnknownComputeResource []types.ManagedObjectReference `xml:"unknownComputeResource,omitempty" json:"unknownComputeResource,omitempty"`
}

An <code>InvalidAgencyScope</code> fault is thrown when the scope in an `AgencyConfigInfo` is invalid.

See also `AgencyConfigInfo`.

This structure may be used only with operations rendered under `/eam`.

type InvalidAgencyScopeFault 

type InvalidAgencyScopeFault InvalidAgencyScope

type InvalidAgentConfiguration 

type InvalidAgentConfiguration struct {
	EamFault

	// An optional invalid agent configuration.
	InvalidAgentConfiguration *AgentConfigInfo `xml:"invalidAgentConfiguration,omitempty" json:"invalidAgentConfiguration,omitempty"`
	// The invalid field.
	InvalidField string `xml:"invalidField,omitempty" json:"invalidField,omitempty"`
}

An <code>InvalidAgentConfiguration</code> fault is thrown when the agent configuration of an agency configuration is empty or invalid.

See also `AgencyConfigInfo`.

This structure may be used only with operations rendered under `/eam`.

type InvalidAgentConfigurationFault 

type InvalidAgentConfigurationFault InvalidAgentConfiguration

type InvalidConfig 

type InvalidConfig struct {
	VmIssue

	// The error, that caused this issue.
	//
	// It must be either MethodFault or
	// RuntimeFault.
	Error types.AnyType `xml:"error,typeattr" json:"error"`
}

Invalid configuration is preventing a virtual machine operation.

Typically the attached error indicates the particular reason why vSphere ESX Agent Manager is unable to power on or reconfigure the agent virtual machine.

This is a passive remediable issue. To remediate update the virtual machine configuration.

This structure may be used only with operations rendered under `/eam`.

type InvalidUrl 

type InvalidUrl struct {
	EamFault

	// Provider `VasaProviderSpec.url`
	Url               string `xml:"url" json:"url"`
	MalformedUrl      bool   `xml:"malformedUrl" json:"malformedUrl"`
	UnknownHost       bool   `xml:"unknownHost" json:"unknownHost"`
	ConnectionRefused bool   `xml:"connectionRefused" json:"connectionRefused"`
	ResponseCode      int32  `xml:"responseCode,omitempty" json:"responseCode,omitempty"`
}

This exception is thrown if `VasaProviderSpec.url` is malformed.

This structure may be used only with operations rendered under `/sms`.

type InvalidUrlFault 

type InvalidUrlFault InvalidUrl

type Issue 

type Issue struct {
	types.DynamicData

	// A unique identifier per <code>Issue</code> instance.
	Key int32 `xml:"key" json:"key"`
	// A localized message describing the issue.
	Description string `xml:"description" json:"description"`
	// The point in time when this issue was generated.
	//
	// Note that issues can be
	// regenerated periodically, so this time does not neccessarily reflect the
	// first time the issue was detected.
	Time time.Time `xml:"time" json:"time"`
}

An issue represents a problem encountered while deploying and configurating agents in a vCenter installation.

An issue conveys the type of problem and the entitity on which the problem has been encountered. Most issues are related to agents, but they can also relate to an agency or a host.

The set of issues provided by the vSphere ESX Agent Manager describes the discrepency between the _desired_ agent deployment state, as defined by the agency configurations, and the _actual_ deployment. The (@link EamObject.RuntimeInfo.Status.status) of an agency or agent is green if it has reached its goal state. It is marked as yellow if the vSphere ESX Agent Manager is actively working to bring the object to its goal state. It is red if there is a discrepency between the current state and the desired state. In the red state, a set of issues are filed on the object that describe the reason for the discrepency between the desired and actual states.

Issues are characterized as either active or passive remediable issues. For an active remediable issue, the vSphere ESX Agent Manager can actively try to solve the issue. For example, by deploying a new agent, removing an agent, changing its power state, and so on. For a passive remediable issue, the vSphere ESX Agent Manager is not able to solve the problem directly, and can only report the problem. For example, this could be caused by an incomplete host configuration.

When <code>resolve</code> is called for an active remediable issue, the vSphere ESX Agent Manager starts performing the appropiate remediation steps for the particular issue. For a passive remediable issue, the EAM manager simply checks if the condition still exists, and if not it removes the issue.

The vSphere ESX Agent Manager actively monitors most conditions relating to both active and passive issues. Thus, it often automatically discovers when an issue has been remediated and removes the issue without needing to explicitly call <code>resolve</code> on an issue.

The complete Issue hierarchy is shown below:

  • `Issue`
  • `AgencyIssue`
  • `AgentIssue`
  • `ManagedHostNotReachable`
  • `VmNotDeployed`
  • `CannotAccessAgentOVF`
  • `IncompatibleHostVersion`
  • `InsufficientResources`
  • `InsufficientSpace`
  • `OvfInvalidFormat`
  • `NoAgentVmDatastore`
  • `NoAgentVmNetwork`
  • `VmIssue`
  • `OvfInvalidProperty`
  • `VmDeployed`
  • `HostInMaintenanceMode`
  • `HostInStandbyMode`
  • `VmCorrupted`
  • `VmOrphaned`
  • `VmPoweredOff`
  • `InsufficientIpAddresses`
  • `MissingAgentIpPool`
  • `VmPoweredOn`
  • `VmSuspended`
  • `VibIssue`
  • `VibCannotPutHostInMaintenanceMode`
  • `VibNotInstalled`
  • `CannotAccessAgentVib`
  • `VibDependenciesNotMetByHost`
  • `VibInvalidFormat`
  • `VibRequirementsNotMetByHost`
  • `VibRequiresHostInMaintenanceMode`
  • `VibRequiresHostReboot`
  • `VibRequiresManualInstallation`
  • `VibRequiresManualUninstallation`
  • `ImmediateHostRebootRequired`
  • `OrphanedAgency`
  • `IntegrityAgencyVUMIssue`
  • `IntegrityAgencyVUMUnavailable`
  • `IntegrityAgencyCannotStageSoftware`
  • `IntegrityAgencyCannotDeleteSoftware`
  • `ClusterAgentAgentIssue`
  • `ClusterAgentVmIssue`
  • `ClusterAgentVmNotRemoved`
  • `ClusterAgentVmPoweredOff`
  • `ClusterAgentInsufficientClusterResources`
  • `ClusterAgentVmNotDeployed`
  • `ClusterAgentInsufficientClusterSpace`
  • `ClusterAgentMissingClusterVmDatastore`
  • `ClusterAgentMissingClusterVmNetwork`

See also `EamObject.Resolve`, `EamObject.ResolveAll`.

This structure may be used only with operations rendered under `/eam`.

func (*Issue) GetIssue 

func (b *Issue) GetIssue() *Issue

type ManagedHostNotReachable 

type ManagedHostNotReachable struct {
	AgentIssue
}

Managed ESXi Server is unreachable from vCenter Server or vSphere ESX Agent Manager.

Currently all operations on the affected host are imposible. Reasons for this might be :

  • ESXi Server is not connected from vCenter Server
  • ESXi Server powered off

This is not a remediable issue. To remediate, connect, power on or reboot the host.

This structure may be used only with operations rendered under `/eam`.

type MarkAsAvailable 

type MarkAsAvailable MarkAsAvailableRequestType

type MarkAsAvailableRequestType 

type MarkAsAvailableRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type MarkAsAvailableResponse 

type MarkAsAvailableResponse struct {
}

type MissingAgentIpPool 

type MissingAgentIpPool struct {
	VmPoweredOff

	// The agent virtual machine network.
	//
	// Refers instance of `Network`.
	Network types.ManagedObjectReference `xml:"network" json:"network"`
}

Deprecated this issue is no longer raised by EAM. It is replaced by `InvalidConfig`.

An agent virtual machine is expected to be powered on, but the agent virtual machine is powered off because there there are no IP addresses defined on the agent's virtual machine network.

To remediate, create an IP pool on the agent's virtual machine network and invoke <code>resolve</code>.

This structure may be used only with operations rendered under `/eam`.

type MissingDvFilterSwitch 

type MissingDvFilterSwitch struct {
	AgentIssue
}

Deprecated dvFilters are no longer supported by EAM.

The agent is using the dvFilter API on the ESX host, but no dvFilter switch has been configured on the host.

This can happen due to host communication failures or if the dvSwitch was (presumably accidentally) deleted from the host configuration.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager recreates the dvFilter switch.

This structure may be used only with operations rendered under `/eam`.

type NoAgentVmDatastore 

type NoAgentVmDatastore struct {
	VmNotDeployed
}

An agent virtual machine is expected to be deployed on a host, but the agent cannot be deployed because the agent datastore has not been configured on the host.

This is a passive remediable issue. The administrator must configure the agent virtual machine datastore on the host.

This structure may be used only with operations rendered under `/eam`.

func (*NoAgentVmDatastore) GetNoAgentVmDatastore 

func (b *NoAgentVmDatastore) GetNoAgentVmDatastore() *NoAgentVmDatastore

type NoAgentVmNetwork 

type NoAgentVmNetwork struct {
	VmNotDeployed
}

An agent virtual machine is expected to be deployed on a host, but the agent cannot be deployed because the agent network has not been configured on the host.

This is a passive remediable issue. The administrator must configure the agent virtual machine network on the host.

This structure may be used only with operations rendered under `/eam`.

func (*NoAgentVmNetwork) GetNoAgentVmNetwork 

func (b *NoAgentVmNetwork) GetNoAgentVmNetwork() *NoAgentVmNetwork

type NoConnectionToVCenter 

type NoConnectionToVCenter struct {
	EamRuntimeFault
}

Thrown when calling vSphere ESX Agent Manager when it is not connected to the vCenter server.

This structure may be used only with operations rendered under `/eam`.

type NoConnectionToVCenterFault 

type NoConnectionToVCenterFault NoConnectionToVCenter

type NoCustomAgentVmDatastore 

type NoCustomAgentVmDatastore struct {
	NoAgentVmDatastore

	// A non-empty array of agent VM datastores that is required on the host.
	//
	// Refers instances of `Datastore`.
	CustomAgentVmDatastore []types.ManagedObjectReference `xml:"customAgentVmDatastore" json:"customAgentVmDatastore"`
	// The names of the agent VM datastores.
	CustomAgentVmDatastoreName []string `xml:"customAgentVmDatastoreName" json:"customAgentVmDatastoreName"`
}

An agent virtual machine is expected to be deployed on a host, but the agent cannot be deployed because the agent datastore has not been configured on the host.

The host needs to be added to one of the datastores listed in customAgentVmDatastore.

This is a passive remediable issue. The administrator must add one of the datastores customAgentVmDatastore to the host.

This structure may be used only with operations rendered under `/eam`.

type NoCustomAgentVmNetwork 

type NoCustomAgentVmNetwork struct {
	NoAgentVmNetwork

	// A non-empty array of agent VM networks that is required on the host.
	//
	// Refers instances of `Network`.
	CustomAgentVmNetwork []types.ManagedObjectReference `xml:"customAgentVmNetwork" json:"customAgentVmNetwork"`
	// The names of the agent VM networks.
	CustomAgentVmNetworkName []string `xml:"customAgentVmNetworkName" json:"customAgentVmNetworkName"`
}

An agent virtual machine is expected to be deployed on a host, but the agent cannot be deployed because the agent network has not been configured on the host.

The host needs to be added to one of the networks listed in customAgentVmNetwork.

This is a passive remediable issue. The administrator must add one of the networks customAgentVmNetwork to the host.

This structure may be used only with operations rendered under `/eam`.

type NoDiscoverableAgentVmDatastore 

type NoDiscoverableAgentVmDatastore struct {
	VmNotDeployed
}

An agent virtual machine is expected to be deployed on a host, but the agent cannot be deployed because the agent VM datastore could not be discovered, as per defined selection policy, on the host.

This issue can be remediated passively if the administrator configures new datastores on the host.

This structure may be used only with operations rendered under `/eam`.

type NoDiscoverableAgentVmNetwork 

type NoDiscoverableAgentVmNetwork struct {
	VmNotDeployed
}

An agent virtual machine is expected to be deployed on a host, but the agent cannot be deployed because the agent VM network could not be discovered, as per defined selection policy, on the host.

This issue can be remediated passively if the administrator configures new networks on the host.

This structure may be used only with operations rendered under `/eam`.

type NotAuthorized 

type NotAuthorized struct {
	EamRuntimeFault
}

Thrown when an a user cannot be authorized.

This structure may be used only with operations rendered under `/eam`.

type NotAuthorizedFault 

type NotAuthorizedFault NotAuthorized

type OrphanedAgency 

type OrphanedAgency struct {
	AgencyIssue
}

Deprecated eAM no longer raises this issue. If agecny is getting orphaned EAM simply destroys it.

The solution that created the agency is no longer registered with the vCenter server.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager undeploys and removes the agency.

This structure may be used only with operations rendered under `/eam`.

type OrphanedDvFilterSwitch 

type OrphanedDvFilterSwitch struct {
	HostIssue
}

Deprecated dvFilters are no longer supported by EAM.

A dvFilter switch exists on a host but no agents on the host depend on dvFilter.

This typically happens if a host is disconnected when an agency configuration changed.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager removes the dvFilterSwitch.

This structure may be used only with operations rendered under `/eam`.

type OvfInvalidFormat 

type OvfInvalidFormat struct {
	VmNotDeployed

	// An optional list of errors that caused this issue.
	//
	// These errors are generated by the
	// vCenter server.
	Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
}

An Agent virtual machine is expected to be provisioned on a host, but it failed to do so because the provisioning of the OVF package failed.

The provisioning is unlikely to succeed until the solution that provides the OVF package has been upgraded or patched to provide a valid OVF package for the agent virtual machine.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the OVF provisioning again.

This structure may be used only with operations rendered under `/eam`.

type OvfInvalidProperty 

type OvfInvalidProperty struct {
	AgentIssue

	// An optional list of errors that caused this issue.
	//
	// These errors are
	// generated by the vCenter server.
	Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"`
}

An agent virtual machine needs to be provisioned or reconfigured, but an OVF property is either missing or has an invalid value.

This is a passive remediable issue. To remediate, update the OVF environment in the agent configuration used to provision the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type PersonalityAgencyCannotConfigureSolutions 

type PersonalityAgencyCannotConfigureSolutions struct {
	PersonalityAgencyPMIssue

	// Compute resource that couldn't be configured
	//
	// Refers instance of `ComputeResource`.
	Cr types.ManagedObjectReference `xml:"cr" json:"cr"`
	// Names of the solutions attempted to be modified
	SolutionsToModify []string `xml:"solutionsToModify,omitempty" json:"solutionsToModify,omitempty"`
	// Names of the solutions attempted to be removed
	SolutionsToRemove []string `xml:"solutionsToRemove,omitempty" json:"solutionsToRemove,omitempty"`
}

EAM was unable to set its required compute resource configuration in PM.

EAM configuration needs to be updated or PM needs to be repaired manually to allow the configuration.

This structure may be used only with operations rendered under `/eam`.

type PersonalityAgencyCannotUploadDepot 

type PersonalityAgencyCannotUploadDepot struct {
	PersonalityAgencyDepotIssue

	// URL EAM hosted the offline bundle as in vCenter.
	LocalDepotUrl string `xml:"localDepotUrl" json:"localDepotUrl"`
}

The offline depot could not be uploaded in Personality Manager.

This structure may be used only with operations rendered under `/eam`.

type PersonalityAgencyDepotIssue 

type PersonalityAgencyDepotIssue struct {
	PersonalityAgencyPMIssue

	// URL the offline bundle is configured in EAM.
	RemoteDepotUrl string `xml:"remoteDepotUrl" json:"remoteDepotUrl"`
}

Base class for all offline depot (VIB) issues while communicating with Personality Manager.

This structure may be used only with operations rendered under `/eam`.

func (*PersonalityAgencyDepotIssue) GetPersonalityAgencyDepotIssue 

func (b *PersonalityAgencyDepotIssue) GetPersonalityAgencyDepotIssue() *PersonalityAgencyDepotIssue

type PersonalityAgencyInaccessibleDepot 

type PersonalityAgencyInaccessibleDepot struct {
	PersonalityAgencyDepotIssue
}

The offline depot was not available for download during communicating with Personality Manager.

This structure may be used only with operations rendered under `/eam`.

type PersonalityAgencyInvalidDepot 

type PersonalityAgencyInvalidDepot struct {
	PersonalityAgencyDepotIssue
}

The offline depot has missing or invalid metadata to be usable by Personality Manager.

This structure may be used only with operations rendered under `/eam`.

type PersonalityAgencyPMIssue 

type PersonalityAgencyPMIssue struct {
	AgencyIssue
}

Base class for all issues which occurred during EAM communication with Personality Manager.

This structure may be used only with operations rendered under `/eam`.

func (*PersonalityAgencyPMIssue) GetPersonalityAgencyPMIssue 

func (b *PersonalityAgencyPMIssue) GetPersonalityAgencyPMIssue() *PersonalityAgencyPMIssue

type PersonalityAgencyPMUnavailable 

type PersonalityAgencyPMUnavailable struct {
	PersonalityAgencyPMIssue
}

PM service is not available - its endpoint cannot be accessed or it is malfunctioning.

This is an active and passive remediable issue. To remediate, vSphere ESX Agent Manager retries to access PM service.

This structure may be used only with operations rendered under `/eam`.

type PersonalityAgentAwaitingPMRemediation 

type PersonalityAgentAwaitingPMRemediation struct {
	PersonalityAgentPMIssue
}

The agent workflow is blocked until its' required solutions are re-mediated externally in Personality Manager.

This issue is only passively remediable. The desired state has to be applied in PM by an user.

This structure may be used only with operations rendered under `/eam`.

type PersonalityAgentBlockedByAgencyOperation 

type PersonalityAgentBlockedByAgencyOperation struct {
	PersonalityAgentPMIssue
}

The agent workflow is blocked by a failed agency operation with Personality Manager.

This issue is only passively remediable. The agency's PM related issue has to be resolved.

This structure may be used only with operations rendered under `/eam`.

type PersonalityAgentPMIssue 

type PersonalityAgentPMIssue struct {
	AgentIssue
}

Base class for all issues which occurred during EAM communication with Personality Manager.

This structure may be used only with operations rendered under `/eam`.

func (*PersonalityAgentPMIssue) GetPersonalityAgentPMIssue 

func (b *PersonalityAgentPMIssue) GetPersonalityAgentPMIssue() *PersonalityAgentPMIssue

type QueryAgency 

type QueryAgency QueryAgencyRequestType

type QueryAgencyRequestType 

type QueryAgencyRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type QueryAgencyResponse 

type QueryAgencyResponse struct {
	Returnval []types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type QueryAgent 

type QueryAgent QueryAgentRequestType

type QueryAgentRequestType 

type QueryAgentRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type QueryAgentResponse 

type QueryAgentResponse struct {
	Returnval []types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type QueryConfig 

type QueryConfig QueryConfigRequestType

type QueryConfigRequestType 

type QueryConfigRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type QueryConfigResponse 

type QueryConfigResponse struct {
	Returnval BaseAgencyConfigInfo `xml:"returnval,typeattr" json:"returnval"`
}

type QueryIssue 

type QueryIssue QueryIssueRequestType

type QueryIssueRequestType 

type QueryIssueRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// An optional array of issue keys. If not set, all issues for this
	// entity are returned.
	IssueKey []int32 `xml:"issueKey,omitempty" json:"issueKey,omitempty"`
}

The parameters of `EamObject.QueryIssue`.

type QueryIssueResponse 

type QueryIssueResponse struct {
	Returnval []BaseIssue `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"`
}

type QuerySolutionId 

type QuerySolutionId QuerySolutionIdRequestType

type QuerySolutionIdRequestType 

type QuerySolutionIdRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type QuerySolutionIdResponse 

type QuerySolutionIdResponse struct {
	Returnval string `xml:"returnval" json:"returnval"`
}

type RegisterAgentVm 

type RegisterAgentVm RegisterAgentVmRequestType

type RegisterAgentVmRequestType 

type RegisterAgentVmRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The managed object reference to the agent VM.
	//
	// Refers instance of `VirtualMachine`.
	AgentVm types.ManagedObjectReference `xml:"agentVm" json:"agentVm"`
}

The parameters of `Agency.RegisterAgentVm`.

type RegisterAgentVmResponse 

type RegisterAgentVmResponse struct {
	Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"`
}

type Resolve 

type Resolve ResolveRequestType

type ResolveAll 

type ResolveAll ResolveAllRequestType

type ResolveAllRequestType 

type ResolveAllRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type ResolveAllResponse 

type ResolveAllResponse struct {
}

type ResolveRequestType 

type ResolveRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// A non-empty array of issue keys.
	IssueKey []int32 `xml:"issueKey" json:"issueKey"`
}

The parameters of `EamObject.Resolve`.

type ResolveResponse 

type ResolveResponse struct {
	Returnval []int32 `xml:"returnval,omitempty" json:"returnval,omitempty"`
}

type ScanForUnknownAgentVm 

type ScanForUnknownAgentVm ScanForUnknownAgentVmRequestType

type ScanForUnknownAgentVmRequestType 

type ScanForUnknownAgentVmRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type ScanForUnknownAgentVmResponse 

type ScanForUnknownAgentVmResponse struct {
}

type SetMaintenanceModePolicyRequestType 

type SetMaintenanceModePolicyRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The policy to use.
	Policy string `xml:"policy" json:"policy"`
}

The parameters of `EsxAgentManager.SetMaintenanceModePolicy`.

type SolutionsApplySpec added in v0.31.0 

type SolutionsApplySpec struct {
	types.DynamicData

	// Complete desired state to be applied on the target entity.
	//
	// the solutions member limits which parts of this desired state to
	// be applied
	// If the solutions member is ommited.
	// Any solution described in this structure will be applied on the
	// target entity
	// Any solution already existing on the target entity, but missing
	// from this structure, will be deleted from the target entity
	DesiredState []SolutionsSolutionConfig `xml:"desiredState,omitempty" json:"desiredState,omitempty"`
	// If provided, limits the parts of the desiredState structure to
	// be applied on the target entity.
	//
	// solutions that are also present in the desiredState
	// structure will be applied on the target entity.
	// solutions that are missing from the desiredState structure
	// will be deleted from the target entity.
	Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"`
	// Specifies exact hosts to apply the desired state to, instead of every
	// host in the cluster.
	//
	// Refers instances of `HostSystem`.
	Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"`
}

Specification describing a desired state to be applied.

This structure may be used only with operations rendered under `/eam`.

type SolutionsComplianceResult added in v0.31.0 

type SolutionsComplianceResult struct {
	types.DynamicData

	// `True` if the compute resource is compliant with the described
	// desired state, `False` - otherwise.
	Compliant bool `xml:"compliant" json:"compliant"`
	// Detailed per-host compliance result of the compute resource.
	Hosts []SolutionsHostComplianceResult `xml:"hosts,omitempty" json:"hosts,omitempty"`
}

Result of a compliance check of a desired state on a compute resource.

This structure may be used only with operations rendered under `/eam`.

type SolutionsComplianceSpec added in v0.31.0 

type SolutionsComplianceSpec struct {
	types.DynamicData

	// Desired state to be checked for compliance.
	//
	// May be incomplete if exact
	// solutions to be checked are provided. Empty desired state means all
	// present solutions must be removed.
	DesiredState []SolutionsSolutionConfig `xml:"desiredState,omitempty" json:"desiredState,omitempty"`
	// Specifies exact solutions to be checked for compliance instead of the
	// complete desired state.
	Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"`
	// Specifies exact hosts to be checked for compliance, instead of every
	// host in the cluster.
	//
	// Refers instances of `HostSystem`.
	Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"`
}

Specification describing how to calculate compliance of a compute resource against a desired state.

This structure may be used only with operations rendered under `/eam`.

type SolutionsHookAcknowledgeConfig added in v0.31.0 

type SolutionsHookAcknowledgeConfig struct {
	types.DynamicData
}

Specifies the acknowledgement type of a configured System Virtual Machine's lifecycle hook.

This structure may be used only with operations rendered under `/eam`.

func (*SolutionsHookAcknowledgeConfig) GetSolutionsHookAcknowledgeConfig added in v0.31.0 

func (b *SolutionsHookAcknowledgeConfig) GetSolutionsHookAcknowledgeConfig() *SolutionsHookAcknowledgeConfig

type SolutionsHookConfig added in v0.31.0 

type SolutionsHookConfig struct {
	types.DynamicData

	// Type of the configured hook, possible values - `HooksHookType_enum`.
	Type string `xml:"type" json:"type"`
	// Type of acknoledgement of the configured hook.
	Acknowledgement BaseSolutionsHookAcknowledgeConfig `xml:"acknowledgement,typeattr" json:"acknowledgement"`
}

Configuration for System Virtual Machine's lifecycle hooks.

This structure may be used only with operations rendered under `/eam`.

type SolutionsHostBoundSolutionConfig added in v0.31.0 

type SolutionsHostBoundSolutionConfig struct {
	SolutionsTypeSpecificSolutionConfig

	// If set to true - default network and datastore configured on host will
	// take precedence over
	// `SolutionsHostBoundSolutionConfig.datastores` and
	// `SolutionsHostBoundSolutionConfig.networks`.
	PreferHostConfiguration *bool `xml:"preferHostConfiguration" json:"preferHostConfiguration,omitempty"`
	// networks to satisfy system Virtual Machine network adapter
	// requirements.
	//
	// If omitted - default configured network on the host will
	// be used.
	//
	// Refers instances of `Network`.
	Networks []types.ManagedObjectReference `xml:"networks,omitempty" json:"networks,omitempty"`
	// datastores to place system Virutal Machine on.
	//
	// If omitted - default
	// configured network on the host will be used.
	//
	// Refers instances of `Datastore`.
	Datastores []types.ManagedObjectReference `xml:"datastores,omitempty" json:"datastores,omitempty"`
	// VMCI to be allowed access from the system Virtual Machine.
	Vmci []string `xml:"vmci,omitempty" json:"vmci,omitempty"`
}

Specifies host-bound solution configuration.

This structure may be used only with operations rendered under `/eam`.

type SolutionsHostComplianceResult added in v0.31.0 

type SolutionsHostComplianceResult struct {
	types.DynamicData

	// The host being checked for compliance.
	//
	// Refers instance of `HostSystem`.
	Host types.ManagedObjectReference `xml:"host" json:"host"`
	// `True` if the compute host is compliant with the described
	// desired state, `False` - otherwise.
	Compliant bool `xml:"compliant" json:"compliant"`
	// Detailed per-solution compliance result of the host.
	Solutions []SolutionsSolutionComplianceResult `xml:"solutions,omitempty" json:"solutions,omitempty"`
}

Result of a compliance check of a desired state on a host.

This structure may be used only with operations rendered under `/eam`.

type SolutionsInteractiveHookAcknowledgeConfig added in v0.31.0 

type SolutionsInteractiveHookAcknowledgeConfig struct {
	SolutionsHookAcknowledgeConfig
}

The user will have to (manually) invoke an API (`Hooks#process`) to acknowledge, the user operations for this lifecycle hook have been completed.

This structure may be used only with operations rendered under `/eam`.

type SolutionsInvalidReason added in v0.31.0 

type SolutionsInvalidReason string

Reasons solution is not valid for application.

type SolutionsNonComplianceReason added in v0.31.0 

type SolutionsNonComplianceReason string

Describes possible reasons a solution is non compliant.

type SolutionsOvfProperty added in v0.31.0 

type SolutionsOvfProperty struct {
	types.DynamicData

	// The name of the property in the OVF descriptor.
	Key string `xml:"key" json:"key"`
	// The value of the property.
	Value string `xml:"value" json:"value"`
}

One OVF Property.

This structure may be used only with operations rendered under `/eam`.

type SolutionsProfileIdStoragePolicy added in v0.31.0 

type SolutionsProfileIdStoragePolicy struct {
	SolutionsStoragePolicy

	// ID of a storage policy profile created by the user.
	//
	// The type of the
	// profile must be `VirtualMachineDefinedProfileSpec`. The ID must be valid
	// `VirtualMachineDefinedProfileSpec.profileId`.
	ProfileId string `xml:"profileId" json:"profileId"`
}

Specifies a user defined profile ID to be applied during Virtual Machine creation.

This structure may be used only with operations rendered under `/eam`.

type SolutionsSolutionComplianceResult added in v0.31.0 

type SolutionsSolutionComplianceResult struct {
	types.DynamicData

	// Solution checked for compliance.
	Solution string `xml:"solution" json:"solution"`
	// `True` if the compute solution is compliant with the described
	// desired state, `False` - otherwise.
	Compliant bool `xml:"compliant" json:"compliant"`
	// Reason the solution is non-compliant
	// `SolutionsNonComplianceReason_enum`.
	NonComplianceReason string `xml:"nonComplianceReason,omitempty" json:"nonComplianceReason,omitempty"`
	// system Virtual Machine created for the solution.
	//
	// Refers instance of `VirtualMachine`.
	Vm *types.ManagedObjectReference `xml:"vm,omitempty" json:"vm,omitempty"`
	// system Virtual Machine created for upgrading the obsoleted system
	// Virtual Machine.
	//
	// Refers instance of `VirtualMachine`.
	UpgradingVm *types.ManagedObjectReference `xml:"upgradingVm,omitempty" json:"upgradingVm,omitempty"`
	// Hook, ESX Agent Manager is awaiting to be processed for this solution.
	Hook *HooksHookInfo `xml:"hook,omitempty" json:"hook,omitempty"`
	// Issues, ESX Agent Manager has encountered while attempting to acheive
	// the solution's requested desired state.
	Issues []BaseIssue `xml:"issues,omitempty,typeattr" json:"issues,omitempty"`
	// Last desired state for the solution, requested from ESX Agent Manager,
	// for application.
	SolutionConfig *SolutionsSolutionConfig `xml:"solutionConfig,omitempty" json:"solutionConfig,omitempty"`
}

Result of a compliance check of a desired state dor a solution(on a host).

This structure may be used only with operations rendered under `/eam`.

type SolutionsSolutionConfig added in v0.31.0 

type SolutionsSolutionConfig struct {
	types.DynamicData

	// Solution, this configuration belongs to.
	Solution string `xml:"solution" json:"solution"`
	// Name of the solution.
	//
	// Will be utilized as a prefix for the system
	// Virtual Machines' names created for the solution.
	Name string `xml:"name" json:"name"`
	// Version of the solution.
	Version string `xml:"version" json:"version"`
	// Source of the system Virtual Machine files.
	VmSource BaseSolutionsVMSource `xml:"vmSource,typeattr" json:"vmSource"`
	// If set to `True` - will insert an UUID in the system Virtual
	// Machines' names created for the solution, otherwise - no additional
	// UUID will be inserted in the system Virtual Machines' names.
	UuidVmName bool `xml:"uuidVmName" json:"uuidVmName"`
	// Resource pool to place the system Virtual Machine in.
	//
	// If omitted a
	// default resource pool will be used.
	//
	// Refers instance of `ResourcePool`.
	ResourcePool *types.ManagedObjectReference `xml:"resourcePool,omitempty" json:"resourcePool,omitempty"`
	// Folder to place the system Virtual Machine in.
	//
	// If omitted a default
	// folder will be used.
	//
	// Refers instance of `Folder`.
	Folder *types.ManagedObjectReference `xml:"folder,omitempty" json:"folder,omitempty"`
	// User configurable OVF properties to be assigned during system Virtual
	// Machine creation.
	OvfProperties []SolutionsOvfProperty `xml:"ovfProperties,omitempty" json:"ovfProperties,omitempty"`
	// Storage policies to be applied during system Virtual Machine creation.
	StoragePolicies []BaseSolutionsStoragePolicy `xml:"storagePolicies,omitempty,typeattr" json:"storagePolicies,omitempty"`
	// Provisioning type for the system Virtual Machines
	// `SolutionsVMDiskProvisioning_enum`.
	//
	// Default provisioning will be used
	// if not specified.
	VmDiskProvisioning string `xml:"vmDiskProvisioning,omitempty" json:"vmDiskProvisioning,omitempty"`
	// Optimization strategy for deploying Virtual Machines
	// `SolutionsVMDeploymentOptimization_enum`.
	//
	// Default optimization will
	// be selected if not specified.
	VmDeploymentOptimization string `xml:"vmDeploymentOptimization,omitempty" json:"vmDeploymentOptimization,omitempty"`
	// Solution type-specific configuration.
	TypeSpecificConfig BaseSolutionsTypeSpecificSolutionConfig `xml:"typeSpecificConfig,typeattr" json:"typeSpecificConfig"`
	// Lifecycle hooks for the solution's virtual machines.
	Hooks []SolutionsHookConfig `xml:"hooks,omitempty" json:"hooks,omitempty"`
}

Configuration for a solution's required system Virtual Machine.

This structure may be used only with operations rendered under `/eam`.

type SolutionsSolutionValidationResult added in v0.31.0 

type SolutionsSolutionValidationResult struct {
	types.DynamicData

	// Validated solution.
	Solution string `xml:"solution" json:"solution"`
	// `True` - if the solution is valid for application, `False`
	// \- otherwise.
	Valid bool `xml:"valid" json:"valid"`
	// Populated with the reason the solution is not valid for application
	// `SolutionsInvalidReason_enum`.
	InvalidReason string `xml:"invalidReason,omitempty" json:"invalidReason,omitempty"`
}

Result of validation, of a solution, for application.

This structure may be used only with operations rendered under `/eam`.

type SolutionsStoragePolicy added in v0.31.0 

type SolutionsStoragePolicy struct {
	types.DynamicData
}

Storage policy to be applied during system Virtual Machine creation.

This structure may be used only with operations rendered under `/eam`.

func (*SolutionsStoragePolicy) GetSolutionsStoragePolicy added in v0.31.0 

func (b *SolutionsStoragePolicy) GetSolutionsStoragePolicy() *SolutionsStoragePolicy

type SolutionsTransitionSpec added in v0.31.0 

type SolutionsTransitionSpec struct {
	types.DynamicData

	// Solution to transition from an old legacy agency.
	Solution string `xml:"solution" json:"solution"`
	// Old legacy agency ID to transition from.
	AgencyId string `xml:"agencyId" json:"agencyId"`
}

Specification necessary to transition a solution from an existing legacy agency.

This structure may be used only with operations rendered under `/eam`.

type SolutionsTypeSpecificSolutionConfig added in v0.31.0 

type SolutionsTypeSpecificSolutionConfig struct {
	types.DynamicData
}

Specifies the specific solution configuration based on its type.

This structure may be used only with operations rendered under `/eam`.

func (*SolutionsTypeSpecificSolutionConfig) GetSolutionsTypeSpecificSolutionConfig added in v0.31.0 

func (b *SolutionsTypeSpecificSolutionConfig) GetSolutionsTypeSpecificSolutionConfig() *SolutionsTypeSpecificSolutionConfig

type SolutionsUrlVMSource added in v0.31.0 

type SolutionsUrlVMSource struct {
	SolutionsVMSource

	// URL to the solution's system Virtual Machine OVF.
	OvfUrl string `xml:"ovfUrl" json:"ovfUrl"`
	// PEM encoded certificate to use to trust the URL.
	//
	// If omitted - will
	// implicitly trust the URL.
	CertificatePEM string `xml:"certificatePEM,omitempty" json:"certificatePEM,omitempty"`
}

Specified the system Virtual Machine sources are to be obtained from an URL.

This structure may be used only with operations rendered under `/eam`.

type SolutionsVMDeploymentOptimization added in v0.31.0 

type SolutionsVMDeploymentOptimization string

Virtual Machine deployment optimization strategies.

type SolutionsVMDiskProvisioning added in v0.31.0 

type SolutionsVMDiskProvisioning string

Provisioning types for system Virtual Machines.

type SolutionsVMSource added in v0.31.0 

type SolutionsVMSource struct {
	types.DynamicData
}

Specifies how to find the files of the system Virtual Machine to be created.

This structure may be used only with operations rendered under `/eam`.

func (*SolutionsVMSource) GetSolutionsVMSource added in v0.31.0 

func (b *SolutionsVMSource) GetSolutionsVMSource() *SolutionsVMSource

type SolutionsValidateSpec added in v0.31.0 

type SolutionsValidateSpec struct {
	types.DynamicData

	// Desired state to be validated.
	DesiredState []SolutionsSolutionConfig `xml:"desiredState" json:"desiredState"`
}

Specification describing a desired state to be validated for application.

This structure may be used only with operations rendered under `/eam`.

type SolutionsValidationResult added in v0.31.0 

type SolutionsValidationResult struct {
	types.DynamicData

	// `True` - if the desired state is valid for application,
	// `False` - otherwise.
	Valid bool `xml:"valid" json:"valid"`
	// Detailed per-solution result of the validation.
	SolutionResult []SolutionsSolutionValidationResult `xml:"solutionResult,omitempty" json:"solutionResult,omitempty"`
}

Result of validation, of a desired state, for application.

This structure may be used only with operations rendered under `/eam`.

type Uninstall 

type Uninstall UninstallRequestType

type UninstallRequestType 

type UninstallRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
}

type UninstallResponse 

type UninstallResponse struct {
}

type UnknownAgentVm 

type UnknownAgentVm struct {
	HostIssue

	// The unknown agent virtual machine.
	//
	// Refers instance of `VirtualMachine`.
	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
}

Deprecated presence of unknown VMs is no more acceptable.

An agent virtual machine has been found in the vCenter inventory that does not belong to any agency in this vSphere ESX Agent Manager server instance.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers off (if powered on) and deletes the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type UnregisterAgentVm 

type UnregisterAgentVm UnregisterAgentVmRequestType

type UnregisterAgentVmRequestType 

type UnregisterAgentVmRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The managed object reference to the agent VM.
	//
	// Refers instance of `VirtualMachine`.
	AgentVm types.ManagedObjectReference `xml:"agentVm" json:"agentVm"`
}

The parameters of `Agency.UnregisterAgentVm`.

type UnregisterAgentVmResponse 

type UnregisterAgentVmResponse struct {
}

type Update 

type Update UpdateRequestType

type UpdateRequestType 

type UpdateRequestType struct {
	This types.ManagedObjectReference `xml:"_this" json:"_this"`
	// The new configuration for this <code>Agency</code>
	Config BaseAgencyConfigInfo `xml:"config,typeattr" json:"config"`
}

The parameters of `Agency.Update`.

type UpdateResponse 

type UpdateResponse struct {
}

type VersionURI 

type VersionURI string

type VibCannotPutHostInMaintenanceMode 

type VibCannotPutHostInMaintenanceMode struct {
	VibIssue
}

A VIB module requires the host to be in maintenance mode, but the vSphere ESX Agent Manager is unable toput the host in maintenance mode.

This can happen if there are virtual machines running on the host that cannot be moved and must be stopped before the host can enter maintenance mode.

This is an active remediable issue. To remediate, the vSphere ESX Agent Manager will try again to put the host into maintenance mode. However, the vSphere ESX Agent Manager will not power off or move any virtual machines to put the host into maintenance mode. This must be done by the client.

This structure may be used only with operations rendered under `/eam`.

type VibCannotPutHostOutOfMaintenanceMode 

type VibCannotPutHostOutOfMaintenanceMode struct {
	VibIssue
}

ESXi host is in Maintenance Mode.

This prevents powering on and re-configuring Agent Virtual Machines. Also if the host's entering in Maintenance Mode was initiated by vSphere Esx Agent Manager, the same is responsible to initiate exit Maintenance Mode.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host out of Maintenance Mode.

This structure may be used only with operations rendered under `/eam`.

type VibDependenciesNotMetByHost 

type VibDependenciesNotMetByHost struct {
	VibNotInstalled
}

A VIB module is expected to be installed on a host, but the dependencies, describred within the module, were not satisfied by the host.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the VIB installation again.

This structure may be used only with operations rendered under `/eam`.

type VibInvalidFormat 

type VibInvalidFormat struct {
	VibNotInstalled
}

A VIB module is expected to be installed on a host, but it failed to install since the VIB package is in an invalid format.

The installation is unlikely to succeed until the solution provding the bundle has been upgraded or patched to provide a valid VIB package.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the VIB installation again.

This structure may be used only with operations rendered under `/eam`.

type VibIssue 

type VibIssue struct {
	AgentIssue
}

Base class for all issues related to the VIB modules that belong to an agent.

This structure may be used only with operations rendered under `/eam`.

func (*VibIssue) GetVibIssue 

func (b *VibIssue) GetVibIssue() *VibIssue

type VibNotInstalled 

type VibNotInstalled struct {
	VibIssue
}

A VIB module is expected to be installed/removed on a host, but it has not been installed/removed.

Typically, a more specific issue (a subclass of this issue) indicates the particular reason why the VIB module operation failed.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the VIB operation again. In case of unreachable host vSphere ESX Agent Manager will remediate the issue automatically when the host becomes reachable.

This structure may be used only with operations rendered under `/eam`.

func (*VibNotInstalled) GetVibNotInstalled 

func (b *VibNotInstalled) GetVibNotInstalled() *VibNotInstalled

type VibRequirementsNotMetByHost 

type VibRequirementsNotMetByHost struct {
	VibNotInstalled
}

A VIB module is expected to be installed on a host, but the system requirements, describred within the module, were not satisfied by the host.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the VIB installation again.

This structure may be used only with operations rendered under `/eam`.

type VibRequiresHostInMaintenanceMode 

type VibRequiresHostInMaintenanceMode struct {
	VibIssue
}

A VIB module has been uploaded to the host, but will not be fully installed until the host has been put in maintenance mode.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host into maintenance mode.

This structure may be used only with operations rendered under `/eam`.

type VibRequiresHostReboot 

type VibRequiresHostReboot struct {
	VibIssue
}

A VIB module has been uploaded to the host, but will not be activated until the host is rebooted.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host into maintenance mode and reboots it.

This structure may be used only with operations rendered under `/eam`.

type VibRequiresManualInstallation 

type VibRequiresManualInstallation struct {
	VibIssue

	// A non-empty array of bulletins required to be installed on the host.
	Bulletin []string `xml:"bulletin" json:"bulletin"`
}

A VIB module failed to install, but failed to do so because automatic installation by vSphere ESX Agent Manager is not allowed on the host.

This is a passive remediable issue. To remediate, go to VMware Update Manager and install the required bulletins on the host or add the bulletins to the host's image profile.

This structure may be used only with operations rendered under `/eam`.

type VibRequiresManualUninstallation 

type VibRequiresManualUninstallation struct {
	VibIssue

	// A non-empty array of bulletins required to be uninstalled on the host.
	Bulletin []string `xml:"bulletin" json:"bulletin"`
}

A VIB module failed to uninstall, but failed to do so because automatic uninstallation by vSphere ESX Agent Manager is not allowed on the host.

This is a passive remediable issue. To remediate, go to VMware Update Manager and uninstall the required bulletins on the host or remove the bulletins from the host's image profile.

This structure may be used only with operations rendered under `/eam`.

type VibVibInfo 

type VibVibInfo struct {
	types.DynamicData

	Id           string                  `xml:"id" json:"id"`
	Name         string                  `xml:"name" json:"name"`
	Version      string                  `xml:"version" json:"version"`
	Vendor       string                  `xml:"vendor" json:"vendor"`
	Summary      string                  `xml:"summary" json:"summary"`
	SoftwareTags *VibVibInfoSoftwareTags `xml:"softwareTags,omitempty" json:"softwareTags,omitempty"`
	ReleaseDate  time.Time               `xml:"releaseDate" json:"releaseDate"`
}

A data entity providing information about a VIB.

This abstraction contains only those of the VIB attributes which convey important information for the client to identify, preview and select VIBs.

This structure may be used only with operations rendered under `/eam`.

type VibVibInfoSoftwareTags 

type VibVibInfoSoftwareTags struct {
	types.DynamicData

	Tags []string `xml:"tags,omitempty" json:"tags,omitempty"`
}

A data entity providing information about software tags of a VIB

This structure may be used only with operations rendered under `/eam`.

type VibVibServicesAnyCertificate added in v0.31.0 

type VibVibServicesAnyCertificate struct {
	VibVibServicesSslTrust
}

Specifies an SSL policy that trusts any SSL certificate.

This structure may be used only with operations rendered under `/eam`.

type VibVibServicesPinnedPemCertificate added in v0.31.0 

type VibVibServicesPinnedPemCertificate struct {
	VibVibServicesSslTrust

	// PEM encoded pinned SSL certificate of the server that needs to be
	// trusted.
	SslCertificate string `xml:"sslCertificate" json:"sslCertificate"`
}

Specifies an SSL policy that trusts one specific pinned PEM encoded SSL certificate.

This structure may be used only with operations rendered under `/eam`.

type VibVibServicesSslTrust added in v0.31.0 

type VibVibServicesSslTrust struct {
	types.DynamicData
}

func (*VibVibServicesSslTrust) GetVibVibServicesSslTrust added in v0.31.0 

func (b *VibVibServicesSslTrust) GetVibVibServicesSslTrust() *VibVibServicesSslTrust

type VmCorrupted 

type VmCorrupted struct {
	VmIssue

	// An optional path for a missing file.
	MissingFile string `xml:"missingFile,omitempty" json:"missingFile,omitempty"`
}

An agent virtual machine is corrupted.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager deletes and reprovisions the agent virtual machine. To remediate manually, fix the missing file issue and power on the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type VmDeployed 

type VmDeployed struct {
	VmIssue
}

An agent virtual machine is expected to be removed from a host, but the agent virtual machine has not been removed.

Typically, a more specific issue (a subclass of this issue) indicates the particular reason why vSphere ESX Agent Manager was unable to remove the agent virtual machine, such as the host is in maintenance mode, powered off or in standby mode.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent.

This structure may be used only with operations rendered under `/eam`.

func (*VmDeployed) GetVmDeployed 

func (b *VmDeployed) GetVmDeployed() *VmDeployed

type VmIssue 

type VmIssue struct {
	AgentIssue

	// The virtual machine to which this issue is related.
	//
	// Refers instance of `VirtualMachine`.
	Vm types.ManagedObjectReference `xml:"vm" json:"vm"`
}

Base class for all issues related to the deployed virtual machine for a particular agent.

This structure may be used only with operations rendered under `/eam`.

func (*VmIssue) GetVmIssue 

func (b *VmIssue) GetVmIssue() *VmIssue

type VmMarkedAsTemplate 

type VmMarkedAsTemplate struct {
	VmIssue
}

Deprecated template agent VMs are not used anymore by VM deployment and monitoring.

An agent virtual machine is a virtual machine template.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager converts the agent virtual machine template to a virtual machine.

This structure may be used only with operations rendered under `/eam`.

type VmNotDeployed 

type VmNotDeployed struct {
	AgentIssue
}

An agent virtual machine is expected to be deployed on a host, but the agent virtual machine has not been deployed.

Typically, a more specific issue (a subclass of this issue) indicates the particular reason why vSphere ESX Agent Manager was unable to deploy the agent, such as being unable to access the OVF package for the agent or a missing host configuration. This issue can also happen if the agent virtual machine is explicitly deleted from the host.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

func (*VmNotDeployed) GetVmNotDeployed 

func (b *VmNotDeployed) GetVmNotDeployed() *VmNotDeployed

type VmOrphaned 

type VmOrphaned struct {
	VmIssue
}

An agent virtual machine exists on a host, but the host is no longer part of scope for the agency.

This typically happens if a host is disconnected when the agency configuration is changed.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager deletes the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type VmPoweredOff 

type VmPoweredOff struct {
	VmIssue
}

An agent virtual machine is expected to be powered on, but the agent virtual machine is powered off.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers on the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

func (*VmPoweredOff) GetVmPoweredOff 

func (b *VmPoweredOff) GetVmPoweredOff() *VmPoweredOff

type VmPoweredOn 

type VmPoweredOn struct {
	VmIssue
}

An agent virtual machine is expected to be powered off, but the agent virtual machine is powered on.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers off the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type VmRequiresHostOutOfMaintenanceMode 

type VmRequiresHostOutOfMaintenanceMode struct {
	VmNotDeployed
}

An agent virtual machine is expected to be deployed on a host, but the agent virtual machine cannot be deployed because the host is in Maintenance Mode.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager takes the host out of Maintenance Mode and deploys the agent virtual machine.

Resolving this issue in vSphere Lifecyle Manager environemnt will be no-op. In those cases user must take the host out of Maintenance Mode manually or wait vSphere Lifecycle Maanger cluster remediation to complete (if any).

This structure may be used only with operations rendered under `/eam`.

type VmSuspended 

type VmSuspended struct {
	VmIssue
}

An agent virtual machine is expected to be powered on, but the agent virtual machine is suspended.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers on the agent virtual machine.

This structure may be used only with operations rendered under `/eam`.

type VmWrongFolder 

type VmWrongFolder struct {
	VmIssue

	// The folder in which the virtual machine currently resides.
	//
	// Refers instance of `Folder`.
	CurrentFolder types.ManagedObjectReference `xml:"currentFolder" json:"currentFolder"`
	// The ESX agent folder in which the virtual machine should reside.
	//
	// Refers instance of `Folder`.
	RequiredFolder types.ManagedObjectReference `xml:"requiredFolder" json:"requiredFolder"`
}

Deprecated eAM does not try to override any action powerfull user has taken.

An agent virtual machine is expected to be located in a designated agent virtual machine folder, but is found in a different folder.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager moves the agent virtual machine back into the designated agent folder.

This structure may be used only with operations rendered under `/eam`.

type VmWrongResourcePool 

type VmWrongResourcePool struct {
	VmIssue

	// The resource pool in which the VM currently resides.
	//
	// Refers instance of `ResourcePool`.
	CurrentResourcePool types.ManagedObjectReference `xml:"currentResourcePool" json:"currentResourcePool"`
	// The ESX agent resource pool in which the VM should reside.
	//
	// Refers instance of `ResourcePool`.
	RequiredResourcePool types.ManagedObjectReference `xml:"requiredResourcePool" json:"requiredResourcePool"`
}

Deprecated eAM does not try to override any action powerfull user has taken.

An agent virtual machine is expected to be located in a designated agent virtual machine resource pool, but is found in a different resource pool.

This is an active remediable issue. To remediate, vSphere ESX Agent Manager moves the agent virtual machine back into the designated agent resource pool.

This structure may be used only with operations rendered under `/eam`.

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.