Class: Aws::KinesisVideo::Client

Inherits:
Seahorse::Client::Base
  • Object
show all
Includes:
ClientStubs
Defined in:
lib/aws-sdk-kinesisvideo/client.rb

Overview

An API client for KinesisVideo. To construct a client, you need to configure a ‘:region` and `:credentials`.

client = Aws::KinesisVideo::Client.new(
  region: region_name,
  credentials: credentials,
  # ...
)

For details on configuring region and credentials see the [developer guide](/sdk-for-ruby/v3/developer-guide/setup-config.html).

See #initialize for a full list of supported configuration options.

Class Attribute Summary collapse

API Operations collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Client

Returns a new instance of Client.

Parameters:

  • options (Hash)

Options Hash (options):

  • :plugins (Array<Seahorse::Client::Plugin>) — default: []] —

    A list of plugins to apply to the client. Each plugin is either a class name or an instance of a plugin class.

  • :credentials (required, Aws::CredentialProvider) —

    Your AWS credentials. This can be an instance of any one of the following classes:

    • ‘Aws::Credentials` - Used for configuring static, non-refreshing credentials.

    • ‘Aws::SharedCredentials` - Used for loading static credentials from a shared file, such as `~/.aws/config`.

    • ‘Aws::AssumeRoleCredentials` - Used when you need to assume a role.

    • ‘Aws::AssumeRoleWebIdentityCredentials` - Used when you need to assume a role after providing credentials via the web.

    • ‘Aws::SSOCredentials` - Used for loading credentials from AWS SSO using an access token generated from `aws login`.

    • ‘Aws::ProcessCredentials` - Used for loading credentials from a process that outputs to stdout.

    • ‘Aws::InstanceProfileCredentials` - Used for loading credentials from an EC2 IMDS on an EC2 instance.

    • ‘Aws::ECSCredentials` - Used for loading credentials from instances running in ECS.

    • ‘Aws::CognitoIdentityCredentials` - Used for loading credentials from the Cognito Identity service.

    When ‘:credentials` are not configured directly, the following locations will be searched for credentials:

    • ‘Aws.config`

    • The ‘:access_key_id`, `:secret_access_key`, `:session_token`, and `:account_id` options.

    • ENV, ENV, ENV, and ENV

    • ‘~/.aws/credentials`

    • ‘~/.aws/config`

    • EC2/ECS IMDS instance profile - When used by default, the timeouts are very aggressive. Construct and pass an instance of ‘Aws::InstanceProfileCredentials` or `Aws::ECSCredentials` to enable retries and extended timeouts. Instance profile credential fetching can be disabled by setting ENV to true.

  • :region (required, String) —

    The AWS region to connect to. The configured ‘:region` is used to determine the service `:endpoint`. When not passed, a default `:region` is searched for in the following locations:

  • :access_key_id (String)
  • :account_id (String)
  • :active_endpoint_cache (Boolean) — default: false —

    When set to ‘true`, a thread polling for endpoints will be running in the background every 60 secs (default). Defaults to `false`.

  • :adaptive_retry_wait_to_fill (Boolean) — default: true —

    Used only in ‘adaptive` retry mode. When true, the request will sleep until there is sufficent client side capacity to retry the request. When false, the request will raise a `RetryCapacityNotAvailableError` and will not retry instead of sleeping.

  • :client_side_monitoring (Boolean) — default: false —

    When ‘true`, client-side metrics will be collected for all API requests from this client.

  • :client_side_monitoring_client_id (String) — default: "" —

    Allows you to provide an identifier for this client which will be attached to all generated client side metrics. Defaults to an empty string.

  • :client_side_monitoring_host (String) — default: "127.0.0.1" —

    Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_port (Integer) — default: 31000 —

    Required for publishing client metrics. The port that the client side monitoring agent is running on, where client metrics will be published via UDP.

  • :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher) — default: Aws::ClientSideMonitoring::Publisher —

    Allows you to provide a custom client-side monitoring publisher class. By default, will use the Client Side Monitoring Agent Publisher.

  • :convert_params (Boolean) — default: true —

    When ‘true`, an attempt is made to coerce request parameters into the required types.

  • :correct_clock_skew (Boolean) — default: true —

    Used only in ‘standard` and adaptive retry modes. Specifies whether to apply a clock skew correction and retry requests with skewed client clocks.

  • :defaults_mode (String) — default: "legacy" —

    See DefaultsModeConfiguration for a list of the accepted modes and the configuration defaults that are included.

  • :disable_host_prefix_injection (Boolean) — default: false —

    Set to true to disable SDK automatically adding host prefix to default service endpoint when available.

  • :disable_request_compression (Boolean) — default: false —

    When set to ‘true’ the request body will not be compressed for supported operations.

  • :endpoint (String, URI::HTTPS, URI::HTTP) —

    Normally you should not configure the ‘:endpoint` option directly. This is normally constructed from the `:region` option. Configuring `:endpoint` is normally reserved for connecting to test or custom endpoints. The endpoint should be a URI formatted like:

    'http://example.com'
'https://example.com'
'http://example.com:123'
  • :endpoint_cache_max_entries (Integer) — default: 1000 —

    Used for the maximum size limit of the LRU cache storing endpoints data for endpoint discovery enabled operations. Defaults to 1000.

  • :endpoint_cache_max_threads (Integer) — default: 10 —

    Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.

  • :endpoint_cache_poll_interval (Integer) — default: 60 —

    When :endpoint_discovery and :active_endpoint_cache is enabled, Use this option to config the time interval in seconds for making requests fetching endpoints information. Defaults to 60 sec.

  • :endpoint_discovery (Boolean) — default: false —

    When set to ‘true`, endpoint discovery will be enabled for operations when available.

  • :ignore_configured_endpoint_urls (Boolean) —

    Setting to true disables use of endpoint URLs provided via environment variables and the shared configuration file.

  • :log_formatter (Aws::Log::Formatter) — default: Aws::Log::Formatter.default —

    The log formatter.

  • :log_level (Symbol) — default: :info —

    The log level to send messages to the ‘:logger` at.

  • :logger (Logger) —

    The Logger instance to send log messages to. If this option is not set, logging will be disabled.

  • :max_attempts (Integer) — default: 3 —

    An integer representing the maximum number attempts that will be made for a single request, including the initial attempt. For example, setting this value to 5 will result in a request being retried up to 4 times. Used in ‘standard` and `adaptive` retry modes.

  • :profile (String) — default: "default" —

    Used when loading credentials from the shared credentials file at HOME/.aws/credentials. When not specified, ‘default’ is used.

  • :request_checksum_calculation (String) — default: "when_supported" —

    Determines when a checksum will be calculated for request payloads. Values are:

    • ‘when_supported` - (default) When set, a checksum will be calculated for all request payloads of operations modeled with the `httpChecksum` trait where `requestChecksumRequired` is `true` and/or a `requestAlgorithmMember` is modeled.

    • ‘when_required` - When set, a checksum will only be calculated for request payloads of operations modeled with the `httpChecksum` trait where `requestChecksumRequired` is `true` or where a `requestAlgorithmMember` is modeled and supplied.

  • :request_min_compression_size_bytes (Integer) — default: 10240 —

    The minimum size in bytes that triggers compression for request bodies. The value must be non-negative integer value between 0 and 10485780 bytes inclusive.

  • :response_checksum_validation (String) — default: "when_supported" —

    Determines when checksum validation will be performed on response payloads. Values are:

    • ‘when_supported` - (default) When set, checksum validation is performed on all response payloads of operations modeled with the `httpChecksum` trait where `responseAlgorithms` is modeled, except when no modeled checksum algorithms are supported.

    • ‘when_required` - When set, checksum validation is not performed on response payloads of operations unless the checksum algorithm is supported and the `requestValidationModeMember` member is set to `ENABLED`.

  • :retry_backoff (Proc) —

    A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay. This option is only used in the ‘legacy` retry mode.

  • :retry_base_delay (Float) — default: 0.3 —

    The base delay in seconds used by the default backoff function. This option is only used in the ‘legacy` retry mode.

  • :retry_jitter (Symbol) — default: :none —

    A delay randomiser function used by the default backoff function. Some predefined functions can be referenced by name - :none, :equal, :full, otherwise a Proc that takes and returns a number. This option is only used in the ‘legacy` retry mode.

    @see www.awsarchitectureblog.com/2015/03/backoff.html

  • :retry_limit (Integer) — default: 3 —

    The maximum number of times to retry failed requests. Only ~ 500 level server errors and certain ~ 400 level client errors are retried. Generally, these are throttling errors, data checksum errors, networking errors, timeout errors, auth errors, endpoint discovery, and errors from expired credentials. This option is only used in the ‘legacy` retry mode.

  • :retry_max_delay (Integer) — default: 0 —

    The maximum number of seconds to delay between retries (0 for no limit) used by the default backoff function. This option is only used in the ‘legacy` retry mode.

  • :retry_mode (String) — default: "legacy" —

    Specifies which retry algorithm to use. Values are:

    • ‘legacy` - The pre-existing retry behavior. This is default value if no retry mode is provided.

    • ‘standard` - A standardized set of retry rules across the AWS SDKs. This includes support for retry quotas, which limit the number of unsuccessful retries a client can make.

    • ‘adaptive` - An experimental retry mode that includes all the functionality of `standard` mode along with automatic client side throttling. This is a provisional mode that may change behavior in the future.

  • :sdk_ua_app_id (String) —

    A unique and opaque application ID that is appended to the User-Agent header as app/sdk_ua_app_id. It should have a maximum length of 50. This variable is sourced from environment variable AWS_SDK_UA_APP_ID or the shared config profile attribute sdk_ua_app_id.

  • :secret_access_key (String)
  • :session_token (String)
  • :sigv4a_signing_region_set (Array) —

    A list of regions that should be signed with SigV4a signing. When not passed, a default ‘:sigv4a_signing_region_set` is searched for in the following locations:

  • :stub_responses (Boolean) — default: false —

    Causes the client to return stubbed responses. By default fake responses are generated and returned. You can specify the response data to return or errors to raise by calling ClientStubs#stub_responses. See ClientStubs for more information.

    ** Please note ** When response stubbing is enabled, no HTTP requests are made, and retries are disabled.

  • :telemetry_provider (Aws::Telemetry::TelemetryProviderBase) — default: Aws::Telemetry::NoOpTelemetryProvider —

    Allows you to provide a telemetry provider, which is used to emit telemetry data. By default, uses ‘NoOpTelemetryProvider` which will not record or emit any telemetry data. The SDK supports the following telemetry providers:

    • OpenTelemetry (OTel) - To use the OTel provider, install and require the

    ‘opentelemetry-sdk` gem and then, pass in an instance of a `Aws::Telemetry::OTelProvider` for telemetry provider.

  • :token_provider (Aws::TokenProvider) —

    A Bearer Token Provider. This can be an instance of any one of the following classes:

    • ‘Aws::StaticTokenProvider` - Used for configuring static, non-refreshing tokens.

    • ‘Aws::SSOTokenProvider` - Used for loading tokens from AWS SSO using an access token generated from `aws login`.

    When ‘:token_provider` is not configured directly, the `Aws::TokenProviderChain` will be used to search for tokens configured for your profile in shared configuration files.

  • :use_dualstack_endpoint (Boolean) —

    When set to ‘true`, dualstack enabled endpoints (with `.aws` TLD) will be used if available.

  • :use_fips_endpoint (Boolean) —

    When set to ‘true`, fips compatible endpoints will be used if available. When a `fips` region is used, the region is normalized and this config is set to `true`.

  • :validate_params (Boolean) — default: true —

    When ‘true`, request parameters are validated before sending the request.

  • :endpoint_provider (Aws::KinesisVideo::EndpointProvider) —

    The endpoint provider used to resolve endpoints. Any object that responds to ‘#resolve_endpoint(parameters)` where `parameters` is a Struct similar to `Aws::KinesisVideo::EndpointParameters`.

  • :http_continue_timeout (Float) — default: 1 —

    The number of seconds to wait for a 100-continue response before sending the request body. This option has no effect unless the request has “Expect” header set to “100-continue”. Defaults to ‘nil` which disables this behaviour. This value can safely be set per request on the session.

  • :http_idle_timeout (Float) — default: 5 —

    The number of seconds a connection is allowed to sit idle before it is considered stale. Stale connections are closed and removed from the pool before making a request.

  • :http_open_timeout (Float) — default: 15 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_proxy (URI::HTTP, String) —

    A proxy to send requests through. Formatted like ‘proxy.com:123’.

  • :http_read_timeout (Float) — default: 60 —

    The default number of seconds to wait for response data. This value can safely be set per-request on the session.

  • :http_wire_trace (Boolean) — default: false —

    When ‘true`, HTTP debug output will be sent to the `:logger`.

  • :on_chunk_received (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the response body is received. It provides three arguments: the chunk, the number of bytes received, and the total number of bytes in the response (or nil if the server did not send a ‘content-length`).

  • :on_chunk_sent (Proc) —

    When a Proc object is provided, it will be used as callback when each chunk of the request body is sent. It provides three arguments: the chunk, the number of bytes read from the body, and the total number of bytes in the body.

  • :raise_response_errors (Boolean) — default: true —

    When ‘true`, response errors are raised.

  • :ssl_ca_bundle (String) —

    Full path to the SSL certificate authority bundle file that should be used when verifying peer certificates. If you do not pass ‘:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.

  • :ssl_ca_directory (String) —

    Full path of the directory that contains the unbundled SSL certificate authority files for verifying peer certificates. If you do not pass ‘:ssl_ca_bundle` or `:ssl_ca_directory` the the system default will be used if available.

  • :ssl_ca_store (String) —

    Sets the X509::Store to verify peer certificate.

  • :ssl_cert (OpenSSL::X509::Certificate) —

    Sets a client certificate when creating http connections.

  • :ssl_key (OpenSSL::PKey) —

    Sets a client key when creating http connections.

  • :ssl_timeout (Float) —

    Sets the SSL timeout in seconds

  • :ssl_verify_peer (Boolean) — default: true —

    When ‘true`, SSL peer certificates are verified when establishing a connection.



467
468
469
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 467

def initialize(*args)
  super
end

Class Attribute Details

.identifier ⇒ Object (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



2041
2042
2043
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 2041

def identifier
  @identifier
end

Class Method Details

.errors_module ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



2044
2045
2046
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 2044

def errors_module
  Errors
end

Instance Method Details

#build_request(operation_name, params = {}) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Parameters:

  • params ({}) (defaults to: {}) 


2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 2014

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  tracer = config.telemetry_provider.tracer_provider.tracer(
    Aws::Telemetry.module_to_tracer_name('Aws::KinesisVideo')
  )
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config,
    tracer: tracer
  )
  context[:gem_name] = 'aws-sdk-kinesisvideo'
  context[:gem_version] = '1.77.0'
  Seahorse::Client::Request.new(handlers, context)
end

#create_signaling_channel(params = {}) ⇒ Types::CreateSignalingChannelOutput

Creates a signaling channel.

‘CreateSignalingChannel` is an asynchronous operation.

Examples:

Request syntax with placeholder values


resp = client.create_signaling_channel({
  channel_name: "ChannelName", # required
  channel_type: "SINGLE_MASTER", # accepts SINGLE_MASTER, FULL_MESH
  single_master_configuration: {
    message_ttl_seconds: 1,
  },
  tags: [
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Response structure


resp.channel_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :channel_name (required, String) —

    A name for the signaling channel that you are creating. It must be unique for each Amazon Web Services account and Amazon Web Services Region.

  • :channel_type (String) —

    A type of the signaling channel that you are creating. Currently, ‘SINGLE_MASTER` is the only supported channel type.

  • :single_master_configuration (Types::SingleMasterConfiguration) —

    A structure containing the configuration for the ‘SINGLE_MASTER` channel type.

  • :tags (Array<Types::Tag>) —

    A set of tags (key-value pairs) that you want to associate with this channel.

Returns:

See Also:



522
523
524
525
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 522

def create_signaling_channel(params = {}, options = {})
  req = build_request(:create_signaling_channel, params)
  req.send_request(options)
end

#create_stream(params = {}) ⇒ Types::CreateStreamOutput

Creates a new Kinesis video stream.

When you create a new stream, Kinesis Video Streams assigns it a version number. When you change the stream’s metadata, Kinesis Video Streams updates the version.

‘CreateStream` is an asynchronous operation.

For information about how the service works, see [How it Works].

You must have permissions for the ‘KinesisVideo:CreateStream` action.

[1]: docs.aws.amazon.com/kinesisvideostreams/latest/dg/how-it-works.html

Examples:

Request syntax with placeholder values


resp = client.create_stream({
  device_name: "DeviceName",
  stream_name: "StreamName", # required
  media_type: "MediaType",
  kms_key_id: "KmsKeyId",
  data_retention_in_hours: 1,
  tags: {
    "TagKey" => "TagValue",
  },
})

Response structure


resp.stream_arn #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :device_name (String) —

    The name of the device that is writing to the stream.

    <note markdown=“1”> In the current implementation, Kinesis Video Streams does not use this name.

    </note>
  • :stream_name (required, String) —

    A name for the stream that you are creating.

    The stream name is an identifier for the stream, and must be unique for each account and region.

  • :media_type (String) —

    The media type of the stream. Consumers of the stream can use this information when processing the stream. For more information about media types, see [Media Types]. If you choose to specify the ‘MediaType`, see [Naming Requirements] for guidelines.

    Example valid values include “video/h264” and “video/h264,audio/aac”.

    This parameter is optional; the default value is ‘null` (or empty in JSON).

    [1]: www.iana.org/assignments/media-types/media-types.xhtml [2]: tools.ietf.org/html/rfc6838#section-4.2

  • :kms_key_id (String) —

    The ID of the Key Management Service (KMS) key that you want Kinesis Video Streams to use to encrypt stream data.

    If no key ID is specified, the default, Kinesis Video-managed key (‘Amazon Web Services/kinesisvideo`) is used.

    For more information, see [DescribeKey].

    [1]: docs.aws.amazon.com/kms/latest/APIReference/API_DescribeKey.html#API_DescribeKey_RequestParameters

  • :data_retention_in_hours (Integer) —

    The number of hours that you want to retain the data in the stream. Kinesis Video Streams retains the data in a data store that is associated with the stream.

    The default value is 0, indicating that the stream does not persist data.

    When the ‘DataRetentionInHours` value is 0, consumers can still consume the fragments that remain in the service host buffer, which has a retention time limit of 5 minutes and a retention memory limit of 200 MB. Fragments are removed from the buffer when either limit is reached.

  • :tags (Hash<String,String>) —

    A list of tags to associate with the specified stream. Each tag is a key-value pair (the value is optional).

Returns:

See Also:



630
631
632
633
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 630

def create_stream(params = {}, options = {})
  req = build_request(:create_stream, params)
  req.send_request(options)
end

#delete_edge_configuration(params = {}) ⇒ Struct

An asynchronous API that deletes a stream’s existing edge configuration, as well as the corresponding media from the Edge Agent.

When you invoke this API, the sync status is set to ‘DELETING`. A deletion process starts, in which active edge jobs are stopped and all media is deleted from the edge device. The time to delete varies, depending on the total amount of stored media. If the deletion process fails, the sync status changes to `DELETE_FAILED`. You will need to re-try the deletion.

When the deletion process has completed successfully, the edge configuration is no longer accessible.

Examples:

Request syntax with placeholder values


resp = client.delete_edge_configuration({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream from which to delete the edge configuration. Specify either the ‘StreamName` or the `StreamARN`.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream. Specify either the ‘StreamName` or the `StreamARN`.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



669
670
671
672
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 669

def delete_edge_configuration(params = {}, options = {})
  req = build_request(:delete_edge_configuration, params)
  req.send_request(options)
end

#delete_signaling_channel(params = {}) ⇒ Struct

Deletes a specified signaling channel. ‘DeleteSignalingChannel` is an asynchronous operation. If you don’t specify the channel’s current version, the most recent version is deleted.

Examples:

Request syntax with placeholder values


resp = client.delete_signaling_channel({
  channel_arn: "ResourceARN", # required
  current_version: "Version",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :channel_arn (required, String) —

    The Amazon Resource Name (ARN) of the signaling channel that you want to delete.

  • :current_version (String) —

    The current version of the signaling channel that you want to delete. You can obtain the current version by invoking the ‘DescribeSignalingChannel` or `ListSignalingChannels` API operations.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



700
701
702
703
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 700

def delete_signaling_channel(params = {}, options = {})
  req = build_request(:delete_signaling_channel, params)
  req.send_request(options)
end

#delete_stream(params = {}) ⇒ Struct

Deletes a Kinesis video stream and the data contained in the stream.

This method marks the stream for deletion, and makes the data in the stream inaccessible immediately.

To ensure that you have the latest version of the stream before deleting it, you can specify the stream version. Kinesis Video Streams assigns a version to each stream. When you update a stream, Kinesis Video Streams assigns a new version number. To get the latest stream version, use the ‘DescribeStream` API.

This operation requires permission for the ‘KinesisVideo:DeleteStream` action.

Examples:

Request syntax with placeholder values


resp = client.delete_stream({
  stream_arn: "ResourceARN", # required
  current_version: "Version",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_arn (required, String) —

    The Amazon Resource Name (ARN) of the stream that you want to delete.

  • :current_version (String) —

    Optional: The version of the stream that you want to delete.

    Specify the version as a safeguard to ensure that your are deleting the correct stream. To get the stream version, use the ‘DescribeStream` API.

    If not specified, only the ‘CreationTime` is checked before deleting the stream.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



747
748
749
750
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 747

def delete_stream(params = {}, options = {})
  req = build_request(:delete_stream, params)
  req.send_request(options)
end

#describe_edge_configuration(params = {}) ⇒ Types::DescribeEdgeConfigurationOutput

Describes a stream’s edge configuration that was set using the ‘StartEdgeConfigurationUpdate` API and the latest status of the edge agent’s recorder and uploader jobs. Use this API to get the status of the configuration to determine if the configuration is in sync with the Edge Agent. Use this API to evaluate the health of the Edge Agent.

Examples:

Request syntax with placeholder values


resp = client.describe_edge_configuration({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
})

Response structure


resp.stream_name #=> String
resp.stream_arn #=> String
resp.creation_time #=> Time
resp.last_updated_time #=> Time
resp.sync_status #=> String, one of "SYNCING", "ACKNOWLEDGED", "IN_SYNC", "SYNC_FAILED", "DELETING", "DELETE_FAILED", "DELETING_ACKNOWLEDGED"
resp.failed_status_details #=> String
resp.edge_config.hub_device_arn #=> String
resp.edge_config.recorder_config.media_source_config.media_uri_secret_arn #=> String
resp.edge_config.recorder_config.media_source_config.media_uri_type #=> String, one of "RTSP_URI", "FILE_URI"
resp.edge_config.recorder_config.schedule_config.schedule_expression #=> String
resp.edge_config.recorder_config.schedule_config.duration_in_seconds #=> Integer
resp.edge_config.uploader_config.schedule_config.schedule_expression #=> String
resp.edge_config.uploader_config.schedule_config.duration_in_seconds #=> Integer
resp.edge_config.deletion_config.edge_retention_in_hours #=> Integer
resp.edge_config.deletion_config.local_size_config.max_local_media_size_in_mb #=> Integer
resp.edge_config.deletion_config.local_size_config.strategy_on_full_size #=> String, one of "DELETE_OLDEST_MEDIA", "DENY_NEW_MEDIA"
resp.edge_config.deletion_config.delete_after_upload #=> Boolean
resp.edge_agent_status.last_recorder_status.job_status_details #=> String
resp.edge_agent_status.last_recorder_status.last_collected_time #=> Time
resp.edge_agent_status.last_recorder_status.last_updated_time #=> Time
resp.edge_agent_status.last_recorder_status.recorder_status #=> String, one of "SUCCESS", "USER_ERROR", "SYSTEM_ERROR"
resp.edge_agent_status.last_uploader_status.job_status_details #=> String
resp.edge_agent_status.last_uploader_status.last_collected_time #=> Time
resp.edge_agent_status.last_uploader_status.last_updated_time #=> Time
resp.edge_agent_status.last_uploader_status.uploader_status #=> String, one of "SUCCESS", "USER_ERROR", "SYSTEM_ERROR"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream whose edge configuration you want to update. Specify either the ‘StreamName` or the `StreamARN`.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream. Specify either the ‘StreamName`or the `StreamARN`.

Returns:

See Also:



816
817
818
819
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 816

def describe_edge_configuration(params = {}, options = {})
  req = build_request(:describe_edge_configuration, params)
  req.send_request(options)
end

#describe_image_generation_configuration(params = {}) ⇒ Types::DescribeImageGenerationConfigurationOutput

Gets the ‘ImageGenerationConfiguration` for a given Kinesis video stream.

Examples:

Request syntax with placeholder values


resp = client.describe_image_generation_configuration({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
})

Response structure


resp.image_generation_configuration.status #=> String, one of "ENABLED", "DISABLED"
resp.image_generation_configuration.image_selector_type #=> String, one of "SERVER_TIMESTAMP", "PRODUCER_TIMESTAMP"
resp.image_generation_configuration.destination_config.uri #=> String
resp.image_generation_configuration.destination_config.destination_region #=> String
resp.image_generation_configuration.sampling_interval #=> Integer
resp.image_generation_configuration.format #=> String, one of "JPEG", "PNG"
resp.image_generation_configuration.format_config #=> Hash
resp.image_generation_configuration.format_config["FormatConfigKey"] #=> String
resp.image_generation_configuration.width_pixels #=> Integer
resp.image_generation_configuration.height_pixels #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream from which to retrieve the image generation configuration. You must specify either the ‘StreamName` or the `StreamARN`.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the Kinesis video stream from which to retrieve the image generation configuration. You must specify either the ‘StreamName` or the `StreamARN`.

Returns:

See Also:



862
863
864
865
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 862

def describe_image_generation_configuration(params = {}, options = {})
  req = build_request(:describe_image_generation_configuration, params)
  req.send_request(options)
end

#describe_mapped_resource_configuration(params = {}) ⇒ Types::DescribeMappedResourceConfigurationOutput

Returns the most current information about the stream. The ‘streamName` or `streamARN` should be provided in the input.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.describe_mapped_resource_configuration({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.mapped_resource_configuration_list #=> Array
resp.mapped_resource_configuration_list[0].type #=> String
resp.mapped_resource_configuration_list[0].arn #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream.

  • :max_results (Integer) —

    The maximum number of results to return in the response.

  • :next_token (String) —

    The token to provide in your next request, to get another batch of results.

Returns:

See Also:



910
911
912
913
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 910

def describe_mapped_resource_configuration(params = {}, options = {})
  req = build_request(:describe_mapped_resource_configuration, params)
  req.send_request(options)
end

#describe_media_storage_configuration(params = {}) ⇒ Types::DescribeMediaStorageConfigurationOutput

Returns the most current information about the channel. Specify the ‘ChannelName` or `ChannelARN` in the input.

Examples:

Request syntax with placeholder values


resp = client.describe_media_storage_configuration({
  channel_name: "ChannelName",
  channel_arn: "ResourceARN",
})

Response structure


resp.media_storage_configuration.stream_arn #=> String
resp.media_storage_configuration.status #=> String, one of "ENABLED", "DISABLED"

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :channel_name (String) —

    The name of the channel.

  • :channel_arn (String) —

    The Amazon Resource Name (ARN) of the channel.

Returns:

See Also:



944
945
946
947
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 944

def describe_media_storage_configuration(params = {}, options = {})
  req = build_request(:describe_media_storage_configuration, params)
  req.send_request(options)
end

#describe_notification_configuration(params = {}) ⇒ Types::DescribeNotificationConfigurationOutput

Gets the ‘NotificationConfiguration` for a given Kinesis video stream.

Examples:

Request syntax with placeholder values


resp = client.describe_notification_configuration({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
})

Response structure


resp.notification_configuration.status #=> String, one of "ENABLED", "DISABLED"
resp.notification_configuration.destination_config.uri #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream from which to retrieve the notification configuration. You must specify either the ‘StreamName` or the `StreamARN`.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the Kinesis video stream from where you want to retrieve the notification configuration. You must specify either the ‘StreamName` or the StreamARN.

Returns:

See Also:



981
982
983
984
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 981

def describe_notification_configuration(params = {}, options = {})
  req = build_request(:describe_notification_configuration, params)
  req.send_request(options)
end

#describe_signaling_channel(params = {}) ⇒ Types::DescribeSignalingChannelOutput

Returns the most current information about the signaling channel. You must specify either the name or the Amazon Resource Name (ARN) of the channel that you want to describe.

Examples:

Request syntax with placeholder values


resp = client.describe_signaling_channel({
  channel_name: "ChannelName",
  channel_arn: "ResourceARN",
})

Response structure


resp.channel_info.channel_name #=> String
resp.channel_info.channel_arn #=> String
resp.channel_info.channel_type #=> String, one of "SINGLE_MASTER", "FULL_MESH"
resp.channel_info.channel_status #=> String, one of "CREATING", "ACTIVE", "UPDATING", "DELETING"
resp.channel_info.creation_time #=> Time
resp.channel_info.single_master_configuration.message_ttl_seconds #=> Integer
resp.channel_info.version #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :channel_name (String) —

    The name of the signaling channel that you want to describe.

  • :channel_arn (String) —

    The ARN of the signaling channel that you want to describe.

Returns:

See Also:



1021
1022
1023
1024
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1021

def describe_signaling_channel(params = {}, options = {})
  req = build_request(:describe_signaling_channel, params)
  req.send_request(options)
end

#describe_stream(params = {}) ⇒ Types::DescribeStreamOutput

Returns the most current information about the specified stream. You must specify either the ‘StreamName` or the `StreamARN`.

Examples:

Request syntax with placeholder values


resp = client.describe_stream({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
})

Response structure


resp.stream_info.device_name #=> String
resp.stream_info.stream_name #=> String
resp.stream_info.stream_arn #=> String
resp.stream_info.media_type #=> String
resp.stream_info.kms_key_id #=> String
resp.stream_info.version #=> String
resp.stream_info.status #=> String, one of "CREATING", "ACTIVE", "UPDATING", "DELETING"
resp.stream_info.creation_time #=> Time
resp.stream_info.data_retention_in_hours #=> Integer

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream.

Returns:

See Also:



1062
1063
1064
1065
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1062

def describe_stream(params = {}, options = {})
  req = build_request(:describe_stream, params)
  req.send_request(options)
end

#get_data_endpoint(params = {}) ⇒ Types::GetDataEndpointOutput

Gets an endpoint for a specified stream for either reading or writing. Use this endpoint in your application to read from the specified stream (using the ‘GetMedia` or `GetMediaForFragmentList` operations) or write to it (using the `PutMedia` operation).

<note markdown=“1”> The returned endpoint does not have the API name appended. The client needs to add the API name to the returned endpoint.

</note>

In the request, specify the stream either by ‘StreamName` or `StreamARN`.

Examples:

Request syntax with placeholder values


resp = client.get_data_endpoint({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
  api_name: "PUT_MEDIA", # required, accepts PUT_MEDIA, GET_MEDIA, LIST_FRAGMENTS, GET_MEDIA_FOR_FRAGMENT_LIST, GET_HLS_STREAMING_SESSION_URL, GET_DASH_STREAMING_SESSION_URL, GET_CLIP, GET_IMAGES
})

Response structure


resp.data_endpoint #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream that you want to get the endpoint for. You must specify either this parameter or a ‘StreamARN` in the request.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream that you want to get the endpoint for. You must specify either this parameter or a ‘StreamName` in the request.

  • :api_name (required, String) —

    The name of the API action for which to get an endpoint.

Returns:

See Also:



1112
1113
1114
1115
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1112

def get_data_endpoint(params = {}, options = {})
  req = build_request(:get_data_endpoint, params)
  req.send_request(options)
end

#get_signaling_channel_endpoint(params = {}) ⇒ Types::GetSignalingChannelEndpointOutput

Provides an endpoint for the specified signaling channel to send and receive messages. This API uses the ‘SingleMasterChannelEndpointConfiguration` input parameter, which consists of the `Protocols` and `Role` properties.

‘Protocols` is used to determine the communication mechanism. For example, if you specify `WSS` as the protocol, this API produces a secure websocket endpoint. If you specify `HTTPS` as the protocol, this API generates an HTTPS endpoint.

‘Role` determines the messaging permissions. A `MASTER` role results in this API generating an endpoint that a client can use to communicate with any of the viewers on the channel. A `VIEWER` role results in this API generating an endpoint that a client can use to communicate only with a `MASTER`.

Examples:

Request syntax with placeholder values


resp = client.get_signaling_channel_endpoint({
  channel_arn: "ResourceARN", # required
  single_master_channel_endpoint_configuration: {
    protocols: ["WSS"], # accepts WSS, HTTPS, WEBRTC
    role: "MASTER", # accepts MASTER, VIEWER
  },
})

Response structure


resp.resource_endpoint_list #=> Array
resp.resource_endpoint_list[0].protocol #=> String, one of "WSS", "HTTPS", "WEBRTC"
resp.resource_endpoint_list[0].resource_endpoint #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :channel_arn (required, String) —

    The Amazon Resource Name (ARN) of the signalling channel for which you want to get an endpoint.

  • :single_master_channel_endpoint_configuration (Types::SingleMasterChannelEndpointConfiguration) —

    A structure containing the endpoint configuration for the ‘SINGLE_MASTER` channel type.

Returns:

See Also:



1165
1166
1167
1168
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1165

def get_signaling_channel_endpoint(params = {}, options = {})
  req = build_request(:get_signaling_channel_endpoint, params)
  req.send_request(options)
end

#list_edge_agent_configurations(params = {}) ⇒ Types::ListEdgeAgentConfigurationsOutput

Returns an array of edge configurations associated with the specified Edge Agent.

In the request, you must specify the Edge Agent ‘HubDeviceArn`.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_edge_agent_configurations({
  hub_device_arn: "HubDeviceArn", # required
  max_results: 1,
  next_token: "NextToken",
})

Response structure


resp.edge_configs #=> Array
resp.edge_configs[0].stream_name #=> String
resp.edge_configs[0].stream_arn #=> String
resp.edge_configs[0].creation_time #=> Time
resp.edge_configs[0].last_updated_time #=> Time
resp.edge_configs[0].sync_status #=> String, one of "SYNCING", "ACKNOWLEDGED", "IN_SYNC", "SYNC_FAILED", "DELETING", "DELETE_FAILED", "DELETING_ACKNOWLEDGED"
resp.edge_configs[0].failed_status_details #=> String
resp.edge_configs[0].edge_config.hub_device_arn #=> String
resp.edge_configs[0].edge_config.recorder_config.media_source_config.media_uri_secret_arn #=> String
resp.edge_configs[0].edge_config.recorder_config.media_source_config.media_uri_type #=> String, one of "RTSP_URI", "FILE_URI"
resp.edge_configs[0].edge_config.recorder_config.schedule_config.schedule_expression #=> String
resp.edge_configs[0].edge_config.recorder_config.schedule_config.duration_in_seconds #=> Integer
resp.edge_configs[0].edge_config.uploader_config.schedule_config.schedule_expression #=> String
resp.edge_configs[0].edge_config.uploader_config.schedule_config.duration_in_seconds #=> Integer
resp.edge_configs[0].edge_config.deletion_config.edge_retention_in_hours #=> Integer
resp.edge_configs[0].edge_config.deletion_config.local_size_config.max_local_media_size_in_mb #=> Integer
resp.edge_configs[0].edge_config.deletion_config.local_size_config.strategy_on_full_size #=> String, one of "DELETE_OLDEST_MEDIA", "DENY_NEW_MEDIA"
resp.edge_configs[0].edge_config.deletion_config.delete_after_upload #=> Boolean
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :hub_device_arn (required, String) —

    The “Internet of Things (IoT) Thing” Arn of the edge agent.

  • :max_results (Integer) —

    The maximum number of edge configurations to return in the response. The default is 5.

  • :next_token (String) —

    If you specify this parameter, when the result of a ‘ListEdgeAgentConfigurations` operation is truncated, the call returns the `NextToken` in the response. To get another batch of edge configurations, provide this token in your next request.

Returns:

See Also:



1229
1230
1231
1232
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1229

def list_edge_agent_configurations(params = {}, options = {})
  req = build_request(:list_edge_agent_configurations, params)
  req.send_request(options)
end

#list_signaling_channels(params = {}) ⇒ Types::ListSignalingChannelsOutput

Returns an array of ‘ChannelInfo` objects. Each object describes a signaling channel. To retrieve only those channels that satisfy a specific condition, you can specify a `ChannelNameCondition`.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_signaling_channels({
  max_results: 1,
  next_token: "NextToken",
  channel_name_condition: {
    comparison_operator: "BEGINS_WITH", # accepts BEGINS_WITH
    comparison_value: "ChannelName",
  },
})

Response structure


resp.channel_info_list #=> Array
resp.channel_info_list[0].channel_name #=> String
resp.channel_info_list[0].channel_arn #=> String
resp.channel_info_list[0].channel_type #=> String, one of "SINGLE_MASTER", "FULL_MESH"
resp.channel_info_list[0].channel_status #=> String, one of "CREATING", "ACTIVE", "UPDATING", "DELETING"
resp.channel_info_list[0].creation_time #=> Time
resp.channel_info_list[0].single_master_configuration.message_ttl_seconds #=> Integer
resp.channel_info_list[0].version #=> String
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of channels to return in the response. The default is 500.

  • :next_token (String) —

    If you specify this parameter, when the result of a ‘ListSignalingChannels` operation is truncated, the call returns the `NextToken` in the response. To get another batch of channels, provide this token in your next request.

  • :channel_name_condition (Types::ChannelNameCondition) —

    Optional: Returns only the channels that satisfy a specific condition.

Returns:

See Also:



1285
1286
1287
1288
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1285

def list_signaling_channels(params = {}, options = {})
  req = build_request(:list_signaling_channels, params)
  req.send_request(options)
end

#list_streams(params = {}) ⇒ Types::ListStreamsOutput

Returns an array of ‘StreamInfo` objects. Each object describes a stream. To retrieve only streams that satisfy a specific condition, you can specify a `StreamNameCondition`.

The returned response is a pageable response and is Enumerable. For details on usage see PageableResponse.

Examples:

Request syntax with placeholder values


resp = client.list_streams({
  max_results: 1,
  next_token: "NextToken",
  stream_name_condition: {
    comparison_operator: "BEGINS_WITH", # accepts BEGINS_WITH
    comparison_value: "StreamName",
  },
})

Response structure


resp.stream_info_list #=> Array
resp.stream_info_list[0].device_name #=> String
resp.stream_info_list[0].stream_name #=> String
resp.stream_info_list[0].stream_arn #=> String
resp.stream_info_list[0].media_type #=> String
resp.stream_info_list[0].kms_key_id #=> String
resp.stream_info_list[0].version #=> String
resp.stream_info_list[0].status #=> String, one of "CREATING", "ACTIVE", "UPDATING", "DELETING"
resp.stream_info_list[0].creation_time #=> Time
resp.stream_info_list[0].data_retention_in_hours #=> Integer
resp.next_token #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :max_results (Integer) —

    The maximum number of streams to return in the response. The default is 10,000.

  • :next_token (String) —

    If you specify this parameter, when the result of a ‘ListStreams` operation is truncated, the call returns the `NextToken` in the response. To get another batch of streams, provide this token in your next request.

  • :stream_name_condition (Types::StreamNameCondition) —

    Optional: Returns only streams that satisfy a specific condition. Currently, you can specify only the prefix of a stream name as a condition.

Returns:

See Also:



1345
1346
1347
1348
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1345

def list_streams(params = {}, options = {})
  req = build_request(:list_streams, params)
  req.send_request(options)
end

#list_tags_for_resource(params = {}) ⇒ Types::ListTagsForResourceOutput

Returns a list of tags associated with the specified signaling channel.

Examples:

Request syntax with placeholder values


resp = client.list_tags_for_resource({
  next_token: "NextToken",
  resource_arn: "ResourceARN", # required
})

Response structure


resp.next_token #=> String
resp.tags #=> Hash
resp.tags["TagKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    If you specify this parameter and the result of a ‘ListTagsForResource` call is truncated, the response includes a token that you can use in the next request to fetch the next batch of tags.

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the signaling channel for which you want to list tags.

Returns:

See Also:



1384
1385
1386
1387
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1384

def list_tags_for_resource(params = {}, options = {})
  req = build_request(:list_tags_for_resource, params)
  req.send_request(options)
end

#list_tags_for_stream(params = {}) ⇒ Types::ListTagsForStreamOutput

Returns a list of tags associated with the specified stream.

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

Examples:

Request syntax with placeholder values


resp = client.list_tags_for_stream({
  next_token: "NextToken",
  stream_arn: "ResourceARN",
  stream_name: "StreamName",
})

Response structure


resp.next_token #=> String
resp.tags #=> Hash
resp.tags["TagKey"] #=> String

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :next_token (String) —

    If you specify this parameter and the result of a ‘ListTagsForStream` call is truncated, the response includes a token that you can use in the next request to fetch the next batch of tags.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream that you want to list tags for.

  • :stream_name (String) —

    The name of the stream that you want to list tags for.

Returns:

See Also:



1429
1430
1431
1432
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1429

def list_tags_for_stream(params = {}, options = {})
  req = build_request(:list_tags_for_stream, params)
  req.send_request(options)
end

#start_edge_configuration_update(params = {}) ⇒ Types::StartEdgeConfigurationUpdateOutput

An asynchronous API that updates a stream’s existing edge configuration. The Kinesis Video Stream will sync the stream’s edge configuration with the Edge Agent IoT Greengrass component that runs on an IoT Hub Device, setup at your premise. The time to sync can vary and depends on the connectivity of the Hub Device. The ‘SyncStatus` will be updated as the edge configuration is acknowledged, and synced with the Edge Agent.

If this API is invoked for the first time, a new edge configuration will be created for the stream, and the sync status will be set to ‘SYNCING`. You will have to wait for the sync status to reach a terminal state such as: `IN_SYNC`, or `SYNC_FAILED`, before using this API again. If you invoke this API during the syncing process, a `ResourceInUseException` will be thrown. The connectivity of the stream’s edge configuration and the Edge Agent will be retried for 15 minutes. After 15 minutes, the status will transition into the `SYNC_FAILED` state.

To move an edge configuration from one device to another, use DeleteEdgeConfiguration to delete the current edge configuration. You can then invoke StartEdgeConfigurationUpdate with an updated Hub Device ARN.

Examples:

Request syntax with placeholder values


resp = client.start_edge_configuration_update({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
  edge_config: { # required
    hub_device_arn: "HubDeviceArn", # required
    recorder_config: { # required
      media_source_config: { # required
        media_uri_secret_arn: "MediaUriSecretArn", # required
        media_uri_type: "RTSP_URI", # required, accepts RTSP_URI, FILE_URI
      },
      schedule_config: {
        schedule_expression: "ScheduleExpression", # required
        duration_in_seconds: 1, # required
      },
    },
    uploader_config: {
      schedule_config: { # required
        schedule_expression: "ScheduleExpression", # required
        duration_in_seconds: 1, # required
      },
    },
    deletion_config: {
      edge_retention_in_hours: 1,
      local_size_config: {
        max_local_media_size_in_mb: 1,
        strategy_on_full_size: "DELETE_OLDEST_MEDIA", # accepts DELETE_OLDEST_MEDIA, DENY_NEW_MEDIA
      },
      delete_after_upload: false,
    },
  },
})

Response structure


resp.stream_name #=> String
resp.stream_arn #=> String
resp.creation_time #=> Time
resp.last_updated_time #=> Time
resp.sync_status #=> String, one of "SYNCING", "ACKNOWLEDGED", "IN_SYNC", "SYNC_FAILED", "DELETING", "DELETE_FAILED", "DELETING_ACKNOWLEDGED"
resp.failed_status_details #=> String
resp.edge_config.hub_device_arn #=> String
resp.edge_config.recorder_config.media_source_config.media_uri_secret_arn #=> String
resp.edge_config.recorder_config.media_source_config.media_uri_type #=> String, one of "RTSP_URI", "FILE_URI"
resp.edge_config.recorder_config.schedule_config.schedule_expression #=> String
resp.edge_config.recorder_config.schedule_config.duration_in_seconds #=> Integer
resp.edge_config.uploader_config.schedule_config.schedule_expression #=> String
resp.edge_config.uploader_config.schedule_config.duration_in_seconds #=> Integer
resp.edge_config.deletion_config.edge_retention_in_hours #=> Integer
resp.edge_config.deletion_config.local_size_config.max_local_media_size_in_mb #=> Integer
resp.edge_config.deletion_config.local_size_config.strategy_on_full_size #=> String, one of "DELETE_OLDEST_MEDIA", "DENY_NEW_MEDIA"
resp.edge_config.deletion_config.delete_after_upload #=> Boolean

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream whose edge configuration you want to update. Specify either the ‘StreamName` or the `StreamARN`.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream. Specify either the ‘StreamName` or the `StreamARN`.

  • :edge_config (required, Types::EdgeConfig) —

    The edge configuration details required to invoke the update process.

Returns:

See Also:



1536
1537
1538
1539
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1536

def start_edge_configuration_update(params = {}, options = {})
  req = build_request(:start_edge_configuration_update, params)
  req.send_request(options)
end

#tag_resource(params = {}) ⇒ Struct

Adds one or more tags to a signaling channel. A tag is a key-value pair (the value is optional) that you can define and assign to Amazon Web Services resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see [Using Cost Allocation Tags] in the *Billing and Cost Management and Cost Management User Guide*.

[1]: docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html

Examples:

Request syntax with placeholder values


resp = client.tag_resource({
  resource_arn: "ResourceARN", # required
  tags: [ # required
    {
      key: "TagKey", # required
      value: "TagValue", # required
    },
  ],
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the signaling channel to which you want to add tags.

  • :tags (required, Array<Types::Tag>) —

    A list of tags to associate with the specified signaling channel. Each tag is a key-value pair.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1578
1579
1580
1581
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1578

def tag_resource(params = {}, options = {})
  req = build_request(:tag_resource, params)
  req.send_request(options)
end

#tag_stream(params = {}) ⇒ Struct

Adds one or more tags to a stream. A tag is a key-value pair (the value is optional) that you can define and assign to Amazon Web Services resources. If you specify a tag that already exists, the tag value is replaced with the value that you specify in the request. For more information, see [Using Cost Allocation Tags] in the *Billing and Cost Management and Cost Management User Guide*.

You must provide either the ‘StreamName` or the `StreamARN`.

This operation requires permission for the ‘KinesisVideo:TagStream` action.

A Kinesis video stream can support up to 50 tags.

[1]: docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/cost-alloc-tags.html

Examples:

Request syntax with placeholder values


resp = client.tag_stream({
  stream_arn: "ResourceARN",
  stream_name: "StreamName",
  tags: { # required
    "TagKey" => "TagValue",
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the resource that you want to add the tag or tags to.

  • :stream_name (String) —

    The name of the stream that you want to add the tag or tags to.

  • :tags (required, Hash<String,String>) —

    A list of tags to associate with the specified stream. Each tag is a key-value pair (the value is optional).

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1628
1629
1630
1631
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1628

def tag_stream(params = {}, options = {})
  req = build_request(:tag_stream, params)
  req.send_request(options)
end

#untag_resource(params = {}) ⇒ Struct

Removes one or more tags from a signaling channel. In the request, specify only a tag key or keys; don’t specify the value. If you specify a tag key that does not exist, it’s ignored.

Examples:

Request syntax with placeholder values


resp = client.untag_resource({
  resource_arn: "ResourceARN", # required
  tag_key_list: ["TagKey"], # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :resource_arn (required, String) —

    The Amazon Resource Name (ARN) of the signaling channel from which you want to remove tags.

  • :tag_key_list (required, Array<String>) —

    A list of the keys of the tags that you want to remove.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1657
1658
1659
1660
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1657

def untag_resource(params = {}, options = {})
  req = build_request(:untag_resource, params)
  req.send_request(options)
end

#untag_stream(params = {}) ⇒ Struct

Removes one or more tags from a stream. In the request, specify only a tag key or keys; don’t specify the value. If you specify a tag key that does not exist, it’s ignored.

In the request, you must provide the ‘StreamName` or `StreamARN`.

Examples:

Request syntax with placeholder values


resp = client.untag_stream({
  stream_arn: "ResourceARN",
  stream_name: "StreamName",
  tag_key_list: ["TagKey"], # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream that you want to remove tags from.

  • :stream_name (String) —

    The name of the stream that you want to remove tags from.

  • :tag_key_list (required, Array<String>) —

    A list of the keys of the tags that you want to remove.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1692
1693
1694
1695
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1692

def untag_stream(params = {}, options = {})
  req = build_request(:untag_stream, params)
  req.send_request(options)
end

#update_data_retention(params = {}) ⇒ Struct

Increases or decreases the stream’s data retention period by the value that you specify. To indicate whether you want to increase or decrease the data retention period, specify the ‘Operation` parameter in the request body. In the request, you must specify either the `StreamName` or the `StreamARN`.

This operation requires permission for the ‘KinesisVideo:UpdateDataRetention` action.

Changing the data retention period affects the data in the stream as follows:

  • If the data retention period is increased, existing data is retained for the new retention period. For example, if the data retention period is increased from one hour to seven hours, all existing data is retained for seven hours.

  • If the data retention period is decreased, existing data is retained for the new retention period. For example, if the data retention period is decreased from seven hours to one hour, all existing data is retained for one hour, and any data older than one hour is deleted immediately.

Examples:

Request syntax with placeholder values


resp = client.update_data_retention({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
  current_version: "Version", # required
  operation: "INCREASE_DATA_RETENTION", # required, accepts INCREASE_DATA_RETENTION, DECREASE_DATA_RETENTION
  data_retention_change_in_hours: 1, # required
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream whose retention period you want to change.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the stream whose retention period you want to change.

  • :current_version (required, String) —

    The version of the stream whose retention period you want to change. To get the version, call either the ‘DescribeStream` or the `ListStreams` API.

  • :operation (required, String) —

    Indicates whether you want to increase or decrease the retention period.

  • :data_retention_change_in_hours (required, Integer) —

    The number of hours to adjust the current retention by. The value you specify is added to or subtracted from the current value, depending on the ‘operation`.

    The minimum value for data retention is 0 and the maximum value is 87600 (ten years).

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1760
1761
1762
1763
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1760

def update_data_retention(params = {}, options = {})
  req = build_request(:update_data_retention, params)
  req.send_request(options)
end

#update_image_generation_configuration(params = {}) ⇒ Struct

Updates the ‘StreamInfo` and `ImageProcessingConfiguration` fields.

Examples:

Request syntax with placeholder values


resp = client.update_image_generation_configuration({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
  image_generation_configuration: {
    status: "ENABLED", # required, accepts ENABLED, DISABLED
    image_selector_type: "SERVER_TIMESTAMP", # required, accepts SERVER_TIMESTAMP, PRODUCER_TIMESTAMP
    destination_config: { # required
      uri: "DestinationUri", # required
      destination_region: "DestinationRegion", # required
    },
    sampling_interval: 1, # required
    format: "JPEG", # required, accepts JPEG, PNG
    format_config: {
      "JPEGQuality" => "FormatConfigValue",
    },
    width_pixels: 1,
    height_pixels: 1,
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream from which to update the image generation configuration. You must specify either the ‘StreamName` or the `StreamARN`.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the Kinesis video stream from where you want to update the image generation configuration. You must specify either the ‘StreamName` or the `StreamARN`.

  • :image_generation_configuration (Types::ImageGenerationConfiguration) —

    The structure that contains the information required for the KVS images delivery. If the structure is null, the configuration will be deleted from the stream.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1810
1811
1812
1813
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1810

def update_image_generation_configuration(params = {}, options = {})
  req = build_request(:update_image_generation_configuration, params)
  req.send_request(options)
end

#update_media_storage_configuration(params = {}) ⇒ Struct

Associates a ‘SignalingChannel` to a stream to store the media. There are two signaling modes that you can specify :

  • If ‘StorageStatus` is enabled, the data will be stored in the `StreamARN` provided. In order for WebRTC Ingestion to work, the stream must have data retention enabled.

  • If ‘StorageStatus` is disabled, no data will be stored, and the `StreamARN` parameter will not be needed.

If ‘StorageStatus` is enabled, direct peer-to-peer (master-viewer) connections no longer occur. Peers connect directly to the storage session. You must call the `JoinStorageSession` API to trigger an SDP offer send and establish a connection between a peer and the storage session.

Examples:

Request syntax with placeholder values


resp = client.update_media_storage_configuration({
  channel_arn: "ResourceARN", # required
  media_storage_configuration: { # required
    stream_arn: "ResourceARN",
    status: "ENABLED", # required, accepts ENABLED, DISABLED
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :channel_arn (required, String) —

    The Amazon Resource Name (ARN) of the channel.

  • :media_storage_configuration (required, Types::MediaStorageConfiguration) —

    A structure that encapsulates, or contains, the media storage configuration properties.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1854
1855
1856
1857
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1854

def update_media_storage_configuration(params = {}, options = {})
  req = build_request(:update_media_storage_configuration, params)
  req.send_request(options)
end

#update_notification_configuration(params = {}) ⇒ Struct

Updates the notification information for a stream.

Examples:

Request syntax with placeholder values


resp = client.update_notification_configuration({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
  notification_configuration: {
    status: "ENABLED", # required, accepts ENABLED, DISABLED
    destination_config: { # required
      uri: "DestinationUri", # required
    },
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream from which to update the notification configuration. You must specify either the ‘StreamName` or the `StreamARN`.

  • :stream_arn (String) —

    The Amazon Resource Name (ARN) of the Kinesis video stream from where you want to update the notification configuration. You must specify either the ‘StreamName` or the `StreamARN`.

  • :notification_configuration (Types::NotificationConfiguration) —

    The structure containing the information required for notifications. If the structure is null, the configuration will be deleted from the stream.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1895
1896
1897
1898
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1895

def update_notification_configuration(params = {}, options = {})
  req = build_request(:update_notification_configuration, params)
  req.send_request(options)
end

#update_signaling_channel(params = {}) ⇒ Struct

Updates the existing signaling channel. This is an asynchronous operation and takes time to complete.

If the ‘MessageTtlSeconds` value is updated (either increased or reduced), it only applies to new messages sent via this channel after it’s been updated. Existing messages are still expired as per the previous ‘MessageTtlSeconds` value.

Examples:

Request syntax with placeholder values


resp = client.update_signaling_channel({
  channel_arn: "ResourceARN", # required
  current_version: "Version", # required
  single_master_configuration: {
    message_ttl_seconds: 1,
  },
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :channel_arn (required, String) —

    The Amazon Resource Name (ARN) of the signaling channel that you want to update.

  • :current_version (required, String) —

    The current version of the signaling channel that you want to update.

  • :single_master_configuration (Types::SingleMasterConfiguration) —

    The structure containing the configuration for the ‘SINGLE_MASTER` type of the signaling channel that you want to update.

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



1935
1936
1937
1938
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 1935

def update_signaling_channel(params = {}, options = {})
  req = build_request(:update_signaling_channel, params)
  req.send_request(options)
end

#update_stream(params = {}) ⇒ Struct

Updates stream metadata, such as the device name and media type.

You must provide the stream name or the Amazon Resource Name (ARN) of the stream.

To make sure that you have the latest version of the stream before updating it, you can specify the stream version. Kinesis Video Streams assigns a version to each stream. When you update a stream, Kinesis Video Streams assigns a new version number. To get the latest stream version, use the ‘DescribeStream` API.

‘UpdateStream` is an asynchronous operation, and takes time to complete.

Examples:

Request syntax with placeholder values


resp = client.update_stream({
  stream_name: "StreamName",
  stream_arn: "ResourceARN",
  current_version: "Version", # required
  device_name: "DeviceName",
  media_type: "MediaType",
})

Parameters:

  • params (Hash) (defaults to: {}) —

    ({})

Options Hash (params):

  • :stream_name (String) —

    The name of the stream whose metadata you want to update.

    The stream name is an identifier for the stream, and must be unique for each account and region.

  • :stream_arn (String) —

    The ARN of the stream whose metadata you want to update.

  • :current_version (required, String) —

    The version of the stream whose metadata you want to update.

  • :device_name (String) —

    The name of the device that is writing to the stream.

    <note markdown=“1”> In the current implementation, Kinesis Video Streams does not use this name.

    </note>
  • :media_type (String) —

    The stream’s media type. Use ‘MediaType` to specify the type of content that the stream contains to the consumers of the stream. For more information about media types, see [Media Types]. If you choose to specify the `MediaType`, see [Naming Requirements].

    To play video on the console, you must specify the correct video type. For example, if the video in the stream is H.264, specify ‘video/h264` as the `MediaType`.

    [1]: www.iana.org/assignments/media-types/media-types.xhtml [2]: tools.ietf.org/html/rfc6838#section-4.2

Returns:

  • (Struct) —

    Returns an empty response.

See Also:



2005
2006
2007
2008
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 2005

def update_stream(params = {}, options = {})
  req = build_request(:update_stream, params)
  req.send_request(options)
end

#waiter_names ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Deprecated. 


2034
2035
2036
 
# File 'lib/aws-sdk-kinesisvideo/client.rb', line 2034

def waiter_names
  []
end