rbeai 0.0.1

data/lib/rbeai/GetLogic.rb

@@ -0,0 +1,144 @@
+require 'rio'
+require 'rmail/parser'
+require 'net/pop'
+require 'rexml/document'
+
+include REXML
+
+module RbEAI
+
+  class GetLogic
+  
+    
+    def initialize(xmlDoc, task)
+      @task = task
+      protNode = XPath.first(xmlDoc, "./protocol")
+      protocol = protNode.attributes["def"]
+      @logic =  case protocol
+                when "file"  then GetFileLogic.new(protNode, task)
+		when "ftp"  then GetFileLogic.new(protNode, task)
+                when "email" then GetEmailLogic.new(protNode, task)
+                end
+    end
+    
+    def getFiles()
+      return @logic.getFiles()
+    end
+  
+  end
+  
+  class GetFileLogic
+  
+    def initialize(protNode, task)
+      @task = task
+      @location = task.location
+      @pattern  = task.pattern
+    end
+    
+    def getFiles()
+      files = []
+      filesaux = []
+      files = rio("#{@location}")["#{@pattern}"]          
+      files.each do |file|      
+	filesaux << @task.persist(file)		
+      end
+      return filesaux
+    end
+  
+  end
+
+  class GetFtpLogic
+  
+    def initialize(protNode, task)
+      @task = task
+      @location = task.location
+      @pattern  = task.pattern
+    end
+    
+    def getFiles()
+      files = []
+      filesaux = []
+      files = rio("#{@location}") 
+      regexp = Regexp.new("#{@pattern}")
+      files.each do |file|      
+      	      puts "file = #{file}"
+        filesaux << @task.persistFtp(file)  if regexp.match("#{file}")	
+      end
+      return filesaux
+    end
+  
+  end
+  
+#      <protocol def="email">
+#        <location address="" port=""/>
+#        <account name="" pwd=""/>
+#        <pattern>out.xml</pattern>
+#      </protocol>
+  
+  class GetEmailLogic
+  
+    def initialize(protNode, task)
+      @task = task
+      location  = XPath.first(protNode, "./location")
+      account   = XPath.first(protNode, "./account")
+      @address  = location.attributes["address"]
+      @port     = location.attributes["port"]
+      @name     = account.attributes["name"]
+      @pwd      = account.attributes["pwd"]    
+      @pattern  = task.pattern
+    end
+    
+    def getFiles()
+      files = []
+      pop = Net::POP3.new(@address)
+      pop.start(@name, @pwd)
+      if pop.mails.empty?
+        puts 'No mail.'
+      else
+        i = 1
+        pop.each_mail do |m|
+          str = m.pop
+          i = i + 1
+          begin
+            email = RMail::Parser.read(str)          
+            aux = true
+            _parseMail(email,  @pattern, "mail_#{i}").each do |file|
+              _persistAndDelete(m, str, "mail_#{i}.txt") if aux
+              aux = false            
+              files << file
+            end
+          rescue Exception 
+            puts $!
+          end
+        end
+        puts "#{pop.mails.size} mails popped."
+      end
+      pop.finish        
+      return files
+    end
+  
+    private
+  
+      def _persistAndDelete(mail, str, basename)
+        @task.persistStr(str, "#{basename}.txt")
+        #mail.delete    
+      end
+  
+      def _parseMail(email, fnameExpr, basename)
+        result = []
+        if email.multipart?
+          i = 0
+          email.each_part do |part|
+            fname = part.header.param('Content-Disposition','filename')          
+            re = Regexp.new(fnameExpr.to_s)
+            if re.match(fname)
+              result << @task.persistStr(part.decode, "#{basename}_att_#{i}.txt")
+            end          
+          end
+        end    
+        return result
+      end
+  
+  end
+
+end #module

data/lib/rbeai/Main.rb

@@ -0,0 +1,70 @@
+require 'rio'
+require 'gserver' 
+require 'rbeai/Workflow'
+
+include REXML
+
+module RbEAI
+
+  
+  class MAIN < GServer
+  
+    load 'config/conf.rb'
+  
+    def initialize()
+      #server_port = 8888
+      #server_log = true
+      @wflowlist = []
+      super(port = @@server_port, host = "localhost", maxConnections = 1, audit = @@server_log)    
+    end
+    
+    def serve(io)
+      command = io.gets.strip
+      if command == "stop"
+        io.puts "Exiting ..."
+        stop()
+      end    
+    end
+    
+    def start()
+      files = []
+      files = rio("workflows")["*.wf"]
+      files.each do |file|
+        puts file
+        awflow = Workflow.new(File.new(file))
+        awflow.run
+        @wflowlist << awflow
+      end    
+      super()
+    end
+    
+    def shutdown()
+      _endWflows()
+      super()
+    end
+  
+    def stop()
+      _endWflows()
+      super()
+    end
+  
+    private 
+    
+      def _endWflows()
+        @wflowlist.each do |wflow|
+          wflow.finish
+        end    
+      end
+  
+  end #class
+  
+  
+end #module
+
+#wf = Workflow.new(wfstr)
+#wf.run()
+#sleep(10)
+#wf.finish()
+#eai = MAIN.new()
+#eai.start
+#eai.join

