nestene 0.1.0

data/lib/nestene/actor/delayed_scheduler.rb

@@ -0,0 +1,76 @@
+require 'celluloid'
+
+module Nestene
+  module Actor
+    class DelayedScheduler
+
+      include Celluloid
+      include Celluloid::Notifications
+
+      def initialize
+        subscribe('state_update', :update_schedule)
+        @schedule = []
+        @timer = nil
+      end
+
+
+      def update_schedule topic, auton_id, state
+
+        @schedule.delete_if{|e| e.first == auton_id}
+
+        state.queue.delayed.each do |d|
+          @schedule << [auton_id, d]
+        end
+
+        @schedule.sort_by!{|e| e[1].execute_at}
+
+        async.schedule_methods
+
+      end
+
+
+      def schedule_methods
+
+        if @timer
+          @timer.cancel
+        end
+
+        now = Time.now
+
+        loop do
+          (auton_id, delayed_method) = @schedule.shift
+
+          if auton_id
+            execute_in = delayed_method.execute_at - now
+            if execute_in <= 0
+              Celluloid::Actor["storage:%s" % auton_id].update do |state|
+                delayed = state.queue.delayed.shift
+                execute_in = delayed.execute_at - now
+                if execute_in <= 0
+                  method = ScheduledMethod.new(delayed)
+                  state.queue.to_execute << method
+                end
+                if delayed.every
+                  delayed.execute_at += delayed.every
+                  state.queue.add_delayed(delayed)
+                end
+              end
+            else
+              @schedule.unshift [auton_id, delayed_method]
+              break
+            end
+          else
+            break
+          end
+        end
+
+        unless @schedule.empty?
+          to_wait = @schedule.first[1].execute_at - now
+          @timer = after(to_wait){async.schedule_methods}
+        end
+
+      end
+    end
+
+  end
+end

data/lib/nestene/auton_context.rb

@@ -0,0 +1,31 @@
+module Nestene
+  class AutonContext
+
+    def initialize auton_id
+      @auton_id = auton_id
+    end
+
+    attr_accessor :steps_to_schedule
+
+    def schedule_callback auton_id, method, parameters, callback_method
+      Celluloid::Actor[:nestene_core].schedule_step auton_id, method, parameters, @auton_id, callback_method
+    end
+
+    def schedule_step name, parameters=[]
+      Celluloid::Actor[:nestene_core].schedule_step @auton_id, name, parameters
+    end
+
+    def schedule_delayed_step delay, name, parameters=[]
+      Celluloid::Actor[:nestene_core].schedule_delayed_step @auton_id, delay, name, parameters
+    end
+
+    def schedule_repeating_delayed_step every, delay, name, parameters=[]
+      Celluloid::Actor[:nestene_core].schedule_repeating_delayed_step @auton_id, every, delay, name, parameters
+    end
+
+    def credentials
+      Celluloid::Actor[:nestene_core].get_credentials
+    end
+
+  end
+end

data/lib/nestene/auton_execution_queue.rb

@@ -0,0 +1,43 @@
+require 'nestene/delayed_method'
+require 'securerandom'
+require 'structure_mapper'
+
+module Nestene
+  class AutonExecutionQueue
+    include StructureMapper::Hash
+
+    def initialize
+      self.to_execute = []
+      self.executed = []
+      self.delayed = []
+    end
+
+    def add_delayed_method name, parameters, delay, every = nil
+      delayed_method = DelayedMethod.new
+      delayed_method.uuid = SecureRandom.uuid
+      delayed_method.name = name
+      delayed_method.parameters = parameters
+      delayed_method.execute_at = Time.now + delay
+      delayed_method.every = every
+      add_delayed(delayed_method)
+      delayed_method
+    end
+
+    def add_delayed delayed_method
+      delayed << delayed_method
+      delayed.sort_by! {|x| x.execute_at}
+    end
+
+
+    def remove_delayed_method method_uuid
+      delayed.delete_if{|m| m.uuid == method_uuid}
+    end
+
+    attribute failed: Boolean
+    attribute to_execute: [ScheduledMethod]
+    attribute executed: [ExecutedMethod]
+    attribute currently_executing: ExecutingMethod
+    attribute delayed: [DelayedMethod]
+
+  end
+end

