nestene 0.1.0

data/features/step_definitions/schedule_steps_steps.rb

@@ -0,0 +1,29 @@
+Given(/^I have an Auton that has two steps, first step scheduling the next step$/) do
+  class ScheduleSecondStepAuton
+    include StructureMapper::Hash
+
+    def first
+      context.schedule_step(:second)
+    end
+
+    def second
+      'ok'
+    end
+
+    attr_accessor :context
+
+    attribute foo: Fixnum
+  end
+  @auton_type="ScheduleSecondStepAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton(@auton_type)
+end
+
+When(/^I schedule the first step that returns the uuid of the second scheduled step$/) do
+  @step_execution_id = Celluloid::Actor[:nestene_core].schedule_step @auton_id, :first
+  @step_execution_id = Celluloid::Actor[:nestene_core].wait_for_execution_result(@auton_id, @step_execution_id)
+end
+
+When(/^I wait for the second step to finish$/) do
+  @execution_result = Celluloid::Actor[:nestene_core].wait_for_execution_result(@auton_id, @step_execution_id)
+end
+

data/features/step_definitions/time_delayed_steps_steps.rb

@@ -0,0 +1,103 @@
+Given(/^an Auton that schedules an one off delayed step in (\d+)\.(\d+) second$/) do |arg1, arg2|
+  class TimeDelayedStepSchedulingAuton
+    include StructureMapper::Hash
+
+    def first
+      context.schedule_delayed_step(0.1, :second)
+    end
+
+    def second
+      'ok'
+    end
+
+    attr_accessor :context
+
+    attribute foo: Fixnum
+  end
+  @auton_type="TimeDelayedStepSchedulingAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton(@auton_type)
+end
+
+When(/^I execute the step that schedules the delayed step$/) do
+  @start_time = Time.now
+  @step_execution_id = Celluloid::Actor[:nestene_core].schedule_step @auton_id, :first
+  @second_step_execution_id = Celluloid::Actor[:nestene_core].wait_for_execution_result(@auton_id, @step_execution_id)
+end
+
+Then(/^the elapsed time between first and sencond step should be at least (\d+\.\d+) secods$/) do |seconds_string|
+  raise @execution_exception if @execution_exception
+  expect(@execution_result).to eq('ok')
+  expect(Time.now - @start_time).to be >= seconds_string.to_f
+end
+
+When(/^I cancel the time delayed step$/) do
+  Celluloid::Actor[:nestene_core].cancel_delayed_step @auton_id, @second_step_execution_id
+end
+
+When(/^I wait for (\d+\.\d+) seconds$/) do |seconds|
+  sleep seconds.to_f
+end
+
+Then(/^the scheduled step should not be executed$/) do
+  expect(Celluloid::Actor[:nestene_core].get_state(@auton_id).queue.executed.size).to eq(1)
+end
+
+
+Given(/^an Auton that schedules an repeating every (\d+\.\d+) seconds delayed step in (\d+\.\d+) second$/) do |every, delay|
+  class RepeatingTimeDelayedStepdSchedulingAuton
+    include StructureMapper::Hash
+
+    def first
+      context.schedule_repeating_delayed_step(0.1, 0.1, :second)
+    end
+
+    def second
+      'ok'
+    end
+
+    attr_accessor :context
+
+    attribute foo: Fixnum
+  end
+  @auton_type="RepeatingTimeDelayedStepdSchedulingAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton(@auton_type)
+end
+
+Then(/^the scheduled step should be executed twice$/) do
+  expect(Celluloid::Actor[:nestene_core].get_state(@auton_id).queue.executed.map{|m| m.name}).to eq([:first,:second,:second])
+end
+
+
+Given(/^an Auton that schedules an one off delayed step in (\d+\.\d+) seconds and has a failing step$/) do |delay|
+    class TimeDelayedAndFailingStepSchedulingAuton
+    include StructureMapper::Hash
+
+    def first
+      context.schedule_delayed_step(0.1, :second)
+    end
+
+    def fail
+      raise "fail!"
+    end
+
+    def second
+      'ok'
+    end
+
+    attr_accessor :context
+
+    attribute foo: Fixnum
+  end
+  @auton_type="TimeDelayedAndFailingStepSchedulingAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton(@auton_type)
+end
+
+When(/^I execute the failing step$/) do
+  @step_execution_id = Celluloid::Actor[:nestene_core].schedule_step @auton_id, :fail
+  expect {Celluloid::Actor[:nestene_core].wait_for_execution_result(@auton_id, @step_execution_id)}.to raise_error
+end
+
+Then(/^the delayed step should not be executed$/) do
+  expect(Celluloid::Actor[:nestene_core].get_state(@auton_id).queue.executed.map{|m| m.name}).to eq([:first,:fail])
+end
+

