simplerubysteps 0.0.4 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1331d05828403e219eed44ad66888362be212c7cb31d7676e2c58ced835b0b8
-  data.tar.gz: f402ca43e00170f1b4814098a03b9e1048ba7d52b6f44bf613726f4409d57e98
+  metadata.gz: 625e45764755904cd72be21e6fd5c37977e917060036ba6f2c3d7fdf7c34d988
+  data.tar.gz: 07e2d5d6bf7c0469d485b691857bc658e82e1b406b21d24c828be0df8f809bef
 SHA512:
-  metadata.gz: 2c8c8fb7a7e62c32abd550ad902082ccdc0568093b1a262b804b64ae9886bc9dd5dbc2673ce4460a3d881d68953a4b593a659bc507c295966e9be719f792638d
-  data.tar.gz: '05327638e236a405009d752d23d0b4ea28ae7cb5a77bcc43deb7ecb909674b83f80ca9f197e0ba1c2c0e6ff5172ccd7aad194a84c55b1888bdb169f0c56f8385'
+  metadata.gz: 7bf3fc4f7675bcede5b043bfdf99c46e8351e976dadd51ad15eaec5d2146f2152dce4c39220b2d67ef490bda973cfc27ae3441fb686fcdcb92645ee29cf8793e
+  data.tar.gz: 424673482091537950b35eebadc33545585a6773f2f7484c9d9dc84655ef457e95c972f85b49efd1cd5777d62420a7c7570f2158d9b59f6febde036091a2cef5

data/README.md

@@ -61,7 +61,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ### TODOs
 
-* Support for StateMachineType (STANDARD or EXPRESS)
 * Custom IAM role policies (Step Functions and Lambda)
 * sls-like tooling in ruby with AWS SDK
 * Workflow action unit test support

data/exe/simplerubysteps

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+bin_dir = File.expand_path(File.dirname(__FILE__))
+include_path = File.join(bin_dir, "../lib/tool.rb")
+
+require include_path

data/lib/function.rb

@@ -2,9 +2,9 @@ require "json"
 require "./workflow.rb"
 
 def handler(event:, context:)
-  puts ENV.inspect # FIXME remove DEBUG code
-  puts event # FIXME remove DEBUG code
-  puts context.inspect # FIXME remove DEBUG code
+  puts ENV.inspect if ENV["DEBUG"]
+  puts event if ENV["DEBUG"]
+  puts context.inspect if ENV["DEBUG"]
 
   if event["Token"]
     $sm.states[event["Task"].to_sym].perform_action event["Input"], event["Token"]

data/lib/simplerubysteps/version.rb

@@ -1,3 +1,3 @@
 module Simplerubysteps
-  VERSION = "0.0.4"
+  VERSION = "0.0.6"
 end

data/lib/simplerubysteps.rb

@@ -14,9 +14,11 @@ module Simplerubysteps
   class StateMachine
     attr_reader :states
     attr_reader :start_at
+    attr_accessor :kind
 
     def initialize()
       @states = {}
+      @kind = "STANDARD"
     end
 
     def add(state)
@@ -189,6 +191,10 @@ module Simplerubysteps
 
   $sm = StateMachine.new
   $tasks = []
+  
+  def kind(k)
+    $sm.kind = k
+  end
 
   def task(name)
     t = $sm.add Task.new(name)

data/lib/statemachine.yaml

@@ -25,6 +25,10 @@ Parameters:
       - "yes"
       - "no"
     ConstraintDescription: must specify yes or no.    
+  StateMachineType:
+    Description: StateMachineType.
+    Default: STANDARD
+    Type: String    
 Conditions:
   CreateLambda: !Equals 
     - !Ref DeployLambda
@@ -53,6 +57,7 @@ Resources:
         Bucket: !Ref DeployBucket
         Key: !Ref StepFunctionsS3
       RoleArn: !GetAtt StepFunctionsRole.Arn
+      StateMachineType: !Ref StateMachineType
   MyLambdaRole:
     Type: AWS::IAM::Role
     Condition: CreateLambda

data/lib/tool.rb