data/lib/nestene/auton_state.rb

@@ -0,0 +1,27 @@
+module Nestene
+    class AutonState
+
+    include StructureMapper::Hash
+
+    def initialize
+      self.queue=AutonExecutionQueue.new
+    end
+
+    def state
+      if queue.currently_executing == nil
+        queue.failed ? :failed : :ready
+      else
+        :running
+      end
+    end
+
+    attribute type: String
+    attribute serialized: {}
+    attribute queue: AutonExecutionQueue
+
+    def type_as_class
+      self.type ? Nestene::class_from_string(self.type) : nil
+    end
+  end
+
+end

data/lib/nestene/callback.rb

@@ -0,0 +1,7 @@
+module Nestene
+  class Callback
+    include StructureMapper::Hash
+    attribute name: Symbol
+    attribute auton_id: String
+  end
+end

data/lib/nestene/delayed_method.rb

@@ -0,0 +1,17 @@
+module Nestene
+  class DelayedMethod
+    include StructureMapper::Hash
+
+    def initialize
+      self.parameters = []
+      self.scheduled_at = Time.now
+    end
+
+    attribute name: Symbol
+    attribute parameters: []
+    attribute uuid: String
+    attribute scheduled_at: Time
+    attribute execute_at: Time
+    attribute every: Float
+  end
+end

data/lib/nestene/executed_method.rb

@@ -0,0 +1,29 @@
+module Nestene
+  class ExecutedMethod
+    include StructureMapper::Hash
+
+    def initialize(executing_method = nil)
+      self.parameters = []
+      if executing_method
+        self.name = executing_method.name
+        self.parameters = executing_method.parameters
+        self.uuid = executing_method.uuid
+        self.scheduled_at = executing_method.scheduled_at
+        self.started_at = executing_method.started_at
+        self.duration = Time.now - executing_method.started_at
+        self.callback = executing_method.callback
+      end
+    end
+
+    attribute name: Symbol
+    attribute parameters: []
+    attribute uuid: String
+    attribute result: {}
+    attribute error: Exception
+    attribute scheduled_at: Time
+    attribute started_at: Time
+    attribute duration: Float
+    attribute callback: Callback
+
+  end
+end

data/lib/nestene/executing_method.rb

@@ -0,0 +1,23 @@
+module Nestene
+  class ExecutingMethod
+    include StructureMapper::Hash
+
+    def initialize(scheduled_method = nil)
+      if scheduled_method
+        self.name = scheduled_method.name
+        self.parameters = scheduled_method.parameters
+        self.uuid = scheduled_method.uuid
+        self.scheduled_at = scheduled_method.scheduled_at
+        self.started_at = Time.now
+        self.callback = scheduled_method.callback
+      end
+    end
+
+    attribute name: Symbol
+    attribute parameters: []
+    attribute uuid: String
+    attribute scheduled_at: Time
+    attribute started_at: Time
+    attribute callback: Callback
+  end
+end

data/lib/nestene/execution_error.rb

@@ -0,0 +1,39 @@
+module Nestene
+
+  class ExecutionError
+    include StructureMapper::Hash
+
+    def initialize(exception = nil)
+
+      if exception
+        self.message = exception.message
+        self.type = exception.class.name
+        self.backtrace = exception.backtrace
+      end
+    end
+
+    attribute message: String
+    attribute type: String
+    attribute backtrace: [String]
+
+
+    def to_exception
+      exception = Nestene.class_from_string(type).new(message)
+      exception.set_backtrace self.backtrace
+      exception
+    end
+  end
+
+end
+
+class Exception
+
+  def to_structure
+    Nestene::ExecutionError.new(self).to_structure
+  end
+
+  def self.from_structure structure
+    structure ? Nestene::ExecutionError.from_structure(structure).to_exception : nil
+  end
+
+end