data/features/step_definitions/ui/create_auton_steps.rb

@@ -0,0 +1,21 @@
+Given(/^there is a simple Auton implementation$/) do
+  class EmptyAuton
+    include StructureMapper::Hash
+
+    attribute foo: String
+  end
+  @auton_type="EmptyAuton"
+end
+
+When(/^I create that simple Auton$/) do
+  visit '/'
+  click_on 'Create Auton'
+  fill_in 'auton_type', with: @auton_type
+  click_on 'create'
+end
+
+Then(/^the list of Autons should contain the auton id$/) do
+  get '/autons.json'
+  expect(last_response).to be_ok
+  expect(JSON.parse(last_response.body)).not_to be_empty
+end

data/features/step_definitions/ui/list_of_autons_steps.rb

@@ -0,0 +1,18 @@
+Given(/^I have one started auton$/) do
+  class EmptyAuton
+    include StructureMapper::Hash
+
+    attribute foo: String
+  end
+  @auton_type="EmptyAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton(@auton_type, 'empty_auton')
+end
+
+When(/^I visit the index page$/) do
+  visit '/'
+end
+
+Then(/^I should see the id of that auton$/) do
+  expect(page).to have_content 'empty_auton'
+end
+

data/features/step_definitions/ui/schedule_auton_step_steps.rb

@@ -0,0 +1,64 @@
+Given(/^I have a running auton with one defined step without parameters$/) do
+  class EmptyAuton
+    include StructureMapper::Hash
+
+    def initialize
+    end
+
+    def start
+      self.started = true
+    end
+
+    attribute started: Boolean
+  end
+
+  @auton_type="EmptyAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton(@auton_type, 'empty_auton')
+end
+
+When(/^I schedule the step$/) do
+  visit '/auton/%s' % @auton_id
+  click_on 'schedule_step'
+  select 'start'
+  click_on 'schedule'
+  @step_execution_id = page.response_headers['X-AUTON-STEP-ID']
+  raise 'could not find step id' unless @step_execution_id
+end
+
+
+Given(/^I have a running auton with one defined step with two parameters$/) do
+  class EmptyAutonWithParams
+    include StructureMapper::Hash
+
+    def initialize
+    end
+
+    def start p1, p2
+      self.p1 = p1
+      self.p2 = p2
+    end
+
+    attribute p1: String
+    attribute p2: String
+  end
+
+  @auton_type="EmptyAutonWithParams"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton(@auton_type)
+end
+
+When(/^I schedule the step with parameters$/) do
+  visit '/auton/%s' % @auton_id
+  click_on 'schedule_step'
+  select 'start'
+  click_on 'schedule'
+  # select 'start'
+  fill_in 'parameters[0]', with: 'p1'
+  fill_in 'parameters[1]', with: 'p1'
+  click_on 'schedule'
+  @step_execution_id = page.response_headers['X-AUTON-STEP-ID']
+  raise 'could not find step id' unless @step_execution_id
+end
+
+Then(/^the executed steps should include the step with the parameters$/) do
+  expect(Celluloid::Actor["storage:%s" % @auton_id].get.queue.executed.first.uuid).to eq(@step_execution_id)
+end

data/features/step_definitions/ui/show_auton_steps.rb

