Class: Google::Cloud::NetApp::V1::NetApp::Client

Inherits:

Object

Object
Google::Cloud::NetApp::V1::NetApp::Client

show all

Includes:: Paths

Defined in:: lib/google/cloud/netapp/v1/netapp/client.rb

Overview

Client for the NetApp service.

NetApp Files Google Cloud Service

Defined Under Namespace

Classes: Configuration

Instance Attribute Summary collapse

#location_client ⇒ Google::Cloud::Location::Locations::Client readonly
Get the associated client for mix-in of the Locations.
#operations_client ⇒ ::Google::Cloud::NetApp::V1::NetApp::Operations readonly
Get the associated client for long-running operations.

Class Method Summary collapse

.configure {|config| ... } ⇒ Client::Configuration
Configure the NetApp Client class.

Instance Method Summary collapse

#configure {|config| ... } ⇒ Client::Configuration
Configure the NetApp Client instance.
#create_active_directory(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
CreateActiveDirectory Creates the active directory specified in the request.
#create_backup(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Creates a backup from the volume specified in the request The backup can be created from the given snapshot if specified in the request.
#create_backup_policy(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Creates new backup policy.
#create_backup_vault(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Creates new backup vault.
#create_host_group(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Creates a new host group.
#create_kms_config(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Creates a new KMS config.
#create_quota_rule(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Creates a new quota rule.
#create_replication(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Create a new replication for a volume.
#create_snapshot(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Create a new snapshot for a volume.
#create_storage_pool(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Creates a new storage pool.
#create_volume(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Creates a new Volume in a given project and location.
#delete_active_directory(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Delete the active directory specified in the request.
#delete_backup(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Warning! This operation will permanently delete the backup.
#delete_backup_policy(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Warning! This operation will permanently delete the backup policy.
#delete_backup_vault(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Warning! This operation will permanently delete the backup vault.
#delete_host_group(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Deletes a host group.
#delete_kms_config(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Warning! This operation will permanently delete the Kms config.
#delete_quota_rule(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Deletes a quota rule.
#delete_replication(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Deletes a replication.
#delete_snapshot(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Deletes a snapshot.
#delete_storage_pool(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Warning! This operation will permanently delete the storage pool.
#delete_volume(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Deletes a single Volume.
#encrypt_volumes(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Encrypt the existing volumes without CMEK encryption with the desired the KMS config for the whole region.
#establish_peering(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Establish replication peering.
#establish_volume_peering(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Establish volume peering.
#execute_ontap_delete(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse
ExecuteOntapDelete dispatches the ONTAP DELETE request to the StoragePool cluster.
#execute_ontap_get(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse
ExecuteOntapGet dispatches the ONTAP GET request to the StoragePool cluster.
#execute_ontap_patch(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse
ExecuteOntapPatch dispatches the ONTAP PATCH request to the StoragePool cluster.
#execute_ontap_post(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse
ExecuteOntapPost dispatches the ONTAP POST request to the StoragePool cluster.
#get_active_directory(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::ActiveDirectory
Describes a specified active directory.
#get_backup(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::Backup
Returns the description of the specified backup.
#get_backup_policy(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::BackupPolicy
Returns the description of the specified backup policy by backup_policy_id.
#get_backup_vault(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::BackupVault
Returns the description of the specified backup vault.
#get_host_group(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::HostGroup
Returns details of the specified host group.
#get_kms_config(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::KmsConfig
Returns the description of the specified KMS config by kms_config_id.
#get_quota_rule(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::QuotaRule
Returns details of the specified quota rule.
#get_replication(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::Replication
Describe a replication for a volume.
#get_snapshot(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::Snapshot
Describe a snapshot for a volume.
#get_storage_pool(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::StoragePool
Returns the description of the specified storage pool by poolId.
#get_volume(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::Volume
Gets details of a single Volume.
#initialize {|config| ... } ⇒ Client constructor
Create a new NetApp client object.
#list_active_directories(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::ActiveDirectory>
Lists active directories.
#list_backup_policies(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>
Returns list of all available backup policies.
#list_backup_vaults(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>
Returns list of all available backup vaults.
#list_backups(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>
Returns descriptions of all backups for a backupVault.
#list_host_groups(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::HostGroup>
Returns a list of host groups in a location.
#list_kms_configs(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::KmsConfig>
Returns descriptions of all KMS configs owned by the caller.
#list_quota_rules(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::QuotaRule>
Returns list of all quota rules in a location.
#list_replications(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Replication>
Returns descriptions of all replications for a volume.
#list_snapshots(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Snapshot>
Returns descriptions of all snapshots for a volume.
#list_storage_pools(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::StoragePool>
Returns descriptions of all storage pools owned by the caller.
#list_volumes(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Volume>
Lists Volumes in a given project.
#logger ⇒ Logger
The logger used for request/response debug logging.
#restore_backup_files(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Restore files from a backup to a volume.
#resume_replication(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Resume Cross Region Replication.
#reverse_replication_direction(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Reverses direction of replication.
#revert_volume(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Revert an existing volume to a specified snapshot.
#stop_replication(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Stop Cross Region Replication.
#switch_active_replica_zone(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
This operation will switch the active/replica zone for a regional storagePool.
#sync_replication(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Syncs the replication.
#universe_domain ⇒ String
The effective universe domain.
#update_active_directory(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Update the parameters of an active directories.
#update_backup(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Update backup with full spec.
#update_backup_policy(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates settings of a specific backup policy.
#update_backup_vault(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates the settings of a specific backup vault.
#update_host_group(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates an existing host group.
#update_kms_config(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates the Kms config properties with the full spec.
#update_quota_rule(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates a quota rule.
#update_replication(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates the settings of a specific replication.
#update_snapshot(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates the settings of a specific snapshot.
#update_storage_pool(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates the storage pool properties with the full spec.
#update_volume(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
Updates the parameters of a single Volume.
#validate_directory_service(request, options = nil) {|response, operation| ... } ⇒ ::Gapic::Operation
ValidateDirectoryService does a connectivity check for a directory service policy attached to the storage pool.
#verify_kms_config(request, options = nil) {|response, operation| ... } ⇒ ::Google::Cloud::NetApp::V1::VerifyKmsConfigResponse
Verifies KMS config reachability.

Methods included from Paths

#active_directory_path, #backup_path, #backup_policy_path, #backup_vault_path, #host_group_path, #kms_config_path, #location_path, #network_path, #quota_rule_path, #replication_path, #snapshot_path, #storage_pool_path, #volume_path

Constructor Details

#initialize {|config| ... } ⇒ `Client`

Create a new NetApp client object.

Examples:


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

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

Yields:

(config) —
Configure the NetApp client.

Yield Parameters:

