bullring 0.7.4 → 0.8

data/lib/bullring/version.rb

@@ -1,3 +1,3 @@
 module Bullring
-  VERSION = "0.7.4"
+  VERSION = "0.8"
 end

data/lib/bullring/worker.rb

@@ -1,36 +1,56 @@
 require 'bullring/util/exceptions'
 
-# TODO this class may have the common uglifier code, maybe some common 
-# caching code
-
 module Bullring
   class Worker
 
-    def add_library(name, script)
-      raise AbstractMethodCalled
-    end
+    attr_reader :libraries
     
-    def add_library_file(name, filename)
-      raise AbstractMethodCalled
+    def initialize
+      @libraries = {}
+    end
+
+    def add_library(name, script)
+      Bullring.logger.debug { "Bullring: Adding library named '#{name}'" }
+      @libraries[name] = script
+      _add_library(name, script)
     end
     
     def check(script, options)
-      raise AbstractMethodCalled
+      Bullring.logger.debug { "Bullring: Checking script with hash '#{script.hash}'" }
+      _check(script, options)
     end
 
     def run(script, options)
-      raise AbstractMethodCalled
+      Bullring.logger.debug { "Bullring: Running script with hash '#{script.hash}'" }
+      _run(script, options)
     end
     
     def alive?
-      raise AbstractMethodCalled
+      _alive?
     end
     
     def discard
-      raise AbstractMethodCalled
+      Bullring.logger.debug { "Bullring: Attempting to discard." }
+      _discard
     end
     
+    def refresh
+      Bullring.logger.debug { "Bullring: Attempting to refresh." }
+      _refresh
+    end
+    
+  protected
+    
+    # Quasi-template method pattern
+    def _add_library(name, script); end
+    def _check(script, options); raise AbstractMethodCalled; end
+    def _run(script, options); raise AbstractMethodCalled; end
+    def _alive?; raise AbstractMethodCalled; end
+    def _discard; raise AbstractMethodCalled; end
+    
   end
 end
 
-require 'bullring/workers/rhino_server_worker'
+require 'bullring/workers/rhino_server_worker'
+require 'bullring/workers/racer_worker'
+

data/lib/bullring/workers/common.rb

