MINT-core 1.0.1 → 2.0.0

data/lib/MINT-core/connector/redis_connector.rb

@@ -0,0 +1,16 @@
+class RedisConnector
+
+  def self.redis
+
+    @@redis ||= EventMachine::Hiredis.connect
+  end
+
+  def self.sync_redis
+    @@sync_redis ||= Redis.new
+  end
+
+  def self.reset
+    @@redis =nil
+  end
+
+end

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

@@ -0,0 +1,101 @@
+require 'rubygems'
+require "bundler/setup"
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+class MappingManager
+  include REXML
+  include StreamListener
+
+  def initialize()
+    @mappings = {}
+    @callbacks = {}
+    @file_path = nil
+
+    #callback that will be called if all mappings with attribute == run have been activated == subscribed
+    @started_cb = nil
+
+    # contains mappings that have been loaded ans started but whose observations have not finished subscribing
+    @waiting_mappings = []
+
+    #will be true if all mappings have been parsed
+    @finished_parsing = false
+  end
+
+  def finished_parsing
+    @finished_parsing = true
+    wait_for_all_mappings_activated(nil)
+  end
+
+  # This function parses scxml from a file
+  def build_from_scxml(filename)
+    source = File.new filename
+    Document.parse_stream(source, self)
+    finished_parsing()
+    @mappings
+  end
+
+  # This function parses scxml directly from the string parameter "stringbuffer"
+  def build_from_scxml_string(stringbuffer)
+    Document.parse_stream(stringbuffer, self)
+    finished_parsing()
+    @mappings
+  end
+
+  def load(xml_file)
+    @file_path = File.expand_path(File.dirname(xml_file))
+    @mappings = build_from_scxml(xml_file)
+    self
+  end
+
+  def get_mappings
+    @mappings.keys
+  end
+
+  def register_callback(mapping_name, callback)
+    #If mapping already exists add callback
+    #Otherwise save it for later
+    if @mappings.has_key? (mapping_name)
+      @mappings[mapping_name].state_callback = callback
+    else
+      @callbacks[mapping_name] = callback
+    end
+  end
+
+  # This function defines the actions to be taken for each different tag when the tag is opened
+  def tag_start(name, attributes)
+    case name
+      when 'mim'
+         #Do I have to store its name?
+      when 'include'
+         parser = MINT::MappingParser.new
+         mapping = parser.build_from_scxml(@file_path +"/"+ attributes['href'])
+         @mappings[mapping.mapping_name] = mapping
+
+         #If a callback has already been register, add it.
+         if @callbacks.has_key? mapping.mapping_name
+           mapping.state_callback = @callbacks[mapping.mapping_name]
+         end
+
+         #TODO check if callback here or in class initialize
+         if @mappings[mapping.mapping_name].state_callback
+           p "Mapping #{mapping.mapping_name} loaded"
+           @mappings[mapping.mapping_name].state_callback.call(mapping.mapping_name, {:id => mapping.id, :mapping_state => :loaded})
+         end
+         if attributes['start'] == "true"
+           @waiting_mappings << mapping.mapping_name
+           mapping.start.activated_callback {wait_for_all_mappings_activated(mapping)}
+
+         end
+    end
+  end
+
+  def wait_for_all_mappings_activated(mapping)
+      @waiting_mappings.delete mapping.mapping_name if mapping
+      @started_cb.call if @started_cb and @finished_parsing and @waiting_mappings.length == 0
+  end
+
+  def started(&block)
+    @started_cb = block
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'rubygems'
+require "bundler/setup"
+require 'rexml/document'
+require 'rexml/streamlistener'
+module MINT
+  class MappingParser
+    include REXML
+    include StreamListener
+
+    def initialize()
+      @mapping_name  #actual name of the mapping
+      @mapping_type  #type of the mapping: complementary, sequential, ...
+      @observations = Array.new #will store the observations
+      @actions = Array.new #will store the actions
+      @mapping #actual mapping
+    end
+
+    # This function parses scxml from a file
+    def build_from_scxml(filename)
+      source = File.new filename
+      Document.parse_stream(source, self)
+      @mapping
+    end
+
+    # This function parses scxml directly from the string parameter "stringbuffer"
+    def build_from_scxml_string(stringbuffer)
+      Document.parse_stream(stringbuffer, self)
+      @mapping
+    end
+
+    # This function defines the actions to be taken for each different tag when the tag is opened
+    def tag_start(name, attributes)
+      case name
+        when 'mapping'
+          @mapping_name = attributes['name']
+        when 'operator'
+          @mapping_type = attributes['type']
+          @mapping_id = attributes['id']
+        when 'observation'
+          observation_states = Array.new
+          observation_hash = Hash.new
+          observation_hash[:element] = attributes['interactor']
+          observation_hash[:name] = attributes['name']
+          observation_hash[:id] = attributes['id']
+          attributes['states'].split("|").each do |s| observation_states << s.to_sym end   if attributes['states']
+          observation_hash[:states] = observation_states
+          observation_hash[:process] = attributes['process'].to_s.to_sym if attributes['process']
+          observation_hash[:result] = attributes['result'] if attributes['result']
+
+          if attributes['type'] and attributes['type'].eql? "negation"
+            @observations << NegationObservation.new(observation_hash)
+          else
+            @observations << Observation.new(observation_hash)
+          end
+        when 'backend'
+          backend_call = MINT::const_get(attributes['class']).method(attributes['call'].to_sym) # TODO figure out a way that this can work
+          @actions << BackendAction.new(:call => backend_call,:parameter => attributes['parameter'], :id => attributes['id'])
+        when 'bind'
+          backend_call = MINT::const_get(attributes['class']).method(attributes['transformation'].to_sym) if attributes['transformation']
+          @actions << BindAction.new(:id => attributes['id'], :elementIn => attributes['interactor_in'], :nameIn => attributes['name_in'], :attrIn => attributes['attr_in'],
+                                     :elementOut => attributes['interactor_out'], :nameOut => attributes['name_out'], :attrOut => attributes['attr_out'],:transform => backend_call)
+        when 'event'
+          @actions << EventAction.new(:id => attributes['id'], :event => attributes['type'].to_sym, :target => attributes['target'])
+        else
+      end
+    end
+
+    # This function defines the actions to be taken for each different tag when the tag is closed
+    def tag_end(name)
+      case name
+        when 'operator'
+          case @mapping_type
+            when 'complementary'
+              @mapping = ComplementaryMapping.new(:id => @mapping_id, :name => @mapping_name, :observations => @observations, :actions => @actions)
+            when 'sequential'
+              @mapping = SequentialMapping.new(:id => @mapping_id, :name => @mapping_name, :observations => @observations, :actions => @actions)
+            else
+          end
+        else
+      end
+    end
+
+    def text(text)
+    end
+
+    def xmldecl(version, encoding, standalone)
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+
+require 'rubygems'
+require "bundler/setup"
+require "MINT-core"
+require "MINT-scxml"
+
+class MappingServer
+  attr_accessor :connections
+  attr_accessor :manager
+
+  class StatefulProtocol < EventMachine::Connection
+    include EM::Protocols::LineText2
+    attr_accessor :manager
+
+    def initialize
+      @mapping_store = {}
+
+      # saves if a registered mapping is detail
+      @registered_as_detail = {}
+      super()
+    end
+
+    def forward_callback(mapping,data)
+      p "in forward #{mapping} #{data}"
+
+      if (data[:result])
+        d = data[:result]
+        if not d.nil? and not d.empty? and not @mapping_store[mapping]
+          #a= d.first
+          #b = a[1]['name']
+          if d.first[1].is_a? Hash
+            @mapping_store[mapping] =  {:name => d.first[1]['name']}
+
+          else
+
+            @mapping_store[mapping] =  {:name => d.first[1].map{|x| x['name']}}
+          end
+        end
+      end
+      json_data = (@mapping_store[mapping]!=nil)?MultiJson.encode(data.merge(@mapping_store[mapping])) :  MultiJson.encode(data)
+      if data[:mapping_state] and data[:mapping_state] == :succeeded
+        send_data("INFO%"+mapping+"%"+json_data+"\r\n")
+        p "sent: INFO%"+mapping+"%"+json_data
+        @mapping_store[mapping]=nil
+      elsif  @registered_as_detail[mapping]
+        send_data("DETAIL%"+mapping+"%"+json_data+"\r\n")
+        p "sent: DETAIL%"+mapping+"%"+json_data
+        @mapping_store[mapping]=nil
+      end
+
+    end
+
+    def receive_line(data)
+      begin
+        p "server received:#{data}"
+        d = data.split('%')
+
+        case d[0]
+          when "REGISTER"
+            @manager.register_callback(d[1], method(:forward_callback))
+            @registered_as_detail[d[1]] = d[2].eql?('DETAIL')?true:false
+            send_data("REGISTERED%#{d[1]}%#{d[2]}\r\n")
+          when "LIST"
+            mappings = @manager.get_mappings
+            mappings.each {|m| send_data("MAPPING%#{m}\r\n")}
+          else
+            p "ERROR\r\nReceived Unknown data:#{data}\r\n "
+        end
+      end
+    rescue Statemachine::TransitionMissingException => bang
+      puts "ERROR\n#{bang}"
+    end
+  end
+
+  def initialize(hsh = {:host=>"0.0.0.0",:port=>8000})
+    @host = hsh[:host]
+    @port = hsh[:port]
+    @connections =[]
+  end
+
+  def start(manager = nil)
+
+    if (manager)
+      @manager = manager
+    else
+      @manager = MappingManager.new
+    end
+    EventMachine::start_server @host, @port, StatefulProtocol do |conn|
+      @connections << conn
+      conn.send_data("READY\r\n")
+      conn.manager=@manager
+      puts "connection..."
+    end
+    puts "Started server on #{@host}:#{@port}"
+  end
+
+end
+
+

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

