class Google::Cloud::ManagedIdentities::V1::ManagedIdentitiesService::Client

Client for the ManagedIdentitiesService service.

API Overview

The `managedidentites.googleapis.com` service implements the Google Cloud Managed Identites API for identity services (e.g. Microsoft Active Directory).

The Managed Identities service provides methods to manage (create/read/update/delete) domains, reset managed identities admin password, add/remove domain controllers in GCP regions and add/remove VPC peering.

Data Model

The Managed Identities service exposes the following resources:

The `{domain_name}` refers to fully qualified domain name in the customer project e.g. mydomain.myorganization.com, with the following restrictions:

* Must contain only lowercase letters, numbers, periods and hyphens.
* Must start with a letter.
* Must contain between 2-64 characters.
* Must end with a number or a letter.
* Must not start with period.
* First segement length (mydomain form example above) shouldn't exceed
  15 chars.
* The last segment cannot be fully numeric.
* Must be unique within the customer project.

Attributes

managed_identities_service_stub[R]

@private

operations_client[R]

Get the associated client for long-running operations.

@return [::Google::Cloud::ManagedIdentities::V1::ManagedIdentitiesService::Operations]

Public Class Methods

configure() { |configure| ... } click to toggle source

Configure the ManagedIdentitiesService Client class.

See {::Google::Cloud::ManagedIdentities::V1::ManagedIdentitiesService::Client::Configuration} for a description of the configuration fields.

@example

# Modify the configuration for all ManagedIdentitiesService clients
::Google::Cloud::ManagedIdentities::V1::ManagedIdentitiesService::Client.configure do |config|
  config.timeout = 10.0
end

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 87
def self.configure
  @configure ||= begin
    namespace = ["Google", "Cloud", "ManagedIdentities", "V1"]
    parent_config = while namespace.any?
                      parent_name = namespace.join "::"
                      parent_const = const_get parent_name
                      break parent_const.configure if parent_const.respond_to? :configure
                      namespace.pop
                    end
    default_config = Client::Configuration.new parent_config

    default_config.rpcs.create_microsoft_ad_domain.timeout = 60.0

    default_config.rpcs.reset_admin_password.timeout = 60.0

    default_config.rpcs.list_domains.timeout = 60.0

    default_config.rpcs.get_domain.timeout = 60.0

    default_config.rpcs.update_domain.timeout = 60.0

    default_config.rpcs.delete_domain.timeout = 60.0

    default_config.rpcs.attach_trust.timeout = 60.0

    default_config.rpcs.reconfigure_trust.timeout = 60.0

    default_config.rpcs.detach_trust.timeout = 60.0

    default_config.rpcs.validate_trust.timeout = 60.0

    default_config
  end
  yield @configure if block_given?
  @configure
end
new() { |config| ... } click to toggle source

Create a new ManagedIdentitiesService client object.

@example

# Create a client using the default configuration
client = ::Google::Cloud::ManagedIdentities::V1::ManagedIdentitiesService::Client.new

# Create a client using a custom configuration
client = ::Google::Cloud::ManagedIdentities::V1::ManagedIdentitiesService::Client.new do |config|
  config.timeout = 10.0
end

@yield [config] Configure the ManagedIdentitiesService client. @yieldparam config [Client::Configuration]

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 160
def initialize
  # These require statements are intentionally placed here to initialize
  # the gRPC module only when it's required.
  # See https://github.com/googleapis/toolkit/issues/446
  require "gapic/grpc"
  require "google/cloud/managedidentities/v1/managed_identities_service_services_pb"

  # Create the configuration object
  @config = Configuration.new Client.configure

  # Yield the configuration if needed
  yield @config if block_given?

  # Create credentials
  credentials = @config.credentials
  # Use self-signed JWT if the endpoint is unchanged from default,
  # but only if the default endpoint does not have a region prefix.
  enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&
                           !@config.endpoint.split(".").first.include?("-")
  credentials ||= Credentials.default scope: @config.scope,
                                      enable_self_signed_jwt: enable_self_signed_jwt
  if credentials.is_a?(::String) || credentials.is_a?(::Hash)
    credentials = Credentials.new credentials, scope: @config.scope
  end
  @quota_project_id = @config.quota_project
  @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id

  @operations_client = Operations.new do |config|
    config.credentials = credentials
    config.endpoint = @config.endpoint
  end

  @managed_identities_service_stub = ::Gapic::ServiceStub.new(
    ::Google::Cloud::ManagedIdentities::V1::ManagedIdentitiesService::Stub,
    credentials:  credentials,
    endpoint:     @config.endpoint,
    channel_args: @config.channel_args,
    interceptors: @config.interceptors
  )
end

Public Instance Methods

attach_trust(request, options = nil) { |response, operation| ... } click to toggle source

Adds an AD trust to a domain.

@overload attach_trust(request, options = nil)