@@ -0,0 +1,448 @@
+require "aws-sdk-cloudformation"
+require "aws-sdk-s3"
+require "aws-sdk-states"
+require "digest"
+require "zip"
+require "tempfile"
+require "json"
+require "optparse"
+require "aws-sdk-cloudwatchlogs"
+require "time"
+
+$cloudformation_client = Aws::CloudFormation::Client.new
+$s3_client = Aws::S3::Client.new
+$states_client = Aws::States::Client.new
+$logs_client = Aws::CloudWatchLogs::Client.new
+
+def tail_follow_logs(log_group_name, extract_pattern = nil) # FIXME too hacky and not really working
+  Signal.trap("INT") do
+    exit
+  end
+
+  first_event_time = Time.now.to_i * 1000
+
+  next_tokens = {}
+  first_round = true
+  loop do
+    log_streams = $logs_client.describe_log_streams(
+      log_group_name: log_group_name,
+      order_by: "LastEventTime",
+      descending: true,
+    ).log_streams
+
+    log_streams.each do |log_stream|
+      get_log_events_params = {
+        log_group_name: log_group_name,
+        log_stream_name: log_stream.log_stream_name,
+      }
+
+      if next_tokens.key?(log_stream.log_stream_name)
+        get_log_events_params[:next_token] = next_tokens[log_stream.log_stream_name]
+      else
+        get_log_events_params[:start_time] = first_round ? log_stream.last_event_timestamp : first_event_time
+      end
+
+      response = $logs_client.get_log_events(get_log_events_params)
+
+      response.events.each do |event|
+        if event.timestamp >= first_event_time
+          if extract_pattern
+            if /#{extract_pattern}/ =~ event.message
+              puts $1
+              exit
+            end
+          else
+            puts "#{Time.at(event.timestamp / 1000).utc} - #{log_stream.log_stream_name} - #{event.message}"
+          end
+        end
+      end
+
+      next_tokens[log_stream.log_stream_name] = response.next_forward_token
+    end
+
+    sleep 5
+
+    first_round = false
+  end
+end
+
+def stack_outputs(stack_name)
+  begin
+    response = $cloudformation_client.describe_stacks(stack_name: stack_name)
+    outputs = {}
+    response.stacks.first.outputs.each do |output|
+      outputs[output.output_key] = output.output_value
+    end
+    outputs
+  rescue Aws::CloudFormation::Errors::ServiceError => error
+    return nil if error.message =~ /Stack .* does not exist/
+    raise error
+  end
+end
+
+def stack_params(stack_name, template, parameters)
+  params = {
+    stack_name: stack_name,
+    template_body: template,
+    capabilities: ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"],
+    parameters: [],
+  }
+  parameters.each do |k, v|
+    params[:parameters].push({
+      parameter_key: k,
+      parameter_value: v,
+    })
+  end
+  params
+end
+
+def stack_create(stack_name, template, parameters)
+  $cloudformation_client.create_stack(stack_params(stack_name, template, parameters))
+  $cloudformation_client.wait_until(:stack_create_complete, stack_name: stack_name)
+  stack_outputs(stack_name)
+end
+
+def stack_update(stack_name, template, parameters)
+  begin
+    $cloudformation_client.update_stack(stack_params(stack_name, template, parameters))
+    $cloudformation_client.wait_until(:stack_update_complete, stack_name: stack_name)
+    stack_outputs(stack_name)
+  rescue Aws::CloudFormation::Errors::ServiceError => error
+    return stack_outputs(stack_name).merge({ :no_update => true }) if error.message =~ /No updates are to be performed/
+    raise unless error.message =~ /No updates are to be performed/
+  end
+end
+
+def upload_to_s3(bucket, key, body)
+  $s3_client.put_object(
+    bucket: bucket,
+    key: key,
+    body: body,
+  )
+end
+
+def upload_file_to_s3(bucket, key, file_path)
+  File.open(file_path, "rb") do |file|
+    upload_to_s3(bucket, key, file)
+  end
+end
+
+def empty_s3_bucket(bucket_name)
+  $s3_client.list_objects_v2(bucket: bucket_name).contents.each do |object|
+    $s3_client.delete_object(bucket: bucket_name, key: object.key)
+  end
+end
+
+def create_zip(zip_file, files_by_name)
+  Zip::File.open(zip_file, create: true) do |zipfile|
+    base_dir = File.expand_path(File.dirname(__FILE__))
+    files_by_name.each do |n, f|
+      zipfile.add n, f
+    end
+  end
+end
+
+def dir_files(base_dir, glob)
+  files_by_name = {}
+  base_dir = File.expand_path(base_dir)
+  Dir.glob("#{base_dir}/#{glob}").select { |path| File.file?(path) }.each do |f|
+    files_by_name[File.expand_path(f)[base_dir.length + 1..-1]] = f
+  end
+  files_by_name
+end
+
+def stack_name_from_current_dir
+  File.basename(File.expand_path("."))
+end
+
+def workflow_files
+  dir_files ".", "**/*.rb"
+end
+
+def my_lib_files
+  dir_files File.dirname(__FILE__), "**/*.rb"
+end
+
+def cloudformation_template
+  File.open("#{File.dirname(__FILE__)}/statemachine.yaml", "r") do |file|
+    return file.read
+  end
+end
+
+def log(extract_pattern = nil)
+  current_stack_outputs = stack_outputs(stack_name_from_current_dir)
+  function_name = current_stack_outputs["LambdaFunctionName"]
+  rause "State Machine is not deployed" unless function_name
+
+  tail_follow_logs "/aws/lambda/#{function_name}", extract_pattern
+end
+
+def destroy
+  current_stack_outputs = stack_outputs(stack_name_from_current_dir)
+  deploy_bucket = current_stack_outputs["DeployBucket"]
+  rause "No CloudFormation stack to destroy" unless deploy_bucket
+
+  empty_s3_bucket deploy_bucket
+
+  puts "Bucket emptied: #{deploy_bucket}"
+
+  $cloudformation_client.delete_stack(stack_name: stack_name_from_current_dir)
+  $cloudformation_client.wait_until(:stack_delete_complete, stack_name: stack_name_from_current_dir)
+
+  puts "Stack deleted"
+end
+
+def deploy(workflow_type)
+  current_stack_outputs = stack_outputs(stack_name_from_current_dir)
+
+  unless current_stack_outputs
+    current_stack_outputs = stack_create(stack_name_from_current_dir, cloudformation_template, {
+      "DeployLambda" => "no",
+      "DeployStepfunctions" => "no",
+      "LambdaS3" => "",
+      "StepFunctionsS3" => "",
+      "StateMachineType" => "",
+    })
+
+    puts "Deployment bucket created"
+  end
+
+  deploy_bucket = current_stack_outputs["DeployBucket"]
+  puts "Deployment bucket: #{deploy_bucket}"
+
+  function_zip_temp = Tempfile.new("function")
+  create_zip function_zip_temp.path, my_lib_files.merge(workflow_files)
+  lambda_sha = Digest::SHA1.file function_zip_temp.path
+  lambda_zip_name = "function-#{lambda_sha}.zip"
+  upload_file_to_s3 deploy_bucket, lambda_zip_name, function_zip_temp.path
+  puts "Uploaded: #{lambda_zip_name}"
+
+  unless current_stack_outputs["LambdaFunctionARN"]
+    current_stack_outputs = stack_update(stack_name_from_current_dir, cloudformation_template, {
+      "DeployLambda" => "yes",
+      "DeployStepfunctions" => "no",
+      "LambdaS3" => lambda_zip_name,
+      "StepFunctionsS3" => "",
+      "StateMachineType" => "",
+    })
+
+    puts "Lambda function created"
+  end
+
+  lambda_arn = current_stack_outputs["LambdaFunctionARN"]
+  puts "Lambda function: #{lambda_arn}"
+
+  state_machine_json = JSON.parse(`LAMBDA_FUNCTION_ARN=#{lambda_arn} ruby -e 'require "./workflow.rb";puts $sm.render.to_json'`).to_json
+  state_machine_json_sha = Digest::SHA1.hexdigest state_machine_json
+  state_machine_json_name = "statemachine-#{state_machine_json_sha}.json"
+  upload_to_s3 deploy_bucket, state_machine_json_name, state_machine_json
+  puts "Uploaded: #{state_machine_json_name}"
+
+  current_stack_outputs = stack_update(stack_name_from_current_dir, cloudformation_template, {
+    "DeployLambda" => "yes",
+    "DeployStepfunctions" => "yes",
+    "LambdaS3" => lambda_zip_name,
+    "StepFunctionsS3" => state_machine_json_name,
+    "StateMachineType" => workflow_type,
+  })
+
+  if current_stack_outputs[:no_update]
+    puts "Stack not updated"
+  else
+    puts "Stack updated"
+  end
+
+  puts "State machine: #{current_stack_outputs["StepFunctionsStateMachineARN"]}"
+end
+
+def start_sync_execution(state_machine_arn, input)
+  $states_client.start_sync_execution(
+    state_machine_arn: state_machine_arn,
+    input: input,
+  )
+end
+
+def start_async_execution(state_machine_arn, input)
+  $states_client.start_execution(
+    state_machine_arn: state_machine_arn,
+    input: input,
+  )
+end
+
+def describe_execution(execution_arn)
+  $states_client.describe_execution(
+    execution_arn: execution_arn,
+  )
+end
+
+def wait_for_async_execution_completion(execution_arn)
+  response = nil
+
+  loop do
+    response = describe_execution(execution_arn)
+    status = response.status
+
+    break if %w[SUCCEEDED FAILED TIMED_OUT].include?(status)
+
+    sleep 5
+  end
+
+  response
+end
+
+def start(workflow_type, wait = true, input = $stdin)
+  current_stack_outputs = stack_outputs(stack_name_from_current_dir)
+  state_machine_arn = current_stack_outputs["StepFunctionsStateMachineARN"]
+  raise "State Machine is not deployed" unless state_machine_arn
+
+  input_json = JSON.parse(input.read).to_json
+
+  if workflow_type == "STANDARD"
+    start_response = start_async_execution(state_machine_arn, input_json)
+
+    unless wait
+      puts start_response.to_json
+    else
+      execution_arn = start_response.execution_arn
+
+      puts wait_for_async_execution_completion(execution_arn).to_json
+    end
+  elsif workflow_type == "EXPRESS"
+    puts start_sync_execution(state_machine_arn, input_json).to_json
+  else
+    raise "Unknown state machine type: #{workflow_type}"
+  end
+end
+
+def send_task_success(task_token, output = $stdin)
+  raise "No token" unless task_token
+
+  output_json = JSON.parse(output.read).to_json
+
+  puts $states_client.send_task_success(
+    task_token: task_token,
+    output: output_json,
+  ).to_json
+end
+
+options = {
+  :workflow_type => "STANDARD",
+  :wait => false,
+  :input => $stdin,
+}
+
+subcommands = {
+  "deploy" => OptionParser.new do |opts|
+    opts.banner = "Usage: #{$0} deploy [options]"
+
+    opts.on("--type VALUE", "STANDARD (default) or EXPRESS") do |value|
+      options[:workflow_type] = value
+    end
+
+    opts.on("-h", "--help", "Display this help message") do
+      puts opts
+      exit
+    end
+  end,
+  "destroy" => OptionParser.new do |opts|
+    opts.banner = "Usage: #{$0} destroy [options]"
+
+    opts.on("-h", "--help", "Display this help message") do
+      puts opts
+      exit
+    end
+  end,
+  "log" => OptionParser.new do |opts|
+    opts.banner = "Usage: #{$0} log [options]"
+
+    opts.on("--extract_pattern VALUE", "Waits for and extracts pattern") do |value|
+      options[:extract_pattern] = value
+    end
+
+    opts.on("-h", "--help", "Display this help message") do
+      puts opts
+      exit
+    end
+  end,
+  "start" => OptionParser.new do |opts|
+    opts.banner = "Usage: #{$0} start [options]"
+
+    opts.on("--type VALUE", "STANDARD (default) or EXPRESS") do |value|
+      options[:workflow_type] = value
+    end
+
+    opts.on("--wait VALUE", "true (default and always true for EXPRESS) or false (default for STANDARD)") do |value|
+      options[:wait] = "true" == value
+    end
+
+    opts.on("--input VALUE", "/path/to/file (STDIN will be used per default)") do |value|
+      options[:input] = File.new(value)
+    end
+
+    opts.on("-h", "--help", "Display this help message") do
+      puts opts
+      exit
+    end
+  end,
+  "task-success" => OptionParser.new do |opts|
+    opts.banner = "Usage: #{$0} task-success [options]"
+
+    opts.on("--input VALUE", "/path/to/file (STDIN will be used per default)") do |value|
+      options[:input] = File.new(value)
+    end
+
+    opts.on("--token VALUE", "The task token") do |value|
+      options[:token] = value
+    end
+
+    opts.on("-h", "--help", "Display this help message") do
+      puts opts
+      exit
+    end
+  end,
+}
+
+global = OptionParser.new do |opts|
+  opts.banner = "Usage: #{$0} [command] [options]"
+  opts.separator ""
+  opts.separator "Commands:"
+  opts.separator "    deploy        Create Step Functions State Machine"
+  opts.separator "    destroy       Delete Step Functions State Machine"
+  opts.separator "    log           Continuously prints Lambda function log output"
+  opts.separator "    start         Start State Machine execution"
+  opts.separator "    task-success  Continue Start State Machine execution"
+  opts.separator ""
+
+  opts.on_tail("-h", "--help", "Display this help message") do
+    puts opts
+    exit
+  end
+end
+
+begin
+  global.order!(ARGV)
+  command = ARGV.shift
+  options[:command] = command
+  subcommands.fetch(command).parse!(ARGV)
+rescue KeyError
+  puts "Unknown command: '#{command}'"
+  puts
+  puts global
+  exit 1
+rescue OptionParser::ParseError => error
+  puts error.message
+  puts subcommands.fetch(command)
+  exit 1
+end
+
+if options[:command] == "deploy"
+  deploy options[:workflow_type]
+elsif options[:command] == "start"
+  start options[:workflow_type], options[:wait], options[:input]
+elsif options[:command] == "log"
+  log options[:extract_pattern]
+elsif options[:command] == "task-success"
+  send_task_success options[:token], options[:input]
+elsif options[:command] == "destroy"
+  destroy
+end