@@ -0,0 +1,33 @@
+
+require 'rubygems'
+require "bundler/setup"
+require "eventmachine"
+require "MINT-scxml"
+
+require 'redis'
+require 'hiredis'
+
+class PositionUpdater
+
+    def initialize
+    end
+
+    def start()
+      redis = EventMachine::Hiredis.connect
+
+      redis.pubsub.psubscribe("in_channel:Interactor.CIO.coordinates.*") { |key, message|
+        found=MultiJson.decode message
+        cio = CIO.get "cui-gfx",found['name']
+        #cio.x =found['x']
+        #cio.y = found['y']
+        cio.width=found['width']
+        cio.height = found['height']
+        cio.save
+        CUIControl.update_cache(cio)
+        puts found.inspect
+      }.callback { p "subscribed to receive position updates"}
+
+    end
+
+end
+

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

@@ -0,0 +1,118 @@
+
+require 'rubygems'
+require "bundler/setup"
+require "eventmachine"
+require "MINT-scxml"
+
+require 'redis'
+require 'hiredis'
+
+class SCXMLClient
+  attr_accessor :connections
+
+  def self.state_store
+   @@state_store ||= {}
+  end
+
+
+  class StatefulProtocol < EventMachine::Connection
+    include EM::Protocols::LineText2
+
+    @@host = nil
+    @@port = nil
+
+    def initialize
+
+
+      super()
+    end
+
+    def unbind
+      puts "#{@@host}: #{@@port}"
+       puts "-- disconnected from remote server!"
+       puts "-- attempting reconnection"
+       #reconnect @@ip, @@port # use reconnect, already provided by E
+      EventMachine.add_timer 15, proc { reconnect(@@host,@@port) }
+    end
+
+    def self.config(host,port)
+      @@host = host
+      @@port = port
+    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
+
+          current_active_states = found["states"] + found["abstract_states"].split("|")
+          if(SCXMLClient.state_store.has_key? key)
+            activated_states =  SCXMLClient.state_store[key]
+
+
+
+            deactivated_states = activated_states - current_active_states
+
+            # send deactivate states
+
+            deactivated_states.each {|state|
+              p "deactivated: #{state}"
+              send_inactive_state state
+            }
+
+            #save activated states
+
+          end
+          SCXMLClient.state_store[key] = current_active_states
+        end
+      }.callback { p "subscribed to #{@interactor} name #{@name}"}
+
+    end
+
+    def send_active_state(name)
+      send_data "1 #{name}\r\n"
+    end
+
+    def send_inactive_state(name)
+      send_data "0 #{name}\r\n"
+    end
+  end
+
+  def initialize(_interactor,_name)
+    @interactor = _interactor
+    @name = _name
+
+  end
+
+  def start(host="0.0.0.0",port=3003)
+
+    StatefulProtocol.config(host,port)
+
+    #socket = EM.connect(host, port, StatefulProtocol) do |conn|
+    EventMachine::start_server host, port, StatefulProtocol do |conn|
+     # conn.config(host,port)
+      conn.subscribe_redis(@interactor,@name)
+      #@connections << conn
+
+      puts "SCXML Tool connection..."
+
+      # inform about all currently activated states
+      # @state_store[@interactor]
+    end
+    puts "Started server on #{host}:#{port}"
+  end
+
+end
+