@@ -0,0 +1,49 @@
+Given(/^I have one running Auton$/) do
+  class SomeCoolAuton
+    include StructureMapper::Hash
+
+    def start
+    end
+
+    attribute foo: String
+  end
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton "SomeCoolAuton"
+end
+
+When(/^I view the Auton$/) do
+  visit '/'
+  click_on @auton_id
+end
+
+Then(/^I should see Auton's id/) do
+  expect(page).to have_content @auton_id
+end
+
+
+Then(/^I should see Auton's status$/) do
+  expect(page.find('#auton_state').text).to eq('ready')
+end
+
+Then(/^I should see Auton's state$/) do
+  expect(page).to have_css('#current_state')
+end
+
+Then(/^I should see Auton's queue$/) do
+  expect(page).to have_css('#queue')
+end
+
+Then(/^I should see Auton's executed steps$/) do
+    expect(page).to have_css('#executed')
+end
+
+Then(/^I should see Auton's current step$/) do
+    expect(page).to have_css('#executing')
+end
+
+Then(/^I should see Auton's scheduled steps$/) do
+    expect(page).to have_css('#to_execute')
+end
+
+Then(/^I should see Auton's delayed steps$/) do
+  pending # express the regexp above with the code you wish you had
+end

data/features/support/env.rb

@@ -0,0 +1,36 @@
+ENV['RACK_ENV'] = 'test'
+require "rack/test"
+require 'nestene'
+require 'capybara/cucumber'
+require 'capybara/poltergeist'
+require 'pry'
+Capybara.javascript_driver = :poltergeist
+
+Capybara.app = Nestene::Ui::App
+
+Capybara.register_driver :rack_test do |app|
+  Capybara::RackTest::Driver.new app, \
+    redirect_limit: 15,
+    follow_redirects: false,
+    respect_data_method: true
+end
+
+Before do
+  Celluloid.shutdown
+  Celluloid.boot
+  @storage = Nestene::MemoryStorage.new
+  Nestene::start_nestene(@storage)
+end
+
+class MyWorld
+  include Rack::Test::Methods
+  def app
+    Nestene::Ui::App
+  end
+end
+
+World do
+  MyWorld.new
+end
+
+

data/features/time_delayed_steps.feature

@@ -0,0 +1,28 @@
+Feature: time delayed steps
+
+  Scenario: scheduling one off time delayed step
+    Given an Auton that schedules an one off delayed step in 0.1 second
+    When I execute the step that schedules the delayed step
+    And I wait for the second step to execute
+    Then the elapsed time between first and sencond step should be at least 0.1 secods
+
+  Scenario: un-scheduling one off time delayed step
+    Given an Auton that schedules an one off delayed step in 0.1 second
+    When I execute the step that schedules the delayed step
+    And I cancel the time delayed step
+    And I wait for 0.15 seconds
+    Then the scheduled step should not be executed
+
+  Scenario: scheduling repeating delayed step
+    Given an Auton that schedules an repeating every 0.1 seconds delayed step in 0.1 second
+    When I execute the step that schedules the delayed step
+    And I wait for 0.21 seconds
+    Then the scheduled step should be executed twice
+
+  Scenario: suspending one off delayed step when auton is in error state
+    Given an Auton that schedules an one off delayed step in 0.1 seconds and has a failing step
+    When I execute the step that schedules the delayed step
+    When I execute the failing step
+    And I wait for 0.11 seconds
+    Then the delayed step should not be executed
+

data/features/ui/create_auton.feature

@@ -0,0 +1,7 @@
+Feature: create auton
+
+  @javascript
+  Scenario: create auton
+    Given there is a simple Auton implementation
+    When I create that simple Auton
+    Then the list of Autons should contain the auton id

data/features/ui/list_of_autons.feature

@@ -0,0 +1,7 @@
+Feature: List of autons
+
+  @javascript
+  Scenario: Listing Running Autons
+    Given I have one started auton
+    When I visit the index page
+    Then I should see the id of that auton

data/features/ui/schedule_auton_step.feature

@@ -0,0 +1,12 @@
+Feature: schedule auton step
+
+  Scenario: schedule steps without parameters
+    Given I have a running auton with one defined step without parameters
+    When I schedule the step
+    And I wait for the step to execute
+
+  Scenario: schedule steps with parameters
+    Given I have a running auton with one defined step with two parameters
+    When I schedule the step with parameters
+    And I wait for the step to execute
+    Then the executed steps should include the step with the parameters

data/features/ui/show_auton.feature

@@ -0,0 +1,14 @@
+Feature: show auton
+
+  @javascript
+  Scenario: show running Auton
+    Given I have one running Auton
+    When I view the Auton
+    Then I should see Auton's id
+    And I should see Auton's status
+    And I should see Auton's state
+    And I should see Auton's queue
+    And I should see Auton's executed steps
+    And I should see Auton's current step
+    And I should see Auton's scheduled steps
+    # And I should see Auton's delayed steps

data/lib/nestene/actor/auton_queue.rb

@@ -0,0 +1,87 @@
+require 'celluloid'
+
+module Nestene
+  module Actor
+    class AutonQueue
+      include Celluloid
+      include Celluloid::Notifications
+
+      def initialize
+        subscribe('state_update', :execute_next_step)
+      end
+
+
+      def execute_next_step topic, auton_id, state
+        executing = nil
+        type = nil
+        ser = nil
+        running = false
+
+        Celluloid::Actor["storage:%s" % auton_id].update do |state|
+          running = state.state == :ready && !state.queue.to_execute.empty?
+          if running
+            nx = state.queue.to_execute.shift
+            executing = ExecutingMethod.new(nx)
+            state.queue.currently_executing = executing
+            type = state.type
+            ser = state.serialized
+          end
+        end
+
+        return unless running
+
+        instance = Nestene::class_from_string(type).from_structure(ser)
+
+        if instance.public_methods.include?(:context=)
+          instance.public_send(:context=, AutonContext.new(auton_id))
+        end
+
+        future = Celluloid::Future.new do
+          instance.method(executing.name).call(*executing.parameters)
+        end
+
+        result = exception = nil
+
+        begin
+          result = future.value
+        rescue Exception => e
+          exception = e
+        end
+
+        executed = ExecutedMethod.new(executing)
+
+        executed.result = result
+
+        if exception
+          executed.error = exception
+        end
+
+        if executed.callback
+          if exception
+            Celluloid::Actor[:nestene_core].async.schedule_step executed.callback.auton_id, ("%s_error" % executed.callback.name.to_s), [exception.class.name, exception.message]
+          else
+            Celluloid::Actor[:nestene_core].async.schedule_step executed.callback.auton_id, executed.callback.name, result
+          end
+        end
+
+        Celluloid::Actor["storage:%s" % auton_id].update do |state|
+          state.queue.currently_executing = nil
+          state.serialized = instance.to_structure
+          if exception
+            if instance.methods.include?(:handle_exception) && executing.name != :handle_exception
+              method = ScheduledMethod.new
+              method.name = :handle_exception
+              method.parameters = [exception.class.name, exception.message, executing.name, executing.parameters]
+              method.uuid = SecureRandom.uuid
+              state.queue.to_execute.unshift method
+            else
+              state.queue.failed = true
+            end
+          end
+          state.queue.executed << executed
+        end
+      end
+
+    end
+  end
+end

data/lib/nestene/actor/auton_storage.rb

@@ -0,0 +1,50 @@
+require 'celluloid'
+
+module Nestene
+  module Actor
+    class AutonStorage
+      include Celluloid
+      include Celluloid::Notifications
+
+      exclusive :create, :get, :update
+
+      execute_block_on_receiver :update
+
+      def initialize(auton_id, storage)
+        @auton_id = auton_id
+        @storage = storage
+        state = get
+        publish('state_update', @auton_id, state) if state
+      end
+
+      def create type
+        state = AutonState.new
+        state.type = type
+        instance = Nestene::class_from_string(type).new
+        state.serialized = instance.to_structure
+        @storage.store(@auton_id,state.to_structure)
+        publish('state_update', @auton_id, state)
+      rescue Exception => e
+        abort e
+      end
+
+      def get
+        structure = @storage.load(@auton_id)
+        structure ? AutonState.from_structure(structure) : nil
+      end
+
+      def update &block
+        before = @storage.load(@auton_id)
+        state = AutonState.from_structure(@storage.load(@auton_id))
+        result = block.call(state)
+        after = state.to_structure
+        @storage.store(@auton_id,after)
+        publish('state_update', @auton_id, state) if before != after
+        result
+      rescue Exception => e
+        abort e
+      end
+
+    end
+  end
+end

data/lib/nestene/actor/core.rb

@@ -0,0 +1,150 @@
+require 'celluloid'
+
+module Nestene
+  module Actor
+    class Core
+
+      include Celluloid
+      include Celluloid::Notifications
+
+      def initialize(storage)
+        subscribe('state_update', :notify_waiters)
+        @execution_futures={}
+        @storage = storage
+        storage.list.each do |auton_id|
+          Celluloid::Actor["storage:%s" % auton_id] = AutonStorage.new(auton_id, @storage)
+        end
+      end
+
+      def auton_names
+        @storage.list
+      end
+
+      def get_credentials
+        @storage.load('__credentials__') || {}
+      end
+
+      def set_credentials credentials
+        @storage.store('__credentials__',credentials)
+      end
+
+      def create_auton type, auton_id=SecureRandom.uuid
+        storage = AutonStorage.new(auton_id, @storage)
+        Celluloid::Actor["storage:%s" % auton_id] = storage
+        storage.create(type)
+        auton_id
+      rescue Exception => e
+        abort e
+      end
+
+      def get_state auton_id
+        Celluloid::Actor["storage:%s" % auton_id].get
+      rescue Exception => e
+        abort e
+      end
+
+      def schedule_step auton_id, step_name, parameters=[], callback_auton_id=nil, callback_method=nil
+        step_id = SecureRandom.uuid
+        Celluloid::Actor["storage:%s" % auton_id].update do |state|
+          method = ScheduledMethod.new
+          method.name = step_name
+          method.parameters = parameters
+          method.uuid = step_id
+          if callback_auton_id && callback_method
+            method.callback = Callback.new
+            method.callback.name = callback_method
+            method.callback.auton_id = callback_auton_id
+          end
+          state.queue.to_execute << method
+        end
+        step_id
+      end
+
+      def cancel_delayed_step auton_id, step_id
+        Celluloid::Actor["storage:%s" % auton_id].update do |state|
+          delayed = state.queue.remove_delayed_method step_id
+        end
+      end
+
+      def schedule_delayed_step auton_id, delay , name, parameters=[]
+        Celluloid::Actor["storage:%s" % auton_id].update do |state|
+          delayed = state.queue.add_delayed_method name, parameters, delay
+          delayed.uuid
+        end
+      end
+
+
+      def schedule_repeating_delayed_step auton_id, every, delay, name, parameters=[]
+        Celluloid::Actor["storage:%s" % auton_id].update do |state|
+          delayed = state.queue.add_delayed_method name, parameters, delay, every
+          delayed.uuid
+        end
+      end
+
+      def repeat_step auton_id, method_uuid
+        step_id = SecureRandom.uuid
+        Celluloid::Actor["storage:%s" % auton_id].update do |state|
+
+          original_step = state.queue.executed.find{|m| m.uuid == method_uuid}
+
+          method = ScheduledMethod.new
+          method.name = original_step.name
+          method.parameters = original_step.parameters
+          method.uuid = step_id
+          state.queue.to_execute.unshift method
+          state.queue.failed = false
+        end
+        step_id
+      end
+
+      def resume auton_id
+        Celluloid::Actor["storage:%s" % auton_id].update do |state|
+          state.queue.failed = false
+        end
+      end
+
+
+      def wait_for_execution_result auton_id, method_uuid
+
+        future = nil
+
+        executed = nil
+
+
+        exclusive do
+
+          state = Celluloid::Actor["storage:%s" % auton_id].get
+
+          unless @execution_futures.has_key?(auton_id)
+            @execution_futures[auton_id] = Celluloid::Future.new
+          end
+
+          future = @execution_futures[auton_id]
+
+          executed = state ? state.queue.executed.find{|m| m.uuid == method_uuid} : nil
+
+        end
+
+        until executed
+
+          executed = future.value
+          state = Celluloid::Actor["storage:%s" % auton_id].get
+          executed = state.queue.executed.find{|m| m.uuid == method_uuid}
+        end
+
+        if executed.error
+          abort executed.error
+        else
+          return executed.result
+        end
+
+      end
+
+      def notify_waiters topic, auton_id, state
+        future = @execution_futures.delete(auton_id)
+        future.signal(SelfValue.new) if future
+      end
+
+    end
+  end
+end