simplerubysteps 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12126fa84a9d21228e4b705f57b100a007087d2d7cc2f2af84efcfc18c06ffd7
-  data.tar.gz: 4f7d36681479f8f44370ea4615d0d13d395134c64fa31b822e6542cdcf924c92
+  metadata.gz: b1331d05828403e219eed44ad66888362be212c7cb31d7676e2c58ced835b0b8
+  data.tar.gz: f402ca43e00170f1b4814098a03b9e1048ba7d52b6f44bf613726f4409d57e98
 SHA512:
-  metadata.gz: bfc06b92ad3921c465ffde34a2440817c0161089e0577eb058adbd4840b88e478f07404fc09387a15a3c63edcd9961b1af6586f4400bab8b3b284b74a90c672d
-  data.tar.gz: 26aebdba09383657ff151d6ed3abdd2cd1e16fb99a614c3f8686db973aa509777a8d65761b418c12809239d712a3e51be98aab8fcc56d3579df1750c54add53f
+  metadata.gz: 2c8c8fb7a7e62c32abd550ad902082ccdc0568093b1a262b804b64ae9886bc9dd5dbc2673ce4460a3d881d68953a4b593a659bc507c295966e9be719f792638d
+  data.tar.gz: '05327638e236a405009d752d23d0b4ea28ae7cb5a77bcc43deb7ecb909674b83f80ca9f197e0ba1c2c0e6ff5172ccd7aad194a84c55b1888bdb169f0c56f8385'

data/README.md

@@ -42,7 +42,7 @@ simplerubysteps-deploy
 ```
 export AWS_PROFILE=...          
 cd samples/sample1
-echo '{"foo": "John Wick"}' | simplerubysteps-workflow-run
+echo '{"foo": "James Bond"}' | simplerubysteps-workflow-run
 ```
 
 ### Delete CloudFormation stack
@@ -59,6 +59,14 @@ 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
+
+* 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
+* ...
+
 ## Contributing
 
 Bug reports and pull requests are (soon - after alpha phase) welcome on GitHub at https://github.com/chtz/simplerubysteps

data/bin/setup

@@ -4,4 +4,3 @@ IFS=$'\n\t'
 set -vx
 
 bundle install
-

data/exe/simplerubysteps-deploy

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

data/exe/simplerubysteps-destroy

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

data/exe/simplerubysteps-logs

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

data/lib/function.rb

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

data/lib/logs.sh

@@ -0,0 +1,7 @@
+#!/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/simplerubysteps/version.rb

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

data/lib/simplerubysteps.rb

@@ -2,177 +2,267 @@ require "simplerubysteps/version"
 require "json"
 
 module Simplerubysteps
-  $FUNCTION_ARN=ENV["LAMBDA_FUNCTION_ARN"] ? ENV["LAMBDA_FUNCTION_ARN"] : "unknown"
+  # Step Functions JSON generator
 
-  class StateMachine
-      attr_reader :states
-      attr_reader :start_at
+  $FUNCTION_ARN = ENV["LAMBDA_FUNCTION_ARN"] ? ENV["LAMBDA_FUNCTION_ARN"] : "unknown"
 
-      def initialize()
-          @states = {}
-      end
+  def function_name
+    return "unknown" unless $FUNCTION_ARN =~ /.+\:function\:(.+)/
+    $1
+  end
 
-      def add(state)
-          @start_at = state.name unless @start_at
-          
-          @states[state.name] = state
-          state.state_machine = self
+  class StateMachine
+    attr_reader :states
+    attr_reader :start_at
 
-          state
-      end
+    def initialize()
+      @states = {}
+    end
 
-      def render
-          {
-              :StartAt => @start_at,
-              :States => @states.map { |name,state| [name, state.render] }.to_h
-          }
-      end
-  end
+    def add(state)
+      @start_at = state.name unless @start_at
 
-  class State
-      attr_reader :name
-      attr_accessor :state_machine
-          
-      def initialize(name)
-          @name = name
-          @dict = {}
-      end
+      @states[state.name] = state
+      state.state_machine = self
 
-      def []=(key,value)
-          @dict[key] = value
-      end
+      state
+    end
 
