Class ServiceManagerClient (2.0.0)

public abstract class ServiceManagerClient

ServiceManager client wrapper, for convenient use.

Inheritance

Object > ServiceManagerClient

Inherited Members

Object.GetHashCode()

Object.GetType()

Object.MemberwiseClone()

Object.ToString()

Derived Types

ServiceManagerClientImpl

Namespace

Google.Cloud.ServiceManagement.V1

Assembly

Google.Cloud.ServiceManagement.V1.dll

Remarks

Google Service Management API

Properties

CreateServiceOperationsClient

public virtual OperationsClient CreateServiceOperationsClient { get; }

The long-running operations client for CreateService.

Property Value
Type	Description
`OperationsClient`

CreateServiceRolloutOperationsClient

public virtual OperationsClient CreateServiceRolloutOperationsClient { get; }

The long-running operations client for CreateServiceRollout.

Property Value
Type	Description
`OperationsClient`

DefaultEndpoint

public static string DefaultEndpoint { get; }

The default endpoint for the ServiceManager service, which is a host of "servicemanagement.googleapis.com" and a port of 443.

Property Value
Type	Description
`String`

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

The default ServiceManager scopes.

Property Value
Type	Description
`IReadOnlyList<String>`

Remarks

The default ServiceManager scopes are:

DeleteServiceOperationsClient

public virtual OperationsClient DeleteServiceOperationsClient { get; }

The long-running operations client for DeleteService.

Property Value
Type	Description
`OperationsClient`

GrpcClient

public virtual ServiceManager.ServiceManagerClient GrpcClient { get; }

The underlying gRPC ServiceManager client

Property Value
Type	Description
`ServiceManager.ServiceManagerClient`

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

The service metadata associated with this client type.

Property Value
Type	Description
`ServiceMetadata`

SubmitConfigSourceOperationsClient

public virtual OperationsClient SubmitConfigSourceOperationsClient { get; }

The long-running operations client for SubmitConfigSource.

Property Value
Type	Description
`OperationsClient`

UndeleteServiceOperationsClient

public virtual OperationsClient UndeleteServiceOperationsClient { get; }

The long-running operations client for UndeleteService.

Property Value
Type	Description
`OperationsClient`

Methods

Create()

public static ServiceManagerClient Create()

Synchronously creates a ServiceManagerClient using the default credentials, endpoint and settings. To specify custom credentials or other settings, use ServiceManagerClientBuilder.

Returns
Type	Description
`ServiceManagerClient`	The created ServiceManagerClient.

CreateAsync(CancellationToken)

public static Task<ServiceManagerClient> CreateAsync(CancellationToken cancellationToken = default(CancellationToken))

Asynchronously creates a ServiceManagerClient using the default credentials, endpoint and settings. To specify custom credentials or other settings, use ServiceManagerClientBuilder.

Parameter
Name	Description
`cancellationToken`	`CancellationToken` The CancellationToken to use while creating the client.

Returns
Type	Description
`Task<ServiceManagerClient>`	The task representing the created ServiceManagerClient.

CreateService(CreateServiceRequest, CallSettings)

public virtual Operation<ManagedService, OperationMetadata> CreateService(CreateServiceRequest request, CallSettings callSettings = null)

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>

Parameters
Name	Description
`request`	`CreateServiceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<ManagedService, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
CreateServiceRequest request = new CreateServiceRequest
{
    Service = new ManagedService(),
};
// Make the request
Operation<ManagedService, OperationMetadata> response = serviceManagerClient.CreateService(request);

// Poll until the returned long-running operation is complete
Operation<ManagedService, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
ManagedService result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<ManagedService, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceCreateService(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    ManagedService retrievedResult = retrievedResponse.Result;
}

CreateService(ManagedService, CallSettings)

public virtual Operation<ManagedService, OperationMetadata> CreateService(ManagedService service, CallSettings callSettings = null)

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>

Parameters
Name	Description
`service`	`ManagedService` Required. Initial values for the service resource.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<ManagedService, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
ManagedService service = new ManagedService();
// Make the request
Operation<ManagedService, OperationMetadata> response = serviceManagerClient.CreateService(service);

// Poll until the returned long-running operation is complete
Operation<ManagedService, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
ManagedService result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<ManagedService, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceCreateService(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    ManagedService retrievedResult = retrievedResponse.Result;
}

CreateServiceAsync(CreateServiceRequest, CallSettings)

public virtual Task<Operation<ManagedService, OperationMetadata>> CreateServiceAsync(CreateServiceRequest request, CallSettings callSettings = null)

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>

Parameters
Name	Description
`request`	`CreateServiceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<ManagedService, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
CreateServiceRequest request = new CreateServiceRequest
{
    Service = new ManagedService(),
};
// Make the request
Operation<ManagedService, OperationMetadata> response = await serviceManagerClient.CreateServiceAsync(request);

// Poll until the returned long-running operation is complete
Operation<ManagedService, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
ManagedService result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<ManagedService, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceCreateServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    ManagedService retrievedResult = retrievedResponse.Result;
}

CreateServiceAsync(CreateServiceRequest, CancellationToken)

public virtual Task<Operation<ManagedService, OperationMetadata>> CreateServiceAsync(CreateServiceRequest request, CancellationToken cancellationToken)

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>

Parameters
Name	Description
`request`	`CreateServiceRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<ManagedService, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
CreateServiceRequest request = new CreateServiceRequest
{
    Service = new ManagedService(),
};
// Make the request
Operation<ManagedService, OperationMetadata> response = await serviceManagerClient.CreateServiceAsync(request);

// Poll until the returned long-running operation is complete
Operation<ManagedService, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
ManagedService result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<ManagedService, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceCreateServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    ManagedService retrievedResult = retrievedResponse.Result;
}

CreateServiceAsync(ManagedService, CallSettings)

public virtual Task<Operation<ManagedService, OperationMetadata>> CreateServiceAsync(ManagedService service, CallSettings callSettings = null)

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>

Parameters
Name	Description
`service`	`ManagedService` Required. Initial values for the service resource.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<ManagedService, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
ManagedService service = new ManagedService();
// Make the request
Operation<ManagedService, OperationMetadata> response = await serviceManagerClient.CreateServiceAsync(service);

// Poll until the returned long-running operation is complete
Operation<ManagedService, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
ManagedService result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<ManagedService, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceCreateServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    ManagedService retrievedResult = retrievedResponse.Result;
}

CreateServiceAsync(ManagedService, CancellationToken)

public virtual Task<Operation<ManagedService, OperationMetadata>> CreateServiceAsync(ManagedService service, CancellationToken cancellationToken)

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>

Parameters
Name	Description
`service`	`ManagedService` Required. Initial values for the service resource.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<ManagedService, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
ManagedService service = new ManagedService();
// Make the request
Operation<ManagedService, OperationMetadata> response = await serviceManagerClient.CreateServiceAsync(service);

// Poll until the returned long-running operation is complete
Operation<ManagedService, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
ManagedService result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<ManagedService, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceCreateServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    ManagedService retrievedResult = retrievedResponse.Result;
}

CreateServiceConfig(CreateServiceConfigRequest, CallSettings)

public virtual Service CreateServiceConfig(CreateServiceConfigRequest request, CallSettings callSettings = null)

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.

Parameters
Name	Description
`request`	`CreateServiceConfigRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Service`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
CreateServiceConfigRequest request = new CreateServiceConfigRequest
{
    ServiceName = "",
    ServiceConfig = new Service(),
};
// Make the request
Service response = serviceManagerClient.CreateServiceConfig(request);

CreateServiceConfig(String, Service, CallSettings)

public virtual Service CreateServiceConfig(string serviceName, Service serviceConfig, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`serviceConfig`	`Service` Required. The service configuration resource.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Service`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
Service serviceConfig = new Service();
// Make the request
Service response = serviceManagerClient.CreateServiceConfig(serviceName, serviceConfig);

