nolman-jetty-rails 0.9.6-jruby

data/lib/jetty_rails/adapters/merb_adapter.rb

@@ -0,0 +1,34 @@
+module JettyRails
+  module Adapters
+    
+    class MerbAdapter < AbstractAdapter
+      
+      def init_params
+        # please refer to goldspike and jruby-rack documentation
+        @merb_params ||= {
+          'merb.root' => '/',
+          'merb.environment' => config[:environment]
+        }.merge(base_init_params)
+      end
+      
+      def event_listeners
+        [ Rack::MerbServletContextListener.new, SignalHandler.new ]
+      end
+      
+      class SignalHandler
+        include Java::JavaxServlet::ServletContextListener
+        
+        def contextInitialized(cfg)
+          trap("INT") do
+            puts "\nbye!"
+            java.lang.System.exit(0)
+          end
+        end
+        
+        def contextDestroyed(cfg)
+        end
+      end
+      
+    end
+  end
+end

data/lib/jetty_rails/adapters/rails_adapter.rb

@@ -0,0 +1,22 @@
+module JettyRails
+  module Adapters
+    
+    class RailsAdapter < AbstractAdapter
+            
+      def init_params
+        # please refer to goldspike and jruby-rack documentation
+        # in: PoolingRackApplicationFactory 
+        @rails_params ||= {
+          'rails.root' => '/',
+          'rails.env' => config[:environment]
+        }.merge(base_init_params)
+      end
+      
+      def event_listeners
+        [ Rack::RailsServletContextListener.new ]
+      end
+      
+    end
+    
+  end
+end

data/lib/jetty_rails/adapters/rails_jms_adapter.rb

@@ -0,0 +1,104 @@
+module JettyRails
+  module Adapters
+    
+    # This adapter extends the standard Rails adapter with
+    # an additional listener for JMS queues
+    class RailsJmsAdapter < RailsAdapter
+      
+      # Defaults to expecting OpenMQ jars in lib_dir/jms_dir at startup
+      @@defaults = {
+        :jms_dir    => "jms",
+        :queue_name => "rails_queue",
+        :mq_host    => "localhost",
+        :mq_port    => 7676
+      }
+      
+      def initialize(config)
+        super @@defaults.merge(config)
+        require_jms_jars()
+      end
+      
+      def event_listeners
+        super << Rack::JMS::QueueContextListener.new(queue_manager_factory())
+      end
+      
+      def queue_manager_factory
+        factory = jndiless_default_queue_manager_factory_class()
+        factory.queue_name = config[:queue_name]
+        factory.mq_host    = config[:mq_host]
+        factory.mq_port    = config[:mq_port]
+        factory.new
+      end
+      
+      protected
+      
+      def jms_jars_path
+        File.join(config[:base], config[:lib_dir], config[:jms_dir])
+      end
+      
+      def require_jms_jars
+        Dir["#{self.jms_jars_path}/*.jar"].each {|jar| require jar }
+      end
+      
+      # JRuby Rack's DefaultQueueManager uses JNDI for discovery
+      # JNDI is overkill for embedded servers like Jetty Rails
+      # 
+      # This method returns a custom Rack::JMS::QueueManagerFactory
+      # which produces a JNDI-less Rack::JMS::DefaultQueueManager
+      def jndiless_default_queue_manager_factory_class
+        factory_class = Class.new
+        factory_class.send :cattr_accessor, :queue_name, :mq_host, :mq_port
+        
+        # Implement Rack::JMS::QueueManagerFactory Interface
+        factory_class.send :include, Rack::JMS::QueueManagerFactory
+        factory_class.module_eval(<<-EOS)
+          
+          def newQueueManager
+            manager_class = Class.new Rack::JMS::DefaultQueueManager
+            
+            manager_class.send :field_accessor, :context, 
+                                                :connectionFactory
+            
+            manager_class.send :attr_accessor, :queue_name, :mq_host, :mq_port
+            
+            # Overrides JNDI parts of DefaultQueueManager
+            manager_class.module_eval do
+              
+              # Overrides in order to initialize connection factory w/o JNDI
+              def init(context)
+                self.context = context
+                unless self.connectionFactory
+                  import "com.sun.messaging.ConnectionFactory"
+                  factory = com.sun.messaging.ConnectionFactory.new
+                  config  = com.sun.messaging.ConnectionConfiguration
+                  factory.setProperty(config.imqAddressList, "mq://" + self.mq_host + ":" + self.mq_port.to_s)
+                  self.connectionFactory = factory
+                end
+              end
+              
+              # Overrides in order to perform lookup of queue w/o JNDI
+              def lookup(name)
+                if name == self.queue_name
+                  @jndiless_queue ||= com.sun.messaging.Queue.new(self.queue_name)
+                else
+                  super(name)
+                end
+              end
+              
+            end
+            
+            returning manager_class.new do |m|
+              m.queue_name = self.class.queue_name
+              m.mq_host    = self.class.mq_host
+              m.mq_port    = self.class.mq_port
+            end
+          end
+        EOS
+        
+        factory_class
+      end
+      
+    end
+    
+  end
+end

