smartfox_jruby 0.1 → 0.2.3

data/lib/smartfox_jruby/sfs_runner.rb

@@ -3,120 +3,123 @@ require File.expand_path(File.dirname(__FILE__) + '/common')
 java_import java.lang.Runtime
 java_import java.lang.System
 
-class SmartfoxJruby::SfsRunner
-
-  def initialize(home_dir, opts = {})
-    @home_dir = home_dir
-    @opts = opts
-    @launched = false
-    @fault = false
-    @pid = nil
-  end
+module SmartfoxJruby
+  class SfsRunner
+
+    def initialize(home_dir, opts = {})
+      @home_dir = home_dir
+      @opts = opts
+      @launched = false
+      @fault = false
+      @pid = nil
+    end
 
-  def run!
-    Thread.new do
-      begin
-        info "Changing dir to #{work_dir}"
-        Dir.chdir(work_dir) do
-          info "Running cmd #{cmd}"
-          IO.popen(cmd) do |output|
-            @pid = output.pid
-            info "Running child with pid=#{output.pid}..."
-            output.each do |line|
-              debug(line.gsub(/\n/, ""))
-              @launched = true if line =~ /SmartFoxServer 2X \(.+\) READY!/
+    def run!
+      Thread.new do
+        begin
+          info "Changing dir to #{work_dir}"
+          Dir.chdir(work_dir) do
+            info "Running cmd #{cmd}"
+            IO.popen(cmd) do |output|
+              @pid = output.pid
+              info "Running child with pid=#{output.pid}..."
+              output.each do |line|
+                debug(line.gsub(/\n/, ""))
+                @launched = true if line =~ /SmartFoxServer 2X \(.+\) READY!/
+              end
             end
+            @fault = true
           end
-          @fault = true
+        rescue Exception => e
+          error "#{e}"
         end
-      rescue Exception => e
-        error "#{e}"
       end
     end
-  end
 
-  def kill!
-    info "Checking running processes: #{pids.join(",")}"
-    pids.each { |pid|
-      pid = pid.try(:strip).try(:to_i)
-      info "Killing the process with pid=#{pid}..."
-      Process.kill("KILL", pid) if Process.alive?(pid)
-      wait_with_timeout(5) { !Process.alive?(pid) } rescue ""
-    }
-  end
+    def kill!
+      info "Checking running processes: #{pids.join(",")}"
+      pids.each { |pid|
+        pid = pid.try(:strip).try(:to_i)
+        info "Killing the process with pid=#{pid}..."
+        Process.kill("KILL", pid) if Process.alive?(pid)
+        wait_with_timeout(5) { !Process.alive?(pid) } rescue ""
+      }
+    end
 
-  def run_and_wait!(opts = {})
-    run!
-    wait_until_launched_or_fault(opts[:timeout])
-  end
+    def run_and_wait!(opts = {})
+      run!
+      wait_until_launched_or_fault(opts[:timeout])
+    end
 
 
-  def kill_and_wait!(opts = {})
-    kill!
-    wait_until_terminated(opts[:timeout])
-  end
+    def kill_and_wait!(opts = {})
+      kill!
+      wait_until_terminated(opts[:timeout])
+    end
 
-  def running?
-    !pids.blank? && pids.map { |pid| Process.alive?(pid.to_i) }.include?(true)
-  end
+    def running?
+      !pids.blank? && pids.map { |pid| Process.alive?(pid.to_i) }.include?(true)
+    end
 
-  def launched?
-    @launched
-  end
+    def launched?
+      @launched
+    end
 
-  def fault?
-    @fault
-  end
+    def fault?
+      @fault
+    end
 
-  def wait_until_terminated(timeout = nil)
-    wait_with_timeout(timeout) { !running? }
-  end
+    def wait_until_terminated(timeout = nil)
+      wait_with_timeout(timeout) { !running? }
+    end
 
-  def wait_until_launched_or_fault(timeout = nil)
-    wait_with_timeout(timeout) { launched? or fault? }
-  end
+    def wait_until_launched_or_fault(timeout = nil)
+      wait_with_timeout(timeout) { launched? or fault? }
+    end
 
