/// <summary>
/// Initiates the asynchronous execution of the PutRecord operation.
/// <seealso cref="Amazon.Kinesis.IAmazonKinesis.PutRecord"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutRecord 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 <PutRecordResponse> PutRecordAsync(PutRecordRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.GetInstance();
return(Invoke <IRequest, PutRecordRequest, PutRecordResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
internal virtual PutRecordResponse PutRecord(PutRecordRequest request)
{
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.Instance;
return(Invoke <PutRecordRequest, PutRecordResponse>(request, marshaller, unmarshaller));
}
public void PutRecord_ValidationErrorExceptionMarshallTest()
{
var operation = service_model.FindOperation("PutRecord");
var request = InstantiateClassGenerator.Execute <PutRecordRequest>();
var marshaller = new PutRecordRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
TestTools.RequestValidator.Validate("PutRecord", request, internalRequest, service_model);
var exception = operation.Exceptions.First(e => e.Name.Equals("ValidationErrorException"));
var webResponse = new WebResponseData
{
Headers =
{
{ "x-amzn-RequestId", Guid.NewGuid().ToString() },
{ "x-amz-crc32", "0" },
{ "x-amzn-ErrorType", "ValidationErrorException" },
}
};
var payloadResponse = new JsonSampleGenerator(service_model, exception).Execute();
webResponse.Headers["Content-Length"] = UTF8Encoding.UTF8.GetBytes(payloadResponse).Length.ToString();
var context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(payloadResponse), true, webResponse, true);
var response = PutRecordResponseUnmarshaller.Instance.UnmarshallException(context, null, System.Net.HttpStatusCode.OK);
InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
}
public void PutRecordMarshallTest()
{
var request = InstantiateClassGenerator.Execute <PutRecordRequest>();
var marshaller = new PutRecordRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content);
Comparer.CompareObjectToJson <PutRecordRequest>(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("PutRecord").ResponseStructure).Execute();
webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(jsonResponse).Length.ToString());
UnmarshallerContext context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(jsonResponse), false, webResponse);
var response = PutRecordResponseUnmarshaller.Instance.Unmarshall(context)
as PutRecordResponse;
InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
}
/// <summary>
/// Initiates the asynchronous execution of the PutRecord operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutRecord 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/PutRecord">REST API Reference for PutRecord Operation</seealso>
public virtual Task <PutRecordResponse> PutRecordAsync(PutRecordRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.Instance;
return(InvokeAsync <PutRecordRequest, PutRecordResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// Initiates the asynchronous execution of the PutRecord operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutRecord 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 EndPutRecord
/// operation.</returns>
public IAsyncResult BeginPutRecord(PutRecordRequest request, AsyncCallback callback, object state)
{
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.Instance;
return(BeginInvoke <PutRecordRequest>(request, marshaller, unmarshaller,
callback, state));
}
public void PutRecordMarshallTest()
{
var operation = service_model.FindOperation("PutRecord");
var request = InstantiateClassGenerator.Execute <PutRecordRequest>();
var marshaller = new PutRecordRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
TestTools.RequestValidator.Validate("PutRecord", request, internalRequest, service_model);
}
/// <summary>
/// Initiates the asynchronous execution of the PutRecord operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutRecord 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 PutRecordAsync(PutRecordRequest request, AmazonServiceCallback <PutRecordRequest, PutRecordResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <PutRecordRequest, PutRecordResponse> responseObject
= new AmazonServiceResult <PutRecordRequest, PutRecordResponse>((PutRecordRequest)req, (PutRecordResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <PutRecordRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// <para>This operation puts a data record into an Amazon Kinesis stream from a producer. This operation must be called to send data from the
/// producer into the Amazon Kinesis stream for real-time ingestion and subsequent processing. The <c>PutRecord</c> operation requires the name
/// of the stream that captures, stores, and transports the data; a partition key; and the data blob itself. The data blob could be a segment
/// from a log file, geographic/location data, website clickstream data, or any other data type.</para> <para>The partition key is used to
/// distribute data across shards. Amazon Kinesis segregates the data records that belong to a data stream into multiple shards, using the
/// partition key associated with each data record to determine which shard a given data record belongs to. </para> <para>Partition keys are
/// Unicode strings, with a maximum length limit of 256 bytes. An MD5 hash function is used to map partition keys to 128-bit integer values and
/// to map associated data records to shards using the hash key ranges of the shards. You can override hashing the partition key to determine
/// the shard by explicitly specifying a hash value using the <c>ExplicitHashKey</c> parameter. For more information, see the <a href="http://docs.aws.amazon.com/kinesis/latest/dev/">Amazon Kinesis Developer Guide</a> .</para> <para> <c>PutRecord</c> returns the shard
/// ID of where the data record was placed and the sequence number that was assigned to the data record.</para> <para>The
/// <c>SequenceNumberForOrdering</c> sets the initial sequence number for the partition key. Later <c>PutRecord</c> requests to the same
/// partition key (from the same client) will automatically increase from <c>SequenceNumberForOrdering</c> , ensuring strict sequential
/// ordering.</para> <para>If a <c>PutRecord</c> request cannot be processed because of insufficient provisioned throughput on the shard
/// involved in the request, <c>PutRecord</c> throws <c>ProvisionedThroughputExceededException</c> . </para> <para>Data records are accessible
/// for only 24 hours from the time that they are added to an Amazon Kinesis stream.</para>
/// </summary>
///
/// <param name="putRecordRequest">Container for the necessary parameters to execute the PutRecord service method on AmazonKinesis.</param>
///
/// <returns>The response from the PutRecord service method, as returned by AmazonKinesis.</returns>
///
/// <exception cref="T:Amazon.Kinesis.Model.ProvisionedThroughputExceededException" />
/// <exception cref="T:Amazon.Kinesis.Model.InvalidArgumentException" />
/// <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<PutRecordResponse> PutRecordAsync(PutRecordRequest putRecordRequest, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.GetInstance();
return Invoke<IRequest, PutRecordRequest, PutRecordResponse>(putRecordRequest, marshaller, unmarshaller, signer, cancellationToken);
}
/// <summary>
/// Initiates the asynchronous execution of the PutRecord operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutRecord 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<PutRecordResponse> PutRecordAsync(PutRecordRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.Instance;
return InvokeAsync<PutRecordRequest,PutRecordResponse>(request, marshaller,
unmarshaller, cancellationToken);
}
/// <summary>
/// Writes a single data record into an Amazon Kinesis Firehose delivery stream. To write
/// multiple data records into a delivery stream, use <a>PutRecordBatch</a>. Applications
/// using these operations are referred to as producers.
///
///
/// <para>
/// 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, etc.
/// </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>
/// Amazon Kinesis Firehose does not maintain data record ordering. If the destination
/// data needs to be re-ordered by the consumer application, the producer should include
/// some form of sequence number in each data record.
/// </para>
///
/// <para>
/// The <a>PutRecord</a> operation returns a <code>RecordId</code>, which is a unique
/// string assigned to each record. Producer applications can use this ID for purposes
/// such as auditability and investigation.
/// </para>
///
/// <para>
/// If the <a>PutRecord</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 PutRecord service method.</param>
///
/// <returns>The response from the PutRecord 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 PutRecordResponse PutRecord(PutRecordRequest request)
{
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.Instance;
return Invoke<PutRecordRequest,PutRecordResponse>(request, marshaller, unmarshaller);
}
public void PutRecordMarshallTest()
{
var request = InstantiateClassGenerator.Execute<PutRecordRequest>();
var marshaller = new PutRecordRequestMarshaller();
var internalRequest = marshaller.Marshall(request);
var jsonRequest = UTF8Encoding.UTF8.GetString(internalRequest.Content);
Comparer.CompareObjectToJson<PutRecordRequest>(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("PutRecord").ResponseStructure).Execute();
webResponse.Headers.Add("Content-Length", UTF8Encoding.UTF8.GetBytes(jsonResponse).Length.ToString());
UnmarshallerContext context = new JsonUnmarshallerContext(Utils.CreateStreamFromString(jsonResponse), false, webResponse);
var response = PutRecordResponseUnmarshaller.Instance.Unmarshall(context)
as PutRecordResponse;
InstantiateClassGenerator.ValidateObjectFullyInstantiated(response);
}
/// <summary>
/// Initiates the asynchronous execution of the PutRecord operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutRecord 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 EndPutRecord
/// operation.</returns>
public IAsyncResult BeginPutRecord(PutRecordRequest request, AsyncCallback callback, object state)
{
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.Instance;
return BeginInvoke<PutRecordRequest>(request, marshaller, unmarshaller,
callback, state);
}
/// <summary>
/// Initiates the asynchronous execution of the PutRecord operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the PutRecord 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 PutRecordAsync(PutRecordRequest request, AmazonServiceCallback<PutRecordRequest, PutRecordResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new PutRecordRequestMarshaller();
var unmarshaller = PutRecordResponseUnmarshaller.Instance;
Action<AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if(callback !=null )
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult<PutRecordRequest,PutRecordResponse> responseObject
= new AmazonServiceResult<PutRecordRequest,PutRecordResponse>((PutRecordRequest)req, (PutRecordResponse)res, ex , ao.State);
callback(responseObject);
};
BeginInvoke<PutRecordRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
IAsyncResult invokePutRecord(PutRecordRequest putRecordRequest, AsyncCallback callback, object state, bool synchronized)
{
IRequest irequest = new PutRecordRequestMarshaller().Marshall(putRecordRequest);
var unmarshaller = PutRecordResponseUnmarshaller.GetInstance();
AsyncResult result = new AsyncResult(irequest, callback, state, synchronized, signer, unmarshaller);
Invoke(result);
return result;
}
