MINT-core 1.0.1 → 2.0.0

data/lib/MINT-core/manager/scxml_server.rb

@@ -0,0 +1,86 @@
+
+require 'rubygems'
+require "bundler/setup"
+require "MINT-core"
+require "MINT-scxml"
+
+class SCXMLServer
+  attr_accessor :connections
+  attr_accessor :manager
+
+  class StatefulProtocol < EventMachine::Connection
+    include EM::Protocols::LineText2
+    attr_accessor :manager
+
+    def initialize
+      super()
+    end
+
+    def subscribe_redis(interactor,name)
+      @interactor = interactor
+      @name = name
+
+      redis = EventMachine::Hiredis.connect
+
+      redis.pubsub.psubscribe(@interactor) { |key, message|
+
+        found=MultiJson.decode message
+        if @name.nil? or @name.eql? found["name"]
+          if found.has_key? "new_states"
+            # send new state
+            found["new_states"].each { |state|
+              p "activated: #{state}"
+              send_active_state state }
+          end
+
+          if(@state_store[key])
+            activated_states =  @state_store[key]
+
+            current_active_states = found["states"] + found["abstract_states"]
+
+            deactivated_states = activated_states - current_active_states
+
+            # send deactivate states
+
+            deactivated_states.each {|state|
+              p "deactivated: #{state}"
+              send_inactive_state state
+            }
+
+            #save activated states
+            @state_store[key] = current_active_states
+          end
+        end
+      }.callback { p "subscribed to #{@interactor} name #{@name}"}
+
+    end
+
+    def send_active_state(name)
+      send_data "1 #{name}"
+    end
+
+    def send_inactive_state(name)
+      send_data "0 #{name}"
+    end
+  end
+
+  def initialize(_interactor,_name)
+    @interactor = _interactor
+    @name = _name
+  end
+
+  def start(host="0.0.0.0",port=3001)
+  EventMachine::start_server host, port, StatefulProtocol do |conn|
+      conn.subscribe_redis(@interactor,@name)
+      @connections << conn
+
+      puts "connection..."
+
+      # inform about all currently activated states
+      # @state_store[@interactor]
+    end
+    puts "Started server on #{host}:#{port}"
+  end
+
+end
+

data/lib/MINT-core/mapping/action/action.rb

@@ -0,0 +1,32 @@
+class Action
+
+def initialize
+
+  # sucecss of action used by finisheh callback
+  @result = false
+end
+
+  def id
+    @action[:id]
+  end
+
+ def identifier
+
+ end
+
+ def initiated_callback(cb)
+
+ end
+
+ def start (observation_results)
+   self
+ end
+
+
+  # This callback is used to inform that the action has been successfully finished
+  def finished_callback (&block)
+    block.call(id,@result)
+  end
+
+
+end

data/lib/MINT-core/mapping/action/backend_action.rb

@@ -0,0 +1,32 @@
+class BackendAction < Action
+  # BackendAction.new(:call => CUIControl.method(:find_cio_from_coordinates))
+  def initialize(params)
+      super()
+      @action = params
+  end
+
+
+  def parameter
+    return [] if @action[:parameter].nil?
+    @action[:parameter].split(',')
+  end
+
+  def call_function
+    @action[:call]
+  end
+
+  def identifier
+    call_function.name.to_s
+  end
+
+  def start(observation_results)
+    @result = false
+    params = []
+    parameter.each { |p|
+      params << observation_results[p]
+    }
+
+    @result = call_function.call *params
+    self
+  end
+end

data/lib/MINT-core/mapping/action/bind_action.rb