Pass arguments to `attach_trust` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::AttachTrustRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::AttachTrustRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload attach_trust(name: nil, trust: nil)

Pass arguments to `attach_trust` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The resource domain name, project name and location using the form:
  `projects/{project_id}/locations/global/domains/{domain_name}`
@param trust [::Google::Cloud::ManagedIdentities::V1::Trust, ::Hash]
  Required. The domain trust resource.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 700
def attach_trust request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::AttachTrustRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.attach_trust.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.attach_trust.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.attach_trust.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :attach_trust, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
configure() { |config| ... } click to toggle source

Configure the ManagedIdentitiesService Client instance.

The configuration is set to the derived mode, meaning that values can be changed, but structural changes (adding new fields, etc.) are not allowed. Structural changes should be made on {Client.configure}.

See {::Google::Cloud::ManagedIdentities::V1::ManagedIdentitiesService::Client::Configuration} for a description of the configuration fields.

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 139
def configure
  yield @config if block_given?
  @config
end
create_microsoft_ad_domain(request, options = nil) { |response, operation| ... } click to toggle source

Creates a Microsoft AD domain.

@overload create_microsoft_ad_domain(request, options = nil)

Pass arguments to `create_microsoft_ad_domain` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::CreateMicrosoftAdDomainRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::CreateMicrosoftAdDomainRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload create_microsoft_ad_domain(parent: nil, domain_name: nil, domain: nil)

Pass arguments to `create_microsoft_ad_domain` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. The resource project name and location using the form:
  `projects/{project_id}/locations/global`
@param domain_name [::String]
  Required. The fully qualified domain name.
  e.g. mydomain.myorganization.com, with the following restrictions:

   * Must contain only lowercase letters, numbers, periods and hyphens.
   * Must start with a letter.
   * Must contain between 2-64 characters.
   * Must end with a number or a letter.
   * Must not start with period.
   * First segement length (mydomain form example above) shouldn't exceed
     15 chars.
   * The last segment cannot be fully numeric.
   * Must be unique within the customer project.
@param domain [::Google::Cloud::ManagedIdentities::V1::Domain, ::Hash]
  Required. A Managed Identity domain resource.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 255
def create_microsoft_ad_domain request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::CreateMicrosoftAdDomainRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.create_microsoft_ad_domain.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.create_microsoft_ad_domain.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_microsoft_ad_domain.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :create_microsoft_ad_domain, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
delete_domain(request, options = nil) { |response, operation| ... } click to toggle source

Deletes a domain.

@overload delete_domain(request, options = nil)

Pass arguments to `delete_domain` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::DeleteDomainRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::DeleteDomainRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload delete_domain(name: nil)

Pass arguments to `delete_domain` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The domain resource name using the form:
  `projects/{project_id}/locations/global/domains/{domain_name}`

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 628
def delete_domain request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::DeleteDomainRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.delete_domain.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.delete_domain.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_domain.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :delete_domain, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
detach_trust(request, options = nil) { |response, operation| ... } click to toggle source

Removes an AD trust.

@overload detach_trust(request, options = nil)

Pass arguments to `detach_trust` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::DetachTrustRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::DetachTrustRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload detach_trust(name: nil, trust: nil)

Pass arguments to `detach_trust` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The resource domain name, project name, and location using the form:
  `projects/{project_id}/locations/global/domains/{domain_name}`
@param trust [::Google::Cloud::ManagedIdentities::V1::Trust, ::Hash]
  Required. The domain trust resource to removed.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 848
def detach_trust request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::DetachTrustRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.detach_trust.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.detach_trust.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.detach_trust.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :detach_trust, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
get_domain(request, options = nil) { |response, operation| ... } click to toggle source

Gets information about a domain.

@overload get_domain(request, options = nil)

Pass arguments to `get_domain` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::GetDomainRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::GetDomainRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload get_domain(name: nil)

Pass arguments to `get_domain` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The domain resource name using the form:
  `projects/{project_id}/locations/global/domains/{domain_name}`

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::ManagedIdentities::V1::Domain] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::ManagedIdentities::V1::Domain]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 482
def get_domain request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::GetDomainRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.get_domain.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.get_domain.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_domain.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :get_domain, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
list_domains(request, options = nil) { |response, operation| ... } click to toggle source

Lists domains in a project.

@overload list_domains(request, options = nil)

Pass arguments to `list_domains` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::ListDomainsRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::ListDomainsRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload list_domains(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil)

Pass arguments to `list_domains` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param parent [::String]
  Required. The resource name of the domain location using the form:
  `projects/{project_id}/locations/global`
