VirtualNetworkClientCompositeOperations

class oci.core.VirtualNetworkClientCompositeOperations(client, work_request_client=None, **kwargs)

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

__init__(client, work_request_client=None, **kwargs)

Creates a new VirtualNetworkClientCompositeOperations object

Parameters:
attach_service_id_and_wait_for_state(service_gateway_id, attach_service_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls attach_service_id() and waits for the ServiceGateway acted upon to enter the given state(s).

Parameters:
  • service_gateway_id (str) --

    (required) The service gateway's OCID.

  • attach_service_details (ServiceIdRequestDetails) -- (required) ServiceId of Service to be attached to a service gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to attach_service_id()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
change_drg_compartment_and_wait_for_state(drg_id, change_drg_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls change_drg_compartment() and waits for the WorkRequest to enter the given state(s).

Parameters:
  • drg_id (str) -- (required) The OCID of the DRG.
  • change_drg_compartment_details (ChangeDrgCompartmentDetails) -- (required) Request to change the compartment of a DRG.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for status
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to change_drg_compartment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
change_drg_compartment_and_wait_for_work_request(drg_id, change_drg_compartment_details, work_request_states=[], operation_kwargs={}, waiter_kwargs={})

Calls change_drg_compartment() and waits for the oci.work_requests.models.WorkRequest to enter the given state(s).

Parameters:
  • drg_id (str) -- (required) The OCID of the DRG.
  • change_drg_compartment_details (ChangeDrgCompartmentDetails) -- (required) Request to change the compartment of a DRG.
  • work_request_states (list[str]) -- (optional) An array of work requests states to wait on. These should be valid values for status Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED]
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to change_drg_compartment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
change_subnet_compartment_and_wait_for_state(subnet_id, change_subnet_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls change_subnet_compartment() and waits for the WorkRequest to enter the given state(s).

Parameters:
  • subnet_id (str) -- (required) The OCID of the subnet.
  • change_subnet_compartment_details (ChangeSubnetCompartmentDetails) -- (required) Request to change the compartment of a given subnet.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for status
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to change_subnet_compartment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
change_subnet_compartment_and_wait_for_work_request(subnet_id, change_subnet_compartment_details, work_request_states=[], operation_kwargs={}, waiter_kwargs={})

Calls change_subnet_compartment() and waits for the oci.work_requests.models.WorkRequest to enter the given state(s).

Parameters:
  • subnet_id (str) -- (required) The OCID of the subnet.
  • change_subnet_compartment_details (ChangeSubnetCompartmentDetails) -- (required) Request to change the compartment of a given subnet.
  • work_request_states (list[str]) -- (optional) An array of work requests states to wait on. These should be valid values for status Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED]
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to change_subnet_compartment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
change_vcn_compartment_and_wait_for_state(vcn_id, change_vcn_compartment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls change_vcn_compartment() and waits for the WorkRequest to enter the given state(s).

Parameters:
  • vcn_id (str) --

    (required) The OCID of the VCN.

  • change_vcn_compartment_details (ChangeVcnCompartmentDetails) -- (required) Request to change the compartment of a given VCN.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for status
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to change_vcn_compartment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
change_vcn_compartment_and_wait_for_work_request(vcn_id, change_vcn_compartment_details, work_request_states=[], operation_kwargs={}, waiter_kwargs={})

Calls change_vcn_compartment() and waits for the oci.work_requests.models.WorkRequest to enter the given state(s).

Parameters:
  • vcn_id (str) --

    (required) The OCID of the VCN.

  • change_vcn_compartment_details (ChangeVcnCompartmentDetails) -- (required) Request to change the compartment of a given VCN.
  • work_request_states (list[str]) -- (optional) An array of work requests states to wait on. These should be valid values for status Default values are termination states: [STATUS_SUCCEEDED, STATUS_FAILED, STATUS_CANCELED]
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to change_vcn_compartment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_cross_connect_and_wait_for_state(create_cross_connect_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_cross_connect() and waits for the CrossConnect acted upon to enter the given state(s).

Parameters:
  • create_cross_connect_details (CreateCrossConnectDetails) -- (required) Details to create a CrossConnect
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_cross_connect()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_cross_connect_group_and_wait_for_state(create_cross_connect_group_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_cross_connect_group() and waits for the CrossConnectGroup acted upon to enter the given state(s).

Parameters:
  • create_cross_connect_group_details (CreateCrossConnectGroupDetails) -- (required) Details to create a CrossConnectGroup
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_cross_connect_group()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_dhcp_options_and_wait_for_state(create_dhcp_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_dhcp_options() and waits for the DhcpOptions acted upon to enter the given state(s).

Parameters:
  • create_dhcp_details (CreateDhcpDetails) -- (required) Request object for creating a new set of DHCP options.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_dhcp_options()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_drg_and_wait_for_state(create_drg_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_drg() and waits for the Drg acted upon to enter the given state(s).

Parameters:
  • create_drg_details (CreateDrgDetails) -- (required) Details for creating a DRG.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_drg()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_drg_attachment_and_wait_for_state(create_drg_attachment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_drg_attachment() and waits for the DrgAttachment acted upon to enter the given state(s).

Parameters:
  • create_drg_attachment_details (CreateDrgAttachmentDetails) -- (required) Details for creating a DrgAttachment.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_drg_attachment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_internet_gateway_and_wait_for_state(create_internet_gateway_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_internet_gateway() and waits for the InternetGateway acted upon to enter the given state(s).

Parameters:
  • create_internet_gateway_details (CreateInternetGatewayDetails) -- (required) Details for creating a new internet gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_internet_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_ip_sec_connection_and_wait_for_state(create_ip_sec_connection_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_ip_sec_connection() and waits for the IPSecConnection acted upon to enter the given state(s).

Parameters:
  • create_ip_sec_connection_details (CreateIPSecConnectionDetails) -- (required) Details for creating an IPSecConnection.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_ip_sec_connection()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_ipv6_and_wait_for_state(create_ipv6_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_ipv6() and waits for the Ipv6 acted upon to enter the given state(s).

Parameters:
  • create_ipv6_details (CreateIpv6Details) -- (required) Create IPv6 details.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_ipv6()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_local_peering_gateway_and_wait_for_state(create_local_peering_gateway_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_local_peering_gateway() and waits for the LocalPeeringGateway acted upon to enter the given state(s).

Parameters:
  • create_local_peering_gateway_details (CreateLocalPeeringGatewayDetails) -- (required) Details for creating a new local peering gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_local_peering_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_nat_gateway_and_wait_for_state(create_nat_gateway_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_nat_gateway() and waits for the NatGateway acted upon to enter the given state(s).

Parameters:
  • create_nat_gateway_details (CreateNatGatewayDetails) -- (required) Details for creating a NAT gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_nat_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_network_security_group_and_wait_for_state(create_network_security_group_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_network_security_group() and waits for the NetworkSecurityGroup acted upon to enter the given state(s).

Parameters:
  • create_network_security_group_details (CreateNetworkSecurityGroupDetails) -- (required) Details for creating a network security group.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_network_security_group()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_public_ip_and_wait_for_state(create_public_ip_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_public_ip() and waits for the PublicIp acted upon to enter the given state(s).

Parameters:
  • create_public_ip_details (CreatePublicIpDetails) -- (required) Create public IP details.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_public_ip()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_remote_peering_connection_and_wait_for_state(create_remote_peering_connection_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_remote_peering_connection() and waits for the RemotePeeringConnection acted upon to enter the given state(s).

Parameters:
  • create_remote_peering_connection_details (CreateRemotePeeringConnectionDetails) -- (required) Request to create peering connection to remote region
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_remote_peering_connection()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_route_table_and_wait_for_state(create_route_table_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_route_table() and waits for the RouteTable acted upon to enter the given state(s).

Parameters:
  • create_route_table_details (CreateRouteTableDetails) -- (required) Details for creating a new route table.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_route_table()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_security_list_and_wait_for_state(create_security_list_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_security_list() and waits for the SecurityList acted upon to enter the given state(s).

Parameters:
  • create_security_list_details (CreateSecurityListDetails) -- (required) Details regarding the security list to create.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_security_list()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_service_gateway_and_wait_for_state(create_service_gateway_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_service_gateway() and waits for the ServiceGateway acted upon to enter the given state(s).

Parameters:
  • create_service_gateway_details (CreateServiceGatewayDetails) -- (required) Details for creating a service gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_service_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_subnet_and_wait_for_state(create_subnet_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_subnet() and waits for the Subnet acted upon to enter the given state(s).

Parameters:
  • create_subnet_details (CreateSubnetDetails) -- (required) Details for creating a subnet.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_subnet()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_vcn_and_wait_for_state(create_vcn_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_vcn() and waits for the Vcn acted upon to enter the given state(s).

Parameters:
  • create_vcn_details (CreateVcnDetails) -- (required) Details for creating a new VCN.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_vcn()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
create_virtual_circuit_and_wait_for_state(create_virtual_circuit_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls create_virtual_circuit() and waits for the VirtualCircuit acted upon to enter the given state(s).

Parameters:
  • create_virtual_circuit_details (CreateVirtualCircuitDetails) -- (required) Details to create a VirtualCircuit.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to create_virtual_circuit()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_cross_connect_and_wait_for_state(cross_connect_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_cross_connect() and waits for the CrossConnect acted upon to enter the given state(s).

Parameters:
  • cross_connect_id (str) -- (required) The OCID of the cross-connect.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_cross_connect()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_cross_connect_group_and_wait_for_state(cross_connect_group_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_cross_connect_group() and waits for the CrossConnectGroup acted upon to enter the given state(s).

Parameters:
  • cross_connect_group_id (str) -- (required) The OCID of the cross-connect group.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_cross_connect_group()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_dhcp_options_and_wait_for_state(dhcp_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_dhcp_options() and waits for the DhcpOptions acted upon to enter the given state(s).

Parameters:
  • dhcp_id (str) -- (required) The OCID for the set of DHCP options.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_dhcp_options()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_drg_and_wait_for_state(drg_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_drg() and waits for the Drg acted upon to enter the given state(s).

Parameters:
  • drg_id (str) -- (required) The OCID of the DRG.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_drg()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_drg_attachment_and_wait_for_state(drg_attachment_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_drg_attachment() and waits for the DrgAttachment acted upon to enter the given state(s).

Parameters:
  • drg_attachment_id (str) -- (required) The OCID of the DRG attachment.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_drg_attachment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_internet_gateway_and_wait_for_state(ig_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_internet_gateway() and waits for the InternetGateway acted upon to enter the given state(s).

Parameters:
  • ig_id (str) -- (required) The OCID of the internet gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_internet_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_ip_sec_connection_and_wait_for_state(ipsc_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_ip_sec_connection() and waits for the IPSecConnection acted upon to enter the given state(s).

Parameters:
  • ipsc_id (str) -- (required) The OCID of the IPSec connection.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_ip_sec_connection()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_ipv6_and_wait_for_state(ipv6_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_ipv6() and waits for the Ipv6 acted upon to enter the given state(s).

Parameters:
  • ipv6_id (str) --

    (required) The OCID of the IPv6.

  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_ipv6()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_local_peering_gateway_and_wait_for_state(local_peering_gateway_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_local_peering_gateway() and waits for the LocalPeeringGateway acted upon to enter the given state(s).

Parameters:
  • local_peering_gateway_id (str) -- (required) The OCID of the local peering gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_local_peering_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_nat_gateway_and_wait_for_state(nat_gateway_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_nat_gateway() and waits for the NatGateway acted upon to enter the given state(s).

Parameters:
  • nat_gateway_id (str) --

    (required) The NAT gateway's OCID.

  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_nat_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_network_security_group_and_wait_for_state(network_security_group_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_network_security_group() and waits for the NetworkSecurityGroup acted upon to enter the given state(s).

Parameters:
  • network_security_group_id (str) --

    (required) The OCID of the network security group.

  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_network_security_group()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_public_ip_and_wait_for_state(public_ip_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_public_ip() and waits for the PublicIp acted upon to enter the given state(s).

Parameters:
  • public_ip_id (str) -- (required) The OCID of the public IP.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_public_ip()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_remote_peering_connection_and_wait_for_state(remote_peering_connection_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_remote_peering_connection() and waits for the RemotePeeringConnection acted upon to enter the given state(s).

Parameters:
  • remote_peering_connection_id (str) -- (required) The OCID of the remote peering connection (RPC).
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_remote_peering_connection()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_route_table_and_wait_for_state(rt_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_route_table() and waits for the RouteTable acted upon to enter the given state(s).

Parameters:
  • rt_id (str) -- (required) The OCID of the route table.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_route_table()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_security_list_and_wait_for_state(security_list_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_security_list() and waits for the SecurityList acted upon to enter the given state(s).

Parameters:
  • security_list_id (str) -- (required) The OCID of the security list.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_security_list()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_service_gateway_and_wait_for_state(service_gateway_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_service_gateway() and waits for the ServiceGateway acted upon to enter the given state(s).

Parameters:
  • service_gateway_id (str) --

    (required) The service gateway's OCID.

  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_service_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_subnet_and_wait_for_state(subnet_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_subnet() and waits for the Subnet acted upon to enter the given state(s).

Parameters:
  • subnet_id (str) -- (required) The OCID of the subnet.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_subnet()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_vcn_and_wait_for_state(vcn_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_vcn() and waits for the Vcn acted upon to enter the given state(s).

Parameters:
  • vcn_id (str) --

    (required) The OCID of the VCN.

  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_vcn()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
delete_virtual_circuit_and_wait_for_state(virtual_circuit_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls delete_virtual_circuit() and waits for the VirtualCircuit acted upon to enter the given state(s).

Parameters:
  • virtual_circuit_id (str) -- (required) The OCID of the virtual circuit.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to delete_virtual_circuit()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
detach_service_id_and_wait_for_state(service_gateway_id, detach_service_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls detach_service_id() and waits for the ServiceGateway acted upon to enter the given state(s).

Parameters:
  • service_gateway_id (str) --

    (required) The service gateway's OCID.

  • detach_service_details (ServiceIdRequestDetails) -- (required) ServiceId of Service to be detached from a service gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to detach_service_id()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_cross_connect_and_wait_for_state(cross_connect_id, update_cross_connect_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_cross_connect() and waits for the CrossConnect acted upon to enter the given state(s).

Parameters:
  • cross_connect_id (str) -- (required) The OCID of the cross-connect.
  • update_cross_connect_details (UpdateCrossConnectDetails) -- (required) Update CrossConnect fields.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_cross_connect()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_cross_connect_group_and_wait_for_state(cross_connect_group_id, update_cross_connect_group_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_cross_connect_group() and waits for the CrossConnectGroup acted upon to enter the given state(s).

Parameters:
  • cross_connect_group_id (str) -- (required) The OCID of the cross-connect group.
  • update_cross_connect_group_details (UpdateCrossConnectGroupDetails) -- (required) Update CrossConnectGroup fields
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_cross_connect_group()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_dhcp_options_and_wait_for_state(dhcp_id, update_dhcp_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_dhcp_options() and waits for the DhcpOptions acted upon to enter the given state(s).

Parameters:
  • dhcp_id (str) -- (required) The OCID for the set of DHCP options.
  • update_dhcp_details (UpdateDhcpDetails) -- (required) Request object for updating a set of DHCP options.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_dhcp_options()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_drg_and_wait_for_state(drg_id, update_drg_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_drg() and waits for the Drg acted upon to enter the given state(s).

Parameters:
  • drg_id (str) -- (required) The OCID of the DRG.
  • update_drg_details (UpdateDrgDetails) -- (required) Details object for updating a DRG.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_drg()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_drg_attachment_and_wait_for_state(drg_attachment_id, update_drg_attachment_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_drg_attachment() and waits for the DrgAttachment acted upon to enter the given state(s).

Parameters:
  • drg_attachment_id (str) -- (required) The OCID of the DRG attachment.
  • update_drg_attachment_details (UpdateDrgAttachmentDetails) -- (required) Details object for updating a DrgAttachment.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_drg_attachment()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_internet_gateway_and_wait_for_state(ig_id, update_internet_gateway_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_internet_gateway() and waits for the InternetGateway acted upon to enter the given state(s).

Parameters:
  • ig_id (str) -- (required) The OCID of the internet gateway.
  • update_internet_gateway_details (UpdateInternetGatewayDetails) -- (required) Details for updating the internet gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_internet_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_ip_sec_connection_and_wait_for_state(ipsc_id, update_ip_sec_connection_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_ip_sec_connection() and waits for the IPSecConnection acted upon to enter the given state(s).

Parameters:
  • ipsc_id (str) -- (required) The OCID of the IPSec connection.
  • update_ip_sec_connection_details (UpdateIPSecConnectionDetails) -- (required) Details object for updating a IPSec connection.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_ip_sec_connection()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_ip_sec_connection_tunnel_and_wait_for_state(ipsc_id, tunnel_id, update_ip_sec_connection_tunnel_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_ip_sec_connection_tunnel() and waits for the IPSecConnectionTunnel acted upon to enter the given state(s).

Parameters:
  • ipsc_id (str) -- (required) The OCID of the IPSec connection.
  • tunnel_id (str) --

    (required) The OCID of the tunnel.

  • update_ip_sec_connection_tunnel_details (UpdateIPSecConnectionTunnelDetails) -- (required) Details object for updating a IPSecConnection tunnel's details.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_ip_sec_connection_tunnel()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_ipv6_and_wait_for_state(ipv6_id, update_ipv6_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_ipv6() and waits for the Ipv6 acted upon to enter the given state(s).

Parameters:
  • ipv6_id (str) --

    (required) The OCID of the IPv6.

  • update_ipv6_details (UpdateIpv6Details) -- (required) IPv6 details to be updated.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_ipv6()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_local_peering_gateway_and_wait_for_state(local_peering_gateway_id, update_local_peering_gateway_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_local_peering_gateway() and waits for the LocalPeeringGateway acted upon to enter the given state(s).

Parameters:
  • local_peering_gateway_id (str) -- (required) The OCID of the local peering gateway.
  • update_local_peering_gateway_details (UpdateLocalPeeringGatewayDetails) -- (required) Details object for updating a local peering gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_local_peering_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_nat_gateway_and_wait_for_state(nat_gateway_id, update_nat_gateway_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_nat_gateway() and waits for the NatGateway acted upon to enter the given state(s).

Parameters:
  • nat_gateway_id (str) --

    (required) The NAT gateway's OCID.

  • update_nat_gateway_details (UpdateNatGatewayDetails) -- (required) Details object for updating a NAT gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_nat_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_network_security_group_and_wait_for_state(network_security_group_id, update_network_security_group_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_network_security_group() and waits for the NetworkSecurityGroup acted upon to enter the given state(s).

Parameters:
  • network_security_group_id (str) --

    (required) The OCID of the network security group.

  • update_network_security_group_details (UpdateNetworkSecurityGroupDetails) -- (required) Details object for updating a network security group.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_network_security_group()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_public_ip_and_wait_for_state(public_ip_id, update_public_ip_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_public_ip() and waits for the PublicIp acted upon to enter the given state(s).

Parameters:
  • public_ip_id (str) -- (required) The OCID of the public IP.
  • update_public_ip_details (UpdatePublicIpDetails) -- (required) Public IP details.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_public_ip()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_remote_peering_connection_and_wait_for_state(remote_peering_connection_id, update_remote_peering_connection_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_remote_peering_connection() and waits for the RemotePeeringConnection acted upon to enter the given state(s).

Parameters:
  • remote_peering_connection_id (str) -- (required) The OCID of the remote peering connection (RPC).
  • update_remote_peering_connection_details (UpdateRemotePeeringConnectionDetails) -- (required) Request to the update the peering connection to remote region
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_remote_peering_connection()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_route_table_and_wait_for_state(rt_id, update_route_table_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_route_table() and waits for the RouteTable acted upon to enter the given state(s).

Parameters:
  • rt_id (str) -- (required) The OCID of the route table.
  • update_route_table_details (UpdateRouteTableDetails) -- (required) Details object for updating a route table.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_route_table()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_security_list_and_wait_for_state(security_list_id, update_security_list_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_security_list() and waits for the SecurityList acted upon to enter the given state(s).

Parameters:
  • security_list_id (str) -- (required) The OCID of the security list.
  • update_security_list_details (UpdateSecurityListDetails) -- (required) Updated details for the security list.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_security_list()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_service_gateway_and_wait_for_state(service_gateway_id, update_service_gateway_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_service_gateway() and waits for the ServiceGateway acted upon to enter the given state(s).

Parameters:
  • service_gateway_id (str) --

    (required) The service gateway's OCID.

  • update_service_gateway_details (UpdateServiceGatewayDetails) -- (required) Details object for updating a service gateway.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_service_gateway()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_subnet_and_wait_for_state(subnet_id, update_subnet_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_subnet() and waits for the Subnet acted upon to enter the given state(s).

Parameters:
  • subnet_id (str) -- (required) The OCID of the subnet.
  • update_subnet_details (UpdateSubnetDetails) -- (required) Details object for updating a subnet.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_subnet()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_vcn_and_wait_for_state(vcn_id, update_vcn_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_vcn() and waits for the Vcn acted upon to enter the given state(s).

Parameters:
  • vcn_id (str) --

    (required) The OCID of the VCN.

  • update_vcn_details (UpdateVcnDetails) -- (required) Details object for updating a VCN.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_vcn()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_virtual_circuit_and_wait_for_state(virtual_circuit_id, update_virtual_circuit_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_virtual_circuit() and waits for the VirtualCircuit acted upon to enter the given state(s).

Parameters:
  • virtual_circuit_id (str) -- (required) The OCID of the virtual circuit.
  • update_virtual_circuit_details (UpdateVirtualCircuitDetails) -- (required) Update VirtualCircuit fields.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_virtual_circuit()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait
update_vnic_and_wait_for_state(vnic_id, update_vnic_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={})

Calls update_vnic() and waits for the Vnic acted upon to enter the given state(s).

Parameters:
  • vnic_id (str) -- (required) The OCID of the VNIC.
  • update_vnic_details (UpdateVnicDetails) -- (required) Details object for updating a VNIC.
  • wait_for_states (list[str]) -- An array of states to wait on. These should be valid values for lifecycle_state
  • operation_kwargs (dict) -- A dictionary of keyword arguments to pass to update_vnic()
  • waiter_kwargs (dict) -- A dictionary of keyword arguments to pass to the oci.wait_until() function. For example, you could pass max_interval_seconds or max_interval_seconds as dictionary keys to modify how long the waiter function will wait between retries and the maximum amount of time it will wait