config (Client::Configuration)

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 281

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/netapp/v1/cloud_netapp_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.nil? ||
                           (@config.endpoint == Configuration::DEFAULT_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.quota_project = @quota_project_id
    config.endpoint = @config.endpoint
    config.universe_domain = @config.universe_domain
  end

  @net_app_stub = ::Gapic::ServiceStub.new(
    ::Google::Cloud::NetApp::V1::NetApp::Stub,
    credentials: credentials,
    endpoint: @config.endpoint,
    endpoint_template: DEFAULT_ENDPOINT_TEMPLATE,
    universe_domain: @config.universe_domain,
    channel_args: @config.channel_args,
    interceptors: @config.interceptors,
    channel_pool_config: @config.channel_pool,
    logger: @config.logger
  )

  @net_app_stub.stub_logger&.info do |entry|
    entry.set_system_name
    entry.set_service
    entry.message = "Created client for #{entry.service}"
    entry.set_credentials_fields credentials
    entry.set "customEndpoint", @config.endpoint if @config.endpoint
    entry.set "defaultTimeout", @config.timeout if @config.timeout
    entry.set "quotaProject", @quota_project_id if @quota_project_id
  end

  @location_client = Google::Cloud::Location::Locations::Client.new do |config|
    config.credentials = credentials
    config.quota_project = @quota_project_id
    config.endpoint = @net_app_stub.endpoint
    config.universe_domain = @net_app_stub.universe_domain
    config.logger = @net_app_stub.logger if config.respond_to? :logger=
  end
end

Instance Attribute Details

#location_client ⇒ `Google::Cloud::Location::Locations::Client` (readonly)

Get the associated client for mix-in of the Locations.

Returns:

(Google::Cloud::Location::Locations::Client)



359
360
361

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 359

def location_client
  @location_client
end

#operations_client ⇒ `::Google::Cloud::NetApp::V1::NetApp::Operations` (readonly)

Get the associated client for long-running operations.

Returns:

(::Google::Cloud::NetApp::V1::NetApp::Operations)



352
353
354

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 352

def operations_client
  @operations_client
end

Class Method Details

.configure {|config| ... } ⇒ `Client::Configuration`

Configure the NetApp Client class.

See Configuration for a description of the configuration fields.

Examples:


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

Yields:

(config) —
Configure the Client client.

Yield Parameters:

config (Client::Configuration)

Returns:

(Client::Configuration)

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 63

def self.configure
  @configure ||= begin
    namespace = ["Google", "Cloud", "NetApp", "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.list_storage_pools.timeout = 60.0
    default_config.rpcs.list_storage_pools.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.create_storage_pool.timeout = 60.0

    default_config.rpcs.get_storage_pool.timeout = 60.0
    default_config.rpcs.get_storage_pool.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.update_storage_pool.timeout = 60.0

    default_config.rpcs.delete_storage_pool.timeout = 60.0

    default_config.rpcs.list_volumes.timeout = 60.0
    default_config.rpcs.list_volumes.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.get_volume.timeout = 60.0
    default_config.rpcs.get_volume.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.create_volume.timeout = 60.0

    default_config.rpcs.update_volume.timeout = 60.0

    default_config.rpcs.delete_volume.timeout = 60.0

    default_config.rpcs.revert_volume.timeout = 60.0

    default_config.rpcs.list_snapshots.timeout = 60.0
    default_config.rpcs.list_snapshots.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.get_snapshot.timeout = 60.0
    default_config.rpcs.get_snapshot.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.create_snapshot.timeout = 60.0

    default_config.rpcs.delete_snapshot.timeout = 60.0

    default_config.rpcs.update_snapshot.timeout = 60.0

    default_config.rpcs.list_active_directories.timeout = 60.0
    default_config.rpcs.list_active_directories.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.get_active_directory.timeout = 60.0
    default_config.rpcs.get_active_directory.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.create_active_directory.timeout = 60.0

    default_config.rpcs.update_active_directory.timeout = 60.0

    default_config.rpcs.delete_active_directory.timeout = 60.0

    default_config.rpcs.list_kms_configs.timeout = 60.0
    default_config.rpcs.list_kms_configs.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.create_kms_config.timeout = 60.0

    default_config.rpcs.get_kms_config.timeout = 60.0
    default_config.rpcs.get_kms_config.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.update_kms_config.timeout = 60.0

    default_config.rpcs.encrypt_volumes.timeout = 60.0

    default_config.rpcs.verify_kms_config.timeout = 60.0

    default_config.rpcs.delete_kms_config.timeout = 60.0

    default_config.rpcs.list_replications.timeout = 60.0
    default_config.rpcs.list_replications.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.get_replication.timeout = 60.0
    default_config.rpcs.get_replication.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.create_replication.timeout = 60.0

    default_config.rpcs.delete_replication.timeout = 60.0

    default_config.rpcs.update_replication.timeout = 60.0

    default_config.rpcs.stop_replication.timeout = 60.0

    default_config.rpcs.resume_replication.timeout = 60.0

    default_config.rpcs.reverse_replication_direction.timeout = 60.0

    default_config.rpcs.create_backup_vault.timeout = 60.0

    default_config.rpcs.get_backup_vault.timeout = 60.0
    default_config.rpcs.get_backup_vault.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.list_backup_vaults.timeout = 60.0
    default_config.rpcs.list_backup_vaults.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.update_backup_vault.timeout = 60.0

    default_config.rpcs.delete_backup_vault.timeout = 60.0

    default_config.rpcs.create_backup.timeout = 60.0

    default_config.rpcs.get_backup.timeout = 60.0
    default_config.rpcs.get_backup.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.list_backups.timeout = 60.0
    default_config.rpcs.list_backups.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.delete_backup.timeout = 60.0

    default_config.rpcs.update_backup.timeout = 60.0

    default_config.rpcs.create_backup_policy.timeout = 60.0

    default_config.rpcs.get_backup_policy.timeout = 60.0
    default_config.rpcs.get_backup_policy.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.list_backup_policies.timeout = 60.0
    default_config.rpcs.list_backup_policies.retry_policy = {
      initial_delay: 1.0, max_delay: 10.0, multiplier: 1.3, retry_codes: [14]
    }

    default_config.rpcs.update_backup_policy.timeout = 60.0

    default_config.rpcs.delete_backup_policy.timeout = 60.0

    default_config
  end
  yield @configure if block_given?
  @configure
end

Instance Method Details

#configure {|config| ... } ⇒ `Client::Configuration`

Configure the NetApp 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 configure.

See Configuration for a description of the configuration fields.

Yields:

(config) —
Configure the Client client.

Yield Parameters:

config (Client::Configuration)

Returns:

(Client::Configuration)

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 251

def configure
  yield @config if block_given?
  @config
end

#create_active_directory(request, options = nil) ⇒ `::Gapic::Operation` #create_active_directory(parent: nil, active_directory: nil, active_directory_id: nil) ⇒ `::Gapic::Operation`

CreateActiveDirectory Creates the active directory specified in the request.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateActiveDirectoryRequest.new

# Call the create_active_directory method.
result = client.create_active_directory request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_active_directory(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_active_directory via a request object, either of type CreateActiveDirectoryRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateActiveDirectoryRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_active_directory(parent: nil, active_directory: nil, active_directory_id: nil) ⇒ ::Gapic::Operation

Pass arguments to create_active_directory 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Value for parent.
- active_directory (::Google::Cloud::NetApp::V1::ActiveDirectory, ::Hash) (defaults to: nil) —
  Required. Fields of the to be created active directory.
- active_directory_id (::String) (defaults to: nil) —
  Required. ID of the active directory to create. Must be unique within the parent resource. Must contain only letters, numbers and hyphen, with the first character a letter , the last a letter or a number, and a 63 character maximum.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2463

def create_active_directory request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateActiveDirectoryRequest

  # 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_active_directory.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_active_directory.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_active_directory.retry_policy

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

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

#create_backup(request, options = nil) ⇒ `::Gapic::Operation` #create_backup(parent: nil, backup_id: nil, backup: nil) ⇒ `::Gapic::Operation`

Creates a backup from the volume specified in the request The backup can be created from the given snapshot if specified in the request. If no snapshot specified, there'll be a new snapshot taken to initiate the backup creation.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateBackupRequest.new

# Call the create_backup method.
result = client.create_backup request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_backup(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_backup via a request object, either of type CreateBackupRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateBackupRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_backup(parent: nil, backup_id: nil, backup: nil) ⇒ ::Gapic::Operation

Pass arguments to create_backup 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The NetApp backupVault to create the backups of, in the format projects/*/locations/*/backupVaults/{backup_vault_id}
- backup_id (::String) (defaults to: nil) —
  Required. The ID to use for the backup. The ID must be unique within the specified backupVault. Must contain only letters, numbers and hyphen, with the first character a letter, the last a letter or a number, and a 63 character maximum.
- backup (::Google::Cloud::NetApp::V1::Backup, ::Hash) (defaults to: nil) —
  Required. A backup resource

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4886

def create_backup request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateBackupRequest

  # 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_backup.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_backup.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_backup.retry_policy

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

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

#create_backup_policy(request, options = nil) ⇒ `::Gapic::Operation` #create_backup_policy(parent: nil, backup_policy: nil, backup_policy_id: nil) ⇒ `::Gapic::Operation`

Creates new backup policy

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateBackupPolicyRequest.new

# Call the create_backup_policy method.
result = client.create_backup_policy request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_backup_policy(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_backup_policy via a request object, either of type CreateBackupPolicyRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateBackupPolicyRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_backup_policy(parent: nil, backup_policy: nil, backup_policy_id: nil) ⇒ ::Gapic::Operation

Pass arguments to create_backup_policy 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The location to create the backup policies of, in the format projects/{project_id}/locations/{location}
- backup_policy (::Google::Cloud::NetApp::V1::BackupPolicy, ::Hash) (defaults to: nil) —
  Required. A backupPolicy resource
- backup_policy_id (::String) (defaults to: nil) —
  Required. The ID to use for the backup policy. The ID must be unique within the specified location. Must contain only letters, numbers and hyphen, with the first character a letter, the last a letter or a number, and a 63 character maximum.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5383

def create_backup_policy request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateBackupPolicyRequest

  # 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_backup_policy.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_backup_policy.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_backup_policy.retry_policy

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

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

#create_backup_vault(request, options = nil) ⇒ `::Gapic::Operation` #create_backup_vault(parent: nil, backup_vault_id: nil, backup_vault: nil) ⇒ `::Gapic::Operation`

Creates new backup vault

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateBackupVaultRequest.new

# Call the create_backup_vault method.
result = client.create_backup_vault request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_backup_vault(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_backup_vault via a request object, either of type CreateBackupVaultRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateBackupVaultRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_backup_vault(parent: nil, backup_vault_id: nil, backup_vault: nil) ⇒ ::Gapic::Operation

Pass arguments to create_backup_vault 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The location to create the backup vaults, in the format projects/{project_id}/locations/{location}
- backup_vault_id (::String) (defaults to: nil) —
  Required. The ID to use for the backupVault. The ID must be unique within the specified location. Must contain only letters, numbers and hyphen, with the first character a letter, the last a letter or a number, and a 63 character maximum.
- backup_vault (::Google::Cloud::NetApp::V1::BackupVault, ::Hash) (defaults to: nil) —
  Required. A backupVault resource

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4397

def create_backup_vault request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateBackupVaultRequest

  # 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_backup_vault.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_backup_vault.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_backup_vault.retry_policy

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

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

#create_host_group(request, options = nil) ⇒ `::Gapic::Operation` #create_host_group(parent: nil, host_group: nil, host_group_id: nil) ⇒ `::Gapic::Operation`

Creates a new host group.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateHostGroupRequest.new

# Call the create_host_group method.
result = client.create_host_group request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_host_group(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_host_group via a request object, either of type CreateHostGroupRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateHostGroupRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_host_group(parent: nil, host_group: nil, host_group_id: nil) ⇒ ::Gapic::Operation

Pass arguments to create_host_group 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value for CreateHostGroupRequest
- host_group (::Google::Cloud::NetApp::V1::HostGroup, ::Hash) (defaults to: nil) —
  Required. Fields of the host group to create.
- host_group_id (::String) (defaults to: nil) —
  Required. ID of the host group to create. Must be unique within the parent resource. Must contain only letters, numbers, and hyphen, with the first character a letter or underscore, the last a letter or underscore or a number, and a 63 character maximum.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6637

def create_host_group request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateHostGroupRequest

  # 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_host_group.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_host_group.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_host_group.retry_policy

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

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

#create_kms_config(request, options = nil) ⇒ `::Gapic::Operation` #create_kms_config(parent: nil, kms_config_id: nil, kms_config: nil) ⇒ `::Gapic::Operation`

Creates a new KMS config.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateKmsConfigRequest.new

# Call the create_kms_config method.
result = client.create_kms_config request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_kms_config(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_kms_config via a request object, either of type CreateKmsConfigRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateKmsConfigRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_kms_config(parent: nil, kms_config_id: nil, kms_config: nil) ⇒ ::Gapic::Operation

Pass arguments to create_kms_config 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Value for parent.
- kms_config_id (::String) (defaults to: nil) —
  Required. Id of the requesting KmsConfig. Must be unique within the parent resource. Must contain only letters, numbers and hyphen, with the first character a letter, the last a letter or a number, and a 63 character maximum.
- kms_config (::Google::Cloud::NetApp::V1::KmsConfig, ::Hash) (defaults to: nil) —
  Required. The required parameters to create a new KmsConfig.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2858

def create_kms_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateKmsConfigRequest

  # 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_kms_config.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_kms_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_kms_config.retry_policy

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

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

#create_quota_rule(request, options = nil) ⇒ `::Gapic::Operation` #create_quota_rule(parent: nil, quota_rule: nil, quota_rule_id: nil) ⇒ `::Gapic::Operation`

Creates a new quota rule.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateQuotaRuleRequest.new

# Call the create_quota_rule method.
result = client.create_quota_rule request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_quota_rule(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_quota_rule via a request object, either of type CreateQuotaRuleRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateQuotaRuleRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_quota_rule(parent: nil, quota_rule: nil, quota_rule_id: nil) ⇒ ::Gapic::Operation

Pass arguments to create_quota_rule 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value for CreateQuotaRuleRequest
- quota_rule (::Google::Cloud::NetApp::V1::QuotaRule, ::Hash) (defaults to: nil) —
  Required. Fields of the to be created quota rule.
- quota_rule_id (::String) (defaults to: nil) —
  Required. ID of the quota rule to create. Must be unique within the parent resource. Must contain only letters, numbers, underscore and hyphen, with the first character a letter or underscore, the last a letter or underscore or a number, and a 63 character maximum.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6050

def create_quota_rule request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateQuotaRuleRequest

  # 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_quota_rule.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_quota_rule.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_quota_rule.retry_policy

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

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

#create_replication(request, options = nil) ⇒ `::Gapic::Operation` #create_replication(parent: nil, replication: nil, replication_id: nil) ⇒ `::Gapic::Operation`

Create a new replication for a volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateReplicationRequest.new

# Call the create_replication method.
result = client.create_replication request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_replication(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_replication via a request object, either of type CreateReplicationRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateReplicationRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_replication(parent: nil, replication: nil, replication_id: nil) ⇒ ::Gapic::Operation

Pass arguments to create_replication 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The NetApp volume to create the replications of, in the format projects/{project_id}/locations/{location}/volumes/{volume_id}
- replication (::Google::Cloud::NetApp::V1::Replication, ::Hash) (defaults to: nil) —
  Required. A replication resource
- replication_id (::String) (defaults to: nil) —
  Required. ID of the replication to create. Must be unique within the parent resource. Must contain only letters, numbers and hyphen, with the first character a letter, the last a letter or a number, and a 63 character maximum.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3607

def create_replication request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateReplicationRequest

  # 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_replication.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_replication.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_replication.retry_policy

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

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

#create_snapshot(request, options = nil) ⇒ `::Gapic::Operation` #create_snapshot(parent: nil, snapshot: nil, snapshot_id: nil) ⇒ `::Gapic::Operation`

Create a new snapshot for a volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateSnapshotRequest.new

# Call the create_snapshot method.
result = client.create_snapshot request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_snapshot(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_snapshot via a request object, either of type CreateSnapshotRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateSnapshotRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_snapshot(parent: nil, snapshot: nil, snapshot_id: nil) ⇒ ::Gapic::Operation

Pass arguments to create_snapshot 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The NetApp volume to create the snapshots of, in the format projects/{project_id}/locations/{location}/volumes/{volume_id}
- snapshot (::Google::Cloud::NetApp::V1::Snapshot, ::Hash) (defaults to: nil) —
  Required. A snapshot resource
- snapshot_id (::String) (defaults to: nil) —
  Required. ID of the snapshot to create. Must be unique within the parent resource. Must contain only letters, numbers and hyphen, with the first character a letter, the last a letter or a number, and a 63 character maximum.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1984

def create_snapshot request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateSnapshotRequest

  # 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_snapshot.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_snapshot.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_snapshot.retry_policy

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

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

#create_storage_pool(request, options = nil) ⇒ `::Gapic::Operation` #create_storage_pool(parent: nil, storage_pool_id: nil, storage_pool: nil) ⇒ `::Gapic::Operation`

Creates a new storage pool.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateStoragePoolRequest.new

# Call the create_storage_pool method.
result = client.create_storage_pool request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_storage_pool(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_storage_pool via a request object, either of type CreateStoragePoolRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateStoragePoolRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_storage_pool(parent: nil, storage_pool_id: nil, storage_pool: nil) ⇒ ::Gapic::Operation

Pass arguments to create_storage_pool 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Value for parent.
- storage_pool_id (::String) (defaults to: nil) —
  Required. Id of the requesting storage pool. Must be unique within the parent resource. Must contain only letters, numbers and hyphen, with the first character a letter, the last a letter or a number, and a 63 character maximum.
- storage_pool (::Google::Cloud::NetApp::V1::StoragePool, ::Hash) (defaults to: nil) —
  Required. The required parameters to create a new storage pool.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 531

def create_storage_pool request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateStoragePoolRequest

  # 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_storage_pool.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_storage_pool.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_storage_pool.retry_policy

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

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

#create_volume(request, options = nil) ⇒ `::Gapic::Operation` #create_volume(parent: nil, volume_id: nil, volume: nil) ⇒ `::Gapic::Operation`

Creates a new Volume in a given project and location.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::CreateVolumeRequest.new

# Call the create_volume method.
result = client.create_volume request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#create_volume(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to create_volume via a request object, either of type CreateVolumeRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::CreateVolumeRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#create_volume(parent: nil, volume_id: nil, volume: nil) ⇒ ::Gapic::Operation

Pass arguments to create_volume 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Value for parent.
- volume_id (::String) (defaults to: nil) —
  Required. Id of the requesting volume. Must be unique within the parent resource. Must contain only letters, numbers and hyphen, with the first character a letter, the last a letter or a number, and a 63 character maximum.
- volume (::Google::Cloud::NetApp::V1::Volume, ::Hash) (defaults to: nil) —
  Required. The volume being created.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1288

def create_volume request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::CreateVolumeRequest

  # 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_volume.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_volume.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.create_volume.retry_policy

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

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

#delete_active_directory(request, options = nil) ⇒ `::Gapic::Operation` #delete_active_directory(name: nil) ⇒ `::Gapic::Operation`

Delete the active directory specified in the request.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteActiveDirectoryRequest.new

# Call the delete_active_directory method.
result = client.delete_active_directory request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_active_directory(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_active_directory via a request object, either of type DeleteActiveDirectoryRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteActiveDirectoryRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_active_directory(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_active_directory 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the active directory.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2657

def delete_active_directory request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteActiveDirectoryRequest

  # 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_active_directory.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_active_directory.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_active_directory.retry_policy

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

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

#delete_backup(request, options = nil) ⇒ `::Gapic::Operation` #delete_backup(name: nil) ⇒ `::Gapic::Operation`

Warning! This operation will permanently delete the backup.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteBackupRequest.new

# Call the delete_backup method.
result = client.delete_backup request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_backup(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_backup via a request object, either of type DeleteBackupRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteBackupRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_backup(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_backup 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The backup resource name, in the format projects/{project_id}/locations/{location}/backupVaults/{backup_vault_id}/backups/{backup_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5180

def delete_backup request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteBackupRequest

  # 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_backup.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_backup.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_backup.retry_policy

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

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

#delete_backup_policy(request, options = nil) ⇒ `::Gapic::Operation` #delete_backup_policy(name: nil) ⇒ `::Gapic::Operation`

Warning! This operation will permanently delete the backup policy.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteBackupPolicyRequest.new

# Call the delete_backup_policy method.
result = client.delete_backup_policy request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_backup_policy(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_backup_policy via a request object, either of type DeleteBackupPolicyRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteBackupPolicyRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_backup_policy(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_backup_policy 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The backup policy resource name, in the format projects/{project_id}/locations/{location}/backupPolicies/{backup_policy_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5764

def delete_backup_policy request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteBackupPolicyRequest

  # 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_backup_policy.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_backup_policy.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_backup_policy.retry_policy

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

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

#delete_backup_vault(request, options = nil) ⇒ `::Gapic::Operation` #delete_backup_vault(name: nil) ⇒ `::Gapic::Operation`

Warning! This operation will permanently delete the backup vault.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteBackupVaultRequest.new

# Call the delete_backup_vault method.
result = client.delete_backup_vault request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_backup_vault(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_backup_vault via a request object, either of type DeleteBackupVaultRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteBackupVaultRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_backup_vault(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_backup_vault 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The backupVault resource name, in the format projects/{project_id}/locations/{location}/backupVaults/{backup_vault_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4780

def delete_backup_vault request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteBackupVaultRequest

  # 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_backup_vault.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_backup_vault.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_backup_vault.retry_policy

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

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

#delete_host_group(request, options = nil) ⇒ `::Gapic::Operation` #delete_host_group(name: nil) ⇒ `::Gapic::Operation`

Deletes a host group.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteHostGroupRequest.new

# Call the delete_host_group method.
result = client.delete_host_group request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_host_group(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_host_group via a request object, either of type DeleteHostGroupRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteHostGroupRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_host_group(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_host_group 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of the host group. Format: projects/{project_number}/locations/{location_id}/hostGroups/{host_group_id}.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6832

def delete_host_group request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteHostGroupRequest

  # 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_host_group.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_host_group.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_host_group.retry_policy

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

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

#delete_kms_config(request, options = nil) ⇒ `::Gapic::Operation` #delete_kms_config(name: nil) ⇒ `::Gapic::Operation`

Warning! This operation will permanently delete the Kms config.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteKmsConfigRequest.new

# Call the delete_kms_config method.
result = client.delete_kms_config request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_kms_config(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_kms_config via a request object, either of type DeleteKmsConfigRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteKmsConfigRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_kms_config(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_kms_config 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the KmsConfig.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3317

def delete_kms_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteKmsConfigRequest

  # 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_kms_config.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_kms_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_kms_config.retry_policy

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

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

#delete_quota_rule(request, options = nil) ⇒ `::Gapic::Operation` #delete_quota_rule(name: nil) ⇒ `::Gapic::Operation`

Deletes a quota rule.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteQuotaRuleRequest.new

# Call the delete_quota_rule method.
result = client.delete_quota_rule request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_quota_rule(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_quota_rule via a request object, either of type DeleteQuotaRuleRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteQuotaRuleRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_quota_rule(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_quota_rule 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the quota rule.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6244

def delete_quota_rule request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteQuotaRuleRequest

  # 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_quota_rule.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_quota_rule.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_quota_rule.retry_policy

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

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

#delete_replication(request, options = nil) ⇒ `::Gapic::Operation` #delete_replication(name: nil) ⇒ `::Gapic::Operation`

Deletes a replication.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteReplicationRequest.new

# Call the delete_replication method.
result = client.delete_replication request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_replication(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_replication via a request object, either of type DeleteReplicationRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteReplicationRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_replication(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_replication 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The replication resource name, in the format projects/*/locations/*/volumes/*/replications/{replication_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3702

def delete_replication request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteReplicationRequest

  # 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_replication.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_replication.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_replication.retry_policy

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

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

#delete_snapshot(request, options = nil) ⇒ `::Gapic::Operation` #delete_snapshot(name: nil) ⇒ `::Gapic::Operation`

Deletes a snapshot.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteSnapshotRequest.new

# Call the delete_snapshot method.
result = client.delete_snapshot request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_snapshot(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_snapshot via a request object, either of type DeleteSnapshotRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteSnapshotRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_snapshot(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_snapshot 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The snapshot resource name, in the format projects/*/locations/*/volumes/*/snapshots/{snapshot_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2079

def delete_snapshot request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteSnapshotRequest

  # 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_snapshot.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_snapshot.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_snapshot.retry_policy

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

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

#delete_storage_pool(request, options = nil) ⇒ `::Gapic::Operation` #delete_storage_pool(name: nil) ⇒ `::Gapic::Operation`

Warning! This operation will permanently delete the storage pool.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteStoragePoolRequest.new

# Call the delete_storage_pool method.
result = client.delete_storage_pool request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_storage_pool(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_storage_pool via a request object, either of type DeleteStoragePoolRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteStoragePoolRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_storage_pool(name: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_storage_pool 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the storage pool

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 810

def delete_storage_pool request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteStoragePoolRequest

  # 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_storage_pool.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_storage_pool.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_storage_pool.retry_policy

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

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

#delete_volume(request, options = nil) ⇒ `::Gapic::Operation` #delete_volume(name: nil, force: nil) ⇒ `::Gapic::Operation`

Deletes a single Volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::DeleteVolumeRequest.new

# Call the delete_volume method.
result = client.delete_volume request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#delete_volume(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to delete_volume via a request object, either of type DeleteVolumeRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::DeleteVolumeRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#delete_volume(name: nil, force: nil) ⇒ ::Gapic::Operation

Pass arguments to delete_volume 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the volume
- force (::Boolean) (defaults to: nil) —
  If this field is set as true, CCFE will not block the volume resource deletion even if it has any snapshots resource. (Otherwise, the request will only work if the volume has no snapshots.)

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1486

def delete_volume request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::DeleteVolumeRequest

  # 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_volume.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_volume.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.delete_volume.retry_policy

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

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

#encrypt_volumes(request, options = nil) ⇒ `::Gapic::Operation` #encrypt_volumes(name: nil) ⇒ `::Gapic::Operation`

Encrypt the existing volumes without CMEK encryption with the desired the KMS config for the whole region.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::EncryptVolumesRequest.new

# Call the encrypt_volumes method.
result = client.encrypt_volumes request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#encrypt_volumes(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to encrypt_volumes via a request object, either of type EncryptVolumesRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::EncryptVolumesRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#encrypt_volumes(name: nil) ⇒ ::Gapic::Operation

Pass arguments to encrypt_volumes 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the KmsConfig.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3138

def encrypt_volumes request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::EncryptVolumesRequest

  # 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.encrypt_volumes.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.encrypt_volumes.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.encrypt_volumes.retry_policy

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

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

#establish_peering(request, options = nil) ⇒ `::Gapic::Operation` #establish_peering(name: nil, peer_cluster_name: nil, peer_svm_name: nil, peer_ip_addresses: nil, peer_volume_name: nil) ⇒ `::Gapic::Operation`

Establish replication peering.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::EstablishPeeringRequest.new

# Call the establish_peering method.
result = client.establish_peering request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#establish_peering(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to establish_peering via a request object, either of type EstablishPeeringRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::EstablishPeeringRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#establish_peering(name: nil, peer_cluster_name: nil, peer_svm_name: nil, peer_ip_addresses: nil, peer_volume_name: nil) ⇒ ::Gapic::Operation

Pass arguments to establish_peering 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of the replication, in the format of projects/{project_id}/locations/{location}/volumes/{volume_id}/replications/{replication_id}.
- peer_cluster_name (::String) (defaults to: nil) —
  Required. Name of the user's local source cluster to be peered with the destination cluster.
- peer_svm_name (::String) (defaults to: nil) —
  Required. Name of the user's local source vserver svm to be peered with the destination vserver svm.
- peer_ip_addresses (::Array<::String>) (defaults to: nil) —
  Optional. List of IPv4 ip addresses to be used for peering.
- peer_volume_name (::String) (defaults to: nil) —
  Required. Name of the user's local source volume to be peered with the destination volume.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4198

def establish_peering request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::EstablishPeeringRequest

  # 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.establish_peering.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.establish_peering.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.establish_peering.retry_policy

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

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

#establish_volume_peering(request, options = nil) ⇒ `::Gapic::Operation` #establish_volume_peering(name: nil, peer_cluster_name: nil, peer_svm_name: nil, peer_ip_addresses: nil, peer_volume_name: nil) ⇒ `::Gapic::Operation`

Establish volume peering. This is used to establish cluster and svm peerings between the GCNV and OnPrem clusters.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::EstablishVolumePeeringRequest.new

# Call the establish_volume_peering method.
result = client.establish_volume_peering request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#establish_volume_peering(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to establish_volume_peering via a request object, either of type EstablishVolumePeeringRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::EstablishVolumePeeringRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#establish_volume_peering(name: nil, peer_cluster_name: nil, peer_svm_name: nil, peer_ip_addresses: nil, peer_volume_name: nil) ⇒ ::Gapic::Operation

Pass arguments to establish_volume_peering 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The volume resource name, in the format projects/{project_id}/locations/{location}/volumes/{volume_id}
- peer_cluster_name (::String) (defaults to: nil) —
  Required. Name of the user's local source cluster to be peered with the destination cluster.
- peer_svm_name (::String) (defaults to: nil) —
  Required. Name of the user's local source vserver svm to be peered with the destination vserver svm.
- peer_ip_addresses (::Array<::String>) (defaults to: nil) —
  Optional. List of IPv4 ip addresses to be used for peering.
- peer_volume_name (::String) (defaults to: nil) —
  Required. Name of the user's local source volume to be peered with the destination volume.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1694

def establish_volume_peering request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::EstablishVolumePeeringRequest

  # 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.establish_volume_peering.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.establish_volume_peering.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.establish_volume_peering.retry_policy

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

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

#execute_ontap_delete(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse` #execute_ontap_delete(ontap_path: nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse`

ExecuteOntapDelete dispatches the ONTAP DELETE request to the StoragePool cluster.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ExecuteOntapDeleteRequest.new

# Call the execute_ontap_delete method.
result = client.execute_ontap_delete request

# The returned object is of type Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse.
p result

Overloads:

#execute_ontap_delete(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse

Pass arguments to execute_ontap_delete via a request object, either of type ExecuteOntapDeleteRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ExecuteOntapDeleteRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#execute_ontap_delete(ontap_path: nil) ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse

Pass arguments to execute_ontap_delete 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).
Parameters:
- ontap_path (::String) (defaults to: nil) —
  Required. The resource path of the ONTAP resource. Format: projects/{project_number}/locations/{location_id}/storagePools/{storage_pool_id}/ontap/{ontap_resource_path}. For example: projects/123456789/locations/us-central1/storagePools/my-storage-pool/ontap/api/storage/volumes.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 7116

def execute_ontap_delete request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ExecuteOntapDeleteRequest

  # 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.execute_ontap_delete.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.ontap_path
    header_params["ontap_path"] = request.ontap_path
  end

  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.execute_ontap_delete.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.execute_ontap_delete.retry_policy

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

  @net_app_stub.call_rpc :execute_ontap_delete, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#execute_ontap_get(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse` #execute_ontap_get(ontap_path: nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse`

ExecuteOntapGet dispatches the ONTAP GET request to the StoragePool cluster.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ExecuteOntapGetRequest.new

# Call the execute_ontap_get method.
result = client.execute_ontap_get request

# The returned object is of type Google::Cloud::NetApp::V1::ExecuteOntapGetResponse.
p result

Overloads:

#execute_ontap_get(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse

Pass arguments to execute_ontap_get via a request object, either of type ExecuteOntapGetRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ExecuteOntapGetRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#execute_ontap_get(ontap_path: nil) ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse

Pass arguments to execute_ontap_get 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).
Parameters:
- ontap_path (::String) (defaults to: nil) —
  Required. The resource path of the ONTAP resource. Format: projects/{project_number}/locations/{location_id}/storagePools/{storage_pool_id}/ontap/{ontap_resource_path}. For example: projects/123456789/locations/us-central1/storagePools/my-storage-pool/ontap/api/storage/volumes.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 7026

def execute_ontap_get request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ExecuteOntapGetRequest

  # 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.execute_ontap_get.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.ontap_path
    header_params["ontap_path"] = request.ontap_path
  end

  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.execute_ontap_get.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.execute_ontap_get.retry_policy

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

  @net_app_stub.call_rpc :execute_ontap_get, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#execute_ontap_patch(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse` #execute_ontap_patch(body: nil, ontap_path: nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse`

ExecuteOntapPatch dispatches the ONTAP PATCH request to the StoragePool cluster.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ExecuteOntapPatchRequest.new

# Call the execute_ontap_patch method.
result = client.execute_ontap_patch request

# The returned object is of type Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse.
p result

Overloads:

#execute_ontap_patch(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse

Pass arguments to execute_ontap_patch via a request object, either of type ExecuteOntapPatchRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ExecuteOntapPatchRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#execute_ontap_patch(body: nil, ontap_path: nil) ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse

Pass arguments to execute_ontap_patch 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).
Parameters:
- body (::Google::Protobuf::Struct, ::Hash) (defaults to: nil) —
  Required. The raw JSON body of the request. The body should be in the format of the ONTAP resource. For example:
```
{
  "body": {
    "field1": "value1",
    "field2": "value2",
  }
}
```
- ontap_path (::String) (defaults to: nil) —
  Required. The resource path of the ONTAP resource. Format: projects/{project_number}/locations/{location_id}/storagePools/{storage_pool_id}/ontap/{ontap_resource_path}. For example: projects/123456789/locations/us-central1/storagePools/my-storage-pool/ontap/api/storage/volumes.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 7218

def execute_ontap_patch request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ExecuteOntapPatchRequest

  # 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.execute_ontap_patch.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.ontap_path
    header_params["ontap_path"] = request.ontap_path
  end

  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.execute_ontap_patch.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.execute_ontap_patch.retry_policy

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

  @net_app_stub.call_rpc :execute_ontap_patch, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#execute_ontap_post(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse` #execute_ontap_post(body: nil, ontap_path: nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse`

ExecuteOntapPost dispatches the ONTAP POST request to the StoragePool cluster.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ExecuteOntapPostRequest.new

# Call the execute_ontap_post method.
result = client.execute_ontap_post request

# The returned object is of type Google::Cloud::NetApp::V1::ExecuteOntapPostResponse.
p result

Overloads:

#execute_ontap_post(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse

Pass arguments to execute_ontap_post via a request object, either of type ExecuteOntapPostRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ExecuteOntapPostRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#execute_ontap_post(body: nil, ontap_path: nil) ⇒ ::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse

Pass arguments to execute_ontap_post 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).
Parameters:
- body (::Google::Protobuf::Struct, ::Hash) (defaults to: nil) —
  Required. The raw JSON body of the request. The body should be in the format of the ONTAP resource. For example:
```
{
  "body": {
    "field1": "value1",
    "field2": "value2",
  }
}
```
- ontap_path (::String) (defaults to: nil) —
  Required. The resource path of the ONTAP resource. Format: projects/{project_number}/locations/{location_id}/storagePools/{storage_pool_id}/ontap/{ontap_resource_path}. For example: projects/123456789/locations/us-central1/storagePools/my-storage-pool/ontap/api/storage/volumes.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6936

def execute_ontap_post request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ExecuteOntapPostRequest

  # 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.execute_ontap_post.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.ontap_path
    header_params["ontap_path"] = request.ontap_path
  end

  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.execute_ontap_post.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.execute_ontap_post.retry_policy

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

  @net_app_stub.call_rpc :execute_ontap_post, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_active_directory(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ActiveDirectory` #get_active_directory(name: nil) ⇒ `::Google::Cloud::NetApp::V1::ActiveDirectory`

Describes a specified active directory.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetActiveDirectoryRequest.new

# Call the get_active_directory method.
result = client.get_active_directory request

# The returned object is of type Google::Cloud::NetApp::V1::ActiveDirectory.
p result

Overloads:

#get_active_directory(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::ActiveDirectory

Pass arguments to get_active_directory via a request object, either of type GetActiveDirectoryRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetActiveDirectoryRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_active_directory(name: nil) ⇒ ::Google::Cloud::NetApp::V1::ActiveDirectory

Pass arguments to get_active_directory 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the active directory.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::ActiveDirectory)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::ActiveDirectory)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2363

def get_active_directory request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetActiveDirectoryRequest

  # 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_active_directory.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_active_directory.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_active_directory.retry_policy

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

  @net_app_stub.call_rpc :get_active_directory, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_backup(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::Backup` #get_backup(name: nil) ⇒ `::Google::Cloud::NetApp::V1::Backup`

Returns the description of the specified backup

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetBackupRequest.new

# Call the get_backup method.
result = client.get_backup request

# The returned object is of type Google::Cloud::NetApp::V1::Backup.
p result

Overloads:

#get_backup(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::Backup

Pass arguments to get_backup via a request object, either of type GetBackupRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetBackupRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_backup(name: nil) ⇒ ::Google::Cloud::NetApp::V1::Backup

Pass arguments to get_backup 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The backup resource name, in the format projects/{project_id}/locations/{location}/backupVaults/{backup_vault_id}/backups/{backup_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::Backup)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::Backup)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4974

def get_backup request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetBackupRequest

  # 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_backup.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_backup.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_backup.retry_policy

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

  @net_app_stub.call_rpc :get_backup, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_backup_policy(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::BackupPolicy` #get_backup_policy(name: nil) ⇒ `::Google::Cloud::NetApp::V1::BackupPolicy`

Returns the description of the specified backup policy by backup_policy_id.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetBackupPolicyRequest.new

# Call the get_backup_policy method.
result = client.get_backup_policy request

# The returned object is of type Google::Cloud::NetApp::V1::BackupPolicy.
p result

Overloads:

#get_backup_policy(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::BackupPolicy

Pass arguments to get_backup_policy via a request object, either of type GetBackupPolicyRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetBackupPolicyRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_backup_policy(name: nil) ⇒ ::Google::Cloud::NetApp::V1::BackupPolicy

Pass arguments to get_backup_policy 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The backupPolicy resource name, in the format projects/{project_id}/locations/{location}/backupPolicies/{backup_policy_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::BackupPolicy)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::BackupPolicy)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5471

def get_backup_policy request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetBackupPolicyRequest

  # 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_backup_policy.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_backup_policy.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_backup_policy.retry_policy

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

  @net_app_stub.call_rpc :get_backup_policy, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_backup_vault(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::BackupVault` #get_backup_vault(name: nil) ⇒ `::Google::Cloud::NetApp::V1::BackupVault`

Returns the description of the specified backup vault

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetBackupVaultRequest.new

# Call the get_backup_vault method.
result = client.get_backup_vault request

# The returned object is of type Google::Cloud::NetApp::V1::BackupVault.
p result

Overloads:

#get_backup_vault(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::BackupVault

Pass arguments to get_backup_vault via a request object, either of type GetBackupVaultRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetBackupVaultRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_backup_vault(name: nil) ⇒ ::Google::Cloud::NetApp::V1::BackupVault

Pass arguments to get_backup_vault 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The backupVault resource name, in the format projects/{project_id}/locations/{location}/backupVaults/{backup_vault_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::BackupVault)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::BackupVault)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4485

def get_backup_vault request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetBackupVaultRequest

  # 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_backup_vault.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_backup_vault.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_backup_vault.retry_policy

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

  @net_app_stub.call_rpc :get_backup_vault, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_host_group(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::HostGroup` #get_host_group(name: nil) ⇒ `::Google::Cloud::NetApp::V1::HostGroup`

Returns details of the specified host group.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetHostGroupRequest.new

# Call the get_host_group method.
result = client.get_host_group request

# The returned object is of type Google::Cloud::NetApp::V1::HostGroup.
p result

Overloads:

#get_host_group(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::HostGroup

Pass arguments to get_host_group via a request object, either of type GetHostGroupRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetHostGroupRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_host_group(name: nil) ⇒ ::Google::Cloud::NetApp::V1::HostGroup

Pass arguments to get_host_group 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of the host group. Format: projects/{project_number}/locations/{location_id}/hostGroups/{host_group_id}.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::HostGroup)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::HostGroup)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6538

def get_host_group request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetHostGroupRequest

  # 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_host_group.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_host_group.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_host_group.retry_policy

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

  @net_app_stub.call_rpc :get_host_group, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_kms_config(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::KmsConfig` #get_kms_config(name: nil) ⇒ `::Google::Cloud::NetApp::V1::KmsConfig`

Returns the description of the specified KMS config by kms_config_id.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetKmsConfigRequest.new

# Call the get_kms_config method.
result = client.get_kms_config request

# The returned object is of type Google::Cloud::NetApp::V1::KmsConfig.
p result

Overloads:

#get_kms_config(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::KmsConfig

Pass arguments to get_kms_config via a request object, either of type GetKmsConfigRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetKmsConfigRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_kms_config(name: nil) ⇒ ::Google::Cloud::NetApp::V1::KmsConfig

Pass arguments to get_kms_config 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the KmsConfig

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::KmsConfig)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::KmsConfig)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2945

def get_kms_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetKmsConfigRequest

  # 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_kms_config.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_kms_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_kms_config.retry_policy

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

  @net_app_stub.call_rpc :get_kms_config, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_quota_rule(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::QuotaRule` #get_quota_rule(name: nil) ⇒ `::Google::Cloud::NetApp::V1::QuotaRule`

Returns details of the specified quota rule.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetQuotaRuleRequest.new

# Call the get_quota_rule method.
result = client.get_quota_rule request

# The returned object is of type Google::Cloud::NetApp::V1::QuotaRule.
p result

Overloads:

#get_quota_rule(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::QuotaRule

Pass arguments to get_quota_rule via a request object, either of type GetQuotaRuleRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetQuotaRuleRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_quota_rule(name: nil) ⇒ ::Google::Cloud::NetApp::V1::QuotaRule

Pass arguments to get_quota_rule 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the quota rule

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::QuotaRule)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::QuotaRule)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5951

def get_quota_rule request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetQuotaRuleRequest

  # 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_quota_rule.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_quota_rule.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_quota_rule.retry_policy

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

  @net_app_stub.call_rpc :get_quota_rule, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_replication(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::Replication` #get_replication(name: nil) ⇒ `::Google::Cloud::NetApp::V1::Replication`

Describe a replication for a volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetReplicationRequest.new

# Call the get_replication method.
result = client.get_replication request

# The returned object is of type Google::Cloud::NetApp::V1::Replication.
p result

Overloads:

#get_replication(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::Replication

Pass arguments to get_replication via a request object, either of type GetReplicationRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetReplicationRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_replication(name: nil) ⇒ ::Google::Cloud::NetApp::V1::Replication

Pass arguments to get_replication 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The replication resource name, in the format projects/{project_id}/locations/{location}/volumes/{volume_id}/replications/{replication_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::Replication)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::Replication)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3507

def get_replication request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetReplicationRequest

  # 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_replication.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_replication.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_replication.retry_policy

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

  @net_app_stub.call_rpc :get_replication, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_snapshot(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::Snapshot` #get_snapshot(name: nil) ⇒ `::Google::Cloud::NetApp::V1::Snapshot`

Describe a snapshot for a volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetSnapshotRequest.new

# Call the get_snapshot method.
result = client.get_snapshot request

# The returned object is of type Google::Cloud::NetApp::V1::Snapshot.
p result

Overloads:

#get_snapshot(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::Snapshot

Pass arguments to get_snapshot via a request object, either of type GetSnapshotRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetSnapshotRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_snapshot(name: nil) ⇒ ::Google::Cloud::NetApp::V1::Snapshot

Pass arguments to get_snapshot 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The snapshot resource name, in the format projects/{project_id}/locations/{location}/volumes/{volume_id}/snapshots/{snapshot_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::Snapshot)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::Snapshot)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1884

def get_snapshot request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetSnapshotRequest

  # 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_snapshot.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_snapshot.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_snapshot.retry_policy

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

  @net_app_stub.call_rpc :get_snapshot, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_storage_pool(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::StoragePool` #get_storage_pool(name: nil) ⇒ `::Google::Cloud::NetApp::V1::StoragePool`

Returns the description of the specified storage pool by poolId.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetStoragePoolRequest.new

# Call the get_storage_pool method.
result = client.get_storage_pool request

# The returned object is of type Google::Cloud::NetApp::V1::StoragePool.
p result

Overloads:

#get_storage_pool(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::StoragePool

Pass arguments to get_storage_pool via a request object, either of type GetStoragePoolRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetStoragePoolRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_storage_pool(name: nil) ⇒ ::Google::Cloud::NetApp::V1::StoragePool

Pass arguments to get_storage_pool 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the storage pool

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::StoragePool)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::StoragePool)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 618

def get_storage_pool request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetStoragePoolRequest

  # 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_storage_pool.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_storage_pool.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_storage_pool.retry_policy

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

  @net_app_stub.call_rpc :get_storage_pool, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#get_volume(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::Volume` #get_volume(name: nil) ⇒ `::Google::Cloud::NetApp::V1::Volume`

Gets details of a single Volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::GetVolumeRequest.new

# Call the get_volume method.
result = client.get_volume request

# The returned object is of type Google::Cloud::NetApp::V1::Volume.
p result

Overloads:

#get_volume(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::Volume

Pass arguments to get_volume via a request object, either of type GetVolumeRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::GetVolumeRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#get_volume(name: nil) ⇒ ::Google::Cloud::NetApp::V1::Volume

Pass arguments to get_volume 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the volume

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::Volume)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::Volume)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1189

def get_volume request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::GetVolumeRequest

  # 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_volume.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_volume.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.get_volume.retry_policy

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

  @net_app_stub.call_rpc :get_volume, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_active_directories(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::ActiveDirectory>` #list_active_directories(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::ActiveDirectory>`

Lists active directories.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListActiveDirectoriesRequest.new

# Call the list_active_directories method.
result = client.list_active_directories request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::ActiveDirectory.
  p item
end

Overloads:

#list_active_directories(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::ActiveDirectory>

Pass arguments to list_active_directories via a request object, either of type ListActiveDirectoriesRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListActiveDirectoriesRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_active_directories(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::ActiveDirectory>

Pass arguments to list_active_directories 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value for ListActiveDirectoriesRequest
- page_size (::Integer) (defaults to: nil) —
  Requested page size. Server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
- page_token (::String) (defaults to: nil) —
  A token identifying a page of results the server should return.
- filter (::String) (defaults to: nil) —
  Filtering results
- order_by (::String) (defaults to: nil) —
  Hint for how to order the results

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::ActiveDirectory>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::ActiveDirectory>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2276

def list_active_directories request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListActiveDirectoriesRequest

  # 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_active_directories.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_active_directories.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_active_directories.retry_policy

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

  @net_app_stub.call_rpc :list_active_directories, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_active_directories, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_backup_policies(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>` #list_backup_policies(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>`

Returns list of all available backup policies.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListBackupPoliciesRequest.new

# Call the list_backup_policies method.
result = client.list_backup_policies request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::BackupPolicy.
  p item
end

Overloads:

#list_backup_policies(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>

Pass arguments to list_backup_policies via a request object, either of type ListBackupPoliciesRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListBackupPoliciesRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_backup_policies(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>

Pass arguments to list_backup_policies 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value for ListBackupPoliciesRequest
- page_size (::Integer) (defaults to: nil) —
  Requested page size. Server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
- page_token (::String) (defaults to: nil) —
  A token identifying a page of results the server should return.
- filter (::String) (defaults to: nil) —
  Filtering results
- order_by (::String) (defaults to: nil) —
  Hint for how to order the results

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5569

def list_backup_policies request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListBackupPoliciesRequest

  # 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_backup_policies.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_backup_policies.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_backup_policies.retry_policy

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

  @net_app_stub.call_rpc :list_backup_policies, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_backup_policies, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_backup_vaults(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>` #list_backup_vaults(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>`

Returns list of all available backup vaults.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListBackupVaultsRequest.new

# Call the list_backup_vaults method.
result = client.list_backup_vaults request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::BackupVault.
  p item
end

Overloads:

#list_backup_vaults(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>

Pass arguments to list_backup_vaults via a request object, either of type ListBackupVaultsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListBackupVaultsRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_backup_vaults(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>

Pass arguments to list_backup_vaults 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The location for which to retrieve backupVault information, in the format projects/{project_id}/locations/{location}.
- page_size (::Integer) (defaults to: nil) —
  The maximum number of items to return.
- page_token (::String) (defaults to: nil) —
  The next_page_token value to use if there are additional results to retrieve for this list request.
- order_by (::String) (defaults to: nil) —
  Sort results. Supported values are "name", "name desc" or "" (unsorted).
- filter (::String) (defaults to: nil) —
  List filter.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4585

def list_backup_vaults request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListBackupVaultsRequest

  # 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_backup_vaults.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_backup_vaults.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_backup_vaults.retry_policy

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

  @net_app_stub.call_rpc :list_backup_vaults, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_backup_vaults, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_backups(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>` #list_backups(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>`

Returns descriptions of all backups for a backupVault.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListBackupsRequest.new

# Call the list_backups method.
result = client.list_backups request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::Backup.
  p item
end

Overloads:

#list_backups(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>

Pass arguments to list_backups via a request object, either of type ListBackupsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListBackupsRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_backups(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>

Pass arguments to list_backups 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The backupVault for which to retrieve backup information, in the format projects/{project_id}/locations/{location}/backupVaults/{backup_vault_id}. To retrieve backup information for all locations, use "-" for the {location} value. To retrieve backup information for all backupVaults, use "-" for the {backup_vault_id} value. To retrieve backup information for a volume, use "-" for the {backup_vault_id} value and specify volume full name with the filter.
- page_size (::Integer) (defaults to: nil) —
  The maximum number of items to return. The service may return fewer than this value. The maximum value is 1000; values above 1000 will be coerced to 1000.
- page_token (::String) (defaults to: nil) —
  The next_page_token value to use if there are additional results to retrieve for this list request.
- order_by (::String) (defaults to: nil) —
  Sort results. Supported values are "name", "name desc" or "" (unsorted).
- filter (::String) (defaults to: nil) —
  The standard list filter. If specified, backups will be returned based on the attribute name that matches the filter expression. If empty, then no backups are filtered out. See https://google.aip.dev/160

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5085

def list_backups request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListBackupsRequest

  # 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_backups.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_backups.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_backups.retry_policy

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

  @net_app_stub.call_rpc :list_backups, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_backups, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_host_groups(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::HostGroup>` #list_host_groups(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::HostGroup>`

Returns a list of host groups in a location. Use - as location to list host groups across all locations.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListHostGroupsRequest.new

# Call the list_host_groups method.
result = client.list_host_groups request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::HostGroup.
  p item
end

Overloads:

#list_host_groups(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::HostGroup>

Pass arguments to list_host_groups via a request object, either of type ListHostGroupsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListHostGroupsRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_host_groups(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::HostGroup>

Pass arguments to list_host_groups 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value for ListHostGroupsRequest
- page_size (::Integer) (defaults to: nil) —
  Optional. Requested page size. Server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
- page_token (::String) (defaults to: nil) —
  Optional. A token identifying a page of results the server should return.
- filter (::String) (defaults to: nil) —
  Optional. Filter to apply to the request.
- order_by (::String) (defaults to: nil) —
  Optional. Hint for how to order the results

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::HostGroup>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::HostGroup>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6449

def list_host_groups request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListHostGroupsRequest

  # 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_host_groups.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_host_groups.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_host_groups.retry_policy

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

  @net_app_stub.call_rpc :list_host_groups, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_host_groups, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_kms_configs(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::KmsConfig>` #list_kms_configs(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::KmsConfig>`

Returns descriptions of all KMS configs owned by the caller.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListKmsConfigsRequest.new

# Call the list_kms_configs method.
result = client.list_kms_configs request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::KmsConfig.
  p item
end

Overloads:

#list_kms_configs(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::KmsConfig>

Pass arguments to list_kms_configs via a request object, either of type ListKmsConfigsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListKmsConfigsRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_kms_configs(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::KmsConfig>

Pass arguments to list_kms_configs 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value
- page_size (::Integer) (defaults to: nil) —
  The maximum number of items to return.
- page_token (::String) (defaults to: nil) —
  The next_page_token value to use if there are additional results to retrieve for this list request.
- order_by (::String) (defaults to: nil) —
  Sort results. Supported values are "name", "name desc" or "" (unsorted).
- filter (::String) (defaults to: nil) —
  List filter.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::KmsConfig>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::KmsConfig>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2757

def list_kms_configs request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListKmsConfigsRequest

  # 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_kms_configs.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_kms_configs.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_kms_configs.retry_policy

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

  @net_app_stub.call_rpc :list_kms_configs, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_kms_configs, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_quota_rules(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::QuotaRule>` #list_quota_rules(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::QuotaRule>`

Returns list of all quota rules in a location.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListQuotaRulesRequest.new

# Call the list_quota_rules method.
result = client.list_quota_rules request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::QuotaRule.
  p item
end

Overloads:

#list_quota_rules(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::QuotaRule>

Pass arguments to list_quota_rules via a request object, either of type ListQuotaRulesRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListQuotaRulesRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_quota_rules(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::QuotaRule>

Pass arguments to list_quota_rules 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value for ListQuotaRulesRequest
- page_size (::Integer) (defaults to: nil) —
  Optional. Requested page size. Server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
- page_token (::String) (defaults to: nil) —
  Optional. A token identifying a page of results the server should return.
- filter (::String) (defaults to: nil) —
  Optional. Filtering results
- order_by (::String) (defaults to: nil) —
  Optional. Hint for how to order the results

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::QuotaRule>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::QuotaRule>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5864

def list_quota_rules request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListQuotaRulesRequest

  # 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_quota_rules.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_quota_rules.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_quota_rules.retry_policy

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

  @net_app_stub.call_rpc :list_quota_rules, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_quota_rules, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_replications(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Replication>` #list_replications(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Replication>`

Returns descriptions of all replications for a volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListReplicationsRequest.new

# Call the list_replications method.
result = client.list_replications request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::Replication.
  p item
end

Overloads:

#list_replications(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Replication>

Pass arguments to list_replications via a request object, either of type ListReplicationsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListReplicationsRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_replications(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Replication>

Pass arguments to list_replications 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The volume for which to retrieve replication information, in the format projects/{project_id}/locations/{location}/volumes/{volume_id}.
- page_size (::Integer) (defaults to: nil) —
  The maximum number of items to return.
- page_token (::String) (defaults to: nil) —
  The next_page_token value to use if there are additional results to retrieve for this list request.
- order_by (::String) (defaults to: nil) —
  Sort results. Supported values are "name", "name desc" or "" (unsorted).
- filter (::String) (defaults to: nil) —
  List filter.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Replication>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Replication>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3419

def list_replications request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListReplicationsRequest

  # 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_replications.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_replications.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_replications.retry_policy

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

  @net_app_stub.call_rpc :list_replications, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_replications, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_snapshots(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Snapshot>` #list_snapshots(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Snapshot>`

Returns descriptions of all snapshots for a volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListSnapshotsRequest.new

# Call the list_snapshots method.
result = client.list_snapshots request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::Snapshot.
  p item
end

Overloads:

#list_snapshots(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Snapshot>

Pass arguments to list_snapshots via a request object, either of type ListSnapshotsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListSnapshotsRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_snapshots(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Snapshot>

Pass arguments to list_snapshots 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. The volume for which to retrieve snapshot information, in the format projects/{project_id}/locations/{location}/volumes/{volume_id}.
- page_size (::Integer) (defaults to: nil) —
  The maximum number of items to return.
- page_token (::String) (defaults to: nil) —
  The next_page_token value to use if there are additional results to retrieve for this list request.
- order_by (::String) (defaults to: nil) —
  Sort results. Supported values are "name", "name desc" or "" (unsorted).
- filter (::String) (defaults to: nil) —
  List filter.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Snapshot>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Snapshot>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1796

def list_snapshots request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListSnapshotsRequest

  # 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_snapshots.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_snapshots.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_snapshots.retry_policy

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

  @net_app_stub.call_rpc :list_snapshots, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_snapshots, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_storage_pools(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::StoragePool>` #list_storage_pools(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::StoragePool>`

Returns descriptions of all storage pools owned by the caller.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListStoragePoolsRequest.new

# Call the list_storage_pools method.
result = client.list_storage_pools request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::StoragePool.
  p item
end

Overloads:

#list_storage_pools(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::StoragePool>

Pass arguments to list_storage_pools via a request object, either of type ListStoragePoolsRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListStoragePoolsRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_storage_pools(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::StoragePool>

Pass arguments to list_storage_pools 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value
- page_size (::Integer) (defaults to: nil) —
  Optional. The maximum number of items to return.
- page_token (::String) (defaults to: nil) —
  Optional. The next_page_token value to use if there are additional results to retrieve for this list request.
- order_by (::String) (defaults to: nil) —
  Optional. Sort results. Supported values are "name", "name desc" or "" (unsorted).
- filter (::String) (defaults to: nil) —
  Optional. List filter.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::StoragePool>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::StoragePool>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 430

def list_storage_pools request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListStoragePoolsRequest

  # 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_storage_pools.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_storage_pools.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_storage_pools.retry_policy

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

  @net_app_stub.call_rpc :list_storage_pools, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_storage_pools, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#list_volumes(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Volume>` #list_volumes(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Volume>`

Lists Volumes in a given project.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ListVolumesRequest.new

# Call the list_volumes method.
result = client.list_volumes request

# The returned object is of type Gapic::PagedEnumerable. You can iterate
# over elements, and API calls will be issued to fetch pages as needed.
result.each do |item|
  # Each element is of type ::Google::Cloud::NetApp::V1::Volume.
  p item
end

Overloads:

#list_volumes(request, options = nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Volume>

Pass arguments to list_volumes via a request object, either of type ListVolumesRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ListVolumesRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#list_volumes(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ ::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Volume>

Pass arguments to list_volumes 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).
Parameters:
- parent (::String) (defaults to: nil) —
  Required. Parent value for ListVolumesRequest
- page_size (::Integer) (defaults to: nil) —
  Requested page size. Server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
- page_token (::String) (defaults to: nil) —
  A token identifying a page of results the server should return.
- filter (::String) (defaults to: nil) —
  Filtering results
- order_by (::String) (defaults to: nil) —
  Hint for how to order the results

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Volume>)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Volume>)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1102

def list_volumes request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ListVolumesRequest

  # 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_volumes.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.parent
    header_params["parent"] = request.parent
  end

  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_volumes.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.list_volumes.retry_policy

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

  @net_app_stub.call_rpc :list_volumes, request, options: options do |response, operation|
    response = ::Gapic::PagedEnumerable.new @net_app_stub, :list_volumes, request, response, operation, options
    yield response, operation if block_given?
    throw :response, response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

#logger ⇒ `Logger`

The logger used for request/response debug logging.

Returns:

(Logger)



366
367
368

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 366

def logger
  @net_app_stub.logger
end

#restore_backup_files(request, options = nil) ⇒ `::Gapic::Operation` #restore_backup_files(name: nil, backup: nil, file_list: nil, restore_destination_path: nil) ⇒ `::Gapic::Operation`

Restore files from a backup to a volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::RestoreBackupFilesRequest.new

# Call the restore_backup_files method.
result = client.restore_backup_files request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#restore_backup_files(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to restore_backup_files via a request object, either of type RestoreBackupFilesRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::RestoreBackupFilesRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#restore_backup_files(name: nil, backup: nil, file_list: nil, restore_destination_path: nil) ⇒ ::Gapic::Operation

Pass arguments to restore_backup_files 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The volume resource name, in the format projects/{project_id}/locations/{location}/volumes/{volume_id}
- backup (::String) (defaults to: nil) —
  Required. The backup resource name, in the format projects/{project_id}/locations/{location}/backupVaults/{backup_vault_id}/backups/{backup_id}
- file_list (::Array<::String>) (defaults to: nil) —
  Required. List of files to be restored, specified by their absolute path in the source volume.
- restore_destination_path (::String) (defaults to: nil) —
  Optional. Absolute directory path in the destination volume. This is required if the file_list is provided.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6348

def restore_backup_files request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::RestoreBackupFilesRequest

  # 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.restore_backup_files.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.restore_backup_files.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.restore_backup_files.retry_policy

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

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

#resume_replication(request, options = nil) ⇒ `::Gapic::Operation` #resume_replication(name: nil) ⇒ `::Gapic::Operation`

Resume Cross Region Replication.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ResumeReplicationRequest.new

# Call the resume_replication method.
result = client.resume_replication request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#resume_replication(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to resume_replication via a request object, either of type ResumeReplicationRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ResumeReplicationRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#resume_replication(name: nil) ⇒ ::Gapic::Operation

Pass arguments to resume_replication 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of the replication, in the format of projects/{project_id}/locations/{location}/volumes/{volume_id}/replications/{replication_id}.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3996

def resume_replication request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ResumeReplicationRequest

  # 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.resume_replication.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.resume_replication.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.resume_replication.retry_policy

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

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

#reverse_replication_direction(request, options = nil) ⇒ `::Gapic::Operation` #reverse_replication_direction(name: nil) ⇒ `::Gapic::Operation`

Reverses direction of replication. Source becomes destination and destination becomes source.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ReverseReplicationDirectionRequest.new

# Call the reverse_replication_direction method.
result = client.reverse_replication_direction request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#reverse_replication_direction(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to reverse_replication_direction via a request object, either of type ReverseReplicationDirectionRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ReverseReplicationDirectionRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#reverse_replication_direction(name: nil) ⇒ ::Gapic::Operation

Pass arguments to reverse_replication_direction 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of the replication, in the format of projects/{project_id}/locations/{location}/volumes/{volume_id}/replications/{replication_id}.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4092

def reverse_replication_direction request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ReverseReplicationDirectionRequest

  # 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.reverse_replication_direction.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.reverse_replication_direction.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.reverse_replication_direction.retry_policy

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

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

#revert_volume(request, options = nil) ⇒ `::Gapic::Operation` #revert_volume(name: nil, snapshot_id: nil) ⇒ `::Gapic::Operation`

Revert an existing volume to a specified snapshot. Warning! This operation will permanently revert all changes made after the snapshot was created.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::RevertVolumeRequest.new

# Call the revert_volume method.
result = client.revert_volume request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#revert_volume(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to revert_volume via a request object, either of type RevertVolumeRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::RevertVolumeRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#revert_volume(name: nil, snapshot_id: nil) ⇒ ::Gapic::Operation

Pass arguments to revert_volume 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of the volume, in the format of projects/{project_id}/locations/{location}/volumes/{volume_id}.
- snapshot_id (::String) (defaults to: nil) —
  Required. The snapshot resource ID, in the format 'my-snapshot', where the specified ID is the {snapshot_id} of the fully qualified name like projects/{project_id}/locations/{location_id}/volumes/{volume_id}/snapshots/{snapshot_id}

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1587

def revert_volume request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::RevertVolumeRequest

  # 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.revert_volume.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.revert_volume.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.revert_volume.retry_policy

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

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

#stop_replication(request, options = nil) ⇒ `::Gapic::Operation` #stop_replication(name: nil, force: nil) ⇒ `::Gapic::Operation`

Stop Cross Region Replication.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::StopReplicationRequest.new

# Call the stop_replication method.
result = client.stop_replication request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#stop_replication(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to stop_replication via a request object, either of type StopReplicationRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::StopReplicationRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#stop_replication(name: nil, force: nil) ⇒ ::Gapic::Operation

Pass arguments to stop_replication 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of the replication, in the format of projects/{project_id}/locations/{location}/volumes/{volume_id}/replications/{replication_id}.
- force (::Boolean) (defaults to: nil) —
  Indicates whether to stop replication forcefully while data transfer is in progress. Warning! if force is true, this will abort any current transfers and can lead to data loss due to partial transfer. If force is false, stop replication will fail while data transfer is in progress and you will need to retry later.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3901

def stop_replication request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::StopReplicationRequest

  # 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.stop_replication.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.stop_replication.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.stop_replication.retry_policy

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

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

#switch_active_replica_zone(request, options = nil) ⇒ `::Gapic::Operation` #switch_active_replica_zone(name: nil) ⇒ `::Gapic::Operation`

This operation will switch the active/replica zone for a regional storagePool.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::SwitchActiveReplicaZoneRequest.new

# Call the switch_active_replica_zone method.
result = client.switch_active_replica_zone request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#switch_active_replica_zone(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to switch_active_replica_zone via a request object, either of type SwitchActiveReplicaZoneRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::SwitchActiveReplicaZoneRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#switch_active_replica_zone(name: nil) ⇒ ::Gapic::Operation

Pass arguments to switch_active_replica_zone 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the storage pool

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1002

def switch_active_replica_zone request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::SwitchActiveReplicaZoneRequest

  # 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.switch_active_replica_zone.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.switch_active_replica_zone.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.switch_active_replica_zone.retry_policy

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

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

#sync_replication(request, options = nil) ⇒ `::Gapic::Operation` #sync_replication(name: nil) ⇒ `::Gapic::Operation`

Syncs the replication. This will invoke one time volume data transfer from source to destination.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::SyncReplicationRequest.new

# Call the sync_replication method.
result = client.sync_replication request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#sync_replication(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to sync_replication via a request object, either of type SyncReplicationRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::SyncReplicationRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#sync_replication(name: nil) ⇒ ::Gapic::Operation

Pass arguments to sync_replication 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. The resource name of the replication, in the format of projects/{project_id}/locations/{location}/volumes/{volume_id}/replications/{replication_id}.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4294

def sync_replication request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::SyncReplicationRequest

  # 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.sync_replication.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.sync_replication.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.sync_replication.retry_policy

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

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

#universe_domain ⇒ `String`

The effective universe domain

Returns:

(String)



261
262
263

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 261

def universe_domain
  @net_app_stub.universe_domain
end

#update_active_directory(request, options = nil) ⇒ `::Gapic::Operation` #update_active_directory(update_mask: nil, active_directory: nil) ⇒ `::Gapic::Operation`

Update the parameters of an active directories.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateActiveDirectoryRequest.new

# Call the update_active_directory method.
result = client.update_active_directory request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_active_directory(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_active_directory via a request object, either of type UpdateActiveDirectoryRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateActiveDirectoryRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_active_directory(update_mask: nil, active_directory: nil) ⇒ ::Gapic::Operation

Pass arguments to update_active_directory 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Field mask is used to specify the fields to be overwritten in the Active Directory resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.
- active_directory (::Google::Cloud::NetApp::V1::ActiveDirectory, ::Hash) (defaults to: nil) —
  Required. The volume being updated

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2563

def update_active_directory request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateActiveDirectoryRequest

  # 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_active_directory.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.active_directory&.name
    header_params["active_directory.name"] = request.active_directory.name
  end

  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_active_directory.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_active_directory.retry_policy

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

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

#update_backup(request, options = nil) ⇒ `::Gapic::Operation` #update_backup(update_mask: nil, backup: nil) ⇒ `::Gapic::Operation`

Update backup with full spec.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateBackupRequest.new

# Call the update_backup method.
result = client.update_backup request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_backup(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_backup via a request object, either of type UpdateBackupRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateBackupRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_backup(update_mask: nil, backup: nil) ⇒ ::Gapic::Operation

Pass arguments to update_backup 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Field mask is used to specify the fields to be overwritten in the Backup resource to be updated. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.
- backup (::Google::Cloud::NetApp::V1::Backup, ::Hash) (defaults to: nil) —
  Required. The backup being updated

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5280

def update_backup request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateBackupRequest

  # 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_backup.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.backup&.name
    header_params["backup.name"] = request.backup.name
  end

  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_backup.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_backup.retry_policy

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

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

#update_backup_policy(request, options = nil) ⇒ `::Gapic::Operation` #update_backup_policy(update_mask: nil, backup_policy: nil) ⇒ `::Gapic::Operation`

Updates settings of a specific backup policy.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateBackupPolicyRequest.new

# Call the update_backup_policy method.
result = client.update_backup_policy request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_backup_policy(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_backup_policy via a request object, either of type UpdateBackupPolicyRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateBackupPolicyRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_backup_policy(update_mask: nil, backup_policy: nil) ⇒ ::Gapic::Operation

Pass arguments to update_backup_policy 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Field mask is used to specify the fields to be overwritten in the Backup Policy resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.
- backup_policy (::Google::Cloud::NetApp::V1::BackupPolicy, ::Hash) (defaults to: nil) —
  Required. The backup policy being updated

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 5669

def update_backup_policy request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateBackupPolicyRequest

  # 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_backup_policy.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.backup_policy&.name
    header_params["backup_policy.name"] = request.backup_policy.name
  end

  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_backup_policy.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_backup_policy.retry_policy

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

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

#update_backup_vault(request, options = nil) ⇒ `::Gapic::Operation` #update_backup_vault(update_mask: nil, backup_vault: nil) ⇒ `::Gapic::Operation`

Updates the settings of a specific backup vault.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateBackupVaultRequest.new

# Call the update_backup_vault method.
result = client.update_backup_vault request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_backup_vault(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_backup_vault via a request object, either of type UpdateBackupVaultRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateBackupVaultRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_backup_vault(update_mask: nil, backup_vault: nil) ⇒ ::Gapic::Operation

Pass arguments to update_backup_vault 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Field mask is used to specify the fields to be overwritten in the Backup resource to be updated. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.
- backup_vault (::Google::Cloud::NetApp::V1::BackupVault, ::Hash) (defaults to: nil) —
  Required. The backupVault being updated

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 4685

def update_backup_vault request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateBackupVaultRequest

  # 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_backup_vault.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.backup_vault&.name
    header_params["backup_vault.name"] = request.backup_vault.name
  end

  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_backup_vault.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_backup_vault.retry_policy

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

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

#update_host_group(request, options = nil) ⇒ `::Gapic::Operation` #update_host_group(host_group: nil, update_mask: nil) ⇒ `::Gapic::Operation`

Updates an existing host group.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateHostGroupRequest.new

# Call the update_host_group method.
result = client.update_host_group request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_host_group(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_host_group via a request object, either of type UpdateHostGroupRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateHostGroupRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_host_group(host_group: nil, update_mask: nil) ⇒ ::Gapic::Operation

Pass arguments to update_host_group 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).
Parameters:
- host_group (::Google::Cloud::NetApp::V1::HostGroup, ::Hash) (defaults to: nil) —
  Required. The host group to update. The host group's name field is used to identify the host group. Format: projects/{project_number}/locations/{location_id}/hostGroups/{host_group_id}.
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Optional. The list of fields to update.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6736

def update_host_group request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateHostGroupRequest

  # 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_host_group.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.host_group&.name
    header_params["host_group.name"] = request.host_group.name
  end

  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_host_group.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_host_group.retry_policy

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

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

#update_kms_config(request, options = nil) ⇒ `::Gapic::Operation` #update_kms_config(update_mask: nil, kms_config: nil) ⇒ `::Gapic::Operation`

Updates the Kms config properties with the full spec

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateKmsConfigRequest.new

# Call the update_kms_config method.
result = client.update_kms_config request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_kms_config(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_kms_config via a request object, either of type UpdateKmsConfigRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateKmsConfigRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_kms_config(update_mask: nil, kms_config: nil) ⇒ ::Gapic::Operation

Pass arguments to update_kms_config 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Field mask is used to specify the fields to be overwritten in the KmsConfig resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.
- kms_config (::Google::Cloud::NetApp::V1::KmsConfig, ::Hash) (defaults to: nil) —
  Required. The KmsConfig being updated

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3043

def update_kms_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateKmsConfigRequest

  # 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_kms_config.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.kms_config&.name
    header_params["kms_config.name"] = request.kms_config.name
  end

  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_kms_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_kms_config.retry_policy

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

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

#update_quota_rule(request, options = nil) ⇒ `::Gapic::Operation` #update_quota_rule(update_mask: nil, quota_rule: nil) ⇒ `::Gapic::Operation`

Updates a quota rule.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateQuotaRuleRequest.new

# Call the update_quota_rule method.
result = client.update_quota_rule request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_quota_rule(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_quota_rule via a request object, either of type UpdateQuotaRuleRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateQuotaRuleRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_quota_rule(update_mask: nil, quota_rule: nil) ⇒ ::Gapic::Operation

Pass arguments to update_quota_rule 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Optional. Field mask is used to specify the fields to be overwritten in the Quota Rule resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.
- quota_rule (::Google::Cloud::NetApp::V1::QuotaRule, ::Hash) (defaults to: nil) —
  Required. The quota rule being updated

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 6150

def update_quota_rule request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateQuotaRuleRequest

  # 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_quota_rule.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.quota_rule&.name
    header_params["quota_rule.name"] = request.quota_rule.name
  end

  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_quota_rule.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_quota_rule.retry_policy

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

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

#update_replication(request, options = nil) ⇒ `::Gapic::Operation` #update_replication(update_mask: nil, replication: nil) ⇒ `::Gapic::Operation`

Updates the settings of a specific replication.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateReplicationRequest.new

# Call the update_replication method.
result = client.update_replication request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_replication(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_replication via a request object, either of type UpdateReplicationRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateReplicationRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_replication(update_mask: nil, replication: nil) ⇒ ::Gapic::Operation

Pass arguments to update_replication 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Mask of fields to update. At least one path must be supplied in this field.
- replication (::Google::Cloud::NetApp::V1::Replication, ::Hash) (defaults to: nil) —
  Required. A replication resource

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3799

def update_replication request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateReplicationRequest

  # 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_replication.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.replication&.name
    header_params["replication.name"] = request.replication.name
  end

  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_replication.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_replication.retry_policy

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

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

#update_snapshot(request, options = nil) ⇒ `::Gapic::Operation` #update_snapshot(update_mask: nil, snapshot: nil) ⇒ `::Gapic::Operation`

Updates the settings of a specific snapshot.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateSnapshotRequest.new

# Call the update_snapshot method.
result = client.update_snapshot request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_snapshot(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_snapshot via a request object, either of type UpdateSnapshotRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateSnapshotRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_snapshot(update_mask: nil, snapshot: nil) ⇒ ::Gapic::Operation

Pass arguments to update_snapshot 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Mask of fields to update. At least one path must be supplied in this field.
- snapshot (::Google::Cloud::NetApp::V1::Snapshot, ::Hash) (defaults to: nil) —
  Required. A snapshot resource

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 2176

def update_snapshot request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateSnapshotRequest

  # 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_snapshot.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.snapshot&.name
    header_params["snapshot.name"] = request.snapshot.name
  end

  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_snapshot.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_snapshot.retry_policy

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

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

#update_storage_pool(request, options = nil) ⇒ `::Gapic::Operation` #update_storage_pool(update_mask: nil, storage_pool: nil) ⇒ `::Gapic::Operation`

Updates the storage pool properties with the full spec

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateStoragePoolRequest.new

# Call the update_storage_pool method.
result = client.update_storage_pool request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_storage_pool(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_storage_pool via a request object, either of type UpdateStoragePoolRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateStoragePoolRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_storage_pool(update_mask: nil, storage_pool: nil) ⇒ ::Gapic::Operation

Pass arguments to update_storage_pool 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Field mask is used to specify the fields to be overwritten in the StoragePool resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.
- storage_pool (::Google::Cloud::NetApp::V1::StoragePool, ::Hash) (defaults to: nil) —
  Required. The pool being updated

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 716

def update_storage_pool request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateStoragePoolRequest

  # 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_storage_pool.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.storage_pool&.name
    header_params["storage_pool.name"] = request.storage_pool.name
  end

  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_storage_pool.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_storage_pool.retry_policy

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

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

#update_volume(request, options = nil) ⇒ `::Gapic::Operation` #update_volume(update_mask: nil, volume: nil) ⇒ `::Gapic::Operation`

Updates the parameters of a single Volume.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::UpdateVolumeRequest.new

# Call the update_volume method.
result = client.update_volume request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#update_volume(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to update_volume via a request object, either of type UpdateVolumeRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::UpdateVolumeRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#update_volume(update_mask: nil, volume: nil) ⇒ ::Gapic::Operation

Pass arguments to update_volume 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).
Parameters:
- update_mask (::Google::Protobuf::FieldMask, ::Hash) (defaults to: nil) —
  Required. Field mask is used to specify the fields to be overwritten in the Volume resource by the update. The fields specified in the update_mask are relative to the resource, not the full request. A field will be overwritten if it is in the mask. If the user does not provide a mask then all fields will be overwritten.
- volume (::Google::Cloud::NetApp::V1::Volume, ::Hash) (defaults to: nil) —
  Required. The volume being updated

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 1388

def update_volume request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::UpdateVolumeRequest

  # 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_volume.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.volume&.name
    header_params["volume.name"] = request.volume.name
  end

  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_volume.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.update_volume.retry_policy

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

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

#validate_directory_service(request, options = nil) ⇒ `::Gapic::Operation` #validate_directory_service(name: nil, directory_service_type: nil) ⇒ `::Gapic::Operation`

ValidateDirectoryService does a connectivity check for a directory service policy attached to the storage pool.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::ValidateDirectoryServiceRequest.new

# Call the validate_directory_service method.
result = client.validate_directory_service request

# The returned object is of type Gapic::Operation. You can use it to
# check the status of an operation, cancel it, or wait for results.
# Here is how to wait for a response.
result.wait_until_done! timeout: 60
if result.response?
  p result.response
else
  puts "No response received."
end

Overloads:

#validate_directory_service(request, options = nil) ⇒ ::Gapic::Operation

Pass arguments to validate_directory_service via a request object, either of type ValidateDirectoryServiceRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::ValidateDirectoryServiceRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#validate_directory_service(name: nil, directory_service_type: nil) ⇒ ::Gapic::Operation

Pass arguments to validate_directory_service 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the storage pool
- directory_service_type (::Google::Cloud::NetApp::V1::DirectoryServiceType) (defaults to: nil) —
  Type of directory service policy attached to the storage pool.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Gapic::Operation)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Gapic::Operation)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 907

def validate_directory_service request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::ValidateDirectoryServiceRequest

  # 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_directory_service.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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_directory_service.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.validate_directory_service.retry_policy

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

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

#verify_kms_config(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::VerifyKmsConfigResponse` #verify_kms_config(name: nil) ⇒ `::Google::Cloud::NetApp::V1::VerifyKmsConfigResponse`

Verifies KMS config reachability.

Examples:

Basic example

require "google/cloud/netapp/v1"

# Create a client object. The client can be reused for multiple calls.
client = Google::Cloud::NetApp::V1::NetApp::Client.new

# Create a request. To set request fields, pass in keyword arguments.
request = Google::Cloud::NetApp::V1::VerifyKmsConfigRequest.new

# Call the verify_kms_config method.
result = client.verify_kms_config request

# The returned object is of type Google::Cloud::NetApp::V1::VerifyKmsConfigResponse.
p result

Overloads:

#verify_kms_config(request, options = nil) ⇒ ::Google::Cloud::NetApp::V1::VerifyKmsConfigResponse

Pass arguments to verify_kms_config via a request object, either of type VerifyKmsConfigRequest or an equivalent Hash.
Parameters:
- request (::Google::Cloud::NetApp::V1::VerifyKmsConfigRequest, ::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.
- options (::Gapic::CallOptions, ::Hash) (defaults to: nil) —
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.
#verify_kms_config(name: nil) ⇒ ::Google::Cloud::NetApp::V1::VerifyKmsConfigResponse

Pass arguments to verify_kms_config 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).
Parameters:
- name (::String) (defaults to: nil) —
  Required. Name of the KMS Config to be verified.

Yields:

(response, operation) —
Access the result along with the RPC operation

Yield Parameters:

response (::Google::Cloud::NetApp::V1::VerifyKmsConfigResponse)
operation (::GRPC::ActiveCall::Operation)

Returns:

(::Google::Cloud::NetApp::V1::VerifyKmsConfigResponse)

Raises:

(::Google::Cloud::Error) —
if the RPC is aborted.

# File 'lib/google/cloud/netapp/v1/netapp/client.rb', line 3225

def verify_kms_config request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::NetApp::V1::VerifyKmsConfigRequest

  # 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.verify_kms_config.metadata.to_h

  # Set x-goog-api-client, x-goog-user-project and x-goog-api-version 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::NetApp::V1::VERSION
  metadata[:"x-goog-api-version"] = API_VERSION unless API_VERSION.empty?
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {}
  if request.name
    header_params["name"] = request.name
  end

  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.verify_kms_config.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.verify_kms_config.retry_policy

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

  @net_app_stub.call_rpc :verify_kms_config, request, options: options do |response, operation|
    yield response, operation if block_given?
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end

Class: Google::Cloud::NetApp::V1::NetApp::Client

Overview

Defined Under Namespace

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Paths

Constructor Details

#initialize {|config| ... } ⇒ Client

Examples:

Instance Attribute Details

#location_client ⇒ Google::Cloud::Location::Locations::Client (readonly)

#operations_client ⇒ ::Google::Cloud::NetApp::V1::NetApp::Operations (readonly)

Class Method Details

.configure {|config| ... } ⇒ Client::Configuration

Examples:

Instance Method Details

#configure {|config| ... } ⇒ Client::Configuration

#create_active_directory(request, options = nil) ⇒ ::Gapic::Operation #create_active_directory(parent: nil, active_directory: nil, active_directory_id: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_backup(request, options = nil) ⇒ ::Gapic::Operation #create_backup(parent: nil, backup_id: nil, backup: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_backup_policy(request, options = nil) ⇒ ::Gapic::Operation #create_backup_policy(parent: nil, backup_policy: nil, backup_policy_id: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_backup_vault(request, options = nil) ⇒ ::Gapic::Operation #create_backup_vault(parent: nil, backup_vault_id: nil, backup_vault: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_host_group(request, options = nil) ⇒ ::Gapic::Operation #create_host_group(parent: nil, host_group: nil, host_group_id: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_kms_config(request, options = nil) ⇒ ::Gapic::Operation #create_kms_config(parent: nil, kms_config_id: nil, kms_config: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_quota_rule(request, options = nil) ⇒ ::Gapic::Operation #create_quota_rule(parent: nil, quota_rule: nil, quota_rule_id: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_replication(request, options = nil) ⇒ ::Gapic::Operation #create_replication(parent: nil, replication: nil, replication_id: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_snapshot(request, options = nil) ⇒ ::Gapic::Operation #create_snapshot(parent: nil, snapshot: nil, snapshot_id: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_storage_pool(request, options = nil) ⇒ ::Gapic::Operation #create_storage_pool(parent: nil, storage_pool_id: nil, storage_pool: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#create_volume(request, options = nil) ⇒ ::Gapic::Operation #create_volume(parent: nil, volume_id: nil, volume: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_active_directory(request, options = nil) ⇒ ::Gapic::Operation #delete_active_directory(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_backup(request, options = nil) ⇒ ::Gapic::Operation #delete_backup(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_backup_policy(request, options = nil) ⇒ ::Gapic::Operation #delete_backup_policy(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_backup_vault(request, options = nil) ⇒ ::Gapic::Operation #delete_backup_vault(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_host_group(request, options = nil) ⇒ ::Gapic::Operation #delete_host_group(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_kms_config(request, options = nil) ⇒ ::Gapic::Operation #delete_kms_config(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_quota_rule(request, options = nil) ⇒ ::Gapic::Operation #delete_quota_rule(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_replication(request, options = nil) ⇒ ::Gapic::Operation #delete_replication(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_snapshot(request, options = nil) ⇒ ::Gapic::Operation #delete_snapshot(name: nil) ⇒ ::Gapic::Operation

Examples:

Basic example

#delete_storage_pool(request, options = nil) ⇒ ::Gapic::Operation #delete_storage_pool(name: nil) ⇒ ::Gapic::Operation

Examples:

#initialize {|config| ... } ⇒ `Client`

#location_client ⇒ `Google::Cloud::Location::Locations::Client` (readonly)

#operations_client ⇒ `::Google::Cloud::NetApp::V1::NetApp::Operations` (readonly)

.configure {|config| ... } ⇒ `Client::Configuration`

#configure {|config| ... } ⇒ `Client::Configuration`

#create_active_directory(request, options = nil) ⇒ `::Gapic::Operation` #create_active_directory(parent: nil, active_directory: nil, active_directory_id: nil) ⇒ `::Gapic::Operation`

#create_backup(request, options = nil) ⇒ `::Gapic::Operation` #create_backup(parent: nil, backup_id: nil, backup: nil) ⇒ `::Gapic::Operation`

#create_backup_policy(request, options = nil) ⇒ `::Gapic::Operation` #create_backup_policy(parent: nil, backup_policy: nil, backup_policy_id: nil) ⇒ `::Gapic::Operation`

#create_backup_vault(request, options = nil) ⇒ `::Gapic::Operation` #create_backup_vault(parent: nil, backup_vault_id: nil, backup_vault: nil) ⇒ `::Gapic::Operation`

#create_host_group(request, options = nil) ⇒ `::Gapic::Operation` #create_host_group(parent: nil, host_group: nil, host_group_id: nil) ⇒ `::Gapic::Operation`

#create_kms_config(request, options = nil) ⇒ `::Gapic::Operation` #create_kms_config(parent: nil, kms_config_id: nil, kms_config: nil) ⇒ `::Gapic::Operation`

#create_quota_rule(request, options = nil) ⇒ `::Gapic::Operation` #create_quota_rule(parent: nil, quota_rule: nil, quota_rule_id: nil) ⇒ `::Gapic::Operation`

#create_replication(request, options = nil) ⇒ `::Gapic::Operation` #create_replication(parent: nil, replication: nil, replication_id: nil) ⇒ `::Gapic::Operation`

#create_snapshot(request, options = nil) ⇒ `::Gapic::Operation` #create_snapshot(parent: nil, snapshot: nil, snapshot_id: nil) ⇒ `::Gapic::Operation`

#create_storage_pool(request, options = nil) ⇒ `::Gapic::Operation` #create_storage_pool(parent: nil, storage_pool_id: nil, storage_pool: nil) ⇒ `::Gapic::Operation`

#create_volume(request, options = nil) ⇒ `::Gapic::Operation` #create_volume(parent: nil, volume_id: nil, volume: nil) ⇒ `::Gapic::Operation`

#delete_active_directory(request, options = nil) ⇒ `::Gapic::Operation` #delete_active_directory(name: nil) ⇒ `::Gapic::Operation`

#delete_backup(request, options = nil) ⇒ `::Gapic::Operation` #delete_backup(name: nil) ⇒ `::Gapic::Operation`

#delete_backup_policy(request, options = nil) ⇒ `::Gapic::Operation` #delete_backup_policy(name: nil) ⇒ `::Gapic::Operation`

#delete_backup_vault(request, options = nil) ⇒ `::Gapic::Operation` #delete_backup_vault(name: nil) ⇒ `::Gapic::Operation`

#delete_host_group(request, options = nil) ⇒ `::Gapic::Operation` #delete_host_group(name: nil) ⇒ `::Gapic::Operation`

#delete_kms_config(request, options = nil) ⇒ `::Gapic::Operation` #delete_kms_config(name: nil) ⇒ `::Gapic::Operation`

#delete_quota_rule(request, options = nil) ⇒ `::Gapic::Operation` #delete_quota_rule(name: nil) ⇒ `::Gapic::Operation`

#delete_replication(request, options = nil) ⇒ `::Gapic::Operation` #delete_replication(name: nil) ⇒ `::Gapic::Operation`

#delete_snapshot(request, options = nil) ⇒ `::Gapic::Operation` #delete_snapshot(name: nil) ⇒ `::Gapic::Operation`

#delete_storage_pool(request, options = nil) ⇒ `::Gapic::Operation` #delete_storage_pool(name: nil) ⇒ `::Gapic::Operation`

#delete_volume(request, options = nil) ⇒ `::Gapic::Operation` #delete_volume(name: nil, force: nil) ⇒ `::Gapic::Operation`

#encrypt_volumes(request, options = nil) ⇒ `::Gapic::Operation` #encrypt_volumes(name: nil) ⇒ `::Gapic::Operation`

#establish_peering(request, options = nil) ⇒ `::Gapic::Operation` #establish_peering(name: nil, peer_cluster_name: nil, peer_svm_name: nil, peer_ip_addresses: nil, peer_volume_name: nil) ⇒ `::Gapic::Operation`

#establish_volume_peering(request, options = nil) ⇒ `::Gapic::Operation` #establish_volume_peering(name: nil, peer_cluster_name: nil, peer_svm_name: nil, peer_ip_addresses: nil, peer_volume_name: nil) ⇒ `::Gapic::Operation`

#execute_ontap_delete(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse` #execute_ontap_delete(ontap_path: nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapDeleteResponse`

#execute_ontap_get(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse` #execute_ontap_get(ontap_path: nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapGetResponse`

#execute_ontap_patch(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse` #execute_ontap_patch(body: nil, ontap_path: nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapPatchResponse`

#execute_ontap_post(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse` #execute_ontap_post(body: nil, ontap_path: nil) ⇒ `::Google::Cloud::NetApp::V1::ExecuteOntapPostResponse`

#get_active_directory(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::ActiveDirectory` #get_active_directory(name: nil) ⇒ `::Google::Cloud::NetApp::V1::ActiveDirectory`

#get_backup(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::Backup` #get_backup(name: nil) ⇒ `::Google::Cloud::NetApp::V1::Backup`

#get_backup_policy(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::BackupPolicy` #get_backup_policy(name: nil) ⇒ `::Google::Cloud::NetApp::V1::BackupPolicy`

#get_backup_vault(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::BackupVault` #get_backup_vault(name: nil) ⇒ `::Google::Cloud::NetApp::V1::BackupVault`

#get_host_group(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::HostGroup` #get_host_group(name: nil) ⇒ `::Google::Cloud::NetApp::V1::HostGroup`

#get_kms_config(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::KmsConfig` #get_kms_config(name: nil) ⇒ `::Google::Cloud::NetApp::V1::KmsConfig`

#get_quota_rule(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::QuotaRule` #get_quota_rule(name: nil) ⇒ `::Google::Cloud::NetApp::V1::QuotaRule`

#get_replication(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::Replication` #get_replication(name: nil) ⇒ `::Google::Cloud::NetApp::V1::Replication`

#get_snapshot(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::Snapshot` #get_snapshot(name: nil) ⇒ `::Google::Cloud::NetApp::V1::Snapshot`

#get_storage_pool(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::StoragePool` #get_storage_pool(name: nil) ⇒ `::Google::Cloud::NetApp::V1::StoragePool`

#get_volume(request, options = nil) ⇒ `::Google::Cloud::NetApp::V1::Volume` #get_volume(name: nil) ⇒ `::Google::Cloud::NetApp::V1::Volume`

#list_backup_policies(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>` #list_backup_policies(parent: nil, page_size: nil, page_token: nil, filter: nil, order_by: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupPolicy>`

#list_backup_vaults(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>` #list_backup_vaults(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::BackupVault>`

#list_backups(request, options = nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>` #list_backups(parent: nil, page_size: nil, page_token: nil, order_by: nil, filter: nil) ⇒ `::Gapic::PagedEnumerable<::Google::Cloud::NetApp::V1::Backup>`