nestene 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OGZlMjkwODJhMGQ4MWE0ODkyYTgzNTU4NGQyOWM5M2Q0M2ZhMTg3Nw==
+  data.tar.gz: !binary |-
+    NzhhN2NjOTM5MDM4MGZkMWZkMjU1ZGU5YTA5MDM1OTE2YzYxYTg1MQ==
+SHA512:
+  metadata.gz: !binary |-
+    NjhmY2Q4YWFhNmIxMTE4YWQwZDE3ZTc3NzNmMzVmNGYzODMxMDYwOTQzNjlj
+    NDBjMTFiNWUzYmY4Y2JjNGY0MTE3MzhiMmRmODIyZjA4ZTJkOGJhODhjYWVl
+    ZWNmMGZkZjFiYWY4MjA5ZGE3MWU4NGJlZjg5NGJlNzE1YWZlOGY=
+  data.tar.gz: !binary |-
+    MTRlZGIxYmIwMjY2MmExMGUwM2ViNDYwOWU5ZGRjMWExN2JkOGQyZDQ0Yzc2
+    NDk0MDc3MTc0MjY5ZjE1MWE4MTA3YzYyMWE3MDYwYjg5ODAxODFkMDA5ZmI0
+    YTEzZjRjYWJjMjg0YTczN2IzNjk2NzJjMzRhMjcwODcyZWE5ODM=

data/.gitignore

@@ -0,0 +1,15 @@
+/storage
+/.bundle
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+# A sample Gemfile
+source "https://rubygems.org"
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Net Ice 9 Ltd
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Nestene
+
+Execution framework for persistent Actors (Autons)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nestene'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nestene
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/nestene/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/TODO.txt

@@ -0,0 +1,7 @@
+todo:
+- Create Auton with specific ID
+- Create Auton with wrong type -> error message
+
+done:
+- Render parameters field for parameters to the method, use parameters when scheduling
+- Sort methods for the dropdown

data/api.rb

@@ -0,0 +1,8 @@
+require 'sinatra/base'
+
+class NesteneApi < Sinatra::Base
+  get '/' do
+    'ok'
+  end
+end
+

data/autons.rb

@@ -0,0 +1,13 @@
+class DummyAuton
+  include StructureMapper::Hash
+
+  def start
+    sleep 6
+  end
+
+
+  def with_parameters p1, p2
+  end
+
+  attribute foo: String
+end

data/bin/nestene.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "rack"
+Rack::Server.start(config: File.expand_path('../../config.ru', __FILE__), Port: 9292)
+

data/config.ru

@@ -0,0 +1,21 @@
+$LOAD_PATH << '.'
+$LOAD_PATH << 'lib'
+
+require 'nestene'
+
+Dir.mkdir('storage') unless File.exists?('storage')
+
+Nestene::start_nestene(Nestene::DiskStorage.new('storage'))
+
+to_check = Bundler.load.specs.map(&:full_gem_path)
+to_check << '.'
+
+to_check.each do |path|
+  file_name = "%s/autons.rb" % [path]
+  if File.exists?(file_name)
+    puts "loading %s" % file_name
+    load(file_name)
+  end
+end
+
+run Nestene::Ui::App

data/features/api/api_create_auton.feature

@@ -0,0 +1,6 @@
+Feature: Api Create Auton
+
+@wip
+  Scenario:
+    When request creation of an auton with an existing type
+    Then the API should respond with status code 201 and auton's ID

data/features/api/api_credentials.feature

@@ -0,0 +1,11 @@
+Feature: API for credentials
+
+  Scenario: getting credentials
+    Given there are credentials set
+    When I get credentials
+    Then I should receive credentials
+
+  Scenario: setting credentials
+    When I set credentials
+    Then the credentials should be set
+

data/features/api/api_list_of_autons.feature

@@ -0,0 +1,6 @@
+Feature: list of autons
+
+  Scenario: List of autons
+    Given I have one started auton
+    When I get the API list of autons
+    Then result should contain the started auton

