/// ReplicationCycle contains information about the current replication cycle /// status. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ReplicationCycle { /// The time the replication cycle has started. #[prost(message, optional, tag = "1")] pub start_time: ::core::option::Option<::prost_types::Timestamp>, /// The current progress in percentage of this cycle. #[prost(int32, tag = "5")] pub progress_percent: i32, } /// ReplicationSync contain information about the last replica sync to the cloud. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ReplicationSync { /// The most updated snapshot created time in the source that finished /// replication. #[prost(message, optional, tag = "1")] pub last_sync_time: ::core::option::Option<::prost_types::Timestamp>, } /// MigratingVm describes the VM that will be migrated from a Source environment /// and its replication state. #[derive(Clone, PartialEq, ::prost::Message)] pub struct MigratingVm { /// Output only. The identifier of the MigratingVm. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The unique ID of the VM in the source. /// The VM's name in vSphere can be changed, so this is not the VM's name but /// rather its moRef id. This id is of the form vm-. #[prost(string, tag = "2")] pub source_vm_id: ::prost::alloc::string::String, /// The display name attached to the MigratingVm by the user. #[prost(string, tag = "18")] pub display_name: ::prost::alloc::string::String, /// The description attached to the migrating VM by the user. #[prost(string, tag = "3")] pub description: ::prost::alloc::string::String, /// The replication schedule policy. #[prost(message, optional, tag = "8")] pub policy: ::core::option::Option, /// Output only. The time the migrating VM was created (this refers to this resource and not /// to the time it was installed in the source). #[prost(message, optional, tag = "9")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The last time the migrating VM resource was updated. #[prost(message, optional, tag = "10")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The most updated snapshot created time in the source that finished /// replication. #[prost(message, optional, tag = "11")] pub last_sync: ::core::option::Option, /// Output only. State of the MigratingVm. #[prost(enumeration = "migrating_vm::State", tag = "23")] pub state: i32, /// Output only. The last time the migrating VM state was updated. #[prost(message, optional, tag = "22")] pub state_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The percentage progress of the current running replication cycle. #[prost(message, optional, tag = "13")] pub current_sync_info: ::core::option::Option, /// Output only. The group this migrating vm is included in, if any. The group is /// represented by the full path of the appropriate /// \[Group][google.cloud.vmmigration.v1.Group\] resource. #[prost(string, tag = "15")] pub group: ::prost::alloc::string::String, /// The labels of the migrating VM. #[prost(map = "string, string", tag = "16")] pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// Output only. Provides details on the state of the Migrating VM in case of an /// error in replication. #[prost(message, optional, tag = "19")] pub error: ::core::option::Option, /// The default configuration of the target VM that will be created in GCP as a /// result of the migration. #[prost(oneof = "migrating_vm::TargetVmDefaults", tags = "26")] pub target_vm_defaults: ::core::option::Option, } /// Nested message and enum types in `MigratingVm`. pub mod migrating_vm { /// The possible values of the state/health of source VM. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// The state was not sampled by the health checks yet. Unspecified = 0, /// The VM in the source is being verified. Pending = 1, /// The source VM was verified, and it's ready to start replication. Ready = 2, /// Migration is going through the first sync cycle. FirstSync = 3, /// The replication is active, and it's running or scheduled to run. Active = 4, /// The source VM is being turned off, and a final replication is currently /// running. CuttingOver = 7, /// The source VM was stopped and replicated. The replication is currently /// paused. Cutover = 8, /// A cutover job is active and replication cycle is running the final sync. FinalSync = 9, /// The replication was paused by the user and no cycles are scheduled to /// run. Paused = 10, /// The migrating VM is being finalized and migration resources are being /// removed. Finalizing = 11, /// The replication process is done. The migrating VM is finalized and no /// longer consumes billable resources. Finalized = 12, /// The replication process encountered an unrecoverable error and was /// aborted. Error = 13, } /// The default configuration of the target VM that will be created in GCP as a /// result of the migration. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum TargetVmDefaults { /// Details of the target VM in Compute Engine. #[prost(message, tag = "26")] ComputeEngineTargetDefaults(super::ComputeEngineTargetDefaults), } } /// CloneJob describes the process of creating a clone of a /// \[MigratingVM][google.cloud.vmmigration.v1.MigratingVm\] to the /// requested target based on the latest successful uploaded snapshots. /// While the migration cycles of a MigratingVm take place, it is possible to /// verify the uploaded VM can be started in the cloud, by creating a clone. The /// clone can be created without any downtime, and it is created using the latest /// snapshots which are already in the cloud. The cloneJob is only responsible /// for its work, not its products, which means once it is finished, it will /// never touch the instance it created. It will only delete it in case of the /// CloneJob being cancelled or upon failure to clone. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CloneJob { /// Output only. The time the clone job was created (as an API call, not when it was /// actually created in the target). #[prost(message, optional, tag = "1")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// The name of the clone. #[prost(string, tag = "3")] pub name: ::prost::alloc::string::String, /// Output only. State of the clone job. #[prost(enumeration = "clone_job::State", tag = "12")] pub state: i32, /// Output only. The time the state was last updated. #[prost(message, optional, tag = "14")] pub state_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Provides details for the errors that led to the Clone Job's state. #[prost(message, optional, tag = "17")] pub error: ::core::option::Option, /// Details of the VM to create as the target of this clone job. #[prost(oneof = "clone_job::TargetVmDetails", tags = "20")] pub target_vm_details: ::core::option::Option, } /// Nested message and enum types in `CloneJob`. pub mod clone_job { /// Possible states of the clone job. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// The state is unknown. This is used for API compatibility only and is not /// used by the system. Unspecified = 0, /// The clone job has not yet started. Pending = 1, /// The clone job is active and running. Active = 2, /// The clone job finished with errors. Failed = 3, /// The clone job finished successfully. Succeeded = 4, /// The clone job was cancelled. Cancelled = 5, /// The clone job is being cancelled. Cancelling = 6, /// OS adaptation is running as part of the clone job to generate license. AdaptingOs = 7, } /// Details of the VM to create as the target of this clone job. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum TargetVmDetails { /// Output only. Details of the target VM in Compute Engine. #[prost(message, tag = "20")] ComputeEngineTargetDetails(super::ComputeEngineTargetDetails), } } /// CutoverJob message describes a cutover of a migrating VM. The CutoverJob is /// the operation of shutting down the VM, creating a snapshot and /// clonning the VM using the replicated snapshot. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CutoverJob { /// Output only. The time the cutover job was created (as an API call, not when it was /// actually created in the target). #[prost(message, optional, tag = "1")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The name of the cutover job. #[prost(string, tag = "3")] pub name: ::prost::alloc::string::String, /// Output only. State of the cutover job. #[prost(enumeration = "cutover_job::State", tag = "5")] pub state: i32, /// Output only. The time the state was last updated. #[prost(message, optional, tag = "6")] pub state_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The current progress in percentage of the cutover job. #[prost(int32, tag = "13")] pub progress_percent: i32, /// Output only. Provides details for the errors that led to the Cutover Job's state. #[prost(message, optional, tag = "9")] pub error: ::core::option::Option, /// Output only. A message providing possible extra details about the current state. #[prost(string, tag = "10")] pub state_message: ::prost::alloc::string::String, /// Details of the VM to create as the target of this cutover job. #[prost(oneof = "cutover_job::TargetVmDetails", tags = "14")] pub target_vm_details: ::core::option::Option, } /// Nested message and enum types in `CutoverJob`. pub mod cutover_job { /// Possible states of the cutover job. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// The state is unknown. This is used for API compatibility only and is not /// used by the system. Unspecified = 0, /// The cutover job has not yet started. Pending = 1, /// The cutover job finished with errors. Failed = 2, /// The cutover job finished successfully. Succeeded = 3, /// The cutover job was cancelled. Cancelled = 4, /// The cutover job is being cancelled. Cancelling = 5, /// The cutover job is active and running. Active = 6, /// OS adaptation is running as part of the cutover job to generate license. AdaptingOs = 7, } /// Details of the VM to create as the target of this cutover job. #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum TargetVmDetails { /// Output only. Details of the target VM in Compute Engine. #[prost(message, tag = "14")] ComputeEngineTargetDetails(super::ComputeEngineTargetDetails), } } /// Request message for 'CreateCloneJob' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateCloneJobRequest { /// Required. The Clone's parent. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The clone job identifier. #[prost(string, tag = "2")] pub clone_job_id: ::prost::alloc::string::String, /// Required. The clone request body. #[prost(message, optional, tag = "3")] pub clone_job: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "4")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'CancelCloneJob' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelCloneJobRequest { /// Required. The clone job id #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Response message for 'CancelCloneJob' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelCloneJobResponse {} /// Request message for 'ListCloneJobsRequest' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListCloneJobsRequest { /// Required. The parent, which owns this collection of source VMs. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The maximum number of clone jobs to return. The service may return /// fewer than this value. If unspecified, at most 500 clone jobs will be /// returned. The maximum value is 1000; values above 1000 will be coerced to /// 1000. #[prost(int32, tag = "2")] pub page_size: i32, /// Required. A page token, received from a previous `ListCloneJobs` call. /// Provide this to retrieve the subsequent page. /// /// When paginating, all other parameters provided to `ListCloneJobs` must /// match the call that provided the page token. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// Optional. The filter request. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, /// Optional. the order by fields for the result. #[prost(string, tag = "5")] pub order_by: ::prost::alloc::string::String, } /// Response message for 'ListCloneJobs' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListCloneJobsResponse { /// Output only. The list of clone jobs response. #[prost(message, repeated, tag = "1")] pub clone_jobs: ::prost::alloc::vec::Vec, /// Output only. A token, which can be sent as `page_token` to retrieve the next page. /// If this field is omitted, there are no subsequent pages. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, /// Output only. Locations that could not be reached. #[prost(string, repeated, tag = "3")] pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Request message for 'GetCloneJob' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetCloneJobRequest { /// Required. The name of the CloneJob. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Source message describes a specific vm migration Source resource. It contains /// the source environment information. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Source { /// Output only. The Source name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Output only. The create time timestamp. #[prost(message, optional, tag = "2")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The update time timestamp. #[prost(message, optional, tag = "3")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, /// The labels of the source. #[prost(map = "string, string", tag = "4")] pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// User-provided description of the source. #[prost(string, tag = "6")] pub description: ::prost::alloc::string::String, #[prost(oneof = "source::SourceDetails", tags = "10")] pub source_details: ::core::option::Option, } /// Nested message and enum types in `Source`. pub mod source { #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum SourceDetails { /// Vmware type source details. #[prost(message, tag = "10")] Vmware(super::VmwareSourceDetails), } } /// VmwareSourceDetails message describes a specific source details for the /// vmware source type. #[derive(Clone, PartialEq, ::prost::Message)] pub struct VmwareSourceDetails { /// The credentials username. #[prost(string, tag = "1")] pub username: ::prost::alloc::string::String, /// Input only. The credentials password. This is write only and can not be read in a GET /// operation. #[prost(string, tag = "2")] pub password: ::prost::alloc::string::String, /// The ip address of the vcenter this Source represents. #[prost(string, tag = "3")] pub vcenter_ip: ::prost::alloc::string::String, /// The thumbprint representing the certificate for the vcenter. #[prost(string, tag = "4")] pub thumbprint: ::prost::alloc::string::String, } /// DatacenterConnector message describes a connector between the Source and GCP, /// which is installed on a vmware datacenter (an OVA vm installed by the user) /// to connect the Datacenter to GCP and support vm migration data transfer. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DatacenterConnector { /// Output only. The time the connector was created (as an API call, not when it was /// actually installed). #[prost(message, optional, tag = "1")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The last time the connector was updated with an API call. #[prost(message, optional, tag = "2")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The connector's name. #[prost(string, tag = "3")] pub name: ::prost::alloc::string::String, /// Immutable. A unique key for this connector. This key is internal to the OVA connector /// and is supplied with its creation during the registration process and can /// not be modified. #[prost(string, tag = "12")] pub registration_id: ::prost::alloc::string::String, /// The service account to use in the connector when communicating with the /// cloud. #[prost(string, tag = "5")] pub service_account: ::prost::alloc::string::String, /// The version running in the DatacenterConnector. This is supplied by the OVA /// connector during the registration process and can not be modified. #[prost(string, tag = "6")] pub version: ::prost::alloc::string::String, /// Output only. The communication channel between the datacenter connector and GCP. #[prost(string, tag = "10")] pub bucket: ::prost::alloc::string::String, /// Output only. State of the DatacenterConnector, as determined by the health checks. #[prost(enumeration = "datacenter_connector::State", tag = "7")] pub state: i32, /// Output only. The time the state was last set. #[prost(message, optional, tag = "8")] pub state_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Provides details on the state of the Datacenter Connector in case of an /// error. #[prost(message, optional, tag = "11")] pub error: ::core::option::Option, } /// Nested message and enum types in `DatacenterConnector`. pub mod datacenter_connector { /// The possible values of the state. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// The state is unknown. This is used for API compatibility only and is not /// used by the system. Unspecified = 0, /// The state was not sampled by the health checks yet. Pending = 1, /// The source was sampled by health checks and is not available. Offline = 2, /// The source is available but might not be usable yet due to unvalidated /// credentials or another reason. The credentials referred to are the ones /// to the Source. The error message will contain further details. Failed = 3, /// The source exists and its credentials were verified. Active = 4, } } /// Request message for 'ListSources' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListSourcesRequest { /// Required. The parent, which owns this collection of sources. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The maximum number of sources to return. The service may return /// fewer than this value. If unspecified, at most 500 sources will be /// returned. The maximum value is 1000; values above 1000 will be coerced to /// 1000. #[prost(int32, tag = "2")] pub page_size: i32, /// Required. A page token, received from a previous `ListSources` call. /// Provide this to retrieve the subsequent page. /// /// When paginating, all other parameters provided to `ListSources` must /// match the call that provided the page token. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// Optional. The filter request. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, /// Optional. the order by fields for the result. #[prost(string, tag = "5")] pub order_by: ::prost::alloc::string::String, } /// Response message for 'ListSources' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListSourcesResponse { /// Output only. The list of sources response. #[prost(message, repeated, tag = "1")] pub sources: ::prost::alloc::vec::Vec, /// Output only. A token, which can be sent as `page_token` to retrieve the next page. /// If this field is omitted, there are no subsequent pages. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, /// Output only. Locations that could not be reached. #[prost(string, repeated, tag = "3")] pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Request message for 'GetSource' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetSourceRequest { /// Required. The Source name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for 'CreateSource' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateSourceRequest { /// Required. The Source's parent. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The source identifier. #[prost(string, tag = "2")] pub source_id: ::prost::alloc::string::String, /// Required. The create request body. #[prost(message, optional, tag = "3")] pub source: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "4")] pub request_id: ::prost::alloc::string::String, } /// Update message for 'UpdateSources' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateSourceRequest { /// Field mask is used to specify the fields to be overwritten in the /// Source resource by the update. /// The fields specified in the update_mask are relative to the resource, not /// the full request. A field will be overwritten if it is in the mask. If the /// user does not provide a mask then all fields will be overwritten. #[prost(message, optional, tag = "1")] pub update_mask: ::core::option::Option<::prost_types::FieldMask>, /// Required. The update request body. #[prost(message, optional, tag = "2")] pub source: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "3")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'DeleteSource' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteSourceRequest { /// Required. The Source name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Optional. A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes after the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "2")] pub request_id: ::prost::alloc::string::String, } /// Request message for /// \[fetchInventory][google.cloud.vmmigration.v1.VmMigration.FetchInventory\]. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FetchInventoryRequest { /// Required. The name of the Source. #[prost(string, tag = "1")] pub source: ::prost::alloc::string::String, /// If this flag is set to true, the source will be queried instead of using /// cached results. Using this flag will make the call slower. #[prost(bool, tag = "2")] pub force_refresh: bool, } /// VmwareVmDetails describes a VM in vCenter. #[derive(Clone, PartialEq, ::prost::Message)] pub struct VmwareVmDetails { /// The VM's id in the source (note that this is not the MigratingVm's id). /// This is the moref id of the VM. #[prost(string, tag = "1")] pub vm_id: ::prost::alloc::string::String, /// The id of the vCenter's datacenter this VM is contained in. #[prost(string, tag = "2")] pub datacenter_id: ::prost::alloc::string::String, /// The descriptive name of the vCenter's datacenter this VM is contained in. #[prost(string, tag = "3")] pub datacenter_description: ::prost::alloc::string::String, /// The unique identifier of the VM in vCenter. #[prost(string, tag = "4")] pub uuid: ::prost::alloc::string::String, /// The display name of the VM. Note that this is not necessarily unique. #[prost(string, tag = "5")] pub display_name: ::prost::alloc::string::String, /// The power state of the VM at the moment list was taken. #[prost(enumeration = "vmware_vm_details::PowerState", tag = "6")] pub power_state: i32, /// The number of cpus in the VM. #[prost(int32, tag = "7")] pub cpu_count: i32, /// The size of the memory of the VM in MB. #[prost(int32, tag = "8")] pub memory_mb: i32, /// The number of disks the VM has. #[prost(int32, tag = "9")] pub disk_count: i32, /// The total size of the storage allocated to the VM in MB. #[prost(int64, tag = "12")] pub committed_storage_mb: i64, /// The VM's OS. See for example /// /// for types of strings this might hold. #[prost(string, tag = "11")] pub guest_description: ::prost::alloc::string::String, /// Output only. The VM Boot Option. #[prost(enumeration = "vmware_vm_details::BootOption", tag = "13")] pub boot_option: i32, } /// Nested message and enum types in `VmwareVmDetails`. pub mod vmware_vm_details { /// Possible values for the power state of the VM. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum PowerState { /// Power state is not specified. Unspecified = 0, /// The VM is turned ON. On = 1, /// The VM is turned OFF. Off = 2, /// The VM is suspended. This is similar to hibernation or sleep mode. Suspended = 3, } /// Possible values for vm boot option. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum BootOption { /// The boot option is unknown. Unspecified = 0, /// The boot option is EFI. Efi = 1, /// The boot option is BIOS. Bios = 2, } } /// VmwareVmsDetails describes VMs in vCenter. #[derive(Clone, PartialEq, ::prost::Message)] pub struct VmwareVmsDetails { /// The details of the vmware VMs. #[prost(message, repeated, tag = "1")] pub details: ::prost::alloc::vec::Vec, } /// Response message for /// \[fetchInventory][google.cloud.vmmigration.v1.VmMigration.FetchInventory\]. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FetchInventoryResponse { /// Output only. The timestamp when the source was last queried (if the result is from the /// cache). #[prost(message, optional, tag = "2")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, #[prost(oneof = "fetch_inventory_response::SourceVms", tags = "1")] pub source_vms: ::core::option::Option, } /// Nested message and enum types in `FetchInventoryResponse`. pub mod fetch_inventory_response { #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum SourceVms { /// Output only. The description of the VMs in a Source of type Vmware. #[prost(message, tag = "1")] VmwareVms(super::VmwareVmsDetails), } } /// Utilization report details the utilization (CPU, memory, etc.) of selected /// source VMs. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UtilizationReport { /// Output only. The report unique name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The report display name, as assigned by the user. #[prost(string, tag = "2")] pub display_name: ::prost::alloc::string::String, /// Output only. Current state of the report. #[prost(enumeration = "utilization_report::State", tag = "3")] pub state: i32, /// Output only. The time the state was last set. #[prost(message, optional, tag = "4")] pub state_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Provides details on the state of the report in case of an error. #[prost(message, optional, tag = "5")] pub error: ::core::option::Option, /// Output only. The time the report was created (this refers to the time of the request, /// not the time the report creation completed). #[prost(message, optional, tag = "6")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Time frame of the report. #[prost(enumeration = "utilization_report::TimeFrame", tag = "7")] pub time_frame: i32, /// Output only. The point in time when the time frame ends. Notice that the time /// frame is counted backwards. For instance if the "frame_end_time" value is /// 2021/01/20 and the time frame is WEEK then the report covers the week /// between 2021/01/20 and 2021/01/14. #[prost(message, optional, tag = "8")] pub frame_end_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Total number of VMs included in the report. #[prost(int32, tag = "9")] pub vm_count: i32, /// List of utilization information per VM. /// When sent as part of the request, the "vm_id" field is used in order to /// specify which VMs to include in the report. In that case all other fields /// are ignored. #[prost(message, repeated, tag = "10")] pub vms: ::prost::alloc::vec::Vec, } /// Nested message and enum types in `UtilizationReport`. pub mod utilization_report { /// Utilization report state. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum State { /// The state is unknown. This value is not in use. Unspecified = 0, /// The report is in the making. Creating = 1, /// Report creation completed successfully. Succeeded = 2, /// Report creation failed. Failed = 3, } /// Report time frame options. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum TimeFrame { /// The time frame was not specified and will default to WEEK. Unspecified = 0, /// One week. Week = 1, /// One month. Month = 2, /// One year. Year = 3, } } /// Utilization information of a single VM. #[derive(Clone, PartialEq, ::prost::Message)] pub struct VmUtilizationInfo { /// The VM's ID in the source. #[prost(string, tag = "3")] pub vm_id: ::prost::alloc::string::String, /// Utilization metrics for this VM. #[prost(message, optional, tag = "2")] pub utilization: ::core::option::Option, #[prost(oneof = "vm_utilization_info::VmDetails", tags = "1")] pub vm_details: ::core::option::Option, } /// Nested message and enum types in `VmUtilizationInfo`. pub mod vm_utilization_info { #[derive(Clone, PartialEq, ::prost::Oneof)] pub enum VmDetails { /// The description of the VM in a Source of type Vmware. #[prost(message, tag = "1")] VmwareVmDetails(super::VmwareVmDetails), } } /// Utilization metrics values for a single VM. #[derive(Clone, PartialEq, ::prost::Message)] pub struct VmUtilizationMetrics { /// Max CPU usage, percent. #[prost(int32, tag = "9")] pub cpu_max_percent: i32, /// Average CPU usage, percent. #[prost(int32, tag = "10")] pub cpu_average_percent: i32, /// Max memory usage, percent. #[prost(int32, tag = "11")] pub memory_max_percent: i32, /// Average memory usage, percent. #[prost(int32, tag = "12")] pub memory_average_percent: i32, /// Max disk IO rate, in kilobytes per second. #[prost(int64, tag = "13")] pub disk_io_rate_max_kbps: i64, /// Average disk IO rate, in kilobytes per second. #[prost(int64, tag = "14")] pub disk_io_rate_average_kbps: i64, /// Max network throughput (combined transmit-rates and receive-rates), in /// kilobytes per second. #[prost(int64, tag = "15")] pub network_throughput_max_kbps: i64, /// Average network throughput (combined transmit-rates and receive-rates), in /// kilobytes per second. #[prost(int64, tag = "16")] pub network_throughput_average_kbps: i64, } /// Request message for 'ListUtilizationReports' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListUtilizationReportsRequest { /// Required. The Utilization Reports parent. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The level of details of each report. /// Defaults to BASIC. #[prost(enumeration = "UtilizationReportView", tag = "2")] pub view: i32, /// Optional. The maximum number of reports to return. The service may return /// fewer than this value. If unspecified, at most 500 reports will be /// returned. The maximum value is 1000; values above 1000 will be coerced to /// 1000. #[prost(int32, tag = "3")] pub page_size: i32, /// Required. A page token, received from a previous `ListUtilizationReports` call. /// Provide this to retrieve the subsequent page. /// /// When paginating, all other parameters provided to `ListUtilizationReports` /// must match the call that provided the page token. #[prost(string, tag = "4")] pub page_token: ::prost::alloc::string::String, /// Optional. The filter request. #[prost(string, tag = "5")] pub filter: ::prost::alloc::string::String, /// Optional. the order by fields for the result. #[prost(string, tag = "6")] pub order_by: ::prost::alloc::string::String, } /// Response message for 'ListUtilizationReports' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListUtilizationReportsResponse { /// Output only. The list of reports. #[prost(message, repeated, tag = "1")] pub utilization_reports: ::prost::alloc::vec::Vec, /// Output only. A token, which can be sent as `page_token` to retrieve the next page. /// If this field is omitted, there are no subsequent pages. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, /// Output only. Locations that could not be reached. #[prost(string, repeated, tag = "3")] pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Request message for 'GetUtilizationReport' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetUtilizationReportRequest { /// Required. The Utilization Report name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Optional. The level of details of the report. /// Defaults to FULL #[prost(enumeration = "UtilizationReportView", tag = "2")] pub view: i32, } /// Request message for 'CreateUtilizationReport' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateUtilizationReportRequest { /// Required. The Utilization Report's parent. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The report to create. #[prost(message, optional, tag = "2")] pub utilization_report: ::core::option::Option, /// Required. The ID to use for the report, which will become the final component of /// the reports's resource name. /// /// This value maximum length is 63 characters, and valid characters /// are /\[a-z][0-9\]-/. It must start with an english letter and must not /// end with a hyphen. #[prost(string, tag = "3")] pub utilization_report_id: ::prost::alloc::string::String, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "4")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'DeleteUtilizationReport' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteUtilizationReportRequest { /// Required. The Utilization Report name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Optional. A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes after the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "2")] pub request_id: ::prost::alloc::string::String, } /// Response message for 'ListDatacenterConnectors' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListDatacenterConnectorsResponse { /// Output only. The list of sources response. #[prost(message, repeated, tag = "1")] pub datacenter_connectors: ::prost::alloc::vec::Vec, /// Output only. A token, which can be sent as `page_token` to retrieve the next page. /// If this field is omitted, there are no subsequent pages. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, /// Output only. Locations that could not be reached. #[prost(string, repeated, tag = "3")] pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Request message for 'GetDatacenterConnector' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetDatacenterConnectorRequest { /// Required. The name of the DatacenterConnector. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for 'CreateDatacenterConnector' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateDatacenterConnectorRequest { /// Required. The DatacenterConnector's parent. /// Required. The Source in where the new DatacenterConnector will be created. /// For example: /// `projects/my-project/locations/us-central1/sources/my-source` #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The datacenterConnector identifier. #[prost(string, tag = "2")] pub datacenter_connector_id: ::prost::alloc::string::String, /// Required. The create request body. #[prost(message, optional, tag = "3")] pub datacenter_connector: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "4")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'DeleteDatacenterConnector' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteDatacenterConnectorRequest { /// Required. The DatacenterConnector name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes after the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "2")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'ListDatacenterConnectors' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListDatacenterConnectorsRequest { /// Required. The parent, which owns this collection of connectors. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The maximum number of connectors to return. The service may return /// fewer than this value. If unspecified, at most 500 sources will be /// returned. The maximum value is 1000; values above 1000 will be coerced to /// 1000. #[prost(int32, tag = "2")] pub page_size: i32, /// Required. A page token, received from a previous `ListDatacenterConnectors` call. /// Provide this to retrieve the subsequent page. /// /// When paginating, all other parameters provided to /// `ListDatacenterConnectors` must match the call that provided the page /// token. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// Optional. The filter request. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, /// Optional. the order by fields for the result. #[prost(string, tag = "5")] pub order_by: ::prost::alloc::string::String, } /// ComputeEngineTargetDefaults is a collection of details for creating a VM in a /// target Compute Engine project. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ComputeEngineTargetDefaults { /// The name of the VM to create. #[prost(string, tag = "1")] pub vm_name: ::prost::alloc::string::String, /// The full path of the resource of type TargetProject which represents the /// Compute Engine project in which to create this VM. #[prost(string, tag = "2")] pub target_project: ::prost::alloc::string::String, /// The zone in which to create the VM. #[prost(string, tag = "3")] pub zone: ::prost::alloc::string::String, /// The machine type series to create the VM with. #[prost(string, tag = "4")] pub machine_type_series: ::prost::alloc::string::String, /// The machine type to create the VM with. #[prost(string, tag = "5")] pub machine_type: ::prost::alloc::string::String, /// A map of network tags to associate with the VM. #[prost(string, repeated, tag = "6")] pub network_tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// List of NICs connected to this VM. #[prost(message, repeated, tag = "7")] pub network_interfaces: ::prost::alloc::vec::Vec, /// The service account to associate the VM with. #[prost(string, tag = "8")] pub service_account: ::prost::alloc::string::String, /// The disk type to use in the VM. #[prost(enumeration = "ComputeEngineDiskType", tag = "9")] pub disk_type: i32, /// A map of labels to associate with the VM. #[prost(map = "string, string", tag = "10")] pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// The license type to use in OS adaptation. #[prost(enumeration = "ComputeEngineLicenseType", tag = "11")] pub license_type: i32, /// Output only. The OS license returned from the adaptation module report. #[prost(message, optional, tag = "12")] pub applied_license: ::core::option::Option, /// Compute instance scheduling information (if empty default is used). #[prost(message, optional, tag = "13")] pub compute_scheduling: ::core::option::Option, /// Defines whether the instance has Secure Boot enabled. /// This can be set to true only if the vm boot option is EFI. #[prost(bool, tag = "14")] pub secure_boot: bool, /// Output only. The VM Boot Option, as set in the source vm. #[prost(enumeration = "ComputeEngineBootOption", tag = "15")] pub boot_option: i32, /// The metadata key/value pairs to assign to the VM. #[prost(map = "string, string", tag = "16")] pub metadata: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// ComputeEngineTargetDetails is a collection of details for creating a VM in a /// target Compute Engine project. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ComputeEngineTargetDetails { /// The name of the VM to create. #[prost(string, tag = "1")] pub vm_name: ::prost::alloc::string::String, /// The GCP target project ID or project name. #[prost(string, tag = "2")] pub project: ::prost::alloc::string::String, /// The zone in which to create the VM. #[prost(string, tag = "3")] pub zone: ::prost::alloc::string::String, /// The machine type series to create the VM with. #[prost(string, tag = "4")] pub machine_type_series: ::prost::alloc::string::String, /// The machine type to create the VM with. #[prost(string, tag = "5")] pub machine_type: ::prost::alloc::string::String, /// A map of network tags to associate with the VM. #[prost(string, repeated, tag = "6")] pub network_tags: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, /// List of NICs connected to this VM. #[prost(message, repeated, tag = "7")] pub network_interfaces: ::prost::alloc::vec::Vec, /// The service account to associate the VM with. #[prost(string, tag = "8")] pub service_account: ::prost::alloc::string::String, /// The disk type to use in the VM. #[prost(enumeration = "ComputeEngineDiskType", tag = "9")] pub disk_type: i32, /// A map of labels to associate with the VM. #[prost(map = "string, string", tag = "10")] pub labels: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, /// The license type to use in OS adaptation. #[prost(enumeration = "ComputeEngineLicenseType", tag = "11")] pub license_type: i32, /// The OS license returned from the adaptation module report. #[prost(message, optional, tag = "12")] pub applied_license: ::core::option::Option, /// Compute instance scheduling information (if empty default is used). #[prost(message, optional, tag = "13")] pub compute_scheduling: ::core::option::Option, /// Defines whether the instance has Secure Boot enabled. /// This can be set to true only if the vm boot option is EFI. #[prost(bool, tag = "14")] pub secure_boot: bool, /// The VM Boot Option, as set in the source vm. #[prost(enumeration = "ComputeEngineBootOption", tag = "15")] pub boot_option: i32, /// The metadata key/value pairs to assign to the VM. #[prost(map = "string, string", tag = "16")] pub metadata: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>, } /// NetworkInterface represents a NIC of a VM. #[derive(Clone, PartialEq, ::prost::Message)] pub struct NetworkInterface { /// The network to connect the NIC to. #[prost(string, tag = "1")] pub network: ::prost::alloc::string::String, /// The subnetwork to connect the NIC to. #[prost(string, tag = "2")] pub subnetwork: ::prost::alloc::string::String, /// The internal IP to define in the NIC. /// The formats accepted are: `ephemeral` \ ipv4 address \ a named address /// resource full path. #[prost(string, tag = "3")] pub internal_ip: ::prost::alloc::string::String, /// The external IP to define in the NIC. #[prost(string, tag = "4")] pub external_ip: ::prost::alloc::string::String, } /// AppliedLicense holds the license data returned by adaptation module report. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AppliedLicense { /// The license type that was used in OS adaptation. #[prost(enumeration = "applied_license::Type", tag = "1")] pub r#type: i32, /// The OS license returned from the adaptation module's report. #[prost(string, tag = "2")] pub os_license: ::prost::alloc::string::String, } /// Nested message and enum types in `AppliedLicense`. pub mod applied_license { /// License types used in OS adaptation. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Type { /// Unspecified license for the OS. Unspecified = 0, /// No license available for the OS. None = 1, /// The license type is Pay As You Go license type. Payg = 2, /// The license type is is Bring Your Own License type. Byol = 3, } } /// Node Affinity: the configuration of desired nodes onto which this Instance /// could be scheduled. Based on /// #[derive(Clone, PartialEq, ::prost::Message)] pub struct SchedulingNodeAffinity { /// The label key of Node resource to reference. #[prost(string, tag = "1")] pub key: ::prost::alloc::string::String, /// The operator to use for the node resources specified in the `values` /// parameter. #[prost(enumeration = "scheduling_node_affinity::Operator", tag = "2")] pub operator: i32, /// Corresponds to the label values of Node resource. #[prost(string, repeated, tag = "3")] pub values: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Nested message and enum types in `SchedulingNodeAffinity`. pub mod scheduling_node_affinity { /// Possible types of node selection operators. Valid operators are IN for /// affinity and NOT_IN for anti-affinity. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum Operator { /// An unknown, unexpected behavior. Unspecified = 0, /// The node resource group should be in these resources affinity. In = 1, /// The node resource group should not be in these resources affinity. NotIn = 2, } } /// Scheduling information for VM on maintenance/restart behaviour and /// node allocation in sole tenant nodes. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ComputeScheduling { /// How the instance should behave when the host machine undergoes /// maintenance that may temporarily impact instance performance. #[prost(enumeration = "compute_scheduling::OnHostMaintenance", tag = "1")] pub on_host_maintenance: i32, /// Whether the Instance should be automatically restarted whenever it is /// terminated by Compute Engine (not terminated by user). /// This configuration is identical to `automaticRestart` field in Compute /// Engine create instance under scheduling. /// It was changed to an enum (instead of a boolean) to match the default /// value in Compute Engine which is automatic restart. #[prost(enumeration = "compute_scheduling::RestartType", tag = "5")] pub restart_type: i32, /// A set of node affinity and anti-affinity configurations for sole tenant /// nodes. #[prost(message, repeated, tag = "3")] pub node_affinities: ::prost::alloc::vec::Vec, /// The minimum number of virtual CPUs this instance will consume when /// running on a sole-tenant node. Ignored if no node_affinites are /// configured. #[prost(int32, tag = "4")] pub min_node_cpus: i32, } /// Nested message and enum types in `ComputeScheduling`. pub mod compute_scheduling { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum OnHostMaintenance { /// An unknown, unexpected behavior. Unspecified = 0, /// Terminate the instance when the host machine undergoes maintenance. Terminate = 1, /// Migrate the instance when the host machine undergoes maintenance. Migrate = 2, } /// Defines whether the Instance should be automatically restarted whenever /// it is terminated by Compute Engine (not terminated by user). #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum RestartType { /// Unspecified behavior. This will use the default. Unspecified = 0, /// The Instance should be automatically restarted whenever it is /// terminated by Compute Engine. AutomaticRestart = 1, /// The Instance isn't automatically restarted whenever it is /// terminated by Compute Engine. NoAutomaticRestart = 2, } } /// A policy for scheduling replications. #[derive(Clone, PartialEq, ::prost::Message)] pub struct SchedulePolicy { /// The idle duration between replication stages. #[prost(message, optional, tag = "1")] pub idle_duration: ::core::option::Option<::prost_types::Duration>, /// A flag to indicate whether to skip OS adaptation during the replication /// sync. OS adaptation is a process where the VM's operating system undergoes /// changes and adaptations to fully function on Compute Engine. #[prost(bool, tag = "2")] pub skip_os_adaptation: bool, } /// Request message for 'CreateMigratingVm' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateMigratingVmRequest { /// Required. The MigratingVm's parent. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The migratingVm identifier. #[prost(string, tag = "2")] pub migrating_vm_id: ::prost::alloc::string::String, /// Required. The create request body. #[prost(message, optional, tag = "3")] pub migrating_vm: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "4")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'LisMigratingVmsRequest' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListMigratingVmsRequest { /// Required. The parent, which owns this collection of MigratingVms. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The maximum number of migrating VMs to return. The service may return /// fewer than this value. If unspecified, at most 500 migrating VMs will be /// returned. The maximum value is 1000; values above 1000 will be coerced to /// 1000. #[prost(int32, tag = "2")] pub page_size: i32, /// Required. A page token, received from a previous `ListMigratingVms` call. /// Provide this to retrieve the subsequent page. /// /// When paginating, all other parameters provided to `ListMigratingVms` /// must match the call that provided the page token. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// Optional. The filter request. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, /// Optional. the order by fields for the result. #[prost(string, tag = "5")] pub order_by: ::prost::alloc::string::String, } /// Response message for 'ListMigratingVms' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListMigratingVmsResponse { /// Output only. The list of Migrating VMs response. #[prost(message, repeated, tag = "1")] pub migrating_vms: ::prost::alloc::vec::Vec, /// Output only. A token, which can be sent as `page_token` to retrieve the next page. /// If this field is omitted, there are no subsequent pages. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, /// Output only. Locations that could not be reached. #[prost(string, repeated, tag = "3")] pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Request message for 'GetMigratingVm' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetMigratingVmRequest { /// Required. The name of the MigratingVm. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for 'UpdateMigratingVm' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateMigratingVmRequest { /// Field mask is used to specify the fields to be overwritten in the /// MigratingVm resource by the update. /// The fields specified in the update_mask are relative to the resource, not /// the full request. A field will be overwritten if it is in the mask. If the /// user does not provide a mask then all fields will be overwritten. #[prost(message, optional, tag = "1")] pub update_mask: ::core::option::Option<::prost_types::FieldMask>, /// Required. The update request body. #[prost(message, optional, tag = "2")] pub migrating_vm: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "3")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'DeleteMigratingVm' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteMigratingVmRequest { /// Required. The name of the MigratingVm. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for 'StartMigrationRequest' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct StartMigrationRequest { /// Required. The name of the MigratingVm. #[prost(string, tag = "1")] pub migrating_vm: ::prost::alloc::string::String, } /// Response message for 'StartMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct StartMigrationResponse {} /// Request message for 'PauseMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PauseMigrationRequest { /// Required. The name of the MigratingVm. #[prost(string, tag = "1")] pub migrating_vm: ::prost::alloc::string::String, } /// Response message for 'PauseMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct PauseMigrationResponse {} /// Request message for 'ResumeMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResumeMigrationRequest { /// Required. The name of the MigratingVm. #[prost(string, tag = "1")] pub migrating_vm: ::prost::alloc::string::String, } /// Response message for 'ResumeMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ResumeMigrationResponse {} /// Request message for 'FinalizeMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FinalizeMigrationRequest { /// Required. The name of the MigratingVm. #[prost(string, tag = "1")] pub migrating_vm: ::prost::alloc::string::String, } /// Response message for 'FinalizeMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct FinalizeMigrationResponse {} /// TargetProject message represents a target Compute Engine project for a /// migration or a clone. #[derive(Clone, PartialEq, ::prost::Message)] pub struct TargetProject { /// The name of the target project. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// The target project ID (number) or project name. #[prost(string, tag = "2")] pub project: ::prost::alloc::string::String, /// The target project's description. #[prost(string, tag = "3")] pub description: ::prost::alloc::string::String, /// Output only. The time this target project resource was created (not related to when the /// Compute Engine project it points to was created). #[prost(message, optional, tag = "4")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The last time the target project resource was updated. #[prost(message, optional, tag = "5")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, } /// Request message for 'GetTargetProject' call. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetTargetProjectRequest { /// Required. The TargetProject name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for 'ListTargetProjects' call. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListTargetProjectsRequest { /// Required. The parent, which owns this collection of targets. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The maximum number of targets to return. The service may return /// fewer than this value. If unspecified, at most 500 targets will be /// returned. The maximum value is 1000; values above 1000 will be coerced to /// 1000. #[prost(int32, tag = "2")] pub page_size: i32, /// Required. A page token, received from a previous `ListTargets` call. /// Provide this to retrieve the subsequent page. /// /// When paginating, all other parameters provided to `ListTargets` must /// match the call that provided the page token. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// Optional. The filter request. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, /// Optional. the order by fields for the result. #[prost(string, tag = "5")] pub order_by: ::prost::alloc::string::String, } /// Response message for 'ListTargetProjects' call. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListTargetProjectsResponse { /// Output only. The list of target response. #[prost(message, repeated, tag = "1")] pub target_projects: ::prost::alloc::vec::Vec, /// Output only. A token, which can be sent as `page_token` to retrieve the next page. /// If this field is omitted, there are no subsequent pages. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, /// Output only. Locations that could not be reached. #[prost(string, repeated, tag = "3")] pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Request message for 'CreateTargetProject' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateTargetProjectRequest { /// Required. The TargetProject's parent. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The target_project identifier. #[prost(string, tag = "2")] pub target_project_id: ::prost::alloc::string::String, /// Required. The create request body. #[prost(message, optional, tag = "3")] pub target_project: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "4")] pub request_id: ::prost::alloc::string::String, } /// Update message for 'UpdateTargetProject' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateTargetProjectRequest { /// Field mask is used to specify the fields to be overwritten in the /// TargetProject resource by the update. /// The fields specified in the update_mask are relative to the resource, not /// the full request. A field will be overwritten if it is in the mask. If the /// user does not provide a mask then all fields will be overwritten. #[prost(message, optional, tag = "1")] pub update_mask: ::core::option::Option<::prost_types::FieldMask>, /// Required. The update request body. #[prost(message, optional, tag = "2")] pub target_project: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "3")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'DeleteTargetProject' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteTargetProjectRequest { /// Required. The TargetProject name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Optional. A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes after the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "2")] pub request_id: ::prost::alloc::string::String, } /// Describes message for 'Group' resource. The Group is a collections of several /// MigratingVms. #[derive(Clone, PartialEq, ::prost::Message)] pub struct Group { /// The Group name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Output only. The create time timestamp. #[prost(message, optional, tag = "2")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The update time timestamp. #[prost(message, optional, tag = "3")] pub update_time: ::core::option::Option<::prost_types::Timestamp>, /// User-provided description of the group. #[prost(string, tag = "4")] pub description: ::prost::alloc::string::String, /// Display name is a user defined name for this group which can be updated. #[prost(string, tag = "5")] pub display_name: ::prost::alloc::string::String, } /// Request message for 'ListGroups' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListGroupsRequest { /// Required. The parent, which owns this collection of groups. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The maximum number of groups to return. The service may return /// fewer than this value. If unspecified, at most 500 groups will be /// returned. The maximum value is 1000; values above 1000 will be coerced to /// 1000. #[prost(int32, tag = "2")] pub page_size: i32, /// Required. A page token, received from a previous `ListGroups` call. /// Provide this to retrieve the subsequent page. /// /// When paginating, all other parameters provided to `ListGroups` must /// match the call that provided the page token. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// Optional. The filter request. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, /// Optional. the order by fields for the result. #[prost(string, tag = "5")] pub order_by: ::prost::alloc::string::String, } /// Response message for 'ListGroups' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListGroupsResponse { /// Output only. The list of groups response. #[prost(message, repeated, tag = "1")] pub groups: ::prost::alloc::vec::Vec, /// Output only. A token, which can be sent as `page_token` to retrieve the next page. /// If this field is omitted, there are no subsequent pages. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, /// Output only. Locations that could not be reached. #[prost(string, repeated, tag = "3")] pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Request message for 'GetGroup' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetGroupRequest { /// Required. The group name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Request message for 'CreateGroup' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateGroupRequest { /// Required. The Group's parent. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The group identifier. #[prost(string, tag = "2")] pub group_id: ::prost::alloc::string::String, /// Required. The create request body. #[prost(message, optional, tag = "3")] pub group: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "4")] pub request_id: ::prost::alloc::string::String, } /// Update message for 'UpdateGroups' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct UpdateGroupRequest { /// Field mask is used to specify the fields to be overwritten in the /// Group resource by the update. /// The fields specified in the update_mask are relative to the resource, not /// the full request. A field will be overwritten if it is in the mask. If the /// user does not provide a mask then all fields will be overwritten. #[prost(message, optional, tag = "1")] pub update_mask: ::core::option::Option<::prost_types::FieldMask>, /// Required. The update request body. #[prost(message, optional, tag = "2")] pub group: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "3")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'DeleteGroup' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct DeleteGroupRequest { /// Required. The Group name. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, /// Optional. A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes after the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "2")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'AddGroupMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AddGroupMigrationRequest { /// Required. The full path name of the Group to add to. #[prost(string, tag = "1")] pub group: ::prost::alloc::string::String, /// The full path name of the MigratingVm to add. #[prost(string, tag = "2")] pub migrating_vm: ::prost::alloc::string::String, } /// Response message for 'AddGroupMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct AddGroupMigrationResponse {} /// Request message for 'RemoveMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RemoveGroupMigrationRequest { /// Required. The name of the Group. #[prost(string, tag = "1")] pub group: ::prost::alloc::string::String, /// The MigratingVm to remove. #[prost(string, tag = "2")] pub migrating_vm: ::prost::alloc::string::String, } /// Response message for 'RemoveMigration' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct RemoveGroupMigrationResponse {} /// Request message for 'CreateCutoverJob' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CreateCutoverJobRequest { /// Required. The Cutover's parent. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Required. The cutover job identifier. #[prost(string, tag = "2")] pub cutover_job_id: ::prost::alloc::string::String, /// Required. The cutover request body. #[prost(message, optional, tag = "3")] pub cutover_job: ::core::option::Option, /// A request ID to identify requests. Specify a unique request ID /// so that if you must retry your request, the server will know to ignore /// the request if it has already been completed. The server will guarantee /// that for at least 60 minutes since the first request. /// /// For example, consider a situation where you make an initial request and t /// he request times out. If you make the request again with the same request /// ID, the server can check if original operation with the same request ID /// was received, and if so, will ignore the second request. This prevents /// clients from accidentally creating duplicate commitments. /// /// The request ID must be a valid UUID with the exception that zero UUID is /// not supported (00000000-0000-0000-0000-000000000000). #[prost(string, tag = "4")] pub request_id: ::prost::alloc::string::String, } /// Request message for 'CancelCutoverJob' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelCutoverJobRequest { /// Required. The cutover job id #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Response message for 'CancelCutoverJob' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct CancelCutoverJobResponse {} /// Request message for 'ListCutoverJobsRequest' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListCutoverJobsRequest { /// Required. The parent, which owns this collection of migrating VMs. #[prost(string, tag = "1")] pub parent: ::prost::alloc::string::String, /// Optional. The maximum number of cutover jobs to return. The service may return /// fewer than this value. If unspecified, at most 500 cutover jobs will be /// returned. The maximum value is 1000; values above 1000 will be coerced to /// 1000. #[prost(int32, tag = "2")] pub page_size: i32, /// Required. A page token, received from a previous `ListCutoverJobs` call. /// Provide this to retrieve the subsequent page. /// /// When paginating, all other parameters provided to `ListCutoverJobs` must /// match the call that provided the page token. #[prost(string, tag = "3")] pub page_token: ::prost::alloc::string::String, /// Optional. The filter request. #[prost(string, tag = "4")] pub filter: ::prost::alloc::string::String, /// Optional. the order by fields for the result. #[prost(string, tag = "5")] pub order_by: ::prost::alloc::string::String, } /// Response message for 'ListCutoverJobs' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct ListCutoverJobsResponse { /// Output only. The list of cutover jobs response. #[prost(message, repeated, tag = "1")] pub cutover_jobs: ::prost::alloc::vec::Vec, /// Output only. A token, which can be sent as `page_token` to retrieve the next page. /// If this field is omitted, there are no subsequent pages. #[prost(string, tag = "2")] pub next_page_token: ::prost::alloc::string::String, /// Output only. Locations that could not be reached. #[prost(string, repeated, tag = "3")] pub unreachable: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, } /// Request message for 'GetCutoverJob' request. #[derive(Clone, PartialEq, ::prost::Message)] pub struct GetCutoverJobRequest { /// Required. The name of the CutoverJob. #[prost(string, tag = "1")] pub name: ::prost::alloc::string::String, } /// Represents the metadata of the long-running operation. #[derive(Clone, PartialEq, ::prost::Message)] pub struct OperationMetadata { /// Output only. The time the operation was created. #[prost(message, optional, tag = "1")] pub create_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. The time the operation finished running. #[prost(message, optional, tag = "2")] pub end_time: ::core::option::Option<::prost_types::Timestamp>, /// Output only. Server-defined resource path for the target of the operation. #[prost(string, tag = "3")] pub target: ::prost::alloc::string::String, /// Output only. Name of the verb executed by the operation. #[prost(string, tag = "4")] pub verb: ::prost::alloc::string::String, /// Output only. Human-readable status of the operation, if any. #[prost(string, tag = "5")] pub status_message: ::prost::alloc::string::String, /// Output only. Identifies whether the user has requested cancellation /// of the operation. Operations that have successfully been cancelled /// have \[Operation.error][\] value with a \[google.rpc.Status.code][google.rpc.Status.code\] of 1, /// corresponding to `Code.CANCELLED`. #[prost(bool, tag = "6")] pub requested_cancellation: bool, /// Output only. API version used to start the operation. #[prost(string, tag = "7")] pub api_version: ::prost::alloc::string::String, } /// Represents migration resource error information that can be used with /// google.rpc.Status message. MigrationError is used to present the user with /// error information in migration operations. #[derive(Clone, PartialEq, ::prost::Message)] pub struct MigrationError { /// Output only. The error code. #[prost(enumeration = "migration_error::ErrorCode", tag = "1")] pub code: i32, /// Output only. The localized error message. #[prost(message, optional, tag = "2")] pub error_message: ::core::option::Option, /// Output only. Suggested action for solving the error. #[prost(message, optional, tag = "3")] pub action_item: ::core::option::Option, /// Output only. URL(s) pointing to additional information on handling the current error. #[prost(message, repeated, tag = "4")] pub help_links: ::prost::alloc::vec::Vec, /// Output only. The time the error occurred. #[prost(message, optional, tag = "5")] pub error_time: ::core::option::Option<::prost_types::Timestamp>, } /// Nested message and enum types in `MigrationError`. pub mod migration_error { /// Represents resource error codes. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ErrorCode { /// Default value. This value is not used. Unspecified = 0, /// Migrate for Compute encountered an unknown error. UnknownError = 1, /// Migrate for Compute encountered an error while validating replication /// source health. SourceValidationError = 2, /// Migrate for Compute encountered an error during source data operation. SourceReplicationError = 3, /// Migrate for Compute encountered an error during target data operation. TargetReplicationError = 4, /// Migrate for Compute encountered an error during OS adaptation. OsAdaptationError = 5, /// Migrate for Compute encountered an error in clone operation. CloneError = 6, /// Migrate for Compute encountered an error in cutover operation. CutoverError = 7, /// Migrate for Compute encountered an error during utilization report /// creation. UtilizationReportError = 8, } } /// Controls the level of details of a Utilization Report. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum UtilizationReportView { /// The default / unset value. /// The API will default to FULL on single report request and BASIC for /// multiple reports request. Unspecified = 0, /// Get the report metadata, without the list of VMs and their utilization /// info. Basic = 1, /// Include everything. Full = 2, } /// Types of disks supported for Compute Engine VM. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ComputeEngineDiskType { /// An unspecified disk type. Will be used as STANDARD. Unspecified = 0, /// A Standard disk type. Standard = 1, /// SSD hard disk type. Ssd = 2, /// An alternative to SSD persistent disks that balance performance and /// cost. Balanced = 3, } /// Types of licenses used in OS adaptation. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ComputeEngineLicenseType { /// The license type is the default for the OS. Default = 0, /// The license type is Pay As You Go license type. Payg = 1, /// The license type is Bring Your Own License type. Byol = 2, } /// Possible values for vm boot option. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] #[repr(i32)] pub enum ComputeEngineBootOption { /// The boot option is unknown. Unspecified = 0, /// The boot option is EFI. Efi = 1, /// The boot option is BIOS. Bios = 2, } #[doc = r" Generated client implementations."] pub mod vm_migration_client { #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)] use tonic::codegen::*; #[doc = " VM Migration Service"] #[derive(Debug, Clone)] pub struct VmMigrationClient { inner: tonic::client::Grpc, } impl VmMigrationClient where T: tonic::client::GrpcService, T::ResponseBody: Body + Send + 'static, T::Error: Into, ::Error: Into + Send, { pub fn new(inner: T) -> Self { let inner = tonic::client::Grpc::new(inner); Self { inner } } pub fn with_interceptor( inner: T, interceptor: F, ) -> VmMigrationClient> where F: tonic::service::Interceptor, T: tonic::codegen::Service< http::Request, Response = http::Response< >::ResponseBody, >, >, >>::Error: Into + Send + Sync, { VmMigrationClient::new(InterceptedService::new(inner, interceptor)) } #[doc = r" Compress requests with `gzip`."] #[doc = r""] #[doc = r" This requires the server to support it otherwise it might respond with an"] #[doc = r" error."] pub fn send_gzip(mut self) -> Self { self.inner = self.inner.send_gzip(); self } #[doc = r" Enable decompressing responses with `gzip`."] pub fn accept_gzip(mut self) -> Self { self.inner = self.inner.accept_gzip(); self } #[doc = " Lists Sources in a given project and location."] pub async fn list_sources( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ListSources", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets details of a single Source."] pub async fn get_source( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/GetSource", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates a new Source in a given project and location."] pub async fn create_source( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CreateSource", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Updates the parameters of a single Source."] pub async fn update_source( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/UpdateSource", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Deletes a single Source."] pub async fn delete_source( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/DeleteSource", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " List remote source's inventory of VMs."] #[doc = " The remote source is the onprem vCenter (remote in the sense it's not in"] #[doc = " Compute Engine). The inventory describes the list of existing VMs in that"] #[doc = " source. Note that this operation lists the VMs on the remote source, as"] #[doc = " opposed to listing the MigratingVms resources in the vmmigration service."] pub async fn fetch_inventory( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/FetchInventory", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists Utilization Reports of the given Source."] pub async fn list_utilization_reports( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ListUtilizationReports", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets a single Utilization Report."] pub async fn get_utilization_report( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/GetUtilizationReport", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates a new UtilizationReport."] pub async fn create_utilization_report( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CreateUtilizationReport", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Deletes a single Utilization Report."] pub async fn delete_utilization_report( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/DeleteUtilizationReport", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists DatacenterConnectors in a given Source."] pub async fn list_datacenter_connectors( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ListDatacenterConnectors", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets details of a single DatacenterConnector."] pub async fn get_datacenter_connector( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/GetDatacenterConnector", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates a new DatacenterConnector in a given Source."] pub async fn create_datacenter_connector( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CreateDatacenterConnector", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Deletes a single DatacenterConnector."] pub async fn delete_datacenter_connector( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/DeleteDatacenterConnector", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates a new MigratingVm in a given Source."] pub async fn create_migrating_vm( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CreateMigratingVm", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists MigratingVms in a given Source."] pub async fn list_migrating_vms( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ListMigratingVms", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets details of a single MigratingVm."] pub async fn get_migrating_vm( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/GetMigratingVm", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Updates the parameters of a single MigratingVm."] pub async fn update_migrating_vm( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/UpdateMigratingVm", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Deletes a single MigratingVm."] pub async fn delete_migrating_vm( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/DeleteMigratingVm", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Starts migration for a VM. Starts the process of uploading"] #[doc = " data and creating snapshots, in replication cycles scheduled by the policy."] pub async fn start_migration( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/StartMigration", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Resumes a migration for a VM. When called on a paused migration, will start"] #[doc = " the process of uploading data and creating snapshots; when called on a"] #[doc = " completed cut-over migration, will update the migration to active state and"] #[doc = " start the process of uploading data and creating snapshots."] pub async fn resume_migration( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ResumeMigration", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Pauses a migration for a VM. If cycle tasks are running they will be"] #[doc = " cancelled, preserving source task data. Further replication cycles will not"] #[doc = " be triggered while the VM is paused."] pub async fn pause_migration( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/PauseMigration", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Marks a migration as completed, deleting migration resources that are no"] #[doc = " longer being used. Only applicable after cutover is done."] pub async fn finalize_migration( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/FinalizeMigration", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Initiates a Clone of a specific migrating VM."] pub async fn create_clone_job( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CreateCloneJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Initiates the cancellation of a running clone job."] pub async fn cancel_clone_job( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CancelCloneJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists CloneJobs of a given migrating VM."] pub async fn list_clone_jobs( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ListCloneJobs", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets details of a single CloneJob."] pub async fn get_clone_job( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/GetCloneJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Initiates a Cutover of a specific migrating VM."] #[doc = " The returned LRO is completed when the cutover job resource is created"] #[doc = " and the job is initiated."] pub async fn create_cutover_job( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CreateCutoverJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Initiates the cancellation of a running cutover job."] pub async fn cancel_cutover_job( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CancelCutoverJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists CutoverJobs of a given migrating VM."] pub async fn list_cutover_jobs( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ListCutoverJobs", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets details of a single CutoverJob."] pub async fn get_cutover_job( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/GetCutoverJob", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists Groups in a given project and location."] pub async fn list_groups( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ListGroups", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets details of a single Group."] pub async fn get_group( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/GetGroup", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates a new Group in a given project and location."] pub async fn create_group( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CreateGroup", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Updates the parameters of a single Group."] pub async fn update_group( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/UpdateGroup", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Deletes a single Group."] pub async fn delete_group( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/DeleteGroup", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Adds a MigratingVm to a Group."] pub async fn add_group_migration( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/AddGroupMigration", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Removes a MigratingVm from a Group."] pub async fn remove_group_migration( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/RemoveGroupMigration", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Lists TargetProjects in a given project."] #[doc = ""] #[doc = " NOTE: TargetProject is a global resource; hence the only supported value"] #[doc = " for location is `global`."] pub async fn list_target_projects( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/ListTargetProjects", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Gets details of a single TargetProject."] #[doc = ""] #[doc = " NOTE: TargetProject is a global resource; hence the only supported value"] #[doc = " for location is `global`."] pub async fn get_target_project( &mut self, request: impl tonic::IntoRequest, ) -> Result, tonic::Status> { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/GetTargetProject", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Creates a new TargetProject in a given project."] #[doc = ""] #[doc = " NOTE: TargetProject is a global resource; hence the only supported value"] #[doc = " for location is `global`."] pub async fn create_target_project( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/CreateTargetProject", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Updates the parameters of a single TargetProject."] #[doc = ""] #[doc = " NOTE: TargetProject is a global resource; hence the only supported value"] #[doc = " for location is `global`."] pub async fn update_target_project( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/UpdateTargetProject", ); self.inner.unary(request.into_request(), path, codec).await } #[doc = " Deletes a single TargetProject."] #[doc = ""] #[doc = " NOTE: TargetProject is a global resource; hence the only supported value"] #[doc = " for location is `global`."] pub async fn delete_target_project( &mut self, request: impl tonic::IntoRequest, ) -> Result< tonic::Response, tonic::Status, > { self.inner.ready().await.map_err(|e| { tonic::Status::new( tonic::Code::Unknown, format!("Service was not ready: {}", e.into()), ) })?; let codec = tonic::codec::ProstCodec::default(); let path = http::uri::PathAndQuery::from_static( "/google.cloud.vmmigration.v1.VmMigration/DeleteTargetProject", ); self.inner.unary(request.into_request(), path, codec).await } } }