-  private
+    private
 
-  def pids
-    pids_out = `pgrep -f "#{work_dir}"`
-    (pids_out.try(:split, "\n")) || []
-  end
+    def pids
+      pids_out = `pgrep -f "#{work_dir}"`
+      (pids_out.try(:split, "\n")) || []
+    end
 
-  def error(msg)
-    @opts[:logger].error(msg) unless @opts[:logger].blank?
-  end
+    def error(msg)
+      @opts[:logger].error(msg) unless @opts[:logger].blank?
+    end
 
-  def debug(msg)
-    @opts[:logger].debug(msg) unless @opts[:logger].blank?
-  end
+    def debug(msg)
+      @opts[:logger].debug(msg) unless @opts[:logger].blank?
+    end
 
-  def info(msg)
-    @opts[:logger].info(msg) unless @opts[:logger].blank?
-  end
+    def info(msg)
+      @opts[:logger].info(msg) unless @opts[:logger].blank?
+    end
 
-  def work_dir
-    Pathname.new(@home_dir).join("SFS2X").to_s
-  end
+    def work_dir
+      Pathname.new(@home_dir).join("SFS2X").to_s
+    end
 
-  def env
-    %W[].to_java :string
-  end
+    def env
+      %W[].to_java :string
+    end
 
-  def cmd
-    %Q[#{java_bin} -cp #{classpath} #{java_opts} -Dsmartfox.work_dir="#{work_dir}" com.smartfoxserver.v2.Main]
-  end
+    def cmd
+      %Q[#{java_bin} -cp #{classpath} #{java_opts} -Dsmartfox.work_dir="#{work_dir}" com.smartfoxserver.v2.Main]
+    end
 
-  def java_bin
-    Pathname.new(System.getProperty("java.home")).join("bin").join("java")
-  end
+    def java_bin
+      Pathname.new(System.getProperty("java.home")).join("bin").join("java")
+    end
 
-  def java_opts
-    %Q[-XX:MaxPermSize=512m -Xms128m -Xms1024m]
-  end
+    def java_opts
+      %Q[-XX:MaxPermSize=512m -Xms128m -Xms1024m]
+    end
+
+    def classpath
+      %Q[aimy:./:lib/*:lib/Jetty/*:extensions/__lib__/*]
+    end
 
-  def classpath
-    %Q[aimy:./:lib/*:lib/Jetty/*:extensions/__lib__/*]
   end
 
 end

data/lib/smartfox_jruby/sfs_worker.rb

@@ -1,256 +1,258 @@
 require 'thread'
 require File.expand_path(File.dirname(__FILE__) + '/common')
 
-module SmartfoxJruby::SfsWorker
-  class Processor
-    attr_accessor :opts
-    attr_accessor :name
-    attr_accessor :chained
-    attr_accessor :current
-    attr_accessor :blocks
-
-    def initialize(name, opts = {}, &block)
-      @blocks = [block]
-      @name = name
-      @current = self
-      @chained = nil
-      @opts = opts
-    end
+module SmartfoxJruby
+  module SfsWorker
+    class Processor
+      attr_accessor :opts
+      attr_accessor :name
+      attr_accessor :chained
+      attr_accessor :current
+      attr_accessor :blocks
+
+      def initialize(name, opts = {}, &block)
+        @blocks = [block]
+        @name = name
+        @current = self
+        @chained = nil
+        @opts = opts
+      end
 
-    def chain(name, &block)
-      link.chained = Processor.new(name, @opts, &block)
-      self
-    end
+      def chain(name, &block)
+        link.chained = Processor.new(name, @opts, &block)
+        self
+      end
 
-    def link
-      p = current
-      p = p.chained while (!p.try(:chained).blank?)
-      p
-    end
+      def link
+        p = current
+        p = p.chained while (!p.try(:chained).blank?)
+        p
+      end
 
-    def append(&block)
-      unless link.blank?
-        link.blocks << block
-      else
-        current.blocks << block
+      def append(&block)
+        unless link.blank?
+          link.blocks << block
+        else
+          current.blocks << block
+        end
+        self
       end
-      self
-    end
 
-    def completed?
-      current.blank?
-    end
+      def completed?
+        current.blank?
+      end
 
-    def mandatory?
-      @opts[:mandatory].nil? || @opts[:mandatory]
-    end
+      def mandatory?
+        @opts[:mandatory].nil? || @opts[:mandatory]
+      end
 
-    def event(name, data = {})
-      if @current.name.to_s == name.to_s
-        @current.blocks.each { |b| b.call(data) }
-        @current = (@current.chained.blank?) ? nil : @current.chained
-        return true
+      def event(name, data = {})
+        if @current.name.to_s == name.to_s
+          @current.blocks.each { |b| b.call(data) }
+          @current = (@current.chained.blank?) ? nil : @current.chained
+          return true
+        end
+        false
       end
-      false
-    end
 
-    def to_s
-      "Proc[#{current.try(:name)}] --> #{current.try(:chained)}"
+      def to_s
+        "Proc[#{current.try(:name)}] --> #{current.try(:chained)}"
+      end
     end
-  end
 
-  class Request
-    attr_reader :name
-    attr_reader :data
+    class Request
+      attr_reader :name
+      attr_reader :data
 
-    def initialize(name, data = {})
-      @name = name
-      @data = data
-    end
+      def initialize(name, data = {})
+        @name = name
+        @data = data
+      end
 
-    def to_extension_request
-      ExtensionRequest.new(@name.to_s, @data)
-    end
+      def to_extension_request
+        ExtensionRequest.new(@name.to_s, @data)
+      end
 
-    def to_s
-      "Req[#{@name}]#{data.to_json}"
+      def to_s
+        "Req[#{@name}]#{data.to_json}"
+      end
     end
-  end
 
-  class Response < Request
-    def to_s
-      "Resp[#{@name}]#{data.to_json}"
+    class Response < Request
+      def to_s
+        "Resp[#{@name}]#{data.to_json}"
+      end
     end
-  end
 
-  class ContextWorker
+    class ContextWorker
 
-    def request(name, data = {})
-      @worker.request(name, data, :context => @context)
-    end
+      def request(name, data = {}, opts = {})
+        @worker.request(name, data, opts.merge(:context => @context))
+      end
 
-    def append_processor(opts = {}, &block)
-      @worker.append_processor(opts.merge(:context => @context), &block)
-    end
+      def append_processor(opts = {}, &block)
+        @worker.append_processor(opts.merge(:context => @context), &block)
+      end
 
-    def expect(name, opts={}, &block)
-      @worker.expect(name, opts.merge(:context => @context), &block)
-    end
+      def expect(name, opts={}, &block)
+        @worker.expect(name, opts.merge(:context => @context), &block)
+      end
 
-    def initialize(context, worker)
-      @context = context
-      @worker = worker
+      def initialize(context, worker)
+        @context = context
+        @worker = worker
+      end
     end
-  end
 
-  class Worker
-    attr_reader :send_queue
-    attr_reader :events_queue
-    attr_reader :processors
-    attr_reader :smart_fox
-    attr_reader :opts
-
-    def initialize(smart_fox, opts = {})
-      @send_queue = []
-      @processors = []
-      @events_queue = []
-      @opts = opts
-      @opts[:timeout] ||= 20
-      @smart_fox = smart_fox
-      @mutex = Mutex.new
-      @send_qm = Mutex.new
-    end
+    class Worker
+      attr_reader :send_queue
+      attr_reader :events_queue
+      attr_reader :processors
+      attr_reader :smart_fox
+      attr_reader :opts
+
+      def initialize(smart_fox, opts = {})
+        @send_queue = []
+        @processors = []
+        @events_queue = []
+        @opts = opts
+        @opts[:timeout] ||= 20
+        @smart_fox = smart_fox
+        @mutex = Mutex.new
+        @send_qm = Mutex.new
+      end
 
-    def append_processor(opts = {}, &block)
-      debug "appending processor with context #{opts[:context]}"
-      if opts[:context]
-        context = opts[:context].append(&block)
-      else
-        context = processors.last.append(&block)
+      def append_processor(opts = {}, &block)
+        debug "appending processor with context #{opts[:context]}"
+        if opts[:context]
+          context = opts[:context].append(&block)
+        else
+          context = processors.last.append(&block)
+        end
+        ContextWorker.new(context, self)
       end
-      ContextWorker.new(context, self)
-    end
 
-    def request(name, data = {}, opts = {})
-      debug "create request #{name} with context #{opts[:context]}"
-      data = data.to_sfsobject(opts[:serialize_opts]) if data.is_a?(Hash)
-      req = Request.new(name, data)
-      if !opts[:context].blank? && opts[:context].is_a?(Processor)
-        debug "appending #{req} to processor #{opts[:context]}"
-        context = opts[:context].append {
+      def request(name, data = {}, opts = {})
+        debug "create request #{name} with context #{opts[:context]} and opts #{opts[:serialize_opts]}"
+        data = data.to_sfsobject(opts[:serialize_opts]) if data.is_a?(Hash)
+        req = Request.new(name, data)
+        if !opts[:context].blank? && opts[:context].is_a?(Processor)
+          debug "appending #{req} to processor #{opts[:context]}"
+          context = opts[:context].append {
+            @send_qm.synchronize { send_queue << req }
+          }
+        else
+          debug "adding #{req} to send_queue \n #{dump_state}"
+          context = req
           @send_qm.synchronize { send_queue << req }
-        }
-      else
-        debug "adding #{req} to send_queue \n #{dump_state}"
-        context = req
-        @send_qm.synchronize { send_queue << req }
+        end
+        ContextWorker.new(context, self)
       end
-      ContextWorker.new(context, self)
-    end
 
-    def expect(name, opts = {}, &block)
-      debug "Expecting to get response #{name} with context #{opts[:context]}"
-      unless opts[:context].blank?
-        if opts[:context].is_a?(Processor)
-          context = opts[:context].chain(name, &block)
-        elsif opts[:context].is_a?(Request)
-          context = Processor.new(name, :context => opts[:context], &block)
+      def expect(name, opts = {}, &block)
+        debug "Expecting to get response #{name} with context #{opts[:context]}"
+        unless opts[:context].blank?
+          if opts[:context].is_a?(Processor)
+            context = opts[:context].chain(name, &block)
+          elsif opts[:context].is_a?(Request)
+            context = Processor.new(name, :context => opts[:context], &block)
+            @mutex.synchronize { processors << context }
+          end
+        else
+          context = Processor.new(name, &block)
           @mutex.synchronize { processors << context }
         end
-      else
-        context = Processor.new(name, &block)
-        @mutex.synchronize { processors << context }
+        ContextWorker.new(context, self)
       end
-      ContextWorker.new(context, self)
-    end
 
-    def response(name, data = {})
-      info "Got response #{name} (#{data.to_json})..."
-      @mutex.synchronize { events_queue << Response.new(name, data) }
-    end
+      def response(name, data = {})
+        info "Got response #{name} (#{data.to_json})..."
+        @mutex.synchronize { events_queue << Response.new(name, data) }
+      end
 
-    def perform!
-      while !all_events_caught?
-        while !send_queue.blank?
-          req = nil
-          @send_qm.synchronize { req = send_queue.shift }
-          debug "sending request #{req.name}..."
-          smart_fox.send(req.to_extension_request) unless smart_fox.blank?
-          @last_act = Time.now.to_i
+      def perform!
+        while !all_events_caught?
+          while !send_queue.blank?
+            req = nil
+            @send_qm.synchronize { req = send_queue.shift }
+            debug "sending request #{req.name}..."
+            smart_fox.send(req.to_extension_request) unless smart_fox.blank?
+            @last_act = Time.now.to_i
+          end
+          process_events
+          check_timeouts
         end
-        process_events
-        check_timeouts
       end
-    end
 
-    def all_events_caught?
-      processors.blank? || processors.collect { |p| p.mandatory? }.blank?
-    end
+      def all_events_caught?
+        processors.blank? || processors.collect { |p| p.mandatory? }.blank?
+      end
 
-    def wait_all_events_caught
-      debug "Waiting all events being caught..."
-      begin
-        wait_with_timeout { all_events_caught? }
-      rescue WaitTimeoutException => e
-        raise "Failed to catch all the events:"+ dump_state
+      def wait_all_events_caught
+        debug "Waiting all events being caught..."
+        begin
+          wait_with_timeout { all_events_caught? }
+        rescue WaitTimeoutException => e
+          raise "Failed to catch all the events:"+ dump_state
+        end
       end
-    end
 
-    private
+      private
 
-    def dump_state
-      "events_queue = \n\t-#{events_queue.join("\n\t-")}" +
-          " \n processors = \n\t-#{processors.join("\n\t-")}" +
-          " \n send_queue = \n\t-#{send_queue.join("\n\t-")}"
-    end
+      def dump_state
+        "events_queue = \n\t-#{events_queue.join("\n\t-")}" +
+            " \n processors = \n\t-#{processors.join("\n\t-")}" +
+            " \n send_queue = \n\t-#{send_queue.join("\n\t-")}"
+      end
 
-    def check_timeouts
-      if !@last_act.blank? && Time.now.to_i > @last_act + opts[:timeout]
-        raise "Worker timeout! Latest interaction was #{Time.now.to_i - @last_act} sec ago!\n #{dump_state}"
+      def check_timeouts
+        if !@last_act.blank? && Time.now.to_i > @last_act + opts[:timeout]
+          raise "Worker timeout! Latest interaction was #{Time.now.to_i - @last_act} sec ago!\n #{dump_state}"
+        end
       end
-    end
 
-    def process_events
-      wait_with_timeout { !events_queue.blank? } rescue nil
-      ei = 0
-      debug "Processing events..."
-      while ei < events_queue.size
-        event = events_queue[ei]
-        pi = 0
-        debug "Processing event #{event.name}..."
-        while pi < processors.size
-          processor = processors[pi]
-          debug "Trying processor #{processor.name}..."
-          if processor.event(event.name, event.data)
-            @last_act = Time.now.to_i
-            debug "Processor found #{processor}"
-            @mutex.synchronize { events_queue.delete_at(ei) }
-            ei -= 1
-            if processor.completed?
-              debug "Processor completed #{processor.name}."
-              @mutex.synchronize { processors.delete_at(pi) }
-              pi -= 1
+      def process_events
+        wait_with_timeout { !events_queue.blank? } rescue nil
+        ei = 0
+        debug "Processing events..."
+        while ei < events_queue.size
+          event = events_queue[ei]
+          pi = 0
+          debug "Processing event #{event.name}..."
+          while pi < processors.size
+            processor = processors[pi]
+            debug "Trying processor #{processor.name}..."
+            if processor.event(event.name, event.data)
+              @last_act = Time.now.to_i
+              debug "Processor found #{processor}"
+              @mutex.synchronize { events_queue.delete_at(ei) }
+              ei -= 1
+              if processor.completed?
+                debug "Processor completed #{processor.name}."
+                @mutex.synchronize { processors.delete_at(pi) }
+                pi -= 1
+              end
             end
+            pi += 1
           end
-          pi += 1
+          ei += 1
         end
-        ei += 1
+        debug "Events processing finished. #{dump_state}"
       end
-      debug "Events processing finished. #{dump_state}"
-    end
 
-    def debug(msg)
-      puts "[#{time}] DEBUG #{msg}" if opts[:debug]
-    end
+      def debug(msg)
+        puts "[#{time}] DEBUG #{msg}" if opts[:debug]
+      end
 
-    def info(msg)
-      puts "[#{time}] INFO #{msg}"
-    end
+      def info(msg)
+        puts "[#{time}] INFO #{msg}"
+      end
 
-    def time
-      Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      def time
+        Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      end
     end
   end
-end
 
+end