bullring 0.6 → 0.7

data/lib/bullring.rb

@@ -1,20 +1,28 @@
 require 'bullring/version'
 require 'bullring/worker'
+require 'uglifier'
 
 module Bullring
   
   class << self
         
-    attr_accessor :logger
+    def logger=(logger)
+      @logger = logger
+    end
+    
+    def logger
+      @logger ||= DummyLogger.new
+    end
     
     # Order is important (and relative to calls to add_library)
-    def add_library_file(filename)
-      worker.add_library_file(filename)
+    def add_library_file(name, filename)
+      worker.add_library_file(name, filename)
     end
     
     # Order is important (and relative to calls to add_library_script)
-    def add_library(script)
-      worker.add_library(script)
+    def add_library(name, script)
+      script = Uglifier.compile(script, :copyright => false) if configuration.minify_libraries
+      worker.add_library(name, script)
     end
     
     def check(script, options = {})
@@ -65,6 +73,8 @@ module Bullring
       attr_accessor :jvm_init_heap_size
       attr_accessor :jvm_max_heap_size
       attr_accessor :jvm_young_heap_size
+      attr_accessor :minify_libraries
+      attr_accessor :server_max_bringup_time
       
       def initialize      
         @execution_timeout_secs = 0.5
@@ -72,6 +82,8 @@ module Bullring
         @jvm_init_heap_size = '128m'
         @jvm_max_heap_size = '128m'
         @jvm_young_heap_size = '64m'
+        @minify_libraries = true
+        @server_max_bringup_time = 20 #seconds
         super
       end
     end
@@ -89,47 +101,12 @@ module Bullring
       @worker
     end
     
-    # ESCAPE_MAP = {
-    #    '\\' => '\\\\', 
-    #    "\r\n" => '\n', 
-    #    "\n" => '\n', 
-    #    "\r" => '\n', 
-    #    '"' => '\"', 
-    #    "'" => "\'"
-    #  }
-    # 
-    #  def prepare_source(source)
-    #    
-    #    # escape javascript characters (similar to Rails escape_javascript)
-    #    source.gsub!(/(\\|\r\n|[\n\r"'])/u) {|match| ESCAPE_MAP[match] }
-    # 
-    #    # make sure the source string is set up to be a multiline string in JS
-    #    source.gsub!(/\n/, '\ \n')   
-    # 
-    #    source   
-    #  end
-    
-    # ESCAPE_MAP2 = {
-    #    '\\' => '\\\\', 
-    #    "\r\n" => "\n", 
-    #    "\n" => "\n", 
-    #    "\r" => "\n", # take these semicolons out b/c we should only use them at the end of a statement; in fact just kill comments
-    #    '"' => '\"',  #need to make this surrounded by double quotes
-    #    "'" => "\'"
-    #  }
-    #  
-    #  
-    #  def prep_source(source)
-    #    # escape javascript characters (similar to Rails escape_javascript)
-    #    source.gsub!(/(\\|\r\n|[\n\r"'])/u) {|match| ESCAPE_MAP2[match] }
-    # 
-    #    # make sure the source string is set up to be a multiline string in JS
-    #    source.gsub!(/\n/, "\ \n")   
-    # 
-    #    source   
-    #    
-    #  end
-    #  
+  end
+  
+  class DummyLogger
+    def method_missing(m, *args, &block)  
+      # ignore
+    end
   end
   
 end

data/lib/bullring/util/drubied_process.rb

@@ -19,48 +19,91 @@ module Bullring
     #   }
     # }
     #
-    def initialize(options)
+    # The provided block will be called whenever this process connects (or 
+    # reconnects) to a process, including when the process is restarted. This
+    # makes the block a good place to put initialization code for the process.
+    #
+    def initialize(options, &block)
       @options = options
+      @after_connect_block = block
       connect_to_process!
     end
 
     def alive?
       begin
-        @process.nil? || @process.alive?
-      rescue DRb::DRbConnError
+        (@process.nil? || @process.alive?).tap{|is_alive| Bullring.logger.debug {"#{caller_name} #{is_alive ? 'is alive!' : 'is not alive!'}"}}
+      rescue DRb::DRbConnError => e
+        Bullring.logger.debug {"#{caller_name}: Checking if server alive and got a connection error: " + e.inspect}
         return false