data/lib/nestene/scheduled_method.rb

@@ -0,0 +1,21 @@
+module Nestene
+  class ScheduledMethod
+    include StructureMapper::Hash
+
+    def initialize(delayed_method = nil)
+      self.parameters = []
+      self.scheduled_at = Time.now
+      if delayed_method
+        self.uuid = delayed_method.uuid
+        self.name = delayed_method.name
+        self.parameters = delayed_method.parameters
+      end
+    end
+
+    attribute name: Symbol
+    attribute parameters: []
+    attribute uuid: String
+    attribute scheduled_at: Time
+    attribute callback: Callback
+  end
+end

data/lib/nestene/storage.rb

@@ -0,0 +1,72 @@
+require 'json'
+
+module Nestene
+
+
+  class FileNameConverter
+
+    def key_to_file_name(key)
+      key.gsub(/[^a-zA-Z0-9]/){|x| "_%x" % x.ord}
+    end
+
+    def file_name_to_key file_name
+      file_name.gsub(/_[a-zA-Z0-9]{2}/){|x| x[1..-1].hex.chr}
+    end
+
+  end
+
+  class DiskStorage
+
+    def initialize(dir)
+      @dir=dir
+      @converter = FileNameConverter.new
+    end
+
+    def list
+      entries = Dir.entries(@dir)
+      entries.delete('.')
+      entries.delete('..')
+      entries.delete('__credentials__')
+      entries.map{|fn| @converter.file_name_to_key(fn)}
+    end
+
+    def store(key, value)
+      final_name = "%s/%s" % [@dir,@converter.key_to_file_name(key)]
+      tmp_name = "%s.temp" % final_name
+      File.open(tmp_name,"w") do |f|
+        f.write(JSON.pretty_generate(value))
+      end
+      File.rename(tmp_name, final_name)
+    end
+
+    def load(key)
+      file_name = "%s/%s" % [@dir,@converter.key_to_file_name(key)]
+      if File.exist?(file_name)
+        File.open(file_name,"r"){|f| JSON.parse(f.read)}
+      else
+        nil
+      end
+    end
+
+  end
+
+  class MemoryStorage
+
+    def initialize
+      @storage = {}
+    end
+
+    def list
+      @storage.keys
+    end
+
+    def load(key)
+      @storage[key]
+    end
+
+    def store(key, value)
+      @storage[key] = value
+    end
+  end
+
+end

data/lib/nestene/ui/app.rb

