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