create_integration_resource_property async ¶

async def create_integration_resource_property(
    self,
    resource_arn: "capo_glue.types.string512.String512",
    *,
    config_overrides: Optional[AsyncGlueClientConfig] = None,
    source_processing_properties: Optional[
        "capo_glue.types.source_processing_properties.SourceProcessingProperties"
    ] = None,
    target_processing_properties: Optional[
        "capo_glue.types.target_processing_properties.TargetProcessingProperties"
    ] = None,
    tags: Optional[
        "capo_glue.types.integration_tags_list.IntegrationTagsList"
    ] = None,
) -> "capo_glue.types.create_integration_resource_property_response.CreateIntegrationResourcePropertyResponse":
    """<p>This API can be used for setting up the <code>ResourceProperty</code> of the Glue connection (for the source) or Glue database ARN (for the target). These properties can include the role to access the connection or database. To set both source and target properties the same API needs to be invoked with the Glue connection ARN as <code>ResourceArn</code> with <code>SourceProcessingProperties</code> and the Glue database ARN as <code>ResourceArn</code> with <code>TargetProcessingProperties</code> respectively.</p>

    Args:
        resource_arn: <p>The connection ARN of the source, or the database ARN of the target.</p>
        source_processing_properties: <p>The resource properties associated with the integration source.</p>
        target_processing_properties: <p>The resource properties associated with the integration target.</p>
        tags: <p>Metadata assigned to the resource consisting of a list of key-value pairs.</p>

    Raises:
        capo_glue.errors.access_denied_exception.AccessDeniedException: <p>Access to a resource was denied.</p>
        capo_glue.errors.conflict_exception.ConflictException: <p>The <code>CreatePartitions</code> API was called on a table that has indexes enabled. </p>
        capo_glue.errors.entity_not_found_exception.EntityNotFoundException: <p>A specified entity does not exist</p>
        capo_glue.errors.internal_server_exception.InternalServerException: <p>An internal server error occurred.</p>
        capo_glue.errors.internal_service_exception.InternalServiceException: <p>An internal service error occurred.</p>
        capo_glue.errors.invalid_input_exception.InvalidInputException: <p>The input provided was not valid.</p>
        capo_glue.errors.resource_not_found_exception.ResourceNotFoundException: <p>The resource could not be found.</p>
        capo_glue.errors.validation_exception.ValidationException: <p>A value could not be validated.</p>
        capo_glue.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_glue.types.create_integration_resource_property_request.CreateIntegrationResourcePropertyRequest]",
    ) -> AsyncOperationResponse[
        "capo_glue.types.create_integration_resource_property_response.CreateIntegrationResourcePropertyResponse"
    ]:
        import capo_glue._operations.aws_glue.create_integration_resource_property

        (
            output,
            http_response,
        ) = await capo_glue._operations.aws_glue.create_integration_resource_property.async_create_integration_resource_property(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("CreateIntegrationResourceProperty")
    )
    input_: capo_glue.types.create_integration_resource_property_request.CreateIntegrationResourcePropertyRequest = {
        "resource_arn": resource_arn
    }
    if source_processing_properties is not None:
        input_["source_processing_properties"] = source_processing_properties
    if target_processing_properties is not None:
        input_["target_processing_properties"] = target_processing_properties
    if tags is not None:
        input_["tags"] = tags

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