/// <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); }