-      def next=(state)
-          @dict[:Next] = (state.is_a? Symbol) ? state : state.name
-      end
+    def render
+      {
+        :StartAt => @start_at,
+        :States => @states.map { |name, state| [name, state.render] }.to_h,
+      }
+    end
+  end
 
-      def render
-          dict = @dict
-          dict[:End] = true unless dict[:Next]
-          dict
-      end
+  class State
+    attr_reader :name
+    attr_accessor :state_machine
+
+    def initialize(name)
+      @name = name
+      @dict = {}
+    end
+
+    def []=(key, value)
+      @dict[key] = value
+    end
+
+    def next=(state)
+      @dict[:Next] = (state.is_a? Symbol) ? state : state.name
+    end
+
+    def render
+      dict = @dict
+      dict[:End] = true unless dict[:Next]
+      dict
+    end
   end
 
   class Task < State
-      def initialize(name)
-          super
-          @dict[:Type] = "Task"
-          @dict[:Resource] = $FUNCTION_ARN
-          @dict[:"Parameters"] = {
-              :Task => name,
-              "Input.$" => "$"
-          }
+    def initialize(name)
+      super
+      @dict[:Type] = "Task"
+      @dict[:Resource] = $FUNCTION_ARN
+      @dict[:Parameters] = {
+        :Task => name,
+        "Input.$" => "$",
+      }
+    end
+
+    def action(&action_block)
+      @action_block = action_block
+    end
+
+    def perform_action(input)
+      output = nil
+      output = @action_block.call(input) if @action_block
+
+      if @implicit_choice
+        output = {} unless output
+        @implicit_choice.perform_action(output)
       end
 
-      def action(&action_block)
-          @action_block = action_block
-      end
+      output
+    end
 
-      def perform_action(input)
-          @action_block.call(input) if @action_block
+    def implicit_choice
+      unless @implicit_choice
+        @implicit_choice = Choice.new("#{name}_choice")
+        $sm.add @implicit_choice
+        self.next = @implicit_choice
       end
+      @implicit_choice
+    end
   end
 
-  class ChoiceItem 
-      def initialize(dict = {}, state = nil)
-          @dict = dict
-          self.next = state if state
-      end
-
-      def next=(state)
-          @dict[:Next] = (state.is_a? Symbol) ? state : state.name
-      end
-
-      def render
-          @dict
-      end
+  class Callback < State
+    def initialize(name)
+      super
+      @dict[:Type] = "Task"
+      @dict[:Resource] = "arn:aws:states:::lambda:invoke.waitForTaskToken"
+      @dict[:Parameters] = {
+        :FunctionName => function_name,
+        :Payload => {
+          :Task => name,
+          "Input.$" => "$",
+          "Token.$" => "$$.Task.Token",
+        },
+      }
+    end
+
+    def action(&action_block)
+      @action_block = action_block
+    end
+
+    def perform_action(input, token)
+      @action_block.call(input, token) if @action_block
+    end
   end
 
-  class Choice < State
-      attr_reader :choices
+  class ChoiceItem
+    attr_accessor :implicit_condition_block
 
-      def initialize(name)
-          super
-          @choices = []
-          @dict[:Type] = "Choice"
-      end
+    def initialize(dict = {}, state = nil)
+      @dict = dict
+      self.next = state if state
+    end
 
-      def add(item)
-          @choices.push item
-      end
-
-      def add_string_matches(var, match, state)
-          add ChoiceItem.new({
-                  :Variable => var,
-                  :StringMatches => match
-              }, state)
-      end
+    def next=(state)
+      @dict[:Next] = (state.is_a? Symbol) ? state : state.name
+    end
 
-      def default=(state)
-          @dict[:Default] = (state.is_a? Symbol) ? state : state.name
-      end
+    def render
+      @dict
+    end
 
-      def next=(state)
-          self.default = state
+    def perform_action(choice_name, output)
+      if @implicit_condition_block
+        output["#{choice_name}_#{@dict[:Next]}"] = @implicit_condition_block.call(output) ? "yes" : "no"
       end
+    end
+  end
 