@param page_size [::Integer]
  Optional. The maximum number of items to return.
  If not specified, a default value of 1000 will be used.
  Regardless of the page_size value, the response may include a partial list.
  Callers should rely on a response's
  {::Google::Cloud::ManagedIdentities::V1::ListDomainsResponse#next_page_token next_page_token}
  to determine if there are additional results to list.
@param page_token [::String]
  Optional. The `next_page_token` value returned from a previous ListDomainsRequest
  request, if any.
@param filter [::String]
  Optional. A filter specifying constraints of a list operation.
  For example, `Domain.fqdn="mydomain.myorginization"`.
@param order_by [::String]
  Optional. Specifies the ordering of results. See
  [Sorting
  order](https://cloud.google.com/apis/design/design_patterns#sorting_order)
  for more information.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::PagedEnumerable<::Google::Cloud::ManagedIdentities::V1::Domain>] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::PagedEnumerable<::Google::Cloud::ManagedIdentities::V1::Domain>]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 412
def list_domains request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::ListDomainsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.list_domains.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "parent" => request.parent
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.list_domains.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_domains.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :list_domains, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @managed_identities_service_stub, :list_domains, request, response, operation, options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
reconfigure_trust(request, options = nil) { |response, operation| ... } click to toggle source

Updates the DNS conditional forwarder.

@overload reconfigure_trust(request, options = nil)

Pass arguments to `reconfigure_trust` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::ReconfigureTrustRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::ReconfigureTrustRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload reconfigure_trust(name: nil, target_domain_name: nil, target_dns_ip_addresses: nil)

Pass arguments to `reconfigure_trust` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The resource domain name, project name and location using the form:
  `projects/{project_id}/locations/global/domains/{domain_name}`
@param target_domain_name [::String]
  Required. The fully-qualified target domain name which will be in trust with current
  domain.
@param target_dns_ip_addresses [::Array<::String>]
  Required. The target DNS server IP addresses to resolve the remote domain involved
  in the trust.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 776
def reconfigure_trust request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::ReconfigureTrustRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.reconfigure_trust.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.reconfigure_trust.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.reconfigure_trust.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :reconfigure_trust, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
reset_admin_password(request, options = nil) { |response, operation| ... } click to toggle source

Resets a domain's administrator password.

@overload reset_admin_password(request, options = nil)

Pass arguments to `reset_admin_password` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::ResetAdminPasswordRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::ResetAdminPasswordRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload reset_admin_password(name: nil)

Pass arguments to `reset_admin_password` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The domain resource name using the form:
  `projects/{project_id}/locations/global/domains/{domain_name}`

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::ManagedIdentities::V1::ResetAdminPasswordResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::ManagedIdentities::V1::ResetAdminPasswordResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 325
def reset_admin_password request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::ResetAdminPasswordRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.reset_admin_password.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.reset_admin_password.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.reset_admin_password.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :reset_admin_password, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
update_domain(request, options = nil) { |response, operation| ... } click to toggle source

Updates the metadata and configuration of a domain.

@overload update_domain(request, options = nil)

Pass arguments to `update_domain` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::UpdateDomainRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::UpdateDomainRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload update_domain(update_mask: nil, domain: nil)

Pass arguments to `update_domain` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param update_mask [::Google::Protobuf::FieldMask, ::Hash]
  Required. Mask of fields to update. At least one path must be supplied in this
  field. The elements of the repeated paths field may only include
  fields from {::Google::Cloud::ManagedIdentities::V1::Domain Domain}:
   * `labels`
   * `locations`
   * `authorized_networks`
@param domain [::Google::Cloud::ManagedIdentities::V1::Domain, ::Hash]
  Required. Domain message with updated fields. Only supported fields specified in
  update_mask are updated.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 558
def update_domain request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::UpdateDomainRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.update_domain.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "domain.name" => request.domain.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.update_domain.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_domain.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :update_domain, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
validate_trust(request, options = nil) { |response, operation| ... } click to toggle source

Validates a trust state, that the target domain is reachable, and that the target domain is able to accept incoming trust requests.

@overload validate_trust(request, options = nil)

Pass arguments to `validate_trust` via a request object, either of type
{::Google::Cloud::ManagedIdentities::V1::ValidateTrustRequest} or an equivalent Hash.

@param request [::Google::Cloud::ManagedIdentities::V1::ValidateTrustRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload validate_trust(name: nil, trust: nil)

Pass arguments to `validate_trust` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param name [::String]
  Required. The resource domain name, project name, and location using the form:
  `projects/{project_id}/locations/global/domains/{domain_name}`
@param trust [::Google::Cloud::ManagedIdentities::V1::Trust, ::Hash]
  Required. The domain trust to validate trust state for.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Gapic::Operation] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Gapic::Operation]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/managed_identities/v1/managed_identities_service/client.rb, line 921
def validate_trust request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::ManagedIdentities::V1::ValidateTrustRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.validate_trust.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::ManagedIdentities::V1::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "name" => request.name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.validate_trust.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.validate_trust.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @managed_identities_service_stub.call_rpc :validate_trust, request, options: options do |response, operation|
    response = ::Gapic::Operation.new response, @operations_client, options: options
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end