-      rescue # things like name errors, in case server doesn't have an alive? method
+      rescue StandardError => e # things like name errors, in case server doesn't have an alive? method
+        Bullring.logger.debug {"#{caller_name}: Checking if server alive and got an error: " + e.inspect}
+        true
+      rescue
+        Bullring.logger.debug {"#{caller_name}: Checking if server alive and got an unknown error"}
         true
       end
     end
 
     def restart_if_needed!
+      Bullring.logger.debug {"#{caller_name}: In restart_if_needed!"}
       alive? || connect_to_process!
     end
 
     def method_missing(m, *args, &block)  
       restart_if_needed!
-      # @process.method_missing(m, args, block)
-      @process.send(m, *args, &block)
+
+      @process.logger = Bullring.logger
+      result = @process.send(m, *args, &block)
+      @process.logger = nil
+
+      result
     end
 
     def process_port_active?
-      Network::is_port_in_use?(@options[:process][:host],@options[:process][:port])
+      in_use = Network::is_port_in_use?(host,port)
+      Bullring.logger.debug {"#{caller_name}: Port #{port} on #{host} is #{in_use ? 'active' : 'inactive'}."}
+      in_use
     end
 
     # Creates a druby connection to the process, starting it up if necessary
     def connect_to_process!
+      Bullring.logger.debug{"#{caller_name}: Connecting to process..."}
+
       if !process_port_active?
-        Process.spawn([@options[:process][:command], @options[:process][:args]].flatten.join(" "))
+        Bullring.logger.debug {"#{caller_name}: Spawning process..."}
+
+        # Spawn the process in its own process group so it stays alive even if this process dies
+        pid = Process.spawn([@options[:process][:command], @options[:process][:args]].flatten.join(" "), {:pgroup => true})
+        Process.detach(pid)
 
+        time_sleeping = 0
         while (!process_port_active?)
           sleep(0.2)
+          if (time_sleeping += 0.2) > @options[:process][:max_bringup_time]
+            Bullring.logger.error {"#{caller_name}: Timed out waiting to bring up the process"}
+            raise StandardError, "#{caller_name}: Timed out waiting to bring up the process", caller
+          end
         end
       end
 
-      DRb.start_service "druby://localhost:0"
-      @process = DRbObject.new nil, "druby://#{@options[:process][:host]}:#{@options[:process][:port]}"
+      if !@local_service.nil?
+        @local_service.stop_service
+        Bullring.logger.debug {"#{caller_name}: Stopped local service on #{@local_service.uri}"}
+      end
+      
+      @local_service = DRb.start_service "druby://localhost:0"
+      Bullring.logger.debug {"#{caller_name}: Started local service on #{@local_service.uri}"}
+
+      @process = DRbObject.new nil, "druby://#{host}:#{port}"
+      
+      @after_connect_block.call(@process) if !@after_connect_block.nil?
     end
+    
+    protected
+    
+    def caller_name; @options[:caller_name]; end
+    def port; @options[:process][:port]; end
+    def host; @options[:process][:host]; end
   end
   
 end

data/lib/bullring/util/exceptions.rb

@@ -7,11 +7,6 @@ module Bullring
   class IllegalArgument < StandardError; end
   class IllegalState < StandardError; end
   class PidDirUnavailable < StandardError; end
-  
-  class JSError < StandardError
-    attr_accessor :cause
-    attr_accessor :backtrace
-    attr_accessor :message
-  end
+  class JSError < StandardError; end
   
 end

data/lib/bullring/version.rb

@@ -1,3 +1,3 @@
 module Bullring
-  VERSION = "0.6"
+  VERSION = "0.7"
 end

data/lib/bullring/worker.rb

@@ -6,11 +6,11 @@ require 'bullring/util/exceptions'
 module Bullring
   class Worker
 
-    def add_library(script)
+    def add_library(name, script)
       raise AbstractMethodCalled
     end
     
