Struct google_api_proto::google::api::servicemanagement::v1::service_manager_client::ServiceManagerClient

pub struct ServiceManagerClient<T> { /* private fields */ }

Google Service Management API

Implementations

impl<T> ServiceManagerClient<T>

where T: GrpcService<BoxBody>, T::Error: Into<StdError>, T::ResponseBody: Body<Data = Bytes> + Send + 'static, <T::ResponseBody as Body>::Error: Into<StdError> + Send,

pub fn new(inner: T) -> Self

pub fn with_origin(inner: T, origin: Uri) -> Self

pub fn with_interceptor<F>( inner: T, interceptor: F, ) -> ServiceManagerClient<InterceptedService<T, F>>

where F: Interceptor, T::ResponseBody: Default, T: Service<Request<BoxBody>, Response = Response<<T as GrpcService<BoxBody>>::ResponseBody>>, <T as Service<Request<BoxBody>>>::Error: Into<StdError> + Send + Sync,

pub fn send_compressed(self, encoding: CompressionEncoding) -> Self

Compress requests with the given encoding.

This requires the server to support it otherwise it might respond with an error.

pub fn accept_compressed(self, encoding: CompressionEncoding) -> Self

Enable decompressing responses.

pub fn max_decoding_message_size(self, limit: usize) -> Self

Limits the maximum size of a decoded message.

Default: 4MB

pub fn max_encoding_message_size(self, limit: usize) -> Self

Limits the maximum size of an encoded message.

Default: usize::MAX

pub async fn list_services( &mut self, request: impl IntoRequest<ListServicesRequest>, ) -> Result<Response<ListServicesResponse>, Status>

Lists managed services.

Returns all public services. For authenticated users, also returns all services the calling user has “servicemanagement.services.get” permission for.

pub async fn get_service( &mut self, request: impl IntoRequest<GetServiceRequest>, ) -> Result<Response<ManagedService>, Status>

Gets a managed service. Authentication is required unless the service is public.

pub async fn create_service( &mut self, request: impl IntoRequest<CreateServiceRequest>, ) -> Result<Response<Operation>, Status>

Creates a new managed service.

A managed service is immutable, and is subject to mandatory 30-day data retention. You cannot move a service or recreate it within 30 days after deletion.

One producer project can own no more than 500 services. For security and reliability purposes, a production service should be hosted in a dedicated producer project.

Operation<response: ManagedService>

pub async fn delete_service( &mut self, request: impl IntoRequest<DeleteServiceRequest>, ) -> Result<Response<Operation>, Status>

Deletes a managed service. This method will change the service to the Soft-Delete state for 30 days. Within this period, service producers may call [UndeleteService][google.api.servicemanagement.v1.ServiceManager.UndeleteService] to restore the service. After 30 days, the service will be permanently deleted.

Operation<response: google.protobuf.Empty>

pub async fn undelete_service( &mut self, request: impl IntoRequest<UndeleteServiceRequest>, ) -> Result<Response<Operation>, Status>

Revives a previously deleted managed service. The method restores the service using the configuration at the time the service was deleted. The target service must exist and must have been deleted within the last 30 days.

Operation<response: UndeleteServiceResponse>

pub async fn list_service_configs( &mut self, request: impl IntoRequest<ListServiceConfigsRequest>, ) -> Result<Response<ListServiceConfigsResponse>, Status>

Lists the history of the service configuration for a managed service, from the newest to the oldest.

pub async fn get_service_config( &mut self, request: impl IntoRequest<GetServiceConfigRequest>, ) -> Result<Response<Service>, Status>

Gets a service configuration (version) for a managed service.

pub async fn create_service_config( &mut self, request: impl IntoRequest<CreateServiceConfigRequest>, ) -> Result<Response<Service>, Status>

Creates a new service configuration (version) for a managed service. This method only stores the service configuration. To roll out the service configuration to backend systems please call [CreateServiceRollout][google.api.servicemanagement.v1.ServiceManager.CreateServiceRollout].

Only the 100 most recent service configurations and ones referenced by existing rollouts are kept for each service. The rest will be deleted eventually.

pub async fn submit_config_source( &mut self, request: impl IntoRequest<SubmitConfigSourceRequest>, ) -> Result<Response<Operation>, Status>

Creates a new service configuration (version) for a managed service based on user-supplied configuration source files (for example: OpenAPI Specification). This method stores the source configurations as well as the generated service configuration. To rollout the service configuration to other services, please call [CreateServiceRollout][google.api.servicemanagement.v1.ServiceManager.CreateServiceRollout].

Only the 100 most recent configuration sources and ones referenced by existing service configurtions are kept for each service. The rest will be deleted eventually.

Operation<response: SubmitConfigSourceResponse>

pub async fn list_service_rollouts( &mut self, request: impl IntoRequest<ListServiceRolloutsRequest>, ) -> Result<Response<ListServiceRolloutsResponse>, Status>

Lists the history of the service configuration rollouts for a managed service, from the newest to the oldest.

pub async fn get_service_rollout( &mut self, request: impl IntoRequest<GetServiceRolloutRequest>, ) -> Result<Response<Rollout>, Status>

Gets a service configuration [rollout][google.api.servicemanagement.v1.Rollout].

pub async fn create_service_rollout( &mut self, request: impl IntoRequest<CreateServiceRolloutRequest>, ) -> Result<Response<Operation>, Status>

Creates a new service configuration rollout. Based on rollout, the Google Service Management will roll out the service configurations to different backend services. For example, the logging configuration will be pushed to Google Cloud Logging.

Please note that any previous pending and running Rollouts and associated Operations will be automatically cancelled so that the latest Rollout will not be blocked by previous Rollouts.

Only the 100 most recent (in any state) and the last 10 successful (if not already part of the set of 100 most recent) rollouts are kept for each service. The rest will be deleted eventually.

Operation<response: Rollout>

pub async fn generate_config_report( &mut self, request: impl IntoRequest<GenerateConfigReportRequest>, ) -> Result<Response<GenerateConfigReportResponse>, Status>

Generates and returns a report (errors, warnings and changes from existing configurations) associated with GenerateConfigReportRequest.new_value

If GenerateConfigReportRequest.old_value is specified, GenerateConfigReportRequest will contain a single ChangeReport based on the comparison between GenerateConfigReportRequest.new_value and GenerateConfigReportRequest.old_value. If GenerateConfigReportRequest.old_value is not specified, this method will compare GenerateConfigReportRequest.new_value with the last pushed service configuration.

Trait Implementations

impl<T: Clone> Clone for ServiceManagerClient<T>

fn clone(&self) -> ServiceManagerClient<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for ServiceManagerClient<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.