data/lib/rbeai/PipeTask.rb

@@ -0,0 +1,216 @@
+require 'thread'
+require 'thwait'
+
+module RbEAI
+  
+  class Control
+  
+    attr_accessor :controlQueue, :control
+    
+    def initialize(controlQueue, dataQueue)
+      @controlQueue = controlQueue
+      @dataQueue = dataQueue
+    end
+    
+    def start(threadPool)
+      @control = Thread.new() do
+        #print "Running control thread \n"
+        begin
+          obj = @controlQueue.deq
+        end until obj == :FINISH_THREADS
+        threadPool.size.times { @dataQueue.enq(:FINISH_WORK) }
+        threadPool.waitJoinAll()
+        #print "Finished control thread \n"          
+      end 
+    end
+    
+    def waitJoin()
+      @control.join()
+    end
+    
+    def finish()
+      @controlQueue.enq(:FINISH_THREADS)
+    end
+    
+  end
+  
+  class ThreadPool
+  
+    attr_accessor :size
+    
+    def initialize(size, task, method, inputQueue, resultQueue, bufferQueue, controlQueue)
+      @size = size
+      @task = task
+      @method = method
+      @inputQueue = inputQueue
+      @resultQueue = resultQueue
+      @bufferQueue = bufferQueue
+      @controlQueue = controlQueue
+      @threadgroup = ThreadsWait.new
+    end
+    
+    def start(name)     
+      @size.times do 
+        th = Thread.new(@method) do |method|          
+          #print "Running #{name} th \n"          
+          begin           
+            obj = @inputQueue.deq
+            #print "#{name} -> #{obj}\n"
+            if obj != :FINISH_WORK && obj != :FINISH_THREADS
+              if @bufferQueue != nil
+                method.call(@bufferQueue, obj)
+                @resultQueue.enq(obj)
+              else
+                method.call(@resultQueue, obj)
+              end
+            elsif obj == :FINISH_THREADS
+              @controlQueue.enq(:FINISH_THREADS)
+            end
+          end until obj == :FINISH_WORK          
+          #print "Finished th \n"
+        end      
+        @threadgroup.join_nowait(th)      
+      end     
+    end  
+    
+    def waitJoinAll()  
+      @threadgroup.all_waits
+      @task.doBuffered(@bufferQueue) if @bufferQueue != nil 
+    end
+    
+  end
+  
+  class PipeTask
+  
+    def initialize(inputQueue, task, control)
+      @inputQueue  = inputQueue
+      @task = task
+      @control = control
+      @resultQueue = Queue.new
+      @bufferQueue = task.respond_to?(:doBuffered) ? Queue.new : nil    
+      @nextPipe = if @task.respond_to?(:nextTask) and @task.nextTask !=  nil 
+                    getNextPipe(@resultQueue, @task.nextTask, Control.new(Queue.new, @resultQueue))
+                  else nil               
+                  end
+      @size = task.size
+      @threadPool = ThreadPool.new(@size, @task, @task.method(:doJob), @inputQueue, @resultQueue, @bufferQueue, control.controlQueue)    
+    end
+    
+    def run()
+      @nextPipe.run() if @nextPipe != nil       
+      @threadPool.start(@task.name)       
+      @control.start(@threadPool)    
+    end
+    
+    def waitToEnd()    
+      #print "JOIN-#{@task.name}\n"    
+      @control.waitJoin()
+      print "END-#{@task.name}\n"
+      @nextPipe.finish() if @nextPipe != nil
+      @nextPipe.waitToEnd() if @nextPipe != nil
+    end
+  
+    def finish()
+      @control.finish()
+      #@inputQueue.enq(:FINISH_THREADS)
+    end
+    
+    protected
+    
+      def getNextPipe(inputQueue, task, control)      
+        nextPipe = nil
+        if task.class == RouterTask
+        then nextPipe = RouterPipeTask.new(inputQueue, task, control)
+        else nextPipe = PipeTask.new(inputQueue, task, control) 
+        end
+             #nextPipe = PipeTask.new(@resultQueue, @task.nextTask, Control.new(Queue.new, @resultQueue)) 
+        return nextPipe
+      end    
+  
+  end
+  
+  
+  class RouterPipeTask < PipeTask
+                    
+     def initialize(inputQueue, task, control)
+      @inputQueue  = inputQueue
+      @task = task
+      @control = control
+      @resultQueue = task.initQueues()
+      @bufferQueue = nil    
+      @nextPipe = _getNextPipes()                
+      @size = task.size
+      @threadPool = ThreadPool.new(@size, @task, @task.method(:doJob), inputQueue, @resultQueue, @bufferQueue, control.controlQueue)    
+    end
+    
+    def run()
+      _RunNextPipes()
+      @threadPool.start(@task.name)       
+      @control.start(@threadPool)
+    end
+    
+    def waitToEnd()    
+      #print "JOIN-#{@task.name}\n"
+      @control.waitJoin
+      print "END-#{@task.name}\n"    
+      _WaitToEndNextPipes()
+    end
+    
+    private
+    
+      def _getNextPipes()                        
+        nextPipeList = Hash.new(0)
+        @task.nextTask.each do | key, task |
+          inputQueue = @resultQueue[key]
+          controlQueue = Queue.new
+          control = Control.new(controlQueue, inputQueue)
+          nextPipeList[key] = getNextPipe(inputQueue, task, control) 
+        end
+        return nextPipeList
+      end    
+  
+      def _RunNextPipes()
+        @nextPipe.each do | key, pipe |
+          pipe.run() if pipe != nil
+        end
+      end
+      
+      def _WaitToEndNextPipes()
+        @nextPipe.each do | key, pipe |
+          pipe.finish() if pipe != nil
+        end    
+        @nextPipe.each do | key, pipe |
+          pipe.waitToEnd() if pipe != nil
+        end          
+      end
+  
+  end
+  
+  class Hello
+    
+    attr_accessor :size
+    
+    def initialize
+      @size = 20
+    end
+    
+    def doJob(aQueue, obj)    
+      print "#{Thread.current.to_s}-#{obj}\n"
+      aQueue.enq("true")
+    end
+    
+    
+    def getItemsNext(numItems)
+      return 200
+    end
+  end
+  
+  #h = Hello.new
+  #inputQ = Queue.new
+  #wp = PipeTask.new(inputQ, Queue.new, h)
+  #wp.run(1000)
+  #1000.times { |i| inputQ.enq(i) }
+  #wp.waitToEnd()
+  
+end #module  
+  