@@ -0,0 +1,88 @@
+class BindAction < Action
+
+
+  def initialize(params)
+    super()
+    @action = params
+    @cb_observation_has_subscribed=nil
+    @is_bound = false
+  end
+
+  def initiated_callback(cb)
+    @cb_observation_has_subscribed = cb
+  end
+
+
+
+  def elementIn
+    @action[:elementIn]
+  end
+
+  def elementOut
+    @action[:elementOut]
+  end
+
+  def identifier
+    elementIn
+  end
+
+  def nameIn
+    @action[:nameIn]
+  end
+
+  def nameOut
+    @action[:nameOut]
+  end
+
+  def attrIn
+    @action[:attrIn]
+  end
+
+  def attrOut
+    @action[:attrOut]
+  end
+
+  def channelIn
+    "#{attrIn}:#{elementIn}.#{nameIn}"
+  end
+
+  def channelOut
+    "#{attrOut}:#{elementOut}.#{nameOut}"
+  end
+
+
+  def start(observation_results)            # TODO handle observation_variables
+    @result = false
+    if @is_bound
+      @cb_observation_has_subscribed.call(elementIn) if @cb_observation_has_subscribed
+      return self
+    end
+
+    redis = RedisConnector.redis
+    redis.pubsub.subscribe(channelIn) { |message|
+
+
+      found=MultiJson.decode message
+
+      if nameIn.eql? found['name']
+
+        if found.has_key? @action[:attrIn]
+          result =  found[@action[:attrIn]]
+          result = @action[:transform].call result if @action[:transform]
+          redis.publish channelOut, MultiJson.encode({:name=>@action[:nameOut], @action[:attrOut] => result})
+
+        end
+
+      end
+    }.callback do
+      @is_bound = true
+      @cb_observation_has_subscribed.call(elementIn) if @cb_observation_has_subscribed
+    end
+    @result = true
+    self
+  end
+
+  def unbind
+    RedisConnector.sub.unsubscribe(@action[:in])
+  end
+end

data/lib/MINT-core/mapping/action/event_action.rb

@@ -0,0 +1,40 @@
+class EventAction < Action
+  # BackendAction.new(:call => CUIControl.method(:find_cio_from_coordinates))
+  def initialize(params)
+    super()
+    @action = params
+  end
+
+  def event
+    @action[:event]
+  end
+
+  def target
+    @action[:target]
+  end
+
+  def selector
+    @action[:selector]
+  end
+
+  def start(observation_results)
+    @result = false
+    results  = []
+    interactor_data= observation_results[target]
+
+    interactor_data = [interactor_data] if not interactor_data.kind_of?(Array)
+
+    interactor_data.each do |int_data|
+      interactor = MINT::Interactor.get(int_data["mint_model"],int_data["name"])
+      interactor = interactor.method(selector).call if not selector.nil?
+
+      results << interactor.process_event(event)
+
+    end
+
+    @result = true if results != nil and results.count(nil)==0
+
+    self
+  end
+
+end

data/lib/MINT-core/mapping/complementary_mapping.rb

@@ -0,0 +1,31 @@
+module MINT
+  class ComplementaryMapping <  Mapping
+    def start
+      @state_callback.call(@mapping[:name], {:id => @mapping[:id], :mapping_state => :started}) if @state_callback
+      start_observations
+      self
+    end
+
+    def restart
+      @state_callback.call(@mapping[:name], {:id => @mapping[:id], :mapping_state => :restarted}) if @state_callback
+      start_observations
+      self
+    end
+
+    def start_observations
+      @observation_init = 0
+      observations.each do |observation|
+        @observation_init += 1
+        observation.start(@observation_results,self.method(:cb_activate_action)).is_subscribed_callback { |observation|
+          @observation_state[observation.element] = false
+          @state_callback.call(@mapping[:name], {:id => observation.id, :state => :activated}) if @state_callback
+          @observation_init -= 1
+          if @observation_init == 0
+            @mapping_activated = true
+            call_activated_callbacks
+          end
+        }
+      end
+    end
+  end
+end

data/lib/MINT-core/mapping/mapping.rb

@@ -5,43 +5,179 @@ module MINT
   # updates to elements or element removals.
   #
   class Mapping