-    def add_library_file(filename)
+    def add_library_file(name, filename)
       raise AbstractMethodCalled
     end
     

data/lib/bullring/workers/rhino_server.rb

@@ -4,11 +4,21 @@ require 'logger'
 
 module Bullring
 
+  class DummyLogger
+    def method_missing(m, *args, &block)  
+      # ignore
+    end
+  end
+
   class RhinoServer
     
+    @@dummy_logger = Bullring::DummyLogger.new
+    
     def initialize
-      @library_scripts = []
+      @library_scripts = {}
+      @setup_providers = []
       configure
+      logger.info {"#{logname}: Started a RhinoServer instance at #{Time.now}"}
     end
     
     def configure(options={})
@@ -18,18 +28,38 @@ module Bullring
 
       # Don't do a merge b/c jruby and ruby don't play nicely for some reason
       options.each{|k,v| @options[k] = v}
+    end
+    
+    def load_setup(setup_provider)
+      # Get the libraries from the setup provider and add them to our local list.
+      # Hopefully, by calling 'to_s' we are getting copies that live only on our
+      # side of DRb.  Store the provider so we can go back to it later if we 
+      # find that we don't have a required library.  Use a list of providers b/c
+      # some providers may have died off.
+      
+      setup_provider.libraries.each do |name, script|
+        add_library(name.to_s, library.to_s)
+      end
       
-      @logger = options[:logger] || DummyLogger.new
+      @setup_providers.push(setup_provider)
+    end
+    
+    def logger=(logger)
+      @logger = logger
     end
     
-    def add_library(script)
-      @library_scripts.push(script)
+    def logger
+      @logger || @@dummy_logger
+    end
+        
+    def add_library(name, script)
+      @library_scripts[name] = script
     end
     
-    def add_library_file(filename)
+    def add_library_file(name, filename)
       raise NotYetImplemented
       script = read file into string
-      @library_scripts.push(script)
+      @library_scripts[name] = script
     end
     
     def check(script, options)
@@ -67,8 +97,10 @@ module Bullring
 
     def run(script, options)
       Rhino::Context.open(:sealed => @options[:run_is_sealed], :restrictable => @options[:run_is_restrictable]) do |context|
-        @library_scripts.each do |library| 
-          context_wrapper {context.eval(library)}      
+
+        (options['library_names'] || []).each do |library_name|
+          library_script = @library_scripts[library_name] || fetch_library_script!(library_name)
+          context_wrapper {context.eval(library_script)}      
         end
           
         context.timeout_limit = @options[:run_timeout_secs]
@@ -100,29 +132,20 @@ module Bullring
         result = yield
         duration = Time.now - start_time
         
-        @logger.debug("Ran script (#{duration} secs); result: " + result.inspect)
+        logger.debug {"#{logname}: Ran script (#{duration} secs); result: " + result.inspect}
         
         return duration, result
       rescue Rhino::JSError => e
-        @logger.debug("JSError! Cause: " + e.cause + "; Message: " + e.message)
-        jsError = JSError.new
-        jsError.cause = e.cause.to_s
-        jsError.message = e.message.to_s
-        jsError.backtrace = []
-        raise jsError
-      rescue Rhino::RunawayScriptError => e
-        @logger.debug("Runaway Script: " + e.inspect)
-        jsError = JSError.new
-        jsError.cause = "Script took too long to run"
-        raise jsError
+        logger.debug {"#{logname}: JSError! Cause: " + e.cause + "; Message: " + e.message}
+        raise Bullring::JSError, e.message.to_s, caller
+      rescue Rhino::RunawayScriptError, Rhino::ScriptTimeoutError => e
+        logger.debug {"#{logname}: Runaway Script: " + e.inspect}
+        raise Bullring::JSError, "Script took too long to run", caller
       rescue NameError => e
-        @logger.debug("Name error: " + e.inspect)
-      rescue Exception => e
-        @logger.debug("Exception: " + e.inspect)
-        raise e
-      rescue Error => e
-        @logger.debug("Error: " + e.inspect)
-        raise e
+        logger.debug {"#{logname}: Name error: " + e.inspect}
+      rescue StandardError => e
+        logger.debug {"#{logname}: StandardError: " + e.inspect}
+        raise
       end
     end
 