data/lib/rbeai/PutLogic.rb

@@ -0,0 +1,123 @@
+require 'rio'
+require 'rmail/parser'
+require 'net/smtp'
+require "base64"
+require 'rexml/document'
+
+include REXML
+
+module RbEAI
+  
+  class PutLogic
+  
+    
+    def initialize(xmlDoc, task)
+      @task = task
+      protNode = XPath.first(xmlDoc, "./protocol")
+      protocol = protNode.attributes["def"]
+      @logic =  case protocol
+                when "file", "ftp"  then PutFileLogic.new(task)
+                when "email" then PutEmailLogic.new(protNode, task)
+                end
+    end
+    
+    def putFile(obj)
+      return @logic.putFile(obj)
+    end
+  
+  end
+  
+  class PutFileLogic
+  
+    def initialize(task)
+      @task = task
+      @location = task.location
+    end
+    
+    def putFile(obj)
+      rio("#{obj}") > rio("#{@location}")
+    end
+  
+  end
+  
+  
+  
+#    <task name="sendfile" type="Put" rate="0s" pool="1">
+#      <next>final</next>
+#      <protocol def="mail">
+#        <location address="" port=""/>
+#        <account name="" pwd=""/>
+#        <from></from>
+#        <to></to>
+#        <cc></cc>
+#        <bcc></bcc>
+#        <subject></subject>
+#      </protocol>
+#    </task>
+  
+  class PutEmailLogic
+  
+    def initialize(protNode, task)
+      @task = task
+      location  = XPath.first(protNode, "./location")
+      account   = XPath.first(protNode, "./account")
+      @address  = location.attributes["address"]
+      @domain   = location.attributes["domain"]
+      @port     = location.attributes["port"]
+      @name     = account.attributes["name"]
+      @pwd      = account.attributes["pwd"]    
+      @from     = XPath.first(protNode, "./from/text()")
+      @to       = XPath.first(protNode, "./to/text()")
+      @subject  = XPath.first(protNode, "./subject/text()")
+      @bodymsg  = XPath.first(protNode, "./body/text()")
+      @attachment  = XPath.first(protNode, "./attachment/text()")
+    end
+    
+    def putFile(obj)
+      begin
+        smtp = if @name != nil
+                  Net::SMTP.start(@address, @port, @domain, @name, @pwd, :login)
+              elsif @domain != nil
+                  Net::SMTP.start(@address, @port, @domain)
+              else
+                  Net::SMTP.start(@address, @port)
+              end
+        message = _buildMessage(obj)
+        smtp.send_message message, "#{@from}", "#{@to}".split(",").each { |to| to.strip! }
+        smtp.finish
+      rescue Exception 
+        puts $!
+      end    
+    end
+    
+    private 
+    
+      def _buildMessage(obj)
+        message = RMail::Message.new
+        header  = message.header
+        # HEADER ###############################
+        header.from= "#{@from}"
+        header.to = "#{@to}"
+        header.subject= "#{@subject}"   
+        header.add('Content-Type', 'multipart/mixed')
+        # BODY #################################
+        abody = RMail::Message.new
+        abody.body = "#{@bodymsg}"
+        message.add_part(abody)
+        # ATTACHMENT ###########################
+        part= RMail::Message.new
+        headerpart = part.header
+        headerpart.add('Content-Type', 'text/plain', nil, 'name' => "#{@attachment}" )
+        headerpart.add('Content-Transfer-Encoding', 'base64')
+        headerpart.add('Content-Description', "#{@attachment}" )
+        headerpart.add('Content-Disposition', 'attachment', nil, 'filename' => "#{@attachment}" )
+        aux = ""
+        rio("#{obj}") > aux
+        part.body = Base64.encode64(aux)
+        message.add_part(part)
+        return message
+      end
+  
+  end
+  
+end #module