@@ -0,0 +1,103 @@
+require 'sinatra/base'
+require 'haml'
+require 'json'
+
+module Nestene
+  module Ui
+    class App < Sinatra::Base
+
+
+      get '/autons.json' do
+        content_type :json
+        Celluloid::Actor[:nestene_core].auton_names.to_json
+      end
+
+      get '/credentials' do
+        content_type :json
+        Celluloid::Actor[:nestene_core].get_credentials.to_json
+      end
+
+      post '/credentials' do
+        content_type :json
+        begin
+          credentials = JSON.parse(request.body.read)
+          auton_id = Celluloid::Actor[:nestene_core].set_credentials credentials
+          status 200
+        rescue Exception => e
+          puts e
+          status 500
+          {message: e.message}.to_json
+        end
+      end
+
+      post '/autons' do
+        content_type :json
+        begin
+          type = JSON.parse(request.body.read).fetch('auton_type')
+          raise "auton_type not set" unless type
+          auton_id = Celluloid::Actor[:nestene_core].create_auton type
+          status 201
+          {auton_id: auton_id}.to_json
+        rescue Exception => e
+          status 500
+          {message: e.message}.to_json
+        end
+
+      end
+
+      get '/' do
+        @auton_names = Celluloid::Actor[:nestene_core].auton_names
+        haml :index
+      end
+
+      get '/auton/create' do
+        haml :auton_form
+      end
+
+      get '/auton/:id' do
+        @auton_id = params[:id]
+        @auton_state = Celluloid::Actor[:nestene_core].get_state(@auton_id)
+        haml :auton
+      end
+
+      get '/auton/:id/schedule_step' do
+        @auton_id = params[:id]
+        @auton_state = Celluloid::Actor[:nestene_core].get_state(@auton_id)
+        auton_type = @auton_state.type_as_class
+        @available_methods = auton_type.instance_methods(false).map{|name| auton_type.instance_method(name)}
+        @number_of_params = 0
+        haml :schedule_step
+      end
+
+      post '/auton/:id/schedule_step' do
+        parameters = params[:parameters] || []
+        step_name = params[:step_name]
+
+        @auton_id = params[:id]
+        @auton_state = Celluloid::Actor[:nestene_core].get_state(@auton_id)
+        auton_type = @auton_state.type_as_class
+        @available_methods = auton_type.instance_methods(false).sort.map{|name| auton_type.instance_method(name)}
+
+        method = @available_methods.find{|m| m.name.to_s == step_name}
+
+        if method && method.arity == parameters.size
+          step_id = Celluloid::Actor[:nestene_core].schedule_step(params[:id],step_name, parameters)
+          headers['X-AUTON-STEP-ID'] = step_id
+          redirect '/auton/%s' % params[:id]
+        else
+          @method = method
+          @number_of_params = method ? method.arity : 0
+          @step_name = step_name
+          haml :schedule_step
+        end
+      end
+
+      post '/auton/create' do
+        Celluloid::Actor[:nestene_core].create_auton params[:auton_type]
+        redirect '/'
+      end
+
+    end
+
+  end
+end

data/lib/nestene/ui/public/app/application.js

@@ -0,0 +1,75 @@
+var nestene = angular.module('nestene', ['JSONedit']);
+
+nestene.controller('AutonsController',  function($scope, $http, $timeout) {
+  $scope.autons=[];
+
+  $scope.getAutons = function() {
+    var autonsPromise = $http.get("autons.json");
+    autonsPromise.success(function(data, status, headers, config) {
+      $scope.autons = data;
+    });
+
+    autonsPromise.error(function(data, status, headers, config) {
+      $.bootstrapGrowl("getting autons failed!", { type: 'danger' });
+    });
+  }
+
+  $scope.intervalFunction = function() {
+    $timeout(function() {
+      $scope.getAutons();
+      $scope.intervalFunction();
+    }, 1000);
+  };
+
+  $scope.intervalFunction();
+
+});
+
+nestene.controller('CreateAutonFormController', function($scope,$http) {
+  $scope.autonType = '';
+  $scope.createAuton = function() {
+    var postPromise = $http.post("autons",{auton_type: $scope.autonType});
+    postPromise.success(function(data, status, headers, config) {
+      $.bootstrapGrowl("Created "+data['auton_id'], { type: 'success' });
+    });
+    postPromise.error(function(data, status, headers, config) {
+      $.bootstrapGrowl("Could not create Auton: "+data['message'], { type: 'error' });
+    });
+  };
+});
+
+nestene.controller('CredentialsController', function($scope,$http) {
+  $scope.credentials={};
+  $scope.loaded = false;
+
+
+  $scope.loadCredentials = function() {
+    var getPromise = $http.get("credentials");
+    getPromise.success(function(data, status, headers, config) {
+      $scope.credentials = data;
+      $scope.loaded = true;
+    });
+
+    getPromise.error(function(data, status, headers, config) {
+      $.bootstrapGrowl("getting credentials failed!", { type: 'danger' });
+    });
+  }
+
+  $scope.loadCredentials();
+
+  $scope.storeCredentials = function() {
+    var postPromise = $http.post("credentials",$scope.credentials);
+    postPromise.success(function(data, status, headers, config) {
+      $.bootstrapGrowl("Credentials saved", { type: 'success' });
+    });
+    postPromise.error(function(data, status, headers, config) {
+      $.bootstrapGrowl("Could not save credentials", { type: 'danger' });
+    });
+  };
+});
+
+
+
+
+
+