data/samples/sample1/sample-task-worker.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+TOKEN=$(simplerubysteps log --extract_pattern 'callback_token=(.+)')
+
+echo '{"willo":"billo"}'|simplerubysteps task-success --token $TOKEN

data/samples/sample1/start-callbackbranch.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 
-echo '{"foo": "John Wick"}'|simplerubysteps-workflow-run
+echo '{"foo": "John Wick"}'|simplerubysteps start --wait true|jq

data/samples/sample1/start-directbranch.sh

@@ -1,3 +1,3 @@
 #!/bin/bash
 
-echo '{"foo": "James Bond"}'|simplerubysteps-workflow-run
+echo '{"foo": "James Bond"}'|simplerubysteps start --wait true|jq -r ".output"|jq

data/samples/sample1/workflow.rb

@@ -13,7 +13,7 @@ task :t1 do
     string_matches "$.Foo1", "ja" do
       callback :t3 do
         action do |input, token|
-          puts "Callback t3: #{input}, #{token}" # The logged token is picked up by continue-callbackbranch.sh
+          puts "Callback t3: #{input}, callback_token=#{token}" # The logged token is picked up by continue-callbackbranch.sh
         end
 
         transition :t5

data/samples/sample2/workflow.rb

@@ -3,6 +3,8 @@
 require "simplerubysteps"
 include Simplerubysteps
 