data/lib/jetty_rails/config/command_line_reader.rb

@@ -0,0 +1,75 @@
+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,
+        :environment => "development"
+      },
+      :merb => {
+        :base => Dir.pwd,
+        :port => 4000,
+        :config_file => "#{File.join(Dir.pwd, 'config', '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 != ""
+      end
+    end
+
+    config[:base] = ARGV.shift unless ARGV.empty?
+    
+    if File.exists?(config[:config_file])
+      config_file = YAML.load_file(config[:config_file])
+      config.merge!(config_file[config[:environment]] || config_file) # check for env scope
+      puts "Loaded #{config[:config_file]}"
+    end
+    
+    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/delegate_on_errors_handler.rb

@@ -0,0 +1,29 @@
+module JettyRails
+  module Handler
+    
+    class DelegateOnErrorsResponse
+      include Java::JavaxServletHttp::HttpServletResponse
+      
+      def initialize(original, request)
+        @original = original
+        @request = request
+      end
+      
+      def sendError(status_code)
+        @request.handled = false
+      end
+      
+      def method_missing(method, *args, &blk)
+        @original.send(method, *args, &blk)
+      end
+    end
+    
+    class DelegateOnErrorsHandler < Jetty::Handler::HandlerWrapper
+      def handle(target, request, response, dispatch)
+        decorated_response = DelegateOnErrorsResponse.new(response, request)
+        self.handler.handle(target, request, decorated_response, dispatch)
+      end
+    end
+    
+  end
+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,85 @@
+module JettyRails
+  module Handler
+    class WebAppHandler < Jetty::Handler::WebAppContext
+      attr_reader :config, :adapter
+      
+      def initialize(config)
+        super("/", config[:context_path])
+        @config = config
+
+        self.class_loader = each_context_has_its_own_classloader
+        self.resource_base = "#{config[:base]}/public"
+        self.descriptor = config[:web_xml]
+        
+        add_classes_dir_to_classpath(config)
+        add_lib_dir_jars_to_classpath(config)
+        
+        @adapter = adapter_for(config[:adapter])
+        self.init_params = @adapter.init_params
+        
+        unless File.exist?(self.descriptor)
+          @adapter.event_listeners.each do |listener|
+            add_event_listener(listener)
+          end
+
+          add_filter(rack_filter, "/*", Jetty::Context::DEFAULT)
+        end
+      end
+  
+      def self.add_adapter(adapter_key, adapter)
+        adapters[adapter_key] = adapter
+      end
+  
+      def self.adapters
+        @adapters ||= {
+          :rails => JettyRails::Adapters::RailsAdapter,
+          :rails_jms => JettyRails::Adapters::RailsJmsAdapter,
+          :merb => JettyRails::Adapters::MerbAdapter
+        }
+      end
+      
+      def adapters
+        self.class.adapters
+      end
+      
+      alias :get_from_public_otherwise :getResource 
+      
+      def getResource(resource)
+        return fix_for_base_url if resource == '/'
+        get_from_public_otherwise resource
+      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 fix_for_base_url
+        Jetty::FileResource.new(java.io.File.new(config[:base]).to_url)
+      end
+      
+      def add_lib_dir_jars_to_classpath(config)
+        lib_dir = "#{config[:base]}/#{config[:lib_dir]}/**/*.jar"
+        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
+      
+      def each_context_has_its_own_classloader()
+        org.jruby.util.JRubyClassLoader.new(JRuby.runtime.jruby_class_loader)
+      end
+    end
+  end
+end

data/lib/jetty_rails/jars.rb

@@ -0,0 +1,36 @@
+module JettyRails
+  
+  require "servlet-api-2.5-6.1.14"
+  require "jetty-6.1.14"
+  require "jetty-util-6.1.14"
+  require "jetty-plus-6.1.14"
+  require "core-3.1.1"
+  require "jsp-api-2.1"
+  require "jsp-2.1"
+    
+  module Jetty
+    include_package "org.mortbay.jetty"
+    include_package "org.mortbay.jetty.servlet"
+    include_package "org.mortbay.jetty.nio"
+    include_package "org.mortbay.resource"
+    module Handler
+      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.7-SNAPSHOT"
+  module Rack
+    include_package "org.jruby.rack"
+    include_package "org.jruby.rack.rails"
+    include_package "org.jruby.rack.merb"
+    
+    module JMS
+      include_package "org.jruby.rack.jms"
+    end
+  end
+  
+end