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(); }
public virtual async Task StartPipelineIfExists(GithubEvent payload) { try { var accountId = Environment.GetEnvironmentVariable("AWS_ACCOUNT_ID"); var region = Environment.GetEnvironmentVariable("AWS_REGION"); var pushEventInput = payload is PushEvent pushEvent?Serialize(pushEvent) : null; var prEventInput = payload is PullRequestEvent pullEvent?Serialize(pullEvent) : null; var input = pushEventInput ?? prEventInput; var stateMachineArn = $"arn:aws:states:{region}:{accountId}:stateMachine:{payload.Repository.Name}-cicd-pipeline"; var request = new StartExecutionRequest { StateMachineArn = stateMachineArn, Input = input }; if (payload.Ref.StartsWith("refs/heads/")) { request.Name = payload.HeadCommitId; } var response = await stepFunctionsClient.StartExecutionAsync(request); logger.LogInformation($"Received start execution response: {Serialize(response)}"); } catch (Exception e) { logger.LogError($"Got error trying to start pipeline: {e.Message}"); } }
private async Task StartNewSurveyAsync(string phoneNumber, ILambdaLogger logger) { // save info about the respondent logger.LogLine($"Saving survey response for {Sanitizer.MaskPhoneNumber(phoneNumber)}"); var phoneNumberHash = Sanitizer.HashPhoneNumber(phoneNumber); var surveyResponse = new SurveyResponse { PhoneNumberHash = phoneNumberHash, TaskToken = "", Responses = new Dictionary <string, string>() }; await _DataAccess.SaveSurveyResponeAsync(surveyResponse).ConfigureAwait(false); // start the workflow logger.LogLine($"Starting workflow for {Sanitizer.MaskPhoneNumber(phoneNumber)}"); using (var client = StepFunctionClientFactory.GetClient()) { var state = new State { PhoneNumber = phoneNumber }; var req = new StartExecutionRequest { Name = phoneNumberHash + Guid.NewGuid().ToString("N"), StateMachineArn = ServerlessConfig.StateMachineArn, Input = JsonConvert.SerializeObject(state) }; await client.StartExecutionAsync(req).ConfigureAwait(false); } }
internal virtual StartExecutionResponse StartExecution(StartExecutionRequest request) { var marshaller = new StartExecutionRequestMarshaller(); var unmarshaller = StartExecutionResponseUnmarshaller.Instance; return(Invoke <StartExecutionRequest, StartExecutionResponse>(request, marshaller, unmarshaller)); }
/// <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)}"); } } } }
/// <summary> /// Initiates the asynchronous execution of the StartExecution operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the StartExecution 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/states-2016-11-23/StartExecution">REST API Reference for StartExecution Operation</seealso> public virtual Task <StartExecutionResponse> StartExecutionAsync(StartExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var marshaller = new StartExecutionRequestMarshaller(); var unmarshaller = StartExecutionResponseUnmarshaller.Instance; return(InvokeAsync <StartExecutionRequest, StartExecutionResponse>(request, marshaller, unmarshaller, cancellationToken)); }
/// <summary> /// Initiates the asynchronous execution of the StartExecution operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the StartExecution 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/states-2016-11-23/StartExecution">REST API Reference for StartExecution Operation</seealso> public virtual Task <StartExecutionResponse> StartExecutionAsync(StartExecutionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = StartExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartExecutionResponseUnmarshaller.Instance; return(InvokeAsync <StartExecutionResponse>(request, options, cancellationToken)); }
internal virtual StartExecutionResponse StartExecution(StartExecutionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = StartExecutionRequestMarshaller.Instance; options.ResponseUnmarshaller = StartExecutionResponseUnmarshaller.Instance; return(Invoke <StartExecutionResponse>(request, options)); }
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); }
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); } } }
/// <summary> /// 为指定的状态机启动一次执行 /// </summary> /// <param name="req"><see cref="StartExecutionRequest"/></param> /// <returns><see cref="StartExecutionResponse"/></returns> public StartExecutionResponse StartExecutionSync(StartExecutionRequest req) { JsonResponseModel <StartExecutionResponse> rsp = null; try { var strResp = this.InternalRequestSync(req, "StartExecution"); rsp = JsonConvert.DeserializeObject <JsonResponseModel <StartExecutionResponse> >(strResp); } catch (JsonSerializationException e) { throw new TencentCloudSDKException(e.Message); } return(rsp.Response); }
public async Task <PublishResponse> PublishAsync(PublishRequest request, string stateMachineArn, CancellationToken cancellationToken = default(CancellationToken)) { var executionRequest = new StartExecutionRequest { Input = JsonConvert.SerializeObject(request), Name = request.GetExecutionName(), StateMachineArn = stateMachineArn }; await StartExecutionAsync(request, executionRequest, cancellationToken); return(new PublishResponse { HttpStatusCode = HttpStatusCode.OK }); }
private async Task StartExecutionAsync(PublishRequest request, StartExecutionRequest executionRequest, CancellationToken cancellationToken = default(CancellationToken)) { if (request.ShouldSuppressExecutionAlreadyExistsException()) { try { await _stepFunctions.StartExecutionAsync(executionRequest, cancellationToken); } catch (ExecutionAlreadyExistsException ex) { Console.WriteLine($"ExecutionAlreadyExistsException error for {request.GetExecutionName()}. Exception was: {ex.Message}"); } } else { await _stepFunctions.StartExecutionAsync(executionRequest, cancellationToken); } }
/// <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 <APIGatewayProxyResponse> FunctionHandler(APIGatewayProxyRequest request, ILambdaContext context) { context.Logger.LogLine(request.Body); var input = JsonSerializer.Deserialize <Payload>(request.Body); context.Logger.LogLine(JsonSerializer.Serialize(input.OrderID)); //Get Order details List <Order> allDocs = await GetOrderDetails(input); var savedState = allDocs.FirstOrDefault(); //Callback step function SendTaskSuccessResponse sendTaskSuccessResponse; using (var amazonStepFunctionsClient = new AmazonStepFunctionsClient()) { //Set Stepfunction output data. var data = new { IsApproved = input.IsApproved }; var jsonData = JsonSerializer.Serialize(data); var startExecutionRequest = new StartExecutionRequest { Input = jsonData, }; var result = amazonStepFunctionsClient.SendTaskSuccessAsync(new SendTaskSuccessRequest() { TaskToken = savedState.Token, Output = jsonData }).Result; } APIGatewayProxyResponse response = new APIGatewayProxyResponse() { Body = "Successfully invoked stepfunction.", StatusCode = 200 }; return(response); }
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); }
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; } } }