class OCI::DataCatalog::DataCatalogClientCompositeOperations

This class provides a wrapper around {OCI::DataCatalog::DataCatalogClient} and offers convenience methods for operations that would otherwise need to be chained together. For example, instead of performing an action on a resource (e.g. launching an instance, creating a load balancer) and then using a waiter to wait for the resource to enter a given state, you can call a single method in this class to accomplish the same functionality

Attributes

service_client[R]

The {OCI::DataCatalog::DataCatalogClient} used to communicate with the service_client

@return [OCI::DataCatalog::DataCatalogClient]

Public Class Methods

new(service_client = OCI::DataCatalog::DataCatalogClient.new) click to toggle source

Initializes a new DataCatalogClientCompositeOperations

@param [OCI::DataCatalog::DataCatalogClient] service_client The client used to communicate with the service.

Defaults to a new service client created via {OCI::DataCatalog::DataCatalogClient#initialize} with no arguments
# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 20
def initialize(service_client = OCI::DataCatalog::DataCatalogClient.new)
  @service_client = service_client
end

Public Instance Methods

add_data_selector_patterns_and_wait_for_state(catalog_id, data_asset_key, data_selector_pattern_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#add_data_selector_patterns} and then waits for the {OCI::DataCatalog::Models::DataAsset} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [OCI::DataCatalog::Models::DataSelectorPatternDetails] data_selector_pattern_details The information used to add the patterns for deriving logical entities. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::DataAsset#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#add_data_selector_patterns} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::DataAsset}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 41
def add_data_selector_patterns_and_wait_for_state(catalog_id, data_asset_key, data_selector_pattern_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.add_data_selector_patterns(catalog_id, data_asset_key, data_selector_pattern_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_data_asset(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
associate_custom_property_and_wait_for_state(catalog_id, type_key, associate_custom_property_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#associate_custom_property} and then waits for the {OCI::DataCatalog::Models::Type} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] type_key Unique type key. @param [OCI::DataCatalog::Models::TypeCustomPropertyDetails] associate_custom_property_details The information used to associate the custom property for the type.

@param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Type#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#associate_custom_property} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Type}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 83
def associate_custom_property_and_wait_for_state(catalog_id, type_key, associate_custom_property_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.associate_custom_property(catalog_id, type_key, associate_custom_property_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_type(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
attach_catalog_private_endpoint_and_wait_for_state(attach_catalog_private_endpoint_details, catalog_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#attach_catalog_private_endpoint} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [OCI::DataCatalog::Models::AttachCatalogPrivateEndpointDetails] attach_catalog_private_endpoint_details Details for private reverse connection endpoint to be used for attachment. @param [String] catalog_id Unique catalog identifier. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#attach_catalog_private_endpoint} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 123
def attach_catalog_private_endpoint_and_wait_for_state(attach_catalog_private_endpoint_details, catalog_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.attach_catalog_private_endpoint(attach_catalog_private_endpoint_details, catalog_id, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
change_catalog_compartment_and_wait_for_state(change_catalog_compartment_details, catalog_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#change_catalog_compartment} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [OCI::DataCatalog::Models::ChangeCatalogCompartmentDetails] change_catalog_compartment_details Details for the target compartment. @param [String] catalog_id Unique catalog identifier. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#change_catalog_compartment} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 173
def change_catalog_compartment_and_wait_for_state(change_catalog_compartment_details, catalog_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.change_catalog_compartment(change_catalog_compartment_details, catalog_id, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
change_catalog_private_endpoint_compartment_and_wait_for_state(change_catalog_private_endpoint_compartment_details, catalog_private_endpoint_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#change_catalog_private_endpoint_compartment} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [OCI::DataCatalog::Models::ChangeCatalogPrivateEndpointCompartmentDetails] change_catalog_private_endpoint_compartment_details Details for the target compartment. @param [String] catalog_private_endpoint_id Unique private reverse connection identifier. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#change_catalog_private_endpoint_compartment} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 223
def change_catalog_private_endpoint_compartment_and_wait_for_state(change_catalog_private_endpoint_compartment_details, catalog_private_endpoint_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.change_catalog_private_endpoint_compartment(change_catalog_private_endpoint_compartment_details, catalog_private_endpoint_id, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
change_metastore_compartment_and_wait_for_state(change_metastore_compartment_details, metastore_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#change_metastore_compartment} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [OCI::DataCatalog::Models::ChangeMetastoreCompartmentDetails] change_metastore_compartment_details Information about a change in metastore compartment. @param [String] metastore_id The metastore's OCID. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#change_metastore_compartment} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 273
def change_metastore_compartment_and_wait_for_state(change_metastore_compartment_details, metastore_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.change_metastore_compartment(change_metastore_compartment_details, metastore_id, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_attribute_and_wait_for_state(catalog_id, data_asset_key, entity_key, create_attribute_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_attribute} and then waits for the {OCI::DataCatalog::Models::Attribute} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] entity_key Unique entity key. @param [OCI::DataCatalog::Models::CreateAttributeDetails] create_attribute_details The information used to create an entity attribute. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Attribute#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_attribute} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Attribute}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 325
def create_attribute_and_wait_for_state(catalog_id, data_asset_key, entity_key, create_attribute_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_attribute(catalog_id, data_asset_key, entity_key, create_attribute_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_attribute(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_attribute_tag_and_wait_for_state(catalog_id, data_asset_key, entity_key, attribute_key, create_attribute_tag_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_attribute_tag} and then waits for the {OCI::DataCatalog::Models::AttributeTag} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] entity_key Unique entity key. @param [String] attribute_key Unique attribute key. @param [OCI::DataCatalog::Models::CreateTagDetails] create_attribute_tag_details The information used to create an entity attribute tag. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::AttributeTag#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_attribute_tag} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::AttributeTag}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 368
def create_attribute_tag_and_wait_for_state(catalog_id, data_asset_key, entity_key, attribute_key, create_attribute_tag_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_attribute_tag(catalog_id, data_asset_key, entity_key, attribute_key, create_attribute_tag_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_attribute_tag(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_catalog_and_wait_for_state(create_catalog_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_catalog} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [OCI::DataCatalog::Models::CreateCatalogDetails] create_catalog_details Details for the new data catalog. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_catalog} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 407
def create_catalog_and_wait_for_state(create_catalog_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_catalog(create_catalog_details, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_catalog_private_endpoint_and_wait_for_state(create_catalog_private_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_catalog_private_endpoint} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [OCI::DataCatalog::Models::CreateCatalogPrivateEndpointDetails] create_catalog_private_endpoint_details The information used to create the private reverse connection. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_catalog_private_endpoint} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 456
def create_catalog_private_endpoint_and_wait_for_state(create_catalog_private_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_catalog_private_endpoint(create_catalog_private_endpoint_details, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_connection_and_wait_for_state(catalog_id, data_asset_key, create_connection_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_connection} and then waits for the {OCI::DataCatalog::Models::Connection} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [OCI::DataCatalog::Models::CreateConnectionDetails] create_connection_details The information used to create the connection. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Connection#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_connection} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Connection}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 507
def create_connection_and_wait_for_state(catalog_id, data_asset_key, create_connection_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_connection(catalog_id, data_asset_key, create_connection_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_connection(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_custom_property_and_wait_for_state(catalog_id, namespace_id, create_custom_property_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_custom_property} and then waits for the {OCI::DataCatalog::Models::CustomProperty} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] namespace_id Unique namespace identifier. @param [OCI::DataCatalog::Models::CreateCustomPropertyDetails] create_custom_property_details The information used to create the Custom Property.

@param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::CustomProperty#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_custom_property} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::CustomProperty}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 549
def create_custom_property_and_wait_for_state(catalog_id, namespace_id, create_custom_property_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_custom_property(catalog_id, namespace_id, create_custom_property_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_custom_property(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_data_asset_and_wait_for_state(catalog_id, create_data_asset_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_data_asset} and then waits for the {OCI::DataCatalog::Models::DataAsset} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [OCI::DataCatalog::Models::CreateDataAssetDetails] create_data_asset_details The information used to create the data asset. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::DataAsset#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_data_asset} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::DataAsset}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 589
def create_data_asset_and_wait_for_state(catalog_id, create_data_asset_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_data_asset(catalog_id, create_data_asset_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_data_asset(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_data_asset_tag_and_wait_for_state(catalog_id, data_asset_key, create_data_asset_tag_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_data_asset_tag} and then waits for the {OCI::DataCatalog::Models::DataAssetTag} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [OCI::DataCatalog::Models::CreateTagDetails] create_data_asset_tag_details The information used to create the data asset tag. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::DataAssetTag#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_data_asset_tag} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::DataAssetTag}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 630
def create_data_asset_tag_and_wait_for_state(catalog_id, data_asset_key, create_data_asset_tag_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_data_asset_tag(catalog_id, data_asset_key, create_data_asset_tag_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_data_asset_tag(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_entity_and_wait_for_state(catalog_id, data_asset_key, create_entity_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_entity} and then waits for the {OCI::DataCatalog::Models::Entity} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [OCI::DataCatalog::Models::CreateEntityDetails] create_entity_details The information used to create the data entity. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Entity#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_entity} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Entity}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 671
def create_entity_and_wait_for_state(catalog_id, data_asset_key, create_entity_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_entity(catalog_id, data_asset_key, create_entity_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_entity(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_entity_tag_and_wait_for_state(catalog_id, data_asset_key, entity_key, create_entity_tag_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_entity_tag} and then waits for the {OCI::DataCatalog::Models::EntityTag} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] entity_key Unique entity key. @param [OCI::DataCatalog::Models::CreateTagDetails] create_entity_tag_details The information used to create the entity tag. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::EntityTag#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_entity_tag} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::EntityTag}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 713
def create_entity_tag_and_wait_for_state(catalog_id, data_asset_key, entity_key, create_entity_tag_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_entity_tag(catalog_id, data_asset_key, entity_key, create_entity_tag_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_entity_tag(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_folder_and_wait_for_state(catalog_id, data_asset_key, create_folder_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_folder} and then waits for the {OCI::DataCatalog::Models::Folder} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [OCI::DataCatalog::Models::CreateFolderDetails] create_folder_details The information used to create the folder. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Folder#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_folder} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Folder}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 754
def create_folder_and_wait_for_state(catalog_id, data_asset_key, create_folder_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_folder(catalog_id, data_asset_key, create_folder_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_folder(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_folder_tag_and_wait_for_state(catalog_id, data_asset_key, folder_key, create_folder_tag_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_folder_tag} and then waits for the {OCI::DataCatalog::Models::FolderTag} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] folder_key Unique folder key. @param [OCI::DataCatalog::Models::CreateTagDetails] create_folder_tag_details The information used to create the folder tag. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::FolderTag#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_folder_tag} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::FolderTag}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 796
def create_folder_tag_and_wait_for_state(catalog_id, data_asset_key, folder_key, create_folder_tag_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_folder_tag(catalog_id, data_asset_key, folder_key, create_folder_tag_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_folder_tag(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_glossary_and_wait_for_state(catalog_id, create_glossary_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_glossary} and then waits for the {OCI::DataCatalog::Models::Glossary} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [OCI::DataCatalog::Models::CreateGlossaryDetails] create_glossary_details The information used to create the glossary. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Glossary#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_glossary} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Glossary}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 836
def create_glossary_and_wait_for_state(catalog_id, create_glossary_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_glossary(catalog_id, create_glossary_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_glossary(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_job_and_wait_for_state(catalog_id, create_job_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_job} and then waits for the {OCI::DataCatalog::Models::Job} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [OCI::DataCatalog::Models::CreateJobDetails] create_job_details The information used to create the job. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Job#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_job} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Job}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 876
def create_job_and_wait_for_state(catalog_id, create_job_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_job(catalog_id, create_job_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_job(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_job_definition_and_wait_for_state(catalog_id, create_job_definition_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_job_definition} and then waits for the {OCI::DataCatalog::Models::JobDefinition} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [OCI::DataCatalog::Models::CreateJobDefinitionDetails] create_job_definition_details The information used to create the job definition. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::JobDefinition#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_job_definition} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::JobDefinition}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 916
def create_job_definition_and_wait_for_state(catalog_id, create_job_definition_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_job_definition(catalog_id, create_job_definition_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_job_definition(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_job_execution_and_wait_for_state(catalog_id, job_key, create_job_execution_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_job_execution} and then waits for the {OCI::DataCatalog::Models::JobExecution} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] job_key Unique job key. @param [OCI::DataCatalog::Models::CreateJobExecutionDetails] create_job_execution_details The information used to create the job execution. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::JobExecution#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_job_execution} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::JobExecution}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 957
def create_job_execution_and_wait_for_state(catalog_id, job_key, create_job_execution_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_job_execution(catalog_id, job_key, create_job_execution_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_job_execution(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_metastore_and_wait_for_state(create_metastore_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_metastore} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [OCI::DataCatalog::Models::CreateMetastoreDetails] create_metastore_details Information about a new metastore to be created. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_metastore} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 996
def create_metastore_and_wait_for_state(create_metastore_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_metastore(create_metastore_details, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_namespace_and_wait_for_state(catalog_id, create_namespace_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_namespace} and then waits for the {OCI::DataCatalog::Models::Namespace} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [OCI::DataCatalog::Models::CreateNamespaceDetails] create_namespace_details The information used to create the Namespace.

@param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Namespace#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_namespace} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Namespace}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1047
def create_namespace_and_wait_for_state(catalog_id, create_namespace_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_namespace(catalog_id, create_namespace_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_namespace(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_pattern_and_wait_for_state(catalog_id, create_pattern_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_pattern} and then waits for the {OCI::DataCatalog::Models::Pattern} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [OCI::DataCatalog::Models::CreatePatternDetails] create_pattern_details The information used to create the pattern. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Pattern#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_pattern} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Pattern}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1087
def create_pattern_and_wait_for_state(catalog_id, create_pattern_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_pattern(catalog_id, create_pattern_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_pattern(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_term_and_wait_for_state(catalog_id, glossary_key, create_term_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_term} and then waits for the {OCI::DataCatalog::Models::Term} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] glossary_key Unique glossary key. @param [OCI::DataCatalog::Models::CreateTermDetails] create_term_details The information used to create the term. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Term#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_term} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Term}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1128
def create_term_and_wait_for_state(catalog_id, glossary_key, create_term_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_term(catalog_id, glossary_key, create_term_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_term(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
create_term_relationship_and_wait_for_state(catalog_id, glossary_key, term_key, create_term_relationship_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#create_term_relationship} and then waits for the {OCI::DataCatalog::Models::TermRelationship} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] glossary_key Unique glossary key. @param [String] term_key Unique glossary term key. @param [OCI::DataCatalog::Models::CreateTermRelationshipDetails] create_term_relationship_details The information used to create the term relationship. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::TermRelationship#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#create_term_relationship} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::TermRelationship}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1170
def create_term_relationship_and_wait_for_state(catalog_id, glossary_key, term_key, create_term_relationship_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_term_relationship(catalog_id, glossary_key, term_key, create_term_relationship_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_term_relationship(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
delete_catalog_and_wait_for_state(catalog_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#delete_catalog} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#delete_catalog} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1209
def delete_catalog_and_wait_for_state(catalog_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_catalog(catalog_id, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
delete_catalog_private_endpoint_and_wait_for_state(catalog_private_endpoint_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#delete_catalog_private_endpoint} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [String] catalog_private_endpoint_id Unique private reverse connection identifier. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#delete_catalog_private_endpoint} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1258
def delete_catalog_private_endpoint_and_wait_for_state(catalog_private_endpoint_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_catalog_private_endpoint(catalog_private_endpoint_id, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
delete_metastore_and_wait_for_state(metastore_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#delete_metastore} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [String] metastore_id The metastore's OCID. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#delete_metastore} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1307
def delete_metastore_and_wait_for_state(metastore_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_metastore(metastore_id, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
detach_catalog_private_endpoint_and_wait_for_state(detach_catalog_private_endpoint_details, catalog_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#detach_catalog_private_endpoint} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [OCI::DataCatalog::Models::DetachCatalogPrivateEndpointDetails] detach_catalog_private_endpoint_details Details for private reverse connection endpoint to be used for attachment @param [String] catalog_id Unique catalog identifier. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#detach_catalog_private_endpoint} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1357
def detach_catalog_private_endpoint_and_wait_for_state(detach_catalog_private_endpoint_details, catalog_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.detach_catalog_private_endpoint(detach_catalog_private_endpoint_details, catalog_id, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
disassociate_custom_property_and_wait_for_state(catalog_id, type_key, disassociate_custom_property_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#disassociate_custom_property} and then waits for the {OCI::DataCatalog::Models::Type} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] type_key Unique type key. @param [OCI::DataCatalog::Models::TypeCustomPropertyDetails] disassociate_custom_property_details The information used to remove the custom properties.

@param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Type#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#disassociate_custom_property} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Type}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1409
def disassociate_custom_property_and_wait_for_state(catalog_id, type_key, disassociate_custom_property_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.disassociate_custom_property(catalog_id, type_key, disassociate_custom_property_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_type(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
remove_data_selector_patterns_and_wait_for_state(catalog_id, data_asset_key, data_selector_pattern_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#remove_data_selector_patterns} and then waits for the {OCI::DataCatalog::Models::DataAsset} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [OCI::DataCatalog::Models::DataSelectorPatternDetails] data_selector_pattern_details The information used to remove the data selector patterns. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::DataAsset#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#remove_data_selector_patterns} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::DataAsset}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1450
def remove_data_selector_patterns_and_wait_for_state(catalog_id, data_asset_key, data_selector_pattern_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.remove_data_selector_patterns(catalog_id, data_asset_key, data_selector_pattern_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_data_asset(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_attribute_and_wait_for_state(catalog_id, data_asset_key, entity_key, attribute_key, update_attribute_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_attribute} and then waits for the {OCI::DataCatalog::Models::Attribute} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] entity_key Unique entity key. @param [String] attribute_key Unique attribute key. @param [OCI::DataCatalog::Models::UpdateAttributeDetails] update_attribute_details The information to be updated in the attribute. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Attribute#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_attribute} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Attribute}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1493
def update_attribute_and_wait_for_state(catalog_id, data_asset_key, entity_key, attribute_key, update_attribute_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_attribute(catalog_id, data_asset_key, entity_key, attribute_key, update_attribute_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_attribute(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_catalog_and_wait_for_state(catalog_id, update_catalog_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_catalog} and then waits for the {OCI::DataCatalog::Models::Catalog} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [OCI::DataCatalog::Models::UpdateCatalogDetails] update_catalog_details The data catalog information to be updated. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Catalog#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_catalog} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Catalog}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1533
def update_catalog_and_wait_for_state(catalog_id, update_catalog_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_catalog(catalog_id, update_catalog_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_catalog(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_catalog_private_endpoint_and_wait_for_state(catalog_private_endpoint_id, update_catalog_private_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_catalog_private_endpoint} and then waits for the {OCI::DataCatalog::Models::WorkRequest} to enter the given state(s).

@param [String] catalog_private_endpoint_id Unique private reverse connection identifier. @param [OCI::DataCatalog::Models::UpdateCatalogPrivateEndpointDetails] update_catalog_private_endpoint_details The information to be updated in private reverse connection @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::WorkRequest#status} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_catalog_private_endpoint} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object containing the completed {OCI::DataCatalog::Models::WorkRequest}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1573
def update_catalog_private_endpoint_and_wait_for_state(catalog_private_endpoint_id, update_catalog_private_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_catalog_private_endpoint(catalog_private_endpoint_id, update_catalog_private_endpoint_details, base_operation_opts)
  use_util = OCI::DataCatalog::Util.respond_to?(:wait_on_work_request)

  return operation_result if wait_for_states.empty? && !use_util

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.headers['opc-work-request-id']

  begin
    if use_util
      waiter_result = OCI::DataCatalog::Util.wait_on_work_request(
        @service_client,
        wait_for_resource_id,
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    else
      waiter_result = @service_client.get_work_request(wait_for_resource_id).wait_until(
        eval_proc: ->(response) { response.data.respond_to?(:status) && lowered_wait_for_states.include?(response.data.status.downcase) },
        max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
        max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
      )
    end
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_connection_and_wait_for_state(catalog_id, data_asset_key, connection_key, update_connection_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_connection} and then waits for the {OCI::DataCatalog::Models::Connection} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] connection_key Unique connection key. @param [OCI::DataCatalog::Models::UpdateConnectionDetails] update_connection_details The information to be updated in the connection. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Connection#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_connection} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Connection}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1625
def update_connection_and_wait_for_state(catalog_id, data_asset_key, connection_key, update_connection_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_connection(catalog_id, data_asset_key, connection_key, update_connection_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_connection(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_custom_property_and_wait_for_state(catalog_id, namespace_id, custom_property_key, update_custom_property_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_custom_property} and then waits for the {OCI::DataCatalog::Models::CustomProperty} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] namespace_id Unique namespace identifier. @param [String] custom_property_key Unique Custom Property key @param [OCI::DataCatalog::Models::UpdateCustomPropertyDetails] update_custom_property_details The information to be updated in the custom property. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::CustomProperty#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_custom_property} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::CustomProperty}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1667
def update_custom_property_and_wait_for_state(catalog_id, namespace_id, custom_property_key, update_custom_property_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_custom_property(catalog_id, namespace_id, custom_property_key, update_custom_property_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_custom_property(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_data_asset_and_wait_for_state(catalog_id, data_asset_key, update_data_asset_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_data_asset} and then waits for the {OCI::DataCatalog::Models::DataAsset} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [OCI::DataCatalog::Models::UpdateDataAssetDetails] update_data_asset_details The information to be updated in the data asset. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::DataAsset#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_data_asset} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::DataAsset}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1708
def update_data_asset_and_wait_for_state(catalog_id, data_asset_key, update_data_asset_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_data_asset(catalog_id, data_asset_key, update_data_asset_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_data_asset(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_entity_and_wait_for_state(catalog_id, data_asset_key, entity_key, update_entity_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_entity} and then waits for the {OCI::DataCatalog::Models::Entity} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] entity_key Unique entity key. @param [OCI::DataCatalog::Models::UpdateEntityDetails] update_entity_details The information to be updated in the data entity. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Entity#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_entity} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Entity}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1750
def update_entity_and_wait_for_state(catalog_id, data_asset_key, entity_key, update_entity_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_entity(catalog_id, data_asset_key, entity_key, update_entity_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_entity(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_folder_and_wait_for_state(catalog_id, data_asset_key, folder_key, update_folder_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_folder} and then waits for the {OCI::DataCatalog::Models::Folder} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] folder_key Unique folder key. @param [OCI::DataCatalog::Models::UpdateFolderDetails] update_folder_details The information to be updated in the folder. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Folder#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_folder} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Folder}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1792
def update_folder_and_wait_for_state(catalog_id, data_asset_key, folder_key, update_folder_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_folder(catalog_id, data_asset_key, folder_key, update_folder_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_folder(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_glossary_and_wait_for_state(catalog_id, glossary_key, update_glossary_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_glossary} and then waits for the {OCI::DataCatalog::Models::Glossary} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] glossary_key Unique glossary key. @param [OCI::DataCatalog::Models::UpdateGlossaryDetails] update_glossary_details The information to be updated in the glossary. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Glossary#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_glossary} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Glossary}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1833
def update_glossary_and_wait_for_state(catalog_id, glossary_key, update_glossary_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_glossary(catalog_id, glossary_key, update_glossary_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_glossary(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_job_and_wait_for_state(catalog_id, job_key, update_job_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_job} and then waits for the {OCI::DataCatalog::Models::Job} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] job_key Unique job key. @param [OCI::DataCatalog::Models::UpdateJobDetails] update_job_details The information to be updated in the job. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Job#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_job} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Job}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1874
def update_job_and_wait_for_state(catalog_id, job_key, update_job_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_job(catalog_id, job_key, update_job_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_job(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_job_definition_and_wait_for_state(catalog_id, job_definition_key, update_job_definition_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_job_definition} and then waits for the {OCI::DataCatalog::Models::JobDefinition} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] job_definition_key Unique job definition key. @param [OCI::DataCatalog::Models::UpdateJobDefinitionDetails] update_job_definition_details The information to be updated in the job definition. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::JobDefinition#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_job_definition} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::JobDefinition}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1915
def update_job_definition_and_wait_for_state(catalog_id, job_definition_key, update_job_definition_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_job_definition(catalog_id, job_definition_key, update_job_definition_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_job_definition(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_metastore_and_wait_for_state(metastore_id, update_metastore_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_metastore} and then waits for the {OCI::DataCatalog::Models::Metastore} acted upon to enter the given state(s).

@param [String] metastore_id The metastore's OCID. @param [OCI::DataCatalog::Models::UpdateMetastoreDetails] update_metastore_details The metastore information to be updated. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Metastore#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_metastore} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Metastore}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1955
def update_metastore_and_wait_for_state(metastore_id, update_metastore_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_metastore(metastore_id, update_metastore_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_metastore(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_namespace_and_wait_for_state(catalog_id, namespace_id, update_namespace_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_namespace} and then waits for the {OCI::DataCatalog::Models::Namespace} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] namespace_id Unique namespace identifier. @param [OCI::DataCatalog::Models::UpdateNamespaceDetails] update_namespace_details The information to be updated in the namespace. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Namespace#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_namespace} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Namespace}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 1996
def update_namespace_and_wait_for_state(catalog_id, namespace_id, update_namespace_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_namespace(catalog_id, namespace_id, update_namespace_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_namespace(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_pattern_and_wait_for_state(catalog_id, pattern_key, update_pattern_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_pattern} and then waits for the {OCI::DataCatalog::Models::Pattern} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] pattern_key Unique pattern key. @param [OCI::DataCatalog::Models::UpdatePatternDetails] update_pattern_details The information to be updated in the pattern. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Pattern#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_pattern} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Pattern}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 2037
def update_pattern_and_wait_for_state(catalog_id, pattern_key, update_pattern_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_pattern(catalog_id, pattern_key, update_pattern_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_pattern(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_term_and_wait_for_state(catalog_id, glossary_key, term_key, update_term_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_term} and then waits for the {OCI::DataCatalog::Models::Term} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] glossary_key Unique glossary key. @param [String] term_key Unique glossary term key. @param [OCI::DataCatalog::Models::UpdateTermDetails] update_term_details The information to be updated in the term. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Term#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_term} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Term}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 2079
def update_term_and_wait_for_state(catalog_id, glossary_key, term_key, update_term_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_term(catalog_id, glossary_key, term_key, update_term_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_term(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
update_term_relationship_and_wait_for_state(catalog_id, glossary_key, term_key, term_relationship_key, update_term_relationship_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#update_term_relationship} and then waits for the {OCI::DataCatalog::Models::TermRelationship} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] glossary_key Unique glossary key. @param [String] term_key Unique glossary term key. @param [String] term_relationship_key Unique glossary term relationship key. @param [OCI::DataCatalog::Models::UpdateTermRelationshipDetails] update_term_relationship_details The information to be updated in the term relationship. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::TermRelationship#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#update_term_relationship} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::TermRelationship}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 2122
def update_term_relationship_and_wait_for_state(catalog_id, glossary_key, term_key, term_relationship_key, update_term_relationship_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_term_relationship(catalog_id, glossary_key, term_key, term_relationship_key, update_term_relationship_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_term_relationship(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end
upload_credentials_and_wait_for_state(catalog_id, data_asset_key, connection_key, upload_credentials_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) click to toggle source

Calls {OCI::DataCatalog::DataCatalogClient#upload_credentials} and then waits for the {OCI::DataCatalog::Models::Connection} acted upon to enter the given state(s).

@param [String] catalog_id Unique catalog identifier. @param [String] data_asset_key Unique data asset key. @param [String] connection_key Unique connection key. @param [OCI::DataCatalog::Models::UploadCredentialsDetails] upload_credentials_details The information used to upload the credentials file and metadata for updating this connection. @param [Array<String>] wait_for_states An array of states to wait on. These should be valid values for {OCI::DataCatalog::Models::Connection#lifecycle_state} @param [Hash] base_operation_opts Any optional arguments accepted by {OCI::DataCatalog::DataCatalogClient#upload_credentials} @param [Hash] waiter_opts Optional arguments for the waiter. Keys should be symbols, and the following keys are supported:

* max_interval_seconds: The maximum interval between queries, in seconds.
* max_wait_seconds The maximum time to wait, in seconds

@return [OCI::Response] A {OCI::Response} object with data of type {OCI::DataCatalog::Models::Connection}

# File lib/oci/data_catalog/data_catalog_client_composite_operations.rb, line 2164
def upload_credentials_and_wait_for_state(catalog_id, data_asset_key, connection_key, upload_credentials_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.upload_credentials(catalog_id, data_asset_key, connection_key, upload_credentials_details, base_operation_opts)

  return operation_result if wait_for_states.empty?

  lowered_wait_for_states = wait_for_states.map(&:downcase)
  wait_for_resource_id = operation_result.data.id

  begin
    waiter_result = @service_client.get_connection(wait_for_resource_id).wait_until(
      eval_proc: ->(response) { response.data.respond_to?(:lifecycle_state) && lowered_wait_for_states.include?(response.data.lifecycle_state.downcase) },
      max_interval_seconds: waiter_opts.key?(:max_interval_seconds) ? waiter_opts[:max_interval_seconds] : 30,
      max_wait_seconds: waiter_opts.key?(:max_wait_seconds) ? waiter_opts[:max_wait_seconds] : 1200
    )
    result_to_return = waiter_result

    return result_to_return
  rescue StandardError
    raise OCI::Errors::CompositeOperationError.new(partial_results: [operation_result])
  end
end