Class: OCI::Dns::DnsClientCompositeOperations

Inherits:
Object
  • Object
show all
Defined in:
lib/oci/dns/dns_client_composite_operations.rb

Overview

This class provides a wrapper around DnsClient 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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(service_client = OCI::Dns::DnsClient.new) ⇒ DnsClientCompositeOperations

Initializes a new DnsClientCompositeOperations

Parameters:



22
23
24
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 22

def initialize(service_client = OCI::Dns::DnsClient.new)
  @service_client = service_client
end

Instance Attribute Details

#service_client ⇒ OCI::Dns::DnsClient (readonly)

The OCI::Dns::DnsClient used to communicate with the service_client

Returns:



16
17
18
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 16

def service_client
  @service_client
end

Instance Method Details

#change_resolver_compartment_and_wait_for_state(resolver_id, change_resolver_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#change_resolver_compartment and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • resolver_id (String) —

    The OCID of the target resolver.

  • change_resolver_compartment_details (OCI::Dns::Models::ChangeResolverCompartmentDetails) —

    Details for moving a resolver, along with its protected default view and endpoints, into a different compartment.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#change_resolver_compartment

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 44

def change_resolver_compartment_and_wait_for_state(resolver_id, change_resolver_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.change_resolver_compartment(resolver_id, change_resolver_compartment_details, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_steering_policy_compartment_and_wait_for_state(steering_policy_id, change_steering_policy_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#change_steering_policy_compartment and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • steering_policy_id (String) —

    The OCID of the target steering policy.

  • change_steering_policy_compartment_details (OCI::Dns::Models::ChangeSteeringPolicyCompartmentDetails) —

    Details for moving a steering policy into a different compartment.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#change_steering_policy_compartment

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 95

def change_steering_policy_compartment_and_wait_for_state(steering_policy_id, change_steering_policy_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.change_steering_policy_compartment(steering_policy_id, change_steering_policy_compartment_details, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_view_compartment_and_wait_for_state(view_id, change_view_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#change_view_compartment and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • view_id (String) —

    The OCID of the target view.

  • change_view_compartment_details (OCI::Dns::Models::ChangeViewCompartmentDetails) —

    Details for moving a view into a different compartment.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#change_view_compartment

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 146

def change_view_compartment_and_wait_for_state(view_id, change_view_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.change_view_compartment(view_id, change_view_compartment_details, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_zone_compartment_and_wait_for_state(zone_id, change_zone_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#change_zone_compartment and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • zone_id (String) —

    The OCID of the target zone.

  • change_zone_compartment_details (OCI::Dns::Models::ChangeZoneCompartmentDetails) —

    Details for moving a zone into a different compartment.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#change_zone_compartment

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 197

def change_zone_compartment_and_wait_for_state(zone_id, change_zone_compartment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.change_zone_compartment(zone_id, change_zone_compartment_details, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_resolver_endpoint_and_wait_for_state(resolver_id, create_resolver_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#create_resolver_endpoint and then waits for the Models::ResolverEndpoint acted upon to enter the given state(s).

Parameters:

  • resolver_id (String) —

    The OCID of the target resolver.

  • create_resolver_endpoint_details (OCI::Dns::Models::CreateResolverEndpointDetails) —

    Details for creating a new resolver endpoint.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::ResolverEndpoint#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#create_resolver_endpoint

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 248

def create_resolver_endpoint_and_wait_for_state(resolver_id, create_resolver_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_resolver_endpoint(resolver_id, create_resolver_endpoint_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_resolver_endpoint(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_steering_policy_and_wait_for_state(create_steering_policy_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#create_steering_policy and then waits for the Models::SteeringPolicy acted upon to enter the given state(s).

Parameters:

  • create_steering_policy_details (OCI::Dns::Models::CreateSteeringPolicyDetails) —

    Details for creating a new steering policy.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::SteeringPolicy#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#create_steering_policy

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 287

def create_steering_policy_and_wait_for_state(create_steering_policy_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_steering_policy(create_steering_policy_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_steering_policy(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_steering_policy_attachment_and_wait_for_state(create_steering_policy_attachment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#create_steering_policy_attachment and then waits for the Models::SteeringPolicyAttachment acted upon to enter the given state(s).

Parameters:

Returns:



326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 326

def create_steering_policy_attachment_and_wait_for_state(create_steering_policy_attachment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_steering_policy_attachment(create_steering_policy_attachment_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_steering_policy_attachment(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_tsig_key_and_wait_for_state(create_tsig_key_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#create_tsig_key and then waits for the Models::TsigKey acted upon to enter the given state(s).

Parameters:

  • create_tsig_key_details (OCI::Dns::Models::CreateTsigKeyDetails) —

    Details for creating a new TSIG key.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::TsigKey#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#create_tsig_key

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 365

def create_tsig_key_and_wait_for_state(create_tsig_key_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_tsig_key(create_tsig_key_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_tsig_key(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_view_and_wait_for_state(create_view_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#create_view and then waits for the Models::View acted upon to enter the given state(s).

Parameters:

  • create_view_details (OCI::Dns::Models::CreateViewDetails) —

    Details for creating a new view.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::View#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#create_view

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 404

def create_view_and_wait_for_state(create_view_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_view(create_view_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_view(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_zone_and_wait_for_state(create_zone_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#create_zone and then waits for the Models::Zone acted upon to enter the given state(s).

Parameters:

  • create_zone_details (OCI::Dns::Models::CreateZoneBaseDetails) —

    Details for creating a new zone.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::Zone#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#create_zone

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 443

def create_zone_and_wait_for_state(create_zone_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.create_zone(create_zone_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_zone(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_resolver_endpoint_and_wait_for_state(resolver_id, resolver_endpoint_name, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#delete_resolver_endpoint and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • resolver_id (String) —

    The OCID of the target resolver.

  • resolver_endpoint_name (String) —

    The name of the target resolver endpoint.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#delete_resolver_endpoint

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 483

def delete_resolver_endpoint_and_wait_for_state(resolver_id, resolver_endpoint_name, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_resolver_endpoint(resolver_id, resolver_endpoint_name, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_steering_policy_and_wait_for_state(steering_policy_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#delete_steering_policy and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • steering_policy_id (String) —

    The OCID of the target steering policy.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#delete_steering_policy

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 533

def delete_steering_policy_and_wait_for_state(steering_policy_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_steering_policy(steering_policy_id, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_steering_policy_attachment_and_wait_for_state(steering_policy_attachment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#delete_steering_policy_attachment and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • steering_policy_attachment_id (String) —

    The OCID of the target steering policy attachment.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#delete_steering_policy_attachment

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 583

def delete_steering_policy_attachment_and_wait_for_state(steering_policy_attachment_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_steering_policy_attachment(steering_policy_attachment_id, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_tsig_key_and_wait_for_state(tsig_key_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#delete_tsig_key and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • tsig_key_id (String) —

    The OCID of the target TSIG key.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#delete_tsig_key

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 633

def delete_tsig_key_and_wait_for_state(tsig_key_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_tsig_key(tsig_key_id, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_view_and_wait_for_state(view_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#delete_view and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • view_id (String) —

    The OCID of the target view.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#delete_view

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 683

def delete_view_and_wait_for_state(view_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_view(view_id, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_zone_and_wait_for_state(zone_name_or_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#delete_zone and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • zone_name_or_id (String) —

    The name or OCID of the target zone.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#delete_zone

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 733

def delete_zone_and_wait_for_state(zone_name_or_id, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.delete_zone(zone_name_or_id, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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

#promote_zone_dnssec_key_version_and_wait_for_state(zone_id, promote_zone_dnssec_key_version_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#promote_zone_dnssec_key_version and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • zone_id (String) —

    The OCID of the target zone.

  • promote_zone_dnssec_key_version_details (OCI::Dns::Models::PromoteZoneDnssecKeyVersionDetails) —

    Details for promoting a DnssecKeyVersion.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#promote_zone_dnssec_key_version

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 784

def promote_zone_dnssec_key_version_and_wait_for_state(zone_id, promote_zone_dnssec_key_version_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.promote_zone_dnssec_key_version(zone_id, promote_zone_dnssec_key_version_details, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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

#stage_zone_dnssec_key_version_and_wait_for_state(zone_id, stage_zone_dnssec_key_version_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#stage_zone_dnssec_key_version and then waits for the Models::WorkRequest to enter the given state(s).

Parameters:

  • zone_id (String) —

    The OCID of the target zone.

  • stage_zone_dnssec_key_version_details (OCI::Dns::Models::StageZoneDnssecKeyVersionDetails) —

    Details for staging a DnssecKeyVersion.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::WorkRequest#status

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#stage_zone_dnssec_key_version

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 835

def stage_zone_dnssec_key_version_and_wait_for_state(zone_id, stage_zone_dnssec_key_version_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.stage_zone_dnssec_key_version(zone_id, stage_zone_dnssec_key_version_details, base_operation_opts)
  use_util = OCI::Dns::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']
  return operation_result if wait_for_resource_id.nil? || wait_for_resource_id.empty?

  begin
    if use_util
      waiter_result = OCI::Dns::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_resolver_and_wait_for_state(resolver_id, update_resolver_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#update_resolver and then waits for the Models::Resolver acted upon to enter the given state(s).

Parameters:

  • resolver_id (String) —

    The OCID of the target resolver.

  • update_resolver_details (OCI::Dns::Models::UpdateResolverDetails) —

    New data for the resolver.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::Resolver#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#update_resolver

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 886

def update_resolver_and_wait_for_state(resolver_id, update_resolver_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_resolver(resolver_id, update_resolver_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_resolver(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_resolver_endpoint_and_wait_for_state(resolver_id, resolver_endpoint_name, update_resolver_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#update_resolver_endpoint and then waits for the Models::ResolverEndpoint acted upon to enter the given state(s).

Parameters:

  • resolver_id (String) —

    The OCID of the target resolver.

  • resolver_endpoint_name (String) —

    The name of the target resolver endpoint.

  • update_resolver_endpoint_details (OCI::Dns::Models::UpdateResolverEndpointDetails) —

    New data for the resolver endpoint.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::ResolverEndpoint#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#update_resolver_endpoint

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 927

def update_resolver_endpoint_and_wait_for_state(resolver_id, resolver_endpoint_name, update_resolver_endpoint_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_resolver_endpoint(resolver_id, resolver_endpoint_name, update_resolver_endpoint_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_resolver_endpoint(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_steering_policy_and_wait_for_state(steering_policy_id, update_steering_policy_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#update_steering_policy and then waits for the Models::SteeringPolicy acted upon to enter the given state(s).

Parameters:

  • steering_policy_id (String) —

    The OCID of the target steering policy.

  • update_steering_policy_details (OCI::Dns::Models::UpdateSteeringPolicyDetails) —

    New data for the steering policy.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::SteeringPolicy#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#update_steering_policy

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 967

def update_steering_policy_and_wait_for_state(steering_policy_id, update_steering_policy_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_steering_policy(steering_policy_id, update_steering_policy_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_steering_policy(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_steering_policy_attachment_and_wait_for_state(steering_policy_attachment_id, update_steering_policy_attachment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#update_steering_policy_attachment and then waits for the Models::SteeringPolicyAttachment acted upon to enter the given state(s).

Parameters:

  • steering_policy_attachment_id (String) —

    The OCID of the target steering policy attachment.

  • update_steering_policy_attachment_details (OCI::Dns::Models::UpdateSteeringPolicyAttachmentDetails) —

    New data for the steering policy attachment.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::SteeringPolicyAttachment#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#update_steering_policy_attachment

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 1007

def update_steering_policy_attachment_and_wait_for_state(steering_policy_attachment_id, update_steering_policy_attachment_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_steering_policy_attachment(steering_policy_attachment_id, update_steering_policy_attachment_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_steering_policy_attachment(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_tsig_key_and_wait_for_state(tsig_key_id, update_tsig_key_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#update_tsig_key and then waits for the Models::TsigKey acted upon to enter the given state(s).

Parameters:

  • tsig_key_id (String) —

    The OCID of the target TSIG key.

  • update_tsig_key_details (OCI::Dns::Models::UpdateTsigKeyDetails) —

    New data for the TSIG key.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::TsigKey#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#update_tsig_key

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 1047

def update_tsig_key_and_wait_for_state(tsig_key_id, update_tsig_key_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_tsig_key(tsig_key_id, update_tsig_key_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_tsig_key(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_view_and_wait_for_state(view_id, update_view_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#update_view and then waits for the Models::View acted upon to enter the given state(s).

Parameters:

  • view_id (String) —

    The OCID of the target view.

  • update_view_details (OCI::Dns::Models::UpdateViewDetails) —

    New data for the view.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::View#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#update_view

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 1087

def update_view_and_wait_for_state(view_id, update_view_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_view(view_id, update_view_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_view(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_zone_and_wait_for_state(zone_name_or_id, update_zone_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {}) ⇒ OCI::Response

Calls OCI::Dns::DnsClient#update_zone and then waits for the Models::Zone acted upon to enter the given state(s).

Parameters:

  • zone_name_or_id (String) —

    The name or OCID of the target zone.

  • update_zone_details (OCI::Dns::Models::UpdateZoneDetails) —

    New data for the zone.

  • wait_for_states (Array<String>) (defaults to: []) —

    An array of states to wait on. These should be valid values for Models::Zone#lifecycle_state

  • base_operation_opts (Hash) (defaults to: {}) —

    Any optional arguments accepted by OCI::Dns::DnsClient#update_zone

  • waiter_opts (Hash) (defaults to: {}) —

    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

Returns:



1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
 
# File 'lib/oci/dns/dns_client_composite_operations.rb', line 1127

def update_zone_and_wait_for_state(zone_name_or_id, update_zone_details, wait_for_states = [], base_operation_opts = {}, waiter_opts = {})
  operation_result = @service_client.update_zone(zone_name_or_id, update_zone_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_zone(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