def test_callback_func(virtual_network, config): name = "pythonsdk_waiter_" + tests.util.random_number_string() counters = {'create': 0, 'delete': 0} def create_vcn_callback(times_called, response): counters['create'] = times_called def delete_vcn_callback(times_called, response): counters['delete'] = times_called request = oci.core.models.CreateVcnDetails() request.cidr_block = '10.0.0.0/16' request.display_name = name request.compartment_id = config["tenancy"] response = virtual_network.create_vcn(request) vcn = response.data get_vcn_response = virtual_network.get_vcn(vcn.id) get_vcn_response.data.lifecycle_state = 'DUMMY' # This will force at least one service call response = oci.wait_until(virtual_network, get_vcn_response, 'lifecycle_state', 'AVAILABLE', wait_callback=create_vcn_callback) assert 'AVAILABLE' == response.data.lifecycle_state assert counters['create'] > 0 print('Deleting vcn') response = virtual_network.delete_vcn(vcn.id) result = oci.wait_until(virtual_network, get_vcn_response, 'lifecycle_state', 'TERMINATED', max_wait_seconds=180, succeed_on_not_found=True, wait_callback=delete_vcn_callback) assert result == oci.waiter.WAIT_RESOURCE_NOT_FOUND assert counters['delete'] >= 0
def delete_vcn_and_subnet(virtual_network, vcn_and_subnet): vcn = vcn_and_subnet['vcn'] subnet = vcn_and_subnet['subnet'] # Sometimes we can't delete the subnet straight after a mount target has been deleted as network resources # still need to clear. If we get a conflict, try a few times before bailing out attempts = 0 while attempts < 5: try: virtual_network.delete_subnet(subnet.id) oci.wait_until( virtual_network, virtual_network.get_subnet(subnet.id), 'lifecycle_state', 'TERMINATED', max_wait_seconds=600, succeed_on_not_found=True ) break except oci.exceptions.ServiceError as e: attempts += 1 if e.status == 409 and attempts < 5: time.sleep(5) else: raise virtual_network.delete_vcn(vcn.id) oci.wait_until( virtual_network, virtual_network.get_vcn(vcn.id), 'lifecycle_state', 'TERMINATED', max_wait_seconds=600, succeed_on_not_found=True )
def delete_vcn_and_subnet(virtual_network, vcn_and_subnet): vcn = vcn_and_subnet['vcn'] subnet = vcn_and_subnet['subnet'] virtual_network.delete_subnet(subnet.id) oci.wait_until( virtual_network, virtual_network.get_subnet(subnet.id), 'lifecycle_state', 'TERMINATED', max_wait_seconds=300, # For a deletion, the record may no longer be available and the waiter may encounter a 404 when trying to retrieve it. # This flag tells the waiter to consider 404s as successful (which is only really valid for delete/terminate since # the record not being there anymore can signify a successful delete/terminate) succeed_on_not_found=True ) virtual_network.delete_vcn(vcn.id) oci.wait_until( virtual_network, virtual_network.get_vcn(vcn.id), 'lifecycle_state', 'TERMINATED', max_wait_seconds=300, succeed_on_not_found=True )
def create_vcn_drg_and_drg_attachment(virtual_network_client, compartment_id, cidr_block, vcn_dns_label): vcn_name = 'py_sdk_example_vcn' result = virtual_network_client.create_vcn( oci.core.models.CreateVcnDetails( cidr_block=cidr_block, display_name=vcn_name, compartment_id=compartment_id, dns_label=vcn_dns_label ) ) vcn = oci.wait_until( virtual_network_client, virtual_network_client.get_vcn(result.data.id), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300 ).data print('Created VCN') print('===============') print(vcn) print('\n\n') result = virtual_network_client.create_drg( oci.core.models.CreateDrgDetails( compartment_id=compartment_id, display_name='Python SDK Example DRG' ) ) drg = oci.wait_until( virtual_network_client, virtual_network_client.get_drg(result.data.id), 'lifecycle_state', 'AVAILABLE' ).data print('Created DRG') print('===============') print(drg) print('\n\n') result = virtual_network_client.create_drg_attachment( oci.core.models.CreateDrgAttachmentDetails( display_name='Python SDK Example DRG Attachment', vcn_id=vcn.id, drg_id=drg.id ) ) drg_attachment = oci.wait_until( virtual_network_client, virtual_network_client.get_drg_attachment(result.data.id), 'lifecycle_state', 'ATTACHED' ).data print('Created DRG Attachment') print('=========================') print(drg_attachment) print('\n\n') return {'vcn': vcn, 'drg': drg, 'drg_attachment': drg_attachment}
def delete_volume(block_storage, volume): block_storage.delete_volume(volume.id) oci.wait_until( block_storage, block_storage.get_volume(volume.id), 'lifecycle_state', 'TERMINATED' )
def detach_volume(compute, volume_attachment): compute.detach_volume(volume_attachment.id) oci.wait_until( compute, compute.get_volume_attachment(volume_attachment.id), 'lifecycle_state', 'DETACHED' )
def terminate_instance(compute, instance): compute.terminate_instance(instance.id) oci.wait_until( compute, compute.get_instance(instance.id), 'lifecycle_state', 'TERMINATED', max_wait_seconds=300, succeed_on_not_found=True )
def delete_subnet(virtual_network, subnet): virtual_network.delete_subnet(subnet.id) oci.wait_until( virtual_network, virtual_network.get_subnet(subnet.id), 'lifecycle_state', 'TERMINATED', succeed_on_not_found=True ) print('Deleted Subnet: {}'.format(subnet.id))
def delete_internet_gateway(virtual_network, internet_gateway): virtual_network.delete_internet_gateway(internet_gateway.id) oci.wait_until( virtual_network, virtual_network.get_internet_gateway(internet_gateway.id), 'lifecycle_state', 'TERMINATED', succeed_on_not_found=True ) print('Deleted Internet Gateway: {}'.format(internet_gateway.id))
def clear_route_rules_from_default_route_table(virtual_network, vcn): virtual_network.update_route_table( vcn.default_route_table_id, oci.core.models.UpdateRouteTableDetails(route_rules=[]) ) oci.wait_until( virtual_network, virtual_network.get_route_table(vcn.default_route_table_id), 'lifecycle_state', 'AVAILABLE' ) print('Cleared route rules from route table: {}'.format(vcn.default_route_table_id))
def delete_vcn(virtual_network, vcn): virtual_network.delete_vcn(vcn.id) oci.wait_until( virtual_network, virtual_network.get_vcn(vcn.id), 'lifecycle_state', 'TERMINATED', # For a deletion, the record may no longer be available and the waiter may encounter a 404 when trying to retrieve it. # This flag tells the waiter to consider 404s as successful (which is only really valid for delete/terminate since # the record not being there anymore can signify a successful delete/terminate) succeed_on_not_found=True ) print('Deleted VCN: {}'.format(vcn.id))
def launch_instance(compute, compartment_id, subnet, image_id): create_instance_details = oci.core.models.LaunchInstanceDetails() create_instance_details.compartment_id = compartment_id create_instance_details.availability_domain = subnet.availability_domain create_instance_details.display_name = 'pub_ip_test_instance' create_instance_details.create_vnic_details = oci.core.models.CreateVnicDetails( subnet_id=subnet.id, # We don't assign a public IP here so that we can demonstrate public IP functionality later on # in the script assign_public_ip=False ) create_instance_details.image_id = image_id create_instance_details.shape = 'VM.Standard1.1' result = compute.launch_instance(create_instance_details) instance_ocid = result.data.id get_instance_response = oci.wait_until( compute, compute.get_instance(instance_ocid), 'lifecycle_state', 'RUNNING', max_wait_seconds=600 ) print('Launched instance') return get_instance_response.data
def add_route_rule_to_default_route_table_for_internet_gateway(virtual_network, vcn, internet_gateway): get_route_table_response = virtual_network.get_route_table(vcn.default_route_table_id) route_rules = get_route_table_response.data.route_rules print('\nCurrent Route Rules For VCN') print('===========================') print('{}\n\n'.format(route_rules)) # Updating route rules will totally replace any current route rules with what we send through. # If we wish to preserve any existing route rules, we need to read them out first and then send # them back to the service as part of any update route_rules.append( oci.core.models.RouteRule( cidr_block='0.0.0.0/0', network_entity_id=internet_gateway.id ) ) virtual_network.update_route_table( vcn.default_route_table_id, oci.core.models.UpdateRouteTableDetails(route_rules=route_rules) ) get_route_table_response = oci.wait_until( virtual_network, virtual_network.get_route_table(vcn.default_route_table_id), 'lifecycle_state', 'AVAILABLE' ) print('\nUpdated Route Rules For VCN') print('===========================') print('{}\n\n'.format(get_route_table_response.data.route_rules)) return get_route_table_response.data
def create_internet_gateway(virtual_network, vcn): internet_gateway_name = 'py_sdk_example_ig' result = virtual_network.create_internet_gateway( oci.core.models.CreateInternetGatewayDetails( display_name=internet_gateway_name, compartment_id=vcn.compartment_id, is_enabled=True, vcn_id=vcn.id ) ) get_internet_gateway_response = oci.wait_until( virtual_network, virtual_network.get_internet_gateway(result.data.id), 'lifecycle_state', 'AVAILABLE' ) print('Created internet gateway: {}'.format(get_internet_gateway_response.data.id)) add_route_rule_to_default_route_table_for_internet_gateway( virtual_network, vcn, get_internet_gateway_response.data ) return get_internet_gateway_response.data
def test_basic_wait(virtual_network, config): """Creates and deletes a VCN, waiting after each operation.""" name = "pythonsdk_waiter_" + tests.util.random_number_string() print('Creating cloud network ' + name) start_time = time.time() request = oci.core.models.CreateVcnDetails() request.cidr_block = '10.0.0.0/16' request.display_name = name request.compartment_id = config["tenancy"] response = virtual_network.create_vcn(request) vcn = response.data response = virtual_network.get_vcn(vcn.id) response = oci.wait_until(virtual_network, response, 'lifecycle_state', 'AVAILABLE') assert 'AVAILABLE' == response.data.lifecycle_state print('Deleting vcn') response = virtual_network.delete_vcn(vcn.id) assert response.status == 204 with pytest.raises(oci.exceptions.ServiceError) as excinfo: response = virtual_network.get_vcn(vcn.id) assert 'TERMINATING' == response.data.lifecycle_state oci.wait_until( virtual_network, response, 'lifecycle_state', 'TERMINATED', max_wait_seconds=180 ) assert excinfo.value.status == 404 result = oci.wait_until(virtual_network, response, 'lifecycle_state', 'TERMINATED', max_wait_seconds=180, succeed_on_not_found=True) assert result == oci.waiter.WAIT_RESOURCE_NOT_FOUND total_time = time.time() - start_time # This should always be between 1 second and 5 minutes. assert total_time < 60 * 5 assert total_time > 1
def do_vcn_interactions_with_retries(virtual_network_client, compartment_id, retry_strategy): vcn_name = 'python_sdk_example_vcn' cidr_block = '10.0.0.0/16' result = virtual_network_client.create_vcn( oci.core.models.CreateVcnDetails( cidr_block=cidr_block, display_name=vcn_name, compartment_id=compartment_id ), retry_strategy=retry_strategy ) vcn = oci.wait_until( virtual_network_client, virtual_network_client.get_vcn(result.data.id), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300 ).data print('Created VCN') print('================') print(vcn) print('\n\n') result = virtual_network_client.update_vcn( vcn.id, oci.core.models.UpdateVcnDetails(display_name='python_sdk_example_vcn_updated'), retry_strategy=retry_strategy ) print('Updated VCN') print('================') print(result.data) print('\n\n') virtual_network_client.delete_vcn(vcn.id, retry_strategy=retry_strategy) oci.wait_until( virtual_network_client, virtual_network_client.get_vcn(vcn.id), 'lifecycle_state', 'TERMINATED', max_wait_seconds=300, succeed_on_not_found=True ) print('Deleted VCN') print('\n\n')
def test_already_in_state(identity, config): description = 'test user' request = oci.identity.models.CreateUserDetails() request.compartment_id = config["tenancy"] request.name = tests.util.unique_name('python_wait_test_user') request.description = description response = identity.create_user(request) user_id = response.data.id response = identity.get_user(user_id) assert description == response.data.description start_time = time.time() oci.wait_until(identity, response, 'description', description) assert start_time - time.time() < 1 # clean up identity.delete_user(user_id)
def create_vcn_and_subnet(virtual_network, compartment_id, availability_domain): # Create a VCN vcn_name = 'python_sdk_test_vcn' cidr_block = "10.0.0.0/16" result = virtual_network.create_vcn( oci.core.models.CreateVcnDetails( cidr_block=cidr_block, display_name=vcn_name, compartment_id=compartment_id ) ) vcn = oci.wait_until( virtual_network, virtual_network.get_vcn(result.data.id), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300 ).data print('Created VCN') # Create a subnet subnet_name = 'python_sdk_test_subnet1' subnet_cidr_block1 = "10.0.0.0/24" result = virtual_network.create_subnet( oci.core.models.CreateSubnetDetails( compartment_id=compartment_id, availability_domain=availability_domain, display_name=subnet_name, vcn_id=vcn.id, cidr_block=subnet_cidr_block1 ) ) subnet = oci.wait_until( virtual_network, virtual_network.get_subnet(result.data.id), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300 ).data print('Created subnet') return {'vcn': vcn, 'subnet': subnet}
def create_vcn_and_subnet(virtual_network, compartment_id, availability_domain): vcn_name = 'py_sdk_fs_example_vcn' cidr_block = "10.0.0.0/16" vcn_dns_label = 'pysdkfs' result = virtual_network.create_vcn( oci.core.models.CreateVcnDetails( cidr_block=cidr_block, display_name=vcn_name, compartment_id=compartment_id, dns_label=vcn_dns_label ) ) vcn = oci.wait_until( virtual_network, virtual_network.get_vcn(result.data.id), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300 ).data subnet_name = 'py_sdk_fs_example_subnet' subnet_dns_label = 'pyfssub' result = virtual_network.create_subnet( oci.core.models.CreateSubnetDetails( compartment_id=compartment_id, availability_domain=availability_domain, display_name=subnet_name, vcn_id=vcn.id, cidr_block=cidr_block, dns_label=subnet_dns_label ) ) subnet = oci.wait_until( virtual_network, virtual_network.get_subnet(result.data.id), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300 ).data return {'vcn': vcn, 'subnet': subnet}
def test_eval_function_func_ref(identity, config): user_id = None try: description = 'test user' request = oci.identity.models.CreateUserDetails() request.compartment_id = config["tenancy"] request.name = tests.util.unique_name('python_wait_test_user') request.description = description response = identity.create_user(request) user_id = response.data.id response = identity.get_user(user_id) assert description == response.data.description def test_user_response(user_response): print('Invoked function reference in test_user_response') user = user_response.data return user.description == description and user.name == request.name and user.lifecycle_state == 'ACTIVE' response = oci.wait_until(identity, response, evaluate_response=test_user_response) assert response.data.id == user_id assert response.data.description == description assert response.data.name == request.name assert response.data.lifecycle_state == 'ACTIVE' times_called = {'counter': 0} def test_user_response_for_timeout(user_response): print('Invoked function reference in test_user_response_for_timeout') user = user_response.data times_called['counter'] += 1 return user.description == description and user.name == request.name and user.lifecycle_state == 'superman' with pytest.raises(oci.exceptions.MaximumWaitTimeExceeded): response = oci.wait_until(identity, response, evaluate_response=test_user_response_for_timeout, max_wait_seconds=45, max_interval_seconds=10) assert times_called['counter'] >= 2 finally: if user_id: identity.delete_user(user_id)
def delete_vcn_drg_and_drg_attachment(virtual_network_client, vcn_drg_and_drg_attachment): vcn = vcn_drg_and_drg_attachment['vcn'] drg = vcn_drg_and_drg_attachment['drg'] drg_attachment = vcn_drg_and_drg_attachment['drg_attachment'] print('Deleting DRG Attachment') virtual_network_client.delete_drg_attachment(drg_attachment.id) oci.wait_until( virtual_network_client, virtual_network_client.get_drg_attachment(drg_attachment.id), 'lifecycle_state', 'DETACHED', succeed_on_not_found=True ) print('Deleting DRG') virtual_network_client.delete_drg(drg.id) oci.wait_until( virtual_network_client, virtual_network_client.get_drg(drg.id), 'lifecycle_state', 'TERMINATED', succeed_on_not_found=True ) print('Deleting VCN') virtual_network_client.delete_vcn(vcn.id) oci.wait_until( virtual_network_client, virtual_network_client.get_vcn(vcn.id), 'lifecycle_state', 'TERMINATED', succeed_on_not_found=True )
def test_wait_time_exceeded(identity, config): description = 'test user' request = oci.identity.models.CreateUserDetails() request.compartment_id = config["tenancy"] request.name = tests.util.unique_name('python_wait_test_user') request.description = description response = identity.create_user(request) user_id = response.data.id response = identity.get_user(user_id) assert description == response.data.description start_time = time.time() with pytest.raises(oci.exceptions.MaximumWaitTimeExceeded): # Wait on a property that will not change until we time out. oci.wait_until(identity, response, 'name', 'test', max_wait_seconds=2) total_time = time.time() - start_time assert 1 < total_time < 4 # clean up identity.delete_user(user_id)
def create_volume(block_storage, compartment_id, availability_domain, display_name): result = block_storage.create_volume( oci.core.models.CreateVolumeDetails( compartment_id=compartment_id, availability_domain=availability_domain, display_name=display_name ) ) volume = oci.wait_until( block_storage, block_storage.get_volume(result.data.id), 'lifecycle_state', 'AVAILABLE' ).data print('Created Volume: {}'.format(display_name)) return volume
def create_vcn(virtual_network, compartment_id, cidr_block): vcn_name = 'py_sdk_example_vcn' result = virtual_network.create_vcn( oci.core.models.CreateVcnDetails( cidr_block=cidr_block, display_name=vcn_name, compartment_id=compartment_id ) ) get_vcn_response = oci.wait_until( virtual_network, virtual_network.get_vcn(result.data.id), 'lifecycle_state', 'AVAILABLE' ) print('Created VCN: {}'.format(get_vcn_response.data.id)) return get_vcn_response.data
def db_node_action_and_wait_for_state(self, db_node_id, action, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}): """ Calls :py:func:`~oci.database.DatabaseClient.db_node_action` and waits for the :py:class:`~oci.database.models.DbNode` acted upon to enter the given state(s). :param str db_node_id: (required) The database node `OCID`__. __ https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm :param str action: (required) The action to perform on the DB Node. Allowed values are: "STOP", "START", "SOFTRESET", "RESET" :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.database.models.DbNode.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.database.DatabaseClient.db_node_action` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 """ operation_result = self.client.db_node_action(db_node_id, action, **operation_kwargs) if not wait_for_states: return operation_result lowered_wait_for_states = [w.lower() for w in wait_for_states] wait_for_resource_id = operation_result.data.id try: waiter_result = oci.wait_until( self.client, self.client.get_db_node(wait_for_resource_id), evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states, **waiter_kwargs ) result_to_return = waiter_result return result_to_return except Exception as e: raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
def update_idp_group_mapping_and_wait_for_state(self, identity_provider_id, mapping_id, update_idp_group_mapping_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}): """ Calls :py:func:`~oci.identity.IdentityClient.update_idp_group_mapping` and waits for the :py:class:`~oci.identity.models.IdpGroupMapping` acted upon to enter the given state(s). :param str identity_provider_id: (required) The OCID of the identity provider. :param str mapping_id: (required) The OCID of the group mapping. :param UpdateIdpGroupMappingDetails update_idp_group_mapping_details: (required) Request object for updating an identity provider group mapping :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.identity.models.IdpGroupMapping.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.identity.IdentityClient.update_idp_group_mapping` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 """ operation_result = self.client.update_idp_group_mapping(identity_provider_id, mapping_id, update_idp_group_mapping_details, **operation_kwargs) if not wait_for_states: return operation_result lowered_wait_for_states = [w.lower() for w in wait_for_states] wait_for_resource_id = operation_result.data.id try: waiter_result = oci.wait_until( self.client, self.client.get_idp_group_mapping(wait_for_resource_id), evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states, **waiter_kwargs ) result_to_return = waiter_result return result_to_return except Exception as e: raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
def create_subnet(virtual_network, vcn, availability_domain): subnet_name = 'py_sdk_example_subnet1' result = virtual_network.create_subnet( oci.core.models.CreateSubnetDetails( compartment_id=vcn.compartment_id, availability_domain=availability_domain, display_name=subnet_name, vcn_id=vcn.id, cidr_block=vcn.cidr_block ) ) get_subnet_response = oci.wait_until( virtual_network, virtual_network.get_subnet(result.data.id), 'lifecycle_state', 'AVAILABLE' ) print('Created Subnet: {}'.format(get_subnet_response.data.id)) return get_subnet_response.data
def launch_instance(compute, vcn_and_subnet): result = compute.launch_instance( oci.core.models.LaunchInstanceDetails( availability_domain=vcn_and_subnet['subnet'].availability_domain, compartment_id=vcn_and_subnet['subnet'].compartment_id, display_name='VolAttachTypesExampleInstance', shape='VM.Standard1.1', subnet_id=vcn_and_subnet['subnet'].id, image_id=get_image(compute, vcn_and_subnet['subnet'].compartment_id, 'Oracle Linux', '7.4', 'VM.Standard1.1').id ) ) get_instance_response = oci.wait_until( compute, compute.get_instance(result.data.id), 'lifecycle_state', 'RUNNING', max_wait_seconds=300 ) print('Launched Instance') return get_instance_response.data
def update_image_and_wait_for_state(self, image_id, update_image_details, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}): """ Calls :py:func:`~oci.core.ComputeClient.update_image` and waits for the :py:class:`~oci.core.models.Image` acted upon to enter the given state(s). :param str image_id: (required) The OCID of the image. :param UpdateImageDetails update_image_details: (required) Updates the image display name field. Avoid entering confidential information. :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.core.models.Image.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.core.ComputeClient.update_image` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 """ operation_result = self.client.update_image(image_id, update_image_details, **operation_kwargs) if not wait_for_states: return operation_result lowered_wait_for_states = [w.lower() for w in wait_for_states] wait_for_resource_id = operation_result.data.id try: waiter_result = oci.wait_until( self.client, self.client.get_image(wait_for_resource_id), evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states, **waiter_kwargs ) result_to_return = waiter_result return result_to_return except Exception as e: raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
def terminate_db_system_and_wait_for_state(self, db_system_id, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}): """ Calls :py:func:`~oci.database.DatabaseClient.terminate_db_system` and waits for the :py:class:`~oci.database.models.DbSystem` acted upon to enter the given state(s). :param str db_system_id: (required) The DB System `OCID`__. __ https://docs.us-phoenix-1.oraclecloud.com/Content/General/Concepts/identifiers.htm :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.database.models.DbSystem.lifecycle_state` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.database.DatabaseClient.terminate_db_system` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 """ initial_get_result = self.client.get_db_system(db_system_id) operation_result = self.client.terminate_db_system(db_system_id, **operation_kwargs) if not wait_for_states: return operation_result lowered_wait_for_states = [w.lower() for w in wait_for_states] try: waiter_result = oci.wait_until( self.client, initial_get_result, evaluate_response=lambda r: getattr(r.data, 'lifecycle_state') and getattr(r.data, 'lifecycle_state').lower() in lowered_wait_for_states, succeed_on_not_found=True, **waiter_kwargs ) result_to_return = waiter_result return result_to_return except Exception as e: raise oci.exceptions.CompositeOperationError(partial_results=[operation_result], cause=e)
launch_response = database_client.launch_db_system(launch_db_system_details) print('\nLaunched DB System') print('===========================') print('{}\n\n'.format(launch_response.data)) # We can wait until the DB system is available. A DB system can take some time to launch (e.g. on the order # of magnitude of hours) so we can change the max_interval_seconds and max_wait_seconds to account for this. # The wait_until defaults of checking every 30 seconds and waiting for a maximum of 1200 seconds (20 minutes) # may not be sufficient. # # In the below example, we check every 900 seconds (15 minutes) and wait a max of 21600 seconds (6 hours) get_db_system_response = oci.wait_until( database_client, database_client.get_db_system(launch_response.data.id), 'lifecycle_state', 'AVAILABLE', max_interval_seconds=900, max_wait_seconds=21600 ) print('\nDB System Available') print('===========================') print('{}\n\n'.format(get_db_system_response.data)) list_db_home_and_databases_under_db_system(database_client, compartment_id, get_db_system_response.data) # Once we're done with the DB system, we can terminate it and wait for it to be terminated. We also use # succeed_on_not_found for the waiter in case the DB system is no longer returned by get_db_system calls # as that implies our delete/termination has succeeded. # # In this basic scenario where we have a single DB system, DB home and database, terminating the DB system
def handle_create_volume(block_storage_client, module): create_volume_details = CreateVolumeDetails() create_volume_details.availability_domain = module.params[ 'availability_domain'] create_volume_details.compartment_id = module.params['compartment_id'] create_volume_details.display_name = module.params['display_name'] create_volume_details.size_in_gbs = module.params['size_in_gbs'] oci_utils.add_tags_to_model_from_module(create_volume_details, module) if module.params['source_details']: source_details = module.params['source_details'] volume_source = None if 'type' in source_details: if source_details['type'] == "volume": volume_source = VolumeSourceFromVolumeDetails() volume_source.id = source_details["id"] elif source_details['type'] == "volumeBackup": volume_source = VolumeSourceFromVolumeBackupDetails() volume_source.id = source_details["id"] else: module.fail_json( msg="value of state must be one of: volume, volumeBackup") else: module.fail_json(msg="missing required arguments: type") create_volume_details.source_details = volume_source result = oci_utils.create_and_wait( resource_type="volume", create_fn=block_storage_client.create_volume, kwargs_create={"create_volume_details": create_volume_details}, client=block_storage_client, get_fn=block_storage_client.get_volume, get_param="volume_id", module=module) wait_for_copy = False copy_timeout = 1800 WAIT_FOR_INITIALIZATION = "wait_for_copy" INITIALIZATION_TIMEOUT = "copy_timeout" if create_volume_details.source_details is not None: if WAIT_FOR_INITIALIZATION in source_details: wait_for_copy = source_details[WAIT_FOR_INITIALIZATION] if INITIALIZATION_TIMEOUT in source_details: copy_timeout = source_details[INITIALIZATION_TIMEOUT] try: response = oci_utils.call_with_backoff( block_storage_client.get_volume, volume_id=result['volume']['id']) if wait_for_copy: result['volume'] = to_dict( oci.wait_until(block_storage_client, response, 'is_hydrated', True, max_wait_seconds=copy_timeout).data) except ServiceError as ex: module.fail_json(msg=ex.message) except MaximumWaitTimeExceeded as ex: module.fail_json(msg=str(ex)) return result
def vcn_and_subnet(runner, config_file, config_profile, network_client): with test_config_container.create_vcr(cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette('filestorage_vcn_and_subnet_fixture.yml'): # create VCN vcn_name = util.random_name('cli_db_test_vcn') cidr_block = "10.0.0.0/16" vcn_dns_label = util.random_name('vcn', insert_underscore=False) create_vcn_details = oci.core.models.CreateVcnDetails() create_vcn_details.cidr_block = cidr_block create_vcn_details.display_name = vcn_name create_vcn_details.compartment_id = util.COMPARTMENT_ID create_vcn_details.dns_label = vcn_dns_label result = network_client.create_vcn(create_vcn_details) vcn_ocid = result.data.id assert result.status == 200 oci.wait_until(network_client, network_client.get_vcn(vcn_ocid), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300) # create subnet in first AD subnet_name = util.random_name('python_sdk_test_subnet') cidr_block = "10.0.1.0/24" subnet_dns_label = util.random_name('subnet', insert_underscore=False) + '1' create_subnet_details = oci.core.models.CreateSubnetDetails() create_subnet_details.compartment_id = util.COMPARTMENT_ID create_subnet_details.availability_domain = util.availability_domain() create_subnet_details.display_name = subnet_name create_subnet_details.vcn_id = vcn_ocid create_subnet_details.cidr_block = cidr_block create_subnet_details.dns_label = subnet_dns_label result = network_client.create_subnet(create_subnet_details) subnet_ocid = result.data.id assert result.status == 200 oci.wait_until(network_client, network_client.get_subnet(subnet_ocid), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300) yield vcn_ocid, subnet_ocid # this code does not run inside the vcr_fixture because it is outside any test function # thus we are explicitly creating a separate cassette for it here with test_config_container.create_vcr(cassette_library_dir=CASSETTE_LIBRARY_DIR).use_cassette('filestorage_vcn_and_subnet_fixture_cleanup.yml'): # Sometimes we can't delete the subnet straight after the mount target because some VNIC is still # hanging around. If we get a conflict, try a few times before bailing out attempts = 0 while attempts < 5: try: network_client.delete_subnet(subnet_ocid) test_config_container.do_wait( network_client, network_client.get_subnet(subnet_ocid), 'lifecycle_state', 'TERMINATED', max_wait_seconds=600, succeed_on_not_found=True ) break except oci.exceptions.ServiceError as e: attempts += 1 if e.status == 409 and attempts < 5: time.sleep(5) else: raise network_client.delete_vcn(vcn_ocid)
def update_rover_entitlement(ctx, from_json, force, wait_for_state, max_wait_seconds, wait_interval_seconds, rover_entitlement_id, display_name, tenant_id, requestor_name, requestor_email, entitlement_details, lifecycle_state, lifecycle_state_details, freeform_tags, defined_tags, system_tags, if_match): if isinstance(rover_entitlement_id, six.string_types) and len(rover_entitlement_id.strip()) == 0: raise click.UsageError('Parameter --rover-entitlement-id cannot be whitespace or empty string') if not force: if freeform_tags or defined_tags or system_tags: if not click.confirm("WARNING: Updates to freeform-tags and defined-tags and system-tags will replace any existing values. Are you sure you want to continue?"): ctx.abort() kwargs = {} if if_match is not None: kwargs['if_match'] = if_match kwargs['opc_request_id'] = cli_util.use_or_generate_request_id(ctx.obj['request_id']) _details = {} if display_name is not None: _details['displayName'] = display_name if tenant_id is not None: _details['tenantId'] = tenant_id if requestor_name is not None: _details['requestorName'] = requestor_name if requestor_email is not None: _details['requestorEmail'] = requestor_email if entitlement_details is not None: _details['entitlementDetails'] = entitlement_details if lifecycle_state is not None: _details['lifecycleState'] = lifecycle_state if lifecycle_state_details is not None: _details['lifecycleStateDetails'] = lifecycle_state_details if freeform_tags is not None: _details['freeformTags'] = cli_util.parse_json_parameter("freeform_tags", freeform_tags) if defined_tags is not None: _details['definedTags'] = cli_util.parse_json_parameter("defined_tags", defined_tags) if system_tags is not None: _details['systemTags'] = cli_util.parse_json_parameter("system_tags", system_tags) client = cli_util.build_client('rover', 'rover_entitlement', ctx) result = client.update_rover_entitlement( rover_entitlement_id=rover_entitlement_id, update_rover_entitlement_details=_details, **kwargs ) if wait_for_state: if hasattr(client, 'get_rover_entitlement') and callable(getattr(client, 'get_rover_entitlement')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs['max_interval_seconds'] = wait_interval_seconds click.echo('Action completed. Waiting until the resource has entered state: {}'.format(wait_for_state), file=sys.stderr) result = oci.wait_until(client, client.get_rover_entitlement(result.data.id), 'lifecycle_state', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo('Failed to wait until the resource entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo('Encountered error while waiting for resource to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo('Unable to wait for the resource to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def update_backend_and_wait_for_state(self, network_load_balancer_id, update_backend_details, backend_set_name, backend_name, wait_for_states=[], operation_kwargs={}, waiter_kwargs={}): """ Calls :py:func:`~oci.network_load_balancer.NetworkLoadBalancerClient.update_backend` and waits for the :py:class:`~oci.network_load_balancer.models.WorkRequest` to enter the given state(s). :param str network_load_balancer_id: (required) The `OCID`__ of the network load balancer to update. __ https://docs.cloud.oracle.com/Content/General/Concepts/identifiers.htm :param oci.network_load_balancer.models.UpdateBackendDetails update_backend_details: (required) Details for updating a backend server. :param str backend_set_name: (required) The name of the backend set associated with the backend server. Example: `example_backend_set` :param str backend_name: (required) The name of the backend server to update. This is specified as <ip>:<port>, or as <ip> <OCID>:<port>. Example: `10.0.0.3:8080` or `ocid1.privateip..oc1.<var><unique_ID></var>:8080` :param list[str] wait_for_states: An array of states to wait on. These should be valid values for :py:attr:`~oci.network_load_balancer.models.WorkRequest.status` :param dict operation_kwargs: A dictionary of keyword arguments to pass to :py:func:`~oci.network_load_balancer.NetworkLoadBalancerClient.update_backend` :param dict waiter_kwargs: A dictionary of keyword arguments to pass to the :py:func:`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 """ operation_result = self.client.update_backend(network_load_balancer_id, update_backend_details, backend_set_name, backend_name, **operation_kwargs) if not wait_for_states: return operation_result lowered_wait_for_states = [w.lower() for w in wait_for_states] wait_for_resource_id = operation_result.headers['opc-work-request-id'] try: waiter_result = oci.wait_until( self.client, self.client.get_work_request(wait_for_resource_id), evaluate_response=lambda r: getattr(r.data, 'status') and getattr(r.data, 'status').lower() in lowered_wait_for_states, **waiter_kwargs) result_to_return = waiter_result return result_to_return except Exception as e: raise oci.exceptions.CompositeOperationError( partial_results=[operation_result], cause=e)
# errors). The retry strategy will also make requests with an opc-retry-token that it generates. # # If you do not use the retry_strategy (or have an alternate way of retrying you wish to use instead) we still # recommend that you use an opc-retry-token in your service calls so that if you receive, say, a timeout or server error # and need to retry/reissue the request you won't run the risk of creating multiple resources. create_response = file_storage_client.create_file_system( oci.file_storage.models.CreateFileSystemDetails( display_name='py_sdk_example_fs', compartment_id=compartment_id, availability_domain=availability_domain), retry_strategy=oci.retry.DEFAULT_RETRY_STRATEGY) # A file system has a lifecycle state, we should wait until it is active. Note that wait_until returns a response, so # to access the model object we use the .data attribute file_system = oci.wait_until( file_storage_client, file_storage_client.get_file_system(create_response.data.id), 'lifecycle_state', 'ACTIVE').data print('Created file system:\n{}'.format(file_system)) print('=============================\n') # We can update the display name of the file system update_response = file_storage_client.update_file_system( file_system.id, oci.file_storage.models.UpdateFileSystemDetails( display_name='updated_py_sdk_example_fs')) print('Updated file system:\n{}'.format(update_response.data)) print('=============================\n') # Listing file systems is a paginated operation, so we can use the functionality in the oci.pagination # module to get all the results all_file_systems = oci.pagination.list_call_get_all_results(
def create_transfer_appliance_extended(ctx, **kwargs): if 'job_id' in kwargs: kwargs['id'] = kwargs['job_id'] kwargs.pop('job_id') kwargs['customer_shipping_address'] = {} for option, value in customer_address_options.items(): if option in kwargs: kwargs['customer_shipping_address'][value] = kwargs[option] kwargs.pop(option) id = kwargs['id'] customer_shipping_address = kwargs['customer_shipping_address'] wait_for_state = kwargs['wait_for_state'] max_wait_seconds = kwargs['max_wait_seconds'] wait_interval_seconds = kwargs['wait_interval_seconds'] setup_notifications = kwargs['setup_notifications'] # Copied from the generated file because the result of the create is required to setup notifications if isinstance(id, six.string_types) and len(id.strip()) == 0: raise click.UsageError( 'Parameter --id cannot be whitespace or empty string') kwargs = {} details = {} if customer_shipping_address is not None: details['customerShippingAddress'] = cli_util.parse_json_parameter( "customer_shipping_address", customer_shipping_address) client = cli_util.build_client('dts', 'transfer_appliance', ctx) result = client.create_transfer_appliance( id=id, create_transfer_appliance_details=details, **kwargs) if wait_for_state: if hasattr(client, 'get_transfer_appliance') and callable( getattr(client, 'get_transfer_appliance')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the resource has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_transfer_appliance(result.data.id), 'lifecycle_state', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the resource entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for resource to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the resource to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx) if setup_notifications: setup_import_notifications(ctx, result.data.label)
'pyremote' ) # Create a remote peering connection in the local region print('Creating remote peering connection in {}'.format(local_region)) print('=====================================') result = virtual_network_client_local.create_remote_peering_connection( oci.core.models.CreateRemotePeeringConnectionDetails( compartment_id=compartment_id, drg_id=local_vcn_and_drg['drg'].id, display_name='Remote peering connection in local' ) ) remote_peering_connection_in_local_region = oci.wait_until( virtual_network_client_local, virtual_network_client_local.get_remote_peering_connection(result.data.id), 'lifecycle_state', 'AVAILABLE' ).data print(remote_peering_connection_in_local_region) print('\n\n') # Create a remote peering connection in the remote region print('Creating remote peering connection in {}'.format(remote_region)) print('=====================================') result = virtual_network_client_remote.create_remote_peering_connection( oci.core.models.CreateRemotePeeringConnectionDetails( compartment_id=compartment_id, drg_id=remote_vcn_and_drg['drg'].id, display_name='Remote peering connection in remote' ) )
def update_http_redirect(ctx, from_json, force, wait_for_state, max_wait_seconds, wait_interval_seconds, http_redirect_id, display_name, target, response_code, freeform_tags, defined_tags, if_match): if isinstance(http_redirect_id, six.string_types) and len( http_redirect_id.strip()) == 0: raise click.UsageError( 'Parameter --http-redirect-id cannot be whitespace or empty string' ) if not force: if target or freeform_tags or defined_tags: if not click.confirm( "WARNING: Updates to target and freeform-tags and defined-tags will replace any existing values. Are you sure you want to continue?" ): ctx.abort() kwargs = {} if if_match is not None: kwargs['if_match'] = if_match kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) _details = {} if display_name is not None: _details['displayName'] = display_name if target is not None: _details['target'] = cli_util.parse_json_parameter("target", target) if response_code is not None: _details['responseCode'] = response_code if freeform_tags is not None: _details['freeformTags'] = cli_util.parse_json_parameter( "freeform_tags", freeform_tags) if defined_tags is not None: _details['definedTags'] = cli_util.parse_json_parameter( "defined_tags", defined_tags) client = cli_util.build_client('waas', 'redirect', ctx) result = client.update_http_redirect(http_redirect_id=http_redirect_id, update_http_redirect_details=_details, **kwargs) if wait_for_state: if hasattr(client, 'get_work_request') and callable( getattr(client, 'get_work_request')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the work request has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_work_request( result.headers['opc-work-request-id']), 'status', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the work request entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for work request to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the work request to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def create_http_redirect(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, compartment_id, domain, target, display_name, response_code, freeform_tags, defined_tags): kwargs = {} kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) _details = {} _details['compartmentId'] = compartment_id _details['domain'] = domain _details['target'] = cli_util.parse_json_parameter("target", target) if display_name is not None: _details['displayName'] = display_name if response_code is not None: _details['responseCode'] = response_code if freeform_tags is not None: _details['freeformTags'] = cli_util.parse_json_parameter( "freeform_tags", freeform_tags) if defined_tags is not None: _details['definedTags'] = cli_util.parse_json_parameter( "defined_tags", defined_tags) client = cli_util.build_client('waas', 'redirect', ctx) result = client.create_http_redirect(create_http_redirect_details=_details, **kwargs) if wait_for_state: if hasattr(client, 'get_work_request') and callable( getattr(client, 'get_work_request')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the work request has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_work_request( result.headers['opc-work-request-id']), 'status', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the work request entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for work request to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the work request to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def handle_create_volume(block_storage_client, module): create_volume_details = CreateVolumeDetails() for attribute in create_volume_details.attribute_map.keys(): if attribute in module.params: setattr(create_volume_details, attribute, module.params[attribute]) if module.params["source_details"]: source_details = module.params["source_details"] volume_source = None if "type" in source_details: if source_details["type"] == "volume": volume_source = VolumeSourceFromVolumeDetails() volume_source.id = source_details.get("id") elif source_details["type"] == "volumeBackup": volume_source = VolumeSourceFromVolumeBackupDetails() volume_source.id = source_details.get("id") else: module.fail_json( msg="value of state must be one of: volume, volumeBackup" ) else: module.fail_json(msg="missing required arguments: type") create_volume_details.source_details = volume_source result = oci_utils.create_and_wait( resource_type="volume", create_fn=block_storage_client.create_volume, kwargs_create={"create_volume_details": create_volume_details}, client=block_storage_client, get_fn=block_storage_client.get_volume, get_param="volume_id", module=module, ) wait_for_copy = False copy_timeout = 1800 WAIT_FOR_INITIALIZATION = "wait_for_copy" INITIALIZATION_TIMEOUT = "copy_timeout" if create_volume_details.source_details is not None: if WAIT_FOR_INITIALIZATION in source_details: wait_for_copy = source_details[WAIT_FOR_INITIALIZATION] if INITIALIZATION_TIMEOUT in source_details: copy_timeout = source_details[INITIALIZATION_TIMEOUT] try: response = oci_utils.call_with_backoff( block_storage_client.get_volume, volume_id=result["volume"]["id"] ) if wait_for_copy: result["volume"] = to_dict( oci.wait_until( block_storage_client, response, "is_hydrated", True, max_wait_seconds=copy_timeout, ).data ) except ServiceError as ex: module.fail_json(msg=ex.message) except MaximumWaitTimeExceeded as ex: module.fail_json(msg=str(ex)) return result
def vcn_and_subnets(network_client): from tests import util with test_config_container.create_vcr().use_cassette( '_conftest_fixture_vcn_and_subnets.yml'): # create VCN vcn_name = util.random_name('cli_lb_test_vcn') cidr_block = "10.0.0.0/16" vcn_dns_label = util.random_name('vcn', insert_underscore=False) create_vcn_details = oci.core.models.CreateVcnDetails() create_vcn_details.cidr_block = cidr_block create_vcn_details.display_name = vcn_name create_vcn_details.compartment_id = os.environ[ 'OCI_CLI_COMPARTMENT_ID'] create_vcn_details.dns_label = vcn_dns_label result = network_client.create_vcn(create_vcn_details) vcn_ocid = result.data.id assert result.status == 200 oci.wait_until(network_client, network_client.get_vcn(vcn_ocid), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300, max_interval_seconds=WAIT_INTERVAL_SECONDS) # create subnet in first AD subnet_name = util.random_name('cli_lb_test_subnet') cidr_block = "10.0.1.0/24" subnet_dns_label = util.random_name('subnet', insert_underscore=False) create_subnet_details = oci.core.models.CreateSubnetDetails() create_subnet_details.compartment_id = os.environ[ 'OCI_CLI_COMPARTMENT_ID'] create_subnet_details.availability_domain = util.availability_domain() create_subnet_details.display_name = subnet_name create_subnet_details.vcn_id = vcn_ocid create_subnet_details.cidr_block = cidr_block create_subnet_details.dns_label = subnet_dns_label result = network_client.create_subnet(create_subnet_details) subnet_ocid_1 = result.data.id assert result.status == 200 oci.wait_until(network_client, network_client.get_subnet(subnet_ocid_1), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300, max_interval_seconds=WAIT_INTERVAL_SECONDS) # create subnet in second AD subnet_name = util.random_name('cli_lb_test_subnet') cidr_block = "10.0.0.0/24" subnet_dns_label = util.random_name('subnet2', insert_underscore=False) create_subnet_details = oci.core.models.CreateSubnetDetails() create_subnet_details.compartment_id = os.environ[ 'OCI_CLI_COMPARTMENT_ID'] create_subnet_details.availability_domain = util.second_availability_domain( ) create_subnet_details.display_name = subnet_name create_subnet_details.vcn_id = vcn_ocid create_subnet_details.cidr_block = cidr_block create_subnet_details.dns_label = subnet_dns_label result = network_client.create_subnet(create_subnet_details) subnet_ocid_2 = result.data.id assert result.status == 200 oci.wait_until(network_client, network_client.get_subnet(subnet_ocid_2), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300, max_interval_seconds=WAIT_INTERVAL_SECONDS) yield [vcn_ocid, subnet_ocid_1, subnet_ocid_2] # For some reason VCR doesn't like that the post-yield stuff here is all in one cassette. Splitting into different cassettes seems to work with test_config_container.create_vcr().use_cassette( '_conftest_fixture_vcn_and_subnets_delete.yml'): # delete VCN and subnets network_client.delete_subnet(subnet_ocid_1) try: oci.wait_until(network_client, network_client.get_subnet(subnet_ocid_1), 'lifecycle_state', 'TERMINATED', max_wait_seconds=600, max_interval_seconds=WAIT_INTERVAL_SECONDS) except oci.exceptions.ServiceError as error: if not hasattr(error, 'status') or error.status != 404: util.print_latest_exception(error) network_client.delete_subnet(subnet_ocid_2) try: oci.wait_until(network_client, network_client.get_subnet(subnet_ocid_2), 'lifecycle_state', 'TERMINATED', max_wait_seconds=600, max_interval_seconds=WAIT_INTERVAL_SECONDS) except oci.exceptions.ServiceError as error: if not hasattr(error, 'status') or error.status != 404: util.print_latest_exception(error) network_client.delete_vcn(vcn_ocid)
def start_instance(instance_id, instance_name, compute_client, wait): print("===============================\nStarting Instance %s\n===============================\n" %(instance_name)) compute_client.instance_action(instance_id, "START") if wait: oci.wait_until(compute_client, compute_client.get_instance(instance_id), 'lifecycle_state', 'RUNNING') print("Instance Started:\n%s, %s\n\n" % (instance_name, instance_id))
def change_oce_instance_compartment(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, oce_instance_id, compartment_id, if_match): if isinstance(oce_instance_id, six.string_types) and len( oce_instance_id.strip()) == 0: raise click.UsageError( 'Parameter --oce-instance-id cannot be whitespace or empty string') kwargs = {} if if_match is not None: kwargs['if_match'] = if_match kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) _details = {} _details['compartmentId'] = compartment_id client = cli_util.build_client('oce', 'oce_instance', ctx) result = client.change_oce_instance_compartment( oce_instance_id=oce_instance_id, change_oce_instance_compartment_details=_details, **kwargs) if wait_for_state: if hasattr(client, 'get_work_request') and callable( getattr(client, 'get_work_request')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the work request has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_work_request( result.headers['opc-work-request-id']), 'status', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the work request entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for work request to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the work request to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
display_name='Python SDK tagging example VCN', dns_label='vcn{}'.format(random.randint(0, 1000000)), freeform_tags={ 'free': 'form', 'another': 'item' }, defined_tags={ tag_namespace.name: { tag_one_name: 'hello', tag_two_name: 'world' } })) vcn_id = create_vcn_response.data.id vcn_after_wait_response = oci.wait_until( virtual_network, virtual_network.get_vcn(vcn_id), 'lifecycle_state', 'AVAILABLE', max_wait_seconds=300) print('Created VCN with tags: {}'.format(vcn_after_wait_response.data)) break except oci.exceptions.ServiceError as e: if e.status == 404: print('Retrying on 404: {}'.format(e)) num_tries += 1 if num_tries >= 3: # If we can't get it in 3 tries, something else may be going on raise else: time.sleep(2) else: raise
def create_oce_instance(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, compartment_id, name, tenancy_id, idcs_access_token, tenancy_name, object_storage_namespace, admin_email, description, identity_stripe, instance_usage_type, upgrade_schedule, waf_primary_domain, instance_access_type, instance_license_type, freeform_tags, defined_tags): kwargs = {} kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) _details = {} _details['compartmentId'] = compartment_id _details['name'] = name _details['tenancyId'] = tenancy_id _details['idcsAccessToken'] = idcs_access_token _details['tenancyName'] = tenancy_name _details['objectStorageNamespace'] = object_storage_namespace _details['adminEmail'] = admin_email if description is not None: _details['description'] = description if identity_stripe is not None: _details['identityStripe'] = cli_util.parse_json_parameter( "identity_stripe", identity_stripe) if instance_usage_type is not None: _details['instanceUsageType'] = instance_usage_type if upgrade_schedule is not None: _details['upgradeSchedule'] = upgrade_schedule if waf_primary_domain is not None: _details['wafPrimaryDomain'] = waf_primary_domain if instance_access_type is not None: _details['instanceAccessType'] = instance_access_type if instance_license_type is not None: _details['instanceLicenseType'] = instance_license_type if freeform_tags is not None: _details['freeformTags'] = cli_util.parse_json_parameter( "freeform_tags", freeform_tags) if defined_tags is not None: _details['definedTags'] = cli_util.parse_json_parameter( "defined_tags", defined_tags) client = cli_util.build_client('oce', 'oce_instance', ctx) result = client.create_oce_instance(create_oce_instance_details=_details, **kwargs) if wait_for_state: if hasattr(client, 'get_work_request') and callable( getattr(client, 'get_work_request')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the work request has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_work_request( result.headers['opc-work-request-id']), 'status', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the work request entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for work request to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the work request to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def create_transfer_appliance_entitlement(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, compartment_id, display_name, requestor_name, requestor_email, freeform_tags, defined_tags): kwargs = {} kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) details = {} if compartment_id is not None: details['compartmentId'] = compartment_id if display_name is not None: details['displayName'] = display_name if requestor_name is not None: details['requestorName'] = requestor_name if requestor_email is not None: details['requestorEmail'] = requestor_email if freeform_tags is not None: details['freeformTags'] = cli_util.parse_json_parameter( "freeform_tags", freeform_tags) if defined_tags is not None: details['definedTags'] = cli_util.parse_json_parameter( "defined_tags", defined_tags) client = cli_util.build_client('transfer_appliance_entitlement', ctx) result = client.create_transfer_appliance_entitlement( create_transfer_appliance_entitlement_details=details, **kwargs) if wait_for_state: if hasattr(client, 'get_transfer_appliance_entitlement') and callable( getattr(client, 'get_transfer_appliance_entitlement')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the resource has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_transfer_appliance_entitlement(result.data.id), 'lifecycle_state', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the resource entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for resource to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the resource to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def delete_volume(block_storage, volume): block_storage.delete_volume(volume.id) oci.wait_until(block_storage, block_storage.get_volume(volume.id), 'lifecycle_state', 'TERMINATED')
source_config = oci.config.from_file() destination_config = source_config.copy() destination_config["region"] = destination_region source_blockstorage_client = oci.core.BlockstorageClient(source_config) destination_blockstorage_client = oci.core.BlockstorageClient( destination_config) print( 'Copying backup with ID {} from {} to {} using new display name: {} and kms key id: {} \n' .format(source_backup_id, source_config["region"], destination_region, display_name, kms_key_id)) result = source_blockstorage_client.copy_volume_backup( source_backup_id, oci.core.models.CopyVolumeBackupDetails( destination_region=destination_region, display_name=display_name, kms_key_id=kms_key_id)) print('Copy backup response status: {}, copied backup: {}\n'.format( result.status, result.data)) print('Waiting for the copied backup to be in available state...') # query the destination region for the copied' backup's status and wait for it to be available. copied_backup = oci.wait_until( destination_blockstorage_client, destination_blockstorage_client.get_volume_backup(result.data.id), 'lifecycle_state', 'AVAILABLE').data print('Backup successfully copied: {}'.format(copied_backup)) print('Example script done')
print('') print('') paravirtualized_volume_attachment_response = compute_client.attach_volume( oci.core.models.AttachParavirtualizedVolumeDetails( display_name='ParavirtualizedVolAttachment', instance_id=instance.id, volume_id=volume.id, is_pv_encryption_in_transit_enabled=True)) print('Attached paravirtualized volume') print('') # We can wait until the volume have attached oci.wait_until( compute_client, compute_client.get_volume_attachment( paravirtualized_volume_attachment_response.data.id), 'lifecycle_state', 'ATTACHED') # Listing volume attachments is a paginated operation, so we can use the functions in the # oci.pagination module to get them all. We can also supply keyword argument filters - in # this case we are only interested in the volume attachments on our instance volume_attachments = oci.pagination.list_call_get_all_results( compute_client.list_volume_attachments, compartment_id, instance_id=instance.id).data # Note that each element could be a different attachment_type, denoting the different types of volume attachments # there are. # # These are all subclasses of oci.core.models.VolumeAttachment
def create_esxi_host(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, sddc_id, display_name, current_sku, next_sku, compute_availability_domain, failed_esxi_host_id, host_shape_name, host_ocpu_count, capacity_reservation_id, freeform_tags, defined_tags): kwargs = {} kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) _details = {} _details['sddcId'] = sddc_id if display_name is not None: _details['displayName'] = display_name if current_sku is not None: _details['currentSku'] = current_sku if next_sku is not None: _details['nextSku'] = next_sku if compute_availability_domain is not None: _details['computeAvailabilityDomain'] = compute_availability_domain if failed_esxi_host_id is not None: _details['failedEsxiHostId'] = failed_esxi_host_id if host_shape_name is not None: _details['hostShapeName'] = host_shape_name if host_ocpu_count is not None: _details['hostOcpuCount'] = host_ocpu_count if capacity_reservation_id is not None: _details['capacityReservationId'] = capacity_reservation_id if freeform_tags is not None: _details['freeformTags'] = cli_util.parse_json_parameter( "freeform_tags", freeform_tags) if defined_tags is not None: _details['definedTags'] = cli_util.parse_json_parameter( "defined_tags", defined_tags) client = cli_util.build_client('ocvp', 'esxi_host', ctx) result = client.create_esxi_host(create_esxi_host_details=_details, **kwargs) if wait_for_state: if hasattr(client, 'get_work_request') and callable( getattr(client, 'get_work_request')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the work request has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_work_request( result.headers['opc-work-request-id']), 'status', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the work request entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for work request to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the work request to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def update_rover_cluster( ctx, from_json, force, wait_for_state, max_wait_seconds, wait_interval_seconds, rover_cluster_id, display_name, cluster_size, customer_shipping_address, cluster_workloads, super_user_password, lifecycle_state, lifecycle_state_details, unlock_passphrase, enclosure_type, point_of_contact, point_of_contact_phone_number, shipping_preference, oracle_shipping_tracking_url, shipping_vendor, time_pickup_expected, freeform_tags, defined_tags, system_tags, if_match): if isinstance(rover_cluster_id, six.string_types) and len( rover_cluster_id.strip()) == 0: raise click.UsageError( 'Parameter --rover-cluster-id cannot be whitespace or empty string' ) if not force: if customer_shipping_address or cluster_workloads or freeform_tags or defined_tags or system_tags: if not click.confirm( "WARNING: Updates to customer-shipping-address and cluster-workloads and freeform-tags and defined-tags and system-tags will replace any existing values. Are you sure you want to continue?" ): ctx.abort() kwargs = {} if if_match is not None: kwargs['if_match'] = if_match kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) _details = {} if display_name is not None: _details['displayName'] = display_name if cluster_size is not None: _details['clusterSize'] = cluster_size if customer_shipping_address is not None: _details['customerShippingAddress'] = cli_util.parse_json_parameter( "customer_shipping_address", customer_shipping_address) if cluster_workloads is not None: _details['clusterWorkloads'] = cli_util.parse_json_parameter( "cluster_workloads", cluster_workloads) if super_user_password is not None: _details['superUserPassword'] = super_user_password if lifecycle_state is not None: _details['lifecycleState'] = lifecycle_state if lifecycle_state_details is not None: _details['lifecycleStateDetails'] = lifecycle_state_details if unlock_passphrase is not None: _details['unlockPassphrase'] = unlock_passphrase if enclosure_type is not None: _details['enclosureType'] = enclosure_type if point_of_contact is not None: _details['pointOfContact'] = point_of_contact if point_of_contact_phone_number is not None: _details['pointOfContactPhoneNumber'] = point_of_contact_phone_number if shipping_preference is not None: _details['shippingPreference'] = shipping_preference if oracle_shipping_tracking_url is not None: _details['oracleShippingTrackingUrl'] = oracle_shipping_tracking_url if shipping_vendor is not None: _details['shippingVendor'] = shipping_vendor if time_pickup_expected is not None: _details['timePickupExpected'] = time_pickup_expected if freeform_tags is not None: _details['freeformTags'] = cli_util.parse_json_parameter( "freeform_tags", freeform_tags) if defined_tags is not None: _details['definedTags'] = cli_util.parse_json_parameter( "defined_tags", defined_tags) if system_tags is not None: _details['systemTags'] = cli_util.parse_json_parameter( "system_tags", system_tags) client = cli_util.build_client('rover', 'rover_cluster', ctx) result = client.update_rover_cluster(rover_cluster_id=rover_cluster_id, update_rover_cluster_details=_details, **kwargs) if wait_for_state: if hasattr(client, 'get_rover_cluster') and callable( getattr(client, 'get_rover_cluster')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the resource has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_rover_cluster(result.data.id), 'lifecycle_state', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the resource entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for resource to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the resource to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def do_wait(client, *args, **kwargs): if vcr_mode == 'none': kwargs['max_interval_seconds'] = 0 oci.wait_until(client, *args, **kwargs)
def delete_rover_cluster(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, rover_cluster_id, if_match): if isinstance(rover_cluster_id, six.string_types) and len( rover_cluster_id.strip()) == 0: raise click.UsageError( 'Parameter --rover-cluster-id cannot be whitespace or empty string' ) kwargs = {} if if_match is not None: kwargs['if_match'] = if_match kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) client = cli_util.build_client('rover', 'rover_cluster', ctx) result = client.delete_rover_cluster(rover_cluster_id=rover_cluster_id, **kwargs) if wait_for_state: if hasattr(client, 'get_rover_cluster') and callable( getattr(client, 'get_rover_cluster')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the resource has entered state: {}' .format(wait_for_state), file=sys.stderr) oci.wait_until(client, client.get_rover_cluster(rover_cluster_id), 'lifecycle_state', wait_for_state, succeed_on_not_found=True, **wait_period_kwargs) except oci.exceptions.ServiceError as e: # We make an initial service call so we can pass the result to oci.wait_until(), however if we are waiting on the # outcome of a delete operation it is possible that the resource is already gone and so the initial service call # will result in an exception that reflects a HTTP 404. In this case, we can exit with success (rather than raising # the exception) since this would have been the behaviour in the waiter anyway (as for delete we provide the argument # succeed_on_not_found=True to the waiter). # # Any non-404 should still result in the exception being thrown. if e.status == 404: pass else: raise except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the resource entered the specified state. Please retrieve the resource to find its current state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for resource to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the resource to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def create_alert_rule(ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, budget_id, type, threshold, threshold_type, recipients, display_name, description, message, freeform_tags, defined_tags): if isinstance(budget_id, six.string_types) and len(budget_id.strip()) == 0: raise click.UsageError( 'Parameter --budget-id cannot be whitespace or empty string') kwargs = {} kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) details = {} details['type'] = type details['threshold'] = threshold details['thresholdType'] = threshold_type details['recipients'] = recipients if display_name is not None: details['displayName'] = display_name if description is not None: details['description'] = description if message is not None: details['message'] = message if freeform_tags is not None: details['freeformTags'] = cli_util.parse_json_parameter( "freeform_tags", freeform_tags) if defined_tags is not None: details['definedTags'] = cli_util.parse_json_parameter( "defined_tags", defined_tags) client = cli_util.build_client('budget', ctx) result = client.create_alert_rule(budget_id=budget_id, create_alert_rule_details=details, **kwargs) if wait_for_state: if hasattr(client, 'get_alert_rule') and callable( getattr(client, 'get_alert_rule')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the resource has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until(client, client.get_alert_rule(result.data.id), 'lifecycle_state', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the resource entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for resource to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the resource to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def create_rover_cluster( ctx, from_json, wait_for_state, max_wait_seconds, wait_interval_seconds, display_name, compartment_id, cluster_size, customer_shipping_address, cluster_workloads, super_user_password, enclosure_type, unlock_passphrase, point_of_contact, point_of_contact_phone_number, shipping_preference, shipping_vendor, time_pickup_expected, oracle_shipping_tracking_url, lifecycle_state, lifecycle_state_details, freeform_tags, defined_tags, system_tags): kwargs = {} kwargs['opc_request_id'] = cli_util.use_or_generate_request_id( ctx.obj['request_id']) _details = {} _details['displayName'] = display_name _details['compartmentId'] = compartment_id _details['clusterSize'] = cluster_size if customer_shipping_address is not None: _details['customerShippingAddress'] = cli_util.parse_json_parameter( "customer_shipping_address", customer_shipping_address) if cluster_workloads is not None: _details['clusterWorkloads'] = cli_util.parse_json_parameter( "cluster_workloads", cluster_workloads) if super_user_password is not None: _details['superUserPassword'] = super_user_password if enclosure_type is not None: _details['enclosureType'] = enclosure_type if unlock_passphrase is not None: _details['unlockPassphrase'] = unlock_passphrase if point_of_contact is not None: _details['pointOfContact'] = point_of_contact if point_of_contact_phone_number is not None: _details['pointOfContactPhoneNumber'] = point_of_contact_phone_number if shipping_preference is not None: _details['shippingPreference'] = shipping_preference if shipping_vendor is not None: _details['shippingVendor'] = shipping_vendor if time_pickup_expected is not None: _details['timePickupExpected'] = time_pickup_expected if oracle_shipping_tracking_url is not None: _details['oracleShippingTrackingUrl'] = oracle_shipping_tracking_url if lifecycle_state is not None: _details['lifecycleState'] = lifecycle_state if lifecycle_state_details is not None: _details['lifecycleStateDetails'] = lifecycle_state_details if freeform_tags is not None: _details['freeformTags'] = cli_util.parse_json_parameter( "freeform_tags", freeform_tags) if defined_tags is not None: _details['definedTags'] = cli_util.parse_json_parameter( "defined_tags", defined_tags) if system_tags is not None: _details['systemTags'] = cli_util.parse_json_parameter( "system_tags", system_tags) client = cli_util.build_client('rover', 'rover_cluster', ctx) result = client.create_rover_cluster(create_rover_cluster_details=_details, **kwargs) if wait_for_state: if hasattr(client, 'get_rover_cluster') and callable( getattr(client, 'get_rover_cluster')): try: wait_period_kwargs = {} if max_wait_seconds is not None: wait_period_kwargs['max_wait_seconds'] = max_wait_seconds if wait_interval_seconds is not None: wait_period_kwargs[ 'max_interval_seconds'] = wait_interval_seconds click.echo( 'Action completed. Waiting until the resource has entered state: {}' .format(wait_for_state), file=sys.stderr) result = oci.wait_until( client, client.get_rover_cluster(result.data.id), 'lifecycle_state', wait_for_state, **wait_period_kwargs) except oci.exceptions.MaximumWaitTimeExceeded as e: # If we fail, we should show an error, but we should still provide the information to the customer click.echo( 'Failed to wait until the resource entered the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) sys.exit(2) except Exception: click.echo( 'Encountered error while waiting for resource to enter the specified state. Outputting last known resource state', file=sys.stderr) cli_util.render_response(result, ctx) raise else: click.echo( 'Unable to wait for the resource to enter the specified state', file=sys.stderr) cli_util.render_response(result, ctx)
def power_action_on_instance_pool(compute_management_client, module): result = {} changed = False # The power action to execute on a compute instance pool to reach the desired 'state' state_action_map = { "stopped": "STOP", "running": "START", "reset": "RESET", "softreset": "SOFTRESET", } # The desired lifecycle state for the compute instance pool to reach the user specified 'state' desired_lifecycle_states = { "stopped": "STOPPED", "running": "RUNNING", "reset": "RUNNING", "softreset": "RUNNING", } desired_state = module.params["state"] instance_pool_id = module.params["id"] try: response = oci_utils.call_with_backoff( compute_management_client.get_instance_pool, instance_pool_id=instance_pool_id, ) curr_state = response.data.lifecycle_state change_required = False # We need to perform a power action if the current state doesn't match the desired state if curr_state != desired_lifecycle_states[desired_state]: change_required = True # Resets also require a change if desired_state in ["softreset", "reset"]: change_required = True if change_required: changed = True instance_action_method_name = ( state_action_map[desired_state].lower() + "_instance_pool") instance_action_method = getattr(compute_management_client, instance_action_method_name) oci_utils.call_with_backoff(instance_action_method, instance_pool_id=instance_pool_id) response = oci_utils.call_with_backoff( compute_management_client.get_instance_pool, instance_pool_id=instance_pool_id, ) # for now the power actions on instances do not go through common utilities for wait. if module.params.get("wait", None): debug("waiting for lifecycle_state to reach {0}".format( desired_lifecycle_states[desired_state])) oci.wait_until( compute_management_client, response, "lifecycle_state", desired_lifecycle_states[desired_state], max_wait_seconds=module.params.get( "wait_timeout", oci_utils.MAX_WAIT_TIMEOUT_IN_SECONDS), ) response = oci_utils.call_with_backoff( compute_management_client.get_instance_pool, instance_pool_id=instance_pool_id, ) else: debug( "Not waiting for power action request {0} as 'wait' is false." .format(desired_state)) result["instance_pool"] = to_dict(response.data) except ServiceError as ex: module.fail_json(msg=ex.message) except MaximumWaitTimeExceeded as ex: module.fail_json(msg=str(ex)) result["changed"] = changed return result
# The first argument is the name of the script, so start the index at 1 compartment_id = sys.argv[1] target_compartment_id = sys.argv[2] sender_address = sys.argv[3] suppression_address = sys.argv[4] create_sender_response = email_client.create_sender( oci.email.models.CreateSenderDetails(compartment_id=compartment_id, email_address=sender_address)) print('Created sender:\n{}'.format(create_sender_response.data)) print('\n=========================\n') # A sender has a lifecycle state, so we can wait for it to become available get_sender_response = oci.wait_until( email_client, email_client.get_sender(create_sender_response.data.id), 'lifecycle_state', 'ACTIVE') print('Waited for sender to become available:\n{}'.format( get_sender_response.data)) print('\n=========================\n') # change sender compartment change_sender_response = email_client.change_sender_compartment( create_sender_response.data.id, oci.email.models.ChangeSenderCompartmentDetails( compartment_id=target_compartment_id)) print('Moved sender:\n{}'.format(create_sender_response.data.id)) print('\n=========================\n') # We can list all senders, and also provide optional filters and sorts. Here we'll list all # senders sorted by their email address, and also demonstrate filtering by sender email
def stop_instance(instance_id, instance_name, compute_client, wait): print("===============================\nStopping Instance %s\n===============================\n" %(instance_name)) compute_client.instance_action(instance_id, "STOP") if wait: oci.wait_until(compute_client, compute_client.get_instance(instance_id), 'lifecycle_state', 'STOPPED') print("Instance Stopped:\n%s, %s\n\n" % (instance_name, instance_id))
def detach_volume(compute, volume_attachment): compute.detach_volume(volume_attachment.id) oci.wait_until(compute, compute.get_volume_attachment(volume_attachment.id), 'lifecycle_state', 'DETACHED')