data/features/callback.feature

@@ -0,0 +1,13 @@
+Feature: callback
+
+  Scenario: callback step execution
+    Given I have an Auton that holds counter state
+    And I have an Auton that schedules a callback step on the counter Auton
+    When I execute second Auton's schedule step
+    Then the callback step of the second Auton should be executed
+
+  Scenario: callback exception execution
+    Given I have an Auton that hold counter state and raises exception on execution
+    And I have an Auton that schedules a callback step on the counter Auton
+    When I execute second Auton's schedule step
+    Then the callback error step of the second Auton with the exception's message should be executed

data/features/create_auton.feature

@@ -0,0 +1,11 @@
+Feature: create auton
+
+  Scenario: create auton
+    Given an empty auton
+    When I create the auton
+    Then the Auton should be in the READY state
+
+  Scenario: attempt to create auton with a wrong class name
+    When I try to create an auton with a non-existing type
+    Then an exception should be raised
+    And the auton should not be created

data/features/credentials.feature

@@ -0,0 +1,7 @@
+Feature: credentials
+
+  Scenario: Auton accessing credentials
+    Given I have an Auton that access credentials in the first step
+    And the credentials are set
+    When I execute the first step of the Auton
+    Then the Auton should be in the READY state

data/features/execute_step.feature

@@ -0,0 +1,59 @@
+Feature: execute step
+
+  Scenario: execute simple non-failing step with parameters
+    Given I have a running auton with one defined step with parameters
+    When I add the step with parameters to the execution queue
+    And I wait for the step to execute
+    Then the Auton should be in the READY state
+    And the execution result should be returned
+
+  Scenario: execute simple non-failing step with parameters
+    Given I have a running auton with one defined step with parameters
+    When I add the step with parameters to the execution queue
+    And I wait for the step to execute
+    Then the Auton should be in the READY state
+    And the execution result should be returned
+
+  Scenario: execute simple failing step
+    Given I have a running auton with one defined step that fails
+    When I add the step to the execution queue
+    And I wait for the step to execute
+    Then the auton should be in the FAILED state
+    And the execution result should be an exception
+
+  Scenario: stop execution when in FAILED state
+    Given I have a running auton with one defined step that fails and one that does not fail
+    When I add first the failing and then the not failing step to the execution queue
+    And I wait for the first step to execute
+    Then the auton should be in the FAILED state
+    And the execution result should be an exception
+    And the not failing step will not be executed
+
+  Scenario: repeating failed step
+    Given I have a running auton with one defined step that fails on the first invocation but succeeds on the second
+    When I add the step to the execution queue
+    And I wait for the step to execute
+    And I repeat the failed step
+    And I wait for the step to execute
+    Then the execution result should be returned
+    And the Auton should be in the READY state
+
+  Scenario: resuming after failure
+    Given I have a running auton with one defined step that fails and one that does not fail
+    When I add first the failing and then the not failing step to the execution queue
+    And I wait for the first step to execute
+    Then the auton should be in the FAILED state
+    When I resume the failed auton
+    And I wait for the second step to execute
+    Then the execution result should be returned
+    And the Auton should be in the READY state
+
+  Scenario: handling exception by Auton
+    Given I have a running auton with one defined step that fails and one that does not fail and an exception handling method for the whole Auton
+    When I add first the failing and then the not failing step to the execution queue
+    And I wait for the first step to execute
+    And I wait for the second step to execute
+    Then the execution result should be returned
+    And the Auton should be in the READY state
+    And the "handle_exception" method should have been executed
+

data/features/restart.feature

@@ -0,0 +1,7 @@
+Feature: restart
+
+  Scenario: restart with one created auton
+    Given an empty auton
+    When I create the auton
+    And I restart the nestene
+    Then the Auton should be in the READY state

data/features/schedule_steps.feature

