/// <summary> /// A simple function that takes a string and does a ToUpper /// </summary> /// <param name="input"></param> /// <param name="context"></param> /// <returns></returns> public async Task FunctionHandler(DynamoDBEvent dynamoEvent, ILambdaContext context) { var client = new AmazonStepFunctionsClient(); var sfnArn = Environment.GetEnvironmentVariable("STEP_FUNCTION_ARN"); LambdaLogger.Log($"Processing {dynamoEvent.Records.Count()}"); LambdaLogger.Log($"ARN {sfnArn}"); IList <DynamoDBEvent.DynamodbStreamRecord> r = dynamoEvent.Records; foreach (DynamoDBEvent.DynamodbStreamRecord record in dynamoEvent.Records) { if (record.EventName == OperationType.INSERT) { var incoming = record.Dynamodb.NewImage.ToDynamoEntity <PurchaseOrder>(); LambdaLogger.Log($"ID {incoming.PurchaseId}"); LambdaLogger.Log($"Color {incoming.ColorName}"); var request = new StartExecutionRequest() { Input = JsonSerializer.Serialize(new { PurchasedInventory = new object[] { incoming } }), Name = Guid.NewGuid().ToString(), StateMachineArn = sfnArn, }; var resp = await client.StartExecutionAsync(request); if (resp.HttpStatusCode != System.Net.HttpStatusCode.OK) { throw new Exception($"Failed with code {resp.HttpStatusCode}: {JsonSerializer.Serialize(resp.ResponseMetadata)}"); } } } }
static void ExecuteStepFunctionUsingAssumedExistingStateMachineRole() { var options = new AWSOptions() { Profile = "default", Region = RegionEndpoint.EUWest2 }; var assumedRoleResponse = ManualAssume(options).ConfigureAwait(false).GetAwaiter().GetResult(); var assumedCredentials = assumedRoleResponse.Credentials; var amazonStepFunctionsConfig = new AmazonStepFunctionsConfig { RegionEndpoint = RegionEndpoint.EUWest2 }; using (var amazonStepFunctionsClient = new AmazonStepFunctionsClient( assumedCredentials.AccessKeyId, assumedCredentials.SecretAccessKey, amazonStepFunctionsConfig)) { var state = new State { Name = "MyStepFunctions" }; var jsonData1 = JsonConvert.SerializeObject(state); var startExecutionRequest = new StartExecutionRequest { Input = jsonData1, Name = $"SchedulingEngine_{Guid.NewGuid().ToString("N")}", StateMachineArn = "arn:aws:states:eu-west-2:464534050515:stateMachine:StateMachine-z8hrOwmL9CiG" }; var taskStartExecutionResponse = amazonStepFunctionsClient.StartExecutionAsync(startExecutionRequest).ConfigureAwait(false).GetAwaiter().GetResult(); } Console.ReadLine(); }
private async Task <StartExecutionResponse> StartWorkflowInstanceAsync() { StartExecutionResponse status = null; try { LambdaLogger.Log("1. Lambda start1"); List <Quote> quotes = GetQuotesAsPerStage(2, 13);//2 RSM, 13 Submitted, LambdaLogger.Log("1. Lambda start2"); foreach (var item in quotes) { //Check if any Promotion is submitted //LambdaLogger.Log("1. Lambda start3"+ Directory.GetCurrentDirectory() + @"\iam.json"); //_CredentialProfileStoreChain = new CredentialProfileStoreChain( );//@"/iam.json" //LambdaLogger.Log("Profile Location="+_CredentialProfileStoreChain.ProfilesLocation); //AWSCredentials awsCredentials; //if (_CredentialProfileStoreChain.TryGetAWSCredentials("default", out awsCredentials))//local-test-profile //{ // if (awsCredentials != null) // { string inputToStepFunc = "{ \"quoteid\": \"" + item.QuoteID + "\", \"promodesc\" : \"" + item.TPBackground + "\" }"; var aws_access_key_id = Environment.GetEnvironmentVariable("aws_access_key_id"); var aws_secret_access_key = Environment.GetEnvironmentVariable("aws_secret_access_key"); using (AmazonStepFunctionsClient stepfunctions = new AmazonStepFunctionsClient(aws_access_key_id, aws_secret_access_key, Amazon.RegionEndpoint.USEast1)) { LambdaLogger.Log("Gocha credentials going to invoke Step function"); string nameunique = item.QuoteID + "_WF";//+"_" + DateTime.Now.ToString("ddMMyyyyHHmmssfff"); StartExecutionRequest newRequest = new StartExecutionRequest { StateMachineArn = "arn:aws:states:us-east-1:494875521123:stateMachine:ApprovalWorkflow", Input = inputToStepFunc, Name = nameunique }; LambdaLogger.Log("Step Func object is ready to be invoked."); status = await stepfunctions.StartExecutionAsync(newRequest); LambdaLogger.Log("Step Func invoke done" + status.ToString()); } //} //else // LambdaLogger.Log("Null AWS Credentilas found."); //} LambdaLogger.Log("Workflow is created for Quote id = " + item.QuoteID); } } catch (Exception ex) { LambdaLogger.Log("Error" + ex.ToString()); throw ex; } return(status); }
public async Task <NumberPlateTrigger> FunctionHandler(S3Event evnt, ILambdaContext context) { var s3Event = evnt.Records?[0].S3; context.Logger.LogLine("EVENT Received: " + JsonConvert.SerializeObject(s3Event)); if (regExNumberPlate == null) { context.Logger.LogLine("regExNumberPlate is not yet populated. Calling getNumberPlateFromSecretsManager()..."); regExNumberPlate = await getNumberPlateFromSecretsManager(context); context.Logger.LogLine("regExNumberPlate is " + regExNumberPlate); } NumberPlateTrigger result = new NumberPlateTrigger { bucket = s3Event.Bucket.Name, key = s3Event.Object.Key, contentType = "", contentLength = s3Event.Object.Size, charge = int.Parse(Environment.GetEnvironmentVariable("TollgateCharge")), numberPlate = new NumberPlate() { numberPlateRegEx = this.regExNumberPlate, detected = false } }; AWSXRayRecorder recorder = AWSXRayRecorder.Instance; recorder.BeginSubsegment("TollGantry::Detect Number Plate in Captured Image"); recorder.AddMetadata("bucket", s3Event.Bucket.Name); recorder.AddMetadata("key", s3Event.Object.Key); recorder.AddMetadata("regex", this.regExNumberPlate); // // TODO: Call Rekognition to detect text in the captured image // recorder.EndSubsegment(); // // Kick off the step function // context.Logger.LogLine("Starting the state machine"); IAmazonStepFunctions stepFunctionsClient = new AmazonStepFunctionsClient(); await stepFunctionsClient.StartExecutionAsync(new StartExecutionRequest() { StateMachineArn = Environment.GetEnvironmentVariable("NumberPlateProcessStateMachine"), Input = JsonConvert.SerializeObject(result) }); context.Logger.LogLine("State machine started"); return(result); }
private static async Task StartAndMonitorExecution() { string executionName = Guid.NewGuid().ToString(); using (var client = new AmazonStepFunctionsClient(RegionEndpoint.SAEast1)) { // manda executar o Step Function var payload = new SimpleStepFunctionInput { Name = "pirilampo", Number = _rnd.Next() }; var request = new StartExecutionRequest { Input = JsonConvert.SerializeObject(payload, Formatting.None, _jsonSerializerSettings), Name = executionName, StateMachineArn = _stateMachineArn }; Console.WriteLine("Sending:"); Console.WriteLine(request.Input); var response = await client.StartExecutionAsync(request).ConfigureAwait(false); if (response.HttpStatusCode != System.Net.HttpStatusCode.OK) { Console.WriteLine($"Err: {response.HttpStatusCode}"); return; } // verifica o estado da execução var requestStatus = new DescribeExecutionRequest { ExecutionArn = $"{_executionArn}:{executionName}", }; while (true) { var responseStatus = await client.DescribeExecutionAsync(requestStatus).ConfigureAwait(false); if (responseStatus.HttpStatusCode == System.Net.HttpStatusCode.OK && responseStatus.Status == ExecutionStatus.SUCCEEDED) { dynamic parsed = JsonConvert.DeserializeObject(responseStatus.Output); Console.WriteLine(JsonConvert.SerializeObject(parsed, Formatting.Indented, _jsonSerializerSettings)); break; } Console.WriteLine($"{responseStatus.Status}..."); await Task.Delay(1500).ConfigureAwait(false); } } }
public async Task FunctionHandler(S3Event evnt, ILambdaContext context) { var s3Event = evnt.Records?[0].S3; if (s3Event == null) { return; } FileInfo fileInfo = new FileInfo { Bucket = s3Event.Bucket.Name, Key = s3Event.Object.Key }; string input = JsonConvert.SerializeObject(fileInfo); StartExecutionResponse response = await functionsClient.StartExecutionAsync(new StartExecutionRequest { Input = input, Name = Guid.NewGuid().ToString("N"), StateMachineArn = "arn:aws:states:us-east-1:518495728486:stateMachine:hackathon-2018-chegg" }).ConfigureAwait(false); }
public async Task ExecuteAsync(WorkerJobHelper <WorkflowJob> job) { using (var stepFunctionClient = new AmazonStepFunctionsClient()) await stepFunctionClient.StartExecutionAsync( new StartExecutionRequest { Input = new { Input = job.JobInput, NotificationEndpoint = new NotificationEndpoint { HttpEndpoint = job.JobAssignmentId + "/notifications" } }.ToMcmaJson().ToString(), StateMachineArn = job.Request.GetRequiredContextVariable($"{job.Profile.Name}Id") }); }
public async Task <string> StartFunction(string stateMachineArn, string input, string name = null) { var response = await amazonStepFunctionsClient.StartExecutionAsync(new StartExecutionRequest() { StateMachineArn = stateMachineArn, Input = input, Name = name }); switch (response.HttpStatusCode) { case HttpStatusCode.Accepted: case HttpStatusCode.OK: return(response.ExecutionArn); default: return(null); } }
internal static async Task ProcessJobAssignmentAsync(WorkflowServiceWorkerRequest @event) { var resourceManager = @event.Request.GetAwsV4ResourceManager(); var table = new DynamoDbTable(@event.Request.StageVariables["TableName"]); var jobAssignmentId = @event.JobAssignmentId; try { // 1. Setting job assignment status to RUNNING await UpdateJobAssignmentStatusAsync(resourceManager, table, jobAssignmentId, "RUNNING", null); // 2. Retrieving WorkflowJob var workflowJob = await RetrieveWorkflowJobAsync(resourceManager, table, jobAssignmentId); // 3. Retrieve JobProfile var jobProfile = await RetrieveJobProfileAsync(resourceManager, workflowJob); // 4. Retrieve job inputParameters var jobInput = workflowJob.JobInput; // 5. Check if we support jobProfile and if we have required parameters in jobInput ValidateJobProfile(jobProfile, jobInput); // 6. Launch the appropriate workflow var workflowInput = new { Input = jobInput, NotificationEndpoint = new NotificationEndpoint { HttpEndpoint = jobAssignmentId + "/notifications" } }; var startExecutionRequest = new StartExecutionRequest { Input = workflowInput.ToMcmaJson().ToString() }; switch (jobProfile.Name) { case JOB_PROFILE_CONFORM_WORKFLOW: startExecutionRequest.StateMachineArn = @event.Request.StageVariables["ConformWorkflowId"]; break; case JOB_PROFILE_AI_WORKFLOW: startExecutionRequest.StateMachineArn = @event.Request.StageVariables["AiWorkflowId"]; break; } var stepFunctionClient = new AmazonStepFunctionsClient(); var startExecutionResponse = await stepFunctionClient.StartExecutionAsync(startExecutionRequest); // 7. saving the executionArn on the jobAssignment var jobAssignment = await GetJobAssignmentAsync(table, jobAssignmentId); //TODO: Additional properties on JobAssignment? How to handle this? //jobAssignment.WorkflowExecutionId = startExecutionResponse.ExecutionArn; await PutJobAssignmentAsync(resourceManager, table, jobAssignmentId, jobAssignment); } catch (Exception error) { Logger.Exception(error); try { await UpdateJobAssignmentStatusAsync(resourceManager, table, jobAssignmentId, "FAILED", error.ToString()); } catch (Exception innerError) { Logger.Exception(innerError); } } }
public async Task Can_be_invoked_from_step_functions_local() { // 1. Create the StepFunctions Client var credentials = new BasicAWSCredentials("not", "used"); var config = new AmazonStepFunctionsConfig { ServiceURL = _stepFunctionsServiceUrl.ToString() }; var client = new AmazonStepFunctionsClient(credentials, config); // 2. Create step machine with a single task the invokes a lambda function // The FunctionName contains the lambda to be invoked. var request = new CreateStateMachineRequest { Name = "Foo", Type = StateMachineType.STANDARD, Definition = @"{ ""Comment"": ""A Hello World example demonstrating various state types of the Amazon States Language"", ""StartAt"": ""Invoke Lambda function"", ""States"": { ""Invoke Lambda function"": { ""Type"": ""Task"", ""Resource"": ""arn:aws:states:::lambda:invoke"", ""Parameters"": { ""FunctionName"": ""arn:aws:lambda:us-east-1:123456789012:function:SimpleLambdaFunction:$LATEST"", ""Payload"": { ""Input.$"": ""$.Payload"" } }, ""End"": true } } }" }; var createStateMachineResponse = await client.CreateStateMachineAsync(request); // 3. Create a StepFunction execution. var startExecutionRequest = new StartExecutionRequest { Name = Guid.NewGuid().ToString(), StateMachineArn = createStateMachineResponse.StateMachineArn, Input = @"{ ""Payload"": { ""Foo"": ""Bar"" } }" }; var startExecutionResponse = await client.StartExecutionAsync(startExecutionRequest); var getExecutionHistoryRequest = new GetExecutionHistoryRequest { ExecutionArn = startExecutionResponse.ExecutionArn, IncludeExecutionData = true, }; // 4. Poll and wait for the while (true) { var getExecutionHistoryResponse = await client.GetExecutionHistoryAsync(getExecutionHistoryRequest); var historyEvent = getExecutionHistoryResponse.Events.Last(); if (historyEvent.ExecutionSucceededEventDetails != null) { _outputHelper.WriteLine("Execution succeeded"); _outputHelper.WriteLine(historyEvent.ExecutionSucceededEventDetails.Output); break; } if (historyEvent.ExecutionFailedEventDetails != null) { _outputHelper.WriteLine("Execution failed"); _outputHelper.WriteLine(historyEvent.ExecutionFailedEventDetails.Cause); break; } } }
public Status ProcessRequest(ResolverRequest request) { Status status = new Status(); status.Id = request.Id; status.ActionId = request.ActionId; try { String cueId = request.CueId; Config config = JsonTools.Convert <Config>(request.Signal.Cues[cueId].Resolver.Config); StepFunctionArn arn = new StepFunctionArn(config.Arn); RegionEndpoint region = RegionEndpoint.GetBySystemName(System.Environment.GetEnvironmentVariable("AWS_REGION")); if (!String.IsNullOrEmpty(arn.Region)) { region = RegionEndpoint.GetBySystemName(arn.Region); } AmazonStepFunctionsClient client = new AmazonStepFunctionsClient(region); // Set Region StartExecutionRequest exeRequest = new StartExecutionRequest { StateMachineArn = config.Arn, Input = JsonTools.Serialize(request) }; if (config.UseDefaultName == false) { if (String.IsNullOrWhiteSpace(config.ExecutionName)) { exeRequest.Name = $"syntinel-{request.Id}-{request.ActionId}"; } else { exeRequest.Name = config.ExecutionName; } } Task <StartExecutionResponse> t = client.StartExecutionAsync(exeRequest); t.Wait(30000); StartExecutionResponse response = t.Result; if (response.HttpStatusCode == System.Net.HttpStatusCode.OK) { StepFunctionArn eArn = new StepFunctionArn(response.ExecutionArn); status.NewStatus = StatusType.SentToResolver; status.Message = $"Request Sent To Step Function [{eArn.Name}]. Execution Name [{eArn.ExecutionName}]."; } else { status.NewStatus = StatusType.Error; status.Message = $"Error Sending To Step Function [{arn.Name}]. {response.HttpStatusCode}"; } } catch (Exception e) { status.NewStatus = StatusType.Error; status.Message = e.Message; } return(status); }