+kind "EXPRESS"
+
 task :t1 do
   action do |input|
     puts "Task t1: #{input}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplerubysteps
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.6
 platform: ruby
 authors:
 - Christian Tschenett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-10 00:00:00.000000000 Z
+date: 2023-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -42,10 +42,7 @@ description:
 email:
 - simplerubysteps@furthermore.ch
 executables:
-- simplerubysteps-deploy
-- simplerubysteps-destroy
-- simplerubysteps-logs
-- simplerubysteps-workflow-run
+- simplerubysteps
 extensions: []
 extra_rdoc_files: []
 files:
@@ -56,20 +53,13 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- exe/simplerubysteps-deploy
-- exe/simplerubysteps-destroy
-- exe/simplerubysteps-logs
-- exe/simplerubysteps-workflow-run
-- lib/deploy.sh
-- lib/destroy.sh
+- exe/simplerubysteps
 - lib/function.rb
-- lib/logs.sh
 - lib/simplerubysteps.rb
 - lib/simplerubysteps/version.rb
 - lib/statemachine.yaml
-- lib/workflow-run.sh
-- samples/sample1/continue-callbackbranch.sh
-- samples/sample1/send-task-success.sh
+- lib/tool.rb
+- samples/sample1/sample-task-worker.sh
 - samples/sample1/start-callbackbranch.sh
 - samples/sample1/start-directbranch.sh
 - samples/sample1/workflow.rb