@@ -141,20 +164,37 @@ module Bullring
      source   
     end
     
-  end
-  
-  class JSError < StandardError
-    attr_accessor :cause
-    attr_accessor :backtrace
-    attr_accessor :message
-  end
-  
-  class DummyLogger
-    def method_missing(m, *args, &block)  
-      # ignore
+    # Goes back to the setup provider to the get the named script or throws an
+    # exception if there is no such script to retrieve.
+    def fetch_library_script!(name)
+      logger.debug {"#{logname}: The script named #{name} was not available so trying to fetch from clients"}
+
+      while (provider = @setup_providers.last)
+        begin
+          library_script = provider.libraries[name]
+          break if !library_script.nil?
+        rescue DRb::DRbConnError => e
+          logger.debug {"#{logname}: Could not connect to setup provider (its process probably died): " + e.inspect}
+        rescue StandardError => e
+          logger.error {"#{logname}: Encountered an unknown error searching setup providers for a script named #{name}: " + e.inspect}
+        ensure
+          # Toss the last element so we can continue searching prior elements
+          setup_providers.pop
+        end
+      end
+
+      # If after looking through the providers we are still empty handed, raise an error
+      raise NameError, "Client doesn't have script named #{name}", caller if library_script.nil?
+      
+      add_library(name, library_script)
     end
+    
+    def logname; "Bullring Server"; end
+    
   end
   
+  class JSError < StandardError; end
+  
 end
 
 #

data/lib/bullring/workers/rhino_server_worker.rb

@@ -4,6 +4,8 @@ module Bullring
 
   class RhinoServerWorker < Bullring::Worker
     
+    attr_reader :libraries
+    
     def discard
       # Daemons.run(server_command, stop_options) 
       # @server.kill if !@server.nil?
@@ -17,6 +19,7 @@ module Bullring
       # If already using jruby, can also just use rhino directly
 
       options = {}
+      options[:caller_name] = "Bullring"
       options[:process] = {
         :host => 'localhost',
         :port => Bullring.configuration.server_port,
@@ -26,40 +29,45 @@ module Bullring
                   "#{Bullring.configuration.server_port}",
                   Bullring.configuration.jvm_init_heap_size,
                   Bullring.configuration.jvm_max_heap_size,
-                  Bullring.configuration.jvm_young_heap_size]
+                  Bullring.configuration.jvm_young_heap_size],
+        :max_bringup_time => Bullring.configuration.server_max_bringup_time
       }
+            
+      @libraries = {}
       
-      @server = DrubiedProcess.new(options)
-
-      @server.configure({:run_timeout_secs => Bullring.configuration.execution_timeout_secs, 
-                         :logger => Bullring.logger})
-    end
-    
-    # TODO important! this guy needs to know if the daemon crashed and restarted (so that it
-    # can repopulate its library scripts; alternatively, we could pass the library scripts
-    # in on the command line, in which case the restarting would pick them up)
+      @server = DrubiedProcess.new(options) do |process|
+        process.configure({:run_timeout_secs => Bullring.configuration.execution_timeout_secs})
+        process.load_setup(SetupProvider.new(self))
+      end
+    end    
     
-    def add_library(script)
-      # this guy needs to maintain the library scripts in case the daemon restarts
-      server.add_library(script)
+    def add_library(name, script)
+      # this guy needs to maintain the library scripts in case the server restarts, in which
+      # case the server will request the libraries through the SetupProvider
+      rescue_me do
+        Bullring.logger.debug { "Bullring: Adding library named '#{name}'" }
+        @libraries[name] = script
+        server.add_library(name, script)
+      end
     end
 
-    def add_library_file(filename)
-      server.add_library_script(filename)
+    def add_library_file(name, filename)
+      raise NotYetImplemented
+      # server.add_library_script(filename)
     end
 
     def check(script, options)
