github.com/vmware/govmomi@v0.43.0/sms/types/types.go (about) 1 /* 2 Copyright (c) 2014-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 // This spec contains information needed for queryActiveAlarm API to filter the result. 27 // 28 // This structure may be used only with operations rendered under `/sms`. 29 type AlarmFilter struct { 30 types.DynamicData 31 32 // The status of the alarm to search for. 33 // 34 // Should be one of 35 // `SmsAlarmStatus_enum`. If not specified, all status values 36 // should be considered. 37 AlarmStatus string `xml:"alarmStatus,omitempty" json:"alarmStatus,omitempty"` 38 // The status of the alarm to search for. 39 // 40 // Should be one of 41 // `AlarmType_enum`. If not specified, all alarm types 42 // should be considered. 43 AlarmType string `xml:"alarmType,omitempty" json:"alarmType,omitempty"` 44 // The entityType of interest, VASA provider should 45 // return all active alarms of this type when `AlarmFilter.entityId` 46 // is not set. 47 // 48 // See `SmsEntityType_enum`. 49 EntityType string `xml:"entityType,omitempty" json:"entityType,omitempty"` 50 // The identifiers of the entities of interest. 51 // 52 // If set, all entities must be 53 // of the same `SmsEntityType_enum` and it should be set in 54 // `AlarmFilter.entityType`. VASA provider can skip listing the missing entities. 55 EntityId []types.AnyType `xml:"entityId,omitempty,typeattr" json:"entityId,omitempty"` 56 // The page marker used for query pagination. 57 // 58 // This is an opaque string that 59 // will be set based on the value returned by the VASA provider - see 60 // `AlarmResult.pageMarker`. For initial request this should be set to 61 // null, indicating request for the first page. 62 PageMarker string `xml:"pageMarker,omitempty" json:"pageMarker,omitempty"` 63 } 64 65 func init() { 66 types.Add("sms:AlarmFilter", reflect.TypeOf((*AlarmFilter)(nil)).Elem()) 67 } 68 69 // Contains result for queryActiveAlarm API. 70 // 71 // This structure may be used only with operations rendered under `/sms`. 72 type AlarmResult struct { 73 types.DynamicData 74 75 // Resulting storage alarms. 76 StorageAlarm []StorageAlarm `xml:"storageAlarm,omitempty" json:"storageAlarm,omitempty"` 77 // The page marker used for query pagination. 78 // 79 // This is an opaque string that 80 // will be set by the VASA provider. The client will set the same value in 81 // `AlarmFilter.pageMarker` to query the next page. VP should unset 82 // this value to indicate the end of page. 83 PageMarker string `xml:"pageMarker,omitempty" json:"pageMarker,omitempty"` 84 } 85 86 func init() { 87 types.Add("sms:AlarmResult", reflect.TypeOf((*AlarmResult)(nil)).Elem()) 88 } 89 90 // Thrown if the object is already at the desired state. 91 // 92 // This is always a warning. 93 // 94 // This structure may be used only with operations rendered under `/sms`. 95 type AlreadyDone struct { 96 SmsReplicationFault 97 } 98 99 func init() { 100 types.Add("sms:AlreadyDone", reflect.TypeOf((*AlreadyDone)(nil)).Elem()) 101 } 102 103 type AlreadyDoneFault AlreadyDone 104 105 func init() { 106 types.Add("sms:AlreadyDoneFault", reflect.TypeOf((*AlreadyDoneFault)(nil)).Elem()) 107 } 108 109 // A boxed array of `BackingStoragePool`. To be used in `Any` placeholders. 110 // 111 // This structure may be used only with operations rendered under `/sms`. 112 type ArrayOfBackingStoragePool struct { 113 BackingStoragePool []BackingStoragePool `xml:"BackingStoragePool,omitempty" json:"_value"` 114 } 115 116 func init() { 117 types.Add("sms:ArrayOfBackingStoragePool", reflect.TypeOf((*ArrayOfBackingStoragePool)(nil)).Elem()) 118 } 119 120 // A boxed array of `DatastoreBackingPoolMapping`. To be used in `Any` placeholders. 121 // 122 // This structure may be used only with operations rendered under `/sms`. 123 type ArrayOfDatastoreBackingPoolMapping struct { 124 DatastoreBackingPoolMapping []DatastoreBackingPoolMapping `xml:"DatastoreBackingPoolMapping,omitempty" json:"_value"` 125 } 126 127 func init() { 128 types.Add("sms:ArrayOfDatastoreBackingPoolMapping", reflect.TypeOf((*ArrayOfDatastoreBackingPoolMapping)(nil)).Elem()) 129 } 130 131 // A boxed array of `DatastorePair`. To be used in `Any` placeholders. 132 // 133 // This structure may be used only with operations rendered under `/sms`. 134 type ArrayOfDatastorePair struct { 135 DatastorePair []DatastorePair `xml:"DatastorePair,omitempty" json:"_value"` 136 } 137 138 func init() { 139 types.Add("sms:ArrayOfDatastorePair", reflect.TypeOf((*ArrayOfDatastorePair)(nil)).Elem()) 140 } 141 142 // A boxed array of `DeviceId`. To be used in `Any` placeholders. 143 // 144 // This structure may be used only with operations rendered under `/sms`. 145 type ArrayOfDeviceId struct { 146 DeviceId []BaseDeviceId `xml:"DeviceId,omitempty,typeattr" json:"_value"` 147 } 148 149 func init() { 150 types.Add("sms:ArrayOfDeviceId", reflect.TypeOf((*ArrayOfDeviceId)(nil)).Elem()) 151 } 152 153 // A boxed array of `FaultDomainProviderMapping`. To be used in `Any` placeholders. 154 // 155 // This structure may be used only with operations rendered under `/sms`. 156 type ArrayOfFaultDomainProviderMapping struct { 157 FaultDomainProviderMapping []FaultDomainProviderMapping `xml:"FaultDomainProviderMapping,omitempty" json:"_value"` 158 } 159 160 func init() { 161 types.Add("sms:ArrayOfFaultDomainProviderMapping", reflect.TypeOf((*ArrayOfFaultDomainProviderMapping)(nil)).Elem()) 162 } 163 164 // A boxed array of `GroupOperationResult`. To be used in `Any` placeholders. 165 // 166 // This structure may be used only with operations rendered under `/sms`. 167 type ArrayOfGroupOperationResult struct { 168 GroupOperationResult []BaseGroupOperationResult `xml:"GroupOperationResult,omitempty,typeattr" json:"_value"` 169 } 170 171 func init() { 172 types.Add("sms:ArrayOfGroupOperationResult", reflect.TypeOf((*ArrayOfGroupOperationResult)(nil)).Elem()) 173 } 174 175 // A boxed array of `NameValuePair`. To be used in `Any` placeholders. 176 // 177 // This structure may be used only with operations rendered under `/sms`. 178 type ArrayOfNameValuePair struct { 179 NameValuePair []NameValuePair `xml:"NameValuePair,omitempty" json:"_value"` 180 } 181 182 func init() { 183 types.Add("sms:ArrayOfNameValuePair", reflect.TypeOf((*ArrayOfNameValuePair)(nil)).Elem()) 184 } 185 186 // A boxed array of `PointInTimeReplicaInfo`. To be used in `Any` placeholders. 187 // 188 // This structure may be used only with operations rendered under `/sms`. 189 type ArrayOfPointInTimeReplicaInfo struct { 190 PointInTimeReplicaInfo []PointInTimeReplicaInfo `xml:"PointInTimeReplicaInfo,omitempty" json:"_value"` 191 } 192 193 func init() { 194 types.Add("sms:ArrayOfPointInTimeReplicaInfo", reflect.TypeOf((*ArrayOfPointInTimeReplicaInfo)(nil)).Elem()) 195 } 196 197 // A boxed array of `PolicyAssociation`. To be used in `Any` placeholders. 198 // 199 // This structure may be used only with operations rendered under `/sms`. 200 type ArrayOfPolicyAssociation struct { 201 PolicyAssociation []PolicyAssociation `xml:"PolicyAssociation,omitempty" json:"_value"` 202 } 203 204 func init() { 205 types.Add("sms:ArrayOfPolicyAssociation", reflect.TypeOf((*ArrayOfPolicyAssociation)(nil)).Elem()) 206 } 207 208 // A boxed array of `QueryReplicationPeerResult`. To be used in `Any` placeholders. 209 // 210 // This structure may be used only with operations rendered under `/sms`. 211 type ArrayOfQueryReplicationPeerResult struct { 212 QueryReplicationPeerResult []QueryReplicationPeerResult `xml:"QueryReplicationPeerResult,omitempty" json:"_value"` 213 } 214 215 func init() { 216 types.Add("sms:ArrayOfQueryReplicationPeerResult", reflect.TypeOf((*ArrayOfQueryReplicationPeerResult)(nil)).Elem()) 217 } 218 219 // A boxed array of `RecoveredDevice`. To be used in `Any` placeholders. 220 // 221 // This structure may be used only with operations rendered under `/sms`. 222 type ArrayOfRecoveredDevice struct { 223 RecoveredDevice []RecoveredDevice `xml:"RecoveredDevice,omitempty" json:"_value"` 224 } 225 226 func init() { 227 types.Add("sms:ArrayOfRecoveredDevice", reflect.TypeOf((*ArrayOfRecoveredDevice)(nil)).Elem()) 228 } 229 230 // A boxed array of `RecoveredDiskInfo`. To be used in `Any` placeholders. 231 // 232 // This structure may be used only with operations rendered under `/sms`. 233 type ArrayOfRecoveredDiskInfo struct { 234 RecoveredDiskInfo []RecoveredDiskInfo `xml:"RecoveredDiskInfo,omitempty" json:"_value"` 235 } 236 237 func init() { 238 types.Add("sms:ArrayOfRecoveredDiskInfo", reflect.TypeOf((*ArrayOfRecoveredDiskInfo)(nil)).Elem()) 239 } 240 241 // A boxed array of `RelatedStorageArray`. To be used in `Any` placeholders. 242 // 243 // This structure may be used only with operations rendered under `/sms`. 244 type ArrayOfRelatedStorageArray struct { 245 RelatedStorageArray []RelatedStorageArray `xml:"RelatedStorageArray,omitempty" json:"_value"` 246 } 247 248 func init() { 249 types.Add("sms:ArrayOfRelatedStorageArray", reflect.TypeOf((*ArrayOfRelatedStorageArray)(nil)).Elem()) 250 } 251 252 // A boxed array of `ReplicaIntervalQueryResult`. To be used in `Any` placeholders. 253 // 254 // This structure may be used only with operations rendered under `/sms`. 255 type ArrayOfReplicaIntervalQueryResult struct { 256 ReplicaIntervalQueryResult []ReplicaIntervalQueryResult `xml:"ReplicaIntervalQueryResult,omitempty" json:"_value"` 257 } 258 259 func init() { 260 types.Add("sms:ArrayOfReplicaIntervalQueryResult", reflect.TypeOf((*ArrayOfReplicaIntervalQueryResult)(nil)).Elem()) 261 } 262 263 // A boxed array of `ReplicationGroupData`. To be used in `Any` placeholders. 264 // 265 // This structure may be used only with operations rendered under `/sms`. 266 type ArrayOfReplicationGroupData struct { 267 ReplicationGroupData []ReplicationGroupData `xml:"ReplicationGroupData,omitempty" json:"_value"` 268 } 269 270 func init() { 271 types.Add("sms:ArrayOfReplicationGroupData", reflect.TypeOf((*ArrayOfReplicationGroupData)(nil)).Elem()) 272 } 273 274 // A boxed array of `ReplicationTargetInfo`. To be used in `Any` placeholders. 275 // 276 // This structure may be used only with operations rendered under `/sms`. 277 type ArrayOfReplicationTargetInfo struct { 278 ReplicationTargetInfo []ReplicationTargetInfo `xml:"ReplicationTargetInfo,omitempty" json:"_value"` 279 } 280 281 func init() { 282 types.Add("sms:ArrayOfReplicationTargetInfo", reflect.TypeOf((*ArrayOfReplicationTargetInfo)(nil)).Elem()) 283 } 284 285 // A boxed array of `SmsProviderInfo`. To be used in `Any` placeholders. 286 // 287 // This structure may be used only with operations rendered under `/sms`. 288 type ArrayOfSmsProviderInfo struct { 289 SmsProviderInfo []BaseSmsProviderInfo `xml:"SmsProviderInfo,omitempty,typeattr" json:"_value"` 290 } 291 292 func init() { 293 types.Add("sms:ArrayOfSmsProviderInfo", reflect.TypeOf((*ArrayOfSmsProviderInfo)(nil)).Elem()) 294 } 295 296 // A boxed array of `SourceGroupMemberInfo`. To be used in `Any` placeholders. 297 // 298 // This structure may be used only with operations rendered under `/sms`. 299 type ArrayOfSourceGroupMemberInfo struct { 300 SourceGroupMemberInfo []SourceGroupMemberInfo `xml:"SourceGroupMemberInfo,omitempty" json:"_value"` 301 } 302 303 func init() { 304 types.Add("sms:ArrayOfSourceGroupMemberInfo", reflect.TypeOf((*ArrayOfSourceGroupMemberInfo)(nil)).Elem()) 305 } 306 307 // A boxed array of `StorageAlarm`. To be used in `Any` placeholders. 308 // 309 // This structure may be used only with operations rendered under `/sms`. 310 type ArrayOfStorageAlarm struct { 311 StorageAlarm []StorageAlarm `xml:"StorageAlarm,omitempty" json:"_value"` 312 } 313 314 func init() { 315 types.Add("sms:ArrayOfStorageAlarm", reflect.TypeOf((*ArrayOfStorageAlarm)(nil)).Elem()) 316 } 317 318 // A boxed array of `StorageArray`. To be used in `Any` placeholders. 319 // 320 // This structure may be used only with operations rendered under `/sms`. 321 type ArrayOfStorageArray struct { 322 StorageArray []StorageArray `xml:"StorageArray,omitempty" json:"_value"` 323 } 324 325 func init() { 326 types.Add("sms:ArrayOfStorageArray", reflect.TypeOf((*ArrayOfStorageArray)(nil)).Elem()) 327 } 328 329 // A boxed array of `StorageContainer`. To be used in `Any` placeholders. 330 // 331 // This structure may be used only with operations rendered under `/sms`. 332 type ArrayOfStorageContainer struct { 333 StorageContainer []StorageContainer `xml:"StorageContainer,omitempty" json:"_value"` 334 } 335 336 func init() { 337 types.Add("sms:ArrayOfStorageContainer", reflect.TypeOf((*ArrayOfStorageContainer)(nil)).Elem()) 338 } 339 340 // A boxed array of `StorageFileSystem`. To be used in `Any` placeholders. 341 // 342 // This structure may be used only with operations rendered under `/sms`. 343 type ArrayOfStorageFileSystem struct { 344 StorageFileSystem []StorageFileSystem `xml:"StorageFileSystem,omitempty" json:"_value"` 345 } 346 347 func init() { 348 types.Add("sms:ArrayOfStorageFileSystem", reflect.TypeOf((*ArrayOfStorageFileSystem)(nil)).Elem()) 349 } 350 351 // A boxed array of `StorageFileSystemInfo`. To be used in `Any` placeholders. 352 // 353 // This structure may be used only with operations rendered under `/sms`. 354 type ArrayOfStorageFileSystemInfo struct { 355 StorageFileSystemInfo []StorageFileSystemInfo `xml:"StorageFileSystemInfo,omitempty" json:"_value"` 356 } 357 358 func init() { 359 types.Add("sms:ArrayOfStorageFileSystemInfo", reflect.TypeOf((*ArrayOfStorageFileSystemInfo)(nil)).Elem()) 360 } 361 362 // A boxed array of `StorageLun`. To be used in `Any` placeholders. 363 // 364 // This structure may be used only with operations rendered under `/sms`. 365 type ArrayOfStorageLun struct { 366 StorageLun []StorageLun `xml:"StorageLun,omitempty" json:"_value"` 367 } 368 369 func init() { 370 types.Add("sms:ArrayOfStorageLun", reflect.TypeOf((*ArrayOfStorageLun)(nil)).Elem()) 371 } 372 373 // A boxed array of `StoragePort`. To be used in `Any` placeholders. 374 // 375 // This structure may be used only with operations rendered under `/sms`. 376 type ArrayOfStoragePort struct { 377 StoragePort []BaseStoragePort `xml:"StoragePort,omitempty,typeattr" json:"_value"` 378 } 379 380 func init() { 381 types.Add("sms:ArrayOfStoragePort", reflect.TypeOf((*ArrayOfStoragePort)(nil)).Elem()) 382 } 383 384 // A boxed array of `StorageProcessor`. To be used in `Any` placeholders. 385 // 386 // This structure may be used only with operations rendered under `/sms`. 387 type ArrayOfStorageProcessor struct { 388 StorageProcessor []StorageProcessor `xml:"StorageProcessor,omitempty" json:"_value"` 389 } 390 391 func init() { 392 types.Add("sms:ArrayOfStorageProcessor", reflect.TypeOf((*ArrayOfStorageProcessor)(nil)).Elem()) 393 } 394 395 // A boxed array of `SupportedVendorModelMapping`. To be used in `Any` placeholders. 396 // 397 // This structure may be used only with operations rendered under `/sms`. 398 type ArrayOfSupportedVendorModelMapping struct { 399 SupportedVendorModelMapping []SupportedVendorModelMapping `xml:"SupportedVendorModelMapping,omitempty" json:"_value"` 400 } 401 402 func init() { 403 types.Add("sms:ArrayOfSupportedVendorModelMapping", reflect.TypeOf((*ArrayOfSupportedVendorModelMapping)(nil)).Elem()) 404 } 405 406 // A boxed array of `TargetDeviceId`. To be used in `Any` placeholders. 407 // 408 // This structure may be used only with operations rendered under `/sms`. 409 type ArrayOfTargetDeviceId struct { 410 TargetDeviceId []TargetDeviceId `xml:"TargetDeviceId,omitempty" json:"_value"` 411 } 412 413 func init() { 414 types.Add("sms:ArrayOfTargetDeviceId", reflect.TypeOf((*ArrayOfTargetDeviceId)(nil)).Elem()) 415 } 416 417 // A boxed array of `TargetGroupMemberInfo`. To be used in `Any` placeholders. 418 // 419 // This structure may be used only with operations rendered under `/sms`. 420 type ArrayOfTargetGroupMemberInfo struct { 421 TargetGroupMemberInfo []BaseTargetGroupMemberInfo `xml:"TargetGroupMemberInfo,omitempty,typeattr" json:"_value"` 422 } 423 424 func init() { 425 types.Add("sms:ArrayOfTargetGroupMemberInfo", reflect.TypeOf((*ArrayOfTargetGroupMemberInfo)(nil)).Elem()) 426 } 427 428 // This exception is thrown when an error occurs while 429 // connecting to the vpxd service to validate the user 430 // credentials 431 // 432 // This structure may be used only with operations rendered under `/sms`. 433 type AuthConnectionFailed struct { 434 types.NoPermission 435 } 436 437 func init() { 438 types.Add("sms:AuthConnectionFailed", reflect.TypeOf((*AuthConnectionFailed)(nil)).Elem()) 439 } 440 441 type AuthConnectionFailedFault AuthConnectionFailed 442 443 func init() { 444 types.Add("sms:AuthConnectionFailedFault", reflect.TypeOf((*AuthConnectionFailedFault)(nil)).Elem()) 445 } 446 447 // This data object represents SDRS related data associated with block device or file system. 448 // 449 // This structure may be used only with operations rendered under `/sms`. 450 type BackingConfig struct { 451 types.DynamicData 452 453 // Identifier for the backing pool for thin provisioning 454 ThinProvisionBackingIdentifier string `xml:"thinProvisionBackingIdentifier,omitempty" json:"thinProvisionBackingIdentifier,omitempty"` 455 // Identifier for the backing pool for deduplication 456 DeduplicationBackingIdentifier string `xml:"deduplicationBackingIdentifier,omitempty" json:"deduplicationBackingIdentifier,omitempty"` 457 // Flag to indicate whether auto-tiering optimizations are active 458 AutoTieringEnabled *bool `xml:"autoTieringEnabled" json:"autoTieringEnabled,omitempty"` 459 // Aggregate indication of space savings efficiency in the shared 460 // deduplication pool. 461 // 462 // The value is between 0 and 100, higher values 463 // indicating better efficiency. 464 DeduplicationEfficiency int64 `xml:"deduplicationEfficiency,omitempty" json:"deduplicationEfficiency,omitempty"` 465 // Frequency in seconds at which interval auto-tiering optimizations 466 // are applied. 467 // 468 // A value of 0 indicates continuous optimization. 469 PerformanceOptimizationInterval int64 `xml:"performanceOptimizationInterval,omitempty" json:"performanceOptimizationInterval,omitempty"` 470 } 471 472 func init() { 473 types.Add("sms:BackingConfig", reflect.TypeOf((*BackingConfig)(nil)).Elem()) 474 } 475 476 // This data object represents the backing storage pool information of block device or file system. 477 // 478 // This structure may be used only with operations rendered under `/sms`. 479 type BackingStoragePool struct { 480 types.DynamicData 481 482 // Unique identifier 483 Uuid string `xml:"uuid" json:"uuid"` 484 Type string `xml:"type" json:"type"` 485 // Upper bound of the available capacity in the backing storage pool. 486 CapacityInMB int64 `xml:"capacityInMB" json:"capacityInMB"` 487 // Aggregate used space in the backing storage pool. 488 UsedSpaceInMB int64 `xml:"usedSpaceInMB" json:"usedSpaceInMB"` 489 } 490 491 func init() { 492 types.Add("sms:BackingStoragePool", reflect.TypeOf((*BackingStoragePool)(nil)).Elem()) 493 } 494 495 // This exception is thrown if there is a problem with calls to the 496 // CertificateAuthority. 497 // 498 // This structure may be used only with operations rendered under `/sms`. 499 type CertificateAuthorityFault struct { 500 ProviderRegistrationFault 501 502 // Fault code returned by certificate authority. 503 FaultCode int32 `xml:"faultCode" json:"faultCode"` 504 } 505 506 func init() { 507 types.Add("sms:CertificateAuthorityFault", reflect.TypeOf((*CertificateAuthorityFault)(nil)).Elem()) 508 } 509 510 type CertificateAuthorityFaultFault CertificateAuthorityFault 511 512 func init() { 513 types.Add("sms:CertificateAuthorityFaultFault", reflect.TypeOf((*CertificateAuthorityFaultFault)(nil)).Elem()) 514 } 515 516 // This exception is thrown if `VasaProviderInfo.retainVasaProviderCertificate` 517 // is true and the provider uses a certificate issued by a Certificate Authority, 518 // but the root certificate of the Certificate Authority is not imported to VECS truststore 519 // before attempting the provider registration. 520 // 521 // This structure may be used only with operations rendered under `/sms`. 522 type CertificateNotImported struct { 523 ProviderRegistrationFault 524 } 525 526 func init() { 527 types.Add("sms:CertificateNotImported", reflect.TypeOf((*CertificateNotImported)(nil)).Elem()) 528 } 529 530 type CertificateNotImportedFault CertificateNotImported 531 532 func init() { 533 types.Add("sms:CertificateNotImportedFault", reflect.TypeOf((*CertificateNotImportedFault)(nil)).Elem()) 534 } 535 536 // This exception is thrown if the certificate provided by the 537 // provider is not trusted. 538 // 539 // This structure may be used only with operations rendered under `/sms`. 540 type CertificateNotTrusted struct { 541 ProviderRegistrationFault 542 543 // Certificate 544 Certificate string `xml:"certificate" json:"certificate"` 545 } 546 547 func init() { 548 types.Add("sms:CertificateNotTrusted", reflect.TypeOf((*CertificateNotTrusted)(nil)).Elem()) 549 } 550 551 // An CertificateNotTrusted fault is thrown when an Agency's configuration 552 // contains OVF package URL or VIB URL for that vSphere ESX Agent Manager is not 553 // able to make successful SSL trust verification of the server's certificate. 554 // 555 // Reasons for this might be that the certificate provided via the API 556 // `AgentConfigInfo.ovfSslTrust` and `AgentConfigInfo.vibSslTrust` 557 // or via the script /usr/lib/vmware-eam/bin/eam-utility.py 558 // - is invalid. 559 // - does not match the server's certificate. 560 // 561 // If there is no provided certificate, the fault is thrown when the server's 562 // certificate is not trusted by the system or is invalid - @see 563 // `AgentConfigInfo.ovfSslTrust` and 564 // `AgentConfigInfo.vibSslTrust`. 565 // To enable Agency creation 1) provide a valid certificate used by the 566 // server hosting the `AgentConfigInfo.ovfPackageUrl` or 567 // `AgentConfigInfo.vibUrl` or 2) ensure the server's certificate is 568 // signed by a CA trusted by the system. Then retry the operation, vSphere 569 // ESX Agent Manager will retry the SSL trust verification and proceed with 570 // reaching the desired state. 571 // 572 // This structure may be used only with operations rendered under `/eam`. 573 // 574 // `**Since:**` vEAM API 8.2 575 type CertificateNotTrustedFault CertificateNotTrusted 576 577 func init() { 578 types.Add("sms:CertificateNotTrustedFault", reflect.TypeOf((*CertificateNotTrustedFault)(nil)).Elem()) 579 } 580 581 // This exception is thrown if SMS failed to 582 // refresh a CA signed certificate for the provider (or) 583 // push the latest CA root certificates and CRLs to the provider. 584 // 585 // This structure may be used only with operations rendered under `/sms`. 586 type CertificateRefreshFailed struct { 587 types.MethodFault 588 589 ProviderId []string `xml:"providerId,omitempty" json:"providerId,omitempty"` 590 } 591 592 func init() { 593 types.Add("sms:CertificateRefreshFailed", reflect.TypeOf((*CertificateRefreshFailed)(nil)).Elem()) 594 } 595 596 type CertificateRefreshFailedFault CertificateRefreshFailed 597 598 func init() { 599 types.Add("sms:CertificateRefreshFailedFault", reflect.TypeOf((*CertificateRefreshFailedFault)(nil)).Elem()) 600 } 601 602 // This exception is thrown if SMS failed to revoke CA signed certificate of the provider. 603 // 604 // This structure may be used only with operations rendered under `/sms`. 605 type CertificateRevocationFailed struct { 606 types.MethodFault 607 } 608 609 func init() { 610 types.Add("sms:CertificateRevocationFailed", reflect.TypeOf((*CertificateRevocationFailed)(nil)).Elem()) 611 } 612 613 type CertificateRevocationFailedFault CertificateRevocationFailed 614 615 func init() { 616 types.Add("sms:CertificateRevocationFailedFault", reflect.TypeOf((*CertificateRevocationFailedFault)(nil)).Elem()) 617 } 618 619 // This data object represents the result of queryDatastoreBackingPoolMapping API. 620 // 621 // More than one datastore can map to the same set of BackingStoragePool. 622 // 623 // This structure may be used only with operations rendered under `/sms`. 624 type DatastoreBackingPoolMapping struct { 625 types.DynamicData 626 627 // Refers instances of `Datastore`. 628 Datastore []types.ManagedObjectReference `xml:"datastore" json:"datastore"` 629 BackingStoragePool []BackingStoragePool `xml:"backingStoragePool,omitempty" json:"backingStoragePool,omitempty"` 630 } 631 632 func init() { 633 types.Add("sms:DatastoreBackingPoolMapping", reflect.TypeOf((*DatastoreBackingPoolMapping)(nil)).Elem()) 634 } 635 636 // Deprecated as of SMS API 5.0. 637 // 638 // Datastore pair that is returned as a result of queryDrsMigrationCapabilityForPerformanceEx API. 639 // 640 // This structure may be used only with operations rendered under `/sms`. 641 type DatastorePair struct { 642 types.DynamicData 643 644 // Refers instance of `Datastore`. 645 Datastore1 types.ManagedObjectReference `xml:"datastore1" json:"datastore1"` 646 // Refers instance of `Datastore`. 647 Datastore2 types.ManagedObjectReference `xml:"datastore2" json:"datastore2"` 648 } 649 650 func init() { 651 types.Add("sms:DatastorePair", reflect.TypeOf((*DatastorePair)(nil)).Elem()) 652 } 653 654 // Base class that represents a replicated device. 655 // 656 // This structure may be used only with operations rendered under `/sms`. 657 type DeviceId struct { 658 types.DynamicData 659 } 660 661 func init() { 662 types.Add("sms:DeviceId", reflect.TypeOf((*DeviceId)(nil)).Elem()) 663 } 664 665 // Deprecated as of SMS API 5.0. 666 // 667 // This data object represents the result of queryDrsMigrationCapabilityForPerformanceEx API. 668 // 669 // This structure may be used only with operations rendered under `/sms`. 670 type DrsMigrationCapabilityResult struct { 671 types.DynamicData 672 673 RecommendedDatastorePair []DatastorePair `xml:"recommendedDatastorePair,omitempty" json:"recommendedDatastorePair,omitempty"` 674 NonRecommendedDatastorePair []DatastorePair `xml:"nonRecommendedDatastorePair,omitempty" json:"nonRecommendedDatastorePair,omitempty"` 675 } 676 677 func init() { 678 types.Add("sms:DrsMigrationCapabilityResult", reflect.TypeOf((*DrsMigrationCapabilityResult)(nil)).Elem()) 679 } 680 681 // This exception indicates there are duplicate entries in the input argument. 682 // 683 // This structure may be used only with operations rendered under `/sms`. 684 type DuplicateEntry struct { 685 types.MethodFault 686 } 687 688 func init() { 689 types.Add("sms:DuplicateEntry", reflect.TypeOf((*DuplicateEntry)(nil)).Elem()) 690 } 691 692 type DuplicateEntryFault DuplicateEntry 693 694 func init() { 695 types.Add("sms:DuplicateEntryFault", reflect.TypeOf((*DuplicateEntryFault)(nil)).Elem()) 696 } 697 698 // Deprecated as of SMS API 4.0. 699 // 700 // Unique identifier of a given entity with the storage 701 // management service. 702 // 703 // It is similar to the VirtualCenter 704 // ManagedObjectReference but also identifies certain 705 // non-managed objects. 706 // 707 // This structure may be used only with operations rendered under `/sms`. 708 type EntityReference struct { 709 types.DynamicData 710 711 // Unique identifier for the entity of a given type in the 712 // system. 713 // 714 // A VirtualCenter managed object ID can be supplied 715 // here, in which case the type may be unset. Otherwise, the 716 // type must be set. 717 Id string `xml:"id" json:"id"` 718 // Type of the entity. 719 Type EntityReferenceEntityType `xml:"type,omitempty" json:"type,omitempty"` 720 } 721 722 func init() { 723 types.Add("sms:EntityReference", reflect.TypeOf((*EntityReference)(nil)).Elem()) 724 } 725 726 // Input to the failover or testFailover methods. 727 // 728 // This structure may be used only with operations rendered under `/sms`. 729 type FailoverParam struct { 730 types.DynamicData 731 732 // Whether the failover is a planned failover or not. 733 // 734 // Note that testFailover 735 // can also be executed in an unplanned mode. When this flag is 736 // set to false, the recovery VASA provider must not try to connect 737 // to the primary VASA provider during the failover. 738 IsPlanned bool `xml:"isPlanned" json:"isPlanned"` 739 // Do not execute the (test) failover but check if the configuration 740 // is correct to execute the (test) failover. 741 // 742 // If set to <code>true</code>, the (test)failover result is an array where 743 // each element is either `GroupOperationResult` or `GroupErrorResult`. 744 // 745 // If set to <code>false</code>, the (test)failover result is an array where 746 // each element is either `FailoverSuccessResult` or `GroupErrorResult`. 747 CheckOnly bool `xml:"checkOnly" json:"checkOnly"` 748 // The replication groups to failover. 749 // 750 // It is OK for the VASA 751 // provider to successfully failover only some groups. The 752 // groups that did not complete will be retried. 753 ReplicationGroupsToFailover []ReplicationGroupData `xml:"replicationGroupsToFailover,omitempty" json:"replicationGroupsToFailover,omitempty"` 754 // Storage policies for the devices after (test)failover. 755 // 756 // Failover should be done even if policies cannot be associated. 757 // Test failover, however, should fail if policies cannot be associated. 758 // 759 // If policies cannot be associated, VASA provider can notify the client by 760 // doing either or both of these: 761 // 1\. Set the warning in the result for a replication group to indicate 762 // such a failure to set the policy. 763 // 2\. Raise a compliance alarm after the failover is done. 764 // 765 // If not specified, the default policies are used. Callers may reassign 766 // policy later. 767 PolicyAssociations []PolicyAssociation `xml:"policyAssociations,omitempty" json:"policyAssociations,omitempty"` 768 } 769 770 func init() { 771 types.Add("sms:FailoverParam", reflect.TypeOf((*FailoverParam)(nil)).Elem()) 772 } 773 774 // The parameters of `VasaProvider.FailoverReplicationGroup_Task`. 775 // 776 // This structure may be used only with operations rendered under `/sms`. 777 type FailoverReplicationGroupRequestType struct { 778 This types.ManagedObjectReference `xml:"_this" json:"_this"` 779 // Settings for the failover. 780 FailoverParam BaseFailoverParam `xml:"failoverParam,typeattr" json:"failoverParam"` 781 } 782 783 func init() { 784 types.Add("sms:FailoverReplicationGroupRequestType", reflect.TypeOf((*FailoverReplicationGroupRequestType)(nil)).Elem()) 785 } 786 787 type FailoverReplicationGroup_Task FailoverReplicationGroupRequestType 788 789 func init() { 790 types.Add("sms:FailoverReplicationGroup_Task", reflect.TypeOf((*FailoverReplicationGroup_Task)(nil)).Elem()) 791 } 792 793 type FailoverReplicationGroup_TaskResponse struct { 794 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 795 } 796 797 // Results of a successful failover operation. 798 // 799 // The target fault domain Id, and the device group id are inherited. 800 // 801 // This structure may be used only with operations rendered under `/sms`. 802 type FailoverSuccessResult struct { 803 GroupOperationResult 804 805 // Some replicators may automatically reverse replication on failover. 806 // 807 // Such 808 // replicators must move the replication status to 809 // `SOURCE` 810 // In other cases, it can remain as `FAILEDOVER`. 811 NewState string `xml:"newState" json:"newState"` 812 // Id of the Point in Time snapshot used during failover. 813 // 814 // If not present, 815 // latest PIT was used. 816 PitId *PointInTimeReplicaId `xml:"pitId,omitempty" json:"pitId,omitempty"` 817 // Optional id of the Point in Time snapshot that was automatically created before 818 // failing over. 819 // 820 // This is recommended so users can revert back to this 821 // snapshot to avoid data loss. This can be removed after the reverse 822 // replication call succeeds. 823 PitIdBeforeFailover *PointInTimeReplicaId `xml:"pitIdBeforeFailover,omitempty" json:"pitIdBeforeFailover,omitempty"` 824 // Recovered Devices. 825 // 826 // This is optional because in some corner cases the 827 // replication groups on the target site may not have any virtual volumes. 828 RecoveredDeviceInfo []RecoveredDevice `xml:"recoveredDeviceInfo,omitempty" json:"recoveredDeviceInfo,omitempty"` 829 // Time stamp of recovery. 830 TimeStamp *time.Time `xml:"timeStamp" json:"timeStamp,omitempty"` 831 } 832 833 func init() { 834 types.Add("sms:FailoverSuccessResult", reflect.TypeOf((*FailoverSuccessResult)(nil)).Elem()) 835 } 836 837 // This spec contains information needed for `SmsStorageManager.QueryFaultDomain` 838 // API to filter the result. 839 // 840 // This structure may be used only with operations rendered under `/sms`. 841 type FaultDomainFilter struct { 842 types.DynamicData 843 844 // If specified, query for this specific provider only; else query for all 845 // providers. 846 ProviderId string `xml:"providerId,omitempty" json:"providerId,omitempty"` 847 } 848 849 func init() { 850 types.Add("sms:FaultDomainFilter", reflect.TypeOf((*FaultDomainFilter)(nil)).Elem()) 851 } 852 853 // Information about a Fault Domain. 854 // 855 // This structure may be used only with operations rendered under `/sms`. 856 type FaultDomainInfo struct { 857 types.FaultDomainId 858 859 // Name of the fault domain, if not specified, the id will be used in place 860 // of the name. 861 // 862 // Name need not be unique. 863 Name string `xml:"name,omitempty" json:"name,omitempty"` 864 // Description - could be a localized string. 865 Description string `xml:"description,omitempty" json:"description,omitempty"` 866 // Identifier of the Storage Array that this Fault Domain belongs to. 867 // 868 // A Fault 869 // Domain and all its children should report same `FaultDomainInfo.storageArrayId`. It 870 // can be left unspecified. If not specified, vSphere will not support High 871 // Availability feature for this Fault Domain. When specified, vSphere will 872 // treat the the currently active VASA provider for `StorageArray` as 873 // the active VASA provider for this Fault Domain and its children. 874 // Changing High Availability support choice for a Fault Domain 875 // intermittently, by sometimes specifying the storageArrayId and sometimes 876 // not, will cause unexpected result and might cause VP to be in 'syncError' 877 // state in vSphere. 878 StorageArrayId string `xml:"storageArrayId,omitempty" json:"storageArrayId,omitempty"` 879 // List of children, the entries in the array should always be 880 // `FaultDomainId` and not `FaultDomainInfo`. 881 // 882 // The 2016 vSphere release will not support nested Fault Domains. The field 883 // FaultDomainInfo#children is ignored by vSphere 2016 release. 884 Children []types.FaultDomainId `xml:"children,omitempty" json:"children,omitempty"` 885 // VASA provider that is actively managing this fault domain 886 // 887 // Refers instance of `SmsProvider`. 888 Provider *types.ManagedObjectReference `xml:"provider,omitempty" json:"provider,omitempty"` 889 } 890 891 func init() { 892 types.Add("sms:FaultDomainInfo", reflect.TypeOf((*FaultDomainInfo)(nil)).Elem()) 893 } 894 895 // This mapping will be set in InactiveProvider fault to notify clients 896 // the current active provider for the specified fault domains. 897 // 898 // This structure may be used only with operations rendered under `/sms`. 899 type FaultDomainProviderMapping struct { 900 types.DynamicData 901 902 // Active provider managing the fault domains 903 // 904 // Refers instance of `SmsProvider`. 905 ActiveProvider types.ManagedObjectReference `xml:"activeProvider" json:"activeProvider"` 906 // Fault domains being managed by the provider 907 FaultDomainId []types.FaultDomainId `xml:"faultDomainId,omitempty" json:"faultDomainId,omitempty"` 908 } 909 910 func init() { 911 types.Add("sms:FaultDomainProviderMapping", reflect.TypeOf((*FaultDomainProviderMapping)(nil)).Elem()) 912 } 913 914 // This data object represents the FC storage port. 915 // 916 // This structure may be used only with operations rendered under `/sms`. 917 type FcStoragePort struct { 918 StoragePort 919 920 // World Wide Name for the Port 921 PortWwn string `xml:"portWwn" json:"portWwn"` 922 // World Wide Name for the Node 923 NodeWwn string `xml:"nodeWwn" json:"nodeWwn"` 924 } 925 926 func init() { 927 types.Add("sms:FcStoragePort", reflect.TypeOf((*FcStoragePort)(nil)).Elem()) 928 } 929 930 // This data object represents the FCoE storage port. 931 // 932 // This structure may be used only with operations rendered under `/sms`. 933 type FcoeStoragePort struct { 934 StoragePort 935 936 // World Wide Name for the Port 937 PortWwn string `xml:"portWwn" json:"portWwn"` 938 // World Wide Name for the Node 939 NodeWwn string `xml:"nodeWwn" json:"nodeWwn"` 940 } 941 942 func init() { 943 types.Add("sms:FcoeStoragePort", reflect.TypeOf((*FcoeStoragePort)(nil)).Elem()) 944 } 945 946 // Error result. 947 // 948 // This structure may be used only with operations rendered under `/sms`. 949 type GroupErrorResult struct { 950 GroupOperationResult 951 952 // Error array, must contain at least one entry. 953 Error []types.LocalizedMethodFault `xml:"error" json:"error"` 954 } 955 956 func init() { 957 types.Add("sms:GroupErrorResult", reflect.TypeOf((*GroupErrorResult)(nil)).Elem()) 958 } 959 960 // Replication group information. 961 // 962 // May be either a `SourceGroupInfo` or 963 // `TargetGroupInfo`. 964 // 965 // This structure may be used only with operations rendered under `/sms`. 966 type GroupInfo struct { 967 types.DynamicData 968 969 // Identifier of the group + fault domain id. 970 GroupId types.ReplicationGroupId `xml:"groupId" json:"groupId"` 971 } 972 973 func init() { 974 types.Add("sms:GroupInfo", reflect.TypeOf((*GroupInfo)(nil)).Elem()) 975 } 976 977 // The base class for any operation on a replication group. 978 // 979 // Usually, there is an 980 // operation specific <Operation>SuccessResult 981 // 982 // This structure may be used only with operations rendered under `/sms`. 983 type GroupOperationResult struct { 984 types.DynamicData 985 986 // Replication group Id. 987 GroupId types.ReplicationGroupId `xml:"groupId" json:"groupId"` 988 Warning []types.LocalizedMethodFault `xml:"warning,omitempty" json:"warning,omitempty"` 989 } 990 991 func init() { 992 types.Add("sms:GroupOperationResult", reflect.TypeOf((*GroupOperationResult)(nil)).Elem()) 993 } 994 995 // Thrown if the VASA Provider on which the call is made is currently not 996 // active. 997 // 998 // If the client maintains a cache of the topology of fault domains 999 // and replication groups, it's expected to update the cache based on the 1000 // mapping information set in this fault. 1001 // 1002 // This structure may be used only with operations rendered under `/sms`. 1003 type InactiveProvider struct { 1004 types.MethodFault 1005 1006 // Mapping between VASA provider and the fault domains 1007 Mapping []FaultDomainProviderMapping `xml:"mapping,omitempty" json:"mapping,omitempty"` 1008 } 1009 1010 func init() { 1011 types.Add("sms:InactiveProvider", reflect.TypeOf((*InactiveProvider)(nil)).Elem()) 1012 } 1013 1014 type InactiveProviderFault InactiveProvider 1015 1016 func init() { 1017 types.Add("sms:InactiveProviderFault", reflect.TypeOf((*InactiveProviderFault)(nil)).Elem()) 1018 } 1019 1020 // This fault is thrown if failed to register provider due to incorrect credentials. 1021 // 1022 // This structure may be used only with operations rendered under `/sms`. 1023 type IncorrectUsernamePassword struct { 1024 ProviderRegistrationFault 1025 } 1026 1027 func init() { 1028 types.Add("sms:IncorrectUsernamePassword", reflect.TypeOf((*IncorrectUsernamePassword)(nil)).Elem()) 1029 } 1030 1031 type IncorrectUsernamePasswordFault IncorrectUsernamePassword 1032 1033 func init() { 1034 types.Add("sms:IncorrectUsernamePasswordFault", reflect.TypeOf((*IncorrectUsernamePasswordFault)(nil)).Elem()) 1035 } 1036 1037 // This exception is thrown if the provider certificate is empty, malformed, 1038 // expired, not yet valid, revoked or fails host name verification. 1039 // 1040 // This structure may be used only with operations rendered under `/sms`. 1041 type InvalidCertificate struct { 1042 ProviderRegistrationFault 1043 1044 // Provider certificate 1045 Certificate string `xml:"certificate" json:"certificate"` 1046 } 1047 1048 func init() { 1049 types.Add("sms:InvalidCertificate", reflect.TypeOf((*InvalidCertificate)(nil)).Elem()) 1050 } 1051 1052 type InvalidCertificateFault InvalidCertificate 1053 1054 func init() { 1055 types.Add("sms:InvalidCertificateFault", reflect.TypeOf((*InvalidCertificateFault)(nil)).Elem()) 1056 } 1057 1058 // Thrown if the function is called at the wrong end of the replication (i.e. 1059 // 1060 // the failing function should be tried at the opposite end of replication). 1061 // 1062 // This structure may be used only with operations rendered under `/sms`. 1063 type InvalidFunctionTarget struct { 1064 SmsReplicationFault 1065 } 1066 1067 func init() { 1068 types.Add("sms:InvalidFunctionTarget", reflect.TypeOf((*InvalidFunctionTarget)(nil)).Elem()) 1069 } 1070 1071 type InvalidFunctionTargetFault InvalidFunctionTarget 1072 1073 func init() { 1074 types.Add("sms:InvalidFunctionTargetFault", reflect.TypeOf((*InvalidFunctionTargetFault)(nil)).Elem()) 1075 } 1076 1077 // This exception is thrown if the specified storage profile is invalid. 1078 // 1079 // This structure may be used only with operations rendered under `/sms`. 1080 type InvalidProfile struct { 1081 types.MethodFault 1082 } 1083 1084 func init() { 1085 types.Add("sms:InvalidProfile", reflect.TypeOf((*InvalidProfile)(nil)).Elem()) 1086 } 1087 1088 type InvalidProfileFault InvalidProfile 1089 1090 func init() { 1091 types.Add("sms:InvalidProfileFault", reflect.TypeOf((*InvalidProfileFault)(nil)).Elem()) 1092 } 1093 1094 // Thrown if the replication group is not in the correct state. 1095 // 1096 // This structure may be used only with operations rendered under `/sms`. 1097 type InvalidReplicationState struct { 1098 SmsReplicationFault 1099 1100 // States where the operation would have been successful. 1101 DesiredState []string `xml:"desiredState,omitempty" json:"desiredState,omitempty"` 1102 // Current state. 1103 CurrentState string `xml:"currentState" json:"currentState"` 1104 } 1105 1106 func init() { 1107 types.Add("sms:InvalidReplicationState", reflect.TypeOf((*InvalidReplicationState)(nil)).Elem()) 1108 } 1109 1110 type InvalidReplicationStateFault InvalidReplicationState 1111 1112 func init() { 1113 types.Add("sms:InvalidReplicationStateFault", reflect.TypeOf((*InvalidReplicationStateFault)(nil)).Elem()) 1114 } 1115 1116 // This exception is thrown if a specified session is invalid. 1117 // 1118 // This can occur if the VirtualCenter session referred to by 1119 // the cookie has timed out or has been closed. 1120 // 1121 // This structure may be used only with operations rendered under `/sms`. 1122 type InvalidSession struct { 1123 types.NoPermission 1124 1125 // VirtualCenter session cookie that is invalid. 1126 SessionCookie string `xml:"sessionCookie" json:"sessionCookie"` 1127 } 1128 1129 func init() { 1130 types.Add("sms:InvalidSession", reflect.TypeOf((*InvalidSession)(nil)).Elem()) 1131 } 1132 1133 type InvalidSessionFault InvalidSession 1134 1135 func init() { 1136 types.Add("sms:InvalidSessionFault", reflect.TypeOf((*InvalidSessionFault)(nil)).Elem()) 1137 } 1138 1139 // This exception is thrown if `VasaProviderSpec.url` is malformed. 1140 // 1141 // This structure may be used only with operations rendered under `/sms`. 1142 type InvalidUrl struct { 1143 ProviderRegistrationFault 1144 1145 // Provider `VasaProviderSpec.url` 1146 Url string `xml:"url" json:"url"` 1147 } 1148 1149 func init() { 1150 types.Add("sms:InvalidUrl", reflect.TypeOf((*InvalidUrl)(nil)).Elem()) 1151 } 1152 1153 type InvalidUrlFault InvalidUrl 1154 1155 func init() { 1156 types.Add("sms:InvalidUrlFault", reflect.TypeOf((*InvalidUrlFault)(nil)).Elem()) 1157 } 1158 1159 // This data object represents the iSCSI storage port. 1160 // 1161 // This structure may be used only with operations rendered under `/sms`. 1162 type IscsiStoragePort struct { 1163 StoragePort 1164 1165 // IQN or EQI identifier 1166 Identifier string `xml:"identifier" json:"identifier"` 1167 } 1168 1169 func init() { 1170 types.Add("sms:IscsiStoragePort", reflect.TypeOf((*IscsiStoragePort)(nil)).Elem()) 1171 } 1172 1173 // This data object represents the lun, HBA association 1174 // for synchronous replication. 1175 // 1176 // This structure may be used only with operations rendered under `/sms`. 1177 type LunHbaAssociation struct { 1178 types.DynamicData 1179 1180 CanonicalName string `xml:"canonicalName" json:"canonicalName"` 1181 Hba []types.HostHostBusAdapter `xml:"hba" json:"hba"` 1182 } 1183 1184 func init() { 1185 types.Add("sms:LunHbaAssociation", reflect.TypeOf((*LunHbaAssociation)(nil)).Elem()) 1186 } 1187 1188 // This exception is thrown if more than one sort spec is 1189 // specified in a list query. 1190 // 1191 // This structure may be used only with operations rendered under `/sms`. 1192 type MultipleSortSpecsNotSupported struct { 1193 types.InvalidArgument 1194 } 1195 1196 func init() { 1197 types.Add("sms:MultipleSortSpecsNotSupported", reflect.TypeOf((*MultipleSortSpecsNotSupported)(nil)).Elem()) 1198 } 1199 1200 type MultipleSortSpecsNotSupportedFault MultipleSortSpecsNotSupported 1201 1202 func init() { 1203 types.Add("sms:MultipleSortSpecsNotSupportedFault", reflect.TypeOf((*MultipleSortSpecsNotSupportedFault)(nil)).Elem()) 1204 } 1205 1206 // This data object represents a name value pair. 1207 // 1208 // This structure may be used only with operations rendered under `/sms`. 1209 type NameValuePair struct { 1210 types.DynamicData 1211 1212 // Name of the paramter 1213 ParameterName string `xml:"parameterName" json:"parameterName"` 1214 // Value of the parameter 1215 ParameterValue string `xml:"parameterValue" json:"parameterValue"` 1216 } 1217 1218 func init() { 1219 types.Add("sms:NameValuePair", reflect.TypeOf((*NameValuePair)(nil)).Elem()) 1220 } 1221 1222 // This fault is thrown when backings (@link 1223 // sms.storage.StorageLun/ @link sms.storage.StorageFileSystem) 1224 // of the specified datastores refer to different 1225 // VASA providers. 1226 // 1227 // This structure may be used only with operations rendered under `/sms`. 1228 type NoCommonProviderForAllBackings struct { 1229 QueryExecutionFault 1230 } 1231 1232 func init() { 1233 types.Add("sms:NoCommonProviderForAllBackings", reflect.TypeOf((*NoCommonProviderForAllBackings)(nil)).Elem()) 1234 } 1235 1236 type NoCommonProviderForAllBackingsFault NoCommonProviderForAllBackings 1237 1238 func init() { 1239 types.Add("sms:NoCommonProviderForAllBackingsFault", reflect.TypeOf((*NoCommonProviderForAllBackingsFault)(nil)).Elem()) 1240 } 1241 1242 // This exception is set if the replication target is not yet available. 1243 // 1244 // This structure may be used only with operations rendered under `/sms`. 1245 type NoReplicationTarget struct { 1246 SmsReplicationFault 1247 } 1248 1249 func init() { 1250 types.Add("sms:NoReplicationTarget", reflect.TypeOf((*NoReplicationTarget)(nil)).Elem()) 1251 } 1252 1253 type NoReplicationTargetFault NoReplicationTarget 1254 1255 func init() { 1256 types.Add("sms:NoReplicationTargetFault", reflect.TypeOf((*NoReplicationTargetFault)(nil)).Elem()) 1257 } 1258 1259 // This exception is thrown when there is no valid replica 1260 // to be used in recovery. 1261 // 1262 // This may happen when a Virtual Volume 1263 // is created on the source domain, but the replica is yet to 1264 // be copied to the target. 1265 // 1266 // This structure may be used only with operations rendered under `/sms`. 1267 type NoValidReplica struct { 1268 SmsReplicationFault 1269 1270 // Identifier of the device which does not have a valid 1271 // replica. 1272 // 1273 // This is the identifier on the target site. 1274 // This may not be set if the ReplicationGroup does not 1275 // have even a single valid replica. 1276 DeviceId BaseDeviceId `xml:"deviceId,omitempty,typeattr" json:"deviceId,omitempty"` 1277 } 1278 1279 func init() { 1280 types.Add("sms:NoValidReplica", reflect.TypeOf((*NoValidReplica)(nil)).Elem()) 1281 } 1282 1283 type NoValidReplicaFault NoValidReplica 1284 1285 func init() { 1286 types.Add("sms:NoValidReplicaFault", reflect.TypeOf((*NoValidReplicaFault)(nil)).Elem()) 1287 } 1288 1289 // This exception is thrown if the VASA Provider on which the call is made 1290 // does not support this operation. 1291 // 1292 // This structure may be used only with operations rendered under `/sms`. 1293 type NotSupportedByProvider struct { 1294 types.MethodFault 1295 } 1296 1297 func init() { 1298 types.Add("sms:NotSupportedByProvider", reflect.TypeOf((*NotSupportedByProvider)(nil)).Elem()) 1299 } 1300 1301 type NotSupportedByProviderFault NotSupportedByProvider 1302 1303 func init() { 1304 types.Add("sms:NotSupportedByProviderFault", reflect.TypeOf((*NotSupportedByProviderFault)(nil)).Elem()) 1305 } 1306 1307 // This exception is set if the replication peer is not reachable. 1308 // 1309 // For prepareFailover, it is the target that is not reachable. 1310 // For other functions, it is the source that is not reachable. 1311 // 1312 // This structure may be used only with operations rendered under `/sms`. 1313 type PeerNotReachable struct { 1314 SmsReplicationFault 1315 } 1316 1317 func init() { 1318 types.Add("sms:PeerNotReachable", reflect.TypeOf((*PeerNotReachable)(nil)).Elem()) 1319 } 1320 1321 type PeerNotReachableFault PeerNotReachable 1322 1323 func init() { 1324 types.Add("sms:PeerNotReachableFault", reflect.TypeOf((*PeerNotReachableFault)(nil)).Elem()) 1325 } 1326 1327 // Identity of the Point in Time Replica object. 1328 // 1329 // This structure may be used only with operations rendered under `/sms`. 1330 type PointInTimeReplicaId struct { 1331 types.DynamicData 1332 1333 // ID of the Point In Time replica. 1334 Id string `xml:"id" json:"id"` 1335 } 1336 1337 func init() { 1338 types.Add("sms:PointInTimeReplicaId", reflect.TypeOf((*PointInTimeReplicaId)(nil)).Elem()) 1339 } 1340 1341 // This structure may be used only with operations rendered under `/sms`. 1342 type PointInTimeReplicaInfo struct { 1343 types.DynamicData 1344 1345 // Id of the PIT replica. 1346 // 1347 // Note that this id is always used 1348 // in combination with the `ReplicationGroupId`, hence must be 1349 // unique to the `ReplicationGroupId`. 1350 Id PointInTimeReplicaId `xml:"id" json:"id"` 1351 // Name of the PIT replica. 1352 // 1353 // This may be a localized string 1354 // in a language as chosen by the VASA provider. 1355 PitName string `xml:"pitName" json:"pitName"` 1356 // Time when the snapshot was taken. 1357 // 1358 // Time stamps are maintained by 1359 // the Replication provider, note that this carries time zone information 1360 // as well. 1361 TimeStamp time.Time `xml:"timeStamp" json:"timeStamp"` 1362 // VASA provider managed tags associated with the replica. 1363 Tags []string `xml:"tags,omitempty" json:"tags,omitempty"` 1364 } 1365 1366 func init() { 1367 types.Add("sms:PointInTimeReplicaInfo", reflect.TypeOf((*PointInTimeReplicaInfo)(nil)).Elem()) 1368 } 1369 1370 // Describes the policy association object. 1371 // 1372 // This structure may be used only with operations rendered under `/sms`. 1373 type PolicyAssociation struct { 1374 types.DynamicData 1375 1376 // The source device id. 1377 // 1378 // The corresponding recovered device 1379 // gets the specified <code>policyId</code>. 1380 Id BaseDeviceId `xml:"id,typeattr" json:"id"` 1381 // Policy id. 1382 PolicyId string `xml:"policyId" json:"policyId"` 1383 // Datastore object. 1384 // 1385 // Refers instance of `Datastore`. 1386 Datastore types.ManagedObjectReference `xml:"datastore" json:"datastore"` 1387 } 1388 1389 func init() { 1390 types.Add("sms:PolicyAssociation", reflect.TypeOf((*PolicyAssociation)(nil)).Elem()) 1391 } 1392 1393 // The parameters of `VasaProvider.PrepareFailoverReplicationGroup_Task`. 1394 // 1395 // This structure may be used only with operations rendered under `/sms`. 1396 type PrepareFailoverReplicationGroupRequestType struct { 1397 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1398 // List of replication group IDs. 1399 GroupId []types.ReplicationGroupId `xml:"groupId,omitempty" json:"groupId,omitempty"` 1400 } 1401 1402 func init() { 1403 types.Add("sms:PrepareFailoverReplicationGroupRequestType", reflect.TypeOf((*PrepareFailoverReplicationGroupRequestType)(nil)).Elem()) 1404 } 1405 1406 type PrepareFailoverReplicationGroup_Task PrepareFailoverReplicationGroupRequestType 1407 1408 func init() { 1409 types.Add("sms:PrepareFailoverReplicationGroup_Task", reflect.TypeOf((*PrepareFailoverReplicationGroup_Task)(nil)).Elem()) 1410 } 1411 1412 type PrepareFailoverReplicationGroup_TaskResponse struct { 1413 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 1414 } 1415 1416 // Input to the promoteReplicationGroup method. 1417 // 1418 // This structure may be used only with operations rendered under `/sms`. 1419 type PromoteParam struct { 1420 types.DynamicData 1421 1422 // Specifies whether the promote operation is a planned one. 1423 // 1424 // When this flag is set to false, the recovery VASA provider must not 1425 // try to connect to the primary VASA provider during promote. 1426 IsPlanned bool `xml:"isPlanned" json:"isPlanned"` 1427 // The replication groups to promote. 1428 // 1429 // It is legal for the VASA 1430 // provider to successfully promote only some groups. The 1431 // groups that did not succeed will be retried. 1432 // 1433 // The identifiers of the Virtual Volumes do not change after the 1434 // promote operation. 1435 ReplicationGroupsToPromote []types.ReplicationGroupId `xml:"replicationGroupsToPromote,omitempty" json:"replicationGroupsToPromote,omitempty"` 1436 } 1437 1438 func init() { 1439 types.Add("sms:PromoteParam", reflect.TypeOf((*PromoteParam)(nil)).Elem()) 1440 } 1441 1442 // The parameters of `VasaProvider.PromoteReplicationGroup_Task`. 1443 // 1444 // This structure may be used only with operations rendered under `/sms`. 1445 type PromoteReplicationGroupRequestType struct { 1446 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1447 // Specifies an array of replication group IDs whose 1448 // in-test devices (`INTEST`) need to be 1449 // promoted to failover `FAILEDOVER` state. 1450 PromoteParam PromoteParam `xml:"promoteParam" json:"promoteParam"` 1451 } 1452 1453 func init() { 1454 types.Add("sms:PromoteReplicationGroupRequestType", reflect.TypeOf((*PromoteReplicationGroupRequestType)(nil)).Elem()) 1455 } 1456 1457 type PromoteReplicationGroup_Task PromoteReplicationGroupRequestType 1458 1459 func init() { 1460 types.Add("sms:PromoteReplicationGroup_Task", reflect.TypeOf((*PromoteReplicationGroup_Task)(nil)).Elem()) 1461 } 1462 1463 type PromoteReplicationGroup_TaskResponse struct { 1464 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 1465 } 1466 1467 // This exception is thrown if the VASA Provider on which the call is made 1468 // is currently busy. 1469 // 1470 // This structure may be used only with operations rendered under `/sms`. 1471 type ProviderBusy struct { 1472 types.MethodFault 1473 } 1474 1475 func init() { 1476 types.Add("sms:ProviderBusy", reflect.TypeOf((*ProviderBusy)(nil)).Elem()) 1477 } 1478 1479 type ProviderBusyFault ProviderBusy 1480 1481 func init() { 1482 types.Add("sms:ProviderBusyFault", reflect.TypeOf((*ProviderBusyFault)(nil)).Elem()) 1483 } 1484 1485 // This fault is thrown if the Storage Monitoring Service failed to connect to the VASA provider. 1486 // 1487 // This structure may be used only with operations rendered under `/sms`. 1488 type ProviderConnectionFailed struct { 1489 types.RuntimeFault 1490 } 1491 1492 func init() { 1493 types.Add("sms:ProviderConnectionFailed", reflect.TypeOf((*ProviderConnectionFailed)(nil)).Elem()) 1494 } 1495 1496 type ProviderConnectionFailedFault ProviderConnectionFailed 1497 1498 func init() { 1499 types.Add("sms:ProviderConnectionFailedFault", reflect.TypeOf((*ProviderConnectionFailedFault)(nil)).Elem()) 1500 } 1501 1502 // This fault is thrown when a VASA provider cannot be found for the specified 1503 // entities. 1504 // 1505 // This structure may be used only with operations rendered under `/sms`. 1506 type ProviderNotFound struct { 1507 QueryExecutionFault 1508 } 1509 1510 func init() { 1511 types.Add("sms:ProviderNotFound", reflect.TypeOf((*ProviderNotFound)(nil)).Elem()) 1512 } 1513 1514 type ProviderNotFoundFault ProviderNotFound 1515 1516 func init() { 1517 types.Add("sms:ProviderNotFoundFault", reflect.TypeOf((*ProviderNotFoundFault)(nil)).Elem()) 1518 } 1519 1520 // This exception is thrown if the VASA Provider is out of resource to satisfy 1521 // a provisioning request. 1522 // 1523 // This structure may be used only with operations rendered under `/sms`. 1524 type ProviderOutOfProvisioningResource struct { 1525 types.MethodFault 1526 1527 // Identifier of the provisioning resource. 1528 ProvisioningResourceId string `xml:"provisioningResourceId" json:"provisioningResourceId"` 1529 // Currently available. 1530 AvailableBefore int64 `xml:"availableBefore,omitempty" json:"availableBefore,omitempty"` 1531 // Necessary for provisioning. 1532 AvailableAfter int64 `xml:"availableAfter,omitempty" json:"availableAfter,omitempty"` 1533 // Total amount (free + used). 1534 Total int64 `xml:"total,omitempty" json:"total,omitempty"` 1535 // This resource limitation is transient, i.e. 1536 // 1537 // the resource 1538 // will be available after some time. 1539 IsTransient *bool `xml:"isTransient" json:"isTransient,omitempty"` 1540 } 1541 1542 func init() { 1543 types.Add("sms:ProviderOutOfProvisioningResource", reflect.TypeOf((*ProviderOutOfProvisioningResource)(nil)).Elem()) 1544 } 1545 1546 type ProviderOutOfProvisioningResourceFault ProviderOutOfProvisioningResource 1547 1548 func init() { 1549 types.Add("sms:ProviderOutOfProvisioningResourceFault", reflect.TypeOf((*ProviderOutOfProvisioningResourceFault)(nil)).Elem()) 1550 } 1551 1552 // This exception is thrown if the VASA Provider on which the call is made 1553 // is out of resource. 1554 // 1555 // This structure may be used only with operations rendered under `/sms`. 1556 type ProviderOutOfResource struct { 1557 types.MethodFault 1558 } 1559 1560 func init() { 1561 types.Add("sms:ProviderOutOfResource", reflect.TypeOf((*ProviderOutOfResource)(nil)).Elem()) 1562 } 1563 1564 type ProviderOutOfResourceFault ProviderOutOfResource 1565 1566 func init() { 1567 types.Add("sms:ProviderOutOfResourceFault", reflect.TypeOf((*ProviderOutOfResourceFault)(nil)).Elem()) 1568 } 1569 1570 // This fault is thrown if failed to register provider to storage 1571 // management service. 1572 // 1573 // This structure may be used only with operations rendered under `/sms`. 1574 type ProviderRegistrationFault struct { 1575 types.MethodFault 1576 } 1577 1578 func init() { 1579 types.Add("sms:ProviderRegistrationFault", reflect.TypeOf((*ProviderRegistrationFault)(nil)).Elem()) 1580 } 1581 1582 type ProviderRegistrationFaultFault BaseProviderRegistrationFault 1583 1584 func init() { 1585 types.Add("sms:ProviderRegistrationFaultFault", reflect.TypeOf((*ProviderRegistrationFaultFault)(nil)).Elem()) 1586 } 1587 1588 // Thrown if a failure occurs when synchronizing the service 1589 // cache with provider information. 1590 // 1591 // This structure may be used only with operations rendered under `/sms`. 1592 type ProviderSyncFailed struct { 1593 types.MethodFault 1594 } 1595 1596 func init() { 1597 types.Add("sms:ProviderSyncFailed", reflect.TypeOf((*ProviderSyncFailed)(nil)).Elem()) 1598 } 1599 1600 type ProviderSyncFailedFault BaseProviderSyncFailed 1601 1602 func init() { 1603 types.Add("sms:ProviderSyncFailedFault", reflect.TypeOf((*ProviderSyncFailedFault)(nil)).Elem()) 1604 } 1605 1606 // This exception is thrown if the VASA Provider on which the call is made is 1607 // currently not available, e.g. 1608 // 1609 // VASA Provider is in offline state. This error 1610 // usually means the provider is temporarily unavailable due to network outage, etc. 1611 // The client is expected to wait for some time and retry the same call. 1612 // 1613 // This structure may be used only with operations rendered under `/sms`. 1614 type ProviderUnavailable struct { 1615 types.MethodFault 1616 } 1617 1618 func init() { 1619 types.Add("sms:ProviderUnavailable", reflect.TypeOf((*ProviderUnavailable)(nil)).Elem()) 1620 } 1621 1622 type ProviderUnavailableFault ProviderUnavailable 1623 1624 func init() { 1625 types.Add("sms:ProviderUnavailableFault", reflect.TypeOf((*ProviderUnavailableFault)(nil)).Elem()) 1626 } 1627 1628 // This fault is thrown if failed to unregister provider from storage 1629 // management service. 1630 // 1631 // This structure may be used only with operations rendered under `/sms`. 1632 type ProviderUnregistrationFault struct { 1633 types.MethodFault 1634 } 1635 1636 func init() { 1637 types.Add("sms:ProviderUnregistrationFault", reflect.TypeOf((*ProviderUnregistrationFault)(nil)).Elem()) 1638 } 1639 1640 type ProviderUnregistrationFaultFault ProviderUnregistrationFault 1641 1642 func init() { 1643 types.Add("sms:ProviderUnregistrationFaultFault", reflect.TypeOf((*ProviderUnregistrationFaultFault)(nil)).Elem()) 1644 } 1645 1646 // This exception is thrown if the storage management service 1647 // fails to register with the VirtualCenter proxy during 1648 // initialization. 1649 // 1650 // This structure may be used only with operations rendered under `/sms`. 1651 type ProxyRegistrationFailed struct { 1652 types.RuntimeFault 1653 } 1654 1655 func init() { 1656 types.Add("sms:ProxyRegistrationFailed", reflect.TypeOf((*ProxyRegistrationFailed)(nil)).Elem()) 1657 } 1658 1659 type ProxyRegistrationFailedFault ProxyRegistrationFailed 1660 1661 func init() { 1662 types.Add("sms:ProxyRegistrationFailedFault", reflect.TypeOf((*ProxyRegistrationFailedFault)(nil)).Elem()) 1663 } 1664 1665 type QueryAboutInfo QueryAboutInfoRequestType 1666 1667 func init() { 1668 types.Add("sms:QueryAboutInfo", reflect.TypeOf((*QueryAboutInfo)(nil)).Elem()) 1669 } 1670 1671 type QueryAboutInfoRequestType struct { 1672 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1673 } 1674 1675 func init() { 1676 types.Add("sms:QueryAboutInfoRequestType", reflect.TypeOf((*QueryAboutInfoRequestType)(nil)).Elem()) 1677 } 1678 1679 type QueryAboutInfoResponse struct { 1680 Returnval SmsAboutInfo `xml:"returnval" json:"returnval"` 1681 } 1682 1683 type QueryActiveAlarm QueryActiveAlarmRequestType 1684 1685 func init() { 1686 types.Add("sms:QueryActiveAlarm", reflect.TypeOf((*QueryActiveAlarm)(nil)).Elem()) 1687 } 1688 1689 // The parameters of `VasaProvider.QueryActiveAlarm`. 1690 // 1691 // This structure may be used only with operations rendered under `/sms`. 1692 type QueryActiveAlarmRequestType struct { 1693 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1694 // Filter criteria for the alarm state. 1695 AlarmFilter *AlarmFilter `xml:"alarmFilter,omitempty" json:"alarmFilter,omitempty"` 1696 } 1697 1698 func init() { 1699 types.Add("sms:QueryActiveAlarmRequestType", reflect.TypeOf((*QueryActiveAlarmRequestType)(nil)).Elem()) 1700 } 1701 1702 type QueryActiveAlarmResponse struct { 1703 Returnval *AlarmResult `xml:"returnval,omitempty" json:"returnval,omitempty"` 1704 } 1705 1706 type QueryArray QueryArrayRequestType 1707 1708 func init() { 1709 types.Add("sms:QueryArray", reflect.TypeOf((*QueryArray)(nil)).Elem()) 1710 } 1711 1712 type QueryArrayAssociatedWithLun QueryArrayAssociatedWithLunRequestType 1713 1714 func init() { 1715 types.Add("sms:QueryArrayAssociatedWithLun", reflect.TypeOf((*QueryArrayAssociatedWithLun)(nil)).Elem()) 1716 } 1717 1718 // The parameters of `SmsStorageManager.QueryArrayAssociatedWithLun`. 1719 // 1720 // This structure may be used only with operations rendered under `/sms`. 1721 type QueryArrayAssociatedWithLunRequestType struct { 1722 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1723 // `ScsiLun.canonicalName` 1724 // of ScsiLun 1725 CanonicalName string `xml:"canonicalName" json:"canonicalName"` 1726 } 1727 1728 func init() { 1729 types.Add("sms:QueryArrayAssociatedWithLunRequestType", reflect.TypeOf((*QueryArrayAssociatedWithLunRequestType)(nil)).Elem()) 1730 } 1731 1732 type QueryArrayAssociatedWithLunResponse struct { 1733 Returnval *StorageArray `xml:"returnval,omitempty" json:"returnval,omitempty"` 1734 } 1735 1736 // The parameters of `SmsStorageManager.QueryArray`. 1737 // 1738 // This structure may be used only with operations rendered under `/sms`. 1739 type QueryArrayRequestType struct { 1740 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1741 // List of `SmsProviderInfo.uid` for the VASA 1742 // provider objects. 1743 ProviderId []string `xml:"providerId,omitempty" json:"providerId,omitempty"` 1744 } 1745 1746 func init() { 1747 types.Add("sms:QueryArrayRequestType", reflect.TypeOf((*QueryArrayRequestType)(nil)).Elem()) 1748 } 1749 1750 type QueryArrayResponse struct { 1751 Returnval []StorageArray `xml:"returnval,omitempty" json:"returnval,omitempty"` 1752 } 1753 1754 type QueryAssociatedBackingStoragePool QueryAssociatedBackingStoragePoolRequestType 1755 1756 func init() { 1757 types.Add("sms:QueryAssociatedBackingStoragePool", reflect.TypeOf((*QueryAssociatedBackingStoragePool)(nil)).Elem()) 1758 } 1759 1760 // The parameters of `SmsStorageManager.QueryAssociatedBackingStoragePool`. 1761 // 1762 // This structure may be used only with operations rendered under `/sms`. 1763 type QueryAssociatedBackingStoragePoolRequestType struct { 1764 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1765 // Unique identifier of a StorageLun or StorageFileSystem. 1766 EntityId string `xml:"entityId,omitempty" json:"entityId,omitempty"` 1767 // Entity type of the entity specified using entityId. This can be either 1768 // StorageLun or StorageFileSystem. 1769 EntityType string `xml:"entityType,omitempty" json:"entityType,omitempty"` 1770 } 1771 1772 func init() { 1773 types.Add("sms:QueryAssociatedBackingStoragePoolRequestType", reflect.TypeOf((*QueryAssociatedBackingStoragePoolRequestType)(nil)).Elem()) 1774 } 1775 1776 type QueryAssociatedBackingStoragePoolResponse struct { 1777 Returnval []BackingStoragePool `xml:"returnval,omitempty" json:"returnval,omitempty"` 1778 } 1779 1780 type QueryDatastoreBackingPoolMapping QueryDatastoreBackingPoolMappingRequestType 1781 1782 func init() { 1783 types.Add("sms:QueryDatastoreBackingPoolMapping", reflect.TypeOf((*QueryDatastoreBackingPoolMapping)(nil)).Elem()) 1784 } 1785 1786 // The parameters of `SmsStorageManager.QueryDatastoreBackingPoolMapping`. 1787 // 1788 // This structure may be used only with operations rendered under `/sms`. 1789 type QueryDatastoreBackingPoolMappingRequestType struct { 1790 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1791 // Array containing references to `Datastore` objects. 1792 // 1793 // Refers instances of `Datastore`. 1794 Datastore []types.ManagedObjectReference `xml:"datastore" json:"datastore"` 1795 } 1796 1797 func init() { 1798 types.Add("sms:QueryDatastoreBackingPoolMappingRequestType", reflect.TypeOf((*QueryDatastoreBackingPoolMappingRequestType)(nil)).Elem()) 1799 } 1800 1801 type QueryDatastoreBackingPoolMappingResponse struct { 1802 Returnval []DatastoreBackingPoolMapping `xml:"returnval" json:"returnval"` 1803 } 1804 1805 type QueryDatastoreCapability QueryDatastoreCapabilityRequestType 1806 1807 func init() { 1808 types.Add("sms:QueryDatastoreCapability", reflect.TypeOf((*QueryDatastoreCapability)(nil)).Elem()) 1809 } 1810 1811 // The parameters of `SmsStorageManager.QueryDatastoreCapability`. 1812 // 1813 // This structure may be used only with operations rendered under `/sms`. 1814 type QueryDatastoreCapabilityRequestType struct { 1815 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1816 // reference to `Datastore` 1817 // 1818 // Refers instance of `Datastore`. 1819 Datastore types.ManagedObjectReference `xml:"datastore" json:"datastore"` 1820 } 1821 1822 func init() { 1823 types.Add("sms:QueryDatastoreCapabilityRequestType", reflect.TypeOf((*QueryDatastoreCapabilityRequestType)(nil)).Elem()) 1824 } 1825 1826 type QueryDatastoreCapabilityResponse struct { 1827 Returnval *StorageCapability `xml:"returnval,omitempty" json:"returnval,omitempty"` 1828 } 1829 1830 type QueryDrsMigrationCapabilityForPerformance QueryDrsMigrationCapabilityForPerformanceRequestType 1831 1832 func init() { 1833 types.Add("sms:QueryDrsMigrationCapabilityForPerformance", reflect.TypeOf((*QueryDrsMigrationCapabilityForPerformance)(nil)).Elem()) 1834 } 1835 1836 type QueryDrsMigrationCapabilityForPerformanceEx QueryDrsMigrationCapabilityForPerformanceExRequestType 1837 1838 func init() { 1839 types.Add("sms:QueryDrsMigrationCapabilityForPerformanceEx", reflect.TypeOf((*QueryDrsMigrationCapabilityForPerformanceEx)(nil)).Elem()) 1840 } 1841 1842 // The parameters of `SmsStorageManager.QueryDrsMigrationCapabilityForPerformanceEx`. 1843 // 1844 // This structure may be used only with operations rendered under `/sms`. 1845 type QueryDrsMigrationCapabilityForPerformanceExRequestType struct { 1846 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1847 // Array containing references to `Datastore` objects. 1848 // 1849 // Refers instances of `Datastore`. 1850 Datastore []types.ManagedObjectReference `xml:"datastore" json:"datastore"` 1851 } 1852 1853 func init() { 1854 types.Add("sms:QueryDrsMigrationCapabilityForPerformanceExRequestType", reflect.TypeOf((*QueryDrsMigrationCapabilityForPerformanceExRequestType)(nil)).Elem()) 1855 } 1856 1857 type QueryDrsMigrationCapabilityForPerformanceExResponse struct { 1858 Returnval DrsMigrationCapabilityResult `xml:"returnval" json:"returnval"` 1859 } 1860 1861 // The parameters of `SmsStorageManager.QueryDrsMigrationCapabilityForPerformance`. 1862 // 1863 // This structure may be used only with operations rendered under `/sms`. 1864 type QueryDrsMigrationCapabilityForPerformanceRequestType struct { 1865 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1866 // Reference to the source `Datastore` 1867 // 1868 // Refers instance of `Datastore`. 1869 SrcDatastore types.ManagedObjectReference `xml:"srcDatastore" json:"srcDatastore"` 1870 // Reference to the destination `Datastore` 1871 // 1872 // Refers instance of `Datastore`. 1873 DstDatastore types.ManagedObjectReference `xml:"dstDatastore" json:"dstDatastore"` 1874 } 1875 1876 func init() { 1877 types.Add("sms:QueryDrsMigrationCapabilityForPerformanceRequestType", reflect.TypeOf((*QueryDrsMigrationCapabilityForPerformanceRequestType)(nil)).Elem()) 1878 } 1879 1880 type QueryDrsMigrationCapabilityForPerformanceResponse struct { 1881 Returnval bool `xml:"returnval" json:"returnval"` 1882 } 1883 1884 // This exception is thrown if a failure occurs while 1885 // processing a query request. 1886 // 1887 // This structure may be used only with operations rendered under `/sms`. 1888 type QueryExecutionFault struct { 1889 types.MethodFault 1890 } 1891 1892 func init() { 1893 types.Add("sms:QueryExecutionFault", reflect.TypeOf((*QueryExecutionFault)(nil)).Elem()) 1894 } 1895 1896 type QueryExecutionFaultFault BaseQueryExecutionFault 1897 1898 func init() { 1899 types.Add("sms:QueryExecutionFaultFault", reflect.TypeOf((*QueryExecutionFaultFault)(nil)).Elem()) 1900 } 1901 1902 type QueryFaultDomain QueryFaultDomainRequestType 1903 1904 func init() { 1905 types.Add("sms:QueryFaultDomain", reflect.TypeOf((*QueryFaultDomain)(nil)).Elem()) 1906 } 1907 1908 // The parameters of `SmsStorageManager.QueryFaultDomain`. 1909 // 1910 // This structure may be used only with operations rendered under `/sms`. 1911 type QueryFaultDomainRequestType struct { 1912 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1913 // spec for the query operation. 1914 Filter *FaultDomainFilter `xml:"filter,omitempty" json:"filter,omitempty"` 1915 } 1916 1917 func init() { 1918 types.Add("sms:QueryFaultDomainRequestType", reflect.TypeOf((*QueryFaultDomainRequestType)(nil)).Elem()) 1919 } 1920 1921 type QueryFaultDomainResponse struct { 1922 Returnval []types.FaultDomainId `xml:"returnval,omitempty" json:"returnval,omitempty"` 1923 } 1924 1925 type QueryFileSystemAssociatedWithArray QueryFileSystemAssociatedWithArrayRequestType 1926 1927 func init() { 1928 types.Add("sms:QueryFileSystemAssociatedWithArray", reflect.TypeOf((*QueryFileSystemAssociatedWithArray)(nil)).Elem()) 1929 } 1930 1931 // The parameters of `SmsStorageManager.QueryFileSystemAssociatedWithArray`. 1932 // 1933 // This structure may be used only with operations rendered under `/sms`. 1934 type QueryFileSystemAssociatedWithArrayRequestType struct { 1935 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1936 // `StorageArray.uuid` for the StorageArray 1937 // object. 1938 ArrayId string `xml:"arrayId" json:"arrayId"` 1939 } 1940 1941 func init() { 1942 types.Add("sms:QueryFileSystemAssociatedWithArrayRequestType", reflect.TypeOf((*QueryFileSystemAssociatedWithArrayRequestType)(nil)).Elem()) 1943 } 1944 1945 type QueryFileSystemAssociatedWithArrayResponse struct { 1946 Returnval []StorageFileSystem `xml:"returnval,omitempty" json:"returnval,omitempty"` 1947 } 1948 1949 type QueryHostAssociatedWithLun QueryHostAssociatedWithLunRequestType 1950 1951 func init() { 1952 types.Add("sms:QueryHostAssociatedWithLun", reflect.TypeOf((*QueryHostAssociatedWithLun)(nil)).Elem()) 1953 } 1954 1955 // The parameters of `SmsStorageManager.QueryHostAssociatedWithLun`. 1956 // 1957 // This structure may be used only with operations rendered under `/sms`. 1958 type QueryHostAssociatedWithLunRequestType struct { 1959 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1960 // `StorageLun.uuid` for the StorageLun 1961 // object. 1962 Scsi3Id string `xml:"scsi3Id" json:"scsi3Id"` 1963 // `StorageArray.uuid` for the StorageArray 1964 // object. 1965 ArrayId string `xml:"arrayId" json:"arrayId"` 1966 } 1967 1968 func init() { 1969 types.Add("sms:QueryHostAssociatedWithLunRequestType", reflect.TypeOf((*QueryHostAssociatedWithLunRequestType)(nil)).Elem()) 1970 } 1971 1972 type QueryHostAssociatedWithLunResponse struct { 1973 Returnval []types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"` 1974 } 1975 1976 type QueryLunAssociatedWithArray QueryLunAssociatedWithArrayRequestType 1977 1978 func init() { 1979 types.Add("sms:QueryLunAssociatedWithArray", reflect.TypeOf((*QueryLunAssociatedWithArray)(nil)).Elem()) 1980 } 1981 1982 // The parameters of `SmsStorageManager.QueryLunAssociatedWithArray`. 1983 // 1984 // This structure may be used only with operations rendered under `/sms`. 1985 type QueryLunAssociatedWithArrayRequestType struct { 1986 This types.ManagedObjectReference `xml:"_this" json:"_this"` 1987 // `StorageArray.uuid` for the StorageArray 1988 // object. 1989 ArrayId string `xml:"arrayId" json:"arrayId"` 1990 } 1991 1992 func init() { 1993 types.Add("sms:QueryLunAssociatedWithArrayRequestType", reflect.TypeOf((*QueryLunAssociatedWithArrayRequestType)(nil)).Elem()) 1994 } 1995 1996 type QueryLunAssociatedWithArrayResponse struct { 1997 Returnval []StorageLun `xml:"returnval,omitempty" json:"returnval,omitempty"` 1998 } 1999 2000 type QueryLunAssociatedWithPort QueryLunAssociatedWithPortRequestType 2001 2002 func init() { 2003 types.Add("sms:QueryLunAssociatedWithPort", reflect.TypeOf((*QueryLunAssociatedWithPort)(nil)).Elem()) 2004 } 2005 2006 // The parameters of `SmsStorageManager.QueryLunAssociatedWithPort`. 2007 // 2008 // This structure may be used only with operations rendered under `/sms`. 2009 type QueryLunAssociatedWithPortRequestType struct { 2010 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2011 // `StoragePort.uuid` for the StoragePort 2012 // object. 2013 PortId string `xml:"portId" json:"portId"` 2014 // `StorageArray.uuid` for the StorageArray 2015 // object. 2016 ArrayId string `xml:"arrayId" json:"arrayId"` 2017 } 2018 2019 func init() { 2020 types.Add("sms:QueryLunAssociatedWithPortRequestType", reflect.TypeOf((*QueryLunAssociatedWithPortRequestType)(nil)).Elem()) 2021 } 2022 2023 type QueryLunAssociatedWithPortResponse struct { 2024 Returnval []StorageLun `xml:"returnval,omitempty" json:"returnval,omitempty"` 2025 } 2026 2027 type QueryNfsDatastoreAssociatedWithFileSystem QueryNfsDatastoreAssociatedWithFileSystemRequestType 2028 2029 func init() { 2030 types.Add("sms:QueryNfsDatastoreAssociatedWithFileSystem", reflect.TypeOf((*QueryNfsDatastoreAssociatedWithFileSystem)(nil)).Elem()) 2031 } 2032 2033 // The parameters of `SmsStorageManager.QueryNfsDatastoreAssociatedWithFileSystem`. 2034 // 2035 // This structure may be used only with operations rendered under `/sms`. 2036 type QueryNfsDatastoreAssociatedWithFileSystemRequestType struct { 2037 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2038 // `StorageFileSystem.uuid` for the 2039 // StorageFileSystem object 2040 FileSystemId string `xml:"fileSystemId" json:"fileSystemId"` 2041 // `StorageArray.uuid` for the StorageArray 2042 // object. 2043 ArrayId string `xml:"arrayId" json:"arrayId"` 2044 } 2045 2046 func init() { 2047 types.Add("sms:QueryNfsDatastoreAssociatedWithFileSystemRequestType", reflect.TypeOf((*QueryNfsDatastoreAssociatedWithFileSystemRequestType)(nil)).Elem()) 2048 } 2049 2050 type QueryNfsDatastoreAssociatedWithFileSystemResponse struct { 2051 Returnval *types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"` 2052 } 2053 2054 // This exception is thrown if the specified entity and related 2055 // entity type combination for a list query is not supported. 2056 // 2057 // This structure may be used only with operations rendered under `/sms`. 2058 type QueryNotSupported struct { 2059 types.InvalidArgument 2060 2061 // Entity type. 2062 EntityType EntityReferenceEntityType `xml:"entityType,omitempty" json:"entityType,omitempty"` 2063 // Related entity type. 2064 RelatedEntityType EntityReferenceEntityType `xml:"relatedEntityType" json:"relatedEntityType"` 2065 } 2066 2067 func init() { 2068 types.Add("sms:QueryNotSupported", reflect.TypeOf((*QueryNotSupported)(nil)).Elem()) 2069 } 2070 2071 type QueryNotSupportedFault QueryNotSupported 2072 2073 func init() { 2074 types.Add("sms:QueryNotSupportedFault", reflect.TypeOf((*QueryNotSupportedFault)(nil)).Elem()) 2075 } 2076 2077 type QueryPointInTimeReplica QueryPointInTimeReplicaRequestType 2078 2079 func init() { 2080 types.Add("sms:QueryPointInTimeReplica", reflect.TypeOf((*QueryPointInTimeReplica)(nil)).Elem()) 2081 } 2082 2083 // Describes the search criteria for the PiT query. 2084 // 2085 // If none of the fields 2086 // is set, or if the number of PiT replicas is too large, VASA provider can 2087 // return `QueryPointInTimeReplicaSummaryResult`. 2088 // 2089 // This structure may be used only with operations rendered under `/sms`. 2090 type QueryPointInTimeReplicaParam struct { 2091 types.DynamicData 2092 2093 // Specifies the replica time span that vSphere is interested in. 2094 ReplicaTimeQueryParam *ReplicaQueryIntervalParam `xml:"replicaTimeQueryParam,omitempty" json:"replicaTimeQueryParam,omitempty"` 2095 // Only the replicas that match the given name are requested. 2096 // 2097 // A regexp according to http://www.w3.org/TR/xmlschema-2/#regexs. 2098 PitName string `xml:"pitName,omitempty" json:"pitName,omitempty"` 2099 // Only the replicas with tags that match the given tag(s) are requested. 2100 // 2101 // Each entry may be a regexp according to http://www.w3.org/TR/xmlschema-2/#regexs. 2102 Tags []string `xml:"tags,omitempty" json:"tags,omitempty"` 2103 // This field is hint for the preferred type of return results. 2104 // 2105 // It can be either true for `QueryPointInTimeReplicaSuccessResult` or 2106 // false for `QueryPointInTimeReplicaSummaryResult`. 2107 // If not set, VP may choose the appropriate type, as described in 2108 // <code>ReplicaQueryIntervalParam</code>. 2109 PreferDetails *bool `xml:"preferDetails" json:"preferDetails,omitempty"` 2110 } 2111 2112 func init() { 2113 types.Add("sms:QueryPointInTimeReplicaParam", reflect.TypeOf((*QueryPointInTimeReplicaParam)(nil)).Elem()) 2114 } 2115 2116 // The parameters of `VasaProvider.QueryPointInTimeReplica`. 2117 // 2118 // This structure may be used only with operations rendered under `/sms`. 2119 type QueryPointInTimeReplicaRequestType struct { 2120 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2121 // List of replication group IDs. 2122 GroupId []types.ReplicationGroupId `xml:"groupId,omitempty" json:"groupId,omitempty"` 2123 // Search criteria specification for all the groups. 2124 QueryParam *QueryPointInTimeReplicaParam `xml:"queryParam,omitempty" json:"queryParam,omitempty"` 2125 } 2126 2127 func init() { 2128 types.Add("sms:QueryPointInTimeReplicaRequestType", reflect.TypeOf((*QueryPointInTimeReplicaRequestType)(nil)).Elem()) 2129 } 2130 2131 type QueryPointInTimeReplicaResponse struct { 2132 Returnval []BaseGroupOperationResult `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` 2133 } 2134 2135 // Return type for successful 2136 // `VasaProvider.QueryPointInTimeReplica` 2137 // operation. 2138 // 2139 // If the VASA provider decides that there are too many to return, 2140 // it could set the result of some of the groups to `TooMany` 2141 // fault or `QueryPointInTimeReplicaSummaryResult`. 2142 // 2143 // vSphere will then query for these groups separately. 2144 // 2145 // This structure may be used only with operations rendered under `/sms`. 2146 type QueryPointInTimeReplicaSuccessResult struct { 2147 GroupOperationResult 2148 2149 // Information about the available replicas. 2150 ReplicaInfo []PointInTimeReplicaInfo `xml:"replicaInfo,omitempty" json:"replicaInfo,omitempty"` 2151 } 2152 2153 func init() { 2154 types.Add("sms:QueryPointInTimeReplicaSuccessResult", reflect.TypeOf((*QueryPointInTimeReplicaSuccessResult)(nil)).Elem()) 2155 } 2156 2157 // Summary of the available replicas. 2158 // 2159 // Mostly useful for CDP type replicators. 2160 // 2161 // This structure may be used only with operations rendered under `/sms`. 2162 type QueryPointInTimeReplicaSummaryResult struct { 2163 GroupOperationResult 2164 2165 // A series of query results. 2166 // 2167 // No special ordering is assumed by vSphere. 2168 IntervalResults []ReplicaIntervalQueryResult `xml:"intervalResults,omitempty" json:"intervalResults,omitempty"` 2169 } 2170 2171 func init() { 2172 types.Add("sms:QueryPointInTimeReplicaSummaryResult", reflect.TypeOf((*QueryPointInTimeReplicaSummaryResult)(nil)).Elem()) 2173 } 2174 2175 type QueryPortAssociatedWithArray QueryPortAssociatedWithArrayRequestType 2176 2177 func init() { 2178 types.Add("sms:QueryPortAssociatedWithArray", reflect.TypeOf((*QueryPortAssociatedWithArray)(nil)).Elem()) 2179 } 2180 2181 // The parameters of `SmsStorageManager.QueryPortAssociatedWithArray`. 2182 // 2183 // This structure may be used only with operations rendered under `/sms`. 2184 type QueryPortAssociatedWithArrayRequestType struct { 2185 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2186 // `StorageArray.uuid` for the StorageArray 2187 // object. 2188 ArrayId string `xml:"arrayId" json:"arrayId"` 2189 } 2190 2191 func init() { 2192 types.Add("sms:QueryPortAssociatedWithArrayRequestType", reflect.TypeOf((*QueryPortAssociatedWithArrayRequestType)(nil)).Elem()) 2193 } 2194 2195 type QueryPortAssociatedWithArrayResponse struct { 2196 Returnval []BaseStoragePort `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` 2197 } 2198 2199 type QueryPortAssociatedWithLun QueryPortAssociatedWithLunRequestType 2200 2201 func init() { 2202 types.Add("sms:QueryPortAssociatedWithLun", reflect.TypeOf((*QueryPortAssociatedWithLun)(nil)).Elem()) 2203 } 2204 2205 // The parameters of `SmsStorageManager.QueryPortAssociatedWithLun`. 2206 // 2207 // This structure may be used only with operations rendered under `/sms`. 2208 type QueryPortAssociatedWithLunRequestType struct { 2209 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2210 // `StorageLun.uuid` for the StorageLun 2211 // object. 2212 Scsi3Id string `xml:"scsi3Id" json:"scsi3Id"` 2213 // `StorageArray.uuid` for the StorageArray 2214 // object. 2215 ArrayId string `xml:"arrayId" json:"arrayId"` 2216 } 2217 2218 func init() { 2219 types.Add("sms:QueryPortAssociatedWithLunRequestType", reflect.TypeOf((*QueryPortAssociatedWithLunRequestType)(nil)).Elem()) 2220 } 2221 2222 type QueryPortAssociatedWithLunResponse struct { 2223 Returnval BaseStoragePort `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` 2224 } 2225 2226 type QueryPortAssociatedWithProcessor QueryPortAssociatedWithProcessorRequestType 2227 2228 func init() { 2229 types.Add("sms:QueryPortAssociatedWithProcessor", reflect.TypeOf((*QueryPortAssociatedWithProcessor)(nil)).Elem()) 2230 } 2231 2232 // The parameters of `SmsStorageManager.QueryPortAssociatedWithProcessor`. 2233 // 2234 // This structure may be used only with operations rendered under `/sms`. 2235 type QueryPortAssociatedWithProcessorRequestType struct { 2236 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2237 // `StorageProcessor.uuid` for the 2238 // StorageProcessor object. 2239 ProcessorId string `xml:"processorId" json:"processorId"` 2240 // `StorageArray.uuid` for the StorageArray 2241 // object. 2242 ArrayId string `xml:"arrayId" json:"arrayId"` 2243 } 2244 2245 func init() { 2246 types.Add("sms:QueryPortAssociatedWithProcessorRequestType", reflect.TypeOf((*QueryPortAssociatedWithProcessorRequestType)(nil)).Elem()) 2247 } 2248 2249 type QueryPortAssociatedWithProcessorResponse struct { 2250 Returnval []BaseStoragePort `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` 2251 } 2252 2253 type QueryProcessorAssociatedWithArray QueryProcessorAssociatedWithArrayRequestType 2254 2255 func init() { 2256 types.Add("sms:QueryProcessorAssociatedWithArray", reflect.TypeOf((*QueryProcessorAssociatedWithArray)(nil)).Elem()) 2257 } 2258 2259 // The parameters of `SmsStorageManager.QueryProcessorAssociatedWithArray`. 2260 // 2261 // This structure may be used only with operations rendered under `/sms`. 2262 type QueryProcessorAssociatedWithArrayRequestType struct { 2263 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2264 // `StorageArray.uuid` for the StorageArray 2265 // object. 2266 ArrayId string `xml:"arrayId" json:"arrayId"` 2267 } 2268 2269 func init() { 2270 types.Add("sms:QueryProcessorAssociatedWithArrayRequestType", reflect.TypeOf((*QueryProcessorAssociatedWithArrayRequestType)(nil)).Elem()) 2271 } 2272 2273 type QueryProcessorAssociatedWithArrayResponse struct { 2274 Returnval []StorageProcessor `xml:"returnval,omitempty" json:"returnval,omitempty"` 2275 } 2276 2277 type QueryProvider QueryProviderRequestType 2278 2279 func init() { 2280 types.Add("sms:QueryProvider", reflect.TypeOf((*QueryProvider)(nil)).Elem()) 2281 } 2282 2283 type QueryProviderInfo QueryProviderInfoRequestType 2284 2285 func init() { 2286 types.Add("sms:QueryProviderInfo", reflect.TypeOf((*QueryProviderInfo)(nil)).Elem()) 2287 } 2288 2289 type QueryProviderInfoRequestType struct { 2290 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2291 } 2292 2293 func init() { 2294 types.Add("sms:QueryProviderInfoRequestType", reflect.TypeOf((*QueryProviderInfoRequestType)(nil)).Elem()) 2295 } 2296 2297 type QueryProviderInfoResponse struct { 2298 Returnval BaseSmsProviderInfo `xml:"returnval,typeattr" json:"returnval"` 2299 } 2300 2301 type QueryProviderRequestType struct { 2302 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2303 } 2304 2305 func init() { 2306 types.Add("sms:QueryProviderRequestType", reflect.TypeOf((*QueryProviderRequestType)(nil)).Elem()) 2307 } 2308 2309 type QueryProviderResponse struct { 2310 Returnval []types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"` 2311 } 2312 2313 type QueryReplicationGroup QueryReplicationGroupRequestType 2314 2315 func init() { 2316 types.Add("sms:QueryReplicationGroup", reflect.TypeOf((*QueryReplicationGroup)(nil)).Elem()) 2317 } 2318 2319 type QueryReplicationGroupInfo QueryReplicationGroupInfoRequestType 2320 2321 func init() { 2322 types.Add("sms:QueryReplicationGroupInfo", reflect.TypeOf((*QueryReplicationGroupInfo)(nil)).Elem()) 2323 } 2324 2325 // The parameters of `SmsStorageManager.QueryReplicationGroupInfo`. 2326 // 2327 // This structure may be used only with operations rendered under `/sms`. 2328 type QueryReplicationGroupInfoRequestType struct { 2329 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2330 RgFilter ReplicationGroupFilter `xml:"rgFilter" json:"rgFilter"` 2331 } 2332 2333 func init() { 2334 types.Add("sms:QueryReplicationGroupInfoRequestType", reflect.TypeOf((*QueryReplicationGroupInfoRequestType)(nil)).Elem()) 2335 } 2336 2337 type QueryReplicationGroupInfoResponse struct { 2338 Returnval []BaseGroupOperationResult `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` 2339 } 2340 2341 // The parameters of `VasaProvider.QueryReplicationGroup`. 2342 // 2343 // This structure may be used only with operations rendered under `/sms`. 2344 type QueryReplicationGroupRequestType struct { 2345 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2346 // List of replication group IDs. 2347 GroupId []types.ReplicationGroupId `xml:"groupId,omitempty" json:"groupId,omitempty"` 2348 } 2349 2350 func init() { 2351 types.Add("sms:QueryReplicationGroupRequestType", reflect.TypeOf((*QueryReplicationGroupRequestType)(nil)).Elem()) 2352 } 2353 2354 type QueryReplicationGroupResponse struct { 2355 Returnval []BaseGroupOperationResult `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` 2356 } 2357 2358 // Information about the replication groups. 2359 // 2360 // Information about both the source 2361 // groups and the target groups is returned. 2362 // 2363 // This structure may be used only with operations rendered under `/sms`. 2364 type QueryReplicationGroupSuccessResult struct { 2365 GroupOperationResult 2366 2367 // Information about the replication group. 2368 // 2369 // May be either 2370 // `SourceGroupInfo` or `TargetGroupInfo`. 2371 RgInfo BaseGroupInfo `xml:"rgInfo,typeattr" json:"rgInfo"` 2372 } 2373 2374 func init() { 2375 types.Add("sms:QueryReplicationGroupSuccessResult", reflect.TypeOf((*QueryReplicationGroupSuccessResult)(nil)).Elem()) 2376 } 2377 2378 type QueryReplicationPeer QueryReplicationPeerRequestType 2379 2380 func init() { 2381 types.Add("sms:QueryReplicationPeer", reflect.TypeOf((*QueryReplicationPeer)(nil)).Elem()) 2382 } 2383 2384 // The parameters of `VasaProvider.QueryReplicationPeer`. 2385 // 2386 // This structure may be used only with operations rendered under `/sms`. 2387 type QueryReplicationPeerRequestType struct { 2388 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2389 // An optional list of source fault domain ID. 2390 FaultDomainId []types.FaultDomainId `xml:"faultDomainId,omitempty" json:"faultDomainId,omitempty"` 2391 } 2392 2393 func init() { 2394 types.Add("sms:QueryReplicationPeerRequestType", reflect.TypeOf((*QueryReplicationPeerRequestType)(nil)).Elem()) 2395 } 2396 2397 type QueryReplicationPeerResponse struct { 2398 Returnval []QueryReplicationPeerResult `xml:"returnval,omitempty" json:"returnval,omitempty"` 2399 } 2400 2401 // Information about the replication peers of a VASA provider. 2402 // 2403 // This structure may be used only with operations rendered under `/sms`. 2404 type QueryReplicationPeerResult struct { 2405 types.DynamicData 2406 2407 // Source fault domain id, must correspond to an id from the input. 2408 SourceDomain types.FaultDomainId `xml:"sourceDomain" json:"sourceDomain"` 2409 // Target fault domains for the given source, fault domain ID's are globally 2410 // unique. 2411 // 2412 // There can be one or more target domains for a given source. 2413 TargetDomain []types.FaultDomainId `xml:"targetDomain,omitempty" json:"targetDomain,omitempty"` 2414 // Error must be set when targetDomain field is not set. 2415 Error []types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"` 2416 // Optional warning messages. 2417 Warning []types.LocalizedMethodFault `xml:"warning,omitempty" json:"warning,omitempty"` 2418 } 2419 2420 func init() { 2421 types.Add("sms:QueryReplicationPeerResult", reflect.TypeOf((*QueryReplicationPeerResult)(nil)).Elem()) 2422 } 2423 2424 type QuerySessionManager QuerySessionManagerRequestType 2425 2426 func init() { 2427 types.Add("sms:QuerySessionManager", reflect.TypeOf((*QuerySessionManager)(nil)).Elem()) 2428 } 2429 2430 type QuerySessionManagerRequestType struct { 2431 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2432 } 2433 2434 func init() { 2435 types.Add("sms:QuerySessionManagerRequestType", reflect.TypeOf((*QuerySessionManagerRequestType)(nil)).Elem()) 2436 } 2437 2438 type QuerySessionManagerResponse struct { 2439 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 2440 } 2441 2442 type QuerySmsTaskInfo QuerySmsTaskInfoRequestType 2443 2444 func init() { 2445 types.Add("sms:QuerySmsTaskInfo", reflect.TypeOf((*QuerySmsTaskInfo)(nil)).Elem()) 2446 } 2447 2448 type QuerySmsTaskInfoRequestType struct { 2449 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2450 } 2451 2452 func init() { 2453 types.Add("sms:QuerySmsTaskInfoRequestType", reflect.TypeOf((*QuerySmsTaskInfoRequestType)(nil)).Elem()) 2454 } 2455 2456 type QuerySmsTaskInfoResponse struct { 2457 Returnval SmsTaskInfo `xml:"returnval" json:"returnval"` 2458 } 2459 2460 type QuerySmsTaskResult QuerySmsTaskResultRequestType 2461 2462 func init() { 2463 types.Add("sms:QuerySmsTaskResult", reflect.TypeOf((*QuerySmsTaskResult)(nil)).Elem()) 2464 } 2465 2466 type QuerySmsTaskResultRequestType struct { 2467 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2468 } 2469 2470 func init() { 2471 types.Add("sms:QuerySmsTaskResultRequestType", reflect.TypeOf((*QuerySmsTaskResultRequestType)(nil)).Elem()) 2472 } 2473 2474 type QuerySmsTaskResultResponse struct { 2475 Returnval types.AnyType `xml:"returnval,omitempty,typeattr" json:"returnval,omitempty"` 2476 } 2477 2478 type QueryStorageContainer QueryStorageContainerRequestType 2479 2480 func init() { 2481 types.Add("sms:QueryStorageContainer", reflect.TypeOf((*QueryStorageContainer)(nil)).Elem()) 2482 } 2483 2484 // The parameters of `SmsStorageManager.QueryStorageContainer`. 2485 // 2486 // This structure may be used only with operations rendered under `/sms`. 2487 type QueryStorageContainerRequestType struct { 2488 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2489 // `StorageContainerSpec` 2490 ContainerSpec *StorageContainerSpec `xml:"containerSpec,omitempty" json:"containerSpec,omitempty"` 2491 } 2492 2493 func init() { 2494 types.Add("sms:QueryStorageContainerRequestType", reflect.TypeOf((*QueryStorageContainerRequestType)(nil)).Elem()) 2495 } 2496 2497 type QueryStorageContainerResponse struct { 2498 Returnval *StorageContainerResult `xml:"returnval,omitempty" json:"returnval,omitempty"` 2499 } 2500 2501 type QueryStorageManager QueryStorageManagerRequestType 2502 2503 func init() { 2504 types.Add("sms:QueryStorageManager", reflect.TypeOf((*QueryStorageManager)(nil)).Elem()) 2505 } 2506 2507 type QueryStorageManagerRequestType struct { 2508 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2509 } 2510 2511 func init() { 2512 types.Add("sms:QueryStorageManagerRequestType", reflect.TypeOf((*QueryStorageManagerRequestType)(nil)).Elem()) 2513 } 2514 2515 type QueryStorageManagerResponse struct { 2516 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 2517 } 2518 2519 type QueryVmfsDatastoreAssociatedWithLun QueryVmfsDatastoreAssociatedWithLunRequestType 2520 2521 func init() { 2522 types.Add("sms:QueryVmfsDatastoreAssociatedWithLun", reflect.TypeOf((*QueryVmfsDatastoreAssociatedWithLun)(nil)).Elem()) 2523 } 2524 2525 // The parameters of `SmsStorageManager.QueryVmfsDatastoreAssociatedWithLun`. 2526 // 2527 // This structure may be used only with operations rendered under `/sms`. 2528 type QueryVmfsDatastoreAssociatedWithLunRequestType struct { 2529 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2530 // `StorageLun.uuid` for the StorageLun object 2531 Scsi3Id string `xml:"scsi3Id" json:"scsi3Id"` 2532 // `StorageArray.uuid` for the StorageArray 2533 // object. 2534 ArrayId string `xml:"arrayId" json:"arrayId"` 2535 } 2536 2537 func init() { 2538 types.Add("sms:QueryVmfsDatastoreAssociatedWithLunRequestType", reflect.TypeOf((*QueryVmfsDatastoreAssociatedWithLunRequestType)(nil)).Elem()) 2539 } 2540 2541 type QueryVmfsDatastoreAssociatedWithLunResponse struct { 2542 Returnval *types.ManagedObjectReference `xml:"returnval,omitempty" json:"returnval,omitempty"` 2543 } 2544 2545 // Represents the device after the failover. 2546 // 2547 // Even though many of the fields in this structure are 2548 // marked optional, it is important for VASA provider to 2549 // make sure that the recovery of the entire ReplicationGroup succeeds 2550 // atomically. The only valid scenario when there is a device specific 2551 // recovery failure is when there is no valid replica for the Virtual Volume 2552 // (e.g. Virtual Volume was just added to the ReplicationGroup). 2553 // 2554 // This structure may be used only with operations rendered under `/sms`. 2555 type RecoveredDevice struct { 2556 types.DynamicData 2557 2558 // Identifier of the device which was the target of replication before 2559 // failover. 2560 TargetDeviceId *ReplicaId `xml:"targetDeviceId,omitempty" json:"targetDeviceId,omitempty"` 2561 // Identifier of the target device after test or failover. 2562 RecoveredDeviceId BaseDeviceId `xml:"recoveredDeviceId,omitempty,typeattr" json:"recoveredDeviceId,omitempty"` 2563 // Identifier of the source of the replication data before the failover 2564 // stopped the replication. 2565 SourceDeviceId BaseDeviceId `xml:"sourceDeviceId,typeattr" json:"sourceDeviceId"` 2566 // Informational messages. 2567 Info []string `xml:"info,omitempty" json:"info,omitempty"` 2568 // Datastore for the newly surfaced device. 2569 // 2570 // Refers instance of `Datastore`. 2571 Datastore types.ManagedObjectReference `xml:"datastore" json:"datastore"` 2572 // Only to be filled in if the `RecoveredDevice.recoveredDeviceId` is `VirtualMachineId`. 2573 RecoveredDiskInfo []RecoveredDiskInfo `xml:"recoveredDiskInfo,omitempty" json:"recoveredDiskInfo,omitempty"` 2574 // Virtual Volume specific recovery error. 2575 // 2576 // This should be rare. 2577 Error *types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"` 2578 // Warnings. 2579 Warnings []types.LocalizedMethodFault `xml:"warnings,omitempty" json:"warnings,omitempty"` 2580 } 2581 2582 func init() { 2583 types.Add("sms:RecoveredDevice", reflect.TypeOf((*RecoveredDevice)(nil)).Elem()) 2584 } 2585 2586 // Describes the recovered disks for a given virtual machine. 2587 // 2588 // Only applicable for VAIO based replicators. Upon recovery, 2589 // all the replicated disks must be attached to the virtual machine, 2590 // i.e. the VMX file must refer to the correct file paths. Device 2591 // keys must be preserved and non-replicated disks can refer to 2592 // non-existent file names. 2593 // Array based replicators can ignore this class. 2594 // 2595 // This structure may be used only with operations rendered under `/sms`. 2596 type RecoveredDiskInfo struct { 2597 types.DynamicData 2598 2599 // Virtual disk key. 2600 // 2601 // Note that disk device 2602 // keys must not change after recovery - in other words, the device 2603 // key is the same on both the source and target sites. 2604 // 2605 // For example, if a VMDK d1 is being replicated to d1', and d1 is attached as device 2606 // 2001 to the source VM, the recovered VM should have d1' attached 2607 // as 2001. 2608 DeviceKey int32 `xml:"deviceKey" json:"deviceKey"` 2609 // URL of the datastore that disk was recovered to. 2610 DsUrl string `xml:"dsUrl" json:"dsUrl"` 2611 // Full pathname of the disk. 2612 DiskPath string `xml:"diskPath" json:"diskPath"` 2613 } 2614 2615 func init() { 2616 types.Add("sms:RecoveredDiskInfo", reflect.TypeOf((*RecoveredDiskInfo)(nil)).Elem()) 2617 } 2618 2619 // Information about member virtual volumes in a ReplicationGroup 2620 // on the target after failover or testFailoverStart. 2621 // 2622 // This must include information about all the vSphere managed snapshots in 2623 // the ReplicationGroup. 2624 // 2625 // This structure may be used only with operations rendered under `/sms`. 2626 type RecoveredTargetGroupMemberInfo struct { 2627 TargetGroupMemberInfo 2628 2629 // Identifier of the target device after test or failover. 2630 RecoveredDeviceId BaseDeviceId `xml:"recoveredDeviceId,omitempty,typeattr" json:"recoveredDeviceId,omitempty"` 2631 } 2632 2633 func init() { 2634 types.Add("sms:RecoveredTargetGroupMemberInfo", reflect.TypeOf((*RecoveredTargetGroupMemberInfo)(nil)).Elem()) 2635 } 2636 2637 // The parameters of `SmsStorageManager.RegisterProvider_Task`. 2638 // 2639 // This structure may be used only with operations rendered under `/sms`. 2640 type RegisterProviderRequestType struct { 2641 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2642 // `SmsProviderSpec` 2643 // containing parameters needed to register the 2644 // provider 2645 ProviderSpec BaseSmsProviderSpec `xml:"providerSpec,typeattr" json:"providerSpec"` 2646 } 2647 2648 func init() { 2649 types.Add("sms:RegisterProviderRequestType", reflect.TypeOf((*RegisterProviderRequestType)(nil)).Elem()) 2650 } 2651 2652 type RegisterProvider_Task RegisterProviderRequestType 2653 2654 func init() { 2655 types.Add("sms:RegisterProvider_Task", reflect.TypeOf((*RegisterProvider_Task)(nil)).Elem()) 2656 } 2657 2658 type RegisterProvider_TaskResponse struct { 2659 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 2660 } 2661 2662 // Indicates whether the provider has been marked as active for the given array 2663 // for the session context. 2664 // 2665 // SMS uses `StorageArray.priority` value to mark a provider 2666 // as active among the ones that are registered with SMS and manage this array. 2667 // 2668 // This structure may be used only with operations rendered under `/sms`. 2669 type RelatedStorageArray struct { 2670 types.DynamicData 2671 2672 // `StorageArray.uuid` of StorageArray 2673 ArrayId string `xml:"arrayId" json:"arrayId"` 2674 // This field indicates whether the provider is currently serving data for the StorageArray 2675 Active bool `xml:"active" json:"active"` 2676 // Manageability status of StorageArray on VASA provider, if true it is manageable. 2677 Manageable bool `xml:"manageable" json:"manageable"` 2678 // Deprecated as of SMS API 6.0, replaced by `VasaProviderInfo.priority`. 2679 // 2680 // `StorageArray.priority` of StorageArray 2681 // For VASA 1.0 providers, this field is set to -1. 2682 Priority int32 `xml:"priority" json:"priority"` 2683 } 2684 2685 func init() { 2686 types.Add("sms:RelatedStorageArray", reflect.TypeOf((*RelatedStorageArray)(nil)).Elem()) 2687 } 2688 2689 // Identifier of the replication target device. 2690 // 2691 // For Virtual Volumes, this could be the same as a Virtual Volume 2692 // Id, for VMDK's this could be an FCD uuid, or some other ID 2693 // made up by the replicator. This identifier is opaque to vSphere and 2694 // hence does not have any distinguishing type. This can be used 2695 // to identify the replica without the accompanying source device id 2696 // (though there are no such uses in the current API). 2697 // 2698 // Since this an opaque type, the recovered device id at 2699 // `RecoveredTargetGroupMemberInfo.recoveredDeviceId` 2700 // should be filled in even if the values are the same. 2701 // 2702 // This structure may be used only with operations rendered under `/sms`. 2703 type ReplicaId struct { 2704 types.DynamicData 2705 2706 Id string `xml:"id" json:"id"` 2707 } 2708 2709 func init() { 2710 types.Add("sms:ReplicaId", reflect.TypeOf((*ReplicaId)(nil)).Elem()) 2711 } 2712 2713 // Summarizes the collection of replicas in one time interval. 2714 // 2715 // This structure may be used only with operations rendered under `/sms`. 2716 type ReplicaIntervalQueryResult struct { 2717 types.DynamicData 2718 2719 // Beginning of interval (inclusive). 2720 FromDate time.Time `xml:"fromDate" json:"fromDate"` 2721 // End of interval (exclusive). 2722 ToDate time.Time `xml:"toDate" json:"toDate"` 2723 // Number of Point in Time replicas available for recovery. 2724 // 2725 // TODO: Do we want to have also ask for number of 'special' 2726 // PiTs e.g. those that are consistent? 2727 Number int32 `xml:"number" json:"number"` 2728 } 2729 2730 func init() { 2731 types.Add("sms:ReplicaIntervalQueryResult", reflect.TypeOf((*ReplicaIntervalQueryResult)(nil)).Elem()) 2732 } 2733 2734 // Defines the parameters for a Point In Time replica (PiT) query. 2735 // 2736 // vSphere will not set all the three fields. 2737 // 2738 // In other words, the following combinations of fields are allowed: 2739 // - All the three fields are omitted. 2740 // - `ReplicaQueryIntervalParam.fromDate` and `ReplicaQueryIntervalParam.toDate` are set. 2741 // - `ReplicaQueryIntervalParam.fromDate` and `ReplicaQueryIntervalParam.number` are set. 2742 // - `ReplicaQueryIntervalParam.toDate` and `ReplicaQueryIntervalParam.number` are set. 2743 // 2744 // When all the fields are omitted, VASA provider should return 2745 // `QueryPointInTimeReplicaSummaryResult`. 2746 // But, returned result can be either `QueryPointInTimeReplicaSuccessResult` 2747 // or `QueryPointInTimeReplicaSummaryResult` based on value i.e true or false 2748 // respectively for field `QueryPointInTimeReplicaParam.preferDetails`. 2749 // 2750 // This structure may be used only with operations rendered under `/sms`. 2751 type ReplicaQueryIntervalParam struct { 2752 types.DynamicData 2753 2754 // Return all PiTs including and later than <code>fromDate</code>. 2755 FromDate *time.Time `xml:"fromDate" json:"fromDate,omitempty"` 2756 // Return all PiTs earlier than <code>toDate</code>. 2757 ToDate *time.Time `xml:"toDate" json:"toDate,omitempty"` 2758 // Return information for only <code>number</code> entries. 2759 Number int32 `xml:"number,omitempty" json:"number,omitempty"` 2760 } 2761 2762 func init() { 2763 types.Add("sms:ReplicaQueryIntervalParam", reflect.TypeOf((*ReplicaQueryIntervalParam)(nil)).Elem()) 2764 } 2765 2766 // Describes one Replication Group's data. 2767 // 2768 // This structure may be used only with operations rendered under `/sms`. 2769 type ReplicationGroupData struct { 2770 types.DynamicData 2771 2772 // Replication group to failover. 2773 GroupId types.ReplicationGroupId `xml:"groupId" json:"groupId"` 2774 // The PIT that should be used for (test)Failover. 2775 // 2776 // Use the latest if not specified. 2777 PitId *PointInTimeReplicaId `xml:"pitId,omitempty" json:"pitId,omitempty"` 2778 } 2779 2780 func init() { 2781 types.Add("sms:ReplicationGroupData", reflect.TypeOf((*ReplicationGroupData)(nil)).Elem()) 2782 } 2783 2784 // This spec contains information needed for `SmsStorageManager.QueryReplicationGroupInfo` 2785 // API to filter the result. 2786 // 2787 // This structure may be used only with operations rendered under `/sms`. 2788 type ReplicationGroupFilter struct { 2789 types.DynamicData 2790 2791 // Query for the given replication groups from their associated providers. 2792 // 2793 // The groupId cannot be null or empty. 2794 GroupId []types.ReplicationGroupId `xml:"groupId,omitempty" json:"groupId,omitempty"` 2795 } 2796 2797 func init() { 2798 types.Add("sms:ReplicationGroupFilter", reflect.TypeOf((*ReplicationGroupFilter)(nil)).Elem()) 2799 } 2800 2801 // Information about each replication target. 2802 // 2803 // This structure may be used only with operations rendered under `/sms`. 2804 type ReplicationTargetInfo struct { 2805 types.DynamicData 2806 2807 // Id of the target replication group (including the fault domain ID). 2808 TargetGroupId types.ReplicationGroupId `xml:"targetGroupId" json:"targetGroupId"` 2809 // Description of the replication agreement. 2810 // 2811 // This could be used to describe the characteristics of the replication 2812 // relationship between the source and the target (e.g. RPO, Replication 2813 // Mode, and other such properties). It is expected that VASA provider 2814 // will localize the string before sending to vSphere. 2815 ReplicationAgreementDescription string `xml:"replicationAgreementDescription,omitempty" json:"replicationAgreementDescription,omitempty"` 2816 } 2817 2818 func init() { 2819 types.Add("sms:ReplicationTargetInfo", reflect.TypeOf((*ReplicationTargetInfo)(nil)).Elem()) 2820 } 2821 2822 // The parameters of `VasaProvider.ReverseReplicateGroup_Task`. 2823 // 2824 // This structure may be used only with operations rendered under `/sms`. 2825 type ReverseReplicateGroupRequestType struct { 2826 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2827 // Array of replication groups (currently in 2828 // `FAILEDOVER` state) that need to be reversed. 2829 GroupId []types.ReplicationGroupId `xml:"groupId,omitempty" json:"groupId,omitempty"` 2830 } 2831 2832 func init() { 2833 types.Add("sms:ReverseReplicateGroupRequestType", reflect.TypeOf((*ReverseReplicateGroupRequestType)(nil)).Elem()) 2834 } 2835 2836 type ReverseReplicateGroup_Task ReverseReplicateGroupRequestType 2837 2838 func init() { 2839 types.Add("sms:ReverseReplicateGroup_Task", reflect.TypeOf((*ReverseReplicateGroup_Task)(nil)).Elem()) 2840 } 2841 2842 type ReverseReplicateGroup_TaskResponse struct { 2843 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 2844 } 2845 2846 // Represents the result of a successful reverse replication action. 2847 // 2848 // The newly 2849 // established replication relation might have a different source group ID and 2850 // different set of target group IDs. This means that the replication topology 2851 // will need to be discovered again by the DR orchestration programs (SRM/CAM). 2852 // However, we assume that after the reverse replication, the new source fault 2853 // domain id remains the same as the old (i.e. before failover) fault domain id. 2854 // 2855 // This structure may be used only with operations rendered under `/sms`. 2856 type ReverseReplicationSuccessResult struct { 2857 GroupOperationResult 2858 2859 // The replication group ID of the newly created source group. 2860 // 2861 // FaultDomainId 2862 // must remain the same. 2863 NewGroupId types.DeviceGroupId `xml:"newGroupId" json:"newGroupId"` 2864 } 2865 2866 func init() { 2867 types.Add("sms:ReverseReplicationSuccessResult", reflect.TypeOf((*ReverseReplicationSuccessResult)(nil)).Elem()) 2868 } 2869 2870 // This exception is thrown if the storage management service 2871 // has not yet been initialized successfully and therefore is 2872 // not ready to process requests. 2873 // 2874 // This structure may be used only with operations rendered under `/sms`. 2875 type ServiceNotInitialized struct { 2876 types.RuntimeFault 2877 } 2878 2879 func init() { 2880 types.Add("sms:ServiceNotInitialized", reflect.TypeOf((*ServiceNotInitialized)(nil)).Elem()) 2881 } 2882 2883 type ServiceNotInitializedFault ServiceNotInitialized 2884 2885 func init() { 2886 types.Add("sms:ServiceNotInitializedFault", reflect.TypeOf((*ServiceNotInitializedFault)(nil)).Elem()) 2887 } 2888 2889 // This data object type describes system information. 2890 // 2891 // This structure may be used only with operations rendered under `/sms`. 2892 type SmsAboutInfo struct { 2893 types.DynamicData 2894 2895 Name string `xml:"name" json:"name"` 2896 FullName string `xml:"fullName" json:"fullName"` 2897 Vendor string `xml:"vendor" json:"vendor"` 2898 ApiVersion string `xml:"apiVersion" json:"apiVersion"` 2899 InstanceUuid string `xml:"instanceUuid" json:"instanceUuid"` 2900 VasaApiVersion string `xml:"vasaApiVersion,omitempty" json:"vasaApiVersion,omitempty"` 2901 } 2902 2903 func init() { 2904 types.Add("sms:SmsAboutInfo", reflect.TypeOf((*SmsAboutInfo)(nil)).Elem()) 2905 } 2906 2907 // Thrown when login fails due to token not provided or token could not be 2908 // validated. 2909 // 2910 // This structure may be used only with operations rendered under `/sms`. 2911 type SmsInvalidLogin struct { 2912 types.MethodFault 2913 } 2914 2915 func init() { 2916 types.Add("sms:SmsInvalidLogin", reflect.TypeOf((*SmsInvalidLogin)(nil)).Elem()) 2917 } 2918 2919 type SmsInvalidLoginFault SmsInvalidLogin 2920 2921 func init() { 2922 types.Add("sms:SmsInvalidLoginFault", reflect.TypeOf((*SmsInvalidLoginFault)(nil)).Elem()) 2923 } 2924 2925 // Information about Storage Monitoring Service (SMS) 2926 // providers. 2927 // 2928 // This structure may be used only with operations rendered under `/sms`. 2929 type SmsProviderInfo struct { 2930 types.DynamicData 2931 2932 // Unique identifier 2933 Uid string `xml:"uid" json:"uid"` 2934 // Name 2935 Name string `xml:"name" json:"name"` 2936 // Description of the provider 2937 Description string `xml:"description,omitempty" json:"description,omitempty"` 2938 // Version of the provider 2939 Version string `xml:"version,omitempty" json:"version,omitempty"` 2940 } 2941 2942 func init() { 2943 types.Add("sms:SmsProviderInfo", reflect.TypeOf((*SmsProviderInfo)(nil)).Elem()) 2944 } 2945 2946 // Specification for Storage Monitoring Service (SMS) 2947 // providers. 2948 // 2949 // This structure may be used only with operations rendered under `/sms`. 2950 type SmsProviderSpec struct { 2951 types.DynamicData 2952 2953 // Name 2954 // The maximum length of the name is 275 characters. 2955 Name string `xml:"name" json:"name"` 2956 // Description of the provider 2957 Description string `xml:"description,omitempty" json:"description,omitempty"` 2958 } 2959 2960 func init() { 2961 types.Add("sms:SmsProviderSpec", reflect.TypeOf((*SmsProviderSpec)(nil)).Elem()) 2962 } 2963 2964 // The parameters of `SmsStorageManager.SmsRefreshCACertificatesAndCRLs_Task`. 2965 // 2966 // This structure may be used only with operations rendered under `/sms`. 2967 type SmsRefreshCACertificatesAndCRLsRequestType struct { 2968 This types.ManagedObjectReference `xml:"_this" json:"_this"` 2969 // `SmsProviderInfo.uid` for providers 2970 ProviderId []string `xml:"providerId,omitempty" json:"providerId,omitempty"` 2971 } 2972 2973 func init() { 2974 types.Add("sms:SmsRefreshCACertificatesAndCRLsRequestType", reflect.TypeOf((*SmsRefreshCACertificatesAndCRLsRequestType)(nil)).Elem()) 2975 } 2976 2977 type SmsRefreshCACertificatesAndCRLs_Task SmsRefreshCACertificatesAndCRLsRequestType 2978 2979 func init() { 2980 types.Add("sms:SmsRefreshCACertificatesAndCRLs_Task", reflect.TypeOf((*SmsRefreshCACertificatesAndCRLs_Task)(nil)).Elem()) 2981 } 2982 2983 type SmsRefreshCACertificatesAndCRLs_TaskResponse struct { 2984 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 2985 } 2986 2987 // Base class for all Replication faults. 2988 // 2989 // This structure may be used only with operations rendered under `/sms`. 2990 type SmsReplicationFault struct { 2991 types.MethodFault 2992 } 2993 2994 func init() { 2995 types.Add("sms:SmsReplicationFault", reflect.TypeOf((*SmsReplicationFault)(nil)).Elem()) 2996 } 2997 2998 type SmsReplicationFaultFault BaseSmsReplicationFault 2999 3000 func init() { 3001 types.Add("sms:SmsReplicationFaultFault", reflect.TypeOf((*SmsReplicationFaultFault)(nil)).Elem()) 3002 } 3003 3004 // A ResourceInUse fault indicating that some error has occurred because 3005 // some resources are in use. 3006 // 3007 // Information about the devices that are in 3008 // use may be supplied. 3009 // 3010 // This structure may be used only with operations rendered under `/sms`. 3011 type SmsResourceInUse struct { 3012 types.ResourceInUse 3013 3014 // The list of device Ids that are in use. 3015 DeviceIds []BaseDeviceId `xml:"deviceIds,omitempty,typeattr" json:"deviceIds,omitempty"` 3016 } 3017 3018 func init() { 3019 types.Add("sms:SmsResourceInUse", reflect.TypeOf((*SmsResourceInUse)(nil)).Elem()) 3020 } 3021 3022 type SmsResourceInUseFault SmsResourceInUse 3023 3024 func init() { 3025 types.Add("sms:SmsResourceInUseFault", reflect.TypeOf((*SmsResourceInUseFault)(nil)).Elem()) 3026 } 3027 3028 // This data object type contains all information about a task. 3029 // 3030 // This structure may be used only with operations rendered under `/sms`. 3031 type SmsTaskInfo struct { 3032 types.DynamicData 3033 3034 // The unique key for the task. 3035 Key string `xml:"key" json:"key"` 3036 // The managed object that represents this task. 3037 // 3038 // Refers instance of `SmsTask`. 3039 Task types.ManagedObjectReference `xml:"task" json:"task"` 3040 // Managed Object to which the operation applies. 3041 Object *types.ManagedObjectReference `xml:"object,omitempty" json:"object,omitempty"` 3042 // If the task state is "error", then this property contains the fault code. 3043 Error *types.LocalizedMethodFault `xml:"error,omitempty" json:"error,omitempty"` 3044 // If the task state is "success", then this property may be used 3045 // to hold a return value. 3046 Result types.AnyType `xml:"result,omitempty,typeattr" json:"result,omitempty"` 3047 // Time stamp when the task started running. 3048 StartTime *time.Time `xml:"startTime" json:"startTime,omitempty"` 3049 // Time stamp when the task was completed (whether success or failure). 3050 CompletionTime *time.Time `xml:"completionTime" json:"completionTime,omitempty"` 3051 // Runtime status of the task. 3052 // 3053 // Possible values are `SmsTaskState_enum` 3054 State string `xml:"state" json:"state"` 3055 // If the task state is "running", then this property contains a 3056 // progress measurement, expressed as percentage completed, from 0 to 100. 3057 // 3058 // If this property is not set, then the command does not report progress. 3059 Progress int32 `xml:"progress,omitempty" json:"progress,omitempty"` 3060 } 3061 3062 func init() { 3063 types.Add("sms:SmsTaskInfo", reflect.TypeOf((*SmsTaskInfo)(nil)).Elem()) 3064 } 3065 3066 // Replication group details on the source. 3067 // 3068 // We do not assume the same 3069 // Replication Group id on all the sites. This is returned as answer to 3070 // queryReplicationGroup. 3071 // 3072 // This structure may be used only with operations rendered under `/sms`. 3073 type SourceGroupInfo struct { 3074 GroupInfo 3075 3076 // Name of the replication group, may be edited after creating the 3077 // Replication Group, not unique. 3078 // 3079 // May be a localized string. Some vendors may 3080 // choose to use name as the group id, to support this, vSphere will not 3081 // allow the name to be modified - even if vSphere creates/manages the 3082 // Replication Group. 3083 Name string `xml:"name,omitempty" json:"name,omitempty"` 3084 // Description the Replication Group, may be edited after creating the 3085 // Replication Group. 3086 // 3087 // May be a localized string. 3088 Description string `xml:"description,omitempty" json:"description,omitempty"` 3089 // State of the replication group on the source. 3090 State string `xml:"state" json:"state"` 3091 // Information about the target Replication Groups. 3092 Replica []ReplicationTargetInfo `xml:"replica,omitempty" json:"replica,omitempty"` 3093 // Information about the member virtual volumes and their replicas. 3094 MemberInfo []SourceGroupMemberInfo `xml:"memberInfo,omitempty" json:"memberInfo,omitempty"` 3095 } 3096 3097 func init() { 3098 types.Add("sms:SourceGroupInfo", reflect.TypeOf((*SourceGroupInfo)(nil)).Elem()) 3099 } 3100 3101 // Represents a member virtual volume of a replication group on the source end 3102 // of the replication arrow. 3103 // 3104 // This structure may be used only with operations rendered under `/sms`. 3105 type SourceGroupMemberInfo struct { 3106 types.DynamicData 3107 3108 // Identifier of the source device. 3109 // 3110 // May be a Virtual Volume, a Virtual Disk or a Virtual Machine 3111 DeviceId BaseDeviceId `xml:"deviceId,typeattr" json:"deviceId"` 3112 // Target devices, key'ed by the fault domain id. 3113 // 3114 // TODO: It is not clear if we 3115 // really need this information, since the target side query can return the 3116 // target -> source relation information. 3117 TargetId []TargetDeviceId `xml:"targetId,omitempty" json:"targetId,omitempty"` 3118 } 3119 3120 func init() { 3121 types.Add("sms:SourceGroupMemberInfo", reflect.TypeOf((*SourceGroupMemberInfo)(nil)).Elem()) 3122 } 3123 3124 // This data object represents the storage alarm. 3125 // 3126 // This structure may be used only with operations rendered under `/sms`. 3127 type StorageAlarm struct { 3128 types.DynamicData 3129 3130 // Monotonically increasing sequence number which 3131 // VP will maintain. 3132 AlarmId int64 `xml:"alarmId" json:"alarmId"` 3133 // The type of Alarm. 3134 // 3135 // Must be one of the string values from 3136 // `AlarmType_enum` 3137 // Note that for VMODL VP implemenation this field must be populated with one 3138 // of the values from `vasa.data.notification.AlarmType` 3139 AlarmType string `xml:"alarmType" json:"alarmType"` 3140 // Container identifier 3141 ContainerId string `xml:"containerId,omitempty" json:"containerId,omitempty"` 3142 // The unique identifier of the object impacted by the Alarm. 3143 // 3144 // From VASA version 3 onwards, a non-null `StorageAlarm.alarmObject` 3145 // will override this member. 3146 // This field is made optional from VASA3. Either this or 3147 // `StorageAlarm.alarmObject` must be set. 3148 ObjectId string `xml:"objectId,omitempty" json:"objectId,omitempty"` 3149 // The type of object impacted by the Alarm. 3150 // 3151 // Must be one of the string values 3152 // from `SmsEntityType_enum` 3153 // Note that for VMODL VP implemenation this field must be populated with one 3154 // of the values from `vasa.data.notification.EntityType` 3155 ObjectType string `xml:"objectType" json:"objectType"` 3156 // Current status of the object. 3157 // 3158 // Must be one of the string values from 3159 // `SmsAlarmStatus_enum` 3160 Status string `xml:"status" json:"status"` 3161 // Time-stamp when the alarm occurred in VP context 3162 AlarmTimeStamp time.Time `xml:"alarmTimeStamp" json:"alarmTimeStamp"` 3163 // Pre-defined message for system-defined event 3164 MessageId string `xml:"messageId" json:"messageId"` 3165 // List of parameters (name/value) to be passed as input for message 3166 ParameterList []NameValuePair `xml:"parameterList,omitempty" json:"parameterList,omitempty"` 3167 // The ID of the object on which the alarm is raised; this is an object, 3168 // since ID's may not always be strings. 3169 // 3170 // vSphere will first use 3171 // `StorageAlarm.alarmObject` if set, and if not uses `StorageAlarm.objectId`. 3172 AlarmObject types.AnyType `xml:"alarmObject,omitempty,typeattr" json:"alarmObject,omitempty"` 3173 } 3174 3175 func init() { 3176 types.Add("sms:StorageAlarm", reflect.TypeOf((*StorageAlarm)(nil)).Elem()) 3177 } 3178 3179 // This data object represents the storage array. 3180 // 3181 // This structure may be used only with operations rendered under `/sms`. 3182 type StorageArray struct { 3183 types.DynamicData 3184 3185 // Name 3186 Name string `xml:"name" json:"name"` 3187 // Unique identifier 3188 Uuid string `xml:"uuid" json:"uuid"` 3189 // Storage array Vendor Id 3190 VendorId string `xml:"vendorId" json:"vendorId"` 3191 // Model Id 3192 ModelId string `xml:"modelId" json:"modelId"` 3193 // Storage array firmware 3194 Firmware string `xml:"firmware,omitempty" json:"firmware,omitempty"` 3195 // List of alternate storage array names 3196 AlternateName []string `xml:"alternateName,omitempty" json:"alternateName,omitempty"` 3197 // Supported block-device interfaces 3198 SupportedBlockInterface []string `xml:"supportedBlockInterface,omitempty" json:"supportedBlockInterface,omitempty"` 3199 // Supported file-system interfaces 3200 SupportedFileSystemInterface []string `xml:"supportedFileSystemInterface,omitempty" json:"supportedFileSystemInterface,omitempty"` 3201 // List of supported profiles 3202 SupportedProfile []string `xml:"supportedProfile,omitempty" json:"supportedProfile,omitempty"` 3203 // Deprecated as of SMS API 6.0, replaced by `VasaProviderInfo.priority`. 3204 // 3205 // Priority level of the provider for the given array within the session context. 3206 // 3207 // SMS will use this value to pick a provider among the ones that are registered 3208 // with SMS and manage this array. Once the provider is chosen, SMS will communicate 3209 // with it to get the data related to this array. 3210 // Valid range: 0 to 255. 3211 Priority int32 `xml:"priority,omitempty" json:"priority,omitempty"` 3212 // Required for NVMe-oF arrays and optional otherwise. 3213 // 3214 // Transport information to address the array's discovery service. 3215 DiscoverySvc []types.VASAStorageArrayDiscoverySvcInfo `xml:"discoverySvc,omitempty" json:"discoverySvc,omitempty"` 3216 } 3217 3218 func init() { 3219 types.Add("sms:StorageArray", reflect.TypeOf((*StorageArray)(nil)).Elem()) 3220 } 3221 3222 // This data object represents the storage capability. 3223 // 3224 // This structure may be used only with operations rendered under `/sms`. 3225 type StorageCapability struct { 3226 types.DynamicData 3227 3228 Uuid string `xml:"uuid" json:"uuid"` 3229 Name string `xml:"name" json:"name"` 3230 Description string `xml:"description" json:"description"` 3231 } 3232 3233 func init() { 3234 types.Add("sms:StorageCapability", reflect.TypeOf((*StorageCapability)(nil)).Elem()) 3235 } 3236 3237 // This data object represents the storage container. 3238 // 3239 // This structure may be used only with operations rendered under `/sms`. 3240 type StorageContainer struct { 3241 types.DynamicData 3242 3243 // Unique identifier 3244 Uuid string `xml:"uuid" json:"uuid"` 3245 // Name of the container 3246 Name string `xml:"name" json:"name"` 3247 // Maximum allowed capacity of the Virtual Volume in MBs 3248 MaxVvolSizeInMB int64 `xml:"maxVvolSizeInMB" json:"maxVvolSizeInMB"` 3249 // `SmsProviderInfo.uid` for providers that reports the storage container. 3250 ProviderId []string `xml:"providerId" json:"providerId"` 3251 ArrayId []string `xml:"arrayId" json:"arrayId"` 3252 // Represents type of VVOL container, the supported values are listed in 3253 // `StorageContainerVvolContainerTypeEnum_enum`. 3254 // 3255 // If the storage array is not capable of supporting mixed PEs for a storage container, 3256 // the VVOL VASA provider sets this property to the supported endpoint type 3257 VvolContainerType string `xml:"vvolContainerType,omitempty" json:"vvolContainerType,omitempty"` 3258 // Indicates if this storage container is stretched 3259 Stretched *bool `xml:"stretched" json:"stretched,omitempty"` 3260 } 3261 3262 func init() { 3263 types.Add("sms:StorageContainer", reflect.TypeOf((*StorageContainer)(nil)).Elem()) 3264 } 3265 3266 // This data object represents information about storage containers and related providers. 3267 // 3268 // This structure may be used only with operations rendered under `/sms`. 3269 type StorageContainerResult struct { 3270 types.DynamicData 3271 3272 // `StorageContainer` objects 3273 StorageContainer []StorageContainer `xml:"storageContainer,omitempty" json:"storageContainer,omitempty"` 3274 // `SmsProviderInfo` corresponding to providers that 3275 // report these storage containers 3276 ProviderInfo []BaseSmsProviderInfo `xml:"providerInfo,omitempty,typeattr" json:"providerInfo,omitempty"` 3277 } 3278 3279 func init() { 3280 types.Add("sms:StorageContainerResult", reflect.TypeOf((*StorageContainerResult)(nil)).Elem()) 3281 } 3282 3283 // This data object represents the specification to query 3284 // storage containers retrieved from VASA providers. 3285 // 3286 // This structure may be used only with operations rendered under `/sms`. 3287 type StorageContainerSpec struct { 3288 types.DynamicData 3289 3290 ContainerId []string `xml:"containerId,omitempty" json:"containerId,omitempty"` 3291 } 3292 3293 func init() { 3294 types.Add("sms:StorageContainerSpec", reflect.TypeOf((*StorageContainerSpec)(nil)).Elem()) 3295 } 3296 3297 // This data object represents the storage file-system. 3298 // 3299 // This structure may be used only with operations rendered under `/sms`. 3300 type StorageFileSystem struct { 3301 types.DynamicData 3302 3303 // Unique identifier 3304 Uuid string `xml:"uuid" json:"uuid"` 3305 // Information about the file system 3306 Info []StorageFileSystemInfo `xml:"info" json:"info"` 3307 NativeSnapshotSupported bool `xml:"nativeSnapshotSupported" json:"nativeSnapshotSupported"` 3308 ThinProvisioningStatus string `xml:"thinProvisioningStatus" json:"thinProvisioningStatus"` 3309 Type string `xml:"type" json:"type"` 3310 Version string `xml:"version" json:"version"` 3311 // Backing config information 3312 BackingConfig *BackingConfig `xml:"backingConfig,omitempty" json:"backingConfig,omitempty"` 3313 } 3314 3315 func init() { 3316 types.Add("sms:StorageFileSystem", reflect.TypeOf((*StorageFileSystem)(nil)).Elem()) 3317 } 3318 3319 // This data object represents information about the storage 3320 // file-system. 3321 // 3322 // This structure may be used only with operations rendered under `/sms`. 3323 type StorageFileSystemInfo struct { 3324 types.DynamicData 3325 3326 // Server Name 3327 FileServerName string `xml:"fileServerName" json:"fileServerName"` 3328 // File Path 3329 FileSystemPath string `xml:"fileSystemPath" json:"fileSystemPath"` 3330 // IP address 3331 IpAddress string `xml:"ipAddress,omitempty" json:"ipAddress,omitempty"` 3332 } 3333 3334 func init() { 3335 types.Add("sms:StorageFileSystemInfo", reflect.TypeOf((*StorageFileSystemInfo)(nil)).Elem()) 3336 } 3337 3338 // This data object represents the storage lun. 3339 // 3340 // This structure may be used only with operations rendered under `/sms`. 3341 type StorageLun struct { 3342 types.DynamicData 3343 3344 // Unique Indentfier 3345 Uuid string `xml:"uuid" json:"uuid"` 3346 // Identifer reported by vSphere(ESX) for this LUN 3347 VSphereLunIdentifier string `xml:"vSphereLunIdentifier" json:"vSphereLunIdentifier"` 3348 // Display Name which appears in storage array management 3349 // console 3350 VendorDisplayName string `xml:"vendorDisplayName" json:"vendorDisplayName"` 3351 // Capacity In MB 3352 CapacityInMB int64 `xml:"capacityInMB" json:"capacityInMB"` 3353 // Used space in MB for a thin provisioned LUN 3354 UsedSpaceInMB int64 `xml:"usedSpaceInMB" json:"usedSpaceInMB"` 3355 // Indicates whether the LUN is thin provisioned 3356 LunThinProvisioned bool `xml:"lunThinProvisioned" json:"lunThinProvisioned"` 3357 // Alternate identifiers associated with the LUN 3358 AlternateIdentifier []string `xml:"alternateIdentifier,omitempty" json:"alternateIdentifier,omitempty"` 3359 // Indicates whether Storage DRS is permitted to manage 3360 // performance between this LUN and other LUNs from the same 3361 // array. 3362 DrsManagementPermitted bool `xml:"drsManagementPermitted" json:"drsManagementPermitted"` 3363 ThinProvisioningStatus string `xml:"thinProvisioningStatus" json:"thinProvisioningStatus"` 3364 // Backing config information 3365 BackingConfig *BackingConfig `xml:"backingConfig,omitempty" json:"backingConfig,omitempty"` 3366 } 3367 3368 func init() { 3369 types.Add("sms:StorageLun", reflect.TypeOf((*StorageLun)(nil)).Elem()) 3370 } 3371 3372 // This data object represents the storage port. 3373 // 3374 // This structure may be used only with operations rendered under `/sms`. 3375 type StoragePort struct { 3376 types.DynamicData 3377 3378 // Unique identifier 3379 Uuid string `xml:"uuid" json:"uuid"` 3380 // Storage Port Type 3381 Type string `xml:"type" json:"type"` 3382 // Other identifiers which can help identify storage port 3383 AlternateName []string `xml:"alternateName,omitempty" json:"alternateName,omitempty"` 3384 } 3385 3386 func init() { 3387 types.Add("sms:StoragePort", reflect.TypeOf((*StoragePort)(nil)).Elem()) 3388 } 3389 3390 // This data object represents the storage processor. 3391 // 3392 // This structure may be used only with operations rendered under `/sms`. 3393 type StorageProcessor struct { 3394 types.DynamicData 3395 3396 // Unique Identifier 3397 Uuid string `xml:"uuid" json:"uuid"` 3398 // List of alternate identifiers 3399 AlternateIdentifer []string `xml:"alternateIdentifer,omitempty" json:"alternateIdentifer,omitempty"` 3400 } 3401 3402 func init() { 3403 types.Add("sms:StorageProcessor", reflect.TypeOf((*StorageProcessor)(nil)).Elem()) 3404 } 3405 3406 // Mapping between the supported vendorID and corresponding 3407 // modelID 3408 // 3409 // This structure may be used only with operations rendered under `/sms`. 3410 type SupportedVendorModelMapping struct { 3411 types.DynamicData 3412 3413 // SCSI Vendor ID 3414 VendorId string `xml:"vendorId,omitempty" json:"vendorId,omitempty"` 3415 // SCSI Model ID 3416 ModelId string `xml:"modelId,omitempty" json:"modelId,omitempty"` 3417 } 3418 3419 func init() { 3420 types.Add("sms:SupportedVendorModelMapping", reflect.TypeOf((*SupportedVendorModelMapping)(nil)).Elem()) 3421 } 3422 3423 // This exception is thrown if a sync operation is invoked 3424 // while another sync invocation is in progress. 3425 // 3426 // This structure may be used only with operations rendered under `/sms`. 3427 type SyncInProgress struct { 3428 ProviderSyncFailed 3429 } 3430 3431 func init() { 3432 types.Add("sms:SyncInProgress", reflect.TypeOf((*SyncInProgress)(nil)).Elem()) 3433 } 3434 3435 type SyncInProgressFault SyncInProgress 3436 3437 func init() { 3438 types.Add("sms:SyncInProgressFault", reflect.TypeOf((*SyncInProgressFault)(nil)).Elem()) 3439 } 3440 3441 // Throw if an synchronization is ongoing. 3442 // 3443 // This structure may be used only with operations rendered under `/sms`. 3444 type SyncOngoing struct { 3445 SmsReplicationFault 3446 3447 // Task identifier of the ongoing sync (@see sms.TaskInfo#key). 3448 // 3449 // Refers instance of `SmsTask`. 3450 Task types.ManagedObjectReference `xml:"task" json:"task"` 3451 } 3452 3453 func init() { 3454 types.Add("sms:SyncOngoing", reflect.TypeOf((*SyncOngoing)(nil)).Elem()) 3455 } 3456 3457 type SyncOngoingFault SyncOngoing 3458 3459 func init() { 3460 types.Add("sms:SyncOngoingFault", reflect.TypeOf((*SyncOngoingFault)(nil)).Elem()) 3461 } 3462 3463 // The parameters of `VasaProvider.SyncReplicationGroup_Task`. 3464 // 3465 // This structure may be used only with operations rendered under `/sms`. 3466 type SyncReplicationGroupRequestType struct { 3467 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3468 // List of replication group IDs. 3469 GroupId []types.ReplicationGroupId `xml:"groupId,omitempty" json:"groupId,omitempty"` 3470 // Localized name for the point-in-time snapshot created. 3471 PitName string `xml:"pitName" json:"pitName"` 3472 } 3473 3474 func init() { 3475 types.Add("sms:SyncReplicationGroupRequestType", reflect.TypeOf((*SyncReplicationGroupRequestType)(nil)).Elem()) 3476 } 3477 3478 // Result object for a replication group that was successfully synchronized. 3479 // 3480 // This structure may be used only with operations rendered under `/sms`. 3481 type SyncReplicationGroupSuccessResult struct { 3482 GroupOperationResult 3483 3484 // Creation time of the PIT 3485 TimeStamp time.Time `xml:"timeStamp" json:"timeStamp"` 3486 // PIT id. 3487 // 3488 // If the VASA provider does not support PIT, this can be 3489 // left unset. 3490 // 3491 // A PIT created as a result of the <code>syncReplicationGroup</code> 3492 // may or may not have the same retention policy as other PITs. A VASA provider 3493 // can choose to delete such a PIT after a successful <code>testFailoverStop</code> 3494 PitId *PointInTimeReplicaId `xml:"pitId,omitempty" json:"pitId,omitempty"` 3495 PitName string `xml:"pitName,omitempty" json:"pitName,omitempty"` 3496 } 3497 3498 func init() { 3499 types.Add("sms:SyncReplicationGroupSuccessResult", reflect.TypeOf((*SyncReplicationGroupSuccessResult)(nil)).Elem()) 3500 } 3501 3502 type SyncReplicationGroup_Task SyncReplicationGroupRequestType 3503 3504 func init() { 3505 types.Add("sms:SyncReplicationGroup_Task", reflect.TypeOf((*SyncReplicationGroup_Task)(nil)).Elem()) 3506 } 3507 3508 type SyncReplicationGroup_TaskResponse struct { 3509 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 3510 } 3511 3512 // Represents a replication target device, since the replication group id can 3513 // be the same in all the domains, this is keyed by the fault domain id. 3514 // 3515 // This structure may be used only with operations rendered under `/sms`. 3516 type TargetDeviceId struct { 3517 types.DynamicData 3518 3519 // ID of the fault domain. 3520 DomainId types.FaultDomainId `xml:"domainId" json:"domainId"` 3521 // ID of the target device. 3522 DeviceId ReplicaId `xml:"deviceId" json:"deviceId"` 3523 } 3524 3525 func init() { 3526 types.Add("sms:TargetDeviceId", reflect.TypeOf((*TargetDeviceId)(nil)).Elem()) 3527 } 3528 3529 // Information about the replication target group. 3530 // 3531 // This is returned as answer 3532 // to queryReplicationGroup before failover or testFailoverStart. 3533 // 3534 // This does not have to include the 3535 // snapshot objects in the ReplicationGroup, however, see also 3536 // `RecoveredTargetGroupMemberInfo`. 3537 // 3538 // This structure may be used only with operations rendered under `/sms`. 3539 type TargetGroupInfo struct { 3540 GroupInfo 3541 3542 // Replication source information. 3543 SourceInfo TargetToSourceInfo `xml:"sourceInfo" json:"sourceInfo"` 3544 // Replication state of the group on the replication target. 3545 State string `xml:"state" json:"state"` 3546 // Member device information. 3547 // 3548 // When the ReplicationGroup is either in `FAILEDOVER` 3549 // or `INTEST`, this 3550 // should be `RecoveredTargetGroupMemberInfo`. 3551 // Otherwise, this should be `TargetGroupMemberInfo` 3552 Devices []BaseTargetGroupMemberInfo `xml:"devices,omitempty,typeattr" json:"devices,omitempty"` 3553 // Whether the VASA provider is capable of executing 3554 // `VasaProvider.PromoteReplicationGroup_Task` for this 3555 // ReplicationGroup. 3556 // 3557 // False if not set. Note that this setting is per 3558 // ReplicationGroup per Target domain. 3559 IsPromoteCapable *bool `xml:"isPromoteCapable" json:"isPromoteCapable,omitempty"` 3560 // Name of Replication Group. 3561 Name string `xml:"name,omitempty" json:"name,omitempty"` 3562 } 3563 3564 func init() { 3565 types.Add("sms:TargetGroupInfo", reflect.TypeOf((*TargetGroupInfo)(nil)).Elem()) 3566 } 3567 3568 // Information about member virtual volumes in a ReplicationGroup 3569 // on the target when the state is `TARGET`. 3570 // 3571 // This need not include information about all the snapshots in 3572 // the ReplicationGroup. 3573 // 3574 // This structure may be used only with operations rendered under `/sms`. 3575 type TargetGroupMemberInfo struct { 3576 types.DynamicData 3577 3578 // Identifier of the replica device. 3579 ReplicaId ReplicaId `xml:"replicaId" json:"replicaId"` 3580 // Source device, since the device id can be the same in all the domains, 3581 // this needs to supplemented with the domain id to identify the device. 3582 SourceId BaseDeviceId `xml:"sourceId,typeattr" json:"sourceId"` 3583 // Datastore of the target device. 3584 // 3585 // This may be used by CAM/SRM 3586 // to notify the administrators to setup access paths for the hosts 3587 // to access the recovered devices. 3588 // 3589 // Refers instance of `Datastore`. 3590 TargetDatastore types.ManagedObjectReference `xml:"targetDatastore" json:"targetDatastore"` 3591 } 3592 3593 func init() { 3594 types.Add("sms:TargetGroupMemberInfo", reflect.TypeOf((*TargetGroupMemberInfo)(nil)).Elem()) 3595 } 3596 3597 // Information about each replication target. 3598 // 3599 // This structure may be used only with operations rendered under `/sms`. 3600 type TargetToSourceInfo struct { 3601 types.DynamicData 3602 3603 // Id of the source CG id (including the fault domain ID). 3604 SourceGroupId types.ReplicationGroupId `xml:"sourceGroupId" json:"sourceGroupId"` 3605 // Description of the replication agreement. 3606 // 3607 // This could be used to describe the characteristics of the replication 3608 // relationship between the source and the target (e.g. RPO, Replication 3609 // Mode, and other such properties). It is expected that VASA provider 3610 // will localize the string before sending to vSphere. 3611 ReplicationAgreementDescription string `xml:"replicationAgreementDescription,omitempty" json:"replicationAgreementDescription,omitempty"` 3612 } 3613 3614 func init() { 3615 types.Add("sms:TargetToSourceInfo", reflect.TypeOf((*TargetToSourceInfo)(nil)).Elem()) 3616 } 3617 3618 // Input to testFailover method. 3619 // 3620 // This structure may be used only with operations rendered under `/sms`. 3621 type TestFailoverParam struct { 3622 FailoverParam 3623 } 3624 3625 func init() { 3626 types.Add("sms:TestFailoverParam", reflect.TypeOf((*TestFailoverParam)(nil)).Elem()) 3627 } 3628 3629 // The parameters of `VasaProvider.TestFailoverReplicationGroupStart_Task`. 3630 // 3631 // This structure may be used only with operations rendered under `/sms`. 3632 type TestFailoverReplicationGroupStartRequestType struct { 3633 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3634 // Settings for the failover. 3635 TestFailoverParam TestFailoverParam `xml:"testFailoverParam" json:"testFailoverParam"` 3636 } 3637 3638 func init() { 3639 types.Add("sms:TestFailoverReplicationGroupStartRequestType", reflect.TypeOf((*TestFailoverReplicationGroupStartRequestType)(nil)).Elem()) 3640 } 3641 3642 type TestFailoverReplicationGroupStart_Task TestFailoverReplicationGroupStartRequestType 3643 3644 func init() { 3645 types.Add("sms:TestFailoverReplicationGroupStart_Task", reflect.TypeOf((*TestFailoverReplicationGroupStart_Task)(nil)).Elem()) 3646 } 3647 3648 type TestFailoverReplicationGroupStart_TaskResponse struct { 3649 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 3650 } 3651 3652 // The parameters of `VasaProvider.TestFailoverReplicationGroupStop_Task`. 3653 // 3654 // This structure may be used only with operations rendered under `/sms`. 3655 type TestFailoverReplicationGroupStopRequestType struct { 3656 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3657 // Array of replication groups that need to stop test. 3658 GroupId []types.ReplicationGroupId `xml:"groupId,omitempty" json:"groupId,omitempty"` 3659 // \- if true, VP should force-unbind all Virtual Volumes 3660 // and move the RG from INTEST to TARGET state. If false, VP will report all the 3661 // Virtual Volumes which need to be cleaned up before a failover operation 3662 // can be triggered. The default value will be false. 3663 Force bool `xml:"force" json:"force"` 3664 } 3665 3666 func init() { 3667 types.Add("sms:TestFailoverReplicationGroupStopRequestType", reflect.TypeOf((*TestFailoverReplicationGroupStopRequestType)(nil)).Elem()) 3668 } 3669 3670 type TestFailoverReplicationGroupStop_Task TestFailoverReplicationGroupStopRequestType 3671 3672 func init() { 3673 types.Add("sms:TestFailoverReplicationGroupStop_Task", reflect.TypeOf((*TestFailoverReplicationGroupStop_Task)(nil)).Elem()) 3674 } 3675 3676 type TestFailoverReplicationGroupStop_TaskResponse struct { 3677 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 3678 } 3679 3680 // This exception is thrown if the request exceeds the maximum number of 3681 // elements in batch that the VASA Provider can support for the specific API. 3682 // 3683 // This structure may be used only with operations rendered under `/sms`. 3684 type TooMany struct { 3685 types.MethodFault 3686 3687 // Maximum number of elements in batch that the VASA Provider can support 3688 // for the specific API. 3689 // 3690 // If the value is not specified (zero) or invalid 3691 // (negative), client will assume the default value is 1. 3692 MaxBatchSize int64 `xml:"maxBatchSize,omitempty" json:"maxBatchSize,omitempty"` 3693 } 3694 3695 func init() { 3696 types.Add("sms:TooMany", reflect.TypeOf((*TooMany)(nil)).Elem()) 3697 } 3698 3699 type TooManyFault TooMany 3700 3701 func init() { 3702 types.Add("sms:TooManyFault", reflect.TypeOf((*TooManyFault)(nil)).Elem()) 3703 } 3704 3705 // The parameters of `SmsStorageManager.UnregisterProvider_Task`. 3706 // 3707 // This structure may be used only with operations rendered under `/sms`. 3708 type UnregisterProviderRequestType struct { 3709 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3710 // `SmsProviderInfo.uid` for 3711 // the provider 3712 ProviderId string `xml:"providerId" json:"providerId"` 3713 } 3714 3715 func init() { 3716 types.Add("sms:UnregisterProviderRequestType", reflect.TypeOf((*UnregisterProviderRequestType)(nil)).Elem()) 3717 } 3718 3719 type UnregisterProvider_Task UnregisterProviderRequestType 3720 3721 func init() { 3722 types.Add("sms:UnregisterProvider_Task", reflect.TypeOf((*UnregisterProvider_Task)(nil)).Elem()) 3723 } 3724 3725 type UnregisterProvider_TaskResponse struct { 3726 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 3727 } 3728 3729 // Identity of a virtual volume for policy API purposes. 3730 // 3731 // For the sake of 3732 // brevity, let us use VVolId. This works because the class is defined as a part 3733 // of the policy package. 3734 // 3735 // WSDL names do not have this feature, but WSDL names are usually prefixed with 3736 // the package name any way. 3737 // 3738 // This structure may be used only with operations rendered under `/sms`. 3739 type VVolId struct { 3740 DeviceId 3741 3742 Id string `xml:"id" json:"id"` 3743 } 3744 3745 func init() { 3746 types.Add("sms:VVolId", reflect.TypeOf((*VVolId)(nil)).Elem()) 3747 } 3748 3749 // Information about VASA (vStorage APIs for Storage Awareness) providers. 3750 // 3751 // This structure may be used only with operations rendered under `/sms`. 3752 type VasaProviderInfo struct { 3753 SmsProviderInfo 3754 3755 // Provider URL 3756 Url string `xml:"url" json:"url"` 3757 // Provider certificate 3758 Certificate string `xml:"certificate,omitempty" json:"certificate,omitempty"` 3759 // The operational state of VASA Provider. 3760 Status string `xml:"status,omitempty" json:"status,omitempty"` 3761 // A fault that describes the cause of the current operational status. 3762 StatusFault *types.LocalizedMethodFault `xml:"statusFault,omitempty" json:"statusFault,omitempty"` 3763 // Supported VASA(vStorage APIs for Storage Awareness) version 3764 VasaVersion string `xml:"vasaVersion,omitempty" json:"vasaVersion,omitempty"` 3765 // Namespace to categorize storage capabilities provided by 3766 // arrays managed by the provider 3767 Namespace string `xml:"namespace,omitempty" json:"namespace,omitempty"` 3768 // Time stamp to indicate when last sync operation was completed 3769 // successfully. 3770 LastSyncTime string `xml:"lastSyncTime,omitempty" json:"lastSyncTime,omitempty"` 3771 // List containing mapping between the supported vendorID and 3772 // corresponding modelID 3773 SupportedVendorModelMapping []SupportedVendorModelMapping `xml:"supportedVendorModelMapping,omitempty" json:"supportedVendorModelMapping,omitempty"` 3774 // Deprecated as of SMS API 3.0, use `StorageArray.supportedProfile`. 3775 // 3776 // List of supported profiles 3777 SupportedProfile []string `xml:"supportedProfile,omitempty" json:"supportedProfile,omitempty"` 3778 // List of supported profiles at provider level. 3779 // 3780 // Must be one of the string 3781 // values from `ProviderProfile_enum`. 3782 SupportedProviderProfile []string `xml:"supportedProviderProfile,omitempty" json:"supportedProviderProfile,omitempty"` 3783 // List containing mapping between storage arrays reported by the provider 3784 // and information such as whether the provider is considered active for them. 3785 RelatedStorageArray []RelatedStorageArray `xml:"relatedStorageArray,omitempty" json:"relatedStorageArray,omitempty"` 3786 // Provider identifier reported by the provider which is unique within 3787 // the provider namespace. 3788 ProviderId string `xml:"providerId,omitempty" json:"providerId,omitempty"` 3789 // Provider certificate expiry date. 3790 CertificateExpiryDate string `xml:"certificateExpiryDate,omitempty" json:"certificateExpiryDate,omitempty"` 3791 // Provider certificate status 3792 // This field holds values from `VasaProviderCertificateStatus_enum` 3793 CertificateStatus string `xml:"certificateStatus,omitempty" json:"certificateStatus,omitempty"` 3794 // Service location for the VASA endpoint that SMS is using 3795 // to communicate with the provider. 3796 ServiceLocation string `xml:"serviceLocation,omitempty" json:"serviceLocation,omitempty"` 3797 // Indicates the type of deployment supported by the provider. 3798 // 3799 // If true, it is an active/passive deployment and the provider needs to be 3800 // activated explicitly using activateProviderEx() VASA API. 3801 // If false, it is an active/active deployment and provider does not need any 3802 // explicit activation to respond to VASA calls. 3803 NeedsExplicitActivation *bool `xml:"needsExplicitActivation" json:"needsExplicitActivation,omitempty"` 3804 // Maximum number of elements in batch APIs that the VASA Provider can support. 3805 // 3806 // This value is common to all batch APIs supported by the provider. However, 3807 // for each specific API, the provider may still throw or return `TooMany` 3808 // fault in which a different value of maxBatchSize can be specified. 3809 // If the value is not specified (zero) or invalid (negative), client will 3810 // assume there's no common limit for the number of elements that can be 3811 // handled in all batch APIs. 3812 MaxBatchSize int64 `xml:"maxBatchSize,omitempty" json:"maxBatchSize,omitempty"` 3813 // Indicate whether the provider wants to retain its certificate after bootstrapping. 3814 // 3815 // If true, SMS will not provision a VMCA signed certificate for the provider 3816 // and all certificate life cycle management workflows are disabled for this provider certificate. 3817 // If false, SMS will provision a VMCA signed certificate for the provider and 3818 // all certificate life cycle management workflows are enabled for this provider certificate. 3819 RetainVasaProviderCertificate *bool `xml:"retainVasaProviderCertificate" json:"retainVasaProviderCertificate,omitempty"` 3820 // Indicates if this provider is independent of arrays. 3821 // 3822 // Default value for this flag is false, which means this provider supports 3823 // arrays. Arrays will be queried for this provider during sync. If this flag 3824 // is set to true, arrays will not be synced for this provider and array 3825 // related API will not be invoked on this provider. 3826 ArrayIndependentProvider *bool `xml:"arrayIndependentProvider" json:"arrayIndependentProvider,omitempty"` 3827 // Type of this VASA provider. 3828 // 3829 // This field will be equal to one of the values of `VpType_enum`. 3830 Type string `xml:"type,omitempty" json:"type,omitempty"` 3831 // This field indicates the category of the provider and will be equal to one of the values of 3832 // `VpCategory_enum`. 3833 Category string `xml:"category,omitempty" json:"category,omitempty"` 3834 // Priority level of the provider within a VASA HA group. 3835 // 3836 // For a stand-alone 3837 // provider which does not participate in VASA HA, this field will be ignored. 3838 // 3839 // The priority value is an integer with valid range from 0 to 255. 3840 Priority int32 `xml:"priority,omitempty" json:"priority,omitempty"` 3841 // Unique identifier of a VASA HA group. 3842 // 3843 // Providers should report this 3844 // identifier to utilize HA feature supported by vSphere. Different providers 3845 // reporting the same <code>failoverGroupId</code> will be treated as an HA 3846 // group. Failover/failback will be done within one group. 3847 FailoverGroupId string `xml:"failoverGroupId,omitempty" json:"failoverGroupId,omitempty"` 3848 } 3849 3850 func init() { 3851 types.Add("sms:VasaProviderInfo", reflect.TypeOf((*VasaProviderInfo)(nil)).Elem()) 3852 } 3853 3854 type VasaProviderReconnectRequestType struct { 3855 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3856 } 3857 3858 func init() { 3859 types.Add("sms:VasaProviderReconnectRequestType", reflect.TypeOf((*VasaProviderReconnectRequestType)(nil)).Elem()) 3860 } 3861 3862 type VasaProviderReconnect_Task VasaProviderReconnectRequestType 3863 3864 func init() { 3865 types.Add("sms:VasaProviderReconnect_Task", reflect.TypeOf((*VasaProviderReconnect_Task)(nil)).Elem()) 3866 } 3867 3868 type VasaProviderReconnect_TaskResponse struct { 3869 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 3870 } 3871 3872 type VasaProviderRefreshCertificateRequestType struct { 3873 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3874 } 3875 3876 func init() { 3877 types.Add("sms:VasaProviderRefreshCertificateRequestType", reflect.TypeOf((*VasaProviderRefreshCertificateRequestType)(nil)).Elem()) 3878 } 3879 3880 type VasaProviderRefreshCertificate_Task VasaProviderRefreshCertificateRequestType 3881 3882 func init() { 3883 types.Add("sms:VasaProviderRefreshCertificate_Task", reflect.TypeOf((*VasaProviderRefreshCertificate_Task)(nil)).Elem()) 3884 } 3885 3886 type VasaProviderRefreshCertificate_TaskResponse struct { 3887 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 3888 } 3889 3890 type VasaProviderRevokeCertificateRequestType struct { 3891 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3892 } 3893 3894 func init() { 3895 types.Add("sms:VasaProviderRevokeCertificateRequestType", reflect.TypeOf((*VasaProviderRevokeCertificateRequestType)(nil)).Elem()) 3896 } 3897 3898 type VasaProviderRevokeCertificate_Task VasaProviderRevokeCertificateRequestType 3899 3900 func init() { 3901 types.Add("sms:VasaProviderRevokeCertificate_Task", reflect.TypeOf((*VasaProviderRevokeCertificate_Task)(nil)).Elem()) 3902 } 3903 3904 type VasaProviderRevokeCertificate_TaskResponse struct { 3905 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 3906 } 3907 3908 // VASA(vStorage APIs for Storage Awareness) provider 3909 // specification 3910 // 3911 // This structure may be used only with operations rendered under `/sms`. 3912 type VasaProviderSpec struct { 3913 SmsProviderSpec 3914 3915 // Username 3916 // The maximum length of the username is 255 characters. 3917 Username string `xml:"username" json:"username"` 3918 // Password 3919 // The maximum length of the password is 255 characters. 3920 Password string `xml:"password" json:"password"` 3921 // URL 3922 Url string `xml:"url" json:"url"` 3923 // Certificate 3924 Certificate string `xml:"certificate,omitempty" json:"certificate,omitempty"` 3925 } 3926 3927 func init() { 3928 types.Add("sms:VasaProviderSpec", reflect.TypeOf((*VasaProviderSpec)(nil)).Elem()) 3929 } 3930 3931 // The parameters of `VasaProvider.VasaProviderSync_Task`. 3932 // 3933 // This structure may be used only with operations rendered under `/sms`. 3934 type VasaProviderSyncRequestType struct { 3935 This types.ManagedObjectReference `xml:"_this" json:"_this"` 3936 ArrayId string `xml:"arrayId,omitempty" json:"arrayId,omitempty"` 3937 } 3938 3939 func init() { 3940 types.Add("sms:VasaProviderSyncRequestType", reflect.TypeOf((*VasaProviderSyncRequestType)(nil)).Elem()) 3941 } 3942 3943 type VasaProviderSync_Task VasaProviderSyncRequestType 3944 3945 func init() { 3946 types.Add("sms:VasaProviderSync_Task", reflect.TypeOf((*VasaProviderSync_Task)(nil)).Elem()) 3947 } 3948 3949 type VasaProviderSync_TaskResponse struct { 3950 Returnval types.ManagedObjectReference `xml:"returnval" json:"returnval"` 3951 } 3952 3953 // Represents a virtual disk with a UUID (aka FCD). 3954 // 3955 // Virtual Volume VASA providers can ignore this class. 3956 // 3957 // This structure may be used only with operations rendered under `/sms`. 3958 type VasaVirtualDiskId struct { 3959 DeviceId 3960 3961 // See VIM documentation for more details on first class storage - which is 3962 // new in 2016. 3963 DiskId string `xml:"diskId" json:"diskId"` 3964 } 3965 3966 func init() { 3967 types.Add("sms:VasaVirtualDiskId", reflect.TypeOf((*VasaVirtualDiskId)(nil)).Elem()) 3968 } 3969 3970 // Represents a virtual disk. 3971 // 3972 // Ideally a UUID, since we do not yet have an FCD, 3973 // let us use VM's UUID + diskKey. 3974 // Virtual Volume VASA providers can ignore this class. 3975 // 3976 // This structure may be used only with operations rendered under `/sms`. 3977 type VirtualDiskKey struct { 3978 DeviceId 3979 3980 // The vmInstanceUUID is unique to a VM. 3981 // 3982 // See 3983 // http://pubs.vmware.com/vsphere-60/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvim.vm.ConfigInfo.html 3984 VmInstanceUUID string `xml:"vmInstanceUUID" json:"vmInstanceUUID"` 3985 DeviceKey int32 `xml:"deviceKey" json:"deviceKey"` 3986 } 3987 3988 func init() { 3989 types.Add("sms:VirtualDiskKey", reflect.TypeOf((*VirtualDiskKey)(nil)).Elem()) 3990 } 3991 3992 // Identifies a VirtualDisk uniquely using the disk key, vCenter managed object id of the VM it 3993 // belongs to and the corresponding vCenter UUID. 3994 // 3995 // This structure may be used only with operations rendered under `/sms`. 3996 type VirtualDiskMoId struct { 3997 DeviceId 3998 3999 // The vCenter UUID - this is informational only, and may not always be set. 4000 VcUuid string `xml:"vcUuid,omitempty" json:"vcUuid,omitempty"` 4001 // The managed object id that corresponds to vCenter's ManagedObjectReference#key for this VM. 4002 VmMoid string `xml:"vmMoid" json:"vmMoid"` 4003 // The disk key that corresponds to the VirtualDevice#key in vCenter. 4004 DiskKey string `xml:"diskKey" json:"diskKey"` 4005 } 4006 4007 func init() { 4008 types.Add("sms:VirtualDiskMoId", reflect.TypeOf((*VirtualDiskMoId)(nil)).Elem()) 4009 } 4010 4011 // Identifies a virtual machine by its VMX file path. 4012 // 4013 // This structure may be used only with operations rendered under `/sms`. 4014 type VirtualMachineFilePath struct { 4015 VirtualMachineId 4016 4017 // The vCenter UUID - this is informational only, 4018 // and may not always be set. 4019 VcUuid string `xml:"vcUuid,omitempty" json:"vcUuid,omitempty"` 4020 // Datastore URL, which is globally unique (name is not). 4021 DsUrl string `xml:"dsUrl" json:"dsUrl"` 4022 // Full path name from the URL onwards. 4023 // 4024 // When the vmxPath is returned after failover, the VMX file 4025 // should be fixed up to contain correct target filenames for all replicated 4026 // disks. For non-replicated disks, the target filenames can contain 4027 // any arbitrary path. For better security, it is recommended to 4028 // set these disks pointed to a random string (e.g. UUID). 4029 VmxPath string `xml:"vmxPath" json:"vmxPath"` 4030 } 4031 4032 func init() { 4033 types.Add("sms:VirtualMachineFilePath", reflect.TypeOf((*VirtualMachineFilePath)(nil)).Elem()) 4034 } 4035 4036 // Abstracts the identity of a virtual machine. 4037 // 4038 // This structure may be used only with operations rendered under `/sms`. 4039 type VirtualMachineId struct { 4040 DeviceId 4041 } 4042 4043 func init() { 4044 types.Add("sms:VirtualMachineId", reflect.TypeOf((*VirtualMachineId)(nil)).Elem()) 4045 } 4046 4047 // Identifies a VirtualMachine uniquely using its vCenter managed object id and the corresponding 4048 // vCenter UUID 4049 // 4050 // This structure may be used only with operations rendered under `/sms`. 4051 type VirtualMachineMoId struct { 4052 VirtualMachineId 4053 4054 // The vCenter UUID - this is informational only, and may not always be set. 4055 VcUuid string `xml:"vcUuid,omitempty" json:"vcUuid,omitempty"` 4056 // The managed object id that corresponds to vCenter's ManagedObjectReference#key for this VM. 4057 VmMoid string `xml:"vmMoid" json:"vmMoid"` 4058 } 4059 4060 func init() { 4061 types.Add("sms:VirtualMachineMoId", reflect.TypeOf((*VirtualMachineMoId)(nil)).Elem()) 4062 } 4063 4064 // Identifies a virtual machine by its vmInstanceUUID 4065 // 4066 // This structure may be used only with operations rendered under `/sms`. 4067 type VirtualMachineUUID struct { 4068 VirtualMachineId 4069 4070 // The vmInstanceUUID is unique to a VM. 4071 // 4072 // See 4073 // http://pubs.vmware.com/vsphere-60/index.jsp?topic=%2Fcom.vmware.wssdk.apiref.doc%2Fvim.vm.ConfigInfo.html 4074 VmInstanceUUID string `xml:"vmInstanceUUID" json:"vmInstanceUUID"` 4075 } 4076 4077 func init() { 4078 types.Add("sms:VirtualMachineUUID", reflect.TypeOf((*VirtualMachineUUID)(nil)).Elem()) 4079 } 4080 4081 type VersionURI string 4082 4083 func init() { 4084 types.Add("sms:versionURI", reflect.TypeOf((*VersionURI)(nil)).Elem()) 4085 }