/// <summary>
///
/// </summary>
private static void CreateStream()
{
CreateStreamRequest createStreamRequest = new CreateStreamRequest();
createStreamRequest.StreamName = myStreamName;
oClient.CreateStream(createStreamRequest);
}
internal CreateStreamResponse CreateStream(CreateStreamRequest request)
{
var marshaller = new CreateStreamRequestMarshaller();
var unmarshaller = CreateStreamResponseUnmarshaller.Instance;
return(Invoke <CreateStreamRequest, CreateStreamResponse>(request, marshaller, unmarshaller));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateStream operation.
/// <seealso cref="Amazon.Kinesis.IAmazonKinesis.CreateStream"/>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateStream 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 <CreateStreamResponse> CreateStreamAsync(CreateStreamRequest request, CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new CreateStreamRequestMarshaller();
var unmarshaller = CreateStreamResponseUnmarshaller.GetInstance();
return(Invoke <IRequest, CreateStreamRequest, CreateStreamResponse>(request, marshaller, unmarshaller, signer, cancellationToken));
}
/// <summary>
/// Starts the provisioning of a new stream.
/// The stream will be created in the given compartment id or stream pool id, depending on which parameter is specified.
/// Compartment id and stream pool id cannot be specified at the same time.
/// To track the progress of the provisioning, you can periodically call {@link #getStream(GetStreamRequest) getStream}.
/// In the response, the `lifecycleState` parameter of the {@link Stream} object tells you its current state.
///
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/streaming/CreateStream.cs.html">here</a> to see an example of how to use CreateStream API.</example>
public async Task <CreateStreamResponse> CreateStream(CreateStreamRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called createStream");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/streams".Trim('/')));
HttpMethod method = new HttpMethod("POST");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <CreateStreamResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"CreateStream failed with error: {e.Message}");
throw;
}
}
/// <summary>
/// Creates a new Kinesis video stream.
///
///
/// <para>
/// 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.
/// </para>
///
/// <para>
/// <code>CreateStream</code> is an asynchronous operation.
/// </para>
///
/// <para>
/// For information about how the service works, see <a href="http://docs.aws.amazon.com/kinesisvideostreams/latest/dg/how-it-works.html">How
/// it Works</a>.
/// </para>
///
/// <para>
/// You must have permissions for the <code>KinesisVideo:CreateStream</code> action.
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the CreateStream service method.</param>
///
/// <returns>The response from the CreateStream service method, as returned by KinesisVideo.</returns>
/// <exception cref="Amazon.KinesisVideo.Model.AccountStreamLimitExceededException">
/// The number of streams created for the account is too high.
/// </exception>
/// <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.DeviceStreamLimitExceededException">
/// Not implemented.
/// </exception>
/// <exception cref="Amazon.KinesisVideo.Model.InvalidArgumentException">
/// The value for this input parameter is invalid.
/// </exception>
/// <exception cref="Amazon.KinesisVideo.Model.InvalidDeviceException">
/// Not implemented.
/// </exception>
/// <exception cref="Amazon.KinesisVideo.Model.ResourceInUseException">
/// The stream is currently not available for this operation.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/kinesisvideo-2017-09-30/CreateStream">REST API Reference for CreateStream Operation</seealso>
public virtual CreateStreamResponse CreateStream(CreateStreamRequest request)
{
var marshaller = CreateStreamRequestMarshaller.Instance;
var unmarshaller = CreateStreamResponseUnmarshaller.Instance;
return(Invoke <CreateStreamRequest, CreateStreamResponse>(request, marshaller, unmarshaller));
}
private async Task WriteToStream()
{
const string myStreamName = "myTestStream";
const int myStreamSize = 1;
try
{
var createStreamRequest = new CreateStreamRequest();
createStreamRequest.StreamName = myStreamName;
createStreamRequest.ShardCount = myStreamSize;
var createStreamReq = createStreamRequest;
var existingStreams = await kinesisClient.ListStreamsAsync();
if (!existingStreams.StreamNames.Contains(myStreamName))
{
var CreateStreamResponse = await kinesisClient.CreateStreamAsync(createStreamReq);
Console.WriteLine("Created Stream : " + myStreamName);
}
}
catch (ResourceInUseException)
{
Console.Error.WriteLine("Producer is quitting without creating stream " + myStreamName +
" to put records into as a stream of the same name already exists.");
Environment.Exit(1);
}
await WaitForStreamToBecomeAvailableAsync(myStreamName);
Console.Error.WriteLine("Putting records in stream : " + myStreamName);
// Write 10 UTF-8 encoded records to the stream.
for (int j = 0; j < 10; ++j)
{
byte[] dataAsBytes = Encoding.UTF8.GetBytes("testdata-" + j);
using (MemoryStream memoryStream = new MemoryStream(dataAsBytes))
{
try
{
PutRecordRequest requestRecord = new PutRecordRequest();
requestRecord.StreamName = myStreamName;
requestRecord.PartitionKey = "url-response-times";
requestRecord.Data = memoryStream;
PutRecordResponse responseRecord =
await kinesisClient.PutRecordAsync(requestRecord);
Console.WriteLine("Successfully sent record to Kinesis. Sequence number: {0}",
responseRecord.SequenceNumber);
}
catch (Exception ex)
{
Console.WriteLine("Failed to send record to Kinesis. Exception: {0}", ex.Message);
}
}
}
Console.ReadLine();
}
/// <summary>
/// Initiates the asynchronous execution of the CreateStream operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateStream 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/CreateStream">REST API Reference for CreateStream Operation</seealso>
public virtual Task <CreateStreamResponse> CreateStreamAsync(CreateStreamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = CreateStreamRequestMarshaller.Instance;
var unmarshaller = CreateStreamResponseUnmarshaller.Instance;
return(InvokeAsync <CreateStreamRequest, CreateStreamResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
internal virtual CreateStreamResponse CreateStream(CreateStreamRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateStreamRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateStreamResponseUnmarshaller.Instance;
return(Invoke <CreateStreamResponse>(request, options));
}
/// <summary>
/// Initiates the asynchronous execution of the CreateStream operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateStream 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/CreateStream">REST API Reference for CreateStream Operation</seealso>
public virtual Task <CreateStreamResponse> CreateStreamAsync(CreateStreamRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = CreateStreamRequestMarshaller.Instance;
options.ResponseUnmarshaller = CreateStreamResponseUnmarshaller.Instance;
return(InvokeAsync <CreateStreamResponse>(request, options, cancellationToken));
}
/// <summary>
/// This method verifies your credentials, creates a Kinesis stream, waits for the stream
/// to become active, then puts 10 records in it, and (optionally) deletes the stream.
/// </summary>
public async static Task Main(string[] args)
{
const string myStreamName = "myTestStream";
const int myStreamSize = 1;
try
{
var createStreamRequest = new CreateStreamRequest();
createStreamRequest.StreamName = myStreamName;
createStreamRequest.ShardCount = myStreamSize;
var createStreamReq = createStreamRequest;
await kinesisClient.CreateStreamAsync(createStreamReq);
Console.Error.WriteLine("Created Stream : " + myStreamName);
}
catch (ResourceInUseException)
{
Console.Error.WriteLine("Producer is quitting without creating stream " + myStreamName +
" to put records into as a stream of the same name already exists.");
Environment.Exit(1);
}
await WaitForStreamToBecomeAvailable(myStreamName);
Console.Error.WriteLine("Putting records in stream : " + myStreamName);
// Write 10 UTF-8 encoded records to the stream.
for (int j = 0; j < 10; ++j)
{
PutRecordRequest requestRecord = new PutRecordRequest();
requestRecord.StreamName = myStreamName;
requestRecord.Data = new MemoryStream(Encoding.UTF8.GetBytes("testData-" + j));
requestRecord.PartitionKey = "partitionKey-" + j;
var putResult = await kinesisClient.PutRecordAsync(requestRecord);
Console.Error.WriteLine(
String.Format("Successfully putrecord {0}:\n\t partition key = {1,15}, shard ID = {2}",
j, requestRecord.PartitionKey, putResult.ShardId));
}
// Uncomment the following if you wish to delete the stream here.
//Console.Error.WriteLine("Deleting stream : " + myStreamName);
//DeleteStreamRequest deleteStreamReq = new DeleteStreamRequest();
//deleteStreamReq.StreamName = myStreamName;
//try
//{
// kinesisClient.DeleteStream(deleteStreamReq);
// Console.Error.WriteLine("Stream is now being deleted : " + myStreamName);
//}
//catch (ResourceNotFoundException ex)
//
// Console.Error.WriteLine("Stream could not be found; " + ex);
//}
//catch (AmazonClientException ex)
//{
// Console.Error.WriteLine("Error deleting stream; " + ex);
//}
}
/// <summary>
/// 创建无转储任务的通道
/// </summary>
/// <param name="streamName"> 通道名称</param>
/// <param name="partitionCount">分区数</param>
/// <returns></returns>
public static ResponseResult CreateStream(string streamName, int partitionCount)
{
DISIngestionClient dic = new DISIngestionClient();
var request = new CreateStreamRequest
{
//通道名称
StreamName = streamName,
//通道类型
StreamType = "ADVANCED",
//分区数量
PartitionCount = partitionCount,
//源数据类型有BLOB、JSON、CSV、FILE
DataType = "JSON",
//生命周期
DataDuration = 7 * 24,
};
//通道的标签,可选参数，如果不设置，则注释该代码片段
request.Tags = new List <Tag>();
request.Tags.Add(new Tag()
{
Key = "B key",
Value = "BV value"
});
request.Tags.Add(new Tag()
{
Key = "B key",
Value = "BV value2"
});
//源数据转储为parquet和carbon格式时必选
if (request.DataType.Equals("JSON") || request.DataType.Equals("CSV"))
{
//用于描述用户JOSN、CSV格式的源数据结构
//创建通道时源数据 Schema，Json格式的数据类型的{"key":"value"}转为源数据 Schema格式{"type":"record","name":"RecordName","fields":[{"name":"key","type":"string","doc":"Type inferred from '\"value\"'"}]}
request.DataSchema = "{\"type\":\"record\",\"name\":\"RecordName\",\"fields\":[{\"name\":\"key\",\"type\":\"string\",\"doc\":\"Type inferred from '\\\"value\\\"'\"}]}";
}
//源数据转储为FILE时必选
if (request.DataType.Equals("FILE"))
{
request.ObsDestinationDescriptor = new List <ObsDestinationDescriptor>();
request.ObsDestinationDescriptor.Add(new ObsDestinationDescriptor()
{
//在IAM中创建委托的名称
AgencyName = "all",
//存储该通道数据的OBS桶名称
ObsBucketPath = "obs-shawnobstest"
});
}
ResponseResult response = dic.CreateStream(request);
Console.WriteLine(response);
return(response);
}
private async Task CreateMeasurementsStreamAsync()
{
_logger.LogWarning("Creating Measurements Stream: {0}", _measurementsStreamName);
CreateStreamRequest request = new CreateStreamRequest
{
ShardCount = 1,
StreamName = _measurementsStreamName
};
await _client.CreateStreamAsync(request);
}
/// <summary>
/// Creates a new Kinesis stream.
/// </summary>
/// <param name="client">An initialized Kinesis client.</param>
/// <param name="streamName">The name for the new stream.</param>
/// <param name="shardCount">The number of shards the new stream will
/// use. The throughput of the stream is a function of the number of
/// shards; more shards are required for greater provisioned
/// throughput.</param>
/// <returns>A Boolean value indicating whether the stream was created.</returns>
public static async Task <bool> CreateNewStreamAsync(IAmazonKinesis client, string streamName, int shardCount)
{
var request = new CreateStreamRequest
{
StreamName = streamName,
ShardCount = shardCount,
};
var response = await client.CreateStreamAsync(request);
return(response.HttpStatusCode == System.Net.HttpStatusCode.OK);
}
public static string CreateVideoStream(string streamName)
{
string streamArn = "";
try
{
List <StreamInfo> streamlList = GetVideoStreamList();
if (streamlList != null)
{
if (streamlList.FindAll(videoStream => videoStream.StreamName == streamName).Count > 0)
{
streamArn = "contain";
}
else
{
AmazonKinesisVideoClient kinesisVideoClient;
using (kinesisVideoClient = new AmazonKinesisVideoClient(Models.MyAWSConfigs.KinesisRegion))
{
CreateStreamRequest createStreamRequest = new CreateStreamRequest()
{
StreamName = streamName,
DataRetentionInHours = 1,
MediaType = "video/h264",
};
CreateStreamResponse createStreamResponse = kinesisVideoClient.CreateStream(createStreamRequest);
if (createStreamResponse.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
streamArn = createStreamResponse.StreamARN;
}
else
{
Console.WriteLine("Error creating kinesis video stream");
}
}
}
}
}
catch (AmazonKinesisVideoException e)
{
Console.WriteLine("AmazonKinesisVideoException: " + e);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
}
return(streamArn);
}
private static async Task CreateStream()
{
var request = new CreateStreamRequest
{
Scope = ScopeName,
Stream = StreamName,
ScalingPolicy = CreateScalingPolicy()
};
var response = await _client.CreateStreamAsync(request);
//if the stream already existed, response.Created is false
Console.WriteLine("Stream created: " + response.Created);
}
/// <summary>
/// <para>This operation adds a new Amazon Kinesis stream to your AWS account. A stream captures and transports data records that are
/// continuously emitted from different data sources or <i>producers</i> .
/// Scale-out within an Amazon Kinesis stream is explicitly supported by means of shards, which are uniquely identified groups of
/// data records in an Amazon Kinesis stream.</para> <para>You specify and control the number of shards that a stream is composed of. Each open
/// shard can support up to 5 read transactions per second, up to a maximum total of 2 MB of data read per second. Each shard can support up to
/// 1000 write transactions per second, up to a maximum total of 1 MB data written per second. You can add shards to a stream if the amount of
/// data input increases and you can remove shards if the amount of data input decreases.</para> <para>The stream name identifies the stream.
/// The name is scoped to the AWS account used by the application. It is also scoped by region. That is, two streams in two different accounts
/// can have the same name, and two streams in the same account, but in two different regions, can have the same name. </para> <para>
/// <c>CreateStream</c> is an asynchronous operation. Upon receiving a <c>CreateStream</c> request, Amazon Kinesis immediately returns and sets
/// the stream status to CREATING. After the stream is created, Amazon Kinesis sets the stream status to ACTIVE. You should perform read and
/// write operations only on an ACTIVE stream. </para> <para>You receive a <c>LimitExceededException</c> when making a <c>CreateStream</c>
/// request if you try to do one of the following:</para>
/// <ul>
/// <li>Have more than five streams in the CREATING state at any point in time.</li>
/// <li>Create more shards than are authorized for your account.</li>
///
/// </ul>
/// <para> <b>Note:</b> The default limit for an AWS account is 10 shards per stream. If you need to create a stream with more than 10 shards,
/// <a href="http://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html">contact AWS Support</a> to increase the limit on your
/// account.</para> <para>You can use the <c>DescribeStream</c> operation to check the stream status, which is returned in <c>StreamStatus</c>
/// .</para> <para> <c>CreateStream</c> has a limit of 5 transactions per second per account.</para>
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateStream service method on
/// AmazonKinesis.</param>
///
/// <exception cref="T:Amazon.Kinesis.Model.LimitExceededException" />
/// <exception cref="T:Amazon.Kinesis.Model.ResourceInUseException" />
/// <exception cref="T:Amazon.Kinesis.Model.InvalidArgumentException" />
public CreateStreamResponse CreateStream(CreateStreamRequest request)
{
var task = CreateStreamAsync(request);
try
{
return(task.Result);
}
catch (AggregateException e)
{
ExceptionDispatchInfo.Capture(e.InnerException).Throw();
return(null);
}
}
private static async Task <Stream> CreateStream(StreamAdminClient client, string compartmentId, string streamName, int partitions)
{
logger.Info($"Creating stream {streamName} with {partitions} partitions");
CreateStreamDetails createStreamDetails = new CreateStreamDetails
{
CompartmentId = compartmentId,
Name = streamName,
Partitions = partitions
};
CreateStreamRequest createStreamRequest = new CreateStreamRequest
{
CreateStreamDetails = createStreamDetails
};
CreateStreamResponse createStreamResponse = await client.CreateStream(createStreamRequest);
return(createStreamResponse.Stream);
}
/// <summary>
/// Initiates the asynchronous execution of the CreateStream operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the CreateStream 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 CreateStreamAsync(CreateStreamRequest request, AmazonServiceCallback <CreateStreamRequest, CreateStreamResponse> callback, AsyncOptions options = null)
{
options = options == null?new AsyncOptions():options;
var marshaller = new CreateStreamRequestMarshaller();
var unmarshaller = CreateStreamResponseUnmarshaller.Instance;
Action <AmazonWebServiceRequest, AmazonWebServiceResponse, Exception, AsyncOptions> callbackHelper = null;
if (callback != null)
{
callbackHelper = (AmazonWebServiceRequest req, AmazonWebServiceResponse res, Exception ex, AsyncOptions ao) => {
AmazonServiceResult <CreateStreamRequest, CreateStreamResponse> responseObject
= new AmazonServiceResult <CreateStreamRequest, CreateStreamResponse>((CreateStreamRequest)req, (CreateStreamResponse)res, ex, ao.State);
callback(responseObject);
}
}
;
BeginInvoke <CreateStreamRequest>(request, marshaller, unmarshaller, options, callbackHelper);
}
/// <summary>
/// 创建通道
/// </summary>
/// <param name="createStreamRequest"></param>
/// <returns></returns>
public ResponseResult CreateStream(CreateStreamRequest createStreamRequest)
{
ObsWebServiceRequest obsWebServiceRequest = new DISWebServiceRequest();
IRequest requestobs = new DISDefaultRequest(obsWebServiceRequest, Constants.SERVICENAME)
{
HttpMethod = HttpMethodName.POST.ToString()
};
var resourcePath = ResourcePathBuilder.Standard()
.WithProjectId(_disConfig.GetProjectId())
.WithResource(new StreamResource(null, ""))
.Build();
requestobs.ResourcePath = resourcePath;
var results = this.Request <ResponseResult>(createStreamRequest, requestobs);
return(results);
}
static CreateStreamResponse CreateStream(IAmazonKinesis kinesisClient, string streamName, int shardCount)
{
var request = new CreateStreamRequest {
StreamName = streamName, ShardCount = shardCount
};
try
{
CreateStreamResponse response = kinesisClient.CreateStream(request);
return(response);
}
catch (AmazonServiceException e)
{
var error = string.Format("Failed to create stream '{0}'. Reason: {1}", streamName, e.Message);
SelfLog.WriteLine(error);
return(null);
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
CreateStreamRequest request;
try
{
request = new CreateStreamRequest
{
CreateStreamDetails = CreateStreamDetails,
OpcRequestId = OpcRequestId
};
response = client.CreateStream(request).GetAwaiter().GetResult();
WriteOutput(response, response.Stream);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
/// <summary>
/// Kinesis Stream からイベントを受け取り、Kinesis Streamへデータを書き込む関数です
/// ローカル開発環境として Kinesalite を使用しています
/// </summary>
/// <param name="kinesisEvent"></param>
/// <param name="context"></param>
/// <returns></returns>
public async Task FunctionHandler(KinesisEvent kinesisEvent, ILambdaContext context)
{
context.Logger.LogLine($"Beginning to process {kinesisEvent.Records.Count} records...");
// Kinesis Eventからレコードを取得し、ループ処理を行う
foreach (var record in kinesisEvent.Records)
{
context.Logger.LogLine($"Event ID: {record.EventId}");
context.Logger.LogLine($"Event Name: {record.EventName}");
var recordData = GetRecordContents(record.Kinesis);
context.Logger.LogLine($"Record Data:");
context.Logger.LogLine(recordData);
}
#region ローカル開発用のコード
// Kinesis Stream の作成, 通常は AWSコンソール より作成する
var request = new CreateStreamRequest
{
ShardCount = 1,
StreamName = _streamName
};
var client = new AmazonKinesisClient(new AmazonKinesisConfig
{
ServiceURL = _serviceURL
});
var response = await client.ListStreamsAsync();
if (!response.StreamNames.Any(_ => _ == _streamName))
{
await client.CreateStreamAsync(request);
}
#endregion
// Kinesis Stream に対してデータを書き込む
foreach (var i in Enumerable.Range(1, 10))
{
using (var memory = new MemoryStream(Encoding.UTF8.GetBytes($"Put Data:{i}")))
{
try
{
var req = new PutRecordRequest
{
StreamName = _streamName,
PartitionKey = "url-response-times",
Data = memory
};
var res = await client.PutRecordAsync(req);
context.Logger.LogLine($"Successfully sent record to Kinesis. Sequence number: {res.SequenceNumber}.");
}
catch (Exception ex)
{
context.Logger.LogLine($"Failed to send record to Kinesis. Exception: {ex.Message}.");
}
}
context.Logger.LogLine("Stream processing complete.");
}
}
/// <summary>
/// This operation adds a new Amazon Kinesis stream to your AWS account.
///
/// More info: http://docs.aws.amazon.com/kinesis/latest/APIReference/API_CreateStream.html
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public CreateStreamResponse CreateStream(CreateStreamRequest request)
{
return(Invoke <CreateStreamResponse>(request, "CreateStream"));
}
public async Task TestCreate()
{
// ARRANGE
AWSConfigs.AWSProfilesLocation = $"{Environment.GetEnvironmentVariable("UserProfile")}\\.aws\\credentials";
string StreamName = "test-stream";
string PresignedUrlBucket = "pre-sign-url-bucket";
string AccountNumber = "123456789012";
string Region = "us-east-1";
IAmazonS3 S3Client = new AmazonS3Client();
GetPreSignedUrlRequest Req = new GetPreSignedUrlRequest()
{
BucketName = PresignedUrlBucket,
Key = "result.txt",
Expires = DateTime.Now.AddMinutes(2),
Protocol = Protocol.HTTPS,
Verb = HttpVerb.PUT
};
string PreSignedUrl = S3Client.GetPreSignedURL(Req);
string Json = $@"
{{
""requestType"":""create"",
""responseUrl"":""{PreSignedUrl}"",
""stackId"":""arn:aws:cloudformation:{Region}:{AccountNumber}:stack/stack-name/{Guid.NewGuid().ToString()}"",
""requestId"":""12345678"",
""resourceType"":""Custom::KinesisStreamAwaiter"",
""logicalResourceId"":""KinesisStreamAwaiter"",
""resourceProperties"":{{
""StreamName"":""{StreamName}""
}}
}}";
CustomResourceRequest Request = JsonConvert.DeserializeObject <CustomResourceRequest>(Json);
TestLambdaLogger TestLogger = new TestLambdaLogger();
TestClientContext ClientContext = new TestClientContext();
TestLambdaContext Context = new TestLambdaContext()
{
FunctionName = "KinesisStreamAwaiter",
FunctionVersion = "1",
Logger = TestLogger,
ClientContext = ClientContext,
LogGroupName = "aws/lambda/KinesisStreamAwaiter",
LogStreamName = Guid.NewGuid().ToString(),
RemainingTime = TimeSpan.FromSeconds(300)
};
Entrypoint Entrypoint = new Entrypoint();
// ACT
IAmazonKinesis KinesisClient = new AmazonKinesisClient();
CreateStreamRequest CreateReq = new CreateStreamRequest()
{
ShardCount = 1,
StreamName = StreamName
};
CreateStreamResponse CreateResponse = await KinesisClient.CreateStreamAsync(CreateReq);
try
{
CustomResourceResult Response = await Entrypoint.ExecuteAsync(Request, Context);
// ASSERT
Assert.True(Response.IsSuccess);
}
finally
{
DeleteStreamRequest DeleteReq = new DeleteStreamRequest()
{
StreamName = StreamName
};
await KinesisClient.DeleteStreamAsync(DeleteReq);
}
}
/// <summary>
/// This method verifies your credentials, creates a Kinesis stream, waits for the stream
/// to become active, then puts 10 records in it, and (optionally) deletes the stream.
/// </summary>
public static void Main(string[] args)
{
const string myStreamName = "kclnetsample";
const int myStreamSize = 1;
try
{
var createStreamRequest = new CreateStreamRequest();
createStreamRequest.StreamName = myStreamName;
createStreamRequest.ShardCount = myStreamSize;
var createStreamReq = createStreamRequest;
var CreateStreamResponse = kinesisClient.CreateStreamAsync(createStreamReq).Result;
Console.Error.WriteLine("Created Stream : " + myStreamName);
}
catch (AggregateException ae)
{
ae.Handle((x) =>
{
if (x is ResourceInUseException)
{
Console.Error.WriteLine("Producer is not creating stream " + myStreamName +
" to put records into as a stream of the same name already exists.");
return(true);
}
return(false); // Let anything else stop the application.
});
}
WaitForStreamToBecomeAvailable(myStreamName);
Console.Error.WriteLine("Putting records in stream : " + myStreamName);
// Write 10 UTF-8 encoded records to the stream.
for (int j = 0; j < 10; ++j)
{
PutRecordRequest requestRecord = new PutRecordRequest();
requestRecord.StreamName = myStreamName;
requestRecord.Data = new MemoryStream(Encoding.UTF8.GetBytes("testData-" + j));
requestRecord.PartitionKey = "partitionKey-" + j;
var putResultResponse = kinesisClient.PutRecordAsync(requestRecord).Result;
Console.Error.WriteLine(
String.Format("Successfully putrecord {0}:\n\t partition key = {1,15}, shard ID = {2}",
j, requestRecord.PartitionKey, putResultResponse.ShardId));
}
// Uncomment the following if you wish to delete the stream here.
//Console.Error.WriteLine("Deleting stream : " + myStreamName);
//DeleteStreamRequest deleteStreamReq = new DeleteStreamRequest();
//deleteStreamReq.StreamName = myStreamName;
//try
//{
// kinesisClient.DeleteStream(deleteStreamReq);
// Console.Error.WriteLine("Stream is now being deleted : " + myStreamName);
//}
//catch (ResourceNotFoundException ex)
//
// Console.Error.WriteLine("Stream could not be found; " + ex);
//}
//catch (AmazonClientException ex)
//{
// Console.Error.WriteLine("Error deleting stream; " + ex);
//}
}
public void CreateStreamAsync(CreateStreamRequest request, AmazonServiceCallback <CreateStreamRequest, CreateStreamResponse> callback, AsyncOptions options = null)
{
throw new System.NotImplementedException();
}
public static string CreateDataStream(string streamName)
{
string streamArn = "";
try
{
List <string> streamlList = GetDataStreamList();
if (streamlList != null)
{
if (streamlList.FindAll(dataStreamName => dataStreamName == streamName).Count > 0)
{
streamArn = "contain";
}
else
{
AmazonKinesisClient kinesisClient;
using (kinesisClient = new AmazonKinesisClient(Models.MyAWSConfigs.KinesisRegion))
{
CreateStreamRequest createStreamRequest = new CreateStreamRequest()
{
StreamName = streamName,
ShardCount = 1,
};
CreateStreamResponse createStreamResponse = kinesisClient.CreateStream(createStreamRequest);
if (createStreamResponse.HttpStatusCode == System.Net.HttpStatusCode.OK)
{
StreamDescriptionSummary streamSummary = DescribeDataStream(streamName);
if (streamSummary != null)
{
streamArn = streamSummary.StreamARN;
while (streamSummary.StreamStatus != StreamStatus.ACTIVE ||
streamSummary.StreamStatus == StreamStatus.CREATING)
{
Thread.Sleep(1 * 1000);
streamSummary = DescribeDataStream(streamName);
if (streamSummary == null)
{
streamArn = "";
break;
}
}
}
}
else
{
Console.WriteLine("Error creating kinesis data stream");
}
}
}
}
}
catch (AmazonKinesisException e)
{
Console.WriteLine("AmazonKinesisException: " + e);
}
catch (Exception e)
{
Console.WriteLine("Error: " + e);
}
return(streamArn);
}