-      server.check(script, options)
+      Bullring.logger.debug { "Bullring: Checking script with hash '#{script.hash}'" }
+      rescue_me do 
+        server.check(script, options)
+      end
     end
 
     def run(script, options)
-      begin
+      Bullring.logger.debug { "Bullring: Running script with hash '#{script.hash}'" }
+      rescue_me do
         result = server.run(script, options)
-        result.respond_to?(:to_h) ? result.to_h : result
-      rescue DRb::DRbUnknownError => e
-        raise e.unknown
-      rescue Bullring::JSError => e
-        raise e
+        result.respond_to?(:to_h) ? result.to_h : result      
       end
     end
 
@@ -67,13 +75,46 @@ module Bullring
       server.alive?
     end
     
+    class SetupProvider
+      include DRbUndumped
+
+      def initialize(wrapped_provider)
+        @wrapped_provider = wrapped_provider
+      end
+
+      def libraries
+        @wrapped_provider.libraries
+      end
+    end
+    
   private
+  
+    def rescue_me
+      @times_rescued = 0
+      begin
+        yield
+      rescue DRb::DRbConnError => e
+        Bullring.logger.error {"Bullring: Encountered a DRb connection error at time #{Time.now}: " + e.inspect}
+        
+        if (@times_rescued += 1) < 2
+          Bullring.logger.debug {"Bullring: Attempting to restart the server at time #{Time.now}"}
+          @server.restart_if_needed!
+          retry
+        else
+          raise e
+        end
+      rescue Bullring::JSError => e
+        Bullring.logger.debug {"Bullring: Encountered a JSError: " + e.inspect}
+        raise e
+      rescue DRb::DRbUnknownError => e
+        Bullring.logger.error {"Bullring: Caught an unknown DRb error: " + e.inspect}
+        raise e.unknown
+      end  
+    end
     
     attr_accessor :server 
 
   end
   
-
-  
 end
 

data/test/bullring_test.rb

@@ -1,6 +1,12 @@
 require 'test_helper'
 # require 'test/unit'
 # require 'bullring'
+require 'logger'
+
+if false
+  Bullring.logger = Logger.new('bullring_test_log.txt')
+  Bullring.logger.level = Logger::DEBUG
+end
 
 class BullringTest < Test::Unit::TestCase #ActiveSupport::TestCase
   test "truth" do

data/test/dummy/log/development.log

@@ -25,3 +25,15 @@
 
 ***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****
 
+
+***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****
+
+
+***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****
+
+
+***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****
+
+
+***** Debugger requested, but was not available (ensure ruby-debug is listed in Gemfile/installed as gem): Start server with --debugger to enable *****
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bullring
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: '0.7'
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-19 00:00:00.000000000Z
+date: 2012-04-30 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uglifier
-  requirement: &2151838560 !ruby/object:Gem::Requirement
+  requirement: &2151829140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2151838560
+  version_requirements: *2151829140
 - !ruby/object:Gem::Dependency
   name: therubyrhino
-  requirement: &2151837840 !ruby/object:Gem::Requirement
+  requirement: &2151828300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2151837840
+  version_requirements: *2151828300
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &2151837080 !ruby/object:Gem::Requirement
+  requirement: &2151827660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2151837080
+  version_requirements: *2151827660
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &2151832800 !ruby/object:Gem::Requirement
+  requirement: &2151826580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 3.2.2
   type: :development
   prerelease: false
-  version_requirements: *2151832800
+  version_requirements: *2151826580
 - !ruby/object:Gem::Dependency
   name: test-unit
-  requirement: &2151831460 !ruby/object:Gem::Requirement
+  requirement: &2151825960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2151831460
+  version_requirements: *2151825960
 - !ruby/object:Gem::Dependency
   name: ruby-debug19
-  requirement: &2151830600 !ruby/object:Gem::Requirement
+  requirement: &2151825060 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2151830600
+  version_requirements: *2151825060
 description: Safely run untrusted Javascript from Ruby
 email:
 - jps@kindlinglabs.com
@@ -155,7 +155,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1682714108002767292
+      hash: -918890081008683451
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -164,7 +164,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1682714108002767292
+      hash: -918890081008683451
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.6