-      def render
-          dict = @dict.clone
-          dict[:Choices] = @choices.map { |item| item.render }
-          dict
+  class Choice < State
+    attr_reader :choices
+
+    def initialize(name)
+      super
+      @choices = []
+      @dict[:Type] = "Choice"
+    end
+
+    def add(item)
+      @choices.push item
+    end
+
+    def add_string_matches(var, match, state)
+      add ChoiceItem.new({
+            :Variable => var,
+            :StringMatches => match,
+          }, state)
+    end
+
+    def default=(state)
+      @dict[:Default] = (state.is_a? Symbol) ? state : state.name
+    end
+
+    def next=(state)
+      self.default = state
+    end
+
+    def render
+      dict = @dict.clone
+      dict[:Choices] = @choices.map { |item| item.render }
+      dict
+    end
+
+    def perform_action(output)
+      @choices.each do |choice|
+        choice.perform_action name, output
       end
+    end
   end
 
-  ################################################################################
+  # Workflow DSL
 
   $sm = StateMachine.new
   $tasks = []
 
   def task(name)
-      t = $sm.add Task.new(name)
+    t = $sm.add Task.new(name)
 
-      $tasks.last.next = t if $tasks.last 
+    $tasks.last.next = t if $tasks.last
 
-      $tasks.push t
-      yield if block_given?
-      $tasks.pop
+    $tasks.push t
+    yield if block_given?
+    $tasks.pop
   end
 
+  def callback(name)
+    t = $sm.add Callback.new(name)
+
+    $tasks.last.next = t if $tasks.last
+
+    $tasks.push t
+    yield if block_given?
+    $tasks.pop
+  end
 
   def action(&action_block)
-      $tasks.last.action &action_block
+    $tasks.last.action &action_block
   end
 
   def transition(state)
-      $tasks.last.next = state
+    $tasks.last.next = state
+  end
+
+  def transition_to(state, &condition_block)
+    choice = $tasks.last.implicit_choice
+
+    c = ChoiceItem.new({
+      :Variable => "$.#{choice.name}_#{state}",
+      :StringMatches => "yes",
+    })
+    c.next = state
+    c.implicit_condition_block = condition_block
+
+    choice.add c
+  end
+
+  def default_transition_to(state)
+    choice = $tasks.last.implicit_choice
+
+    choice.default = state
   end
 
   def choice(name)
-      t = $sm.add Choice.new(name)
-      
-      $tasks.last.next = t if $tasks.last
+    t = $sm.add Choice.new(name)
+
+    $tasks.last.next = t if $tasks.last
 
-      $tasks.push t
-      yield if block_given?
-      $tasks.pop
+    $tasks.push t
+    yield if block_given?
+    $tasks.pop
   end
 
   def string_matches(var, match)
-      c = ChoiceItem.new({
-              :Variable => var,
-              :StringMatches => match
-          })
+    c = ChoiceItem.new({
+      :Variable => var,
+      :StringMatches => match,
+    })
 
-      $tasks.last.add c
+    $tasks.last.add c
 
-      $tasks.push c
-      yield if block_given?
-      $tasks.pop
+    $tasks.push c
+    yield if block_given?
+    $tasks.pop
   end
 
   def default
-      $tasks.push $tasks.last
-      yield if block_given?
-      $tasks.pop
+    $tasks.push $tasks.last
+    yield if block_given?
+    $tasks.pop
   end
 end

data/samples/sample1/continue-callbackbranch.sh

@@ -0,0 +1,5 @@
+#!/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

@@ -0,0 +1,6 @@
+#!/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"

data/samples/sample1/start-callbackbranch.sh

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

data/samples/sample1/start-directbranch.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo '{"foo": "James Bond"}'|simplerubysteps-workflow-run

data/samples/sample1/workflow.rb

@@ -4,37 +4,36 @@ require "simplerubysteps"
 include Simplerubysteps
 
 task :t1 do
-    action do |input|
-        puts "Task t1: #{input}"
-        input.merge({ "Foo1" => (input["foo"] == "John Wick" ? "ja" : "nein") })
-    end
-
-    choice :t2 do
-        string_matches "$.Foo1", "ja" do
-            task :t3 do
-                action do |input|
-                    puts "Task t3: #{input}"
-                    input.merge({ "Foo3": "Bar3x" })
-                end
+  action do |input|
+    puts "Task t1: #{input}"
+    input.merge({ "Foo1" => (input["foo"] == "John Wick" ? "ja" : "nein") })
+  end
 