-    attr_accessor :source_model, :on_action, :execute
-
-    # A mapping is initialized with
-    # @param [Class] source_model the other agents' model to listen to for events
-    # @param [String] action  to the tuple space that should be listened to. This is one of "take", "read", "write"
-    # @param [Method] execute this method of the agent that runs the mapping, the specified action has happened.
-    # @param [Method] inital method to call upon initialization of the mapping without the action to be happened, but scans the model for already happened events (write) and executes the method with these data.
-    #
-    def initialize (source_model,action,execute,initial=nil)
-      @source_model = source_model
-      @execute = execute
-      @initial = initial
-      @on_action = action
-    end
-
-    # Starts the mapping thread to listen to events
-    #
-    def execute
-      raise NotImplementedError, "#{self.class}#execute not implemented"
-    end
-
-    def publish_events(events)
-#      p "in check OR cond #{@conditions.inspect}"
-
-      events.each do |c,event|
-        c.each do |model,state|
-          state.each do |s|
-            result=model.first( :abstract_states=> /(^|\|)#{Regexp.quote(s)}/)
-            if not result.nil?
-              p "Sending #{event} to #{result.name}"
-              p result.inspect
-              p result.process_event(event)
-            end
+
+    # informs mapping tool about state changes
+    attr_accessor :state_callback
+
+    def initialize(params)
+      @mapping = params
+
+
+      # to fire callback if all observations have been successfully initialized
+      @observation_init = 0
+
+      @activated_callback = nil
+      @action_activated = {}
+
+      # to fire callback to inform mapping state
+      @state_callback = nil
+
+      # stores variables assigned by observations
+      @observation_results = {}
+
+      @observation_state = {}
+
+      @action_states = {}
+
+      #overall action sucecces used for direct callback
+      @actions_success = false
+    end
+
+    def mapping_name
+      return @mapping[:name] if @mapping[:name]
+      "unnamed"
+    end
+
+    def id
+      @mapping[:id]
+    end
+
+    def observations
+      @mapping[:observations]
+    end
+
+    def actions
+      @mapping[:actions]
+    end
+
+    def start
+      return self
+    end
+
+    def startAction(observation_results)
+      @action_init = 0
+      @actions_success = false
+      actions.each do |action|
+        @action_init += 1
+        @state_callback.call(@mapping[:name], {:id => action.id, :state => :activated}) if @state_callback
+        action.start(observation_results).finished_callback { |id,result|
+          state = :failed
+          state = :succeeded if result
+
+          @action_states[id]=state
+
+          @state_callback.call(@mapping[:name], {:id => action.id, :state => state}) if @state_callback
+          @action_init -= 1
+          if @action_init == 0
+            @action_activated = true
+            r = false
+            r = true if not @action_states.values.include? :failed
+            @actions_success = r
+            call_actions_succeeded_callbacks r
           end
+        }   # pass observation variables
+      end
+      self
+    end
+
+
+
+
+    # This callback is used to inform that all observations have been successfully activated (subscribed)
+    def activated_callback(&block)
+      return unless block
+
+      if @mapping_activated
+        block.call(self)
+      else
+        @activated_callbacks ||= []
+        @activated_callbacks.unshift block # << block
+      end
+    end
+
+    def call_activated_callbacks
+      @activated_callbacks ||= []
+
+      while cb = @activated_callbacks.pop
+        cb.call(self)
+      end
+      @activated_callbacks.clear if @activated_callbacks
+    end
+
+    # This callback is used to inform that all actions have been finished
+    def actions_succeeded_callback(&block)
+      return unless block
+
+      if @action_activated
+        block.call(self,@actions_success )
+      else
+        @actions_succeeded_callbacks ||= []
+        @actions_succeeded_callbacks.unshift block # << block
+      end
+    end
+
+
+    def call_actions_succeeded_callbacks(result)
+      @actions_succeeded_callbacks ||= []
+
+      while cb = @actions_succeeded_callbacks.pop
+        cb.call(self,result)
+      end
+      @actions_succeeded_callbacks.clear if @actions_succeeded_callbacks
+    end
+
+    # function is called every time an observation has been fulfilled or failed (in_state == :fail)
+    def cb_activate_action(element,in_state,result,id)
+      @state_callback.call(@mapping[:name], {:id => id, :element => element, :result => result, :state => in_state.to_s.to_sym}) if @state_callback
+
+      @observation_state[element] = in_state
+
+      if in_state == :fail
+        stop_observations # unsubscribe observations
+        @state_callback.call(@mapping[:name], {:id => @mapping[:id], :mapping_state => :failed}) if @state_callback
+        restart # restart mapping
+        return
+      end
+      if in_state
+        @observation_results.merge! result
+        # check if already all other observations have been matched
+        if not @observation_state.values.include? false
+          stop_observations # unsubscribe observations
+
+          startAction(@observation_results).actions_succeeded_callback { |m,result|
+            state = :failed
+            state = :succeeded if result
+
+            @state_callback.call(@mapping[:name], {:id => @mapping[:id], :mapping_state => state}) if @state_callback
+
+            # TODO -clean restart and move check_at_startup inside observation
+            # - add callback for action if succeeded & implement parallel action execution
+            m.restart
+
+          }
         end
       end
-      true
     end
+
+    def restart
+      @observation_state = {}
+      @action_states = {}
+
+      observations.each do |observation|
+        @observation_state[observation.element] = false
+        observation.start
+      end
+
+    end
+
+    def stop_observations
+      observations.each do |observation|
+        observation.stop
+      end
+
+    end
+
   end
+
+
 end