/// <summary> /// Deletes a Kinesis video stream and the data contained in the stream. /// /// /// <para> /// This method marks the stream for deletion, and makes the data in the stream inaccessible /// immediately. /// </para> /// /// <para> /// /// </para> /// /// <para> /// 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 <code>DescribeStream</code> API. /// </para> /// /// <para> /// This operation requires permission for the <code>KinesisVideo:DeleteStream</code> /// action. /// </para> /// </summary> /// <param name="request">Container for the necessary parameters to execute the DeleteStream service method.</param> /// /// <returns>The response from the DeleteStream service method, as returned by KinesisVideo.</returns> /// <exception cref="Amazon.KinesisVideo.Model.ClientLimitExceededException"> /// Kinesis Video Streams has throttled the request because you have exceeded the limit /// of allowed client calls. Try making the call later. /// </exception> /// <exception cref="Amazon.KinesisVideo.Model.InvalidArgumentException"> /// The value for this input parameter is invalid. /// </exception> /// <exception cref="Amazon.KinesisVideo.Model.NotAuthorizedException"> /// The caller is not authorized to perform this operation. /// </exception> /// <exception cref="Amazon.KinesisVideo.Model.ResourceNotFoundException"> /// Amazon Kinesis Video Streams can't find the stream that you specified. /// </exception> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteStream">REST API Reference for DeleteStream Operation</seealso> public virtual DeleteStreamResponse DeleteStream(DeleteStreamRequest request) { var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.Instance; return(Invoke <DeleteStreamRequest, DeleteStreamResponse>(request, marshaller, unmarshaller)); }
public void DeleteStreamMarshallTest() { var operation = service_model.FindOperation("DeleteStream"); var request = InstantiateClassGenerator.Execute <DeleteStreamRequest>(); var marshaller = new DeleteStreamRequestMarshaller(); var internalRequest = marshaller.Marshall(request); TestTools.RequestValidator.Validate("DeleteStream", request, internalRequest, service_model); var webResponse = new WebResponseData { Headers = { { "x-amzn-RequestId", Guid.NewGuid().ToString() }, { "x-amz-crc32", "0" } } }; var payloadResponse = new JsonSampleGenerator(service_model, operation.ResponseStructure).Execute(); webResponse.Headers["Content-Length"] = UTF8Encoding.UTF8.GetBytes(payloadResponse).Length.ToString(); var context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), false, webResponse); ResponseUnmarshaller unmarshaller = DeleteStreamResponseUnmarshaller.Instance; var response = unmarshaller.Unmarshall(context) as DeleteStreamResponse; InstantiateClassGenerator.ValidateObjectFullyInstantiated(response); }
/// <summary> /// Initiates the asynchronous execution of the DeleteStream operation. /// <seealso cref="Amazon.Kinesis.IAmazonKinesis.DeleteStream"/> /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteStream operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task <DeleteStreamResponse> DeleteStreamAsync(DeleteStreamRequest request, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.GetInstance(); return(Invoke <IRequest, DeleteStreamRequest, DeleteStreamResponse>(request, marshaller, unmarshaller, signer, cancellationToken)); }
/// <summary> /// Initiates the asynchronous execution of the DeleteStream operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteStream operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/DeleteStream">REST API Reference for DeleteStream Operation</seealso> public virtual Task <DeleteStreamResponse> DeleteStreamAsync(DeleteStreamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.Instance; return(InvokeAsync <DeleteStreamRequest, DeleteStreamResponse>(request, marshaller, unmarshaller, cancellationToken)); }
public void DeleteStreamMarshallTest() { var request = InstantiateClassGenerator.Execute <DeleteStreamRequest>(); var marshaller = new DeleteStreamRequestMarshaller(); var internalRequest = marshaller.Marshall(request); var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content); Comparer.CompareObjectToJson <DeleteStreamRequest>(request, jsonRequest); }
public void DeleteStreamMarshallTest() { var request = InstantiateClassGenerator.Execute<DeleteStreamRequest>(); var marshaller = new DeleteStreamRequestMarshaller(); var internalRequest = marshaller.Marshall(request); var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content); Comparer.CompareObjectToJson<DeleteStreamRequest>(request,jsonRequest); }
/// <summary> /// Initiates the asynchronous execution of the DeleteStream operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteStream operation on AmazonKinesisClient.</param> /// <param name="callback">An Action delegate that is invoked when the operation completes.</param> /// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> public void DeleteStreamAsync(DeleteStreamRequest request, AmazonServiceCallback <DeleteStreamRequest, DeleteStreamResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <DeleteStreamRequest, DeleteStreamResponse> responseObject = new AmazonServiceResult <DeleteStreamRequest, DeleteStreamResponse>((DeleteStreamRequest)req, (DeleteStreamResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <DeleteStreamRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// <para>This operation deletes a stream and all of its shards and data. You must shut down any applications that are operating on the stream /// before you delete the stream. If an application attempts to operate on a deleted stream, it will receive the exception /// <c>ResourceNotFoundException</c> .</para> <para>If the stream is in the ACTIVE state, you can delete it. After a <c>DeleteStream</c> /// request, the specified stream is in the DELETING state until Amazon Kinesis completes the deletion.</para> <para> <b>Note:</b> Amazon /// Kinesis might continue to accept data read and write operations, such as PutRecord and GetRecords, on a stream in the DELETING state until /// the stream deletion is complete.</para> <para>When you delete a stream, any shards in that stream are also deleted.</para> <para>You can use /// the DescribeStream operation to check the state of the stream, which is returned in <c>StreamStatus</c> .</para> <para> <c>DeleteStream</c> /// has a limit of 5 transactions per second per account.</para> /// </summary> /// /// <param name="deleteStreamRequest">Container for the necessary parameters to execute the DeleteStream service method on /// AmazonKinesis.</param> /// /// <exception cref="T:Amazon.Kinesis.Model.LimitExceededException" /> /// <exception cref="T:Amazon.Kinesis.Model.ResourceNotFoundException" /> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> public Task<DeleteStreamResponse> DeleteStreamAsync(DeleteStreamRequest deleteStreamRequest, CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.GetInstance(); return Invoke<IRequest, DeleteStreamRequest, DeleteStreamResponse>(deleteStreamRequest, marshaller, unmarshaller, signer, cancellationToken); }
/// <summary> /// Initiates the asynchronous execution of the DeleteStream operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteStream operation.</param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The task object representing the asynchronous operation.</returns> public Task<DeleteStreamResponse> DeleteStreamAsync(DeleteStreamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.Instance; return InvokeAsync<DeleteStreamRequest,DeleteStreamResponse>(request, marshaller, unmarshaller, cancellationToken); }
internal DeleteStreamResponse DeleteStream(DeleteStreamRequest request) { var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.Instance; return Invoke<DeleteStreamRequest,DeleteStreamResponse>(request, marshaller, unmarshaller); }
/// <summary> /// Initiates the asynchronous execution of the DeleteStream operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteStream operation on AmazonKinesisClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndDeleteStream /// operation.</returns> public IAsyncResult BeginDeleteStream(DeleteStreamRequest request, AsyncCallback callback, object state) { var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.Instance; return BeginInvoke<DeleteStreamRequest>(request, marshaller, unmarshaller, callback, state); }
/// <summary> /// Initiates the asynchronous execution of the DeleteStream operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the DeleteStream operation on AmazonKinesisClient.</param> /// <param name="callback">An Action delegate that is invoked when the operation completes.</param> /// <param name="options">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> public void DeleteStreamAsync(DeleteStreamRequest request, AmazonServiceCallback<DeleteStreamRequest, DeleteStreamResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new DeleteStreamRequestMarshaller(); var unmarshaller = DeleteStreamResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<DeleteStreamRequest,DeleteStreamResponse> responseObject = new AmazonServiceResult<DeleteStreamRequest,DeleteStreamResponse>((DeleteStreamRequest)req, (DeleteStreamResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<DeleteStreamRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
IAsyncResult invokeDeleteStream(DeleteStreamRequest deleteStreamRequest, AsyncCallback callback, object state, bool synchronized) { IRequest irequest = new DeleteStreamRequestMarshaller().Marshall(deleteStreamRequest); var unmarshaller = DeleteStreamResponseUnmarshaller.GetInstance(); AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller); Invoke(result); return result; }