data/exe/simplerubysteps-deploy

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-bin_dir = File.expand_path(File.dirname(__FILE__))
-shell_script_path = File.join(bin_dir, "../lib/deploy.sh")
-
-Kernel.exec(shell_script_path)

data/exe/simplerubysteps-destroy

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-bin_dir = File.expand_path(File.dirname(__FILE__))
-shell_script_path = File.join(bin_dir, "../lib/destroy.sh")
-
-Kernel.exec(shell_script_path)

data/exe/simplerubysteps-logs

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-bin_dir = File.expand_path(File.dirname(__FILE__))
-shell_script_path = File.join(bin_dir, "../lib/logs.sh")
-
-Kernel.exec(shell_script_path)

data/exe/simplerubysteps-workflow-run

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-bin_dir = File.expand_path(File.dirname(__FILE__))
-shell_script_path = File.join(bin_dir, "../lib/workflow-run.sh")
-
-Kernel.exec(shell_script_path)

data/lib/deploy.sh

@@ -1,91 +0,0 @@
-#!/bin/bash
-
-SCRIPT_DIR="$( cd -- "$(dirname "$0")" >/dev/null 2>&1 ; pwd -P )"
-
-export STACK_NAME=$(basename "$PWD")
-
-echo "CF Stack: $STACK_NAME"
-
-export CF_TEMPLATE=$SCRIPT_DIR/../lib/statemachine.yaml
-
-export DEPLOY_BUCKET=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --output text --query "Stacks[].Outputs[]"|grep DeployBucket|awk '{print $2}')
-
-if [[ -n "$DEPLOY_BUCKET" ]]; then
-  echo "Deployment bucket found: $DEPLOY_BUCKET"
-else
-  echo "Creating deloyment bucket"
-
-  echo '[{"ParameterKey":"DeployLambda","ParameterValue":"no"},{"ParameterKey":"DeployStepfunctions","ParameterValue":"no"}]' > /tmp/params.json
-
-  aws cloudformation deploy \
-    --template-file $CF_TEMPLATE \
-    --stack-name $STACK_NAME \
-    --capabilities '["CAPABILITY_IAM","CAPABILITY_NAMED_IAM"]' \
-    --parameter-overrides file:///tmp/params.json
-
-  aws cloudformation wait stack-create-complete \
-    --stack-name $STACK_NAME || \
-    { echo "Stack creation/update failed." >&2; exit 1; }
-
-  export DEPLOY_BUCKET=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --output text --query "Stacks[].Outputs[]"|grep DeployBucket|awk '{print $2}')
-fi
-
-echo "Uploading lambda ZIP"
-
-rm -f /tmp/function.zip
-zip /tmp/function.zip *.rb
-(cd $SCRIPT_DIR/../lib; zip -r /tmp/function.zip *.rb)
-(cd $SCRIPT_DIR/../lib; zip -r /tmp/function.zip simplerubysteps/*.rb)
-
-export LAMBDA_SHA=$(shasum /tmp/function.zip | awk '{print $1}')
-export UPLOADED_LAMBDA_ZIP=function-$LAMBDA_SHA.zip
-aws s3 cp /tmp/function.zip s3://$DEPLOY_BUCKET/$UPLOADED_LAMBDA_ZIP
-
-export LAMBDA_FUNCTION_ARN=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --output text --query "Stacks[].Outputs[]"|grep LambdaFunctionARN|awk '{print $2}')
-
-if [[ -n "$LAMBDA_FUNCTION_ARN" ]]; then
-  echo "Lambda ARN found: $LAMBDA_FUNCTION_ARN"
-else
-  echo "Creating lambda"
-
-  echo '[{"ParameterKey":"DeployLambda","ParameterValue":"yes"},{"ParameterKey":"DeployStepfunctions","ParameterValue":"no"},{"ParameterKey":"LambdaS3","ParameterValue":"'$UPLOADED_LAMBDA_ZIP'"}]' > /tmp/params.json
-
-  aws cloudformation deploy \
-    --template-file $CF_TEMPLATE \
-    --stack-name $STACK_NAME \
-    --capabilities '["CAPABILITY_IAM","CAPABILITY_NAMED_IAM"]' \
-    --parameter-overrides file:///tmp/params.json
-
-  aws cloudformation wait stack-update-complete \
-    --stack-name $STACK_NAME || \
-    { echo "Stack update failed." >&2; exit 1; }
-
-  export LAMBDA_FUNCTION_ARN=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --output text --query "Stacks[].Outputs[]"|grep LambdaFunctionARN|awk '{print $2}')
-fi
-
-echo "Uploading state machine JSON"
-
-ruby -e 'require "./workflow.rb";puts $sm.render.to_json' > /tmp/my-state-machine-definition.json
-export STATE_MACHINE_JSON_SHA=$(shasum /tmp/my-state-machine-definition.json | awk '{print $1}')
-export UPLOADED_STATE_MACHINE_JSON=statemachine-$STATE_MACHINE_JSON_SHA.zip
-aws s3 cp /tmp/my-state-machine-definition.json s3://$DEPLOY_BUCKET/$UPLOADED_STATE_MACHINE_JSON
-
-echo "Updating CloudFormation Stack"
-
-echo '[{"ParameterKey":"DeployLambda","ParameterValue":"yes"},{"ParameterKey":"DeployStepfunctions","ParameterValue":"yes"},{"ParameterKey":"LambdaS3","ParameterValue":"'$UPLOADED_LAMBDA_ZIP'"},{"ParameterKey":"StepFunctionsS3","ParameterValue":"'$UPLOADED_STATE_MACHINE_JSON'"}]' > /tmp/params.json
-
-aws cloudformation deploy \
-  --template-file $CF_TEMPLATE \
-  --stack-name $STACK_NAME \
-  --capabilities '["CAPABILITY_IAM","CAPABILITY_NAMED_IAM"]' \
-  --parameter-overrides file:///tmp/params.json
-
-aws cloudformation wait stack-update-complete \
-  --stack-name $STACK_NAME || \
-  { echo "Stack update failed." >&2; exit 1; }
-
-export STEP_FUNCTIONS_ARN=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --output text --query "Stacks[].Outputs[]"|grep StepFunctionsStateMachineARN|awk '{print $2}')
-
-echo "StepFunctions ARN found: $STEP_FUNCTIONS_ARN"
-
-echo "Done"

data/lib/destroy.sh

@@ -1,10 +0,0 @@
-#!/bin/bash
-
-export STACK_NAME=$(basename "$PWD")
-
-export DEPLOY_BUCKET=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --output text --query "Stacks[].Outputs[]"|grep DeployBucket|awk '{print $2}')
-
-aws s3 rm s3://$DEPLOY_BUCKET --recursive
-
-aws cloudformation delete-stack \
-  --stack-name $STACK_NAME 

data/lib/logs.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-export STACK_NAME=$(basename "$PWD")
-
-export FUNCTION_NAME=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --output text --query "Stacks[].Outputs[]"|grep LambdaFunctionName|awk '{print $2}')
-
-aws logs tail /aws/lambda/$FUNCTION_NAME

data/lib/workflow-run.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-
-export STACK_NAME=$(basename "$PWD")
-
-export STEP_FUNCTIONS_ARN=$(aws cloudformation describe-stacks --stack-name $STACK_NAME --output text --query "Stacks[].Outputs[]"|grep StepFunctionsStateMachineARN|awk '{print $2}')
-
-tee /tmp/statemachineinput.json > /dev/null
-STATE_MACHINE_INPUT="$(cat /tmp/statemachineinput.json)"
-
-EXECUTION_ARN=$(aws stepfunctions start-execution \
-  --state-machine-arn $STEP_FUNCTIONS_ARN \
-  --input "$STATE_MACHINE_INPUT" \
-  --query "executionArn" \
-  --output text)
-
-echo "Started execution: $EXECUTION_ARN"
-
-while true; do
-  STATUS=$(aws stepfunctions describe-execution \
-    --execution-arn $EXECUTION_ARN \
-    --query "status" \
-    --output text)
-
-  if [[ "$STATUS" == "SUCCEEDED" ]]; then
-    break
-  elif [[ "$STATUS" == "FAILED" || "$STATUS" == "TIMED_OUT" || "$STATUS" == "ABORTED" ]]; then
-    echo "Execution failed with status: $STATUS"
-    exit 1
-  else
-    sleep 5
-  fi
-done
-
-OUTPUT=$(aws stepfunctions describe-execution \
-  --execution-arn $EXECUTION_ARN \
-  --query "output" \
-  --output text)
-
-echo "Execution output: $OUTPUT"

data/samples/sample1/continue-callbackbranch.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-TOKEN=$(simplerubysteps-logs|grep Token|sort|tail -n 1|ruby -ne 'print $1 if /Token\"=>\"(.+)\"/')
-
-echo "{\"continued\":\"$(date)\"}"|./send-task-success.sh $TOKEN

data/samples/sample1/send-task-success.sh

@@ -1,6 +0,0 @@
-#!/bin/bash
-
-tee /tmp/taskoutput.json > /dev/null
-TASK_OUTPUT="$(cat /tmp/taskoutput.json)"
-
-aws stepfunctions send-task-success --task-token="$1" --task-output "$TASK_OUTPUT"