@@ -0,0 +1,66 @@
+
+
+module Bullring
+  
+  class JSError < StandardError
+    def initialize(msg = nil)
+      @hash = {}
+      super(msg)
+    end
+    
+    def []=(key, value)
+      @hash[key] = value
+    end
+    
+    def [](key)
+      @hash[key]
+    end
+    
+    attr_reader :hash
+  end
+
+  class Helper
+    def self.jslint_call(script)
+       jslintCall = <<-RACER_CALL
+          JSLINT("#{prepare_source(script)}", {devel: false, 
+                               bitwise: true, 
+                               undef: true,
+                               continue: true, 
+                               unparam: true, 
+                               debug: true, 
+                               sloppy: true, 
+                               eqeq: true, 
+                               sub: true, 
+                               es5: true, 
+                               vars: true, 
+                               evil: true, 
+                               white: true, 
+                               forin: true, 
+                               passfail: false, 
+                               newcap: true, 
+                               nomen: true, 
+                               plusplus: true, 
+                               regexp: true, 
+                               maxerr: 50, 
+                               indent: 4}); JSLINT.errors
+        RACER_CALL
+    end
+    
+    ESCAPE_MAP = {
+      '\\' => '\\\\', 
+      "\r\n" => '\n', 
+      "\n" => '\n', 
+      "\r" => '\n', 
+      '"' => '\"', 
+      "'" => '\''
+    }
+          
+    def self.prepare_source(source) 
+     # escape javascript characters (similar to Rails escape_javascript)
+     source.gsub!(/(\\|\r\n|[\n\r"'])/u) {|match| ESCAPE_MAP[match] }
+     source   
+    end
+    
+  end
+  
+end

data/lib/bullring/workers/racer_worker.rb

@@ -0,0 +1,77 @@
+module Bullring
+
+  class RacerWorker < Bullring::Worker
+    
+    def initialize
+      super
+    end
+    
+    def check(script, options)    
+      context = V8::Context.new
+
+      context_wrapper {context.load(File.expand_path("../../js/jslint.min.js", __FILE__))}
+
+      call = Bullring::Helper::jslint_call(script)      
+      duration, result = context_wrapper {context.eval(call)}
+
+      result = result.collect{|obj| obj.respond_to?(:to_h) ? obj.to_h : obj}
+    end
+
+    def run(script, options)
+      context = V8::Context.new
+
+      (options['library_names'] || []).each do |library_name|
+        library = libraries[library_name]
+        context_wrapper {context.eval(library)}      
+      end
+
+      # context.timeout = Bullring.configuration.execution_timeout_secs * 1000
+      
+      duration, result = context_wrapper {context.eval(script)}      
+      result = result.respond_to?(:to_h) ? result.to_h : result      
+    end
+
+    def alive?
+      true
+    end
+    
+    def _discard; end
+    
+  protected
+
+    def context_wrapper
+      begin 
+
+
+        start_time = Time.now
+        result = yield
+        duration = Time.now - start_time
+
+        Bullring.logger.debug {"#{logname}: Ran script (#{duration} secs); result: " + result.inspect}
+
+        return duration, result            
+        
+      rescue V8::JSError => e
+        Bullring.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 Timeout::Error => e
+      #   Bullring.logger.error {"#{logname}: Runaway script: #{e.inspect}"}
+      rescue NameError => e
+        Bullring.logger.debug {"#{logname}: Name error: " + e.inspect}
+      rescue StandardError => e
+        Bullring.logger.debug {"#{logname}: StandardError: " + e.inspect}
+        raise
+      end
+    end
+    
+    def logname; "Bullring (Racer)"; end
+
+  end
+
+  
+  
+end
+

data/lib/bullring/workers/rhino_server.rb

@@ -2,46 +2,54 @@ require 'rhino'
 require 'drb'
 require 'logger'
 
-module Bullring
-
-  class DummyLogger
-    def method_missing(m, *args, &block)  
-      # ignore
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
     end
   end
+end
 
-  class RhinoServer
-    
-    @@dummy_logger = Bullring::DummyLogger.new
-    
-    def initialize
-      @library_scripts = {}
-      @setup_providers = []
-      configure
-      logger.info {"#{logname}: Started a RhinoServer instance at #{Time.now}"}
-    end
-    
-    def configure(options={})
-      @options ||= { :run_is_sealed => false,
-                     :run_is_restrictable => true,
-                     :run_timeout_secs => 0.5 }
+require_relative 'common'
+require_relative '../util/dummy_logger'
+require_relative '../util/server_registry'
 
-      # 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.
+module Bullring
+
+  class RhinoServer
+        
+    def initialize(host, registry_port)
+      @library_cache = {}
       
-      setup_provider.libraries.each do |name, script|
-        add_library(name.to_s, library.to_s)
+      @default_options = { :run_is_sealed => false,
+                           :run_is_restrictable => true,
+                           :run_timeout_secs => 0.5 }
+
+      # Connect to the server registry
+      @server_registry = ServerRegistry.new(host,registry_port, nil)
+
+      # Start up as a DRb server (get the port from the registry)
+      port = @server_registry.next_server_port
+      uri = "druby://#{host}:#{port}"
+      DRb.start_service uri, self
+
+      # Put ourselves on the registry
+      @server_registry.register_server(uri)
+
+      # Keep an eye on the registry, if it dies, we should die
+      Thread.new do
+        while (true) do
+          sleep(5)
+          begin 
+            @server_registry.test!
+          rescue
+            DRb.stop_service
+            Thread.main.exit
+          end
+        end
       end
       
-      @setup_providers.push(setup_provider)
+      DRb.thread.join
     end
     
     def logger=(logger)
@@ -49,62 +57,37 @@ module Bullring
     end
     
     def logger
-      @logger || @@dummy_logger
+      @logger ||= Bullring::DummyLogger.new
     end
-        
-    def add_library(name, script)
-      @library_scripts[name] = script
-    end
-    
-    def add_library_file(name, filename)
-      raise NotYetImplemented
-      script = read file into string
-      @library_scripts[name] = script
+            
+    def get_library(name)
+      @library_cache[name] ||= fetch_library(name)
     end
     
     def check(script, options)
       Rhino::Context.open do |context|
         context_wrapper {context.load(File.expand_path("../../js/jslint.min.js", __FILE__))}
         
-        jslintCall = <<-RHINO_CALL
-          JSLINT("#{prepare_source(script)}", {devel: false, 
-                               bitwise: true, 
-                               undef: true,
-                               continue: true, 
-                               unparam: true, 
-                               debug: true, 
-                               sloppy: true, 
-                               eqeq: true, 
-                               sub: true, 
-                               es5: true, 
-                               vars: true, 
-                               evil: true, 
-                               white: true, 
-                               forin: true, 
-                               passfail: false, 
-                               newcap: true, 
-                               nomen: true, 
-                               plusplus: true, 
-                               regexp: true, 
-                               maxerr: 50, 
-                               indent: 4});
-        RHINO_CALL
+        call = Bullring::Helper::jslint_call(script)
         
-        duration, result = context_wrapper {context.eval(jslintCall + "JSLINT.errors")}
+        duration, result = context_wrapper {context.eval(call)}
         
         result = result.collect{|obj| obj.respond_to?(:to_h) ? obj.to_h : obj}
       end      
     end
 
     def run(script, options)
-      Rhino::Context.open(:sealed => @options[:run_is_sealed], :restrictable => @options[:run_is_restrictable]) do |context|
+      # Don't do a merge b/c jruby and ruby don't play nicely for some reason
+      @default_options.each{|k,v| options[k] = v}
+      
+      Rhino::Context.open(:sealed => options[:run_is_sealed], :restrictable => options[:run_is_restrictable]) do |context|
 
         (options['library_names'] || []).each do |library_name|
-          library_script = @library_scripts[library_name] || fetch_library_script!(library_name)
+          library_script = get_library(library_name)
           context_wrapper {context.eval(library_script)}      
         end
           
-        context.timeout_limit = @options[:run_timeout_secs]
+        context.timeout_limit = options[:run_timeout_secs]
         
         duration, result = context_wrapper {context.eval(script)}      
         result.respond_to?(:to_h) ? result.to_h : result      
@@ -120,12 +103,11 @@ module Bullring
       exit
     end
     
-    def self.start(myPort, clientPort)
-      DRb.start_service "druby://127.0.0.1:#{myPort}", Bullring::RhinoServer.new
-      DRb.thread.join
+    def self.start(host, registry_port)
+      RhinoServer.new(host, registry_port)
     end
     
-    protected
+  protected
 
     def context_wrapper
       begin 
@@ -137,11 +119,20 @@ module Bullring
         
         return duration, result
       rescue Rhino::JSError => e
-        logger.debug {"#{logname}: JSError! Cause: " + e.cause + "; Message: " + e.message}
-        raise Bullring::JSError, e.message.to_s, caller
+        logger.debug {"#{logname}: JSError! #{e.inspect}"}
+        
+        error = Bullring::JSError.new(e.message.to_s)
+        
+        if e.message.respond_to?(:keys)
+          e.message.each do |k,v|
+            error[k.to_s] = v.to_s
+          end
+        end
+        
+        raise error
       rescue Rhino::RunawayScriptError, Rhino::ScriptTimeoutError => e
         logger.debug {"#{logname}: Runaway Script: " + e.inspect}
-        raise Bullring::JSError, "Script took too long to run", caller
+        raise Bullring::JSError, "Script took too long to run"
       rescue NameError => e
         logger.debug {"#{logname}: Name error: " + e.inspect}
       rescue StandardError => e
@@ -149,53 +140,23 @@ module Bullring
         raise
       end
     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] }
-     source   
-    end
     
-    # 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?
+    # Grab the library from the registry server
+    def fetch_library(name)
+      library_script = @server_registry['library', name]
       
-      add_library(name, library_script)
+      logger.debug {"#{logname}: Tried to fetch script '#{name}' from the registry and it " +
+                    "was #{'not ' if library_script.nil?}found."}
+
+      raise NameError, "Server cannot find a script named #{name}" if library_script.nil?
+
+      library_script
     end
     
-    def logname; "Bullring Server"; end
+    def logname; "Bullring (Rhino Server)"; end
     
   end
   
-  class JSError < StandardError; end
-  
 end
 
 #
@@ -203,11 +164,11 @@ end
 #
 
 command = ARGV[0]
-myPort = ARGV[1]
-clientPort = ARGV[2]
+host = ARGV[1]
+registry_port = ARGV[2]
 
 case command
 when "start"
-  Bullring::RhinoServer.start(myPort, clientPort)
+  Bullring::RhinoServer.start(host, registry_port)
 end