#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommonMetadata {
#[prost(message, optional, tag = "1")]
pub start_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(message, optional, tag = "2")]
pub end_time: ::core::option::Option<::prost_types::Timestamp>,
#[prost(enumeration = "OperationType", tag = "3")]
pub operation_type: i32,
#[prost(map = "string, string", tag = "4")]
pub labels:
::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
#[prost(enumeration = "common_metadata::State", tag = "5")]
pub state: i32,
}
pub mod common_metadata {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum State {
Unspecified = 0,
Initializing = 1,
Processing = 2,
Cancelling = 3,
Finalizing = 4,
Successful = 5,
Failed = 6,
Cancelled = 7,
}
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Progress {
#[prost(int64, tag = "1")]
pub work_completed: i64,
#[prost(int64, tag = "2")]
pub work_estimated: i64,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExportEntitiesRequest {
#[prost(string, tag = "1")]
pub project_id: ::prost::alloc::string::String,
#[prost(map = "string, string", tag = "2")]
pub labels:
::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
#[prost(message, optional, tag = "3")]
pub entity_filter: ::core::option::Option<EntityFilter>,
#[prost(string, tag = "4")]
pub output_url_prefix: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportEntitiesRequest {
#[prost(string, tag = "1")]
pub project_id: ::prost::alloc::string::String,
#[prost(map = "string, string", tag = "2")]
pub labels:
::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
#[prost(string, tag = "3")]
pub input_url: ::prost::alloc::string::String,
#[prost(message, optional, tag = "4")]
pub entity_filter: ::core::option::Option<EntityFilter>,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExportEntitiesResponse {
#[prost(string, tag = "1")]
pub output_url: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExportEntitiesMetadata {
#[prost(message, optional, tag = "1")]
pub common: ::core::option::Option<CommonMetadata>,
#[prost(message, optional, tag = "2")]
pub progress_entities: ::core::option::Option<Progress>,
#[prost(message, optional, tag = "3")]
pub progress_bytes: ::core::option::Option<Progress>,
#[prost(message, optional, tag = "4")]
pub entity_filter: ::core::option::Option<EntityFilter>,
#[prost(string, tag = "5")]
pub output_url_prefix: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ImportEntitiesMetadata {
#[prost(message, optional, tag = "1")]
pub common: ::core::option::Option<CommonMetadata>,
#[prost(message, optional, tag = "2")]
pub progress_entities: ::core::option::Option<Progress>,
#[prost(message, optional, tag = "3")]
pub progress_bytes: ::core::option::Option<Progress>,
#[prost(message, optional, tag = "4")]
pub entity_filter: ::core::option::Option<EntityFilter>,
#[prost(string, tag = "5")]
pub input_url: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntityFilter {
#[prost(string, repeated, tag = "1")]
pub kinds: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
#[prost(string, repeated, tag = "2")]
pub namespace_ids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum OperationType {
Unspecified = 0,
ExportEntities = 1,
ImportEntities = 2,
}
#[doc = r" Generated client implementations."]
pub mod datastore_admin_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Google Cloud Datastore Admin API"]
#[doc = ""]
#[doc = " The Datastore Admin API provides several admin services for Cloud Datastore."]
#[doc = ""]
#[doc = " -----------------------------------------------------------------------------"]
#[doc = " ## Concepts"]
#[doc = ""]
#[doc = " Project, namespace, kind, and entity as defined in the Google Cloud Datastore"]
#[doc = " API."]
#[doc = ""]
#[doc = " Operation: An Operation represents work being performed in the background."]
#[doc = ""]
#[doc = " EntityFilter: Allows specifying a subset of entities in a project. This is"]
#[doc = " specified as a combination of kinds and namespaces (either or both of which"]
#[doc = " may be all)."]
#[doc = ""]
#[doc = " -----------------------------------------------------------------------------"]
#[doc = " ## Services"]
#[doc = ""]
#[doc = " # Export/Import"]
#[doc = ""]
#[doc = " The Export/Import service provides the ability to copy all or a subset of"]
#[doc = " entities to/from Google Cloud Storage."]
#[doc = ""]
#[doc = " Exported data may be imported into Cloud Datastore for any Google Cloud"]
#[doc = " Platform project. It is not restricted to the export source project. It is"]
#[doc = " possible to export from one project and then import into another."]
#[doc = ""]
#[doc = " Exported data can also be loaded into Google BigQuery for analysis."]
#[doc = ""]
#[doc = " Exports and imports are performed asynchronously. An Operation resource is"]
#[doc = " created for each export/import. The state (including any errors encountered)"]
#[doc = " of the export/import may be queried via the Operation resource."]
#[doc = ""]
#[doc = " # Operation"]
#[doc = ""]
#[doc = " The Operations collection provides a record of actions performed for the"]
#[doc = " specified project (including any operations in progress). Operations are not"]
#[doc = " created directly but through calls on other collections or resources."]
#[doc = ""]
#[doc = " An operation that is not yet done may be cancelled. The request to cancel is"]
#[doc = " asynchronous and the operation may continue to run for some time after the"]
#[doc = " request to cancel is made."]
#[doc = ""]
#[doc = " An operation that is done may be deleted so that it is no longer listed as"]
#[doc = " part of the Operation collection."]
#[doc = ""]
#[doc = " ListOperations returns all pending operations, but not completed operations."]
#[doc = ""]
#[doc = " Operations are created by service DatastoreAdmin,"]
#[doc = " but are accessed via service google.longrunning.Operations."]
#[derive(Debug, Clone)]
pub struct DatastoreAdminClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> DatastoreAdminClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> DatastoreAdminClient<InterceptedService<T, F>>
where
F: tonic::service::Interceptor,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
DatastoreAdminClient::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 = " Exports a copy of all or a subset of entities from Google Cloud Datastore"]
#[doc = " to another storage system, such as Google Cloud Storage. Recent updates to"]
#[doc = " entities may not be reflected in the export. The export occurs in the"]
#[doc = " background and its progress can be monitored and managed via the"]
#[doc = " Operation resource that is created. The output of an export may only be"]
#[doc = " used once the associated operation is done. If an export operation is"]
#[doc = " cancelled before completion it may leave partial data behind in Google"]
#[doc = " Cloud Storage."]
pub async fn export_entities(
&mut self,
request: impl tonic::IntoRequest<super::ExportEntitiesRequest>,
) -> Result<
tonic::Response<super::super::super::super::longrunning::Operation>,
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.datastore.admin.v1beta1.DatastoreAdmin/ExportEntities",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Imports entities into Google Cloud Datastore. Existing entities with the"]
#[doc = " same key are overwritten. The import occurs in the background and its"]
#[doc = " progress can be monitored and managed via the Operation resource that is"]
#[doc = " created. If an ImportEntities operation is cancelled, it is possible"]
#[doc = " that a subset of the data has already been imported to Cloud Datastore."]
pub async fn import_entities(
&mut self,
request: impl tonic::IntoRequest<super::ImportEntitiesRequest>,
) -> Result<
tonic::Response<super::super::super::super::longrunning::Operation>,
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.datastore.admin.v1beta1.DatastoreAdmin/ImportEntities",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
}