data/lib/rbeai/RouterLogic.rb

@@ -0,0 +1,155 @@
+require 'rio'
+require 'rexml/document'
+require 'rexml/sax2listener'
+require 'rexml/parsers/sax2parser'
+
+include REXML
+
+module RbEAI
+  
+  class RouterLogic
+  
+    attr_accessor :destinations, :default
+  
+    def initialize(xmlDoc)
+      @destinations = []
+      XPath.each(xmlDoc, "./next/goto[count(when) > 0]") do |el|      
+        taskname = el.attributes["task"]
+        @destinations << [taskname, LogicFilter.new(el)]
+      end
+      XPath.each(xmlDoc, "./next/goto[count(when) = 0]") do |el|
+        taskname = el.attributes["task"]
+        @destinations << [taskname, LogicFilter.new(el)]
+      end    
+    end
+    
+    def enroute(file)
+      targettask = nil
+      
+      @destinations.each do | item |
+        taskname = item[0]
+        filter = item[1]      
+        if filter.match(file)
+          targettask = taskname
+          break
+        end
+      end
+          
+      return targettask
+    end
+    
+  end
+  
+  class LogicFilter
+  
+    def initialize(xmlDoc)
+      @parsers = []
+      XPath.each(xmlDoc, "./when") do |el|
+        @parsers << _getParser(el)     
+      end
+    end
+    
+    def match(file)
+      result = true
+      @parsers.each do | parser |
+        begin
+          if parser.match(file)
+            result = true
+            break
+          else
+            result = false
+          end
+        rescue Exception
+          result = false
+        end
+      end    
+      return result
+    end
+    
+    private 
+    
+      def _getParser(node)
+        filter = node.attributes["filter"]
+        re = Regexp.new('(re|xpath|sax|name):(.+)')
+        mr = re.match(filter)
+        case mr[1]
+          when 're' then RexParser.new(node, mr[2])
+          when 'xpath' then XPazParser.new(node, mr[2])
+          when 'sax' then SazParser.new(node, mr[2])
+          when 'name' then NameParser.new(node, mr[2])
+        end
+      end
+  
+  end
+  
+  class RexParser
+    
+    def initialize(node, expression)
+      @resultList = node.elements["."].text
+      @regexp = Regexp.new(expression)
+    end
+    
+    def match(file)
+      ario = rio(file)
+      ario > aString
+      mr = @regexp.match(aString)
+      return @resultList.include?(mr[0])
+    end
+    
+  end
+  
+  class NameParser
+  
+    def initialize(node, expression)
+      @regexp = Regexp.new(expression)
+    end
+    
+    def match(file)
+      filename = File.basename(file)
+      return @regexp.match(filename)
+    end
+    
+  end
+  
+  class XPazParser
+    
+    def initialize(node, expression)
+      @resultList = node.elements["."].text
+      @xpath = expression
+    end
+    
+    def match(file)    
+      ario = rio("#{file}")          
+      xmlString = ario.contents 
+      xmldoc = REXML::Document.new(xmlString)
+      result = false
+      XPath.each(xmldoc, "#{@xpath}") do |el|      
+        result = @resultList.include?(el.text)
+	break if result
+      end
+      return result
+    end
+    
+  end
+  
+  class SazParser
+    
+    def initialize(node, expression)
+      @resultList = node.elements["."].text
+      @node = expression
+    end
+    
+    def match(file)    
+      result = "nil"
+      f = File.new(file)
+      parser = Parsers::SAX2Parser.new( f )
+      parser.listen( :characters , @node) do |text| 
+        result = text  if @resultList.include?(text)
+      end
+      parser.parse
+      return @resultList.include?(result)
+    end
+    
+  end
+
+end #module