github.com/vmware/govmomi@v0.43.0/eam/types/types.go (about) 1 /* 2 Copyright (c) 2021-2024 VMware, Inc. All Rights Reserved. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package types 18 19 import ( 20 "reflect" 21 "time" 22 23 "github.com/vmware/govmomi/vim25/types" 24 ) 25 26 type AddIssue AddIssueRequestType 27 28 func init() { 29 types.Add("eam:AddIssue", reflect.TypeOf((*AddIssue)(nil)).Elem()) 30 } 31 32 // The parameters of `Agency.AddIssue`. 33 // 34 // This structure may be used only with operations rendered under `/eam`. 35 type AddIssueRequestType struct { 36 This types.ManagedObjectReference `xml:"_this" json:"_this"` 37 // A new issue. 38 Issue BaseIssue `xml:"issue,typeattr" json:"issue"` 39 } 40 41 func init() { 42 types.Add("eam:AddIssueRequestType", reflect.TypeOf((*AddIssueRequestType)(nil)).Elem()) 43 } 44 45 type AddIssueResponse struct { 46 Returnval BaseIssue `xml:"returnval,typeattr" json:"returnval"` 47 } 48 49 // Scope specifies on which compute resources to deploy a solution's agents. 50 // 51 // This structure may be used only with operations rendered under `/eam`. 52 type AgencyComputeResourceScope struct { 53 AgencyScope 54 55 // Compute resources on which to deploy the agents. 56 // 57 // If `AgencyConfigInfoEx.vmPlacementPolicy` is set, the array needs to 58 // contain exactly one cluster compute resource. 59 // 60 // Refers instances of `ComputeResource`. 61 ComputeResource []types.ManagedObjectReference `xml:"computeResource,omitempty" json:"computeResource,omitempty"` 62 } 63 64 func init() { 65 types.Add("eam:AgencyComputeResourceScope", reflect.TypeOf((*AgencyComputeResourceScope)(nil)).Elem()) 66 } 67 68 // This is the configuration of an <code>Agency</code>. 69 // 70 // It determines on 71 // which compute resources to deploy the agents, which VIB to install, which 72 // OVF package to install, and how to configure these items by setting the 73 // OVF environment properties. 74 // 75 // This structure may be used only with operations rendered under `/eam`. 76 type AgencyConfigInfo struct { 77 types.DynamicData 78 79 // A list of `AgentConfigInfo`s for hosts covered by this 80 // <code>Agency</code>. 81 // 82 // When provisioning a new agent to a host, vSphere 83 // ESX Agent Manager tries to find, from left to right in the array, a 84 // match for an `AgentConfigInfo` and stops searching at the first 85 // one that it finds. 86 // If `AgencyConfigInfoEx.vmPlacementPolicy` is set, the array needs to contain only a 87 // single agent config. In that case the agent config is not bound to a 88 // specific host, but to the whole cluster. 89 AgentConfig []AgentConfigInfo `xml:"agentConfig,omitempty" json:"agentConfig,omitempty"` 90 // The scope of the <code>Agency</code>. 91 Scope BaseAgencyScope `xml:"scope,omitempty,typeattr" json:"scope,omitempty"` 92 // If set to <code>true</code>, the client of this agency must manually 93 // mark the agent as ready after the agent virtual machine has been 94 // provisioned. 95 // 96 // This is useful if the client of this solution performs 97 // some extra reconfiguration of the agent virtual machine before it is 98 // powered on. 99 // 100 // See also `Agent.MarkAsAvailable`. 101 ManuallyMarkAgentVmAvailableAfterProvisioning *bool `xml:"manuallyMarkAgentVmAvailableAfterProvisioning" json:"manuallyMarkAgentVmAvailableAfterProvisioning,omitempty"` 102 // If set to <code>true</code>, the client of this agency must manually 103 // mark the agent as ready after the agent virtual machine has been 104 // powered on. 105 // 106 // In this case, DRS will not regard the agent virtual machine 107 // as ready until the client has marked the agent as ready. 108 // 109 // See also `Agent.MarkAsAvailable`. 110 ManuallyMarkAgentVmAvailableAfterPowerOn *bool `xml:"manuallyMarkAgentVmAvailableAfterPowerOn" json:"manuallyMarkAgentVmAvailableAfterPowerOn,omitempty"` 111 // If set to <code>true</code>, ESX Agent Manager will use vSphere Linked 112 // Clones to speed up the deployment of agent virtual machines. 113 // 114 // Using 115 // linked clones implies that the agent virtual machines cannot use 116 // Storage vMotion to move to another vSphere datastore. 117 // If set to <code>false</code>, ESX Agent Manager will use Full VM 118 // Cloning. 119 // If unset default is <code>true<code>. 120 OptimizedDeploymentEnabled *bool `xml:"optimizedDeploymentEnabled" json:"optimizedDeploymentEnabled,omitempty"` 121 // An optional name to use when naming agent virtual machines. 122 // 123 // For 124 // example, if set to "example-agent", each agent virtual machine will be 125 // named "example-agent (1)", "example-agent (2)", and so on. The maximum 126 // length of <code>agentName</code> is 70 characters. 127 AgentName string `xml:"agentName,omitempty" json:"agentName,omitempty"` 128 // Name of the agency. 129 // 130 // Must be set when creating the agency. 131 AgencyName string `xml:"agencyName,omitempty" json:"agencyName,omitempty"` 132 // Property <code>agentName</code> is required if this property is set to 133 // <code>true</code>. 134 // 135 // If set to <code>true</code>, ESX Agent Manager will name virtual 136 // machines with UUID suffix. For example, "example-agent-UUID". 137 // In this case, the maximum length of <code>agentName</code> is 43 138 // characters. 139 // 140 // If not set or is set to <code>false</code>, virtual 141 // machines will not contain UUID in their name. 142 UseUuidVmName *bool `xml:"useUuidVmName" json:"useUuidVmName,omitempty"` 143 // Deprecated use automatically provisioned VMs and register hooks to 144 // have control post provisioning and power on. 145 // 146 // Set to true if agent VMs are manually provisioned. 147 // 148 // If unset, defaults 149 // to false. 150 ManuallyProvisioned *bool `xml:"manuallyProvisioned" json:"manuallyProvisioned,omitempty"` 151 // Deprecated use automatically provisioned VMs and register hooks to 152 // have control post provisioning and power on. 153 // 154 // Set to true if agent VMs are manually monitored. 155 // 156 // If unset, defaults to 157 // false. This can only be set to true if 158 // `AgencyConfigInfo.manuallyProvisioned` is set to true. 159 ManuallyMonitored *bool `xml:"manuallyMonitored" json:"manuallyMonitored,omitempty"` 160 // Deprecated vUM is no more consulted so this property has no sense 161 // anymore. 162 // 163 // Set to true will install VIBs directly on the hosts even if VMware 164 // Update Manager is installed. 165 // 166 // If unset, defaults to false. 167 BypassVumEnabled *bool `xml:"bypassVumEnabled" json:"bypassVumEnabled,omitempty"` 168 // Specifies the networks which to be configured on the agent VMs. 169 // 170 // This property is only applicable for pinned to host VMs - i.e. 171 // (`AgencyConfigInfoEx.vmPlacementPolicy`) is not set. 172 // 173 // If not set or `AgencyConfigInfo.preferHostConfiguration` is set to true, the 174 // default host agent VM network (configured through 175 // vim.host.EsxAgentHostManager) is used, otherwise the first network from 176 // the array that is present on the host is used. 177 // 178 // At most one of `AgencyConfigInfo.agentVmNetwork` and `AgencyConfigInfoEx.vmNetworkMapping` 179 // needs to be set. 180 // 181 // Refers instances of `Network`. 182 AgentVmNetwork []types.ManagedObjectReference `xml:"agentVmNetwork,omitempty" json:"agentVmNetwork,omitempty"` 183 // The datastores used to configure the storage on the agent VMs. 184 // 185 // This property is required if `AgencyConfigInfoEx.vmPlacementPolicy` is set and 186 // `AgencyConfigInfoEx.datastoreSelectionPolicy` is not set. In that case the first 187 // element from the list is used. 188 // 189 // If not set or `AgencyConfigInfo.preferHostConfiguration` is set to true and 190 // `AgencyConfigInfoEx.vmPlacementPolicy` is not set, the default host agent VM 191 // datastore (configured through vim.host.EsxAgentHostManager) is used, 192 // otherwise the first datastore from the array that is present on the 193 // host is used. 194 // 195 // If `AgencyConfigInfoEx.vmPlacementPolicy` is set at most one of 196 // `AgencyConfigInfo.agentVmDatastore` and `AgencyConfigInfoEx.datastoreSelectionPolicy` needs 197 // to be set. If `AgencyConfigInfoEx.vmPlacementPolicy` is not set 198 // `AgencyConfigInfoEx.datastoreSelectionPolicy` takes precedence over 199 // `AgencyConfigInfo.agentVmDatastore` . 200 // 201 // Refers instances of `Datastore`. 202 AgentVmDatastore []types.ManagedObjectReference `xml:"agentVmDatastore,omitempty" json:"agentVmDatastore,omitempty"` 203 // If set to true the default agent VM datastore and network will take 204 // precedence over `AgencyConfigInfo.agentVmNetwork` and 205 // `AgencyConfigInfo.agentVmDatastore` when configuring the agent 206 // VMs. 207 // 208 // This property is not used if `AgencyConfigInfoEx.vmPlacementPolicy` is set. 209 PreferHostConfiguration *bool `xml:"preferHostConfiguration" json:"preferHostConfiguration,omitempty"` 210 // Deprecated that is a custom configuration that should be setup by the 211 // agency owner. One way is to use 212 // `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterPowerOn` or 213 // `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning` 214 // hooks. 215 // 216 // If set, a property with id "ip" and value an IP from the pool is added 217 // to the vApp configuration of the deployed VMs. 218 IpPool *types.IpPool `xml:"ipPool,omitempty" json:"ipPool,omitempty"` 219 // Defines the resource pools where VMs to be deployed. 220 // 221 // If specified, the VMs for every compute resouce in the scope will be 222 // deployed to its corresponding resource pool. 223 // If not specified, the agent VMs for each compute resource will be 224 // deployed under top level nested resource pool created for the agent 225 // VMs. If unable to create a nested resource pool, the root resource pool 226 // of the compute resource will be used. 227 ResourcePools []AgencyVMResourcePool `xml:"resourcePools,omitempty" json:"resourcePools,omitempty"` 228 // Defines the folders where VMs to be deployed. 229 // 230 // If specified, the VMs for every compute resouce in the scope will be 231 // deployed to its corresponding folder. The link is made between the 232 // compute resource parent and the datacenter the folder belongs to 233 // `AgencyVMFolder.datacenterId`. 234 // If not specified, the agent VMs for each compute resource will be 235 // deployed in top level folder created in each datacenter for the agent 236 // VMs. 237 Folders []AgencyVMFolder `xml:"folders,omitempty" json:"folders,omitempty"` 238 } 239 240 func init() { 241 types.Add("eam:AgencyConfigInfo", reflect.TypeOf((*AgencyConfigInfo)(nil)).Elem()) 242 } 243 244 // Agency is disabled - one or more ClusterComputeResources from it's scope are 245 // disabled. 246 // 247 // This is not a remediable issue. To remediate, re-enable the cluster. 248 // 249 // This structure may be used only with operations rendered under `/eam`. 250 type AgencyDisabled struct { 251 AgencyIssue 252 } 253 254 func init() { 255 types.Add("eam:AgencyDisabled", reflect.TypeOf((*AgencyDisabled)(nil)).Elem()) 256 types.AddMinAPIVersionForType("eam:AgencyDisabled", "7.6") 257 } 258 259 // Base class for all agency issues. 260 // 261 // This structure may be used only with operations rendered under `/eam`. 262 type AgencyIssue struct { 263 Issue 264 265 // The agency to which this issue belongs. 266 // 267 // Refers instance of `Agency`. 268 Agency types.ManagedObjectReference `xml:"agency" json:"agency"` 269 // The name of the agency. 270 AgencyName string `xml:"agencyName" json:"agencyName"` 271 // The ID of the solution to which this issue belongs. 272 SolutionId string `xml:"solutionId" json:"solutionId"` 273 // The name of the solution to which this issue belongs. 274 SolutionName string `xml:"solutionName" json:"solutionName"` 275 } 276 277 func init() { 278 types.Add("eam:AgencyIssue", reflect.TypeOf((*AgencyIssue)(nil)).Elem()) 279 } 280 281 type AgencyQueryRuntime AgencyQueryRuntimeRequestType 282 283 func init() { 284 types.Add("eam:AgencyQueryRuntime", reflect.TypeOf((*AgencyQueryRuntime)(nil)).Elem()) 285 } 286 287 type AgencyQueryRuntimeRequestType struct { 288 This types.ManagedObjectReference `xml:"_this" json:"_this"` 289 } 290 291 func init() { 292 types.Add("eam:AgencyQueryRuntimeRequestType", reflect.TypeOf((*AgencyQueryRuntimeRequestType)(nil)).Elem()) 293 } 294 295 type AgencyQueryRuntimeResponse struct { 296 Returnval BaseEamObjectRuntimeInfo `xml:"returnval,typeattr" json:"returnval"` 297 } 298 299 // Scope specifies which where to deploy agents. 300 // 301 // This structure may be used only with operations rendered under `/eam`. 302 type AgencyScope struct { 303 types.DynamicData 304 } 305 306 func init() { 307 types.Add("eam:AgencyScope", reflect.TypeOf((*AgencyScope)(nil)).Elem()) 308 } 309 310 // Represents the mapping of a VM folder to a datacenter. 311 // 312 // This structure may be used only with operations rendered under `/eam`. 313 type AgencyVMFolder struct { 314 types.DynamicData 315 316 // Folder identifier. 317 // 318 // The folder must be present in the corresponding 319 // datacenter. 320 // 321 // Refers instance of `Folder`. 322 FolderId types.ManagedObjectReference `xml:"folderId" json:"folderId"` 323 // Datacenter identifier. 324 // 325 // Refers instance of `Datacenter`. 326 DatacenterId types.ManagedObjectReference `xml:"datacenterId" json:"datacenterId"` 327 } 328 329 func init() { 330 types.Add("eam:AgencyVMFolder", reflect.TypeOf((*AgencyVMFolder)(nil)).Elem()) 331 } 332 333 // Represents the mapping of a VM resource pool to a compute resource. 334 // 335 // This structure may be used only with operations rendered under `/eam`. 336 type AgencyVMResourcePool struct { 337 types.DynamicData 338 339 // Resource pool identifier. 340 // 341 // The resource pool must be present in the 342 // corresponding compute resource. 343 // 344 // Refers instance of `ResourcePool`. 345 ResourcePoolId types.ManagedObjectReference `xml:"resourcePoolId" json:"resourcePoolId"` 346 // Compute resource identifier. 347 // 348 // Refers instance of `ComputeResource`. 349 ComputeResourceId types.ManagedObjectReference `xml:"computeResourceId" json:"computeResourceId"` 350 } 351 352 func init() { 353 types.Add("eam:AgencyVMResourcePool", reflect.TypeOf((*AgencyVMResourcePool)(nil)).Elem()) 354 } 355 356 type Agency_Disable Agency_DisableRequestType 357 358 func init() { 359 types.Add("eam:Agency_Disable", reflect.TypeOf((*Agency_Disable)(nil)).Elem()) 360 } 361 362 type Agency_DisableRequestType struct { 363 This types.ManagedObjectReference `xml:"_this" json:"_this"` 364 } 365 366 func init() { 367 types.Add("eam:Agency_DisableRequestType", reflect.TypeOf((*Agency_DisableRequestType)(nil)).Elem()) 368 } 369 370 type Agency_DisableResponse struct { 371 } 372 373 type Agency_Enable Agency_EnableRequestType 374 375 func init() { 376 types.Add("eam:Agency_Enable", reflect.TypeOf((*Agency_Enable)(nil)).Elem()) 377 } 378 379 type Agency_EnableRequestType struct { 380 This types.ManagedObjectReference `xml:"_this" json:"_this"` 381 } 382 383 func init() { 384 types.Add("eam:Agency_EnableRequestType", reflect.TypeOf((*Agency_EnableRequestType)(nil)).Elem()) 385 } 386 387 type Agency_EnableResponse struct { 388 } 389 390 // Specifies an SSL policy that trusts any SSL certificate. 391 // 392 // This structure may be used only with operations rendered under `/eam`. 393 type AgentAnyCertificate struct { 394 AgentSslTrust 395 } 396 397 func init() { 398 types.Add("eam:AgentAnyCertificate", reflect.TypeOf((*AgentAnyCertificate)(nil)).Elem()) 399 types.AddMinAPIVersionForType("eam:AgentAnyCertificate", "8.2") 400 } 401 402 // A description of what should be put on a host. 403 // 404 // By setting the 405 // <code>productLineId</code> and <code>hostVersion</code>, you can specify 406 // the types of hosts for which to use the <code>ConfigInfo</code>. 407 // 408 // This structure may be used only with operations rendered under `/eam`. 409 type AgentConfigInfo struct { 410 types.DynamicData 411 412 // The product line ID of the host. 413 // 414 // Examples of values are "esx" or 415 // "embeddedEsx". If omitted, the host's product line ID is not considered 416 // when matching an <code>AgentPackage</code> against a host. 417 ProductLineId string `xml:"productLineId,omitempty" json:"productLineId,omitempty"` 418 // A dot-separated string of the host version. 419 // 420 // Examples of values are 421 // "4.1.0" "3.5", "4.\*" where \* is a wildcard meaning any version minor 422 // version of the major version 4. If omitted, the host version will not 423 // be considered when matching an <code>AgentPackage</code> against a 424 // host. 425 // This property is not used if 426 // `AgencyConfigInfoEx.vmPlacementPolicy` is set. It is client's 427 // responsibility to trigger an agency upgrade with a new 428 // `AgentConfigInfo.ovfPackageUrl`. 429 HostVersion string `xml:"hostVersion,omitempty" json:"hostVersion,omitempty"` 430 // The URL of the solution's agent OVF package. 431 // 432 // If not set, no agent 433 // virtual machines are installed on the hosts covered by the scope. 434 // If `AgencyConfigInfoEx.vmPlacementPolicy` is set, the VM needs to 435 // be agnostic to the different host versions inside the cluster. 436 OvfPackageUrl string `xml:"ovfPackageUrl,omitempty" json:"ovfPackageUrl,omitempty"` 437 AuthenticationScheme string `xml:"authenticationScheme,omitempty" json:"authenticationScheme,omitempty"` 438 // Specifies an SSL trust policy to be use for verification of the 439 // server that hosts the `AgentConfigInfo.ovfPackageUrl`. 440 // 441 // If not set, the server 442 // certificate is validated against the trusted root certificates of the 443 // OS (Photon) and VECS (TRUSTED\_ROOTS). 444 OvfSslTrust BaseAgentSslTrust `xml:"ovfSslTrust,omitempty,typeattr" json:"ovfSslTrust,omitempty" vim:"8.2"` 445 // The part of the OVF environment that can be set by the solution. 446 // 447 // This 448 // is where Properties that the agent virtual machine's OVF descriptor 449 // specifies are set here. All properties that are specified as 450 // user-configurable must be set. 451 OvfEnvironment *AgentOvfEnvironmentInfo `xml:"ovfEnvironment,omitempty" json:"ovfEnvironment,omitempty"` 452 // An optional URL to an offline bundle. 453 // 454 // If not set, no VIB is installed 455 // on the hosts in the scope. Offline bundles are only supported on 4.0 456 // hosts and later. 457 // 458 // VIB downgrade is not permitted - in case a VIB with the same name, but 459 // lower version is installed on a host in the scope the VIB installation 460 // on that host will not succeed. 461 // 462 // If two or more agents have the same VIB with different versions on the 463 // same host, the install/uninstall behaviour is undefined (the VIB may 464 // remain installed, etc.). 465 // 466 // The property is not used if `AgencyConfigInfoEx.vmPlacementPolicy` 467 // is set. 468 VibUrl string `xml:"vibUrl,omitempty" json:"vibUrl,omitempty"` 469 // Specifies an SSL trust policy to be use for verification of the 470 // server that hosts the `AgentConfigInfo.vibUrl`. 471 // 472 // If not set, the server 473 // certificate is validated against the trusted root certificates of the 474 // OS (Photon) and VECS (TRUSTED\_ROOTS). 475 VibSslTrust BaseAgentSslTrust `xml:"vibSslTrust,omitempty,typeattr" json:"vibSslTrust,omitempty" vim:"8.2"` 476 // Deprecated vIB matching rules are no longer supported by EAM. Same 477 // overlaps with VIB dependency requirements which reside in 478 // each VIB's metadata. 479 // 480 // Optional Vib matching rules. 481 // 482 // If set, the Vib, specified by vibUrl, will 483 // be installed either 484 // - if there is installed Vib on the host which name and version match 485 // the regular expressions in the corresponding rule 486 // - or there isn't any installed Vib on the host with name which 487 // matches the Vib name regular expression in the corresponding rule. Vib 488 // matching rules are usually used for controlling VIB upgrades, in which 489 // case the name regular expression matches any previous versions of the 490 // agency Vib and version regular expression determines whether the 491 // existing Vib should be upgraded. 492 // 493 // For every Vib in the Vib package, only one Vib matching rule can be 494 // defined. If specified more than one, it is not determined which one 495 // will be used. The Vib name regular expression in the Vib matching rule 496 // will be matched against the name of the Vib which will be installed. 497 // Only rules for Vibs which are defined in the Vib package metadata will 498 // be taken in account. 499 VibMatchingRules []AgentVibMatchingRule `xml:"vibMatchingRules,omitempty" json:"vibMatchingRules,omitempty"` 500 // Deprecated use VIB metadata to add such dependency. 501 // 502 // An optional name of a VIB. 503 // 504 // If set, no VIB is installed on the host. The 505 // host is checked if a VIB with vibName is already installed on it. Also 506 // the vibUrl must not be set together with the vibUrl. 507 VibName string `xml:"vibName,omitempty" json:"vibName,omitempty"` 508 // Deprecated that is a custom setup specific for a particular agency. 509 // The agency owner should do it using other means, e.g. 510 // `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterPowerOn` or 511 // `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning` 512 // hooks. Support for this has been removed. Seting this to 513 // <code>true</code> will no longer have any effect. 514 // 515 // If set to <code>true</code>, the hosts in the scope must be configured 516 // for DvFilter before VIBs and agent virtual machines are deployed on 517 // them. 518 // 519 // If not set or set to <code>false</code>, no DvFilter 520 // configuration is done on the hosts. 521 DvFilterEnabled *bool `xml:"dvFilterEnabled" json:"dvFilterEnabled,omitempty"` 522 // Deprecated express that requirement in the VIB descriptor with 523 // 'live-remove-allowed=false'. 524 // 525 // An optional boolean flag to specify whether the agent's host is 526 // rebooted after the VIB is uninstalled. 527 // 528 // If not set, the default value is 529 // <code>false</code>. If set to <code>true</code>, the agent gets a 530 // `VibRequiresHostReboot` issue after a successful 531 // uninstallation. 532 RebootHostAfterVibUninstall *bool `xml:"rebootHostAfterVibUninstall" json:"rebootHostAfterVibUninstall,omitempty"` 533 // If set the virtual machine will be configured with the services and 534 // allow VMCI access from the virtual machine to the installed VIB. 535 VmciService []string `xml:"vmciService,omitempty" json:"vmciService,omitempty"` 536 // AgentVM disk provisioning type. 537 // 538 // Defaults to `none` if not specified. 539 OvfDiskProvisioning string `xml:"ovfDiskProvisioning,omitempty" json:"ovfDiskProvisioning,omitempty"` 540 // Defines the storage policies configured on Agent VMs. 541 // 542 // Storage policies 543 // are configured on all VM related objects including disks. 544 // NOTE: The property needs to be configured on each update, otherwise 545 // vSphere ESX Agent Manager will unset this configuration for all future 546 // agent VMs. 547 VmStoragePolicies []BaseAgentStoragePolicy `xml:"vmStoragePolicies,omitempty,typeattr" json:"vmStoragePolicies,omitempty"` 548 VmResourceConfiguration string `xml:"vmResourceConfiguration,omitempty" json:"vmResourceConfiguration,omitempty"` 549 } 550 551 func init() { 552 types.Add("eam:AgentConfigInfo", reflect.TypeOf((*AgentConfigInfo)(nil)).Elem()) 553 } 554 555 // Base class for all agent issues. 556 // 557 // This structure may be used only with operations rendered under `/eam`. 558 type AgentIssue struct { 559 AgencyIssue 560 561 // The agent that has this issue. 562 // 563 // Refers instance of `Agent`. 564 Agent types.ManagedObjectReference `xml:"agent" json:"agent"` 565 // The name of the agent. 566 AgentName string `xml:"agentName" json:"agentName"` 567 // The managed object reference to the host on which this agent is located. 568 // 569 // Refers instance of `HostSystem`. 570 Host types.ManagedObjectReference `xml:"host" json:"host"` 571 // The name of the host on which this agent is located. 572 HostName string `xml:"hostName" json:"hostName"` 573 } 574 575 func init() { 576 types.Add("eam:AgentIssue", reflect.TypeOf((*AgentIssue)(nil)).Elem()) 577 } 578 579 // The <code>OvfEnvironment</code> is used to assign OVF environment 580 // properties in the `AgentConfigInfo`. 581 // 582 // It specifies the values that 583 // map to properties in the agent virtual machine's OVF descriptor. 584 // 585 // This structure may be used only with operations rendered under `/eam`. 586 type AgentOvfEnvironmentInfo struct { 587 types.DynamicData 588 589 // The OVF properties that are assigned to the agent virtual machine's OVF 590 // environment when it is powered on. 591 OvfProperty []AgentOvfEnvironmentInfoOvfProperty `xml:"ovfProperty,omitempty" json:"ovfProperty,omitempty"` 592 } 593 594 func init() { 595 types.Add("eam:AgentOvfEnvironmentInfo", reflect.TypeOf((*AgentOvfEnvironmentInfo)(nil)).Elem()) 596 } 597 598 // One OVF property. 599 // 600 // This structure may be used only with operations rendered under `/eam`. 601 type AgentOvfEnvironmentInfoOvfProperty struct { 602 types.DynamicData 603 604 // The name of the property in the OVF descriptor. 605 Key string `xml:"key" json:"key"` 606 // The value of the property. 607 Value string `xml:"value" json:"value"` 608 } 609 610 func init() { 611 types.Add("eam:AgentOvfEnvironmentInfoOvfProperty", reflect.TypeOf((*AgentOvfEnvironmentInfoOvfProperty)(nil)).Elem()) 612 } 613 614 // Specifies an SSL policy that trusts one specific pinned PEM encoded 615 // SSL certificate. 616 // 617 // This structure may be used only with operations rendered under `/eam`. 618 type AgentPinnedPemCertificate struct { 619 AgentSslTrust 620 621 // PEM encoded pinned SSL certificate of the server that needs to be 622 // trusted. 623 SslCertificate string `xml:"sslCertificate" json:"sslCertificate"` 624 } 625 626 func init() { 627 types.Add("eam:AgentPinnedPemCertificate", reflect.TypeOf((*AgentPinnedPemCertificate)(nil)).Elem()) 628 types.AddMinAPIVersionForType("eam:AgentPinnedPemCertificate", "8.2") 629 } 630 631 type AgentQueryConfig AgentQueryConfigRequestType 632 633 func init() { 634 types.Add("eam:AgentQueryConfig", reflect.TypeOf((*AgentQueryConfig)(nil)).Elem()) 635 } 636 637 type AgentQueryConfigRequestType struct { 638 This types.ManagedObjectReference `xml:"_this" json:"_this"` 639 } 640 641 func init() { 642 types.Add("eam:AgentQueryConfigRequestType", reflect.TypeOf((*AgentQueryConfigRequestType)(nil)).Elem()) 643 } 644 645 type AgentQueryConfigResponse struct { 646 Returnval AgentConfigInfo `xml:"returnval" json:"returnval"` 647 } 648 649 type AgentQueryRuntime AgentQueryRuntimeRequestType 650 651 func init() { 652 types.Add("eam:AgentQueryRuntime", reflect.TypeOf((*AgentQueryRuntime)(nil)).Elem()) 653 } 654 655 type AgentQueryRuntimeRequestType struct { 656 This types.ManagedObjectReference `xml:"_this" json:"_this"` 657 } 658 659 func init() { 660 types.Add("eam:AgentQueryRuntimeRequestType", reflect.TypeOf((*AgentQueryRuntimeRequestType)(nil)).Elem()) 661 } 662 663 type AgentQueryRuntimeResponse struct { 664 Returnval AgentRuntimeInfo `xml:"returnval" json:"returnval"` 665 } 666 667 // Extends <code>RuntimeInfo</code> with information regarding the deployment 668 // of an agent on a specific host. 669 // 670 // This structure may be used only with operations rendered under `/eam`. 671 type AgentRuntimeInfo struct { 672 EamObjectRuntimeInfo 673 674 // Deprecated get that info calling the virtual machine VIM API. 675 // 676 // The power state of an agent virtual machine. 677 VmPowerState types.VirtualMachinePowerState `xml:"vmPowerState" json:"vmPowerState"` 678 // Deprecated get that info calling the virtual machine VIM API. 679 // 680 // True if the vSphere ESX Agent Manager is receiving heartbeats from the 681 // agent virtual machine. 682 ReceivingHeartBeat bool `xml:"receivingHeartBeat" json:"receivingHeartBeat"` 683 // The agent host. 684 // 685 // Refers instance of `HostSystem`. 686 Host *types.ManagedObjectReference `xml:"host,omitempty" json:"host,omitempty"` 687 // The agent virtual machine. 688 // 689 // Refers instance of `VirtualMachine`. 690 Vm *types.ManagedObjectReference `xml:"vm,omitempty" json:"vm,omitempty"` 691 // Deprecated get that info calling the virtual machine VIM API. 692 // 693 // The IP address of the agent virtual machine 694 VmIp string `xml:"vmIp,omitempty" json:"vmIp,omitempty"` 695 // Deprecated get that info calling the virtual machine VIM API. 696 // 697 // The name of the agent virtual machine. 698 VmName string `xml:"vmName" json:"vmName"` 699 // Deprecated in order to retrieve agent resource pool use VIM API. 700 // 701 // The ESX agent resource pool in which the agent virtual machine resides. 702 // 703 // Refers instance of `ResourcePool`. 704 EsxAgentResourcePool *types.ManagedObjectReference `xml:"esxAgentResourcePool,omitempty" json:"esxAgentResourcePool,omitempty"` 705 // Deprecated in order to retrieve agent VM folder use VIM API. 706 // 707 // The ESX agent folder in which the agent virtual machine resides. 708 // 709 // Refers instance of `Folder`. 710 EsxAgentFolder *types.ManagedObjectReference `xml:"esxAgentFolder,omitempty" json:"esxAgentFolder,omitempty"` 711 // Deprecated use `AgentRuntimeInfo.installedVibs` instead. 712 // 713 // An optional array of IDs of installed bulletins for this agent. 714 InstalledBulletin []string `xml:"installedBulletin,omitempty" json:"installedBulletin,omitempty"` 715 // Information about the installed vibs on the host. 716 InstalledVibs []VibVibInfo `xml:"installedVibs,omitempty" json:"installedVibs,omitempty"` 717 // The agency this agent belongs to. 718 // 719 // Refers instance of `Agency`. 720 Agency *types.ManagedObjectReference `xml:"agency,omitempty" json:"agency,omitempty"` 721 // Active VM hook. 722 // 723 // If present agent is actively waiting for `Agent.MarkAsAvailable`. 724 // See `AgentVmHook`. 725 VmHook *AgentVmHook `xml:"vmHook,omitempty" json:"vmHook,omitempty"` 726 } 727 728 func init() { 729 types.Add("eam:AgentRuntimeInfo", reflect.TypeOf((*AgentRuntimeInfo)(nil)).Elem()) 730 } 731 732 // Specifies an SSL trust policy. 733 // 734 // This structure may be used only with operations rendered under `/eam`. 735 type AgentSslTrust struct { 736 types.DynamicData 737 } 738 739 func init() { 740 types.Add("eam:AgentSslTrust", reflect.TypeOf((*AgentSslTrust)(nil)).Elem()) 741 types.AddMinAPIVersionForType("eam:AgentSslTrust", "8.2") 742 } 743 744 // Specifies the storage policies configured on Agent VMs. 745 // 746 // This structure may be used only with operations rendered under `/eam`. 747 type AgentStoragePolicy struct { 748 types.DynamicData 749 } 750 751 func init() { 752 types.Add("eam:AgentStoragePolicy", reflect.TypeOf((*AgentStoragePolicy)(nil)).Elem()) 753 } 754 755 // Deprecated vIB matching rules are no longer supported by EAM. Same 756 // overlaps with VIB dependency requirements which reside in each 757 // VIB's metadata. 758 // 759 // Specifies regular expressions for Vib name and version. 760 // 761 // This structure may be used only with operations rendered under `/eam`. 762 type AgentVibMatchingRule struct { 763 types.DynamicData 764 765 // Vib name regular expression. 766 VibNameRegex string `xml:"vibNameRegex" json:"vibNameRegex"` 767 // Vib version regular expression. 768 VibVersionRegex string `xml:"vibVersionRegex" json:"vibVersionRegex"` 769 } 770 771 func init() { 772 types.Add("eam:AgentVibMatchingRule", reflect.TypeOf((*AgentVibMatchingRule)(nil)).Elem()) 773 } 774 775 // Represents an active hook of the VM lifecycle which EAM is waiting on to 776 // be processed by the client. 777 // 778 // The supported hooks are defined by 779 // `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning` 780 // and 781 // `AgencyConfigInfo.manuallyMarkAgentVmAvailableAfterProvisioning`. 782 // See `Agent.MarkAsAvailable` 783 // 784 // This structure may be used only with operations rendered under `/eam`. 785 type AgentVmHook struct { 786 types.DynamicData 787 788 // The VM for which lifecycle is this hook. 789 // 790 // This VM may differ from `AgentRuntimeInfo.vm` while an upgrade 791 // of the agent VM is in progress. 792 // 793 // Refers instance of `VirtualMachine`. 794 Vm types.ManagedObjectReference `xml:"vm" json:"vm"` 795 // The current VM lifecycle state. 796 VmState string `xml:"vmState" json:"vmState"` 797 } 798 799 func init() { 800 types.Add("eam:AgentVmHook", reflect.TypeOf((*AgentVmHook)(nil)).Elem()) 801 } 802 803 // Specifies vSAN specific storage policy configured on Agent VMs. 804 // 805 // This structure may be used only with operations rendered under `/eam`. 806 type AgentVsanStoragePolicy struct { 807 AgentStoragePolicy 808 809 // ID of a storage policy profile created by the user. 810 // 811 // The type of the 812 // profile must be `VirtualMachineDefinedProfileSpec`. The ID must be valid 813 // `VirtualMachineDefinedProfileSpec.profileId`. 814 ProfileId string `xml:"profileId" json:"profileId"` 815 } 816 817 func init() { 818 types.Add("eam:AgentVsanStoragePolicy", reflect.TypeOf((*AgentVsanStoragePolicy)(nil)).Elem()) 819 } 820 821 // A boxed array of `AgencyVMFolder`. To be used in `Any` placeholders. 822 // 823 // This structure may be used only with operations rendered under `/eam`. 824 type ArrayOfAgencyVMFolder struct { 825 AgencyVMFolder []AgencyVMFolder `xml:"AgencyVMFolder,omitempty" json:"_value"` 826 } 827 828 func init() { 829 types.Add("eam:ArrayOfAgencyVMFolder", reflect.TypeOf((*ArrayOfAgencyVMFolder)(nil)).Elem()) 830 } 831 832 // A boxed array of `AgencyVMResourcePool`. To be used in `Any` placeholders. 833 // 834 // This structure may be used only with operations rendered under `/eam`. 835 type ArrayOfAgencyVMResourcePool struct { 836 AgencyVMResourcePool []AgencyVMResourcePool `xml:"AgencyVMResourcePool,omitempty" json:"_value"` 837 } 838 839 func init() { 840 types.Add("eam:ArrayOfAgencyVMResourcePool", reflect.TypeOf((*ArrayOfAgencyVMResourcePool)(nil)).Elem()) 841 } 842 843 // A boxed array of `AgentConfigInfo`. To be used in `Any` placeholders. 844 // 845 // This structure may be used only with operations rendered under `/eam`. 846 type ArrayOfAgentConfigInfo struct { 847 AgentConfigInfo []AgentConfigInfo `xml:"AgentConfigInfo,omitempty" json:"_value"` 848 } 849 850 func init() { 851 types.Add("eam:ArrayOfAgentConfigInfo", reflect.TypeOf((*ArrayOfAgentConfigInfo)(nil)).Elem()) 852 } 853 854 // A boxed array of `AgentOvfEnvironmentInfoOvfProperty`. To be used in `Any` placeholders. 855 // 856 // This structure may be used only with operations rendered under `/eam`. 857 type ArrayOfAgentOvfEnvironmentInfoOvfProperty struct { 858 AgentOvfEnvironmentInfoOvfProperty []AgentOvfEnvironmentInfoOvfProperty `xml:"AgentOvfEnvironmentInfoOvfProperty,omitempty" json:"_value"` 859 } 860 861 func init() { 862 types.Add("eam:ArrayOfAgentOvfEnvironmentInfoOvfProperty", reflect.TypeOf((*ArrayOfAgentOvfEnvironmentInfoOvfProperty)(nil)).Elem()) 863 } 864 865 // A boxed array of `AgentStoragePolicy`. To be used in `Any` placeholders. 866 // 867 // This structure may be used only with operations rendered under `/eam`. 868 type ArrayOfAgentStoragePolicy struct { 869 AgentStoragePolicy []BaseAgentStoragePolicy `xml:"AgentStoragePolicy,omitempty,typeattr" json:"_value"` 870 } 871 872 func init() { 873 types.Add("eam:ArrayOfAgentStoragePolicy", reflect.TypeOf((*ArrayOfAgentStoragePolicy)(nil)).Elem()) 874 } 875 876 // A boxed array of `AgentVibMatchingRule`. To be used in `Any` placeholders. 877 // 878 // This structure may be used only with operations rendered under `/eam`. 879 type ArrayOfAgentVibMatchingRule struct { 880 AgentVibMatchingRule []AgentVibMatchingRule `xml:"AgentVibMatchingRule,omitempty" json:"_value"` 881 } 882 883 func init() { 884 types.Add("eam:ArrayOfAgentVibMatchingRule", reflect.TypeOf((*ArrayOfAgentVibMatchingRule)(nil)).Elem()) 885 } 886 887 // A boxed array of `Issue`. To be used in `Any` placeholders. 888 // 889 // This structure may be used only with operations rendered under `/eam`. 890 type ArrayOfIssue struct { 891 Issue []BaseIssue `xml:"Issue,omitempty,typeattr" json:"_value"` 892 } 893 894 func init() { 895 types.Add("eam:ArrayOfIssue", reflect.TypeOf((*ArrayOfIssue)(nil)).Elem()) 896 } 897 898 // A boxed array of `SolutionsClusterSolutionComplianceResult`. To be used in `Any` placeholders. 899 // 900 // This structure may be used only with operations rendered under `/eam`. 901 type ArrayOfSolutionsClusterSolutionComplianceResult struct { 902 SolutionsClusterSolutionComplianceResult []SolutionsClusterSolutionComplianceResult `xml:"SolutionsClusterSolutionComplianceResult,omitempty" json:"_value"` 903 } 904 905 func init() { 906 types.Add("eam:ArrayOfSolutionsClusterSolutionComplianceResult", reflect.TypeOf((*ArrayOfSolutionsClusterSolutionComplianceResult)(nil)).Elem()) 907 } 908 909 // A boxed array of `SolutionsDeploymentUnitComplianceResult`. To be used in `Any` placeholders. 910 // 911 // This structure may be used only with operations rendered under `/eam`. 912 type ArrayOfSolutionsDeploymentUnitComplianceResult struct { 913 SolutionsDeploymentUnitComplianceResult []SolutionsDeploymentUnitComplianceResult `xml:"SolutionsDeploymentUnitComplianceResult,omitempty" json:"_value"` 914 } 915 916 func init() { 917 types.Add("eam:ArrayOfSolutionsDeploymentUnitComplianceResult", reflect.TypeOf((*ArrayOfSolutionsDeploymentUnitComplianceResult)(nil)).Elem()) 918 } 919 920 // A boxed array of `SolutionsHookConfig`. To be used in `Any` placeholders. 921 // 922 // This structure may be used only with operations rendered under `/eam`. 923 type ArrayOfSolutionsHookConfig struct { 924 SolutionsHookConfig []SolutionsHookConfig `xml:"SolutionsHookConfig,omitempty" json:"_value"` 925 } 926 927 func init() { 928 types.Add("eam:ArrayOfSolutionsHookConfig", reflect.TypeOf((*ArrayOfSolutionsHookConfig)(nil)).Elem()) 929 } 930 931 // A boxed array of `SolutionsHookInfo`. To be used in `Any` placeholders. 932 // 933 // This structure may be used only with operations rendered under `/eam`. 934 type ArrayOfSolutionsHookInfo struct { 935 SolutionsHookInfo []SolutionsHookInfo `xml:"SolutionsHookInfo,omitempty" json:"_value"` 936 } 937 938 func init() { 939 types.Add("eam:ArrayOfSolutionsHookInfo", reflect.TypeOf((*ArrayOfSolutionsHookInfo)(nil)).Elem()) 940 } 941 942 // A boxed array of `SolutionsHostComplianceResult`. To be used in `Any` placeholders. 943 // 944 // This structure may be used only with operations rendered under `/eam`. 945 type ArrayOfSolutionsHostComplianceResult struct { 946 SolutionsHostComplianceResult []SolutionsHostComplianceResult `xml:"SolutionsHostComplianceResult,omitempty" json:"_value"` 947 } 948 949 func init() { 950 types.Add("eam:ArrayOfSolutionsHostComplianceResult", reflect.TypeOf((*ArrayOfSolutionsHostComplianceResult)(nil)).Elem()) 951 } 952 953 // A boxed array of `SolutionsOvfProperty`. To be used in `Any` placeholders. 954 // 955 // This structure may be used only with operations rendered under `/eam`. 956 type ArrayOfSolutionsOvfProperty struct { 957 SolutionsOvfProperty []SolutionsOvfProperty `xml:"SolutionsOvfProperty,omitempty" json:"_value"` 958 } 959 960 func init() { 961 types.Add("eam:ArrayOfSolutionsOvfProperty", reflect.TypeOf((*ArrayOfSolutionsOvfProperty)(nil)).Elem()) 962 } 963 964 // A boxed array of `SolutionsSolutionComplianceResult`. To be used in `Any` placeholders. 965 // 966 // This structure may be used only with operations rendered under `/eam`. 967 type ArrayOfSolutionsSolutionComplianceResult struct { 968 SolutionsSolutionComplianceResult []SolutionsSolutionComplianceResult `xml:"SolutionsSolutionComplianceResult,omitempty" json:"_value"` 969 } 970 971 func init() { 972 types.Add("eam:ArrayOfSolutionsSolutionComplianceResult", reflect.TypeOf((*ArrayOfSolutionsSolutionComplianceResult)(nil)).Elem()) 973 } 974 975 // A boxed array of `SolutionsSolutionConfig`. To be used in `Any` placeholders. 976 // 977 // This structure may be used only with operations rendered under `/eam`. 978 type ArrayOfSolutionsSolutionConfig struct { 979 SolutionsSolutionConfig []SolutionsSolutionConfig `xml:"SolutionsSolutionConfig,omitempty" json:"_value"` 980 } 981 982 func init() { 983 types.Add("eam:ArrayOfSolutionsSolutionConfig", reflect.TypeOf((*ArrayOfSolutionsSolutionConfig)(nil)).Elem()) 984 } 985 986 // A boxed array of `SolutionsSolutionValidationResult`. To be used in `Any` placeholders. 987 // 988 // This structure may be used only with operations rendered under `/eam`. 989 type ArrayOfSolutionsSolutionValidationResult struct { 990 SolutionsSolutionValidationResult []SolutionsSolutionValidationResult `xml:"SolutionsSolutionValidationResult,omitempty" json:"_value"` 991 } 992 993 func init() { 994 types.Add("eam:ArrayOfSolutionsSolutionValidationResult", reflect.TypeOf((*ArrayOfSolutionsSolutionValidationResult)(nil)).Elem()) 995 } 996 997 // A boxed array of `SolutionsStoragePolicy`. To be used in `Any` placeholders. 998 // 999 // This structure may be used only with operations rendered under `/eam`. 1000 type ArrayOfSolutionsStoragePolicy struct { 1001 SolutionsStoragePolicy []BaseSolutionsStoragePolicy `xml:"SolutionsStoragePolicy,omitempty,typeattr" json:"_value"` 1002 } 1003 1004 func init() { 1005 types.Add("eam:ArrayOfSolutionsStoragePolicy", reflect.TypeOf((*ArrayOfSolutionsStoragePolicy)(nil)).Elem()) 1006 } 1007 1008 // A boxed array of `SolutionsVMNetworkMapping`. To be used in `Any` placeholders. 1009 // 1010 // This structure may be used only with operations rendered under `/eam`. 1011 type ArrayOfSolutionsVMNetworkMapping struct { 1012 SolutionsVMNetworkMapping []SolutionsVMNetworkMapping `xml:"SolutionsVMNetworkMapping,omitempty" json:"_value"` 1013 } 1014 1015 func init() { 1016 types.Add("eam:ArrayOfSolutionsVMNetworkMapping", reflect.TypeOf((*ArrayOfSolutionsVMNetworkMapping)(nil)).Elem()) 1017 } 1018 1019 // A boxed array of `VibVibInfo`. To be used in `Any` placeholders. 1020 // 1021 // This structure may be used only with operations rendered under `/eam`. 1022 type ArrayOfVibVibInfo struct { 1023 VibVibInfo []VibVibInfo `xml:"VibVibInfo,omitempty" json:"_value"` 1024 } 1025 1026 func init() { 1027 types.Add("eam:ArrayOfVibVibInfo", reflect.TypeOf((*ArrayOfVibVibInfo)(nil)).Elem()) 1028 } 1029 1030 // An agent virtual machine is expected to be deployed on a host, but the agent virtual machine 1031 // cannot be deployed because the vSphere ESX Agent Manager is unable to access the OVF 1032 // package for the agent. 1033 // 1034 // This typically happens because the Web server providing the 1035 // OVF package is down. The Web server is often internal to the solution 1036 // that created the Agency. 1037 // 1038 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent. 1039 // 1040 // This structure may be used only with operations rendered under `/eam`. 1041 type CannotAccessAgentOVF struct { 1042 VmNotDeployed 1043 1044 // The URL from which the OVF could not be downloaded. 1045 DownloadUrl string `xml:"downloadUrl" json:"downloadUrl"` 1046 } 1047 1048 func init() { 1049 types.Add("eam:CannotAccessAgentOVF", reflect.TypeOf((*CannotAccessAgentOVF)(nil)).Elem()) 1050 } 1051 1052 // An agent VIB module is expected to be deployed on a host, but the VIM module 1053 // cannot be deployed because the vSphere ESX Agent Manager is unable to access the VIB 1054 // package for the agent. 1055 // 1056 // This typically happens because the Web server providing the 1057 // VIB package is down. The Web server is often internal to the solution 1058 // that created the Agency. 1059 // 1060 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager reinstalls the VIB module. 1061 // 1062 // This structure may be used only with operations rendered under `/eam`. 1063 type CannotAccessAgentVib struct { 1064 VibNotInstalled 1065 1066 // The URL from which the VIB package could not be downloaded. 1067 DownloadUrl string `xml:"downloadUrl" json:"downloadUrl"` 1068 } 1069 1070 func init() { 1071 types.Add("eam:CannotAccessAgentVib", reflect.TypeOf((*CannotAccessAgentVib)(nil)).Elem()) 1072 } 1073 1074 // This exception is thrown if the certificate provided by the 1075 // provider is not trusted. 1076 // 1077 // This structure may be used only with operations rendered under `/sms`. 1078 type CertificateNotTrusted struct { 1079 AgentIssue 1080 1081 Url string `xml:"url" json:"url"` 1082 } 1083 1084 func init() { 1085 types.Add("eam:CertificateNotTrusted", reflect.TypeOf((*CertificateNotTrusted)(nil)).Elem()) 1086 } 1087 1088 // An CertificateNotTrusted fault is thrown when an Agency's configuration 1089 // contains OVF package URL or VIB URL for that vSphere ESX Agent Manager is not 1090 // able to make successful SSL trust verification of the server's certificate. 1091 // 1092 // Reasons for this might be that the certificate provided via the API 1093 // `AgentConfigInfo.ovfSslTrust` and `AgentConfigInfo.vibSslTrust` 1094 // or via the script /usr/lib/vmware-eam/bin/eam-utility.py 1095 // - is invalid. 1096 // - does not match the server's certificate. 1097 // 1098 // If there is no provided certificate, the fault is thrown when the server's 1099 // certificate is not trusted by the system or is invalid - @see 1100 // `AgentConfigInfo.ovfSslTrust` and 1101 // `AgentConfigInfo.vibSslTrust`. 1102 // To enable Agency creation 1) provide a valid certificate used by the 1103 // server hosting the `AgentConfigInfo.ovfPackageUrl` or 1104 // `AgentConfigInfo.vibUrl` or 2) ensure the server's certificate is 1105 // signed by a CA trusted by the system. Then retry the operation, vSphere 1106 // ESX Agent Manager will retry the SSL trust verification and proceed with 1107 // reaching the desired state. 1108 // 1109 // This structure may be used only with operations rendered under `/eam`. 1110 type CertificateNotTrustedFault struct { 1111 EamAppFault 1112 1113 // The URL that failed the SSL trust verification. 1114 Url string `xml:"url,omitempty" json:"url,omitempty"` 1115 } 1116 1117 func init() { 1118 types.Add("eam:CertificateNotTrustedFault", reflect.TypeOf((*CertificateNotTrustedFault)(nil)).Elem()) 1119 types.AddMinAPIVersionForType("eam:CertificateNotTrustedFault", "8.2") 1120 } 1121 1122 type CertificateNotTrustedFaultFault CertificateNotTrustedFault 1123 1124 func init() { 1125 types.Add("eam:CertificateNotTrustedFaultFault", reflect.TypeOf((*CertificateNotTrustedFaultFault)(nil)).Elem()) 1126 } 1127 1128 // Base class for all cluster bound agents. 1129 // 1130 // This structure may be used only with operations rendered under `/eam`. 1131 type ClusterAgentAgentIssue struct { 1132 AgencyIssue 1133 1134 // The agent that has this issue. 1135 // 1136 // Refers instance of `Agent`. 1137 Agent types.ManagedObjectReference `xml:"agent" json:"agent"` 1138 // The cluster for which this issue is raised. 1139 // 1140 // Migth be null if the cluster 1141 // is missing in vCenter Server inventory. 1142 // 1143 // Refers instance of `ComputeResource`. 1144 Cluster *types.ManagedObjectReference `xml:"cluster,omitempty" json:"cluster,omitempty"` 1145 } 1146 1147 func init() { 1148 types.Add("eam:ClusterAgentAgentIssue", reflect.TypeOf((*ClusterAgentAgentIssue)(nil)).Elem()) 1149 } 1150 1151 // The cluster agent Virtual Machine cannot be deployed, because vSphere ESX 1152 // Agent Manager is not able to make successful SSL trust verification of the 1153 // server's certificate, when establishing connection to the provided 1154 // `AgentConfigInfo.ovfPackageUrl`. 1155 // 1156 // Reasons for this might be that the 1157 // certificate provided via the API `AgentConfigInfo.ovfSslTrust` or via 1158 // the script /usr/lib/vmware-eam/bin/eam-utility.py 1159 // - is invalid. 1160 // - does not match the server's certificate. 1161 // 1162 // If there is no provided certificate, the issue is raised when the server's 1163 // certificate is not trusted by the system or invalid - @see 1164 // `AgentConfigInfo.ovfSslTrust`. 1165 // To remediate the cluster agent Virtual Machine deployment 1) provide a valid 1166 // certificate used by the server hosting the 1167 // `AgentConfigInfo.ovfPackageUrl` or 2) ensure the server's certificate 1168 // is signed by a CA trusted by the system. Then resolve this issue, vSphere ESX 1169 // Agent Manager will retry the SSL trust verification and proceed with reaching 1170 // the desired state. 1171 // 1172 // This structure may be used only with operations rendered under `/eam`. 1173 type ClusterAgentCertificateNotTrusted struct { 1174 ClusterAgentVmNotDeployed 1175 1176 // The URL that failed the SSL trust verification. 1177 Url string `xml:"url" json:"url"` 1178 } 1179 1180 func init() { 1181 types.Add("eam:ClusterAgentCertificateNotTrusted", reflect.TypeOf((*ClusterAgentCertificateNotTrusted)(nil)).Elem()) 1182 types.AddMinAPIVersionForType("eam:ClusterAgentCertificateNotTrusted", "8.2") 1183 } 1184 1185 type ClusterAgentHostInMaintenanceMode struct { 1186 ClusterAgentVmIssue 1187 } 1188 1189 func init() { 1190 types.Add("eam:ClusterAgentHostInMaintenanceMode", reflect.TypeOf((*ClusterAgentHostInMaintenanceMode)(nil)).Elem()) 1191 } 1192 1193 type ClusterAgentHostInPartialMaintenanceMode struct { 1194 ClusterAgentVmIssue 1195 } 1196 1197 func init() { 1198 types.Add("eam:ClusterAgentHostInPartialMaintenanceMode", reflect.TypeOf((*ClusterAgentHostInPartialMaintenanceMode)(nil)).Elem()) 1199 } 1200 1201 // The cluster agent Virtual Machine could not be powered-on, because the 1202 // cluster does not have enough CPU or memory resources. 1203 // 1204 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1205 // powers on the agent Virtual Machine. However, the problem is likely to 1206 // persist until enough CPU and memory resources are made available. 1207 // 1208 // This structure may be used only with operations rendered under `/eam`. 1209 type ClusterAgentInsufficientClusterResources struct { 1210 ClusterAgentVmPoweredOff 1211 } 1212 1213 func init() { 1214 types.Add("eam:ClusterAgentInsufficientClusterResources", reflect.TypeOf((*ClusterAgentInsufficientClusterResources)(nil)).Elem()) 1215 } 1216 1217 // The cluster agent Virtual Machine cannot be deployed, because any of the 1218 // configured datastores does not have enough disk space. 1219 // 1220 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1221 // redeploys the agent Virtual Machine. However, the problem is likely to 1222 // persist until enough disk space is freed up on the cluster datastore. 1223 // 1224 // This structure may be used only with operations rendered under `/eam`. 1225 type ClusterAgentInsufficientClusterSpace struct { 1226 ClusterAgentVmNotDeployed 1227 } 1228 1229 func init() { 1230 types.Add("eam:ClusterAgentInsufficientClusterSpace", reflect.TypeOf((*ClusterAgentInsufficientClusterSpace)(nil)).Elem()) 1231 } 1232 1233 // Invalid configuration is preventing a cluster agent virtual machine 1234 // operation. 1235 // 1236 // Typically the attached error indicates the particular reason why 1237 // vSphere ESX Agent Manager is unable to power on or reconfigure the agent 1238 // virtual machine. 1239 // 1240 // This is a passive remediable issue. To remediate update the virtual machine 1241 // configuration. 1242 // 1243 // This structure may be used only with operations rendered under `/eam`. 1244 type ClusterAgentInvalidConfig struct { 1245 ClusterAgentVmIssue 1246 1247 // The error, that caused this issue. 1248 // 1249 // It must be either MethodFault or 1250 // RuntimeFault. 1251 Error types.AnyType `xml:"error,typeattr" json:"error"` 1252 } 1253 1254 func init() { 1255 types.Add("eam:ClusterAgentInvalidConfig", reflect.TypeOf((*ClusterAgentInvalidConfig)(nil)).Elem()) 1256 } 1257 1258 // The cluster agent Virtual Machine cannot be deployed, because any of the 1259 // configured datastores does not exist on the cluster. 1260 // 1261 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1262 // redeploys the agent Virtual Machine. However, the problem is likely to 1263 // persist until required Virtual Machine datastores are configured on the 1264 // cluster. 1265 // 1266 // This structure may be used only with operations rendered under `/eam`. 1267 type ClusterAgentMissingClusterVmDatastore struct { 1268 ClusterAgentVmNotDeployed 1269 1270 // A non-empty array of cluster agent VM datastores that are missing on the 1271 // cluster. 1272 // 1273 // Refers instances of `Datastore`. 1274 MissingDatastores []types.ManagedObjectReference `xml:"missingDatastores,omitempty" json:"missingDatastores,omitempty"` 1275 } 1276 1277 func init() { 1278 types.Add("eam:ClusterAgentMissingClusterVmDatastore", reflect.TypeOf((*ClusterAgentMissingClusterVmDatastore)(nil)).Elem()) 1279 } 1280 1281 // The cluster agent Virtual Machine cannot be deployed, because the configured 1282 // networks do not exist on the cluster. 1283 // 1284 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1285 // redeploys the agent Virtual Machine. However, the problem is likely to 1286 // persist until required Virtual Machine networks are configured on the 1287 // cluster. 1288 // 1289 // This structure may be used only with operations rendered under `/eam`. 1290 type ClusterAgentMissingClusterVmNetwork struct { 1291 ClusterAgentVmNotDeployed 1292 1293 // A non-empty array of cluster agent VM networks that are required on the 1294 // cluster. 1295 // 1296 // Refers instances of `Network`. 1297 MissingNetworks []types.ManagedObjectReference `xml:"missingNetworks,omitempty" json:"missingNetworks,omitempty"` 1298 // The names of the cluster agent VM networks. 1299 NetworkNames []string `xml:"networkNames,omitempty" json:"networkNames,omitempty"` 1300 } 1301 1302 func init() { 1303 types.Add("eam:ClusterAgentMissingClusterVmNetwork", reflect.TypeOf((*ClusterAgentMissingClusterVmNetwork)(nil)).Elem()) 1304 } 1305 1306 // A cluster agent virtual machine needs to be provisioned, but an OVF property 1307 // is either missing or has an invalid value. 1308 // 1309 // This is a passive remediable issue. To remediate, update the OVF environment 1310 // in the agent configuration used to provision the agent virtual machine. 1311 // 1312 // This structure may be used only with operations rendered under `/eam`. 1313 type ClusterAgentOvfInvalidProperty struct { 1314 ClusterAgentAgentIssue 1315 1316 // An optional list of errors that caused this issue. 1317 // 1318 // These errors are 1319 // generated by the vCenter server. 1320 Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"` 1321 } 1322 1323 func init() { 1324 types.Add("eam:ClusterAgentOvfInvalidProperty", reflect.TypeOf((*ClusterAgentOvfInvalidProperty)(nil)).Elem()) 1325 } 1326 1327 type ClusterAgentVmHookFailed struct { 1328 ClusterAgentVmIssue 1329 } 1330 1331 func init() { 1332 types.Add("eam:ClusterAgentVmHookFailed", reflect.TypeOf((*ClusterAgentVmHookFailed)(nil)).Elem()) 1333 } 1334 1335 type ClusterAgentVmHookTimedout struct { 1336 ClusterAgentVmIssue 1337 } 1338 1339 func init() { 1340 types.Add("eam:ClusterAgentVmHookTimedout", reflect.TypeOf((*ClusterAgentVmHookTimedout)(nil)).Elem()) 1341 } 1342 1343 type ClusterAgentVmInaccessible struct { 1344 ClusterAgentVmIssue 1345 } 1346 1347 func init() { 1348 types.Add("eam:ClusterAgentVmInaccessible", reflect.TypeOf((*ClusterAgentVmInaccessible)(nil)).Elem()) 1349 } 1350 1351 // Base class for all cluster bound Virtual Machines. 1352 // 1353 // This structure may be used only with operations rendered under `/eam`. 1354 type ClusterAgentVmIssue struct { 1355 ClusterAgentAgentIssue 1356 1357 // The Virtual Machine to which this issue is related. 1358 // 1359 // Refers instance of `VirtualMachine`. 1360 Vm types.ManagedObjectReference `xml:"vm" json:"vm"` 1361 } 1362 1363 func init() { 1364 types.Add("eam:ClusterAgentVmIssue", reflect.TypeOf((*ClusterAgentVmIssue)(nil)).Elem()) 1365 } 1366 1367 // A cluster agent Virtual Machine is expected to be deployed on a cluster, but 1368 // the cluster agent Virtual Machine has not been deployed or has been exlicitly 1369 // deleted from the cluster. 1370 // 1371 // Typically more specific issue (a subclass of this 1372 // issue) indicates the particular reason why vSphere ESX Agent Manager was 1373 // unable to deploy the cluster agent Virtual Machine. 1374 // 1375 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1376 // redeploys the cluster agent Virtual Machine. 1377 // 1378 // This structure may be used only with operations rendered under `/eam`. 1379 type ClusterAgentVmNotDeployed struct { 1380 ClusterAgentAgentIssue 1381 } 1382 1383 func init() { 1384 types.Add("eam:ClusterAgentVmNotDeployed", reflect.TypeOf((*ClusterAgentVmNotDeployed)(nil)).Elem()) 1385 } 1386 1387 // The cluster agent Virtual Machine can not be removed from a cluster. 1388 // 1389 // Typically the description indicates the particular reason why vSphere ESX 1390 // Agent Manager was unable to remove the cluster agent Virtual Machine. 1391 // 1392 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1393 // removes the cluster agent Virtual Machine. 1394 // 1395 // This structure may be used only with operations rendered under `/eam`. 1396 type ClusterAgentVmNotRemoved struct { 1397 ClusterAgentVmIssue 1398 } 1399 1400 func init() { 1401 types.Add("eam:ClusterAgentVmNotRemoved", reflect.TypeOf((*ClusterAgentVmNotRemoved)(nil)).Elem()) 1402 } 1403 1404 // A cluster agent Virtual Machine is expected to be powered on, but the agent 1405 // Virtual Machine is powered off. 1406 // 1407 // Typically more specific issue (a subclass of 1408 // this issue) indicates the particular reason why vSphere ESX Agent Manager was 1409 // unable to power on the cluster agent Virtual Machine. 1410 // 1411 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1412 // powers on the cluster agent Virtual Machine. 1413 // 1414 // This structure may be used only with operations rendered under `/eam`. 1415 type ClusterAgentVmPoweredOff struct { 1416 ClusterAgentVmIssue 1417 } 1418 1419 func init() { 1420 types.Add("eam:ClusterAgentVmPoweredOff", reflect.TypeOf((*ClusterAgentVmPoweredOff)(nil)).Elem()) 1421 } 1422 1423 // A cluster agent virtual machine is expected to be powered off, but the agent 1424 // virtual machine is powered on. 1425 // 1426 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1427 // powers off the agent virtual machine. 1428 // 1429 // This structure may be used only with operations rendered under `/eam`. 1430 type ClusterAgentVmPoweredOn struct { 1431 ClusterAgentVmIssue 1432 } 1433 1434 func init() { 1435 types.Add("eam:ClusterAgentVmPoweredOn", reflect.TypeOf((*ClusterAgentVmPoweredOn)(nil)).Elem()) 1436 } 1437 1438 type ClusterAgentVmProtected struct { 1439 ClusterAgentVmIssue 1440 } 1441 1442 func init() { 1443 types.Add("eam:ClusterAgentVmProtected", reflect.TypeOf((*ClusterAgentVmProtected)(nil)).Elem()) 1444 } 1445 1446 // A cluster agent Virtual Machine is expected to be powered on, but the agent 1447 // Virtual Machine is suspended. 1448 // 1449 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1450 // powers on the cluster agent Virtual Machine. 1451 // 1452 // This structure may be used only with operations rendered under `/eam`. 1453 type ClusterAgentVmSuspended struct { 1454 ClusterAgentVmIssue 1455 } 1456 1457 func init() { 1458 types.Add("eam:ClusterAgentVmSuspended", reflect.TypeOf((*ClusterAgentVmSuspended)(nil)).Elem()) 1459 } 1460 1461 type CreateAgency CreateAgencyRequestType 1462 1463 func init() { 1464 types.Add("eam:CreateAgency", reflect.TypeOf((*CreateAgency)(nil)).Elem()) 1465 } 1466 1467 // The parameters of `EsxAgentManager.CreateAgency`. 1468 // 1469 // This structure may be used only with operations rendered under `/eam`. 1470 type CreateAgencyRequestType struct { 1471 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1472 // The configuration that describes how to deploy the agents in the 1473 // created agency. 1474 AgencyConfigInfo BaseAgencyConfigInfo `xml:"agencyConfigInfo,typeattr" json:"agencyConfigInfo"` 1475 // Deprecated. No sence to create agency in other state than 1476 // <code>enabled</code>. <code>disabled</code> is deprecated 1477 // whereas <code>uninstalled</code> is useless. 1478 // The initial goal state of the agency. See 1479 // `EamObjectRuntimeInfoGoalState_enum`. 1480 InitialGoalState string `xml:"initialGoalState" json:"initialGoalState"` 1481 } 1482 1483 func init() { 1484 types.Add("eam:CreateAgencyRequestType", reflect.TypeOf((*CreateAgencyRequestType)(nil)).Elem()) 1485 } 1486 1487 type CreateAgencyResponse struct { 1488 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 1489 } 1490 1491 type DestroyAgency DestroyAgencyRequestType 1492 1493 func init() { 1494 types.Add("eam:DestroyAgency", reflect.TypeOf((*DestroyAgency)(nil)).Elem()) 1495 } 1496 1497 type DestroyAgencyRequestType struct { 1498 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1499 } 1500 1501 func init() { 1502 types.Add("eam:DestroyAgencyRequestType", reflect.TypeOf((*DestroyAgencyRequestType)(nil)).Elem()) 1503 } 1504 1505 type DestroyAgencyResponse struct { 1506 } 1507 1508 // Thrown when trying to modify state over disabled clusters. 1509 // 1510 // This structure may be used only with operations rendered under `/eam`. 1511 type DisabledClusterFault struct { 1512 EamAppFault 1513 1514 // The MoRefs of the disabled compute resources. 1515 // 1516 // Refers instances of `ComputeResource`. 1517 DisabledComputeResource []types.ManagedObjectReference `xml:"disabledComputeResource,omitempty" json:"disabledComputeResource,omitempty"` 1518 } 1519 1520 func init() { 1521 types.Add("eam:DisabledClusterFault", reflect.TypeOf((*DisabledClusterFault)(nil)).Elem()) 1522 types.AddMinAPIVersionForType("eam:DisabledClusterFault", "7.6") 1523 } 1524 1525 type DisabledClusterFaultFault DisabledClusterFault 1526 1527 func init() { 1528 types.Add("eam:DisabledClusterFaultFault", reflect.TypeOf((*DisabledClusterFaultFault)(nil)).Elem()) 1529 } 1530 1531 // Application related error 1532 // As opposed to system errors, application ones are always function of the 1533 // input and the current state. 1534 // 1535 // They occur always upon same conditions. In most 1536 // of the cases they are recoverable, i.e. the client can determine what is 1537 // wrong and know how to recover. 1538 // NOTE: Since there is not yet need to distinguish among specific error 1539 // sub-types then we define a common type. Tomorrow, if necessary, we can add an 1540 // additional level of detailed exception types and make this one abstract. 1541 // 1542 // This structure may be used only with operations rendered under `/eam`. 1543 type EamAppFault struct { 1544 EamRuntimeFault 1545 } 1546 1547 func init() { 1548 types.Add("eam:EamAppFault", reflect.TypeOf((*EamAppFault)(nil)).Elem()) 1549 } 1550 1551 type EamAppFaultFault BaseEamAppFault 1552 1553 func init() { 1554 types.Add("eam:EamAppFaultFault", reflect.TypeOf((*EamAppFaultFault)(nil)).Elem()) 1555 } 1556 1557 // The common base type for all vSphere ESX Agent Manager exceptions. 1558 // 1559 // # TODO migrate to EamRuntimeFault 1560 // 1561 // This structure may be used only with operations rendered under `/eam`. 1562 type EamFault struct { 1563 types.MethodFault 1564 } 1565 1566 func init() { 1567 types.Add("eam:EamFault", reflect.TypeOf((*EamFault)(nil)).Elem()) 1568 } 1569 1570 type EamFaultFault BaseEamFault 1571 1572 func init() { 1573 types.Add("eam:EamFaultFault", reflect.TypeOf((*EamFaultFault)(nil)).Elem()) 1574 } 1575 1576 // IO error 1577 // NOTE: Since this type is a first of system-type errors we do not introduce a 1578 // common base type for them. 1579 // 1580 // Once add a second system type exception though, it 1581 // should be introduced. 1582 // 1583 // This structure may be used only with operations rendered under `/eam`. 1584 type EamIOFault struct { 1585 EamRuntimeFault 1586 } 1587 1588 func init() { 1589 types.Add("eam:EamIOFault", reflect.TypeOf((*EamIOFault)(nil)).Elem()) 1590 } 1591 1592 type EamIOFaultFault EamIOFault 1593 1594 func init() { 1595 types.Add("eam:EamIOFaultFault", reflect.TypeOf((*EamIOFaultFault)(nil)).Elem()) 1596 } 1597 1598 // Thrown when a user cannot be authenticated. 1599 // 1600 // This structure may be used only with operations rendered under `/eam`. 1601 type EamInvalidLogin struct { 1602 EamRuntimeFault 1603 } 1604 1605 func init() { 1606 types.Add("eam:EamInvalidLogin", reflect.TypeOf((*EamInvalidLogin)(nil)).Elem()) 1607 } 1608 1609 type EamInvalidLoginFault EamInvalidLogin 1610 1611 func init() { 1612 types.Add("eam:EamInvalidLoginFault", reflect.TypeOf((*EamInvalidLoginFault)(nil)).Elem()) 1613 } 1614 1615 // Thrown when a user is not allowed to execute an operation. 1616 // 1617 // This structure may be used only with operations rendered under `/eam`. 1618 type EamInvalidState struct { 1619 EamAppFault 1620 } 1621 1622 func init() { 1623 types.Add("eam:EamInvalidState", reflect.TypeOf((*EamInvalidState)(nil)).Elem()) 1624 } 1625 1626 type EamInvalidStateFault EamInvalidState 1627 1628 func init() { 1629 types.Add("eam:EamInvalidStateFault", reflect.TypeOf((*EamInvalidStateFault)(nil)).Elem()) 1630 } 1631 1632 // Indicates for an invalid or unknown Vib package structure and/or format. 1633 // 1634 // This structure may be used only with operations rendered under `/eam`. 1635 type EamInvalidVibPackage struct { 1636 EamRuntimeFault 1637 } 1638 1639 func init() { 1640 types.Add("eam:EamInvalidVibPackage", reflect.TypeOf((*EamInvalidVibPackage)(nil)).Elem()) 1641 } 1642 1643 type EamInvalidVibPackageFault EamInvalidVibPackage 1644 1645 func init() { 1646 types.Add("eam:EamInvalidVibPackageFault", reflect.TypeOf((*EamInvalidVibPackageFault)(nil)).Elem()) 1647 } 1648 1649 // The <code>RuntimeInfo</code> represents the runtime information of the vSphere ESX Agent 1650 // Manager managed 1651 // objects `Agency` and `Agent`. 1652 // 1653 // The runtime information provides 1654 // two kinds of information, namely, the 1655 // desired goal state of the entity and the status with regards to conforming 1656 // to that goal state. 1657 // 1658 // This structure may be used only with operations rendered under `/eam`. 1659 type EamObjectRuntimeInfo struct { 1660 types.DynamicData 1661 1662 // The health of the managed entity. 1663 // 1664 // This denotes how well the entity conforms to the 1665 // goal state. 1666 // 1667 // See also `EamObjectRuntimeInfoStatus_enum`. 1668 Status string `xml:"status" json:"status"` 1669 // Current issues that have been detected for this entity. 1670 // 1671 // Each issue can be remediated 1672 // by invoking `EamObject.Resolve` or `EamObject.ResolveAll`. 1673 Issue []BaseIssue `xml:"issue,omitempty,typeattr" json:"issue,omitempty"` 1674 // The desired state of the entity. 1675 // 1676 // See also `EamObjectRuntimeInfoGoalState_enum`. 1677 GoalState string `xml:"goalState" json:"goalState"` 1678 // The `Agent` or `Agency` with which this <code>RuntimeInfo</code> object is associated. 1679 // 1680 // Refers instance of `EamObject`. 1681 Entity types.ManagedObjectReference `xml:"entity" json:"entity"` 1682 } 1683 1684 func init() { 1685 types.Add("eam:EamObjectRuntimeInfo", reflect.TypeOf((*EamObjectRuntimeInfo)(nil)).Elem()) 1686 } 1687 1688 // The common base type for all vSphere ESX Agent Manager runtime exceptions. 1689 // 1690 // This structure may be used only with operations rendered under `/eam`. 1691 type EamRuntimeFault struct { 1692 types.RuntimeFault 1693 } 1694 1695 func init() { 1696 types.Add("eam:EamRuntimeFault", reflect.TypeOf((*EamRuntimeFault)(nil)).Elem()) 1697 } 1698 1699 type EamRuntimeFaultFault BaseEamRuntimeFault 1700 1701 func init() { 1702 types.Add("eam:EamRuntimeFaultFault", reflect.TypeOf((*EamRuntimeFaultFault)(nil)).Elem()) 1703 } 1704 1705 // Thrown when calling vSphere ESX Agent Manager when it is not fully 1706 // initialized. 1707 // 1708 // This structure may be used only with operations rendered under `/eam`. 1709 type EamServiceNotInitialized struct { 1710 EamRuntimeFault 1711 } 1712 1713 func init() { 1714 types.Add("eam:EamServiceNotInitialized", reflect.TypeOf((*EamServiceNotInitialized)(nil)).Elem()) 1715 } 1716 1717 type EamServiceNotInitializedFault EamServiceNotInitialized 1718 1719 func init() { 1720 types.Add("eam:EamServiceNotInitializedFault", reflect.TypeOf((*EamServiceNotInitializedFault)(nil)).Elem()) 1721 } 1722 1723 // System fault. 1724 // 1725 // This structure may be used only with operations rendered under `/eam`. 1726 type EamSystemFault struct { 1727 EamRuntimeFault 1728 } 1729 1730 func init() { 1731 types.Add("eam:EamSystemFault", reflect.TypeOf((*EamSystemFault)(nil)).Elem()) 1732 } 1733 1734 type EamSystemFaultFault EamSystemFault 1735 1736 func init() { 1737 types.Add("eam:EamSystemFaultFault", reflect.TypeOf((*EamSystemFaultFault)(nil)).Elem()) 1738 } 1739 1740 // Extensible issue class used by solutions to add custom issues to agents. 1741 // 1742 // When resolved, the issue is removed from the agent and an event is generated. 1743 // 1744 // This structure may be used only with operations rendered under `/eam`. 1745 type ExtensibleIssue struct { 1746 Issue 1747 1748 // Unique string for this type of issue. 1749 // 1750 // The type must match an event registered 1751 // by the solution as part of its extension. 1752 TypeId string `xml:"typeId" json:"typeId"` 1753 // Arguments associated with the typeId. 1754 Argument []types.KeyAnyValue `xml:"argument,omitempty" json:"argument,omitempty"` 1755 // A managed object reference to the object this issue is related to. 1756 // 1757 // Refers instance of `ManagedEntity`. 1758 Target *types.ManagedObjectReference `xml:"target,omitempty" json:"target,omitempty"` 1759 // An optional agent this issue pertains 1760 // 1761 // Refers instance of `Agent`. 1762 Agent *types.ManagedObjectReference `xml:"agent,omitempty" json:"agent,omitempty"` 1763 // An optional agency this issue pertains 1764 // 1765 // Refers instance of `Agency`. 1766 Agency *types.ManagedObjectReference `xml:"agency,omitempty" json:"agency,omitempty"` 1767 } 1768 1769 func init() { 1770 types.Add("eam:ExtensibleIssue", reflect.TypeOf((*ExtensibleIssue)(nil)).Elem()) 1771 } 1772 1773 type GetMaintenanceModePolicy GetMaintenanceModePolicyRequestType 1774 1775 func init() { 1776 types.Add("eam:GetMaintenanceModePolicy", reflect.TypeOf((*GetMaintenanceModePolicy)(nil)).Elem()) 1777 } 1778 1779 type GetMaintenanceModePolicyRequestType struct { 1780 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1781 } 1782 1783 func init() { 1784 types.Add("eam:GetMaintenanceModePolicyRequestType", reflect.TypeOf((*GetMaintenanceModePolicyRequestType)(nil)).Elem()) 1785 } 1786 1787 type GetMaintenanceModePolicyResponse struct { 1788 Returnval string `xml:"returnval" json:"returnval"` 1789 } 1790 1791 // Limits the hooks reported to the user. 1792 // 1793 // This structure may be used only with operations rendered under `/eam`. 1794 type HooksHookListSpec struct { 1795 types.DynamicData 1796 1797 // If specified - will report hooks only for agents from the specified 1798 // solutions, otherwise - will report hooks for agents from all solutions. 1799 Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"` 1800 // If specified - will report hooks only for agents on the specified 1801 // hosts, otherwise - will report hooks for agents on all hosts. 1802 // 1803 // Refers instances of `HostSystem`. 1804 Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"` 1805 } 1806 1807 func init() { 1808 types.Add("eam:HooksHookListSpec", reflect.TypeOf((*HooksHookListSpec)(nil)).Elem()) 1809 } 1810 1811 // Specification for marking a raised hook on an agent Virtual Machine as 1812 // processed. 1813 // 1814 // This structure may be used only with operations rendered under `/eam`. 1815 type HooksMarkAsProcessedSpec struct { 1816 types.DynamicData 1817 1818 // Virtual Machine to mark a hook as processed. 1819 // 1820 // Refers instance of `VirtualMachine`. 1821 Vm types.ManagedObjectReference `xml:"vm" json:"vm"` 1822 // Type of hook to be marked as processed `HooksHookType_enum`. 1823 HookType string `xml:"hookType" json:"hookType"` 1824 // `True` - if the hook was processed successfully, `False` - 1825 // if the hook could not be processed. 1826 Success bool `xml:"success" json:"success"` 1827 } 1828 1829 func init() { 1830 types.Add("eam:HooksMarkAsProcessedSpec", reflect.TypeOf((*HooksMarkAsProcessedSpec)(nil)).Elem()) 1831 } 1832 1833 // An agent virtual machine operation is expected to be initiated on host, but 1834 // the agent virtual machine operation has not been initiated. 1835 // 1836 // The reason is 1837 // that the host is in maintenance mode. 1838 // 1839 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1840 // takes the host out of maintenance mode and initiates the agent virtual 1841 // machine operation. 1842 // 1843 // Resolving this issue in vSphere Lifecyle Manager environemnt will be no-op. 1844 // In those cases user must take the host out of Maintenance Mode manually or 1845 // wait vSphere Lifecycle Maanger cluster remediation to complete (if any). 1846 // 1847 // This structure may be used only with operations rendered under `/eam`. 1848 type HostInMaintenanceMode struct { 1849 VmDeployed 1850 } 1851 1852 func init() { 1853 types.Add("eam:HostInMaintenanceMode", reflect.TypeOf((*HostInMaintenanceMode)(nil)).Elem()) 1854 } 1855 1856 type HostInPartialMaintenanceMode struct { 1857 AgentIssue 1858 1859 Vm *types.ManagedObjectReference `xml:"vm,omitempty" json:"vm,omitempty"` 1860 } 1861 1862 func init() { 1863 types.Add("eam:HostInPartialMaintenanceMode", reflect.TypeOf((*HostInPartialMaintenanceMode)(nil)).Elem()) 1864 } 1865 1866 // An agent virtual machine is expected to be removed from a host, but the agent virtual machine has not 1867 // been removed. 1868 // 1869 // The reason is that the host is in standby mode. 1870 // 1871 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host in standby mode 1872 // and removes the agent virtual machine. 1873 // 1874 // This structure may be used only with operations rendered under `/eam`. 1875 type HostInStandbyMode struct { 1876 VmDeployed 1877 } 1878 1879 func init() { 1880 types.Add("eam:HostInStandbyMode", reflect.TypeOf((*HostInStandbyMode)(nil)).Elem()) 1881 } 1882 1883 // Deprecated all host issues were removed. 1884 // 1885 // Base class for all host issues. 1886 // 1887 // This structure may be used only with operations rendered under `/eam`. 1888 type HostIssue struct { 1889 Issue 1890 1891 // The host to which the issue is related. 1892 // 1893 // Refers instance of `HostSystem`. 1894 Host types.ManagedObjectReference `xml:"host" json:"host"` 1895 } 1896 1897 func init() { 1898 types.Add("eam:HostIssue", reflect.TypeOf((*HostIssue)(nil)).Elem()) 1899 } 1900 1901 // Deprecated hostPoweredOff will no longer be used, instead 1902 // `ManagedHostNotReachable` will be raised. 1903 // 1904 // An agent virtual machine is expected to be removed from a host, but the agent 1905 // virtual machine has not been removed. 1906 // 1907 // The reason is that the host is powered 1908 // off. 1909 // 1910 // This is not a remediable issue. To remediate, power on the host. 1911 // 1912 // This structure may be used only with operations rendered under `/eam`. 1913 type HostPoweredOff struct { 1914 VmDeployed 1915 } 1916 1917 func init() { 1918 types.Add("eam:HostPoweredOff", reflect.TypeOf((*HostPoweredOff)(nil)).Elem()) 1919 } 1920 1921 // Live VIB operation failed. 1922 // 1923 // An immediate reboot is required to clear live VIB 1924 // operation failure. 1925 // 1926 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 1927 // puts the host into maintenance mode and reboots it. 1928 // 1929 // This structure may be used only with operations rendered under `/eam`. 1930 type ImmediateHostRebootRequired struct { 1931 VibIssue 1932 } 1933 1934 func init() { 1935 types.Add("eam:ImmediateHostRebootRequired", reflect.TypeOf((*ImmediateHostRebootRequired)(nil)).Elem()) 1936 } 1937 1938 // An agent virtual machine is expected to be deployed on a host, but the agent could not be 1939 // deployed because it was incompatible with the host. 1940 // 1941 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeployes the agent. However, 1942 // the problem is likely to persist until either the host or the solution has been 1943 // upgraded, so that the agent will become compatible with the host. 1944 // 1945 // This structure may be used only with operations rendered under `/eam`. 1946 type IncompatibleHostVersion struct { 1947 VmNotDeployed 1948 } 1949 1950 func init() { 1951 types.Add("eam:IncompatibleHostVersion", reflect.TypeOf((*IncompatibleHostVersion)(nil)).Elem()) 1952 } 1953 1954 // Deprecated this issue is no longer raised by EAM. It is replaced by 1955 // `InvalidConfig`. 1956 // 1957 // An agent virtual machine is expected to be powered on, but there are no free IP addresses in the 1958 // agent's pool of virtual machine IP addresses. 1959 // 1960 // To remediate, free some IP addresses or add some more to the IP pool and invoke 1961 // <code>resolve</code>. 1962 // 1963 // This structure may be used only with operations rendered under `/eam`. 1964 type InsufficientIpAddresses struct { 1965 VmPoweredOff 1966 1967 // The agent virtual machine network. 1968 // 1969 // Refers instance of `Network`. 1970 Network types.ManagedObjectReference `xml:"network" json:"network"` 1971 } 1972 1973 func init() { 1974 types.Add("eam:InsufficientIpAddresses", reflect.TypeOf((*InsufficientIpAddresses)(nil)).Elem()) 1975 } 1976 1977 // An agent virtual machine is expected to be deployed on a host, but the agent virtual machine could not be 1978 // deployed because the host does not have enough free CPU or memory resources. 1979 // 1980 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine. However, 1981 // the problem is likely to persist until enough CPU and memory resources are made available. 1982 // 1983 // This structure may be used only with operations rendered under `/eam`. 1984 type InsufficientResources struct { 1985 VmNotDeployed 1986 } 1987 1988 func init() { 1989 types.Add("eam:InsufficientResources", reflect.TypeOf((*InsufficientResources)(nil)).Elem()) 1990 } 1991 1992 // An agent virtual machine is expected to be deployed on a host, but the agent virtual machine could not be 1993 // deployed because the host's agent datastore did not have enough free space. 1994 // 1995 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine. However, 1996 // the problem is likely to persist until either space is freed up on the host's agent 1997 // virtual machine datastore or a new agent virtual machine datastore with enough free space is configured. 1998 // 1999 // This structure may be used only with operations rendered under `/eam`. 2000 type InsufficientSpace struct { 2001 VmNotDeployed 2002 } 2003 2004 func init() { 2005 types.Add("eam:InsufficientSpace", reflect.TypeOf((*InsufficientSpace)(nil)).Elem()) 2006 } 2007 2008 // Cannot remove the Baseline associated with an Agency from VUM. 2009 // 2010 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 2011 // retries the delete operation. 2012 // Note: In future this issue will denote also the removal of the Agency 2013 // software (VIBs) from VUM software depot once VUM provides an API for that. 2014 // 2015 // This structure may be used only with operations rendered under `/eam`. 2016 type IntegrityAgencyCannotDeleteSoftware struct { 2017 IntegrityAgencyVUMIssue 2018 } 2019 2020 func init() { 2021 types.Add("eam:IntegrityAgencyCannotDeleteSoftware", reflect.TypeOf((*IntegrityAgencyCannotDeleteSoftware)(nil)).Elem()) 2022 } 2023 2024 // The software defined by an Agency cannot be staged in VUM. 2025 // 2026 // The staging 2027 // operation consists of the following steps: 2028 // - Upload the Agency software (VIBs) to the VUM depot. 2029 // - Create or update a VUM Baseline with the Agency software and scope. 2030 // 2031 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 2032 // retries the stage operation. 2033 // 2034 // This structure may be used only with operations rendered under `/eam`. 2035 type IntegrityAgencyCannotStageSoftware struct { 2036 IntegrityAgencyVUMIssue 2037 } 2038 2039 func init() { 2040 types.Add("eam:IntegrityAgencyCannotStageSoftware", reflect.TypeOf((*IntegrityAgencyCannotStageSoftware)(nil)).Elem()) 2041 } 2042 2043 // Base class for all issues which occurred during EAM communication with 2044 // vSphere Update Manager (VUM). 2045 // 2046 // This structure may be used only with operations rendered under `/eam`. 2047 type IntegrityAgencyVUMIssue struct { 2048 AgencyIssue 2049 } 2050 2051 func init() { 2052 types.Add("eam:IntegrityAgencyVUMIssue", reflect.TypeOf((*IntegrityAgencyVUMIssue)(nil)).Elem()) 2053 } 2054 2055 // VUM service is not available - its registered SOAP endpoint cannot be 2056 // accessed or it is malfunctioning. 2057 // 2058 // This is an active and passive remediable issue. To remediate, vSphere ESX 2059 // Agent Manager retries to access VUM service. 2060 // 2061 // This structure may be used only with operations rendered under `/eam`. 2062 type IntegrityAgencyVUMUnavailable struct { 2063 IntegrityAgencyVUMIssue 2064 } 2065 2066 func init() { 2067 types.Add("eam:IntegrityAgencyVUMUnavailable", reflect.TypeOf((*IntegrityAgencyVUMUnavailable)(nil)).Elem()) 2068 } 2069 2070 // An <code>InvalidAgencyScope</code> fault is thrown when the scope in an 2071 // `AgencyConfigInfo` is invalid. 2072 // 2073 // See also `AgencyConfigInfo`. 2074 // 2075 // This structure may be used only with operations rendered under `/eam`. 2076 type InvalidAgencyScope struct { 2077 EamFault 2078 2079 // The MoRefs of the unknown compute resources. 2080 // 2081 // Refers instances of `ComputeResource`. 2082 UnknownComputeResource []types.ManagedObjectReference `xml:"unknownComputeResource,omitempty" json:"unknownComputeResource,omitempty"` 2083 } 2084 2085 func init() { 2086 types.Add("eam:InvalidAgencyScope", reflect.TypeOf((*InvalidAgencyScope)(nil)).Elem()) 2087 } 2088 2089 type InvalidAgencyScopeFault InvalidAgencyScope 2090 2091 func init() { 2092 types.Add("eam:InvalidAgencyScopeFault", reflect.TypeOf((*InvalidAgencyScopeFault)(nil)).Elem()) 2093 } 2094 2095 // An <code>InvalidAgentConfiguration</code> fault is thrown when the agent 2096 // configuration of an agency configuration is empty or invalid. 2097 // 2098 // See also `AgencyConfigInfo`. 2099 // 2100 // This structure may be used only with operations rendered under `/eam`. 2101 type InvalidAgentConfiguration struct { 2102 EamFault 2103 2104 // An optional invalid agent configuration. 2105 InvalidAgentConfiguration *AgentConfigInfo `xml:"invalidAgentConfiguration,omitempty" json:"invalidAgentConfiguration,omitempty"` 2106 // The invalid field. 2107 InvalidField string `xml:"invalidField,omitempty" json:"invalidField,omitempty"` 2108 } 2109 2110 func init() { 2111 types.Add("eam:InvalidAgentConfiguration", reflect.TypeOf((*InvalidAgentConfiguration)(nil)).Elem()) 2112 } 2113 2114 type InvalidAgentConfigurationFault InvalidAgentConfiguration 2115 2116 func init() { 2117 types.Add("eam:InvalidAgentConfigurationFault", reflect.TypeOf((*InvalidAgentConfigurationFault)(nil)).Elem()) 2118 } 2119 2120 // Invalid configuration is preventing a virtual machine operation. 2121 // 2122 // Typically 2123 // the attached error indicates the particular reason why vSphere ESX Agent 2124 // Manager is unable to power on or reconfigure the agent virtual machine. 2125 // 2126 // This is a passive remediable issue. To remediate update the virtual machine 2127 // configuration. 2128 // 2129 // This structure may be used only with operations rendered under `/eam`. 2130 type InvalidConfig struct { 2131 VmIssue 2132 2133 // The error, that caused this issue. 2134 // 2135 // It must be either MethodFault or 2136 // RuntimeFault. 2137 Error types.AnyType `xml:"error,typeattr" json:"error"` 2138 } 2139 2140 func init() { 2141 types.Add("eam:InvalidConfig", reflect.TypeOf((*InvalidConfig)(nil)).Elem()) 2142 } 2143 2144 // This exception is thrown if `VasaProviderSpec.url` is malformed. 2145 // 2146 // This structure may be used only with operations rendered under `/sms`. 2147 type InvalidUrl struct { 2148 EamFault 2149 2150 // Provider `VasaProviderSpec.url` 2151 Url string `xml:"url" json:"url"` 2152 MalformedUrl bool `xml:"malformedUrl" json:"malformedUrl"` 2153 UnknownHost bool `xml:"unknownHost" json:"unknownHost"` 2154 ConnectionRefused bool `xml:"connectionRefused" json:"connectionRefused"` 2155 ResponseCode int32 `xml:"responseCode,omitempty" json:"responseCode,omitempty"` 2156 } 2157 2158 func init() { 2159 types.Add("eam:InvalidUrl", reflect.TypeOf((*InvalidUrl)(nil)).Elem()) 2160 } 2161 2162 type InvalidUrlFault InvalidUrl 2163 2164 func init() { 2165 types.Add("eam:InvalidUrlFault", reflect.TypeOf((*InvalidUrlFault)(nil)).Elem()) 2166 } 2167 2168 // An issue represents a problem encountered while deploying and configurating agents 2169 // in a vCenter installation. 2170 // 2171 // An issue conveys the type of problem and the 2172 // entitity on which the problem has been encountered. Most issues are related to agents, 2173 // but they can also relate to an agency or a host. 2174 // 2175 // The set of issues provided by the vSphere ESX Agent Manager describes the discrepency between 2176 // the _desired_ agent deployment state, as defined by the agency configurations, 2177 // and the _actual_ deployment. The (@link EamObject.RuntimeInfo.Status.status) 2178 // of an agency or agent is green if it has reached its goal state. It is 2179 // marked as yellow if the vSphere ESX Agent Manager is actively working to bring the object 2180 // to its goal state. It is red if there is a discrepency between the current state and 2181 // the desired state. In the red state, a set of issues are filed on the object that 2182 // describe the reason for the discrepency between the desired and actual states. 2183 // 2184 // Issues are characterized as either active or passive remediable issues. For an active 2185 // remediable issue, the vSphere ESX Agent Manager can actively try to solve the issue. For 2186 // example, by deploying a new agent, removing an agent, changing its power state, and so 2187 // on. For a passive remediable issue, the vSphere ESX Agent Manager is not able to solve the 2188 // problem directly, and can only report the problem. For example, this could be 2189 // caused by an incomplete host configuration. 2190 // 2191 // When <code>resolve</code> is called for an active remediable issue, the vSphere ESX Agent Manager 2192 // starts performing the appropiate remediation steps for the particular issue. For a passive 2193 // remediable issue, the EAM manager simply checks if the condition 2194 // still exists, and if not it removes the issue. 2195 // 2196 // The vSphere ESX Agent Manager actively monitors most conditions relating to both 2197 // active and passive issues. Thus, it often automatically discovers when an 2198 // issue has been remediated and removes the issue without needing to explicitly 2199 // call <code>resolve</code> on an issue. 2200 // 2201 // The complete Issue hierarchy is shown below: 2202 // - `Issue` 2203 // - `AgencyIssue` 2204 // - `AgentIssue` 2205 // - `ManagedHostNotReachable` 2206 // - `VmNotDeployed` 2207 // - `CannotAccessAgentOVF` 2208 // - `IncompatibleHostVersion` 2209 // - `InsufficientResources` 2210 // - `InsufficientSpace` 2211 // - `OvfInvalidFormat` 2212 // - `NoAgentVmDatastore` 2213 // - `NoAgentVmNetwork` 2214 // - `VmIssue` 2215 // - `OvfInvalidProperty` 2216 // - `VmDeployed` 2217 // - `HostInMaintenanceMode` 2218 // - `HostInStandbyMode` 2219 // - `VmCorrupted` 2220 // - `VmOrphaned` 2221 // - `VmPoweredOff` 2222 // - `InsufficientIpAddresses` 2223 // - `MissingAgentIpPool` 2224 // - `VmPoweredOn` 2225 // - `VmSuspended` 2226 // - `VibIssue` 2227 // - `VibCannotPutHostInMaintenanceMode` 2228 // - `VibNotInstalled` 2229 // - `CannotAccessAgentVib` 2230 // - `VibDependenciesNotMetByHost` 2231 // - `VibInvalidFormat` 2232 // - `VibRequirementsNotMetByHost` 2233 // - `VibRequiresHostInMaintenanceMode` 2234 // - `VibRequiresHostReboot` 2235 // - `VibRequiresManualInstallation` 2236 // - `VibRequiresManualUninstallation` 2237 // - `ImmediateHostRebootRequired` 2238 // - `OrphanedAgency` 2239 // - `IntegrityAgencyVUMIssue` 2240 // - `IntegrityAgencyVUMUnavailable` 2241 // - `IntegrityAgencyCannotStageSoftware` 2242 // - `IntegrityAgencyCannotDeleteSoftware` 2243 // - `ClusterAgentAgentIssue` 2244 // - `ClusterAgentVmIssue` 2245 // - `ClusterAgentVmNotRemoved` 2246 // - `ClusterAgentVmPoweredOff` 2247 // - `ClusterAgentInsufficientClusterResources` 2248 // - `ClusterAgentVmNotDeployed` 2249 // - `ClusterAgentInsufficientClusterSpace` 2250 // - `ClusterAgentMissingClusterVmDatastore` 2251 // - `ClusterAgentMissingClusterVmNetwork` 2252 // 2253 // See also `EamObject.Resolve`, `EamObject.ResolveAll`. 2254 // 2255 // This structure may be used only with operations rendered under `/eam`. 2256 type Issue struct { 2257 types.DynamicData 2258 2259 // A unique identifier per <code>Issue</code> instance. 2260 Key int32 `xml:"key" json:"key"` 2261 // A localized message describing the issue. 2262 Description string `xml:"description" json:"description"` 2263 // The point in time when this issue was generated. 2264 // 2265 // Note that issues can be 2266 // regenerated periodically, so this time does not neccessarily reflect the 2267 // first time the issue was detected. 2268 Time time.Time `xml:"time" json:"time"` 2269 } 2270 2271 func init() { 2272 types.Add("eam:Issue", reflect.TypeOf((*Issue)(nil)).Elem()) 2273 } 2274 2275 // Managed ESXi Server is unreachable from vCenter Server or vSphere ESX Agent 2276 // Manager. 2277 // 2278 // Currently all operations on the affected host are imposible. Reasons 2279 // for this might be : 2280 // - ESXi Server is not connected from vCenter Server 2281 // - ESXi Server powered off 2282 // 2283 // This is not a remediable issue. To remediate, connect, power on or reboot the 2284 // host. 2285 // 2286 // This structure may be used only with operations rendered under `/eam`. 2287 type ManagedHostNotReachable struct { 2288 AgentIssue 2289 } 2290 2291 func init() { 2292 types.Add("eam:ManagedHostNotReachable", reflect.TypeOf((*ManagedHostNotReachable)(nil)).Elem()) 2293 } 2294 2295 type MarkAsAvailable MarkAsAvailableRequestType 2296 2297 func init() { 2298 types.Add("eam:MarkAsAvailable", reflect.TypeOf((*MarkAsAvailable)(nil)).Elem()) 2299 } 2300 2301 type MarkAsAvailableRequestType struct { 2302 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2303 } 2304 2305 func init() { 2306 types.Add("eam:MarkAsAvailableRequestType", reflect.TypeOf((*MarkAsAvailableRequestType)(nil)).Elem()) 2307 } 2308 2309 type MarkAsAvailableResponse struct { 2310 } 2311 2312 // Deprecated this issue is no longer raised by EAM. It is replaced by 2313 // `InvalidConfig`. 2314 // 2315 // An agent virtual machine is expected to be powered on, but the agent virtual machine is powered off because 2316 // there there are no IP addresses defined on the agent's virtual machine network. 2317 // 2318 // To remediate, create an IP pool on the agent's virtual machine network and invoke <code>resolve</code>. 2319 // 2320 // This structure may be used only with operations rendered under `/eam`. 2321 type MissingAgentIpPool struct { 2322 VmPoweredOff 2323 2324 // The agent virtual machine network. 2325 // 2326 // Refers instance of `Network`. 2327 Network types.ManagedObjectReference `xml:"network" json:"network"` 2328 } 2329 2330 func init() { 2331 types.Add("eam:MissingAgentIpPool", reflect.TypeOf((*MissingAgentIpPool)(nil)).Elem()) 2332 } 2333 2334 // Deprecated dvFilters are no longer supported by EAM. 2335 // 2336 // The agent is using the dvFilter API on the ESX host, but no dvFilter switch 2337 // has been configured on the host. 2338 // 2339 // This can happen due to host communication 2340 // failures or if the dvSwitch was (presumably accidentally) deleted from the 2341 // host configuration. 2342 // 2343 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 2344 // recreates the dvFilter switch. 2345 // 2346 // This structure may be used only with operations rendered under `/eam`. 2347 type MissingDvFilterSwitch struct { 2348 AgentIssue 2349 } 2350 2351 func init() { 2352 types.Add("eam:MissingDvFilterSwitch", reflect.TypeOf((*MissingDvFilterSwitch)(nil)).Elem()) 2353 } 2354 2355 // An agent virtual machine is expected to be deployed on a host, but the agent cannot be 2356 // deployed because the agent datastore has not been configured on the host. 2357 // 2358 // This is a passive remediable issue. The administrator must configure 2359 // the agent virtual machine datastore on the host. 2360 // 2361 // This structure may be used only with operations rendered under `/eam`. 2362 type NoAgentVmDatastore struct { 2363 VmNotDeployed 2364 } 2365 2366 func init() { 2367 types.Add("eam:NoAgentVmDatastore", reflect.TypeOf((*NoAgentVmDatastore)(nil)).Elem()) 2368 } 2369 2370 // An agent virtual machine is expected to be deployed on a host, but the agent cannot be 2371 // deployed because the agent network has not been configured on the host. 2372 // 2373 // This is a passive remediable issue. The administrator must configure 2374 // the agent virtual machine network on the host. 2375 // 2376 // This structure may be used only with operations rendered under `/eam`. 2377 type NoAgentVmNetwork struct { 2378 VmNotDeployed 2379 } 2380 2381 func init() { 2382 types.Add("eam:NoAgentVmNetwork", reflect.TypeOf((*NoAgentVmNetwork)(nil)).Elem()) 2383 } 2384 2385 // Thrown when calling vSphere ESX Agent Manager when it is not connected to the vCenter server. 2386 // 2387 // This structure may be used only with operations rendered under `/eam`. 2388 type NoConnectionToVCenter struct { 2389 EamRuntimeFault 2390 } 2391 2392 func init() { 2393 types.Add("eam:NoConnectionToVCenter", reflect.TypeOf((*NoConnectionToVCenter)(nil)).Elem()) 2394 } 2395 2396 type NoConnectionToVCenterFault NoConnectionToVCenter 2397 2398 func init() { 2399 types.Add("eam:NoConnectionToVCenterFault", reflect.TypeOf((*NoConnectionToVCenterFault)(nil)).Elem()) 2400 } 2401 2402 // An agent virtual machine is expected to be deployed on a host, but the agent cannot be 2403 // deployed because the agent datastore has not been configured on the host. 2404 // 2405 // The host 2406 // needs to be added to one of the datastores listed in customAgentVmDatastore. 2407 // 2408 // This is a passive remediable issue. The administrator must add one of the datastores 2409 // customAgentVmDatastore to the host. 2410 // 2411 // This structure may be used only with operations rendered under `/eam`. 2412 type NoCustomAgentVmDatastore struct { 2413 NoAgentVmDatastore 2414 2415 // A non-empty array of agent VM datastores that is required on the host. 2416 // 2417 // Refers instances of `Datastore`. 2418 CustomAgentVmDatastore []types.ManagedObjectReference `xml:"customAgentVmDatastore" json:"customAgentVmDatastore"` 2419 // The names of the agent VM datastores. 2420 CustomAgentVmDatastoreName []string `xml:"customAgentVmDatastoreName" json:"customAgentVmDatastoreName"` 2421 } 2422 2423 func init() { 2424 types.Add("eam:NoCustomAgentVmDatastore", reflect.TypeOf((*NoCustomAgentVmDatastore)(nil)).Elem()) 2425 } 2426 2427 // An agent virtual machine is expected to be deployed on a host, but the agent cannot be 2428 // deployed because the agent network has not been configured on the host. 2429 // 2430 // The host 2431 // needs to be added to one of the networks listed in customAgentVmNetwork. 2432 // 2433 // This is a passive remediable issue. The administrator must add one of the networks 2434 // customAgentVmNetwork to the host. 2435 // 2436 // This structure may be used only with operations rendered under `/eam`. 2437 type NoCustomAgentVmNetwork struct { 2438 NoAgentVmNetwork 2439 2440 // A non-empty array of agent VM networks that is required on the host. 2441 // 2442 // Refers instances of `Network`. 2443 CustomAgentVmNetwork []types.ManagedObjectReference `xml:"customAgentVmNetwork" json:"customAgentVmNetwork"` 2444 // The names of the agent VM networks. 2445 CustomAgentVmNetworkName []string `xml:"customAgentVmNetworkName" json:"customAgentVmNetworkName"` 2446 } 2447 2448 func init() { 2449 types.Add("eam:NoCustomAgentVmNetwork", reflect.TypeOf((*NoCustomAgentVmNetwork)(nil)).Elem()) 2450 } 2451 2452 // An agent virtual machine is expected to be deployed on a host, but the 2453 // agent cannot be deployed because the agent VM datastore could not be 2454 // discovered, as per defined selection policy, on the host. 2455 // 2456 // This issue can be remediated passively if the administrator configures 2457 // new datastores on the host. 2458 // 2459 // This structure may be used only with operations rendered under `/eam`. 2460 type NoDiscoverableAgentVmDatastore struct { 2461 VmNotDeployed 2462 } 2463 2464 func init() { 2465 types.Add("eam:NoDiscoverableAgentVmDatastore", reflect.TypeOf((*NoDiscoverableAgentVmDatastore)(nil)).Elem()) 2466 } 2467 2468 // An agent virtual machine is expected to be deployed on a host, but the 2469 // agent cannot be deployed because the agent VM network could not be 2470 // discovered, as per defined selection policy, on the host. 2471 // 2472 // This issue can be remediated passively if the administrator configures 2473 // new networks on the host. 2474 // 2475 // This structure may be used only with operations rendered under `/eam`. 2476 type NoDiscoverableAgentVmNetwork struct { 2477 VmNotDeployed 2478 } 2479 2480 func init() { 2481 types.Add("eam:NoDiscoverableAgentVmNetwork", reflect.TypeOf((*NoDiscoverableAgentVmNetwork)(nil)).Elem()) 2482 } 2483 2484 // Thrown when an a user cannot be authorized. 2485 // 2486 // This structure may be used only with operations rendered under `/eam`. 2487 type NotAuthorized struct { 2488 EamRuntimeFault 2489 } 2490 2491 func init() { 2492 types.Add("eam:NotAuthorized", reflect.TypeOf((*NotAuthorized)(nil)).Elem()) 2493 } 2494 2495 type NotAuthorizedFault NotAuthorized 2496 2497 func init() { 2498 types.Add("eam:NotAuthorizedFault", reflect.TypeOf((*NotAuthorizedFault)(nil)).Elem()) 2499 } 2500 2501 // Deprecated eAM no longer raises this issue. If agecny is getting orphaned 2502 // EAM simply destroys it. 2503 // 2504 // The solution that created the agency is no longer registered with the vCenter 2505 // server. 2506 // 2507 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 2508 // undeploys and removes the agency. 2509 // 2510 // This structure may be used only with operations rendered under `/eam`. 2511 type OrphanedAgency struct { 2512 AgencyIssue 2513 } 2514 2515 func init() { 2516 types.Add("eam:OrphanedAgency", reflect.TypeOf((*OrphanedAgency)(nil)).Elem()) 2517 } 2518 2519 // Deprecated dvFilters are no longer supported by EAM. 2520 // 2521 // A dvFilter switch exists on a host but no agents on the host depend on 2522 // dvFilter. 2523 // 2524 // This typically happens if a host is disconnected when an agency 2525 // configuration changed. 2526 // 2527 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 2528 // removes the dvFilterSwitch. 2529 // 2530 // This structure may be used only with operations rendered under `/eam`. 2531 type OrphanedDvFilterSwitch struct { 2532 HostIssue 2533 } 2534 2535 func init() { 2536 types.Add("eam:OrphanedDvFilterSwitch", reflect.TypeOf((*OrphanedDvFilterSwitch)(nil)).Elem()) 2537 } 2538 2539 // An Agent virtual machine is expected to be provisioned on a host, but it failed to do so 2540 // because the provisioning of the OVF package failed. 2541 // 2542 // The provisioning is unlikely to 2543 // succeed until the solution that provides the OVF package has been upgraded or 2544 // patched to provide a valid OVF package for the agent virtual machine. 2545 // 2546 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the OVF provisioning again. 2547 // 2548 // This structure may be used only with operations rendered under `/eam`. 2549 type OvfInvalidFormat struct { 2550 VmNotDeployed 2551 2552 // An optional list of errors that caused this issue. 2553 // 2554 // These errors are generated by the 2555 // vCenter server. 2556 Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"` 2557 } 2558 2559 func init() { 2560 types.Add("eam:OvfInvalidFormat", reflect.TypeOf((*OvfInvalidFormat)(nil)).Elem()) 2561 } 2562 2563 // An agent virtual machine needs to be provisioned or reconfigured, but an OVF 2564 // property is either missing or has an invalid value. 2565 // 2566 // This is a passive remediable issue. To remediate, update the OVF environment 2567 // in the agent configuration used to provision the agent virtual machine. 2568 // 2569 // This structure may be used only with operations rendered under `/eam`. 2570 type OvfInvalidProperty struct { 2571 AgentIssue 2572 2573 // An optional list of errors that caused this issue. 2574 // 2575 // These errors are 2576 // generated by the vCenter server. 2577 Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"` 2578 } 2579 2580 func init() { 2581 types.Add("eam:OvfInvalidProperty", reflect.TypeOf((*OvfInvalidProperty)(nil)).Elem()) 2582 } 2583 2584 // EAM was unable to set its required compute resource configuration in PM. 2585 // 2586 // EAM configuration needs to be updated or PM needs to be repaired manually to 2587 // allow the configuration. 2588 // 2589 // This structure may be used only with operations rendered under `/eam`. 2590 type PersonalityAgencyCannotConfigureSolutions struct { 2591 PersonalityAgencyPMIssue 2592 2593 // Compute resource that couldn't be configured 2594 // 2595 // Refers instance of `ComputeResource`. 2596 Cr types.ManagedObjectReference `xml:"cr" json:"cr"` 2597 // Names of the solutions attempted to be modified 2598 SolutionsToModify []string `xml:"solutionsToModify,omitempty" json:"solutionsToModify,omitempty"` 2599 // Names of the solutions attempted to be removed 2600 SolutionsToRemove []string `xml:"solutionsToRemove,omitempty" json:"solutionsToRemove,omitempty"` 2601 } 2602 2603 func init() { 2604 types.Add("eam:PersonalityAgencyCannotConfigureSolutions", reflect.TypeOf((*PersonalityAgencyCannotConfigureSolutions)(nil)).Elem()) 2605 } 2606 2607 // The offline depot could not be uploaded in Personality Manager. 2608 // 2609 // This structure may be used only with operations rendered under `/eam`. 2610 type PersonalityAgencyCannotUploadDepot struct { 2611 PersonalityAgencyDepotIssue 2612 2613 // URL EAM hosted the offline bundle as in vCenter. 2614 LocalDepotUrl string `xml:"localDepotUrl" json:"localDepotUrl"` 2615 } 2616 2617 func init() { 2618 types.Add("eam:PersonalityAgencyCannotUploadDepot", reflect.TypeOf((*PersonalityAgencyCannotUploadDepot)(nil)).Elem()) 2619 } 2620 2621 // Base class for all offline depot (VIB) issues while communicating with 2622 // Personality Manager. 2623 // 2624 // This structure may be used only with operations rendered under `/eam`. 2625 type PersonalityAgencyDepotIssue struct { 2626 PersonalityAgencyPMIssue 2627 2628 // URL the offline bundle is configured in EAM. 2629 RemoteDepotUrl string `xml:"remoteDepotUrl" json:"remoteDepotUrl"` 2630 } 2631 2632 func init() { 2633 types.Add("eam:PersonalityAgencyDepotIssue", reflect.TypeOf((*PersonalityAgencyDepotIssue)(nil)).Elem()) 2634 } 2635 2636 // The offline depot was not available for download during communicating with 2637 // Personality Manager. 2638 // 2639 // This structure may be used only with operations rendered under `/eam`. 2640 type PersonalityAgencyInaccessibleDepot struct { 2641 PersonalityAgencyDepotIssue 2642 } 2643 2644 func init() { 2645 types.Add("eam:PersonalityAgencyInaccessibleDepot", reflect.TypeOf((*PersonalityAgencyInaccessibleDepot)(nil)).Elem()) 2646 } 2647 2648 // The offline depot has missing or invalid metadata to be usable by 2649 // Personality Manager. 2650 // 2651 // This structure may be used only with operations rendered under `/eam`. 2652 type PersonalityAgencyInvalidDepot struct { 2653 PersonalityAgencyDepotIssue 2654 } 2655 2656 func init() { 2657 types.Add("eam:PersonalityAgencyInvalidDepot", reflect.TypeOf((*PersonalityAgencyInvalidDepot)(nil)).Elem()) 2658 } 2659 2660 // Base class for all issues which occurred during EAM communication with 2661 // Personality Manager. 2662 // 2663 // This structure may be used only with operations rendered under `/eam`. 2664 type PersonalityAgencyPMIssue struct { 2665 AgencyIssue 2666 } 2667 2668 func init() { 2669 types.Add("eam:PersonalityAgencyPMIssue", reflect.TypeOf((*PersonalityAgencyPMIssue)(nil)).Elem()) 2670 } 2671 2672 // PM service is not available - its endpoint cannot be accessed or it is 2673 // malfunctioning. 2674 // 2675 // This is an active and passive remediable issue. To remediate, vSphere ESX 2676 // Agent Manager retries to access PM service. 2677 // 2678 // This structure may be used only with operations rendered under `/eam`. 2679 type PersonalityAgencyPMUnavailable struct { 2680 PersonalityAgencyPMIssue 2681 } 2682 2683 func init() { 2684 types.Add("eam:PersonalityAgencyPMUnavailable", reflect.TypeOf((*PersonalityAgencyPMUnavailable)(nil)).Elem()) 2685 } 2686 2687 // The agent workflow is blocked until its' required solutions are re-mediated 2688 // externally in Personality Manager. 2689 // 2690 // This issue is only passively remediable. The desired state has to be applied 2691 // in PM by an user. 2692 // 2693 // This structure may be used only with operations rendered under `/eam`. 2694 type PersonalityAgentAwaitingPMRemediation struct { 2695 PersonalityAgentPMIssue 2696 } 2697 2698 func init() { 2699 types.Add("eam:PersonalityAgentAwaitingPMRemediation", reflect.TypeOf((*PersonalityAgentAwaitingPMRemediation)(nil)).Elem()) 2700 } 2701 2702 // The agent workflow is blocked by a failed agency operation with 2703 // Personality Manager. 2704 // 2705 // This issue is only passively remediable. The agency's PM related issue has to 2706 // be resolved. 2707 // 2708 // This structure may be used only with operations rendered under `/eam`. 2709 type PersonalityAgentBlockedByAgencyOperation struct { 2710 PersonalityAgentPMIssue 2711 } 2712 2713 func init() { 2714 types.Add("eam:PersonalityAgentBlockedByAgencyOperation", reflect.TypeOf((*PersonalityAgentBlockedByAgencyOperation)(nil)).Elem()) 2715 } 2716 2717 // Base class for all issues which occurred during EAM communication with 2718 // Personality Manager. 2719 // 2720 // This structure may be used only with operations rendered under `/eam`. 2721 type PersonalityAgentPMIssue struct { 2722 AgentIssue 2723 } 2724 2725 func init() { 2726 types.Add("eam:PersonalityAgentPMIssue", reflect.TypeOf((*PersonalityAgentPMIssue)(nil)).Elem()) 2727 } 2728 2729 type QueryAgency QueryAgencyRequestType 2730 2731 func init() { 2732 types.Add("eam:QueryAgency", reflect.TypeOf((*QueryAgency)(nil)).Elem()) 2733 } 2734 2735 type QueryAgencyRequestType struct { 2736 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2737 } 2738 2739 func init() { 2740 types.Add("eam:QueryAgencyRequestType", reflect.TypeOf((*QueryAgencyRequestType)(nil)).Elem()) 2741 } 2742 2743 type QueryAgencyResponse struct { 2744 Returnval []types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"` 2745 } 2746 2747 type QueryAgent QueryAgentRequestType 2748 2749 func init() { 2750 types.Add("eam:QueryAgent", reflect.TypeOf((*QueryAgent)(nil)).Elem()) 2751 } 2752 2753 type QueryAgentRequestType struct { 2754 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2755 } 2756 2757 func init() { 2758 types.Add("eam:QueryAgentRequestType", reflect.TypeOf((*QueryAgentRequestType)(nil)).Elem()) 2759 } 2760 2761 type QueryAgentResponse struct { 2762 Returnval []types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"` 2763 } 2764 2765 type QueryConfig QueryConfigRequestType 2766 2767 func init() { 2768 types.Add("eam:QueryConfig", reflect.TypeOf((*QueryConfig)(nil)).Elem()) 2769 } 2770 2771 type QueryConfigRequestType struct { 2772 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2773 } 2774 2775 func init() { 2776 types.Add("eam:QueryConfigRequestType", reflect.TypeOf((*QueryConfigRequestType)(nil)).Elem()) 2777 } 2778 2779 type QueryConfigResponse struct { 2780 Returnval BaseAgencyConfigInfo `xml:"returnval,typeattr" json:"returnval"` 2781 } 2782 2783 type QueryIssue QueryIssueRequestType 2784 2785 func init() { 2786 types.Add("eam:QueryIssue", reflect.TypeOf((*QueryIssue)(nil)).Elem()) 2787 } 2788 2789 // The parameters of `EamObject.QueryIssue`. 2790 // 2791 // This structure may be used only with operations rendered under `/eam`. 2792 type QueryIssueRequestType struct { 2793 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2794 // An optional array of issue keys. If not set, all issues for this 2795 // entity are returned. 2796 IssueKey []int32 `xml:"issueKey,omitempty" json:"issueKey,omitempty"` 2797 } 2798 2799 func init() { 2800 types.Add("eam:QueryIssueRequestType", reflect.TypeOf((*QueryIssueRequestType)(nil)).Elem()) 2801 } 2802 2803 type QueryIssueResponse struct { 2804 Returnval []BaseIssue `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` 2805 } 2806 2807 type QuerySolutionId QuerySolutionIdRequestType 2808 2809 func init() { 2810 types.Add("eam:QuerySolutionId", reflect.TypeOf((*QuerySolutionId)(nil)).Elem()) 2811 } 2812 2813 type QuerySolutionIdRequestType struct { 2814 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2815 } 2816 2817 func init() { 2818 types.Add("eam:QuerySolutionIdRequestType", reflect.TypeOf((*QuerySolutionIdRequestType)(nil)).Elem()) 2819 } 2820 2821 type QuerySolutionIdResponse struct { 2822 Returnval string `xml:"returnval" json:"returnval"` 2823 } 2824 2825 type RegisterAgentVm RegisterAgentVmRequestType 2826 2827 func init() { 2828 types.Add("eam:RegisterAgentVm", reflect.TypeOf((*RegisterAgentVm)(nil)).Elem()) 2829 } 2830 2831 // The parameters of `Agency.RegisterAgentVm`. 2832 // 2833 // This structure may be used only with operations rendered under `/eam`. 2834 type RegisterAgentVmRequestType struct { 2835 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2836 // The managed object reference to the agent VM. 2837 // 2838 // Refers instance of `VirtualMachine`. 2839 AgentVm types.ManagedObjectReference `xml:"agentVm" json:"agentVm"` 2840 } 2841 2842 func init() { 2843 types.Add("eam:RegisterAgentVmRequestType", reflect.TypeOf((*RegisterAgentVmRequestType)(nil)).Elem()) 2844 } 2845 2846 type RegisterAgentVmResponse struct { 2847 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 2848 } 2849 2850 type Resolve ResolveRequestType 2851 2852 func init() { 2853 types.Add("eam:Resolve", reflect.TypeOf((*Resolve)(nil)).Elem()) 2854 } 2855 2856 type ResolveAll ResolveAllRequestType 2857 2858 func init() { 2859 types.Add("eam:ResolveAll", reflect.TypeOf((*ResolveAll)(nil)).Elem()) 2860 } 2861 2862 type ResolveAllRequestType struct { 2863 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2864 } 2865 2866 func init() { 2867 types.Add("eam:ResolveAllRequestType", reflect.TypeOf((*ResolveAllRequestType)(nil)).Elem()) 2868 } 2869 2870 type ResolveAllResponse struct { 2871 } 2872 2873 // The parameters of `EamObject.Resolve`. 2874 // 2875 // This structure may be used only with operations rendered under `/eam`. 2876 type ResolveRequestType struct { 2877 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2878 // A non-empty array of issue keys. 2879 IssueKey []int32 `xml:"issueKey" json:"issueKey"` 2880 } 2881 2882 func init() { 2883 types.Add("eam:ResolveRequestType", reflect.TypeOf((*ResolveRequestType)(nil)).Elem()) 2884 } 2885 2886 type ResolveResponse struct { 2887 Returnval []int32 `xml:"returnval,omitempty" json:"returnval,omitempty"` 2888 } 2889 2890 type ScanForUnknownAgentVm ScanForUnknownAgentVmRequestType 2891 2892 func init() { 2893 types.Add("eam:ScanForUnknownAgentVm", reflect.TypeOf((*ScanForUnknownAgentVm)(nil)).Elem()) 2894 } 2895 2896 type ScanForUnknownAgentVmRequestType struct { 2897 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2898 } 2899 2900 func init() { 2901 types.Add("eam:ScanForUnknownAgentVmRequestType", reflect.TypeOf((*ScanForUnknownAgentVmRequestType)(nil)).Elem()) 2902 } 2903 2904 type ScanForUnknownAgentVmResponse struct { 2905 } 2906 2907 type SetMaintenanceModePolicy SetMaintenanceModePolicyRequestType 2908 2909 func init() { 2910 types.Add("eam:SetMaintenanceModePolicy", reflect.TypeOf((*SetMaintenanceModePolicy)(nil)).Elem()) 2911 } 2912 2913 // The parameters of `EsxAgentManager.SetMaintenanceModePolicy`. 2914 // 2915 // This structure may be used only with operations rendered under `/eam`. 2916 type SetMaintenanceModePolicyRequestType struct { 2917 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2918 // The policy to use. 2919 Policy string `xml:"policy" json:"policy"` 2920 } 2921 2922 func init() { 2923 types.Add("eam:SetMaintenanceModePolicyRequestType", reflect.TypeOf((*SetMaintenanceModePolicyRequestType)(nil)).Elem()) 2924 types.AddMinAPIVersionForType("eam:SetMaintenanceModePolicyRequestType", "7.4") 2925 } 2926 2927 type SetMaintenanceModePolicyResponse struct { 2928 } 2929 2930 // Specification describing a desired state to be applied. 2931 // 2932 // This structure may be used only with operations rendered under `/eam`. 2933 type SolutionsApplySpec struct { 2934 types.DynamicData 2935 2936 // Complete desired state to be applied on the target entity. 2937 // 2938 // the `*solutions*` member limits which parts of this desired state to 2939 // be applied 2940 // 2941 // If the `*solutions*` member is omitted. 2942 // - Any solution described in this structure will be applied on the 2943 // target entity 2944 // - Any solution already existing on the target entity, but missing 2945 // from this structure, will be deleted from the target entity 2946 DesiredState []SolutionsSolutionConfig `xml:"desiredState,omitempty" json:"desiredState,omitempty"` 2947 // If provided, limits the parts of the `*desiredState*` structure to 2948 // be applied on the target entity. 2949 // - solutions that are also present in the `*desiredState*` 2950 // structure will be applied on the target entity. 2951 // - solutions that are missing from the `*desiredState*` structure 2952 // will be deleted from the target entity. 2953 Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"` 2954 // Specifies exact hosts to apply the desired state to, instead of every 2955 // host in the cluster. 2956 // 2957 // Applicable only to solutions with 2958 // `SolutionsHostBoundSolutionConfig`. 2959 // 2960 // Refers instances of `HostSystem`. 2961 Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"` 2962 // Deployment units on which solutions that are specified by the this 2963 // structure need to be applied. 2964 // 2965 // Applicable only to solutions with 2966 // `SolutionsClusterBoundSolutionConfig`. 2967 // 2968 // The deployment unit represents a single VM instance deployment. It is 2969 // returned by the `Solutions.Compliance` operation. 2970 // 2971 // If omitted - the configured solutions by `SolutionsApplySpec.solutions` are applied 2972 // on all of the deployment units in the cluster. 2973 DeploymentUnits []string `xml:"deploymentUnits,omitempty" json:"deploymentUnits,omitempty"` 2974 } 2975 2976 func init() { 2977 types.Add("eam:SolutionsApplySpec", reflect.TypeOf((*SolutionsApplySpec)(nil)).Elem()) 2978 } 2979 2980 // Specifies cluster-bound solution configuration. 2981 // 2982 // This structure may be used only with operations rendered under `/eam`. 2983 type SolutionsClusterBoundSolutionConfig struct { 2984 SolutionsTypeSpecificSolutionConfig 2985 2986 // The number of instances of the specified VM to be deployed across the 2987 // cluster. 2988 VmCount int32 `xml:"vmCount" json:"vmCount"` 2989 // VM placement policies to be configured on the VMs 2990 // `SolutionsVmPlacementPolicy_enum` If omitted - no VM placement 2991 // policies are configured. 2992 VmPlacementPolicies []string `xml:"vmPlacementPolicies,omitempty" json:"vmPlacementPolicies,omitempty"` 2993 // Networks to be configured on the VMs. 2994 // 2995 // If omitted - no VM networks are 2996 // configured. 2997 VmNetworks []SolutionsVMNetworkMapping `xml:"vmNetworks,omitempty" json:"vmNetworks,omitempty"` 2998 // Datastores to be configured as a storage of the VMs. 2999 // 3000 // The first 3001 // available datastore in the cluster is used. The collection cannot 3002 // contain duplicate elements. 3003 // 3004 // Refers instances of `Datastore`. 3005 Datastores []types.ManagedObjectReference `xml:"datastores,omitempty" json:"datastores,omitempty"` 3006 Devices *types.VirtualMachineConfigSpec `xml:"devices,omitempty" json:"devices,omitempty"` 3007 } 3008 3009 func init() { 3010 types.Add("eam:SolutionsClusterBoundSolutionConfig", reflect.TypeOf((*SolutionsClusterBoundSolutionConfig)(nil)).Elem()) 3011 } 3012 3013 // Result of a compliance check of a desired state for a solution with 3014 // `SolutionsClusterBoundSolutionConfig`. 3015 // 3016 // This structure may be used only with operations rendered under `/eam`. 3017 type SolutionsClusterSolutionComplianceResult struct { 3018 types.DynamicData 3019 3020 // The solution being checked for compliance. 3021 Solution string `xml:"solution" json:"solution"` 3022 // `True` if the solution is compliant with the described desired 3023 // state, `False` - otherwise. 3024 Compliant bool `xml:"compliant" json:"compliant"` 3025 // Detailed per deployment-unit compliance result. 3026 DeploymentUnits []SolutionsDeploymentUnitComplianceResult `xml:"deploymentUnits,omitempty" json:"deploymentUnits,omitempty"` 3027 } 3028 3029 func init() { 3030 types.Add("eam:SolutionsClusterSolutionComplianceResult", reflect.TypeOf((*SolutionsClusterSolutionComplianceResult)(nil)).Elem()) 3031 } 3032 3033 // Result of a compliance check of a desired state on a compute resource. 3034 // 3035 // This structure may be used only with operations rendered under `/eam`. 3036 type SolutionsComplianceResult struct { 3037 types.DynamicData 3038 3039 // `True` if the compute resource is compliant with the described 3040 // desired state, `False` - otherwise. 3041 Compliant bool `xml:"compliant" json:"compliant"` 3042 // Detailed per-host compliance result of the compute resource for 3043 // solutions with `SolutionsHostBoundSolutionConfig`. 3044 Hosts []SolutionsHostComplianceResult `xml:"hosts,omitempty" json:"hosts,omitempty"` 3045 // Detailed per-solution unit compliance result of the compute resource 3046 // for solutions with `SolutionsClusterBoundSolutionConfig`. 3047 ClusterSolutionsCompliance []SolutionsClusterSolutionComplianceResult `xml:"clusterSolutionsCompliance,omitempty" json:"clusterSolutionsCompliance,omitempty"` 3048 } 3049 3050 func init() { 3051 types.Add("eam:SolutionsComplianceResult", reflect.TypeOf((*SolutionsComplianceResult)(nil)).Elem()) 3052 } 3053 3054 // Specification describing how to calculate compliance of a compute resource 3055 // against a desired state. 3056 // 3057 // This structure may be used only with operations rendered under `/eam`. 3058 type SolutionsComplianceSpec struct { 3059 types.DynamicData 3060 3061 // Desired state to be checked for compliance. 3062 // 3063 // May be incomplete if exact 3064 // solutions to be checked are provided. Empty desired state means all 3065 // present solutions must be removed. 3066 DesiredState []SolutionsSolutionConfig `xml:"desiredState,omitempty" json:"desiredState,omitempty"` 3067 // Specifies exact solutions to be checked for compliance instead of the 3068 // complete desired state. 3069 Solutions []string `xml:"solutions,omitempty" json:"solutions,omitempty"` 3070 // Specifies exact hosts to be checked for compliance of all solutions 3071 // with `SolutionsHostBoundSolutionConfig`. 3072 // 3073 // If omitted - the compliance is checked for all hosts in the cluster. 3074 // 3075 // Refers instances of `HostSystem`. 3076 Hosts []types.ManagedObjectReference `xml:"hosts,omitempty" json:"hosts,omitempty"` 3077 // Identifiers of the deployment units that to be checked for compliance 3078 // of all solutions with `SolutionsClusterBoundSolutionConfig`. 3079 // 3080 // The deployment unit represents a single VM instance deployment. 3081 // 3082 // If omitted - the compliance is checked for all deployment units in the 3083 // cluster. 3084 DeploymentUnits []string `xml:"deploymentUnits,omitempty" json:"deploymentUnits,omitempty"` 3085 } 3086 3087 func init() { 3088 types.Add("eam:SolutionsComplianceSpec", reflect.TypeOf((*SolutionsComplianceSpec)(nil)).Elem()) 3089 } 3090 3091 // Result of a compliance check of a deployment unit. 3092 // 3093 // This structure may be used only with operations rendered under `/eam`. 3094 type SolutionsDeploymentUnitComplianceResult struct { 3095 types.DynamicData 3096 3097 // The deployment unit being checked for compliance. 3098 DeploymentUnit string `xml:"deploymentUnit" json:"deploymentUnit"` 3099 // `True` if the deployment unit is compliant with the described 3100 // desired state, `False` - otherwise. 3101 Compliant bool `xml:"compliant" json:"compliant"` 3102 // Detailed compliance result of the deployment unit. 3103 Compliance *SolutionsSolutionComplianceResult `xml:"compliance,omitempty" json:"compliance,omitempty"` 3104 } 3105 3106 func init() { 3107 types.Add("eam:SolutionsDeploymentUnitComplianceResult", reflect.TypeOf((*SolutionsDeploymentUnitComplianceResult)(nil)).Elem()) 3108 } 3109 3110 // Specifies the acknowledgement type of a configured System Virtual 3111 // Machine's lifecycle hook. 3112 // 3113 // This structure may be used only with operations rendered under `/eam`. 3114 type SolutionsHookAcknowledgeConfig struct { 3115 types.DynamicData 3116 } 3117 3118 func init() { 3119 types.Add("eam:SolutionsHookAcknowledgeConfig", reflect.TypeOf((*SolutionsHookAcknowledgeConfig)(nil)).Elem()) 3120 } 3121 3122 // Configuration for System Virtual Machine's lifecycle hooks. 3123 // 3124 // This structure may be used only with operations rendered under `/eam`. 3125 type SolutionsHookConfig struct { 3126 types.DynamicData 3127 3128 // Type of the configured hook, possible values - `HooksHookType_enum`. 3129 Type string `xml:"type" json:"type"` 3130 // Type of acknoledgement of the configured hook. 3131 Acknowledgement BaseSolutionsHookAcknowledgeConfig `xml:"acknowledgement,typeattr" json:"acknowledgement"` 3132 // The maximum time in seconds to wait for a hook to be processed. 3133 // 3134 // An 3135 // issue is raised if the time elapsed and the hook is still not 3136 // processed. 3137 // If omitted - defaults to 10 hours. 3138 Timeout int64 `xml:"timeout,omitempty" json:"timeout,omitempty"` 3139 } 3140 3141 func init() { 3142 types.Add("eam:SolutionsHookConfig", reflect.TypeOf((*SolutionsHookConfig)(nil)).Elem()) 3143 } 3144 3145 // Contains information for a raised hook. 3146 // 3147 // This structure may be used only with operations rendered under `/eam`. 3148 type SolutionsHookInfo struct { 3149 types.DynamicData 3150 3151 // Virtual Machine, the hook was raised for. 3152 // 3153 // Refers instance of `VirtualMachine`. 3154 Vm types.ManagedObjectReference `xml:"vm" json:"vm"` 3155 // Solution the Virtual Machine belongs to. 3156 Solution string `xml:"solution" json:"solution"` 3157 // Configuration of the hook. 3158 Config SolutionsHookConfig `xml:"config" json:"config"` 3159 // Time the hook was raised. 3160 RaisedAt time.Time `xml:"raisedAt" json:"raisedAt"` 3161 } 3162 3163 func init() { 3164 types.Add("eam:SolutionsHookInfo", reflect.TypeOf((*SolutionsHookInfo)(nil)).Elem()) 3165 } 3166 3167 // Specifies host-bound solution configuration. 3168 // 3169 // This structure may be used only with operations rendered under `/eam`. 3170 type SolutionsHostBoundSolutionConfig struct { 3171 SolutionsTypeSpecificSolutionConfig 3172 3173 // If set to true - default network and datastore configured on host will 3174 // take precedence over 3175 // `SolutionsHostBoundSolutionConfig.datastores` and 3176 // `SolutionsHostBoundSolutionConfig.networks`. 3177 PreferHostConfiguration *bool `xml:"preferHostConfiguration" json:"preferHostConfiguration,omitempty"` 3178 // networks to satisfy system Virtual Machine network adapter 3179 // requirements. 3180 // 3181 // If omitted - default configured network on the host will 3182 // be used. 3183 // 3184 // Refers instances of `Network`. 3185 Networks []types.ManagedObjectReference `xml:"networks,omitempty" json:"networks,omitempty"` 3186 // Datastores to be configured as a storage of the VMs. 3187 // 3188 // The first 3189 // available datastore on the host is used. The collection cannot contain 3190 // duplicate elements. If omitted - default configured datastore on the 3191 // host will be used. 3192 // 3193 // Refers instances of `Datastore`. 3194 Datastores []types.ManagedObjectReference `xml:"datastores,omitempty" json:"datastores,omitempty"` 3195 // VMCI to be allowed access from the system Virtual Machine. 3196 Vmci []string `xml:"vmci,omitempty" json:"vmci,omitempty"` 3197 } 3198 3199 func init() { 3200 types.Add("eam:SolutionsHostBoundSolutionConfig", reflect.TypeOf((*SolutionsHostBoundSolutionConfig)(nil)).Elem()) 3201 } 3202 3203 // Result of a compliance check of a desired state on a host. 3204 // 3205 // This structure may be used only with operations rendered under `/eam`. 3206 type SolutionsHostComplianceResult struct { 3207 types.DynamicData 3208 3209 // The host being checked for compliance. 3210 // 3211 // Refers instance of `HostSystem`. 3212 Host types.ManagedObjectReference `xml:"host" json:"host"` 3213 // `True` if the compute host is compliant with the described 3214 // desired state, `False` - otherwise. 3215 Compliant bool `xml:"compliant" json:"compliant"` 3216 // Detailed per-solution compliance result of the host. 3217 Solutions []SolutionsSolutionComplianceResult `xml:"solutions,omitempty" json:"solutions,omitempty"` 3218 } 3219 3220 func init() { 3221 types.Add("eam:SolutionsHostComplianceResult", reflect.TypeOf((*SolutionsHostComplianceResult)(nil)).Elem()) 3222 } 3223 3224 // The user will have to (manually) invoke an API 3225 // (`Hooks.MarkAsProcessed`) to acknowledge, the user operations for 3226 // this lifecycle hook have been completed. 3227 // 3228 // This structure may be used only with operations rendered under `/eam`. 3229 type SolutionsInteractiveHookAcknowledgeConfig struct { 3230 SolutionsHookAcknowledgeConfig 3231 } 3232 3233 func init() { 3234 types.Add("eam:SolutionsInteractiveHookAcknowledgeConfig", reflect.TypeOf((*SolutionsInteractiveHookAcknowledgeConfig)(nil)).Elem()) 3235 } 3236 3237 // One OVF Property. 3238 // 3239 // This structure may be used only with operations rendered under `/eam`. 3240 type SolutionsOvfProperty struct { 3241 types.DynamicData 3242 3243 // The name of the property in the OVF descriptor. 3244 Key string `xml:"key" json:"key"` 3245 // The value of the property. 3246 Value string `xml:"value" json:"value"` 3247 } 3248 3249 func init() { 3250 types.Add("eam:SolutionsOvfProperty", reflect.TypeOf((*SolutionsOvfProperty)(nil)).Elem()) 3251 } 3252 3253 // Specifies a user defined profile ID to be applied during Virtual Machine 3254 // creation. 3255 // 3256 // This structure may be used only with operations rendered under `/eam`. 3257 type SolutionsProfileIdStoragePolicy struct { 3258 SolutionsStoragePolicy 3259 3260 // ID of a storage policy profile created by the user. 3261 // 3262 // The type of the 3263 // profile must be `VirtualMachineDefinedProfileSpec`. The ID must be valid 3264 // `VirtualMachineDefinedProfileSpec.profileId`. 3265 ProfileId string `xml:"profileId" json:"profileId"` 3266 } 3267 3268 func init() { 3269 types.Add("eam:SolutionsProfileIdStoragePolicy", reflect.TypeOf((*SolutionsProfileIdStoragePolicy)(nil)).Elem()) 3270 } 3271 3272 // Result of a compliance check of a desired state dor a solution(on a host). 3273 // 3274 // This structure may be used only with operations rendered under `/eam`. 3275 type SolutionsSolutionComplianceResult struct { 3276 types.DynamicData 3277 3278 // Solution checked for compliance. 3279 Solution string `xml:"solution" json:"solution"` 3280 // `True` if the compute solution is compliant with the described 3281 // desired state, `False` - otherwise. 3282 Compliant bool `xml:"compliant" json:"compliant"` 3283 // Reason the solution is non-compliant 3284 // `SolutionsNonComplianceReason_enum`. 3285 NonComplianceReason string `xml:"nonComplianceReason,omitempty" json:"nonComplianceReason,omitempty"` 3286 // system Virtual Machine created for the solution. 3287 // 3288 // Refers instance of `VirtualMachine`. 3289 Vm *types.ManagedObjectReference `xml:"vm,omitempty" json:"vm,omitempty"` 3290 // system Virtual Machine created for upgrading the obsoleted system 3291 // Virtual Machine. 3292 // 3293 // Refers instance of `VirtualMachine`. 3294 UpgradingVm *types.ManagedObjectReference `xml:"upgradingVm,omitempty" json:"upgradingVm,omitempty"` 3295 // Hook, ESX Agent Manager is awaiting to be processed for this solution. 3296 Hook *SolutionsHookInfo `xml:"hook,omitempty" json:"hook,omitempty"` 3297 // Issues, ESX Agent Manager has encountered while attempting to acheive 3298 // the solution's requested desired state. 3299 Issues []BaseIssue `xml:"issues,omitempty,typeattr" json:"issues,omitempty"` 3300 // Last desired state for the solution, requested from ESX Agent Manager, 3301 // for application. 3302 SolutionConfig *SolutionsSolutionConfig `xml:"solutionConfig,omitempty" json:"solutionConfig,omitempty"` 3303 } 3304 3305 func init() { 3306 types.Add("eam:SolutionsSolutionComplianceResult", reflect.TypeOf((*SolutionsSolutionComplianceResult)(nil)).Elem()) 3307 } 3308 3309 // Configuration for a solution's required system Virtual Machine. 3310 // 3311 // This structure may be used only with operations rendered under `/eam`. 3312 type SolutionsSolutionConfig struct { 3313 types.DynamicData 3314 3315 // Solution, this configuration belongs to. 3316 Solution string `xml:"solution" json:"solution"` 3317 // Display name of the solution. 3318 DisplayName string `xml:"displayName" json:"displayName"` 3319 // Display version of the solution. 3320 DisplayVersion string `xml:"displayVersion" json:"displayVersion"` 3321 // Source of the system Virtual Machine files. 3322 VmSource BaseSolutionsVMSource `xml:"vmSource,typeattr" json:"vmSource"` 3323 // VM name prefix. 3324 PrefixVmName string `xml:"prefixVmName" json:"prefixVmName"` 3325 // If set to `True` - will insert an UUID in the system Virtual 3326 // Machines' names created for the solution, otherwise - no additional 3327 // UUID will be inserted in the system Virtual Machines' names. 3328 UuidVmName bool `xml:"uuidVmName" json:"uuidVmName"` 3329 // Resource pool to place the system Virtual Machine in. 3330 // 3331 // If omitted a 3332 // default resource pool will be used. 3333 // 3334 // Refers instance of `ResourcePool`. 3335 ResourcePool *types.ManagedObjectReference `xml:"resourcePool,omitempty" json:"resourcePool,omitempty"` 3336 // Folder to place the system Virtual Machine in. 3337 // 3338 // If omitted a default 3339 // folder will be used. 3340 // 3341 // Refers instance of `Folder`. 3342 Folder *types.ManagedObjectReference `xml:"folder,omitempty" json:"folder,omitempty"` 3343 // User configurable OVF properties to be assigned during system Virtual 3344 // Machine creation. 3345 OvfProperties []SolutionsOvfProperty `xml:"ovfProperties,omitempty" json:"ovfProperties,omitempty"` 3346 // Storage policies to be applied during system Virtual Machine creation. 3347 StoragePolicies []BaseSolutionsStoragePolicy `xml:"storagePolicies,omitempty,typeattr" json:"storagePolicies,omitempty"` 3348 // Provisioning type for the system Virtual Machines 3349 // `SolutionsVMDiskProvisioning_enum`. 3350 // 3351 // Default provisioning will be used 3352 // if not specified. 3353 VmDiskProvisioning string `xml:"vmDiskProvisioning,omitempty" json:"vmDiskProvisioning,omitempty"` 3354 // Optimization strategy for deploying Virtual Machines 3355 // `SolutionsVMDeploymentOptimization_enum`. 3356 // 3357 // Default optimization will 3358 // be selected if not specified. 3359 VmDeploymentOptimization string `xml:"vmDeploymentOptimization,omitempty" json:"vmDeploymentOptimization,omitempty"` 3360 // Solution type-specific configuration. 3361 TypeSpecificConfig BaseSolutionsTypeSpecificSolutionConfig `xml:"typeSpecificConfig,typeattr" json:"typeSpecificConfig"` 3362 // Lifecycle hooks for the solution's virtual machines. 3363 Hooks []SolutionsHookConfig `xml:"hooks,omitempty" json:"hooks,omitempty"` 3364 // VMs resource configuration. 3365 // 3366 // If omitted - the default resource 3367 // configuration specified in the OVF descriptor is used. 3368 VmResourceSpec *SolutionsVmResourceSpec `xml:"vmResourceSpec,omitempty" json:"vmResourceSpec,omitempty"` 3369 } 3370 3371 func init() { 3372 types.Add("eam:SolutionsSolutionConfig", reflect.TypeOf((*SolutionsSolutionConfig)(nil)).Elem()) 3373 } 3374 3375 // Result of validation, of a solution, for application. 3376 // 3377 // This structure may be used only with operations rendered under `/eam`. 3378 type SolutionsSolutionValidationResult struct { 3379 types.DynamicData 3380 3381 // Validated solution. 3382 Solution string `xml:"solution" json:"solution"` 3383 // `True` - if the solution is valid for application, `False` 3384 // \- otherwise. 3385 Valid bool `xml:"valid" json:"valid"` 3386 // Populated with the reason the solution is not valid for application 3387 // `SolutionsInvalidReason_enum`. 3388 InvalidReason string `xml:"invalidReason,omitempty" json:"invalidReason,omitempty"` 3389 } 3390 3391 func init() { 3392 types.Add("eam:SolutionsSolutionValidationResult", reflect.TypeOf((*SolutionsSolutionValidationResult)(nil)).Elem()) 3393 } 3394 3395 // Storage policy to be applied during system Virtual Machine creation. 3396 // 3397 // This structure may be used only with operations rendered under `/eam`. 3398 type SolutionsStoragePolicy struct { 3399 types.DynamicData 3400 } 3401 3402 func init() { 3403 types.Add("eam:SolutionsStoragePolicy", reflect.TypeOf((*SolutionsStoragePolicy)(nil)).Elem()) 3404 } 3405 3406 // Specification necessary to transition a solution from an existing legacy 3407 // agency. 3408 // 3409 // This structure may be used only with operations rendered under `/eam`. 3410 type SolutionsTransitionSpec struct { 3411 types.DynamicData 3412 3413 // Solution to transition from an old legacy agency. 3414 Solution string `xml:"solution" json:"solution"` 3415 // Old legacy agency ID to transition from. 3416 AgencyId string `xml:"agencyId" json:"agencyId"` 3417 } 3418 3419 func init() { 3420 types.Add("eam:SolutionsTransitionSpec", reflect.TypeOf((*SolutionsTransitionSpec)(nil)).Elem()) 3421 } 3422 3423 // Specifies the specific solution configuration based on its type. 3424 // 3425 // This structure may be used only with operations rendered under `/eam`. 3426 type SolutionsTypeSpecificSolutionConfig struct { 3427 types.DynamicData 3428 } 3429 3430 func init() { 3431 types.Add("eam:SolutionsTypeSpecificSolutionConfig", reflect.TypeOf((*SolutionsTypeSpecificSolutionConfig)(nil)).Elem()) 3432 } 3433 3434 // Specified the system Virtual Machine sources are to be obtained from an 3435 // URL. 3436 // 3437 // This structure may be used only with operations rendered under `/eam`. 3438 type SolutionsUrlVMSource struct { 3439 SolutionsVMSource 3440 3441 // URL to the solution's system Virtual Machine OVF. 3442 OvfUrl string `xml:"ovfUrl" json:"ovfUrl"` 3443 // Overrides the OVF URL certificate validation. 3444 // 3445 // If `True` or 3446 // `<unset>` - the certificate will be subject to standard trust 3447 // validation, if `False` - any certificate will be considered 3448 // trusted. 3449 CertificateValidation *bool `xml:"certificateValidation" json:"certificateValidation,omitempty"` 3450 // PEM encoded certificate to use to trust the URL. 3451 // 3452 // If omitted - URL will 3453 // be trusted using well known methods. 3454 CertificatePEM string `xml:"certificatePEM,omitempty" json:"certificatePEM,omitempty"` 3455 } 3456 3457 func init() { 3458 types.Add("eam:SolutionsUrlVMSource", reflect.TypeOf((*SolutionsUrlVMSource)(nil)).Elem()) 3459 } 3460 3461 // Represents the mapping of the logical network defined in the OVF 3462 // descriptor to the Virtual Infrastructure (VI) network. 3463 // 3464 // This structure may be used only with operations rendered under `/eam`. 3465 type SolutionsVMNetworkMapping struct { 3466 types.DynamicData 3467 3468 // Logical network name defined in the OVF descriptor. 3469 Name string `xml:"name" json:"name"` 3470 // VM network identifier. 3471 // 3472 // Refers instance of `Network`. 3473 Id types.ManagedObjectReference `xml:"id" json:"id"` 3474 } 3475 3476 func init() { 3477 types.Add("eam:SolutionsVMNetworkMapping", reflect.TypeOf((*SolutionsVMNetworkMapping)(nil)).Elem()) 3478 } 3479 3480 // Specifies how to find the files of the system Virtual Machine to be 3481 // created. 3482 // 3483 // This structure may be used only with operations rendered under `/eam`. 3484 type SolutionsVMSource struct { 3485 types.DynamicData 3486 } 3487 3488 func init() { 3489 types.Add("eam:SolutionsVMSource", reflect.TypeOf((*SolutionsVMSource)(nil)).Elem()) 3490 } 3491 3492 // Specification describing a desired state to be validated for application. 3493 // 3494 // This structure may be used only with operations rendered under `/eam`. 3495 type SolutionsValidateSpec struct { 3496 types.DynamicData 3497 3498 // Desired state to be validated. 3499 DesiredState []SolutionsSolutionConfig `xml:"desiredState" json:"desiredState"` 3500 } 3501 3502 func init() { 3503 types.Add("eam:SolutionsValidateSpec", reflect.TypeOf((*SolutionsValidateSpec)(nil)).Elem()) 3504 } 3505 3506 // Result of validation, of a desired state, for application. 3507 // 3508 // This structure may be used only with operations rendered under `/eam`. 3509 type SolutionsValidationResult struct { 3510 types.DynamicData 3511 3512 // `True` - if the desired state is valid for application, 3513 // `False` - otherwise. 3514 Valid bool `xml:"valid" json:"valid"` 3515 // Detailed per-solution result of the validation. 3516 SolutionResult []SolutionsSolutionValidationResult `xml:"solutionResult,omitempty" json:"solutionResult,omitempty"` 3517 } 3518 3519 func init() { 3520 types.Add("eam:SolutionsValidationResult", reflect.TypeOf((*SolutionsValidationResult)(nil)).Elem()) 3521 } 3522 3523 // Specifies the VM resource configurations. 3524 // 3525 // This structure may be used only with operations rendered under `/eam`. 3526 type SolutionsVmResourceSpec struct { 3527 types.DynamicData 3528 3529 // The VM deployment option that corresponds to the Configuration element 3530 // of the DeploymentOptionSection in the OVF descriptor (e.g. 3531 // 3532 // "small", 3533 // "medium", "large"). 3534 // If omitted - the default deployment option as specified in the OVF 3535 // descriptor is used. 3536 OvfDeploymentOption string `xml:"ovfDeploymentOption,omitempty" json:"ovfDeploymentOption,omitempty"` 3537 } 3538 3539 func init() { 3540 types.Add("eam:SolutionsVmResourceSpec", reflect.TypeOf((*SolutionsVmResourceSpec)(nil)).Elem()) 3541 } 3542 3543 type Uninstall UninstallRequestType 3544 3545 func init() { 3546 types.Add("eam:Uninstall", reflect.TypeOf((*Uninstall)(nil)).Elem()) 3547 } 3548 3549 type UninstallRequestType struct { 3550 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3551 } 3552 3553 func init() { 3554 types.Add("eam:UninstallRequestType", reflect.TypeOf((*UninstallRequestType)(nil)).Elem()) 3555 } 3556 3557 type UninstallResponse struct { 3558 } 3559 3560 // Deprecated presence of unknown VMs is no more acceptable. 3561 // 3562 // An agent virtual machine has been found in the vCenter inventory that does 3563 // not belong to any agency in this vSphere ESX Agent Manager server instance. 3564 // 3565 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 3566 // powers off (if powered on) and deletes the agent virtual machine. 3567 // 3568 // This structure may be used only with operations rendered under `/eam`. 3569 type UnknownAgentVm struct { 3570 HostIssue 3571 3572 // The unknown agent virtual machine. 3573 // 3574 // Refers instance of `VirtualMachine`. 3575 Vm types.ManagedObjectReference `xml:"vm" json:"vm"` 3576 } 3577 3578 func init() { 3579 types.Add("eam:UnknownAgentVm", reflect.TypeOf((*UnknownAgentVm)(nil)).Elem()) 3580 } 3581 3582 type UnregisterAgentVm UnregisterAgentVmRequestType 3583 3584 func init() { 3585 types.Add("eam:UnregisterAgentVm", reflect.TypeOf((*UnregisterAgentVm)(nil)).Elem()) 3586 } 3587 3588 // The parameters of `Agency.UnregisterAgentVm`. 3589 // 3590 // This structure may be used only with operations rendered under `/eam`. 3591 type UnregisterAgentVmRequestType struct { 3592 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3593 // The managed object reference to the agent VM. 3594 // 3595 // Refers instance of `VirtualMachine`. 3596 AgentVm types.ManagedObjectReference `xml:"agentVm" json:"agentVm"` 3597 } 3598 3599 func init() { 3600 types.Add("eam:UnregisterAgentVmRequestType", reflect.TypeOf((*UnregisterAgentVmRequestType)(nil)).Elem()) 3601 } 3602 3603 type UnregisterAgentVmResponse struct { 3604 } 3605 3606 type Update UpdateRequestType 3607 3608 func init() { 3609 types.Add("eam:Update", reflect.TypeOf((*Update)(nil)).Elem()) 3610 } 3611 3612 // The parameters of `Agency.Update`. 3613 // 3614 // This structure may be used only with operations rendered under `/eam`. 3615 type UpdateRequestType struct { 3616 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3617 // The new configuration for this <code>Agency</code> 3618 Config BaseAgencyConfigInfo `xml:"config,typeattr" json:"config"` 3619 } 3620 3621 func init() { 3622 types.Add("eam:UpdateRequestType", reflect.TypeOf((*UpdateRequestType)(nil)).Elem()) 3623 } 3624 3625 type UpdateResponse struct { 3626 } 3627 3628 // A VIB module requires the host to be in maintenance mode, but the vSphere ESX Agent Manager 3629 // is unable toput the host in maintenance mode. 3630 // 3631 // This can happen if there are virtual machines running on the host that cannot 3632 // be moved and must be stopped before the host can enter maintenance mode. 3633 // 3634 // This is an active remediable issue. To remediate, the vSphere ESX Agent Manager will try again 3635 // to put the host into maintenance mode. However, the vSphere ESX Agent Manager will not power 3636 // off or move any virtual machines to put the host into maintenance mode. This must be 3637 // done by the client. 3638 // 3639 // This structure may be used only with operations rendered under `/eam`. 3640 type VibCannotPutHostInMaintenanceMode struct { 3641 VibIssue 3642 } 3643 3644 func init() { 3645 types.Add("eam:VibCannotPutHostInMaintenanceMode", reflect.TypeOf((*VibCannotPutHostInMaintenanceMode)(nil)).Elem()) 3646 } 3647 3648 // ESXi host is in Maintenance Mode. 3649 // 3650 // This prevents powering on and 3651 // re-configuring Agent Virtual Machines. Also if the host's entering in 3652 // Maintenance Mode was initiated by vSphere Esx Agent Manager, the same is 3653 // responsible to initiate exit Maintenance Mode. 3654 // 3655 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 3656 // puts the host out of Maintenance Mode. 3657 // 3658 // This structure may be used only with operations rendered under `/eam`. 3659 type VibCannotPutHostOutOfMaintenanceMode struct { 3660 VibIssue 3661 } 3662 3663 func init() { 3664 types.Add("eam:VibCannotPutHostOutOfMaintenanceMode", reflect.TypeOf((*VibCannotPutHostOutOfMaintenanceMode)(nil)).Elem()) 3665 } 3666 3667 // A VIB module is expected to be installed on a host, but the dependencies, 3668 // describred within the module, were not satisfied by the host. 3669 // 3670 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 3671 // attempts the VIB installation again. 3672 // 3673 // This structure may be used only with operations rendered under `/eam`. 3674 type VibDependenciesNotMetByHost struct { 3675 VibNotInstalled 3676 } 3677 3678 func init() { 3679 types.Add("eam:VibDependenciesNotMetByHost", reflect.TypeOf((*VibDependenciesNotMetByHost)(nil)).Elem()) 3680 } 3681 3682 // A VIB module is expected to be installed on a host, but it failed to install 3683 // since the VIB package is in an invalid format. 3684 // 3685 // The installation is unlikely to 3686 // succeed until the solution provding the bundle has been upgraded or patched to 3687 // provide a valid VIB package. 3688 // 3689 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager attempts the VIB installation again. 3690 // 3691 // This structure may be used only with operations rendered under `/eam`. 3692 type VibInvalidFormat struct { 3693 VibNotInstalled 3694 } 3695 3696 func init() { 3697 types.Add("eam:VibInvalidFormat", reflect.TypeOf((*VibInvalidFormat)(nil)).Elem()) 3698 } 3699 3700 // Base class for all issues related to the VIB modules that belong to an agent. 3701 // 3702 // This structure may be used only with operations rendered under `/eam`. 3703 type VibIssue struct { 3704 AgentIssue 3705 } 3706 3707 func init() { 3708 types.Add("eam:VibIssue", reflect.TypeOf((*VibIssue)(nil)).Elem()) 3709 } 3710 3711 // A VIB module is expected to be installed/removed on a host, but it has not 3712 // been installed/removed. 3713 // 3714 // Typically, a more specific issue (a subclass of this 3715 // issue) indicates the particular reason why the VIB module operation failed. 3716 // 3717 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 3718 // attempts the VIB operation again. 3719 // In case of unreachable host vSphere ESX Agent Manager will remediate the 3720 // issue automatically when the host becomes reachable. 3721 // 3722 // This structure may be used only with operations rendered under `/eam`. 3723 type VibNotInstalled struct { 3724 VibIssue 3725 } 3726 3727 func init() { 3728 types.Add("eam:VibNotInstalled", reflect.TypeOf((*VibNotInstalled)(nil)).Elem()) 3729 } 3730 3731 // A VIB module is expected to be installed on a host, but the system 3732 // requirements, describred within the module, were not satisfied by the host. 3733 // 3734 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 3735 // attempts the VIB installation again. 3736 // 3737 // This structure may be used only with operations rendered under `/eam`. 3738 type VibRequirementsNotMetByHost struct { 3739 VibNotInstalled 3740 } 3741 3742 func init() { 3743 types.Add("eam:VibRequirementsNotMetByHost", reflect.TypeOf((*VibRequirementsNotMetByHost)(nil)).Elem()) 3744 } 3745 3746 // A VIB module has been uploaded to the host, but will not be fully installed 3747 // until the host has been put in maintenance mode. 3748 // 3749 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host into maintenance 3750 // mode. 3751 // 3752 // This structure may be used only with operations rendered under `/eam`. 3753 type VibRequiresHostInMaintenanceMode struct { 3754 VibIssue 3755 } 3756 3757 func init() { 3758 types.Add("eam:VibRequiresHostInMaintenanceMode", reflect.TypeOf((*VibRequiresHostInMaintenanceMode)(nil)).Elem()) 3759 } 3760 3761 // A VIB module has been uploaded to the host, but will not be activated 3762 // until the host is rebooted. 3763 // 3764 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager puts the host into maintenance 3765 // mode and reboots it. 3766 // 3767 // This structure may be used only with operations rendered under `/eam`. 3768 type VibRequiresHostReboot struct { 3769 VibIssue 3770 } 3771 3772 func init() { 3773 types.Add("eam:VibRequiresHostReboot", reflect.TypeOf((*VibRequiresHostReboot)(nil)).Elem()) 3774 } 3775 3776 // A VIB module failed to install, but failed to do so because automatic installation 3777 // by vSphere ESX Agent Manager is not allowed on the host. 3778 // 3779 // This is a passive remediable issue. To remediate, go to VMware Update Manager 3780 // and install the required bulletins on the host or add the bulletins to the 3781 // host's image profile. 3782 // 3783 // This structure may be used only with operations rendered under `/eam`. 3784 type VibRequiresManualInstallation struct { 3785 VibIssue 3786 3787 // A non-empty array of bulletins required to be installed on the host. 3788 Bulletin []string `xml:"bulletin" json:"bulletin"` 3789 } 3790 3791 func init() { 3792 types.Add("eam:VibRequiresManualInstallation", reflect.TypeOf((*VibRequiresManualInstallation)(nil)).Elem()) 3793 } 3794 3795 // A VIB module failed to uninstall, but failed to do so because automatic uninstallation 3796 // by vSphere ESX Agent Manager is not allowed on the host. 3797 // 3798 // This is a passive remediable issue. To remediate, go to VMware Update Manager 3799 // and uninstall the required bulletins on the host or remove the bulletins from the 3800 // host's image profile. 3801 // 3802 // This structure may be used only with operations rendered under `/eam`. 3803 type VibRequiresManualUninstallation struct { 3804 VibIssue 3805 3806 // A non-empty array of bulletins required to be uninstalled on the host. 3807 Bulletin []string `xml:"bulletin" json:"bulletin"` 3808 } 3809 3810 func init() { 3811 types.Add("eam:VibRequiresManualUninstallation", reflect.TypeOf((*VibRequiresManualUninstallation)(nil)).Elem()) 3812 } 3813 3814 // A data entity providing information about a VIB. 3815 // 3816 // This abstraction contains only those of the VIB attributes which convey 3817 // important information for the client to identify, preview and select VIBs. 3818 // 3819 // This structure may be used only with operations rendered under `/eam`. 3820 type VibVibInfo struct { 3821 types.DynamicData 3822 3823 Id string `xml:"id" json:"id"` 3824 Name string `xml:"name" json:"name"` 3825 Version string `xml:"version" json:"version"` 3826 Vendor string `xml:"vendor" json:"vendor"` 3827 Summary string `xml:"summary" json:"summary"` 3828 SoftwareTags *VibVibInfoSoftwareTags `xml:"softwareTags,omitempty" json:"softwareTags,omitempty"` 3829 ReleaseDate time.Time `xml:"releaseDate" json:"releaseDate"` 3830 } 3831 3832 func init() { 3833 types.Add("eam:VibVibInfo", reflect.TypeOf((*VibVibInfo)(nil)).Elem()) 3834 } 3835 3836 // A data entity providing information about software tags of a VIB 3837 // 3838 // This structure may be used only with operations rendered under `/eam`. 3839 type VibVibInfoSoftwareTags struct { 3840 types.DynamicData 3841 3842 Tags []string `xml:"tags,omitempty" json:"tags,omitempty"` 3843 } 3844 3845 func init() { 3846 types.Add("eam:VibVibInfoSoftwareTags", reflect.TypeOf((*VibVibInfoSoftwareTags)(nil)).Elem()) 3847 } 3848 3849 // Specifies an SSL policy that trusts any SSL certificate. 3850 // 3851 // This structure may be used only with operations rendered under `/eam`. 3852 type VibVibServicesAnyCertificate struct { 3853 VibVibServicesSslTrust 3854 } 3855 3856 func init() { 3857 types.Add("eam:VibVibServicesAnyCertificate", reflect.TypeOf((*VibVibServicesAnyCertificate)(nil)).Elem()) 3858 types.AddMinAPIVersionForType("eam:VibVibServicesAnyCertificate", "8.2") 3859 } 3860 3861 // Specifies an SSL policy that trusts one specific pinned PEM encoded SSL 3862 // certificate. 3863 // 3864 // This structure may be used only with operations rendered under `/eam`. 3865 type VibVibServicesPinnedPemCertificate struct { 3866 VibVibServicesSslTrust 3867 3868 // PEM encoded pinned SSL certificate of the server that needs to be 3869 // trusted. 3870 SslCertificate string `xml:"sslCertificate" json:"sslCertificate"` 3871 } 3872 3873 func init() { 3874 types.Add("eam:VibVibServicesPinnedPemCertificate", reflect.TypeOf((*VibVibServicesPinnedPemCertificate)(nil)).Elem()) 3875 types.AddMinAPIVersionForType("eam:VibVibServicesPinnedPemCertificate", "8.2") 3876 } 3877 3878 // This structure may be used only with operations rendered under `/eam`. 3879 type VibVibServicesSslTrust struct { 3880 types.DynamicData 3881 } 3882 3883 func init() { 3884 types.Add("eam:VibVibServicesSslTrust", reflect.TypeOf((*VibVibServicesSslTrust)(nil)).Elem()) 3885 types.AddMinAPIVersionForType("eam:VibVibServicesSslTrust", "8.2") 3886 } 3887 3888 // An agent virtual machine is corrupted. 3889 // 3890 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager deletes and 3891 // reprovisions the agent virtual machine. To remediate manually, fix the missing file issue and power on the 3892 // agent virtual machine. 3893 // 3894 // This structure may be used only with operations rendered under `/eam`. 3895 type VmCorrupted struct { 3896 VmIssue 3897 3898 // An optional path for a missing file. 3899 MissingFile string `xml:"missingFile,omitempty" json:"missingFile,omitempty"` 3900 } 3901 3902 func init() { 3903 types.Add("eam:VmCorrupted", reflect.TypeOf((*VmCorrupted)(nil)).Elem()) 3904 } 3905 3906 // An agent virtual machine is expected to be removed from a host, but the agent virtual machine has not 3907 // been removed. 3908 // 3909 // Typically, a more specific issue (a subclass of this issue) 3910 // indicates the particular reason why vSphere ESX Agent Manager was unable to remove the 3911 // agent virtual machine, such as the host is in maintenance mode, powered off or in standby 3912 // mode. 3913 // 3914 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent. 3915 // 3916 // This structure may be used only with operations rendered under `/eam`. 3917 type VmDeployed struct { 3918 VmIssue 3919 } 3920 3921 func init() { 3922 types.Add("eam:VmDeployed", reflect.TypeOf((*VmDeployed)(nil)).Elem()) 3923 } 3924 3925 type VmHookFailed struct { 3926 VmIssue 3927 } 3928 3929 func init() { 3930 types.Add("eam:VmHookFailed", reflect.TypeOf((*VmHookFailed)(nil)).Elem()) 3931 } 3932 3933 type VmHookTimedout struct { 3934 VmIssue 3935 } 3936 3937 func init() { 3938 types.Add("eam:VmHookTimedout", reflect.TypeOf((*VmHookTimedout)(nil)).Elem()) 3939 } 3940 3941 type VmInaccessible struct { 3942 VmIssue 3943 } 3944 3945 func init() { 3946 types.Add("eam:VmInaccessible", reflect.TypeOf((*VmInaccessible)(nil)).Elem()) 3947 } 3948 3949 // Base class for all issues related to the deployed virtual machine for a 3950 // particular agent. 3951 // 3952 // This structure may be used only with operations rendered under `/eam`. 3953 type VmIssue struct { 3954 AgentIssue 3955 3956 // The virtual machine to which this issue is related. 3957 // 3958 // Refers instance of `VirtualMachine`. 3959 Vm types.ManagedObjectReference `xml:"vm" json:"vm"` 3960 } 3961 3962 func init() { 3963 types.Add("eam:VmIssue", reflect.TypeOf((*VmIssue)(nil)).Elem()) 3964 } 3965 3966 // Deprecated template agent VMs are not used anymore by VM deployment and 3967 // monitoring. 3968 // 3969 // An agent virtual machine is a virtual machine template. 3970 // 3971 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 3972 // converts the agent virtual machine template to a virtual machine. 3973 // 3974 // This structure may be used only with operations rendered under `/eam`. 3975 type VmMarkedAsTemplate struct { 3976 VmIssue 3977 } 3978 3979 func init() { 3980 types.Add("eam:VmMarkedAsTemplate", reflect.TypeOf((*VmMarkedAsTemplate)(nil)).Elem()) 3981 } 3982 3983 // An agent virtual machine is expected to be deployed on a host, but the agent virtual machine has not 3984 // been deployed. 3985 // 3986 // Typically, a more specific issue (a subclass of this issue) 3987 // indicates the particular reason why vSphere ESX Agent Manager was unable to deploy the 3988 // agent, such as being unable to access the OVF package for the agent or a missing host 3989 // configuration. This issue can also happen if the agent virtual machine is explicitly deleted 3990 // from the host. 3991 // 3992 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager redeploys the agent virtual machine. 3993 // 3994 // This structure may be used only with operations rendered under `/eam`. 3995 type VmNotDeployed struct { 3996 AgentIssue 3997 } 3998 3999 func init() { 4000 types.Add("eam:VmNotDeployed", reflect.TypeOf((*VmNotDeployed)(nil)).Elem()) 4001 } 4002 4003 // An agent virtual machine exists on a host, but the host is no longer part of scope for the 4004 // agency. 4005 // 4006 // This typically happens if a host is disconnected when the agency 4007 // configuration is changed. 4008 // 4009 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager deletes the agent virtual machine. 4010 // 4011 // This structure may be used only with operations rendered under `/eam`. 4012 type VmOrphaned struct { 4013 VmIssue 4014 } 4015 4016 func init() { 4017 types.Add("eam:VmOrphaned", reflect.TypeOf((*VmOrphaned)(nil)).Elem()) 4018 } 4019 4020 // An agent virtual machine is expected to be powered on, but the agent virtual machine is powered off. 4021 // 4022 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 4023 // powers on the agent virtual machine. 4024 // 4025 // This structure may be used only with operations rendered under `/eam`. 4026 type VmPoweredOff struct { 4027 VmIssue 4028 } 4029 4030 func init() { 4031 types.Add("eam:VmPoweredOff", reflect.TypeOf((*VmPoweredOff)(nil)).Elem()) 4032 } 4033 4034 // An agent virtual machine is expected to be powered off, but the agent virtual machine is powered on. 4035 // 4036 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 4037 // powers off the agent virtual machine. 4038 // 4039 // This structure may be used only with operations rendered under `/eam`. 4040 type VmPoweredOn struct { 4041 VmIssue 4042 } 4043 4044 func init() { 4045 types.Add("eam:VmPoweredOn", reflect.TypeOf((*VmPoweredOn)(nil)).Elem()) 4046 } 4047 4048 type VmProtected struct { 4049 VmIssue 4050 } 4051 4052 func init() { 4053 types.Add("eam:VmProtected", reflect.TypeOf((*VmProtected)(nil)).Elem()) 4054 } 4055 4056 // An agent virtual machine is expected to be deployed on a host, but the agent 4057 // virtual machine cannot be deployed because the host is in Maintenance Mode. 4058 // 4059 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 4060 // takes the host out of Maintenance Mode and deploys the agent virtual machine. 4061 // 4062 // Resolving this issue in vSphere Lifecyle Manager environemnt will be no-op. 4063 // In those cases user must take the host out of Maintenance Mode manually or 4064 // wait vSphere Lifecycle Maanger cluster remediation to complete (if any). 4065 // 4066 // This structure may be used only with operations rendered under `/eam`. 4067 type VmRequiresHostOutOfMaintenanceMode struct { 4068 VmNotDeployed 4069 } 4070 4071 func init() { 4072 types.Add("eam:VmRequiresHostOutOfMaintenanceMode", reflect.TypeOf((*VmRequiresHostOutOfMaintenanceMode)(nil)).Elem()) 4073 types.AddMinAPIVersionForType("eam:VmRequiresHostOutOfMaintenanceMode", "7.2") 4074 } 4075 4076 // An agent virtual machine is expected to be powered on, but the agent virtual machine is suspended. 4077 // 4078 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager powers on the agent virtual machine. 4079 // 4080 // This structure may be used only with operations rendered under `/eam`. 4081 type VmSuspended struct { 4082 VmIssue 4083 } 4084 4085 func init() { 4086 types.Add("eam:VmSuspended", reflect.TypeOf((*VmSuspended)(nil)).Elem()) 4087 } 4088 4089 // Deprecated eAM does not try to override any action powerfull user has taken. 4090 // 4091 // An agent virtual machine is expected to be located in a designated agent 4092 // virtual machine folder, but is found in a different folder. 4093 // 4094 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 4095 // moves the agent virtual machine back into the designated agent folder. 4096 // 4097 // This structure may be used only with operations rendered under `/eam`. 4098 type VmWrongFolder struct { 4099 VmIssue 4100 4101 // The folder in which the virtual machine currently resides. 4102 // 4103 // Refers instance of `Folder`. 4104 CurrentFolder types.ManagedObjectReference `xml:"currentFolder" json:"currentFolder"` 4105 // The ESX agent folder in which the virtual machine should reside. 4106 // 4107 // Refers instance of `Folder`. 4108 RequiredFolder types.ManagedObjectReference `xml:"requiredFolder" json:"requiredFolder"` 4109 } 4110 4111 func init() { 4112 types.Add("eam:VmWrongFolder", reflect.TypeOf((*VmWrongFolder)(nil)).Elem()) 4113 } 4114 4115 // Deprecated eAM does not try to override any action powerfull user has taken. 4116 // 4117 // An agent virtual machine is expected to be located in a designated agent 4118 // virtual machine resource pool, but is found in a different resource pool. 4119 // 4120 // This is an active remediable issue. To remediate, vSphere ESX Agent Manager 4121 // moves the agent virtual machine back into the designated agent resource pool. 4122 // 4123 // This structure may be used only with operations rendered under `/eam`. 4124 type VmWrongResourcePool struct { 4125 VmIssue 4126 4127 // The resource pool in which the VM currently resides. 4128 // 4129 // Refers instance of `ResourcePool`. 4130 CurrentResourcePool types.ManagedObjectReference `xml:"currentResourcePool" json:"currentResourcePool"` 4131 // The ESX agent resource pool in which the VM should reside. 4132 // 4133 // Refers instance of `ResourcePool`. 4134 RequiredResourcePool types.ManagedObjectReference `xml:"requiredResourcePool" json:"requiredResourcePool"` 4135 } 4136 4137 func init() { 4138 types.Add("eam:VmWrongResourcePool", reflect.TypeOf((*VmWrongResourcePool)(nil)).Elem()) 4139 } 4140 4141 type VersionURI string 4142 4143 func init() { 4144 types.Add("eam:versionURI", reflect.TypeOf((*VersionURI)(nil)).Elem()) 4145 }