create_exascale_db_storage_vault async ¶

async def create_exascale_db_storage_vault(
    self,
    display_name: "capo_odb.types.resource_display_name.ResourceDisplayName",
    high_capacity_database_storage_total_size_in_g_bs: int,
    *,
    config_overrides: Optional[AsyncodbClientConfig] = None,
    additional_flash_cache_in_percent: Optional[int] = None,
    autoscale_limit_in_g_bs: Optional[int] = None,
    availability_zone_id: Optional[str] = None,
    availability_zone: Optional[str] = None,
    description: Optional[str] = None,
    is_autoscale_enabled: Optional[bool] = None,
    tags: Optional["capo_odb.types.request_tag_map.RequestTagMap"] = None,
    time_zone: Optional[str] = None,
    client_token: Optional[
        "capo_odb.types.general_input_string.GeneralInputString"
    ] = None,
) -> "capo_odb.types.create_exascale_db_storage_vault_output.CreateExascaleDbStorageVaultOutput":
    """<p>Creates an Exascale storage vault.</p>

    Args:
        display_name: <p>A user-friendly name for the Exascale storage vault.</p>
        high_capacity_database_storage_total_size_in_g_bs: <p>The total size of the high-capacity database storage, in gigabytes (GB), for the Exascale storage vault.</p>
        additional_flash_cache_in_percent: <p>The additional flash cache percentage for the Exascale storage vault.</p>
        autoscale_limit_in_g_bs: <p>The autoscale limit in gigabytes (GB) for the Exascale storage vault.</p>
        availability_zone_id: <p>The Availability Zone ID for the Exascale storage vault.</p>
        availability_zone: <p>The Availability Zone for the Exascale storage vault.</p>
        description: <p>A description of the Exascale storage vault.</p>
        is_autoscale_enabled: <p>Specifies whether autoscaling is enabled for the Exascale storage vault.</p>
        tags: <p>The list of resource tags to apply to the Exascale storage vault.</p>
        time_zone: <p>The time zone for the Exascale storage vault.</p>
        client_token: <p>A unique, case-sensitive identifier that you provide to ensure that the operation completes no more than one time. If you submit the same request twice with the same client token, the service ignores the second request and returns the result of the first. If you don't specify a client token, the AWS SDK automatically generates one. The client token is valid for up to 24 hours after it's first used.</p>

    Raises:
        capo_odb.errors.access_denied_exception.AccessDeniedException: <p>You don't have sufficient access to perform this action. Make sure you have the required permissions and try again.</p>
        capo_odb.errors.conflict_exception.ConflictException: <p>Occurs when a conflict with the current status of your resource. Fix any inconsistencies with your resource and try again.</p>
        capo_odb.errors.internal_server_exception.InternalServerException: <p>Occurs when there is an internal failure in the Oracle Database@Amazon Web Services service. Wait and try again.</p>
        capo_odb.errors.service_quota_exceeded_exception.ServiceQuotaExceededException: <p>You have exceeded the service quota.</p>
        capo_odb.errors.throttling_exception.ThrottlingException: <p>The request was denied due to request throttling.</p>
        capo_odb.errors.validation_exception.ValidationException: <p>The request has failed validation because it is missing required fields or has invalid inputs.</p>
        capo_odb.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_odb.types.create_exascale_db_storage_vault_input.CreateExascaleDbStorageVaultInput]",
    ) -> AsyncOperationResponse[
        "capo_odb.types.create_exascale_db_storage_vault_output.CreateExascaleDbStorageVaultOutput"
    ]:
        import capo_odb._operations.odb.create_exascale_db_storage_vault

        (
            output,
            http_response,
        ) = await capo_odb._operations.odb.create_exascale_db_storage_vault.async_create_exascale_db_storage_vault(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateExascaleDbStorageVault")
    )
    input_: capo_odb.types.create_exascale_db_storage_vault_input.CreateExascaleDbStorageVaultInput = {
        "display_name": display_name,
        "high_capacity_database_storage_total_size_in_g_bs": high_capacity_database_storage_total_size_in_g_bs,
    }
    if additional_flash_cache_in_percent is not None:
        input_["additional_flash_cache_in_percent"] = (
            additional_flash_cache_in_percent
        )
    if autoscale_limit_in_g_bs is not None:
        input_["autoscale_limit_in_g_bs"] = autoscale_limit_in_g_bs
    if availability_zone_id is not None:
        input_["availability_zone_id"] = availability_zone_id
    if availability_zone is not None:
        input_["availability_zone"] = availability_zone
    if description is not None:
        input_["description"] = description
    if is_autoscale_enabled is not None:
        input_["is_autoscale_enabled"] = is_autoscale_enabled
    if tags is not None:
        input_["tags"] = tags
    if time_zone is not None:
        input_["time_zone"] = time_zone
    if client_token is None:
        client_token = str(uuid.uuid4())
    input_["client_token"] = client_token

    response = await aexecute_pipeline(
        AsyncOperationRequest(input=input_, options=options_),
        handler=_handler,
        interceptors=list(interceptors_),
    )
    await response.response.aclose()
    return response.output