Skip to content

describe_stream_storage_configuration async

describe_stream_storage_configuration(
    *,
    config_overrides: Optional[AsyncKinesisVideoClientConfig] = None,
    stream_name: Optional[StreamName] = None,
    stream_arn: Optional[ResourceARN] = None,
) -> DescribeStreamStorageConfigurationOutput

Retrieves the current storage configuration for the specified Kinesis video stream.

In the request, you must specify either the StreamName or the StreamARN.

You must have permissions for the KinesisVideo:DescribeStreamStorageConfiguration action.

Parameters:

  • stream_name (Optional[StreamName], default: None ) –

    The name of the stream for which you want to retrieve the storage configuration.

  • stream_arn (Optional[ResourceARN], default: None ) –

    The Amazon Resource Name (ARN) of the stream for which you want to retrieve the storage configuration.

Raises:

Source code in docs_src/capo_kinesis_video/_services/async_kinesis_video.py
async def describe_stream_storage_configuration(
    self,
    *,
    config_overrides: Optional[AsyncKinesisVideoClientConfig] = None,
    stream_name: Optional["capo_kinesis_video.types.stream_name.StreamName"] = None,
    stream_arn: Optional[
        "capo_kinesis_video.types.resource_arn.ResourceARN"
    ] = None,
) -> "capo_kinesis_video.types.describe_stream_storage_configuration_output.DescribeStreamStorageConfigurationOutput":
    """<p>Retrieves the current storage configuration for the specified Kinesis video stream.</p> <p>In the request, you must specify either the <code>StreamName</code> or the <code>StreamARN</code>.</p> <p>You must have permissions for the <code>KinesisVideo:DescribeStreamStorageConfiguration</code> action.</p>

    Args:
        stream_name: <p>The name of the stream for which you want to retrieve the storage configuration.</p>
        stream_arn: <p>The Amazon Resource Name (ARN) of the stream for which you want to retrieve the storage configuration.</p>

    Raises:
        capo_kinesis_video.errors.access_denied_exception.AccessDeniedException: <p>You do not have required permissions to perform this operation.</p>
        capo_kinesis_video.errors.client_limit_exceeded_exception.ClientLimitExceededException: <p>Kinesis Video Streams has throttled the request because you have exceeded the limit of allowed client calls. Try making the call later.</p>
        capo_kinesis_video.errors.invalid_argument_exception.InvalidArgumentException: <p>The value for this input parameter is invalid.</p>
        capo_kinesis_video.errors.resource_not_found_exception.ResourceNotFoundException: <p>Amazon Kinesis Video Streams can't find the stream that you specified.</p>
        capo_kinesis_video.errors.UnknownServiceError: The service returned an error code this client does not model.
    """

    async def _handler(
        req: "AsyncOperationRequest[capo_kinesis_video.types.describe_stream_storage_configuration_input.DescribeStreamStorageConfigurationInput]",
    ) -> AsyncOperationResponse[
        "capo_kinesis_video.types.describe_stream_storage_configuration_output.DescribeStreamStorageConfigurationOutput"
    ]:
        import capo_kinesis_video._operations.kinesis_video_20170930.describe_stream_storage_configuration

        (
            output,
            http_response,
        ) = await capo_kinesis_video._operations.kinesis_video_20170930.describe_stream_storage_configuration.async_describe_stream_storage_configuration(
            req.options, req.input
        )
        return AsyncOperationResponse(output=output, response=http_response)

    interceptors_, options_ = self.operation_options(
        config_overrides, OperationLogging("DescribeStreamStorageConfiguration")
    )
    input_: capo_kinesis_video.types.describe_stream_storage_configuration_input.DescribeStreamStorageConfigurationInput = {}
    if stream_name is not None:
        input_["stream_name"] = stream_name
    if stream_arn is not None:
        input_["stream_arn"] = stream_arn

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