@@ -0,0 +1,7 @@
+Feature: schedule steps
+
+  Scenario: add step
+    Given I have an Auton that has two steps, first step scheduling the next step
+    When I schedule the first step that returns the uuid of the second scheduled step
+    And I wait for the second step to finish
+    Then the Auton should be in the READY state

data/features/step_definitions/api/api_create_auton_steps.rb

@@ -0,0 +1,16 @@
+When(/^request creation of an auton with an existing type$/) do
+  class EmptyAuton
+    include StructureMapper::Hash
+
+    attribute foo: String
+  end
+  @auton_type="EmptyAuton"
+  post '/autons', {auton_type: @auton_type}.to_json, 'Content-Type' => 'application/json'
+end
+
+Then(/^the API should respond with status code (\d+) and auton's ID$/) do |expected_status|
+  expect(last_response.status).to be(expected_status.to_i)
+  response = JSON.parse(last_response.body)
+  expect(response).not_to be_empty
+  expect(response).to have_key('auton_id')
+end

data/features/step_definitions/api/api_credentials_steps.rb

@@ -0,0 +1,22 @@
+Given(/^there are credentials set$/) do
+  Celluloid::Actor[:nestene_core].set_credentials({'a' => 'b'})
+end
+
+When(/^I get credentials$/) do
+  get '/credentials'
+end
+
+Then(/^I should receive credentials$/) do
+  expect(last_response.status).to be(200)
+  response = JSON.parse(last_response.body)
+  expect(response).to eq({'a' => 'b'})
+end
+
+When(/^I set credentials$/) do
+  post '/credentials', {'a' => 'b'}.to_json, 'Content-Type' => 'application/json'
+end
+
+Then(/^the credentials should be set$/) do
+  expect(last_response.status).to be(200)
+  expect(Celluloid::Actor[:nestene_core].get_credentials).to eq({'a' => 'b'})
+end

data/features/step_definitions/api/api_list_of_autons_steps.rb

@@ -0,0 +1,8 @@
+When(/^I get the API list of autons$/) do
+  get '/autons.json'
+end
+
+Then(/^result should contain the started auton$/) do
+  expect(last_response).to be_ok
+  expect(JSON.parse(last_response.body)).not_to be_empty
+end

data/features/step_definitions/callback_steps.rb

@@ -0,0 +1,75 @@
+Given(/^I have an Auton that holds counter state$/) do
+  class CounterAuton
+    include StructureMapper::Hash
+
+    def initialize
+      self.counter = 0
+    end
+
+    def next
+      self.counter += 1
+    end
+
+    attribute counter: Fixnum
+  end
+  @counter_auton_type="CounterAuton"
+  @counter_auton_id = Celluloid::Actor[:nestene_core].create_auton(@counter_auton_type, "counter")
+end
+
+Given(/^I have an Auton that schedules a callback step on the counter Auton$/) do
+  class CallbackAuton
+    include StructureMapper::Hash
+
+    def start
+      self.context.schedule_callback('counter', :next, [], :set_state)
+    end
+
+    def set_state new_state
+      self.state = new_state
+    end
+
+    def set_state_error error_type, message
+      self.error = message
+    end
+
+    attr_accessor :context
+
+    attribute state: Fixnum
+    attribute error: String
+  end
+  @callback_auton_type="CallbackAuton"
+  @callback_auton_id = Celluloid::Actor[:nestene_core].create_auton(@callback_auton_type, "callback")
+end
+
+When(/^I execute second Auton's schedule step$/) do
+  Celluloid::Actor[:nestene_core].schedule_step @callback_auton_id, :start
+end
+
+Then(/^the callback step of the second Auton should be executed$/) do
+  sleep 0.1
+  expect(Celluloid::Actor["storage:%s" % @callback_auton_id].get.serialized['state']).to eq(1)
+end
+
+
+Given(/^I have an Auton that hold counter state and raises exception on execution$/) do
+  class FailingCounterAuton
+    include StructureMapper::Hash
+
+    def initialize
+      self.counter = 0
+    end
+
+    def next
+      raise "some exception"
+    end
+
+    attribute counter: Fixnum
+  end
+  @counter_auton_type="FailingCounterAuton"
+  @counter_auton_id = Celluloid::Actor[:nestene_core].create_auton(@counter_auton_type, "counter")
+end
+
+Then(/^the callback error step of the second Auton with the exception's message should be executed$/) do
+  sleep 0.1
+  expect(Celluloid::Actor["storage:%s" % @callback_auton_id].get.serialized['error']).to eq('some exception')
+end

data/features/step_definitions/create_auton_steps.rb

@@ -0,0 +1,32 @@
+Given(/^an empty auton$/) do
+  class EmptyAuton
+    include StructureMapper::Hash
+
+    attribute foo: String
+  end
+  @auton_type="EmptyAuton"
+end
+
+When(/^I create the auton$/) do
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton @auton_type
+end
+
+Then(/^the Auton should be in the READY state$/) do
+  expect(Celluloid::Actor["storage:%s" % @auton_id].get.state).to eq(:ready)
+end
+
+When(/^I try to create an auton with a non\-existing type$/) do
+  begin
+    @auton_type = Celluloid::Actor[:nestene_core].create_auton "SomeNotExistingType"
+  rescue Exception => exception
+    @exception = exception
+  end
+end
+
+Then(/^an exception should be raised$/) do
+  expect(@exception).not_to be_nil
+end
+
+Then(/^the auton should not be created$/) do
+  expect(@auton_type).to be_nil
+end

data/features/step_definitions/credentials_steps.rb

@@ -0,0 +1,24 @@
+Given(/^I have an Auton that access credentials in the first step$/) do
+  class CredentialsAuton
+    include StructureMapper::Hash
+
+    attribute credentials: String
+
+    attr_accessor :context
+
+    def use_credentials
+      context.credentials['mail.google.com']
+    end
+  end
+  @auton_type="CredentialsAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton @auton_type
+end
+
+Given(/^the credentials are set$/) do
+  Celluloid::Actor[:nestene_core].set_credentials({'mail.google.com' => 'creds'})
+end
+
+When(/^I execute the first step of the Auton$/) do
+  step_execution_id = Celluloid::Actor[:nestene_core].schedule_step @auton_id, :use_credentials
+  expect(Celluloid::Actor[:nestene_core].wait_for_execution_result(@auton_id, step_execution_id)).to eq('creds')
+end

data/features/step_definitions/execute_step_steps.rb

@@ -0,0 +1,177 @@
+Given(/^I have a running auton with one defined step without any parameters$/) do
+  class SimpleAuton
+    include StructureMapper::Hash
+
+    def start
+      'ok'
+    end
+
+    attribute foo: String
+  end
+  @auton_type="SimpleAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton @auton_type
+  @expected_result = "ok"
+end
+
+When(/^I add the step to the execution queue$/) do
+  @step_execution_id = Celluloid::Actor[:nestene_core].schedule_step @auton_id, :start
+end
+
+When(/^I wait for the step to execute$/) do
+  begin
+    @execution_result = Celluloid::Actor[:nestene_core].wait_for_execution_result(@auton_id, @step_execution_id)
+  rescue Exception => e
+    @execution_exception = e
+  end
+end
+
+Then(/^the execution result should be returned$/) do
+  expect(@execution_result).to eq(@expected_result)
+end
+
+
+Given(/^I have a running auton with one defined step with parameters$/) do
+  class SimpleParamsAuton
+    include StructureMapper::Hash
+
+    def start(p1)
+      'param: %s' % p1
+    end
+
+    attribute foo: String
+  end
+  @auton_type="SimpleParamsAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton @auton_type
+  @expected_result = "param: p1"
+end
+
+When(/^I add the step with parameters to the execution queue$/) do
+  @step_execution_id = Celluloid::Actor[:nestene_core].schedule_step @auton_id, :start, "p1"
+end
+
+
+Given(/^I have a running auton with one defined step that fails$/) do
+  class SimpleFailingAuton
+    include StructureMapper::Hash
+
+    def start
+      raise "failed!"
+    end
+
+    attribute foo: String
+  end
+  @auton_type="SimpleFailingAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton @auton_type
+end
+
+Then(/^the auton should be in the FAILED state$/) do
+  expect(Celluloid::Actor["storage:%s" % @auton_id].get.state).to eq(:failed)
+end
+
+Then(/^the execution result should be an exception$/) do
+  expect(@execution_exception).to be_a(Exception)
+end
+
+
+Given(/^I have a running auton with one defined step that fails and one that does not fail$/) do
+  class SimpleTwoStepsFirstFailingAuton
+    include StructureMapper::Hash
+
+    def start
+      raise "failed!"
+    end
+
+    def cont
+    end
+
+    attribute foo: String
+  end
+  @auton_type="SimpleTwoStepsFirstFailingAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton @auton_type
+end
+
+When(/^I add first the failing and then the not failing step to the execution queue$/) do
+  @first_step_execution_id = Celluloid::Actor[:nestene_core].schedule_step @auton_id, :start
+  @second_step_execution_id = Celluloid::Actor[:nestene_core].schedule_step @auton_id, :cont
+end
+
+When(/^I wait for the first step to execute$/) do
+  begin
+    @execution_result = Celluloid::Actor[:nestene_core].wait_for_execution_result(@auton_id, @first_step_execution_id)
+  rescue Exception => e
+    @execution_exception = e
+  end
+end
+
+Then(/^the not failing step will not be executed$/) do
+  sleep 0.1
+
+  expect(Celluloid::Actor["storage:%s" % @auton_id].get.queue.to_execute.first.uuid).to eq(@second_step_execution_id)
+end
+
+
+Given(/^I have a running auton with one defined step that fails on the first invocation but succeeds on the second$/) do
+  class FirstExecutionFailingAuton
+    include StructureMapper::Hash
+
+    def initalize
+      self.first = true
+    end
+
+    def start
+      should_fail = self.first
+      self.first = false
+      raise "failed!" if should_fail
+    end
+
+    attribute first: Boolean
+  end
+  @auton_type="FirstExecutionFailingAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton @auton_type
+end
+
+When(/^I repeat the failed step$/) do
+
+  @step_execution_id = Celluloid::Actor[:nestene_core].repeat_step @auton_id, @step_execution_id
+
+end
+
+
+When(/^I resume the failed auton$/) do
+  @step_execution_id = Celluloid::Actor[:nestene_core].resume @auton_id
+end
+
+When(/^I wait for the second step to execute$/) do
+  begin
+    @execution_result = Celluloid::Actor[:nestene_core].wait_for_execution_result(@auton_id, @second_step_execution_id)
+  rescue Exception => e
+    @execution_exception = e
+  end
+end
+
+
+Given(/^I have a running auton with one defined step that fails and one that does not fail and an exception handling method for the whole Auton$/) do
+  class TwoStepsFirstFailingWithExceptionHandlerAuton
+    include StructureMapper::Hash
+
+    def start
+      raise "failed!"
+    end
+
+    def cont
+    end
+
+    def handle_exception type, message, method_name, params
+
+    end
+
+    attribute foo: String
+  end
+  @auton_type="TwoStepsFirstFailingWithExceptionHandlerAuton"
+  @auton_id = Celluloid::Actor[:nestene_core].create_auton @auton_type
+end
+
+Then(/^the "(.*?)" method should have been executed$/) do |method_name|
+  expect(Celluloid::Actor["storage:%s" % @auton_id].get.queue.executed.map(&:name)).to include(method_name.to_sym)
+end
+

data/features/step_definitions/restart_steps.rb

@@ -0,0 +1,5 @@
+When(/^I restart the nestene$/) do
+  Celluloid.shutdown
+  Celluloid.boot
+  Nestene::start_nestene(@storage)
+end