CreateServiceConfigAsync(CreateServiceConfigRequest, CallSettings)

public virtual Task<Service> CreateServiceConfigAsync(CreateServiceConfigRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`CreateServiceConfigRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Service>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
CreateServiceConfigRequest request = new CreateServiceConfigRequest
{
    ServiceName = "",
    ServiceConfig = new Service(),
};
// Make the request
Service response = await serviceManagerClient.CreateServiceConfigAsync(request);

CreateServiceConfigAsync(CreateServiceConfigRequest, CancellationToken)

public virtual Task<Service> CreateServiceConfigAsync(CreateServiceConfigRequest request, CancellationToken cancellationToken)

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

Parameters
Name	Description
`request`	`CreateServiceConfigRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Service>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
CreateServiceConfigRequest request = new CreateServiceConfigRequest
{
    ServiceName = "",
    ServiceConfig = new Service(),
};
// Make the request
Service response = await serviceManagerClient.CreateServiceConfigAsync(request);

CreateServiceConfigAsync(String, Service, CallSettings)

public virtual Task<Service> CreateServiceConfigAsync(string serviceName, Service serviceConfig, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`serviceConfig`	`Service` Required. The service configuration resource.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Service>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
Service serviceConfig = new Service();
// Make the request
Service response = await serviceManagerClient.CreateServiceConfigAsync(serviceName, serviceConfig);

CreateServiceConfigAsync(String, Service, CancellationToken)

public virtual Task<Service> CreateServiceConfigAsync(string serviceName, Service serviceConfig, CancellationToken cancellationToken)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`serviceConfig`	`Service` Required. The service configuration resource.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Service>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
Service serviceConfig = new Service();
// Make the request
Service response = await serviceManagerClient.CreateServiceConfigAsync(serviceName, serviceConfig);

CreateServiceRollout(CreateServiceRolloutRequest, CallSettings)

public virtual Operation<Rollout, OperationMetadata> CreateServiceRollout(CreateServiceRolloutRequest request, CallSettings callSettings = null)

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>

Parameters
Name	Description
`request`	`CreateServiceRolloutRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Rollout, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
CreateServiceRolloutRequest request = new CreateServiceRolloutRequest
{
    ServiceName = "",
    Rollout = new Rollout(),
};
// Make the request
Operation<Rollout, OperationMetadata> response = serviceManagerClient.CreateServiceRollout(request);

// Poll until the returned long-running operation is complete
Operation<Rollout, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Rollout result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Rollout, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceCreateServiceRollout(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Rollout retrievedResult = retrievedResponse.Result;
}

CreateServiceRollout(String, Rollout, CallSettings)

public virtual Operation<Rollout, OperationMetadata> CreateServiceRollout(string serviceName, Rollout rollout, CallSettings callSettings = null)

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>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`rollout`	`Rollout` Required. The rollout resource. The `service_name` field is output only.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Rollout, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
Rollout rollout = new Rollout();
// Make the request
Operation<Rollout, OperationMetadata> response = serviceManagerClient.CreateServiceRollout(serviceName, rollout);

// Poll until the returned long-running operation is complete
Operation<Rollout, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Rollout result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Rollout, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceCreateServiceRollout(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Rollout retrievedResult = retrievedResponse.Result;
}

CreateServiceRolloutAsync(CreateServiceRolloutRequest, CallSettings)

public virtual Task<Operation<Rollout, OperationMetadata>> CreateServiceRolloutAsync(CreateServiceRolloutRequest request, CallSettings callSettings = null)

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>

Parameters
Name	Description
`request`	`CreateServiceRolloutRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Rollout, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
CreateServiceRolloutRequest request = new CreateServiceRolloutRequest
{
    ServiceName = "",
    Rollout = new Rollout(),
};
// Make the request
Operation<Rollout, OperationMetadata> response = await serviceManagerClient.CreateServiceRolloutAsync(request);

// Poll until the returned long-running operation is complete
Operation<Rollout, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Rollout result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Rollout, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceCreateServiceRolloutAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Rollout retrievedResult = retrievedResponse.Result;
}

CreateServiceRolloutAsync(CreateServiceRolloutRequest, CancellationToken)

public virtual Task<Operation<Rollout, OperationMetadata>> CreateServiceRolloutAsync(CreateServiceRolloutRequest request, CancellationToken cancellationToken)

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>

Parameters
Name	Description
`request`	`CreateServiceRolloutRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Rollout, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
CreateServiceRolloutRequest request = new CreateServiceRolloutRequest
{
    ServiceName = "",
    Rollout = new Rollout(),
};
// Make the request
Operation<Rollout, OperationMetadata> response = await serviceManagerClient.CreateServiceRolloutAsync(request);

// Poll until the returned long-running operation is complete
Operation<Rollout, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Rollout result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Rollout, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceCreateServiceRolloutAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Rollout retrievedResult = retrievedResponse.Result;
}

CreateServiceRolloutAsync(String, Rollout, CallSettings)

public virtual Task<Operation<Rollout, OperationMetadata>> CreateServiceRolloutAsync(string serviceName, Rollout rollout, CallSettings callSettings = null)

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>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`rollout`	`Rollout` Required. The rollout resource. The `service_name` field is output only.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Rollout, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
Rollout rollout = new Rollout();
// Make the request
Operation<Rollout, OperationMetadata> response = await serviceManagerClient.CreateServiceRolloutAsync(serviceName, rollout);

// Poll until the returned long-running operation is complete
Operation<Rollout, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Rollout result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Rollout, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceCreateServiceRolloutAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Rollout retrievedResult = retrievedResponse.Result;
}

CreateServiceRolloutAsync(String, Rollout, CancellationToken)

public virtual Task<Operation<Rollout, OperationMetadata>> CreateServiceRolloutAsync(string serviceName, Rollout rollout, CancellationToken cancellationToken)

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>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`rollout`	`Rollout` Required. The rollout resource. The `service_name` field is output only.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Rollout, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
Rollout rollout = new Rollout();
// Make the request
Operation<Rollout, OperationMetadata> response = await serviceManagerClient.CreateServiceRolloutAsync(serviceName, rollout);

// Poll until the returned long-running operation is complete
Operation<Rollout, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Rollout result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Rollout, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceCreateServiceRolloutAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Rollout retrievedResult = retrievedResponse.Result;
}

DeleteService(DeleteServiceRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteService(DeleteServiceRequest request, CallSettings callSettings = null)

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>

Parameters
Name	Description
`request`	`DeleteServiceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
DeleteServiceRequest request = new DeleteServiceRequest { ServiceName = "", };
// Make the request
Operation<Empty, OperationMetadata> response = serviceManagerClient.DeleteService(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceDeleteService(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteService(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteService(string serviceName, CallSettings callSettings = null)

Operation<response: google.protobuf.Empty>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
// Make the request
Operation<Empty, OperationMetadata> response = serviceManagerClient.DeleteService(serviceName);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceDeleteService(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteServiceAsync(DeleteServiceRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteServiceAsync(DeleteServiceRequest request, CallSettings callSettings = null)

Operation<response: google.protobuf.Empty>

Parameters
Name	Description
`request`	`DeleteServiceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceRequest request = new DeleteServiceRequest { ServiceName = "", };
// Make the request
Operation<Empty, OperationMetadata> response = await serviceManagerClient.DeleteServiceAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceDeleteServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteServiceAsync(DeleteServiceRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteServiceAsync(DeleteServiceRequest request, CancellationToken cancellationToken)

Operation<response: google.protobuf.Empty>

Parameters
Name	Description
`request`	`DeleteServiceRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceRequest request = new DeleteServiceRequest { ServiceName = "", };
// Make the request
Operation<Empty, OperationMetadata> response = await serviceManagerClient.DeleteServiceAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceDeleteServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteServiceAsync(String, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteServiceAsync(string serviceName, CallSettings callSettings = null)

Operation<response: google.protobuf.Empty>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
// Make the request
Operation<Empty, OperationMetadata> response = await serviceManagerClient.DeleteServiceAsync(serviceName);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceDeleteServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteServiceAsync(String, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteServiceAsync(string serviceName, CancellationToken cancellationToken)

Operation<response: google.protobuf.Empty>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<Empty, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
// Make the request
Operation<Empty, OperationMetadata> response = await serviceManagerClient.DeleteServiceAsync(serviceName);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceDeleteServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

GenerateConfigReport(GenerateConfigReportRequest, CallSettings)

public virtual GenerateConfigReportResponse GenerateConfigReport(GenerateConfigReportRequest request, CallSettings callSettings = null)

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.

Parameters
Name	Description
`request`	`GenerateConfigReportRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`GenerateConfigReportResponse`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
GenerateConfigReportRequest request = new GenerateConfigReportRequest
{
    NewConfig = new Any(),
    OldConfig = new Any(),
};
// Make the request
GenerateConfigReportResponse response = serviceManagerClient.GenerateConfigReport(request);

GenerateConfigReport(Any, Any, CallSettings)

public virtual GenerateConfigReportResponse GenerateConfigReport(Any newConfig, Any oldConfig, CallSettings callSettings = null)

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

Parameters
Name	Description
`newConfig`	`Any` Required. Service configuration for which we want to generate the report. For this version of API, the supported types are [google.api.servicemanagement.v1.ConfigRef][google.api.servicemanagement.v1.ConfigRef], [google.api.servicemanagement.v1.ConfigSource][google.api.servicemanagement.v1.ConfigSource], and [google.api.Service][google.api.Service]
`oldConfig`	`Any` Optional. Service configuration against which the comparison will be done. For this version of API, the supported types are [google.api.servicemanagement.v1.ConfigRef][google.api.servicemanagement.v1.ConfigRef], [google.api.servicemanagement.v1.ConfigSource][google.api.servicemanagement.v1.ConfigSource], and [google.api.Service][google.api.Service]
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`GenerateConfigReportResponse`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
Any newConfig = new Any();
Any oldConfig = new Any();
// Make the request
GenerateConfigReportResponse response = serviceManagerClient.GenerateConfigReport(newConfig, oldConfig);

GenerateConfigReportAsync(GenerateConfigReportRequest, CallSettings)

public virtual Task<GenerateConfigReportResponse> GenerateConfigReportAsync(GenerateConfigReportRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`GenerateConfigReportRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<GenerateConfigReportResponse>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GenerateConfigReportRequest request = new GenerateConfigReportRequest
{
    NewConfig = new Any(),
    OldConfig = new Any(),
};
// Make the request
GenerateConfigReportResponse response = await serviceManagerClient.GenerateConfigReportAsync(request);

GenerateConfigReportAsync(GenerateConfigReportRequest, CancellationToken)

public virtual Task<GenerateConfigReportResponse> GenerateConfigReportAsync(GenerateConfigReportRequest request, CancellationToken cancellationToken)

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

Parameters
Name	Description
`request`	`GenerateConfigReportRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<GenerateConfigReportResponse>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GenerateConfigReportRequest request = new GenerateConfigReportRequest
{
    NewConfig = new Any(),
    OldConfig = new Any(),
};
// Make the request
GenerateConfigReportResponse response = await serviceManagerClient.GenerateConfigReportAsync(request);

GenerateConfigReportAsync(Any, Any, CallSettings)

public virtual Task<GenerateConfigReportResponse> GenerateConfigReportAsync(Any newConfig, Any oldConfig, CallSettings callSettings = null)

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

Parameters
Name	Description
`newConfig`	`Any` Required. Service configuration for which we want to generate the report. For this version of API, the supported types are [google.api.servicemanagement.v1.ConfigRef][google.api.servicemanagement.v1.ConfigRef], [google.api.servicemanagement.v1.ConfigSource][google.api.servicemanagement.v1.ConfigSource], and [google.api.Service][google.api.Service]
`oldConfig`	`Any` Optional. Service configuration against which the comparison will be done. For this version of API, the supported types are [google.api.servicemanagement.v1.ConfigRef][google.api.servicemanagement.v1.ConfigRef], [google.api.servicemanagement.v1.ConfigSource][google.api.servicemanagement.v1.ConfigSource], and [google.api.Service][google.api.Service]
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<GenerateConfigReportResponse>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
Any newConfig = new Any();
Any oldConfig = new Any();
// Make the request
GenerateConfigReportResponse response = await serviceManagerClient.GenerateConfigReportAsync(newConfig, oldConfig);

GenerateConfigReportAsync(Any, Any, CancellationToken)

public virtual Task<GenerateConfigReportResponse> GenerateConfigReportAsync(Any newConfig, Any oldConfig, CancellationToken cancellationToken)

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

Parameters
Name	Description
`newConfig`	`Any` Required. Service configuration for which we want to generate the report. For this version of API, the supported types are [google.api.servicemanagement.v1.ConfigRef][google.api.servicemanagement.v1.ConfigRef], [google.api.servicemanagement.v1.ConfigSource][google.api.servicemanagement.v1.ConfigSource], and [google.api.Service][google.api.Service]
`oldConfig`	`Any` Optional. Service configuration against which the comparison will be done. For this version of API, the supported types are [google.api.servicemanagement.v1.ConfigRef][google.api.servicemanagement.v1.ConfigRef], [google.api.servicemanagement.v1.ConfigSource][google.api.servicemanagement.v1.ConfigSource], and [google.api.Service][google.api.Service]
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<GenerateConfigReportResponse>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
Any newConfig = new Any();
Any oldConfig = new Any();
// Make the request
GenerateConfigReportResponse response = await serviceManagerClient.GenerateConfigReportAsync(newConfig, oldConfig);

GetService(GetServiceRequest, CallSettings)

public virtual ManagedService GetService(GetServiceRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`GetServiceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`ManagedService`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
GetServiceRequest request = new GetServiceRequest { ServiceName = "", };
// Make the request
ManagedService response = serviceManagerClient.GetService(request);

GetService(String, CallSettings)

public virtual ManagedService GetService(string serviceName, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the `ServiceManager` overview for naming requirements. For example: `example.googleapis.com`.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`ManagedService`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
// Make the request
ManagedService response = serviceManagerClient.GetService(serviceName);

GetServiceAsync(GetServiceRequest, CallSettings)

public virtual Task<ManagedService> GetServiceAsync(GetServiceRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`GetServiceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<ManagedService>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GetServiceRequest request = new GetServiceRequest { ServiceName = "", };
// Make the request
ManagedService response = await serviceManagerClient.GetServiceAsync(request);

GetServiceAsync(GetServiceRequest, CancellationToken)

public virtual Task<ManagedService> GetServiceAsync(GetServiceRequest request, CancellationToken cancellationToken)

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

Parameters
Name	Description
`request`	`GetServiceRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<ManagedService>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GetServiceRequest request = new GetServiceRequest { ServiceName = "", };
// Make the request
ManagedService response = await serviceManagerClient.GetServiceAsync(request);

GetServiceAsync(String, CallSettings)

public virtual Task<ManagedService> GetServiceAsync(string serviceName, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the `ServiceManager` overview for naming requirements. For example: `example.googleapis.com`.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<ManagedService>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
// Make the request
ManagedService response = await serviceManagerClient.GetServiceAsync(serviceName);

GetServiceAsync(String, CancellationToken)

public virtual Task<ManagedService> GetServiceAsync(string serviceName, CancellationToken cancellationToken)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the `ServiceManager` overview for naming requirements. For example: `example.googleapis.com`.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<ManagedService>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
// Make the request
ManagedService response = await serviceManagerClient.GetServiceAsync(serviceName);

GetServiceConfig(GetServiceConfigRequest, CallSettings)

public virtual Service GetServiceConfig(GetServiceConfigRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`GetServiceConfigRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Service`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
GetServiceConfigRequest request = new GetServiceConfigRequest
{
    ServiceName = "",
    ConfigId = "",
    View = GetServiceConfigRequest.Types.ConfigView.Basic,
};
// Make the request
Service response = serviceManagerClient.GetServiceConfig(request);

GetServiceConfig(String, String, GetServiceConfigRequest.Types.ConfigView, CallSettings)

public virtual Service GetServiceConfig(string serviceName, string configId, GetServiceConfigRequest.Types.ConfigView view, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`configId`	`String` Required. The id of the service configuration resource. This field must be specified for the server to return all fields, including `SourceInfo`.
`view`	`GetServiceConfigRequest.Types.ConfigView` Specifies which parts of the Service Config should be returned in the response.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Service`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
string configId = "";
GetServiceConfigRequest.Types.ConfigView view = GetServiceConfigRequest.Types.ConfigView.Basic;
// Make the request
Service response = serviceManagerClient.GetServiceConfig(serviceName, configId, view);

GetServiceConfigAsync(GetServiceConfigRequest, CallSettings)

public virtual Task<Service> GetServiceConfigAsync(GetServiceConfigRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`GetServiceConfigRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Service>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GetServiceConfigRequest request = new GetServiceConfigRequest
{
    ServiceName = "",
    ConfigId = "",
    View = GetServiceConfigRequest.Types.ConfigView.Basic,
};
// Make the request
Service response = await serviceManagerClient.GetServiceConfigAsync(request);

GetServiceConfigAsync(GetServiceConfigRequest, CancellationToken)

public virtual Task<Service> GetServiceConfigAsync(GetServiceConfigRequest request, CancellationToken cancellationToken)

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

Parameters
Name	Description
`request`	`GetServiceConfigRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Service>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GetServiceConfigRequest request = new GetServiceConfigRequest
{
    ServiceName = "",
    ConfigId = "",
    View = GetServiceConfigRequest.Types.ConfigView.Basic,
};
// Make the request
Service response = await serviceManagerClient.GetServiceConfigAsync(request);

GetServiceConfigAsync(String, String, GetServiceConfigRequest.Types.ConfigView, CallSettings)

public virtual Task<Service> GetServiceConfigAsync(string serviceName, string configId, GetServiceConfigRequest.Types.ConfigView view, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`configId`	`String` Required. The id of the service configuration resource. This field must be specified for the server to return all fields, including `SourceInfo`.
`view`	`GetServiceConfigRequest.Types.ConfigView` Specifies which parts of the Service Config should be returned in the response.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Service>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
string configId = "";
GetServiceConfigRequest.Types.ConfigView view = GetServiceConfigRequest.Types.ConfigView.Basic;
// Make the request
Service response = await serviceManagerClient.GetServiceConfigAsync(serviceName, configId, view);

GetServiceConfigAsync(String, String, GetServiceConfigRequest.Types.ConfigView, CancellationToken)

public virtual Task<Service> GetServiceConfigAsync(string serviceName, string configId, GetServiceConfigRequest.Types.ConfigView view, CancellationToken cancellationToken)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`configId`	`String` Required. The id of the service configuration resource. This field must be specified for the server to return all fields, including `SourceInfo`.
`view`	`GetServiceConfigRequest.Types.ConfigView` Specifies which parts of the Service Config should be returned in the response.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Service>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
string configId = "";
GetServiceConfigRequest.Types.ConfigView view = GetServiceConfigRequest.Types.ConfigView.Basic;
// Make the request
Service response = await serviceManagerClient.GetServiceConfigAsync(serviceName, configId, view);

GetServiceRollout(GetServiceRolloutRequest, CallSettings)

public virtual Rollout GetServiceRollout(GetServiceRolloutRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`GetServiceRolloutRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Rollout`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
GetServiceRolloutRequest request = new GetServiceRolloutRequest
{
    ServiceName = "",
    RolloutId = "",
};
// Make the request
Rollout response = serviceManagerClient.GetServiceRollout(request);

GetServiceRollout(String, String, CallSettings)

public virtual Rollout GetServiceRollout(string serviceName, string rolloutId, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`rolloutId`	`String` Required. The id of the rollout resource.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Rollout`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
string rolloutId = "";
// Make the request
Rollout response = serviceManagerClient.GetServiceRollout(serviceName, rolloutId);

GetServiceRolloutAsync(GetServiceRolloutRequest, CallSettings)

public virtual Task<Rollout> GetServiceRolloutAsync(GetServiceRolloutRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`GetServiceRolloutRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Rollout>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GetServiceRolloutRequest request = new GetServiceRolloutRequest
{
    ServiceName = "",
    RolloutId = "",
};
// Make the request
Rollout response = await serviceManagerClient.GetServiceRolloutAsync(request);

GetServiceRolloutAsync(GetServiceRolloutRequest, CancellationToken)

public virtual Task<Rollout> GetServiceRolloutAsync(GetServiceRolloutRequest request, CancellationToken cancellationToken)

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

Parameters
Name	Description
`request`	`GetServiceRolloutRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Rollout>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
GetServiceRolloutRequest request = new GetServiceRolloutRequest
{
    ServiceName = "",
    RolloutId = "",
};
// Make the request
Rollout response = await serviceManagerClient.GetServiceRolloutAsync(request);

GetServiceRolloutAsync(String, String, CallSettings)

public virtual Task<Rollout> GetServiceRolloutAsync(string serviceName, string rolloutId, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`rolloutId`	`String` Required. The id of the rollout resource.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Rollout>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
string rolloutId = "";
// Make the request
Rollout response = await serviceManagerClient.GetServiceRolloutAsync(serviceName, rolloutId);

GetServiceRolloutAsync(String, String, CancellationToken)

public virtual Task<Rollout> GetServiceRolloutAsync(string serviceName, string rolloutId, CancellationToken cancellationToken)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`rolloutId`	`String` Required. The id of the rollout resource.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Rollout>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
string rolloutId = "";
// Make the request
Rollout response = await serviceManagerClient.GetServiceRolloutAsync(serviceName, rolloutId);

ListServiceConfigs(ListServiceConfigsRequest, CallSettings)

public virtual PagedEnumerable<ListServiceConfigsResponse, Service> ListServiceConfigs(ListServiceConfigsRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`ListServiceConfigsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListServiceConfigsResponse, Service>`	A pageable sequence of Service resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
ListServiceConfigsRequest request = new ListServiceConfigsRequest { ServiceName = "", };
// Make the request
PagedEnumerable<ListServiceConfigsResponse, Service> response = serviceManagerClient.ListServiceConfigs(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Service item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListServiceConfigsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Service item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Service> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Service item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServiceConfigs(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListServiceConfigsResponse, Service> ListServiceConfigs(string serviceName, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListServiceConfigsResponse, Service>`	A pageable sequence of Service resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
// Make the request
PagedEnumerable<ListServiceConfigsResponse, Service> response = serviceManagerClient.ListServiceConfigs(serviceName);

// Iterate over all response items, lazily performing RPCs as required
foreach (Service item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListServiceConfigsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Service item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Service> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Service item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServiceConfigsAsync(ListServiceConfigsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListServiceConfigsResponse, Service> ListServiceConfigsAsync(ListServiceConfigsRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`ListServiceConfigsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListServiceConfigsResponse, Service>`	A pageable asynchronous sequence of Service resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
ListServiceConfigsRequest request = new ListServiceConfigsRequest { ServiceName = "", };
// Make the request
PagedAsyncEnumerable<ListServiceConfigsResponse, Service> response = serviceManagerClient.ListServiceConfigsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Service item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListServiceConfigsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Service item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Service> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Service item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServiceConfigsAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListServiceConfigsResponse, Service> ListServiceConfigsAsync(string serviceName, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListServiceConfigsResponse, Service>`	A pageable asynchronous sequence of Service resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
// Make the request
PagedAsyncEnumerable<ListServiceConfigsResponse, Service> response = serviceManagerClient.ListServiceConfigsAsync(serviceName);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Service item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListServiceConfigsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Service item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Service> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Service item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServiceRollouts(ListServiceRolloutsRequest, CallSettings)

public virtual PagedEnumerable<ListServiceRolloutsResponse, Rollout> ListServiceRollouts(ListServiceRolloutsRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`ListServiceRolloutsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListServiceRolloutsResponse, Rollout>`	A pageable sequence of Rollout resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
ListServiceRolloutsRequest request = new ListServiceRolloutsRequest
{
    ServiceName = "",
    Filter = "",
};
// Make the request
PagedEnumerable<ListServiceRolloutsResponse, Rollout> response = serviceManagerClient.ListServiceRollouts(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Rollout item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListServiceRolloutsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rollout item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Rollout> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Rollout item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServiceRollouts(String, String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListServiceRolloutsResponse, Rollout> ListServiceRollouts(string serviceName, string filter, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`filter`	`String` Required. Use `filter` to return subset of rollouts. The following filters are supported: -- To limit the results to only those in status (google.api.servicemanagement.v1.RolloutStatus) 'SUCCESS', use filter='status=SUCCESS' -- To limit the results to those in status (google.api.servicemanagement.v1.RolloutStatus) 'CANCELLED' or 'FAILED', use filter='status=CANCELLED OR status=FAILED'
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListServiceRolloutsResponse, Rollout>`	A pageable sequence of Rollout resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
string filter = "";
// Make the request
PagedEnumerable<ListServiceRolloutsResponse, Rollout> response = serviceManagerClient.ListServiceRollouts(serviceName, filter);

// Iterate over all response items, lazily performing RPCs as required
foreach (Rollout item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListServiceRolloutsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rollout item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Rollout> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Rollout item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServiceRolloutsAsync(ListServiceRolloutsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListServiceRolloutsResponse, Rollout> ListServiceRolloutsAsync(ListServiceRolloutsRequest request, CallSettings callSettings = null)

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

Parameters
Name	Description
`request`	`ListServiceRolloutsRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListServiceRolloutsResponse, Rollout>`	A pageable asynchronous sequence of Rollout resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
ListServiceRolloutsRequest request = new ListServiceRolloutsRequest
{
    ServiceName = "",
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<ListServiceRolloutsResponse, Rollout> response = serviceManagerClient.ListServiceRolloutsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Rollout item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListServiceRolloutsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rollout item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Rollout> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Rollout item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServiceRolloutsAsync(String, String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListServiceRolloutsResponse, Rollout> ListServiceRolloutsAsync(string serviceName, string filter, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

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

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`filter`	`String` Required. Use `filter` to return subset of rollouts. The following filters are supported: -- To limit the results to only those in status (google.api.servicemanagement.v1.RolloutStatus) 'SUCCESS', use filter='status=SUCCESS' -- To limit the results to those in status (google.api.servicemanagement.v1.RolloutStatus) 'CANCELLED' or 'FAILED', use filter='status=CANCELLED OR status=FAILED'
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListServiceRolloutsResponse, Rollout>`	A pageable asynchronous sequence of Rollout resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
string filter = "";
// Make the request
PagedAsyncEnumerable<ListServiceRolloutsResponse, Rollout> response = serviceManagerClient.ListServiceRolloutsAsync(serviceName, filter);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Rollout item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListServiceRolloutsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Rollout item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<Rollout> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (Rollout item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServices(ListServicesRequest, CallSettings)

public virtual PagedEnumerable<ListServicesResponse, ManagedService> ListServices(ListServicesRequest request, CallSettings callSettings = null)

Lists managed services.

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

Parameters
Name	Description
`request`	`ListServicesRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListServicesResponse, ManagedService>`	A pageable sequence of ManagedService resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
ListServicesRequest request = new ListServicesRequest
{
    ProducerProjectId = "",
};
// Make the request
PagedEnumerable<ListServicesResponse, ManagedService> response = serviceManagerClient.ListServices(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ManagedService item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListServicesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ManagedService item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<ManagedService> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (ManagedService item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServices(String, String, String, Nullable<Int32>, CallSettings)

[Obsolete]
public virtual PagedEnumerable<ListServicesResponse, ManagedService> ListServices(string producerProjectId, string consumerId, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists managed services.

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

Parameters
Name	Description
`producerProjectId`	`String` Include services produced by the specified project.
`consumerId`	`String` Include services consumed by the specified consumer. The Google Service Management implementation accepts the following forms: project:<project_id>
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedEnumerable<ListServicesResponse, ManagedService>`	A pageable sequence of ManagedService resources.

Example

            // Create client
            ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
            // Initialize request argument(s)
            string producerProjectId = "";
            string consumerId = "";
            // Make the request
#pragma warning disable CS0612
            PagedEnumerable<ListServicesResponse, ManagedService> response = serviceManagerClient.ListServices(producerProjectId, consumerId);
#pragma warning restore CS0612

            // Iterate over all response items, lazily performing RPCs as required
            foreach (ManagedService item in response)
            {
                // Do something with each item
                Console.WriteLine(item);
            }

            // Or iterate over pages (of server-defined size), performing one RPC per page
            foreach (ListServicesResponse page in response.AsRawResponses())
            {
                // Do something with each page of items
                Console.WriteLine("A page of results:");
                foreach (ManagedService item in page)
                {
                    // Do something with each item
                    Console.WriteLine(item);
                }
            }

            // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
            int pageSize = 10;
            Page<ManagedService> singlePage = response.ReadPage(pageSize);
            // Do something with the page of items
            Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
            foreach (ManagedService item in singlePage)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
            // Store the pageToken, for when the next page is required.
            string nextPageToken = singlePage.NextPageToken;

ListServicesAsync(ListServicesRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListServicesResponse, ManagedService> ListServicesAsync(ListServicesRequest request, CallSettings callSettings = null)

Lists managed services.

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

Parameters
Name	Description
`request`	`ListServicesRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListServicesResponse, ManagedService>`	A pageable asynchronous sequence of ManagedService resources.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
ListServicesRequest request = new ListServicesRequest
{
    ProducerProjectId = "",
};
// Make the request
PagedAsyncEnumerable<ListServicesResponse, ManagedService> response = serviceManagerClient.ListServicesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ManagedService item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListServicesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ManagedService item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<ManagedService> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (ManagedService item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServicesAsync(String, String, String, Nullable<Int32>, CallSettings)

[Obsolete]
public virtual PagedAsyncEnumerable<ListServicesResponse, ManagedService> ListServicesAsync(string producerProjectId, string consumerId, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

Lists managed services.

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

Parameters
Name	Description
`producerProjectId`	`String` Include services produced by the specified project.
`consumerId`	`String` Include services consumed by the specified consumer. The Google Service Management implementation accepts the following forms: project:<project_id>
`pageToken`	`String` The token returned from the previous request. A value of `null` or an empty string retrieves the first page.
`pageSize`	`Nullable<Int32>` The size of page to request. The response will not be larger than this, but may be smaller. A value of `null` or `0` uses a server-defined page size.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`PagedAsyncEnumerable<ListServicesResponse, ManagedService>`	A pageable asynchronous sequence of ManagedService resources.

Example

            // Create client
            ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
            // Initialize request argument(s)
            string producerProjectId = "";
            string consumerId = "";
            // Make the request
#pragma warning disable CS0612
            PagedAsyncEnumerable<ListServicesResponse, ManagedService> response = serviceManagerClient.ListServicesAsync(producerProjectId, consumerId);
#pragma warning restore CS0612

            // Iterate over all response items, lazily performing RPCs as required
            await response.ForEachAsync((ManagedService item) =>
            {
                // Do something with each item
                Console.WriteLine(item);
            });

            // Or iterate over pages (of server-defined size), performing one RPC per page
            await response.AsRawResponses().ForEachAsync((ListServicesResponse page) =>
            {
                // Do something with each page of items
                Console.WriteLine("A page of results:");
                foreach (ManagedService item in page)
                {
                    // Do something with each item
                    Console.WriteLine(item);
                }
            });

            // Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
            int pageSize = 10;
            Page<ManagedService> singlePage = await response.ReadPageAsync(pageSize);
            // Do something with the page of items
            Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
            foreach (ManagedService item in singlePage)
            {
                // Do something with each item
                Console.WriteLine(item);
            }
            // Store the pageToken, for when the next page is required.
            string nextPageToken = singlePage.NextPageToken;

PollOnceCreateService(String, CallSettings)

public virtual Operation<ManagedService, OperationMetadata> PollOnceCreateService(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of CreateService.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<ManagedService, OperationMetadata>`	The result of polling the operation.

PollOnceCreateServiceAsync(String, CallSettings)

public virtual Task<Operation<ManagedService, OperationMetadata>> PollOnceCreateServiceAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of CreateService.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<ManagedService, OperationMetadata>>`	A task representing the result of polling the operation.

PollOnceCreateServiceRollout(String, CallSettings)

public virtual Operation<Rollout, OperationMetadata> PollOnceCreateServiceRollout(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of CreateServiceRollout .

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Rollout, OperationMetadata>`	The result of polling the operation.

PollOnceCreateServiceRolloutAsync(String, CallSettings)

public virtual Task<Operation<Rollout, OperationMetadata>> PollOnceCreateServiceRolloutAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of CreateServiceRollout.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Rollout, OperationMetadata>>`	A task representing the result of polling the operation.

PollOnceDeleteService(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteService(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of DeleteService.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<Empty, OperationMetadata>`	The result of polling the operation.

PollOnceDeleteServiceAsync(String, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> PollOnceDeleteServiceAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of DeleteService.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<Empty, OperationMetadata>>`	A task representing the result of polling the operation.

PollOnceSubmitConfigSource(String, CallSettings)

public virtual Operation<SubmitConfigSourceResponse, OperationMetadata> PollOnceSubmitConfigSource(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of SubmitConfigSource .

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<SubmitConfigSourceResponse, OperationMetadata>`	The result of polling the operation.

PollOnceSubmitConfigSourceAsync(String, CallSettings)

public virtual Task<Operation<SubmitConfigSourceResponse, OperationMetadata>> PollOnceSubmitConfigSourceAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of SubmitConfigSource.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<SubmitConfigSourceResponse, OperationMetadata>>`	A task representing the result of polling the operation.

PollOnceUndeleteService(String, CallSettings)

public virtual Operation<UndeleteServiceResponse, OperationMetadata> PollOnceUndeleteService(string operationName, CallSettings callSettings = null)

Poll an operation once, using an operationName from a previous invocation of UndeleteService.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<UndeleteServiceResponse, OperationMetadata>`	The result of polling the operation.

PollOnceUndeleteServiceAsync(String, CallSettings)

public virtual Task<Operation<UndeleteServiceResponse, OperationMetadata>> PollOnceUndeleteServiceAsync(string operationName, CallSettings callSettings = null)

Asynchronously poll an operation once, using an operationName from a previous invocation of UndeleteService.

Parameters
Name	Description
`operationName`	`String` The name of a previously invoked operation. Must not be `null` or empty.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<UndeleteServiceResponse, OperationMetadata>>`	A task representing the result of polling the operation.

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

Shuts down any channels automatically created by Create() and CreateAsync(CancellationToken). Channels which weren't automatically created are not affected.

Returns
Type	Description
`Task`	A task representing the asynchronous shutdown operation.

Remarks

After calling this method, further calls to Create() and CreateAsync(CancellationToken) will create new channels, which could in turn be shut down by another call to this method.

SubmitConfigSource(SubmitConfigSourceRequest, CallSettings)

public virtual Operation<SubmitConfigSourceResponse, OperationMetadata> SubmitConfigSource(SubmitConfigSourceRequest request, CallSettings callSettings = null)

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>

Parameters
Name	Description
`request`	`SubmitConfigSourceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<SubmitConfigSourceResponse, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
SubmitConfigSourceRequest request = new SubmitConfigSourceRequest
{
    ServiceName = "",
    ConfigSource = new ConfigSource(),
    ValidateOnly = false,
};
// Make the request
Operation<SubmitConfigSourceResponse, OperationMetadata> response = serviceManagerClient.SubmitConfigSource(request);

// Poll until the returned long-running operation is complete
Operation<SubmitConfigSourceResponse, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
SubmitConfigSourceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<SubmitConfigSourceResponse, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceSubmitConfigSource(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    SubmitConfigSourceResponse retrievedResult = retrievedResponse.Result;
}

SubmitConfigSource(String, ConfigSource, Boolean, CallSettings)

public virtual Operation<SubmitConfigSourceResponse, OperationMetadata> SubmitConfigSource(string serviceName, ConfigSource configSource, bool validateOnly, CallSettings callSettings = null)

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>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`configSource`	`ConfigSource` Required. The source configuration for the service.
`validateOnly`	`Boolean` Optional. If set, this will result in the generation of a `google.api.Service` configuration based on the `ConfigSource` provided, but the generated config and the sources will NOT be persisted.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<SubmitConfigSourceResponse, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
ConfigSource configSource = new ConfigSource();
bool validateOnly = false;
// Make the request
Operation<SubmitConfigSourceResponse, OperationMetadata> response = serviceManagerClient.SubmitConfigSource(serviceName, configSource, validateOnly);

// Poll until the returned long-running operation is complete
Operation<SubmitConfigSourceResponse, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
SubmitConfigSourceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<SubmitConfigSourceResponse, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceSubmitConfigSource(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    SubmitConfigSourceResponse retrievedResult = retrievedResponse.Result;
}

SubmitConfigSourceAsync(SubmitConfigSourceRequest, CallSettings)

public virtual Task<Operation<SubmitConfigSourceResponse, OperationMetadata>> SubmitConfigSourceAsync(SubmitConfigSourceRequest request, CallSettings callSettings = null)

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>

Parameters
Name	Description
`request`	`SubmitConfigSourceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<SubmitConfigSourceResponse, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
SubmitConfigSourceRequest request = new SubmitConfigSourceRequest
{
    ServiceName = "",
    ConfigSource = new ConfigSource(),
    ValidateOnly = false,
};
// Make the request
Operation<SubmitConfigSourceResponse, OperationMetadata> response = await serviceManagerClient.SubmitConfigSourceAsync(request);

// Poll until the returned long-running operation is complete
Operation<SubmitConfigSourceResponse, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
SubmitConfigSourceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<SubmitConfigSourceResponse, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceSubmitConfigSourceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    SubmitConfigSourceResponse retrievedResult = retrievedResponse.Result;
}

SubmitConfigSourceAsync(SubmitConfigSourceRequest, CancellationToken)

public virtual Task<Operation<SubmitConfigSourceResponse, OperationMetadata>> SubmitConfigSourceAsync(SubmitConfigSourceRequest request, CancellationToken cancellationToken)

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>

Parameters
Name	Description
`request`	`SubmitConfigSourceRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<SubmitConfigSourceResponse, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
SubmitConfigSourceRequest request = new SubmitConfigSourceRequest
{
    ServiceName = "",
    ConfigSource = new ConfigSource(),
    ValidateOnly = false,
};
// Make the request
Operation<SubmitConfigSourceResponse, OperationMetadata> response = await serviceManagerClient.SubmitConfigSourceAsync(request);

// Poll until the returned long-running operation is complete
Operation<SubmitConfigSourceResponse, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
SubmitConfigSourceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<SubmitConfigSourceResponse, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceSubmitConfigSourceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    SubmitConfigSourceResponse retrievedResult = retrievedResponse.Result;
}

SubmitConfigSourceAsync(String, ConfigSource, Boolean, CallSettings)

public virtual Task<Operation<SubmitConfigSourceResponse, OperationMetadata>> SubmitConfigSourceAsync(string serviceName, ConfigSource configSource, bool validateOnly, CallSettings callSettings = null)

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>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`configSource`	`ConfigSource` Required. The source configuration for the service.
`validateOnly`	`Boolean` Optional. If set, this will result in the generation of a `google.api.Service` configuration based on the `ConfigSource` provided, but the generated config and the sources will NOT be persisted.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<SubmitConfigSourceResponse, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
ConfigSource configSource = new ConfigSource();
bool validateOnly = false;
// Make the request
Operation<SubmitConfigSourceResponse, OperationMetadata> response = await serviceManagerClient.SubmitConfigSourceAsync(serviceName, configSource, validateOnly);

// Poll until the returned long-running operation is complete
Operation<SubmitConfigSourceResponse, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
SubmitConfigSourceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<SubmitConfigSourceResponse, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceSubmitConfigSourceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    SubmitConfigSourceResponse retrievedResult = retrievedResponse.Result;
}

SubmitConfigSourceAsync(String, ConfigSource, Boolean, CancellationToken)

public virtual Task<Operation<SubmitConfigSourceResponse, OperationMetadata>> SubmitConfigSourceAsync(string serviceName, ConfigSource configSource, bool validateOnly, CancellationToken cancellationToken)

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>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`configSource`	`ConfigSource` Required. The source configuration for the service.
`validateOnly`	`Boolean` Optional. If set, this will result in the generation of a `google.api.Service` configuration based on the `ConfigSource` provided, but the generated config and the sources will NOT be persisted.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<SubmitConfigSourceResponse, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
ConfigSource configSource = new ConfigSource();
bool validateOnly = false;
// Make the request
Operation<SubmitConfigSourceResponse, OperationMetadata> response = await serviceManagerClient.SubmitConfigSourceAsync(serviceName, configSource, validateOnly);

// Poll until the returned long-running operation is complete
Operation<SubmitConfigSourceResponse, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
SubmitConfigSourceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<SubmitConfigSourceResponse, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceSubmitConfigSourceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    SubmitConfigSourceResponse retrievedResult = retrievedResponse.Result;
}

UndeleteService(UndeleteServiceRequest, CallSettings)

public virtual Operation<UndeleteServiceResponse, OperationMetadata> UndeleteService(UndeleteServiceRequest request, CallSettings callSettings = null)

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>

Parameters
Name	Description
`request`	`UndeleteServiceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<UndeleteServiceResponse, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
UndeleteServiceRequest request = new UndeleteServiceRequest { ServiceName = "", };
// Make the request
Operation<UndeleteServiceResponse, OperationMetadata> response = serviceManagerClient.UndeleteService(request);

// Poll until the returned long-running operation is complete
Operation<UndeleteServiceResponse, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
UndeleteServiceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<UndeleteServiceResponse, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceUndeleteService(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    UndeleteServiceResponse retrievedResult = retrievedResponse.Result;
}

UndeleteService(String, CallSettings)

public virtual Operation<UndeleteServiceResponse, OperationMetadata> UndeleteService(string serviceName, CallSettings callSettings = null)

Operation<response: UndeleteServiceResponse>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Operation<UndeleteServiceResponse, OperationMetadata>`	The RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = ServiceManagerClient.Create();
// Initialize request argument(s)
string serviceName = "";
// Make the request
Operation<UndeleteServiceResponse, OperationMetadata> response = serviceManagerClient.UndeleteService(serviceName);

// Poll until the returned long-running operation is complete
Operation<UndeleteServiceResponse, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
UndeleteServiceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<UndeleteServiceResponse, OperationMetadata> retrievedResponse = serviceManagerClient.PollOnceUndeleteService(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    UndeleteServiceResponse retrievedResult = retrievedResponse.Result;
}

UndeleteServiceAsync(UndeleteServiceRequest, CallSettings)

public virtual Task<Operation<UndeleteServiceResponse, OperationMetadata>> UndeleteServiceAsync(UndeleteServiceRequest request, CallSettings callSettings = null)

Operation<response: UndeleteServiceResponse>

Parameters
Name	Description
`request`	`UndeleteServiceRequest` The request object containing all of the parameters for the API call.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<UndeleteServiceResponse, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
UndeleteServiceRequest request = new UndeleteServiceRequest { ServiceName = "", };
// Make the request
Operation<UndeleteServiceResponse, OperationMetadata> response = await serviceManagerClient.UndeleteServiceAsync(request);

// Poll until the returned long-running operation is complete
Operation<UndeleteServiceResponse, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
UndeleteServiceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<UndeleteServiceResponse, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceUndeleteServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    UndeleteServiceResponse retrievedResult = retrievedResponse.Result;
}

UndeleteServiceAsync(UndeleteServiceRequest, CancellationToken)

public virtual Task<Operation<UndeleteServiceResponse, OperationMetadata>> UndeleteServiceAsync(UndeleteServiceRequest request, CancellationToken cancellationToken)

Operation<response: UndeleteServiceResponse>

Parameters
Name	Description
`request`	`UndeleteServiceRequest` The request object containing all of the parameters for the API call.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<UndeleteServiceResponse, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
UndeleteServiceRequest request = new UndeleteServiceRequest { ServiceName = "", };
// Make the request
Operation<UndeleteServiceResponse, OperationMetadata> response = await serviceManagerClient.UndeleteServiceAsync(request);

// Poll until the returned long-running operation is complete
Operation<UndeleteServiceResponse, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
UndeleteServiceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<UndeleteServiceResponse, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceUndeleteServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    UndeleteServiceResponse retrievedResult = retrievedResponse.Result;
}

UndeleteServiceAsync(String, CallSettings)

public virtual Task<Operation<UndeleteServiceResponse, OperationMetadata>> UndeleteServiceAsync(string serviceName, CallSettings callSettings = null)

Operation<response: UndeleteServiceResponse>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`callSettings`	`CallSettings` If not null, applies overrides to this RPC call.

Returns
Type	Description
`Task<Operation<UndeleteServiceResponse, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
// Make the request
Operation<UndeleteServiceResponse, OperationMetadata> response = await serviceManagerClient.UndeleteServiceAsync(serviceName);

// Poll until the returned long-running operation is complete
Operation<UndeleteServiceResponse, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
UndeleteServiceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<UndeleteServiceResponse, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceUndeleteServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    UndeleteServiceResponse retrievedResult = retrievedResponse.Result;
}

UndeleteServiceAsync(String, CancellationToken)

public virtual Task<Operation<UndeleteServiceResponse, OperationMetadata>> UndeleteServiceAsync(string serviceName, CancellationToken cancellationToken)

Operation<response: UndeleteServiceResponse>

Parameters
Name	Description
`serviceName`	`String` Required. The name of the service. See the overview for naming requirements. For example: `example.googleapis.com`.
`cancellationToken`	`CancellationToken` A CancellationToken to use for this RPC.

Returns
Type	Description
`Task<Operation<UndeleteServiceResponse, OperationMetadata>>`	A Task containing the RPC response.

Example

// Create client
ServiceManagerClient serviceManagerClient = await ServiceManagerClient.CreateAsync();
// Initialize request argument(s)
string serviceName = "";
// Make the request
Operation<UndeleteServiceResponse, OperationMetadata> response = await serviceManagerClient.UndeleteServiceAsync(serviceName);

// Poll until the returned long-running operation is complete
Operation<UndeleteServiceResponse, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
UndeleteServiceResponse result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<UndeleteServiceResponse, OperationMetadata> retrievedResponse = await serviceManagerClient.PollOnceUndeleteServiceAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    UndeleteServiceResponse retrievedResult = retrievedResponse.Result;
}