public void PutRecordBatchMarshallTest() { var request = InstantiateClassGenerator.Execute <PutRecordBatchRequest>(); var marshaller = new PutRecordBatchRequestMarshaller(); var internalRequest = marshaller.Marshall(request); var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content); Comparer.CompareObjectToJson <PutRecordBatchRequest>(request, jsonRequest); var webResponse = new WebResponseData { Headers = { { "x-amzn-RequestId", Guid.NewGuid().ToString() }, { "x-amz-crc32", "0" } } }; var jsonResponse = new JsonSampleGenerator(service_model, service_model.FindOperation("PutRecordBatch").ResponseStructure).Execute(); webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(jsonResponse).Length.ToString()); UnmarshallerContext context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(jsonResponse), false, webResponse); var response = PutRecordBatchResponseUnmarshaller.Instance.Unmarshall(context) as PutRecordBatchResponse; InstantiateClassGenerator.ValidateObjectFullyInstantiated(response); }
internal virtual PutRecordBatchResponse PutRecordBatch(PutRecordBatchRequest request) { var marshaller = new PutRecordBatchRequestMarshaller(); var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance; return(Invoke <PutRecordBatchRequest, PutRecordBatchResponse>(request, marshaller, unmarshaller)); }
/// <summary> /// Initiates the asynchronous execution of the PutRecordBatch operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutRecordBatch 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/firehose-2015-08-04/PutRecordBatch">REST API Reference for PutRecordBatch Operation</seealso> public virtual Task <PutRecordBatchResponse> PutRecordBatchAsync(PutRecordBatchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new PutRecordBatchRequestMarshaller(); var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance; return(InvokeAsync <PutRecordBatchRequest, PutRecordBatchResponse>(request, marshaller, unmarshaller, cancellationToken)); }
/// <summary> /// Initiates the asynchronous execution of the PutRecordBatch operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutRecordBatch operation on AmazonKinesisFirehoseClient.</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 EndPutRecordBatch /// operation.</returns> public IAsyncResult BeginPutRecordBatch(PutRecordBatchRequest request, AsyncCallback callback, object state) { var marshaller = new PutRecordBatchRequestMarshaller(); var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance; return(BeginInvoke <PutRecordBatchRequest>(request, marshaller, unmarshaller, callback, state)); }
/// <summary> /// Initiates the asynchronous execution of the PutRecordBatch operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutRecordBatch operation on AmazonKinesisFirehoseClient.</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> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/firehose-2015-08-04/PutRecordBatch">REST API Reference for PutRecordBatch Operation</seealso> public void PutRecordBatchAsync(PutRecordBatchRequest request, AmazonServiceCallback <PutRecordBatchRequest, PutRecordBatchResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new PutRecordBatchRequestMarshaller(); var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance; Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if (callback != null) { callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult <PutRecordBatchRequest, PutRecordBatchResponse> responseObject = new AmazonServiceResult <PutRecordBatchRequest, PutRecordBatchResponse>((PutRecordBatchRequest)req, (PutRecordBatchResponse)res, ex, ao.State); callback(responseObject); } } ; BeginInvoke <PutRecordBatchRequest>(request, marshaller, unmarshaller, options, callbackHelper); }
/// <summary> /// Initiates the asynchronous execution of the PutRecordBatch operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutRecordBatch 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<PutRecordBatchResponse> PutRecordBatchAsync(PutRecordBatchRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new PutRecordBatchRequestMarshaller(); var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance; return InvokeAsync<PutRecordBatchRequest,PutRecordBatchResponse>(request, marshaller, unmarshaller, cancellationToken); }
/// <summary> /// Writes multiple data records into a delivery stream in a single call, which can achieve /// higher throughput per producer than when writing single records. To write single data /// records into a delivery stream, use <a>PutRecord</a>. Applications using these operations /// are referred to as producers. /// /// /// <para> /// Each <a>PutRecordBatch</a> request supports up to 500 records. Each record in the /// request can be as large as 1,000 KB (before 64-bit encoding), up to a limit of 4 MB /// for the entire request. By default, each delivery stream can take in up to 2,000 transactions /// per second, 5,000 records per second, or 5 MB per second. Note that if you use <a>PutRecord</a> /// and <a>PutRecordBatch</a>, the limits are an aggregate across these two operations /// for each delivery stream. For more information about limits and how to request an /// increase, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon /// Kinesis Firehose Limits</a>. /// </para> /// /// <para> /// You must specify the name of the delivery stream and the data record when using <a>PutRecord</a>. /// The data record consists of a data blob that can be up to 1,000 KB in size, and any /// kind of data, for example, a segment from a log file, geographic location data, web /// site clickstream data, and so on. /// </para> /// /// <para> /// Amazon Kinesis Firehose buffers records before delivering them to the destination. /// To disambiguate the data blobs at the destination, a common solution is to use delimiters /// in the data, such as a newline (<code>\n</code>) or some other character unique within /// the data. This allows the consumer application(s) to parse individual data items when /// reading the data from the destination. /// </para> /// /// <para> /// The <a>PutRecordBatch</a> response includes a count of any failed records, <code>FailedPutCount</code>, /// and an array of responses, <code>RequestResponses</code>. The <code>FailedPutCount</code> /// value is a count of records that failed. Each entry in the <code>RequestResponses</code> /// array gives additional information of the processed record. Each entry in <code>RequestResponses</code> /// directly correlates with a record in the request array using the same ordering, from /// the top to the bottom of the request and response. <code>RequestResponses</code> always /// includes the same number of records as the request array. <code>RequestResponses</code> /// both successfully and unsuccessfully processed records. Amazon Kinesis Firehose attempts /// to process all records in each <a>PutRecordBatch</a> request. A single record failure /// does not stop the processing of subsequent records. /// </para> /// /// <para> /// A successfully processed record includes a <code>RecordId</code> value, which is a /// unique value identified for the record. An unsuccessfully processed record includes /// <code>ErrorCode</code> and <code>ErrorMessage</code> values. <code>ErrorCode</code> /// reflects the type of error and is one of the following values: <code>ServiceUnavailable</code> /// or <code>InternalFailure</code>. <code>ErrorMessage</code> provides more detailed /// information about the error. /// </para> /// /// <para> /// If <code>FailedPutCount</code> is greater than 0 (zero), retry the request. A retry /// of the entire batch of records is possible; however, we strongly recommend that you /// inspect the entire response and resend only those records that failed processing. /// This minimizes duplicate records and also reduces the total bytes sent (and corresponding /// charges). /// </para> /// /// <para> /// If the <a>PutRecordBatch</a> operation throws a <code>ServiceUnavailableException</code>, /// back off and retry. If the exception persists, it is possible that the throughput /// limits have been exceeded for the delivery stream. /// </para> /// /// <para> /// Data records sent to Amazon Kinesis Firehose are stored for 24 hours from the time /// they are added to a delivery stream as it attempts to send the records to the destination. /// If the destination is unreachable for more than 24 hours, the data is no longer available. /// </para> /// </summary> /// <param name="request">Container for the necessary parameters to execute the PutRecordBatch service method.</param> /// /// <returns>The response from the PutRecordBatch service method, as returned by KinesisFirehose.</returns> /// <exception cref="Amazon.KinesisFirehose.Model.InvalidArgumentException"> /// The specified input parameter has an value that is not valid. /// </exception> /// <exception cref="Amazon.KinesisFirehose.Model.ResourceNotFoundException"> /// The specified resource could not be found. /// </exception> /// <exception cref="Amazon.KinesisFirehose.Model.ServiceUnavailableException"> /// The service is unavailable, back off and retry the operation. If you continue to see /// the exception, throughput limits for the delivery stream may have been exceeded. For /// more information about limits and how to request an increase, see <a href="http://docs.aws.amazon.com/firehose/latest/dev/limits.html">Amazon /// Kinesis Firehose Limits</a>. /// </exception> public PutRecordBatchResponse PutRecordBatch(PutRecordBatchRequest request) { var marshaller = new PutRecordBatchRequestMarshaller(); var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance; return Invoke<PutRecordBatchRequest,PutRecordBatchResponse>(request, marshaller, unmarshaller); }
/// <summary> /// Initiates the asynchronous execution of the PutRecordBatch operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutRecordBatch operation on AmazonKinesisFirehoseClient.</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 EndPutRecordBatch /// operation.</returns> public IAsyncResult BeginPutRecordBatch(PutRecordBatchRequest request, AsyncCallback callback, object state) { var marshaller = new PutRecordBatchRequestMarshaller(); var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance; return BeginInvoke<PutRecordBatchRequest>(request, marshaller, unmarshaller, callback, state); }
public void PutRecordBatchMarshallTest() { var request = InstantiateClassGenerator.Execute<PutRecordBatchRequest>(); var marshaller = new PutRecordBatchRequestMarshaller(); var internalRequest = marshaller.Marshall(request); var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content); Comparer.CompareObjectToJson<PutRecordBatchRequest>(request,jsonRequest); var webResponse = new WebResponseData { Headers = { {"x-amzn-RequestId", Guid.NewGuid().ToString()}, {"x-amz-crc32","0"} } }; var jsonResponse = new JsonSampleGenerator(service_model, service_model.FindOperation("PutRecordBatch").ResponseStructure).Execute(); webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(jsonResponse).Length.ToString()); UnmarshallerContext context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(jsonResponse), false, webResponse); var response = PutRecordBatchResponseUnmarshaller.Instance.Unmarshall(context) as PutRecordBatchResponse; InstantiateClassGenerator.ValidateObjectFullyInstantiated(response); }
/// <summary> /// Initiates the asynchronous execution of the PutRecordBatch operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the PutRecordBatch operation on AmazonKinesisFirehoseClient.</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 PutRecordBatchAsync(PutRecordBatchRequest request, AmazonServiceCallback<PutRecordBatchRequest, PutRecordBatchResponse> callback, AsyncOptions options = null) { options = options == null?new AsyncOptions():options; var marshaller = new PutRecordBatchRequestMarshaller(); var unmarshaller = PutRecordBatchResponseUnmarshaller.Instance; Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null; if(callback !=null ) callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => { AmazonServiceResult<PutRecordBatchRequest,PutRecordBatchResponse> responseObject = new AmazonServiceResult<PutRecordBatchRequest,PutRecordBatchResponse>((PutRecordBatchRequest)req, (PutRecordBatchResponse)res, ex , ao.State); callback(responseObject); }; BeginInvoke<PutRecordBatchRequest>(request, marshaller, unmarshaller, options, callbackHelper); }