jetty-rails 0.5 → 0.6

data/lib/jetty_rails/config/command_line_reader.rb

@@ -0,0 +1,68 @@
+require 'getoptlong'
+require 'jetty_rails/config/rdoc_fix'
+
+
+class CommandLineReader
+
+  def default_config()
+    @@config ||= {
+      :rails => { 
+        :base => Dir.pwd,
+        :port => 3000,
+        :config_file => "#{File.join(Dir.pwd, 'config', 'jetty_rails.yml')}",
+        :adapter => :rails
+      },
+      :merb => {
+        :base => Dir.pwd,
+        :port => 4000,
+        :config_file => "#{File.join(Dir.pwd, 'jetty_merb.yml')}",
+        :adapter => :merb
+      }
+    }
+  end
+
+  def read(default_adapter = :rails)
+    config = default_config[default_adapter]
+    
+    opts = GetoptLong.new(
+      [ '--version', '-v', GetoptLong::NO_ARGUMENT ],
+      [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+      [ '--context-path', '-u', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--port', '-p', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--environment', '-e', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--lib', '--jars', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--classes', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--config', '-c', GetoptLong::OPTIONAL_ARGUMENT ]
+    )
+    
+    opts.each do |opt, arg|
+      case opt
+        when '--version'
+          require 'jetty_rails/version'
+          puts "JettyRails version #{JettyRails::VERSION::STRING} - http://jetty-rails.rubyforge.org"
+          exit(0)
+        when '--help'
+          RDoc::usage
+        when '--context-path'
+          config[:context_path] = arg
+        when '--port'
+          config[:port] = arg.to_i
+        when '--environment'
+          config[:environment] = arg
+        when '--classes'
+          config[:classes_dir] = arg
+        when '--lib'
+          config[:lib_dir] = arg
+    	  when '--config'
+    	    config[:config_file] = arg if !arg.nil? && arg != ""
+    	    config.merge!(YAML.load_file(config[:config_file]))
+      end
+    end
+
+    config[:base] = ARGV.shift unless ARGV.empty?
+    config
+  end  
+  
+end
+
+

data/lib/jetty_rails/config/rdoc_fix.rb

@@ -0,0 +1,28 @@
+require 'rdoc/usage'
+
+# fix to work with rubygems (use current file instead of main)
+def RDoc.usage_no_exit(*args)
+  comment = File.open(File.join(File.dirname(__FILE__), %w(.. .. .. bin), File.basename($0))) do |file|
+    find_comment(file)
+  end
+
+  comment = comment.gsub(/^\s*#/, '')
+
+  markup = SM::SimpleMarkup.new
+  flow_convertor = SM::ToFlow.new
+
+  flow = markup.convert(comment, flow_convertor)
+
+  format = "plain"
+
+  unless args.empty?
+    flow = extract_sections(flow, args)
+  end
+
+  options = RI::Options.instance
+  if args = ENV["RI"]
+    options.parse(args.split)
+  end
+  formatter = options.formatter.new(options, "")
+  formatter.display_flow(flow)
+end

data/lib/jetty_rails/handler/public_directory_handler.rb

@@ -0,0 +1,24 @@
+
+module JettyRails
+  module Handler
+    class PublicDirectoryHandler < JettyRails::Handler::DelegateOnErrorsHandler
+  
+      def initialize(config)
+        super()
+        @config = config
+        @resources = Jetty::Handler::ResourceHandler.new
+        @resources.resource_base = @config[:base] + '/public'
+        context_capable = add_context_capability_to @resources
+        self.handler = context_capable
+      end
+  
+      def add_context_capability_to(handler)
+        return handler if @config[:context_path].root?
+        context_handler = Jetty::Handler::ContextHandler.new(@config[:context_path])
+        context_handler.handler = handler
+        context_handler
+      end
+      
+    end
+  end
+end

data/lib/jetty_rails/handler/web_app_handler.rb

@@ -0,0 +1,66 @@
+module JettyRails
+  module Handler
+    class WebAppHandler < Jetty::Handler::WebAppContext
+      attr_reader :config, :adapter
+      
+      def initialize(config)
+        super("/", config[:context_path])
+        @config = config
+
+        # create an isolated classloader per application context
+        self.class_loader = org.jruby.util.JRubyClassLoader.new(JRuby.runtime.jruby_class_loader)
+        self.resource_base = config[:base]
+        
+        add_classes_dir_to_classpath(config)
+        add_lib_dir_jars_to_classpath(config)
+    
+        @adapter = adapter_for(config[:adapter])
+        self.init_params = @adapter.init_params
+        
+        @adapter.event_listeners.each do |listener|
+          add_event_listener(listener)
+        end
+
+        add_filter(rack_filter, "/*", Jetty::Context::DEFAULT)
+      end
+  
+      def self.add_adapter(adapter_key, adapter)
+        adapters[adapter_key] = adapter
+      end
+  
+      def self.adapters
+        @adapters ||= {
+          :rails => JettyRails::Adapters::RailsAdapter,
+          :merb => JettyRails::Adapters::MerbAdapter
+        }
+      end
+      
+      def adapters
+        self.class.adapters
+      end
+  
+      protected
+      def rack_filter
+        Jetty::FilterHolder.new(Rack::RackFilter.new)
+      end
+  
+      def adapter_for(kind)
+        adapters[kind.to_sym].new(@config)
+      end
+      
+      private
+      def add_lib_dir_jars_to_classpath(config)
+        lib_dir = "#{config[:base]}/#{config[:lib_dir]}"
+        Dir[lib_dir].each do |jar|
+          url = java.io.File.new(jar).to_url
+          self.class_loader.add_url(url)
+        end
+      end
+      def add_classes_dir_to_classpath(config)
+        classes_dir = "#{config[:base]}/#{config[:classes_dir]}"
+        url = java.io.File.new(classes_dir).to_url
+        self.class_loader.add_url(url)
+      end
+    end
+  end
+end

data/lib/jetty_rails/jars.rb

@@ -12,9 +12,12 @@ module JettyRails
       include_package "org.mortbay.jetty.handler"
       include_package "org.mortbay.jetty.webapp"
     end
+    module Thread
+      include_package "org.mortbay.thread"
+    end
   end
 
-  require "jruby-rack-0.9"
+  require "jruby-rack-0.9.2"
   module Rack
     include_package "org.jruby.rack"
     include_package "org.jruby.rack.rails"

data/lib/jetty_rails/runner.rb

@@ -3,97 +3,44 @@ require "jruby"
 module JettyRails
   
   class Runner
-    attr_reader :config
-    attr_reader :server
-    attr_reader :app_context
-    
-    @@defaults = {
-      :adapter => :rails, 
-      :environment => 'development',
-      :context_path => '/',
-      :lib_dir => 'lib/**/*.jar',
-      :port => 8080 
-    }
-    
-    @@adapters = {
-      :rails => JettyRails::Adapters::RailsAdapter,
-      :merb => JettyRails::Adapters::MerbAdapter
-    }
+    attr_reader :servers
     
     def initialize(config = {})
-      @config = config.symbolize_keys!.reverse_merge!(@@defaults)
-      @config[:context_path].extend ContextPath
-      
-      raise 'Basedir to be run must be provided' unless config[:base]
-      
-      @server = Jetty::Server.new
-      connector = Jetty::SelectChannelConnector.new
-      connector.port = config[:port]
-      @server.add_connector(connector)
-      
-      add_stuff_to_classpath
-      add_public_dir_to server
-      install_rack_on server
-    end
-    
-    def start
-      @server.start
-      @server.join
-    end
-    
-    private
-    def add_stuff_to_classpath
-      lib_dir = "#{config[:base]}/#{config[:lib_dir]}"
-      Dir[lib_dir].each do |jar|
-        require jar
+      @servers = {}
+      config.symbolize_keys!
+      if config[:servers].nil?
+        add_server(config) 
+      else
+        config[:servers].each do |server_config|
+          server_config.symbolize_keys!
+          server_config.reverse_merge!(config)
+          server_config.delete(:servers)
+          add_server(server_config)
+        end
       end
     end
     
-    def add_public_dir_to(server)
-      @resources = Jetty::Handler::ResourceHandler.new
-      @resources.resource_base = config[:base] + '/public'
-      context_capable = add_context_capability_to @resources
-      delegate_on_error = JettyRails::Handler::DelegateOnErrorsHandler.new
-      delegate_on_error.handler = context_capable
-      server.add_handler(delegate_on_error)
+    def add_server(config = {})
+      server = JettyRails::Server.new(config)
+      @servers[server.config[:port]] = server
     end
     
-    def add_context_capability_to(handler)
-      return handler if config[:context_path].root?
-      context_handler = Jetty::Handler::ContextHandler.new(config[:context_path])
-      context_handler.handler = @resources
-      context_handler
-    end
-    
-    def install_rack_on(server)
-      @app_context = Jetty::Handler::WebAppContext.new("/", config[:context_path])
-      @app_context.class_loader = JRuby.runtime.jruby_class_loader
-      @app_context.resource_base = config[:base]
-      
-      adapter = adapter_for config[:adapter]
-      @app_context.init_params = adapter.init_params
-      adapter.event_listeners.each do |listener|
-        @app_context.add_event_listener(listener)
+    def start
+      server_threads = ThreadGroup.new
+      @servers.each do |base, server|
+        log("starting #{base}")
+        server_threads.add(Thread.new do
+          server.start
+        end)
       end
       
-      @app_context.add_filter(rack_filter, "/*", Jetty::Context::DEFAULT)
-      server.add_handler(@app_context)
-    end
-    
-    def rack_filter
-      Jetty::FilterHolder.new(Rack::RackFilter.new)
+      server_threads.list.each {|thread| thread.join } unless server_threads.list.empty?
     end
     
-    def adapter_for(kind)
-      @@adapters[kind.to_sym].new(config)
-    end
+    private
     
-  end
-  
-  module ContextPath
-    def root?
-      self == '/'
+    def log(msg)
+      $stdout.puts(msg)
     end
   end
-  
 end

data/lib/jetty_rails/server.rb

@@ -0,0 +1,75 @@
+module JettyRails
+  class Server
+    attr_reader :config
+    attr_reader :app_contexts
+    attr_reader :server
+  
+    @@defaults = {
+      :adapter => :rails, 
+      :environment => 'development',
+      :context_path => '/',
+      :lib_dir => 'lib/**/*.jar',
+      :classes_dir => 'classes',
+      :port => 8080,
+      :jruby_min_runtimes => 1,
+      :jruby_max_runtimes => 5,
+      :thread_pool_max => 20,
+      :thread_pool_min => 1,
+      :acceptor_size => 5
+    }
+  
+    def initialize(config = {})
+      @config = config.symbolize_keys!.reverse_merge!(@@defaults)
+    
+      @server = Jetty::Server.new
+      # setup the thread pool for the server
+      thread_pool = Jetty::Thread::QueuedThreadPool.new
+      thread_pool.set_max_threads(config[:thread_pool_max])
+      thread_pool.set_min_threads(config[:thread_pool_min])
+      @server.set_thread_pool(thread_pool)
+    
+      connector = Jetty::SelectChannelConnector.new
+      connector.set_acceptors(config[:acceptor_size])
+      connector.port = config[:port]
+      @server.add_connector(connector)
+
+      if config[:apps].nil?
+        add_app(config)
+      else
+        config[:apps].each do |app_config|
+          app_config.reverse_merge!(config)
+          app_config.delete(:apps)
+          add_app(app_config)
+        end
+      end
+    end
+    
+    def add_app(config) 
+      raise 'Base dir to be run must be provided' unless config[:base]
+      config[:context_path].extend ContextPath
+      
+      @server.add_handler(JettyRails::Handler::PublicDirectoryHandler.new(config))
+      web_app_handler = JettyRails::Handler::WebAppHandler.new(config)
+      (@app_contexts ||= []) << web_app_handler
+      @server.add_handler(web_app_handler)
+    end
+  
+    def start
+      @server.start
+      @server.join
+    end
+  
+  
+    private
+    def read_warble_config
+      require 'warbler'
+      WarblerReader.new(config)
+    end
+  
+    module ContextPath
+      def root?
+        self == '/'
+      end
+    end
+  end
+end

data/lib/jetty_rails/version.rb

@@ -1,7 +1,7 @@
 module JettyRails #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 5
+    MINOR = 6
 
     STRING = [MAJOR, MINOR].join('.')
   end

data/lib/jetty_rails/warbler_reader.rb

@@ -0,0 +1,13 @@
+class WarblerReader
+  
+  def initialize(config)
+    # TODO ignore jruby and jruby-rack
+    warbler_config = load("#{config[:base]}/config/warble.rb")
+    warbler_config.java_libs.each do |jar|
+      require jar
+    end
+    # TODO require custom classes
+  end
+  
+  
+end

data/spec/config.yml

@@ -0,0 +1,28 @@
+--- 
+:servers: 
+- :context_path: /testA
+  :base: /
+  :adapter: :rails
+  :environment: development
+  :port: 3000
+  :lib_dir: lib/**/*.jar
+  :jruby_min_runtimes: 2
+- :context_path: /testB
+  :base: /testing
+  :adapter: :merb
+  :port: 4000
+- :port: 8080
+  :apps:
+  - :context_path: /testC
+    :base: /testing
+    :adapter: :merb
+    :environment: test
+  - :context_path: /testD
+    :base: /something
+    :adapter: :rails
+:environment: production
+:jruby_min_runtimes: 1
+:jruby_max_runtimes: 2
+:thread_pool_max: 40
+:thread_pool_min: 1
+:acceptor_size: 20