simplerubysteps 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1db80d874fc5708a39f631983f7bf584ed63eb3840a2f212db85efff25b06486
-  data.tar.gz: 14ee38786322a3962cb48bcc64ba5c5d0606750fc24f422ef2c0ed17d962680b
+  metadata.gz: 41e3a9ed5b8d6c32357fa880c2826cdf18a16fb9195260c5d10c7063b7dcb474
+  data.tar.gz: '07180493d6f6456f41164cd74f1410fb8bcd6649a645d109011c85ec9133c463'
 SHA512:
-  metadata.gz: 9b43275998e160fb9d47db290b973d73b56da8b829ff5e35f408f6cdb093a3dcbf7c990ceabf063733730cbd131be6a9b0369c29113a11f18317c124391656ac
-  data.tar.gz: 5d224524a8d5f42f69cdd5e5b1fc778744e847d918e5cefca08f2115cd23503b8828f154b1f98292df0d1fd4082f79645444f67ddcccb16ff86e15a9bfffed1f
+  metadata.gz: 0620c89b84893c3e58078ab8dc66a211aaef5a52101a45e7392bde32bfdab3be3cc9d83bdee6e9adcfd1f3ecdc1e3420dd9068f58bea07550aad1993d0775a90
+  data.tar.gz: 50f9d29b51926176a2a3edc900694233f38d44511ef5115433cc756f88c74df5ffca90bc924406644580c43e1f9ca6e2b1e2f79187aa0b3c9eca003f14b2daae

data/README.md

@@ -7,20 +7,15 @@ This is software in the experimental stage and should not really be used by anyo
 ## Installation
 
 Prerequisites (for alpha version):
-* Linux-like environment (the deployment tools are currently implemented with shell scripts)
 * AWS CLI installed
 
-Add this line to your application's Gemfile:
-
-```ruby
-require "simplerubysteps"
-```
-
-And install the gem:
+## Usage
 
-    $ gem install simplerubysteps
+### Install the gem and the simplerubysteps CLI
 
-## Usage
+```
+gem install simplerubysteps
+```
 
 ### Create AWS Step Functions State Machine with ruby DSL
 
@@ -29,12 +24,12 @@ cd samples/sample1
 vi workflow.rb
 ```
 
-### Create CloudFormation stack with Step Functions State Machine and supporting Lambda functions
+### Create CloudFormation stack with Step Functions State Machine and supporting Lambda function
 
 ```
 export AWS_PROFILE=...
 cd samples/sample1
-simplerubysteps-deploy
+simplerubysteps deploy
 ```
 
 ### Trigger State Machine Execution and wait for completion
@@ -42,7 +37,11 @@ simplerubysteps-deploy
 ```
 export AWS_PROFILE=...          
 cd samples/sample1
-echo '{"foo": "James Bond"}' | simplerubysteps-workflow-run
+
+./start-directbranch.sh
+
+./sample-task-worker.sh &
+./start-callbackbranch.sh
 ```
 
 ### Delete CloudFormation stack
@@ -50,19 +49,16 @@ echo '{"foo": "James Bond"}' | simplerubysteps-workflow-run
 ```
 export AWS_PROFILE=...
 cd samples/sample1
-simplerubysteps-destroy
+simplerubysteps destroy
 ```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. 
-
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ### TODOs
 
-* Custom IAM role policies (Step Functions and Lambda)
-* sls-like tooling in ruby with AWS SDK
+* Custom IAM policies per Lambda task
 * 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.5"
+  VERSION = "0.0.7"
 end

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/simplerubysteps.gemspec

@@ -24,4 +24,10 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "aws-sdk-cloudformation"
+  spec.add_dependency "aws-sdk-s3"
+  spec.add_dependency "aws-sdk-states"
+  spec.add_dependency "aws-sdk-cloudwatchlogs"
+  spec.add_dependency "rubyzip"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplerubysteps
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Christian Tschenett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-12 00:00:00.000000000 Z
+date: 2023-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,15 +38,81 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-cloudformation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-states
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-cloudwatchlogs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - simplerubysteps@furthermore.ch
 executables:
-- simplerubysteps-deploy
-- simplerubysteps-destroy
-- simplerubysteps-logs
-- simplerubysteps-workflow-run
-- simplerubysteps-workflow-run-sync
+- simplerubysteps
 extensions: []
 extra_rdoc_files: []
 files:
@@ -57,22 +123,13 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- exe/simplerubysteps-deploy
-- exe/simplerubysteps-destroy
-- exe/simplerubysteps-logs
-- exe/simplerubysteps-workflow-run
-- exe/simplerubysteps-workflow-run-sync
-- 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-sync.sh
-- 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/exe/simplerubysteps-workflow-run-sync

@@ -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-sync.sh")
-
-Kernel.exec(shell_script_path)

data/lib/deploy.sh

@@ -1,92 +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 WF_TYPE=$(ruby -e 'require "./workflow.rb";puts $sm.kind')
-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'"},{"ParameterKey":"StateMachineType","ParameterValue":"'$WF_TYPE'"}]' > /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-sync.sh

@@ -1,10 +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)"
-
-aws stepfunctions start-sync-execution --state-machine-arn $STEP_FUNCTIONS_ARN --input "$STATE_MACHINE_INPUT" --query "output" --output text

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"