data/lib/nestene/ui/public/vendor/angular-ui-sortable/sortable.min.js

@@ -0,0 +1 @@
+!function(a,b){"use strict";b.module("ui.sortable",[]).value("uiSortableConfig",{}).directive("uiSortable",["uiSortableConfig","$timeout","$log",function(a,c,d){return{require:"?ngModel",link:function(e,f,g,h){function i(a,b){return b&&"function"==typeof b?function(c,d){a(c,d),b(c,d)}:a}function j(a,b){var c=a.sortable("option","helper");return"clone"===c||"function"==typeof c&&b.item.sortable.isCustomHelperUsed()}var k,l={},m={receive:null,remove:null,start:null,stop:null,update:null},n={helper:null};return b.extend(l,a,e.$eval(g.uiSortable)),b.element.fn&&b.element.fn.jquery?(h?(e.$watch(g.ngModel+".length",function(){c(function(){f.data("ui-sortable")&&f.sortable("refresh")})}),m.start=function(a,b){b.item.sortable={index:b.item.index(),cancel:function(){b.item.sortable._isCanceled=!0},isCanceled:function(){return b.item.sortable._isCanceled},isCustomHelperUsed:function(){return!!b.item.sortable._isCustomHelperUsed},_isCanceled:!1,_isCustomHelperUsed:b.item.sortable._isCustomHelperUsed}},m.activate=function(){k=f.contents();var a=f.sortable("option","placeholder");if(a&&a.element&&"function"==typeof a.element){var c=a.element();c=b.element(c);var d=f.find('[class="'+c.attr("class")+'"]');k=k.not(d)}},m.update=function(a,b){b.item.sortable.received||(b.item.sortable.dropindex=b.item.index(),b.item.sortable.droptarget=b.item.parent(),f.sortable("cancel")),j(f,b)&&!b.item.sortable.received&&(k=k.not(k.last())),k.appendTo(f),b.item.sortable.received&&(k=null),b.item.sortable.received&&!b.item.sortable.isCanceled()&&e.$apply(function(){h.$modelValue.splice(b.item.sortable.dropindex,0,b.item.sortable.moved)})},m.stop=function(a,b){!b.item.sortable.received&&"dropindex"in b.item.sortable&&!b.item.sortable.isCanceled()?e.$apply(function(){h.$modelValue.splice(b.item.sortable.dropindex,0,h.$modelValue.splice(b.item.sortable.index,1)[0])}):"dropindex"in b.item.sortable&&!b.item.sortable.isCanceled()||j(f,b)||k.appendTo(f),k=null},m.receive=function(a,b){b.item.sortable.received=!0},m.remove=function(a,b){"dropindex"in b.item.sortable||(f.sortable("cancel"),b.item.sortable.cancel()),b.item.sortable.isCanceled()||e.$apply(function(){b.item.sortable.moved=h.$modelValue.splice(b.item.sortable.index,1)[0]})},n.helper=function(a){return a&&"function"==typeof a?function(b,c){var d=a(b,c);return c.sortable._isCustomHelperUsed=c!==d,d}:a},e.$watch(g.uiSortable,function(a){f.data("ui-sortable")&&b.forEach(a,function(a,b){m[b]?("stop"===b&&(a=i(a,function(){e.$apply()})),a=i(m[b],a)):n[b]&&(a=n[b](a)),f.sortable("option",b,a)})},!0),b.forEach(m,function(a,b){l[b]=i(a,l[b])})):d.info("ui.sortable: ngModel not provided!",f),void f.sortable(l)):void d.error("ui.sortable: jQuery should be included before AngularJS!")}}}])}(window,window.angular);