-                transition :t5
-            end
+  choice :t2 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
         end
 
-        default do 
-            task :t4 do
-                action do |input|
-                    puts "Task t4: #{input}"
-                    input.merge({ "Foo4": "Bar4xy" })
-                end
-            end
+        transition :t5
+      end
+    end
+
+    default do
+      task :t4 do
+        action do |input|
+          puts "Task t4: #{input}"
+          input.merge({ "Foo4": "Bar4xy" })
         end
+      end
     end
+  end
 end
 
 task :t5 do
-    action do |input|
-        puts "Task t5: #{input}"
-        input.merge({ "Foo5" => "Bar5" })
-    end
+  action do |input|
+    puts "Task t5: #{input}"
+    input.merge({ "Foo5" => "Bar5" })
+  end
 end

data/samples/sample2/workflow.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/ruby
+
+require "simplerubysteps"
+include Simplerubysteps
+
+task :t1 do
+  action do |input|
+    puts "Task t1: #{input}"
+    input.merge({ "t1" => (input["bar"] ? input["bar"] : "") + "t1" })
+  end
+
+  transition_to :t2 do |output|
+    output["t1"] == "foot1"
+  end
+
+  default_transition_to :t3
+end
+
+task :t2 do
+  action do |input|
+    puts "Task t2: #{input}"
+    input.merge({ "t2" => "yes" })
+  end
+
+  transition :t4
+end
+
+task :t3 do
+  action do |input|
+    puts "Task t3: #{input}"
+    input.merge({ "t3" => "yes" })
+  end
+
+  task :t4 do
+    action do |input|
+      puts "Task t4: #{input}"
+      input.merge({ "t4" => "yes" })
+    end
+  end
+end

data/simplerubysteps.gemspec

@@ -3,31 +3,23 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "simplerubysteps/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = "simplerubysteps"
-  spec.version       = Simplerubysteps::VERSION
-  spec.authors       = ["Christian Tschenett"]
-  spec.email         = ["simplerubysteps@furthermore.ch"]
+  spec.name = "simplerubysteps"
+  spec.version = Simplerubysteps::VERSION
+  spec.authors = ["Christian Tschenett"]
+  spec.email = ["simplerubysteps@furthermore.ch"]
 
-  spec.summary       = %q{simplerubysteps makes it easy to manage AWS Step Functions with ruby (eventually - this is an early alpha version and should not really be used by everyone).}
-  
-  spec.homepage      = "https://github.com/chtz/simplerubysteps"
-  spec.license       = "MIT"
+  spec.summary = %q{simplerubysteps makes it easy to manage AWS Step Functions with ruby (eventually - this is an early alpha version and should not really be used by everyone).}
 
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.homepage = "https://github.com/chtz/simplerubysteps"
+  spec.license = "MIT"
+
+  spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.files << "lib/deploy.sh"
-  spec.files << "lib/destroy.sh"
-  spec.files << "lib/workflow-run.sh"
-  spec.files << "lib/statemachine.yaml"
-  spec.files << "lib/function.rb"
 
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.executables << "simplerubysteps-deploy"
-  spec.executables << "simplerubysteps-destroy"
-  spec.executables << "simplerubysteps-workflow-run"
-  
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.17"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simplerubysteps
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Christian Tschenett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-09 00:00:00.000000000 Z
+date: 2023-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,6 +44,7 @@ email:
 executables:
 - simplerubysteps-deploy
 - simplerubysteps-destroy
+- simplerubysteps-logs
 - simplerubysteps-workflow-run
 extensions: []
 extra_rdoc_files: []
@@ -57,15 +58,22 @@ files:
 - bin/setup
 - exe/simplerubysteps-deploy
 - exe/simplerubysteps-destroy
+- exe/simplerubysteps-logs
 - exe/simplerubysteps-workflow-run
 - lib/deploy.sh
 - lib/destroy.sh
 - 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
+- samples/sample1/start-callbackbranch.sh
+- samples/sample1/start-directbranch.sh
 - samples/sample1/workflow.rb
+- samples/sample2/workflow.rb
 - simplerubysteps.gemspec
 homepage: https://github.com/chtz/simplerubysteps
 licenses: