trinidad 0.9.0 → 0.9.1

data/History.txt

@@ -1,3 +1,11 @@
+== 0.9.1 (2010-05-09)
+
+* Move all configuration logic to a Lifecycle listener:
+    - Keeps the initial configuration so the provided web xml files are no more needed.
+    - Avoids workarounds in the hotdeploy extension.
+* Disable more Tomcat's default behaviours. Process Tlds is also disabled.
+* Allow to specify webapp extensions in the extensions root section.
+
 == 0.9.0 (2010-04-28)
 
 * Tomcat updated to version 6.0.26, added constant to get its version.

data/VERSION

@@ -1 +1 @@
-0.9.0
+0.9.1

data/lib/trinidad/extensions.rb

@@ -3,7 +3,9 @@ module Trinidad
     def self.configure_webapp_extensions(extensions, tomcat, app_context)
       if extensions
         extensions.each do |name, options|
-          extension(name, 'WebAppExtension', options).configure(tomcat, app_context)
+          if extension = extension(name, 'WebAppExtension', options)
+            extension.configure(tomcat, app_context)
+          end
         end
       end
     end
@@ -11,9 +13,10 @@ module Trinidad
     def self.configure_server_extensions(extensions, tomcat)
       if extensions
         extensions.each do |name, options|
-          extension = extension(name, 'ServerExtension', options)
-          configured_tomcat = extension.configure(tomcat)
-          tomcat = configured_tomcat if extension.override_tomcat?
+          if extension = extension(name, 'ServerExtension', options)
+            configured_tomcat = extension.configure(tomcat)
+            tomcat = configured_tomcat if extension.override_tomcat?
+          end
         end
       end
       tomcat
@@ -22,7 +25,9 @@ module Trinidad
     def self.configure_options_extensions(extensions, parser, default_options)
       if extensions
         extensions.each do |name, options|
-          extension(name, 'OptionsExtension', options).configure(parser, default_options)
+          if extension = extension(name, 'OptionsExtension', options)
+            extension.configure(parser, default_options)
+          end
         end
       end
     end
@@ -30,7 +35,8 @@ module Trinidad
     def self.extension(name, type, options)
       class_name = (name.to_s.camelize << type).to_sym
       load_extension(name) unless const_defined?(class_name)
-      const_get(class_name).new(options)
+      clazz = const_get(class_name) rescue nil
+      clazz.new(options) if clazz
     end
 
     def self.load_extension(name)

data/lib/trinidad/rackup_web_app.rb

@@ -1,19 +1,16 @@
 module Trinidad
   class RackupWebApp < WebApp
 
-    def add_init_params
+    def init_params
       super
-      add_parameter_unless_exist('rackup', rackup_script)
+      add_parameter_unless_exist 'rackup', rackup_script
+      @params
     end
 
-    def context_listener
-      'org.jruby.rack.RackServletContextListener'
-    end
+    def context_listener; 'org.jruby.rack.RackServletContextListener'; end
 
     def rackup_script
-      IO.read(File.join(@app[:web_app_dir], @app[:rackup]))
+      File.read(File.join(web_app_dir, rackup))
     end
-
-    def provided_web_xml; 'rackup_web.xml'; end
   end
 end

data/lib/trinidad/rails_web_app.rb

@@ -1,16 +1,13 @@
 module Trinidad
   class RailsWebApp < WebApp
 
-    def add_init_params
+    def init_params
       super
-      add_parameter_unless_exist('rails.env', environment.to_s)
-      add_parameter_unless_exist('rails.root', '/')
+      add_parameter_unless_exist 'rails.env', environment.to_s
+      add_parameter_unless_exist 'rails.root', '/'
+      @params
     end
 
-    def context_listener
-      'org.jruby.rack.rails.RailsServletContextListener'
-    end
-
-    def provided_web_xml; 'rails_web.xml'; end
+    def context_listener; 'org.jruby.rack.rails.RailsServletContextListener'; end
   end
 end

data/lib/trinidad/server.rb

@@ -36,6 +36,7 @@ module Trinidad
       @tomcat.host.app_base = Dir.pwd
       enable_naming
 
+      add_http_connector if http_configured?
       add_ssl_connector if ssl_enabled?
       add_ajp_connector if ajp_enabled?
 
@@ -50,15 +51,10 @@ module Trinidad
         app_context = @tomcat.addWebapp(app_config[:context_path], app_config[:web_app_dir])
         remove_defaults(app_context)
 
-        web_app = WebApp.create(app_context, @config, app_config)
+        web_app = WebApp.create(@config, app_config)
 
-        web_app.load_default_web_xml
-        web_app.configure_rack
-        web_app.configure_extensions(@tomcat)
-        web_app.add_context_loader
-        web_app.add_init_params
-
-        web_app.add_rack_context_listener
+        Trinidad::Extensions.configure_webapp_extensions(web_app.extensions, @tomcat, app_context)
+        app_context.add_lifecycle_listener(WebAppLifecycleListener.new(web_app))
       end
     end
 
@@ -71,11 +67,14 @@ module Trinidad
       connector.secure = opts.delete(:secure) || false
       connector.port = opts.delete(:port).to_i
 
+      connector.protocol_handler_class_name = opts.delete(:protocol_handler) if opts[:protocol_handler]
+
       opts.each do |key, value|
         connector.setProperty(key.to_s, value.to_s)
       end
 
       @tomcat.getService().addConnector(connector)
+      connector
     end
 
     def add_ajp_connector
@@ -95,6 +94,15 @@ module Trinidad
       create_default_keystore(options) unless File.exist?(options[:keystore])
     end
 
+    def add_http_connector
+      options = @config[:http]
+      options[:port] = @config[:port]
+      options[:protocol_handler] = 'org.apache.coyote.http11.Http11NioProtocol' if options[:nio]
+
+      connector = add_service_connector(options)
+      @tomcat.connector = connector
+    end
+
     def ssl_enabled?
       @config.has_key?(:ssl)
     end
@@ -103,6 +111,10 @@ module Trinidad
       @config.has_key?(:ajp)
     end
 
+    def http_configured?
+      @config.has_key?(:http)
+    end
+
     def create_default_keystore(config)
       keystore_file = java.io.File.new(config[:keystore])
 
@@ -166,6 +178,12 @@ module Trinidad
 
       jsp_servlet = app_context.find_child('jsp')
       app_context.remove_child(jsp_servlet) if jsp_servlet
+
+      app_context.remove_servlet_mapping('/')
+      app_context.remove_servlet_mapping('*.jspx')
+      app_context.remove_servlet_mapping('*.jsp')
+
+      app_context.process_tlds = false
     end
   end
 end

data/lib/trinidad/web_app.rb

@@ -1,118 +1,81 @@
 module Trinidad
   class WebApp
-    attr_reader :context, :config
+    attr_reader :config, :app_config, :class_loader, :servlet
 
-    def self.create(context, config, app)
-      app.has_key?(:rackup) ? RackupWebApp.new(context, config, app) : RailsWebApp.new(context, config, app)
+    def self.create(config, app_config)
+      app_config.has_key?(:rackup) ? RackupWebApp.new(config, app_config) : RailsWebApp.new(config, app_config)
     end
 
-    def initialize(context, config, app)
-      @context = context
+    def initialize(config, app_config, servlet_class = 'org.jruby.rack.RackServlet', servlet_name = 'RackServlet')
       @config = config
-      @app = app
+      @app_config = app_config
 
       @class_loader = org.jruby.util.JRubyClassLoader.new(JRuby.runtime.jruby_class_loader)
+      @servlet = {:class => servlet_class, :name => servlet_name} unless rack_servlet_configured?
     end
 
-    def configure_rack(servlet_class = 'org.jruby.rack.RackServlet', servlet_name = 'RackServlet')
-      unless rack_configured?
-        wrapper = @context.createWrapper()
-        wrapper.setServletClass(servlet_class)
-        wrapper.setName(servlet_name)
-
-        @context.addChild(wrapper)
-        @context.addServletMapping('/*', servlet_name)
-      end
+    def rack_listener
+      context_listener unless rack_listener_configured?
     end
 
-    def add_context_loader
-      add_application_libs(@class_loader)
-      add_application_classes(@class_loader)
-
-      loader = Trinidad::Tomcat::WebappLoader.new(@class_loader)
-
-      loader.container = @context
-      @context.loader = loader
+    def init_params
+      @params ||= {}
+      add_parameter_unless_exist 'jruby.min.runtimes', jruby_min_runtimes.to_s
+      add_parameter_unless_exist 'jruby.max.runtimes', jruby_max_runtimes.to_s
+      add_parameter_unless_exist 'jruby.initial.runtimes', jruby_min_runtimes.to_s
+      add_parameter_unless_exist 'public.root', File.join('/', public_root)
+      @params
     end
 
-    def add_init_params
-      add_parameter_unless_exist('jruby.min.runtimes', jruby_min_runtimes.to_s)
-      add_parameter_unless_exist('jruby.max.runtimes', jruby_max_runtimes.to_s)
-      add_parameter_unless_exist('jruby.initial.runtimes', jruby_min_runtimes.to_s)
-      add_parameter_unless_exist('public.root', File.join('/', public_root))
-    end
-
-    def add_rack_context_listener
-      unless rack_listener_configured?
-        @context.addApplicationListener(context_listener)
+    def default_deployment_descriptor
+      @deployment_descriptor ||= if default_web_xml
+        file = File.expand_path(File.join(web_app_dir, default_web_xml))
+        File.exist?(file) ? file : nil
       end
     end
 
-    def add_application_libs(class_loader)
-      resources_dir = File.join(@app[:web_app_dir], libs_dir, '**', '*.jar')
-
-      Dir[resources_dir].each do |resource|
-        class_loader.addURL(java.io.File.new(resource).to_url)
-      end
-    end
-
-    def add_application_classes(class_loader)
-      resources_dir = File.join(@app[:web_app_dir], classes_dir)
-      class_loader.addURL(java.io.File.new(resources_dir).to_url)
-    end
-
-    def load_default_web_xml
-      file = File.expand_path(File.join(@app[:web_app_dir], default_web_xml))
-      file = File.expand_path("../#{provided_web_xml}", __FILE__) unless File.exist?(file)
-
-      @context.setDefaultWebXml(file)
-
-      context_config = Trinidad::Tomcat::ContextConfig.new
-      context_config.setDefaultWebXml(file)
-
-      @context.addLifecycleListener(context_config)
-    end
-
-    def rack_configured?
-      return false if @context.getDefaultWebXml().nil?
-
-      web_xml = IO.read(@context.getDefaultWebXml()).gsub(/\s+/, '')
-
-      return web_xml.include?('<servlet-class>org.jruby.rack.RackServlet') ||
-              web_xml.include?('<filter-class>org.jruby.rack.RackFilter')
+    def rack_servlet_configured?
+      !!(web_xml && (web_xml.include?('<servlet-class>org.jruby.rack.RackServlet') ||
+        web_xml.include?('<filter-class>org.jruby.rack.RackFilter')))
     end
 
     def rack_listener_configured?
-      return false if @context.getDefaultWebXml().nil?
-
-      web_xml = IO.read(@context.getDefaultWebXml()).gsub(/\s+/, '')
-
-      return web_xml.include?("<listener-class>#{context_listener}")
+      !!(web_xml && web_xml.include?("<listener-class>#{context_listener}"))
     end
 
     def public_root
-      @context.findParameter('public.root') || @app[:public]  || @config[:public] || 'public'
+      @app_config[:public]  || @config[:public] || 'public'
     end
 
-    %w{libs_dir classes_dir default_web_xml environment jruby_min_runtimes jruby_max_runtimes}.each do |method_name|
+    %w{web_app_dir libs_dir classes_dir default_web_xml environment jruby_min_runtimes jruby_max_runtimes rackup}.each do |method_name|
       define_method method_name do
         sym = method_name.to_sym
-        @app[sym] || @config[sym]
+        @app_config[sym] || @config[sym]
       end
     end
 
-    def add_parameter_unless_exist(name, value)
-      @context.addParameter(name, value) unless @context.findParameter(name)
+    def extensions
+      @extensions ||= begin
+        extensions = @config[:extensions] || {}
+        extensions.merge!(@app_config[:extensions]) if @app_config[:extensions]
+        extensions
+      end
     end
 
-    def load_extensions?
-      @app.has_key?(:extensions)
+    protected
+    def add_parameter_unless_exist(param_name, param_value)
+      @params[param_name] = param_value unless web_context_param(param_name)
     end
 
-    def configure_extensions(tomcat)
-      return unless load_extensions?
+    private
+    def web_xml
+      @web_xml ||= File.read(default_deployment_descriptor).gsub(/\s+/, '') unless default_deployment_descriptor.nil?
+    end
 
-      Trinidad::Extensions.configure_webapp_extensions(@app[:extensions], tomcat, @context)
-    end 
+    def web_context_param(param)
+      if web_xml =~ /<context-param><param-name>#{param}<\/param-name><param-value>(.+)<\/param-value>/
+        return $1
+      end
+    end
   end
 end

data/lib/trinidad/web_app_lifecycle_listener.rb

@@ -0,0 +1,91 @@
+module Trinidad
+  import org.apache.catalina.LifecycleListener
+  import org.apache.catalina.Lifecycle
+
+  class WebAppLifecycleListener
+    include LifecycleListener
+
+    attr_reader :context
+
+    def initialize(webapp)
+      @webapp = webapp
+    end
+
+    def lifecycleEvent(event)
+      if Lifecycle::BEFORE_START_EVENT == event.type
+        init_defaults(event.lifecycle)
+      end
+    end
+
+    def init_defaults(context)
+      @context = context
+
+      deployment_descriptor = configure_deployment_descriptor
+      unless deployment_descriptor
+        configure_rack_servlet
+        configure_rack_listener
+      end
+      configure_init_params
+      configure_context_loader
+    end
+
+    def configure_deployment_descriptor
+      if descriptor = @webapp.default_deployment_descriptor
+        @context.setDefaultWebXml(descriptor)
+
+        context_config = Trinidad::Tomcat::ContextConfig.new
+        context_config.setDefaultWebXml(descriptor)
+
+        @context.addLifecycleListener(context_config)
+      end
+      descriptor
+    end
+
+    def configure_rack_servlet
+      wrapper = @context.create_wrapper
+      wrapper.servlet_class = @webapp.servlet[:class]
+      wrapper.name = @webapp.servlet[:name]
+
+      @context.add_child(wrapper)
+      @context.add_servlet_mapping('/*', wrapper.name)
+    end
+
+    def configure_rack_listener
+      @context.addApplicationListener(@webapp.rack_listener)
+    end
+
+    def configure_init_params
+      @webapp.init_params.each do |name, value|
+        @context.addParameter(name, value)
+      end
+    end
+
+    def configure_context_loader
+      class_loader = @webapp.class_loader
+
+      add_application_jars(class_loader)
+      add_application_java_classes(class_loader)
+
+      loader = Trinidad::Tomcat::WebappLoader.new(class_loader)
+      loader.container = @context
+      @context.loader = loader
+    end
+
+    def add_application_jars(class_loader)
+      return unless @webapp.libs_dir
+
+      resources_dir = File.join(@webapp.web_app_dir, @webapp.libs_dir, '**', '*.jar')
+
+      Dir[resources_dir].each do |resource|
+        class_loader.addURL(java.io.File.new(resource).to_url)
+      end
+    end
+
+    def add_application_java_classes(class_loader)
+      return unless @webapp.classes_dir
+
+      resources_dir = File.join(@webapp.web_app_dir, @webapp.classes_dir)
+      class_loader.addURL(java.io.File.new(resources_dir).to_url)
+    end
+  end
+end

data/lib/trinidad.rb

@@ -11,10 +11,12 @@ require 'trinidad/extensions'
 require 'trinidad/command_line_parser'
 require 'trinidad/jars'
 require 'trinidad/server'
+require 'trinidad/web_app_lifecycle_listener'
 require 'trinidad/web_app'
 require 'trinidad/rails_web_app'
 require 'trinidad/rackup_web_app'
 
+
 module Trinidad
   VERSION = File.read(File.expand_path('../../VERSION', __FILE__))
   TOMCAT_VERSION = '6.0.26'

data/spec/fixtures/trinidad_foo_extension.rb

@@ -2,7 +2,7 @@ module Trinidad
   module Extensions
     class FooWebAppExtension < WebAppExtension
       def configure(tomcat, app_context)
-        @options
+        app_context.doc_base = 'foo_app_extension' if app_context
       end
     end
 

data/spec/trinidad/extensions_spec.rb

@@ -37,4 +37,22 @@ describe Trinidad::Extensions do
     extended = Trinidad::Extensions.configure_server_extensions(extensions, tomcat)
     extended.should_not equal(tomcat)
   end
+
+  it "ignores extensions that don't exist for that scope" do
+    extensions = {:override_tomcat => {}}
+    tomcat = Trinidad::Tomcat::Tomcat.new
+
+    lambda {
+      Trinidad::Extensions.configure_webapp_extensions(extensions, tomcat, nil)
+    }.should_not raise_error
+  end
+
+  it "raises an error when the extension doesn't exist" do
+    extensions = {:foo_bar => {}}
+    tomcat = Trinidad::Tomcat::Tomcat.new
+
+    lambda {
+      Trinidad::Extensions.configure_webapp_extensions(extensions, tomcat, nil)
+    }.should raise_error
+  end
 end

data/spec/trinidad/fakeapp.rb

@@ -17,8 +17,71 @@ EOF
 EOF
   end
 
+  def create_rails_web_xml
+    @rails_web_xml ||= config_file 'config/web.xml', <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app>
+    <servlet>
+        <servlet-name>RackServlet</servlet-name>
+        <servlet-class>org.jruby.rack.RackServlet</servlet-class>
+    </servlet>
+
+    <servlet-mapping>
+        <servlet-name>RackServlet</servlet-name>
+        <url-pattern>/*</url-pattern>
+    </servlet-mapping>
+
+    <listener>
+      <listener-class>org.jruby.rack.rails.RailsServletContextListener</listener-class>
+    </listener>
+
+</web-app>
+EOF
+  end
+
+  def create_rackup_web_xml
+    @rackup_web_xml ||= config_file 'config/web.xml', <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app>
+    <context-param>
+      <param-name>jruby.min.runtimes</param-name>
+      <param-value>1<param-value>
+    </context-param>
+
+    <context-param>
+      <param-name>jruby.max.runtimes</param-name>
+      <param-value>1</param-value>
+    </context-param>
+
+    <servlet>
+        <servlet-name>RackServlet</servlet-name>
+        <servlet-class>org.jruby.rack.RackServlet</servlet-class>
+    </servlet>
+
+    <servlet-mapping>
+        <servlet-name>RackServlet</servlet-name>
+        <url-pattern>/*</url-pattern>
+    </servlet-mapping>
+
+    <listener>
+      <listener-class>org.jruby.rack.RackServletContextListener</listener-class>
+    </listener>
+
+</web-app>
+EOF
+  end
+
+  def create_rackup_file
+    @rackup ||= config_file 'config/config.ru', <<-EOF
+require 'rubygems'
+require 'sinatra'
+
+run App
+EOF
+  end
+
   private 
-  def config_file(path, options)
-    File.open(path, 'w') {|io| io.write(options) }
+  def config_file(path, content)
+    File.open(path, 'w') {|io| io.write(content) }
   end
 end

data/spec/trinidad/server_spec.rb

@@ -12,47 +12,49 @@ describe Trinidad::Server do
 
   it "enables catalina naming" do
     Trinidad::Server.new
-    JSystem.getProperty(JContext.URL_PKG_PREFIXES).should  include("org.apache.naming")
-    JSystem.getProperty(JContext.INITIAL_CONTEXT_FACTORY).should == "org.apache.naming.java.javaURLContextFactory"
-    JSystem.getProperty("catalina.useNaming").should == "true"
+    JSystem.get_property(JContext.URL_PKG_PREFIXES).should  include("org.apache.naming")
+    JSystem.get_property(JContext.INITIAL_CONTEXT_FACTORY).should == "org.apache.naming.java.javaURLContextFactory"
+    JSystem.get_property("catalina.useNaming").should == "true"
   end
 
-  it "should have ssl disabled when config param is nil" do
+  it "disables ssl when config param is nil" do
     server = Trinidad::Server.new
     server.ssl_enabled?.should be_false
   end
 
-  it "should have ajp disabled when config param is nil" do
+  it "disables ajp when config param is nil" do
     server = Trinidad::Server.new
     server.ajp_enabled?.should be_false
   end
 
-  it "should have ssl enabled when config param is a number" do
+  it "enables ssl when config param is a number" do
     server = Trinidad::Server.new({:ssl => {:port => 8443},
       :web_app_dir => MOCK_WEB_APP_DIR})
 
     server.ssl_enabled?.should be_true
   end
 
-  it "should have ajp enabled when config param is a number" do
+  it "enables ajp when config param is a number" do
     server = Trinidad::Server.new({:ajp => {:port => 8009}})
 
     server.ajp_enabled?.should be_true
   end
 
-  it "should have a connector with https scheme" do
+  it "includes a connector with https scheme when ssl is enabled" do
     server = Trinidad::Server.new({:ssl => {:port => 8443},
       :web_app_dir => MOCK_WEB_APP_DIR})
 
-    server.tomcat.service.findConnectors().should have(1).connectors
-    server.tomcat.service.findConnectors()[0].scheme.should == 'https'
+    connectors = server.tomcat.service.find_connectors
+    connectors.should have(1).connector
+    connectors[0].scheme.should == 'https'
   end
 
-  it "should have an ajp connector enabled" do
+  it "includes a connector with protocol AJP when ajp is enabled" do
     server = Trinidad::Server.new({:ajp => {:port => 8009}})
 
-    server.tomcat.service.findConnectors().should have(1).connectors
-    server.tomcat.service.findConnectors()[0].protocol.should == 'AJP/1.3'
+    connectors = server.tomcat.service.find_connectors
+    connectors.should have(1).connector
+    connectors[0].protocol.should == 'AJP/1.3'
   end
 
   it "loads one application for each option present into :web_apps" do
@@ -71,43 +73,86 @@ describe Trinidad::Server do
       }
     })
 
-    context_loaded = server.tomcat.host.findChildren()
+    context_loaded = server.tomcat.host.find_children
     context_loaded.should have(3).web_apps
 
     expected = ['/mock1', '/mock2', '/']
     context_loaded.each do |context|
-      expected.delete(context.getPath()).should == context.getPath()
+      expected.delete(context.path).should == context.path
     end
   end
 
   it "loads the default application from the current directory if :web_apps is not present" do
     server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
 
-    default_context_should_be_loaded(server.tomcat.host.findChildren())
+    default_context_should_be_loaded(server.tomcat.host.find_children)
   end
 
-  it "loads the default application from the current directory using the rackup file if :web_apps is not present" do
+  it "removes default servlets from the application" do
+    server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
+    app = server.tomcat.host.find_child('/')
+
+    app.find_child('default').should be_nil
+    app.find_child('jsp').should be_nil
+
+    app.find_servlet_mapping('*.jsp').should be_nil
+    app.find_servlet_mapping('*.jspx').should be_nil
+
+    app.process_tlds.should be_false
+  end
+
+  it "uses the default HttpConnector when http is not configured" do
+    server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
+    server.http_configured?.should be_false
+
+    server.tomcat.connector.protocol_handler_class_name.should == 'org.apache.coyote.http11.Http11Protocol'
+  end
+
+  it "uses the NioConnector when the http configuration sets nio to true" do
     server = Trinidad::Server.new({
       :web_app_dir => MOCK_WEB_APP_DIR,
-      :rackup => 'config.ru'
+      :http => {:nio => true}
     })
+    server.http_configured?.should be_true
 
-    context = default_context_should_be_loaded(server.tomcat.host.findChildren())
-    context.findParameter('rackup').gsub(/\s+/, ' ').should == "require 'rubygems' require 'sinatra'"
+    server.tomcat.connector.protocol_handler_class_name.should == 'org.apache.coyote.http11.Http11NioProtocol'
   end
 
-  it "removes default servlets from the application" do
+  it "configures NioConnector with http option values" do
+    server = Trinidad::Server.new({
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :http => {
+        :nio => true,
+        'maxKeepAliveRequests' => 4,
+        'socket.bufferPool' => 1000
+      }
+    })
+    connector = server.tomcat.connector
+    connector.get_property('maxKeepAliveRequests').should == 4
+    connector.get_property('socket.bufferPool').should == '1000'
+  end
+  
+  it "adds the WebAppLifecycleListener to each webapp" do
     server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
-    app = server.tomcat.host.find_child('/')
-
-    app.find_child('default').should be_nil
-    app.find_child('jsp').should be_nil
+    app_context = server.tomcat.host.find_child('/')    
+    
+    app_context.find_lifecycle_listeners.map {|l| l.class.name }.should include('Trinidad::WebAppLifecycleListener')
+  end
+  
+  it "loads application extensions from the root of the configuration" do
+    server = Trinidad::Server.new({
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :extensions => { :foo => {} }
+    })
+    
+    app_context = server.tomcat.host.find_child('/')
+    app_context.doc_base.should == 'foo_app_extension'
   end
 
   def default_context_should_be_loaded(children)
     children.should have(1).web_apps
-    children[0].getDocBase().should == MOCK_WEB_APP_DIR
-    children[0].getPath().should == '/'
+    children[0].doc_base.should == MOCK_WEB_APP_DIR
+    children[0].path.should == '/'
     children[0]
   end
 end

data/spec/trinidad/web_app_lifecycle_listener_spec.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/fakeapp'
+
+include FakeApp
+
+# adding accessor for tests
+class Trinidad::WebAppLifecycleListener
+  attr_accessor :context
+end
+
+import org.apache.catalina.Lifecycle
+
+describe Trinidad::WebAppLifecycleListener do
+  before do
+    @mock = mock
+    @mock.stubs(:type).returns(Lifecycle::BEFORE_START_EVENT)
+    @mock.stubs(:lifecycle).returns(Trinidad::Tomcat::StandardContext.new)
+
+    @tomcat = Trinidad::Tomcat::Tomcat.new
+    @tomcat.host.app_base = Dir.pwd
+  end
+
+  it "ignores the event when it's not BEFORE_START_EVENT" do
+    listener = Trinidad::WebAppLifecycleListener.new(nil)
+    @mock.stubs(:type).returns(Lifecycle::BEFORE_STOP_EVENT)
+    lambda {
+      listener.lifecycleEvent(@mock)
+    }.should_not raise_error
+  end
+
+  it "tries to initialize the context when the event is BEFORE_START_EVENT" do
+    listener = Trinidad::WebAppLifecycleListener.new(nil)
+    lambda {
+      listener.lifecycleEvent(@mock)
+    }.should raise_error
+  end
+
+  it "doesn't load a default web xml when the deployment descriptor is not provided" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {}))
+    listener.configure_deployment_descriptor.should be_nil
+  end
+
+  it "loads a default web xml when the deployment descriptor is provided" do
+    FakeFS do
+      create_rails_web_xml
+
+      listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
+        :web_app_dir => Dir.pwd,
+        :default_web_xml => 'config/web.xml'
+      }))
+      listener.context = Trinidad::Tomcat::StandardContext.new
+
+      expected_xml = File.join(Dir.pwd, 'config/web.xml')
+      listener.configure_deployment_descriptor.should == expected_xml
+      listener.context.default_web_xml.should == expected_xml
+
+      listener.context.find_lifecycle_listeners.
+        map {|l| l.class.name }.should include('Java::OrgApacheCatalinaStartup::ContextConfig')
+    end
+  end
+
+  it "adds the rack servlet and the mapping for /*" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {}))
+    listener.context = Trinidad::Tomcat::StandardContext.new
+
+    listener.configure_rack_servlet
+
+    servlet = listener.context.find_child('RackServlet')
+    servlet.should_not be_nil
+    servlet.servlet_class.should == 'org.jruby.rack.RackServlet'
+
+    listener.context.find_servlet_mapping('/*').should == 'RackServlet'
+  end
+
+  it "configures the rack context listener from the web app" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RackupWebApp.new({}, {}))
+    listener.context = Trinidad::Tomcat::StandardContext.new
+    listener.configure_rack_listener
+
+    listener.context.find_application_listeners.should include('org.jruby.rack.RackServletContextListener')
+  end
+
+  it "adds context parameters from the web app" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
+      :jruby_min_runtimes => 1
+    }))
+    listener.context = Trinidad::Tomcat::StandardContext.new
+    listener.configure_init_params
+
+    listener.context.find_parameter('jruby.min.runtimes').should == '1'
+  end
+
+  it "ignores parameters already present in the deployment descriptor" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
+      :jruby_max_runtimes => 1,
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :default_web_xml => 'config/web.xml'
+    }))
+    listener.init_defaults(@tomcat.add_webapp('/', Dir.pwd))
+
+    listener.context.find_parameter('jruby.max.runtimes').should be_nil
+    listener.context.start
+    listener.context.find_parameter('jruby.max.runtimes').should == '8'
+  end
+
+  it "doesn't load classes into a jar when the libs directory is not present" do
+    web_app = Trinidad::RailsWebApp.new({}, {})
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.add_application_jars(web_app.class_loader)
+
+    lambda {
+      web_app.class_loader.find_class('org.ho.yaml.Yaml')
+    }.should raise_error
+  end
+
+  it "loads classes into a jar when the libs directory is provided" do
+    web_app = Trinidad::RailsWebApp.new({}, {
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :libs_dir => 'lib'
+    })
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.add_application_jars(web_app.class_loader)
+
+    lambda {
+      web_app.class_loader.find_class('org.ho.yaml.Yaml').should_not be_nil
+    }.should_not raise_error
+  end
+
+  it "doesn't load java classes when the classes directory is not present" do
+    web_app = Trinidad::RailsWebApp.new({}, {})
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.add_application_java_classes(web_app.class_loader)
+
+    lambda {
+      web_app.class_loader.find_class('HelloTomcat')
+    }.should raise_error
+  end
+
+  it "loads java classes when the classes directory is provided" do
+    web_app = Trinidad::RailsWebApp.new({}, {
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :classes_dir => 'classes'
+    })
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.add_application_java_classes(web_app.class_loader)
+
+    lambda {
+      web_app.class_loader.find_class('HelloTomcat').should_not be_nil
+    }.should_not raise_error
+  end
+
+  it "creates a WebappLoader with the JRuby class loader" do
+    web_app = Trinidad::RailsWebApp.new({}, {})
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.context = Trinidad::Tomcat::StandardContext.new
+    listener.configure_context_loader
+
+    loader = listener.context.loader
+
+    loader.should be_instance_of(Java::OrgApacheCatalinaLoader::WebappLoader)
+  end
+
+  it "loads the default application from the current directory using the rackup file if :web_apps is not present" do
+    web_app = Trinidad::RackupWebApp.new({
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :rackup => 'config.ru'
+    }, {})
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.context = Trinidad::Tomcat::StandardContext.new
+    listener.configure_init_params
+
+    listener.context.find_parameter('rackup').should == "require 'rubygems'\nrequire 'sinatra'"
+  end
+end

data/spec/trinidad/web_app_spec.rb

@@ -1,144 +1,133 @@
 require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/fakeapp'
 
-describe Trinidad::WebApp do
-  before do
-    @tomcat = Trinidad::Tomcat::Tomcat.new
-    @tomcat.host.app_base = Dir.pwd
-    @tomcat_web_app = @tomcat.addWebapp('/', File.dirname(__FILE__) + '/../../')
-
-    @app = {
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :context_path => '/'
-    }
-    @config = {
-      :libs_dir => 'lib',
-      :classes_dir => 'classes',
-      :default_web_xml => 'config/web.xml',
-      :jruby_min_runtimes => 2,
-      :jruby_max_runtimes => 6,
-      :web_apps => {
-        :default => @app
-      }
-    }
-    @web_app = Trinidad::RailsWebApp.new(@tomcat_web_app, @config, @app)
-  end
+include FakeApp
 
+describe Trinidad::WebApp do
   it "creates a RailsWebApp if rackup option is not present" do
-    app = Trinidad::WebApp.create(@tomcat_web_app, @config, @app)
+    app = Trinidad::WebApp.create({}, {})
     app.should be_an_instance_of(Trinidad::RailsWebApp)
   end
 
   it "creates a RackupWebApp if rackup option is present" do
-    rackup_app = {:rackup => 'config.ru'}
-    @config.deep_merge({:web_apps => {:default => rackup_app}})
-    app = Trinidad::WebApp.create(@tomcat_web_app, @config, rackup_app)
+    app = Trinidad::WebApp.create({}, {:rackup => 'config.ru'})
     app.should be_an_instance_of(Trinidad::RackupWebApp)
   end
 
-  it "should load custom jars" do 
-    class_loader = org.jruby.util.JRubyClassLoader.new(JRuby.runtime.jruby_class_loader)
-    @web_app.add_application_libs(class_loader)
+  it "ignores rack_servlet when a deployment descriptor already provides it" do
+    FakeFS do
+      create_rails_web_xml
 
-    resource = class_loader.find_class('org.ho.yaml.Yaml')
-    resource.should_not be_nil
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :default_web_xml => 'config/web.xml'
+      })
+      app.servlet.should be_nil
+    end
   end
 
-  it "should load custom classes" do
-    class_loader = org.jruby.util.JRubyClassLoader.new(JRuby.runtime.jruby_class_loader)
-    @web_app.add_application_classes(class_loader)
+  it "ignores rack_listener when a deployment descriptor already provides it" do
+    FakeFS do
+      create_rails_web_xml
 
-    resource = class_loader.find_class('HelloTomcat')
-    resource.should_not be_nil
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :default_web_xml => 'config/web.xml'
+      })
+      app.rack_listener.should be_nil
+    end
   end
 
-  it "should start application context without errors" do
-    start_context
+  it "uses rack_servlet as the default servlet when a deployment descriptor is not provided" do
+    app = Trinidad::WebApp.create({}, {})
+    app.servlet.should_not be_nil
+    app.servlet[:name].should == 'RackServlet'
+    app.servlet[:class].should == 'org.jruby.rack.RackServlet'
   end
 
-  it "should add a filter from the default web.xml" do
-    start_context_with_web_xml
-    @web_app.context.findFilterDefs().should have(1).filters
+  it "uses rack_listener as the default listener when a deployment descriptor is not provided" do
+    app = Trinidad::WebApp.create({}, {})
+    app.rack_listener.should == 'org.jruby.rack.rails.RailsServletContextListener'
   end
 
-  it "shouldn't duplicate init params" do
-    start_context_with_web_xml
-    lambda { @web_app.add_init_params }.should_not raise_error
+  it "loads the context parameters from the configuration when a deployment descriptor is not provided" do
+    app = Trinidad::WebApp.create({}, {
+      :jruby_min_runtimes => 1,
+      :jruby_max_runtimes => 1,
+      :public => 'foo',
+      :environment => :production
+    })
+    parameters = app.init_params
+    parameters['jruby.min.runtimes'].should == '1'
+    parameters['jruby.initial.runtimes'].should == '1'
+    parameters['jruby.max.runtimes'].should == '1'
+    parameters['public.root'].should == '/foo'
+    parameters['rails.env'].should == 'production'
+    parameters['rails.root'].should == '/'
   end
 
-  it "loads init params from configuration root" do
-    @web_app.add_init_params
+  it "adds the rackup script as a context parameter when it's provided" do
+    FakeFS do
+      create_rackup_file
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :rackup => 'config/config.ru'
+      })
 
-    @web_app.context.findParameter('jruby.min.runtimes').should == '2'
-    @web_app.context.findParameter('jruby.max.runtimes').should == '6'
+      parameters = app.init_params
+      parameters['rackup'].should =~ /run App/
+    end
   end
 
-  it 'loads init params from application node' do
-    @app[:jruby_min_runtimes] = 4
-    @app[:jruby_max_runtimes] = 8
-    @config[:web_apps][:default] = @app
+  it "ignores parameters from configuration when the deployment descriptor already contains them" do
+    FakeFS do
+      create_rackup_web_xml
 
-    web_app = Trinidad::WebApp.create(@tomcat_web_app, @config, @app)
-    web_app.add_init_params
-
-    web_app.context.findParameter('jruby.min.runtimes').should == '4'
-    web_app.context.findParameter('jruby.max.runtimes').should == '8'
-  end
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :default_web_xml => 'config/web.xml',
+        :jruby_min_runtimes => 2,
+        :jruby_max_runtimes => 5
+      })
+      parameters = app.init_params
 
-  it "configures rack handler" do
-    @web_app.configure_rack
-    @web_app.context.findChild('RackServlet').should_not be_nil
+      parameters['jruby.min.runtimes'].should be_nil
+      parameters['jruby.max.runtimes'].should be_nil
+    end
   end
 
-  it "configures rack listener" do
-    @web_app.add_rack_context_listener
-    @web_app.context.findApplicationListeners().should have(1).listeners
-  end
-
-  it "has rack handler already configured when web.xml includes it" do
-    @web_app.load_default_web_xml
-    @web_app.rack_configured?().should  be_true
-
-    @web_app.configure_rack
-    @web_app.context.findChild('RackServlet').should be_nil
-  end
-
-  it "has rack listener already configured when web.xml includes it" do
-    @web_app.load_default_web_xml
-    @web_app.rack_listener_configured?().should be_true
-
-    @web_app.add_rack_context_listener
-    @web_app.context.findApplicationListeners().should have(0).listeners
-  end
-
-  it "loads the provided web.xml for rails applications" do
-    @config[:default_web_xml] = 'config/foo.xml'
-    app = Trinidad::WebApp.create(@tomcat_web_app, @config, @app)
-
-    app.load_default_web_xml
-    app.context.default_web_xml.should =~ /rails_web.xml$/
-  end
-
-  it "loads the provided web.xml for rack applications" do
-    @config[:default_web_xml] = 'config/foo.xml'
-    @app[:rackup] = 'config.ru'
-
-    app = Trinidad::WebApp.create(@tomcat_web_app, @config, @app)
-    app.load_default_web_xml
-    app.context.default_web_xml.should =~ /rackup_web.xml$/
+  it "ignores the deployment descriptor when it doesn't exist" do
+    app = Trinidad::WebApp.create({}, {
+      :web_app_dir => Dir.pwd,
+      :default_web_xml => 'config/web.xml'
+    })
+    app.default_deployment_descriptor.should be_nil
   end
 
-  def start_context_with_web_xml
-    @web_app.load_default_web_xml
-    start_context
+  it "doesn't load any web.xml when the deployment descriptor doesn't exist" do
+    app = Trinidad::WebApp.create({}, {
+      :web_app_dir => Dir.pwd,
+      :default_web_xml => 'config/web.xml'
+    })
+    app.rack_servlet_configured?.should be_false
+    app.rack_listener_configured?.should be_false
   end
 
-  def start_context
-    load_tomcat_libs
-    lambda { @web_app.context.start }.should_not raise_error
+  it "uses `public` as default public root directory" do
+    app = Trinidad::WebApp.create({}, {})
+    app.public_root.should == 'public'
+  end
+
+  it "uses extensions from the global configuration" do
+    config = { :extensions => {:hotdeploy => {}} }
+    app = Trinidad::WebApp.create(config, {})
+    app.extensions.should include(:hotdeploy)
   end
 
-  def load_tomcat_libs
-    @web_app.config[:libs_dir] = File.join(File.dirname(__FILE__), '..', '..', 'tomcat-libs')
-    @web_app.add_context_loader
+  it "overrides global extensions with application extensions" do
+    config = { :extensions => {:hotdeploy => {}} }
+    app_config = { :extensions => {:hotdeploy => {:delay => 30000}} }
+    app = Trinidad::WebApp.create(config, app_config)
+    app.extensions[:hotdeploy].should include(:delay)
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 0
-  version: 0.9.0
+  - 1
+  version: 0.9.1
 platform: ruby
 authors: 
 - David Calavera
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-28 00:00:00 +02:00
+date: 2010-05-09 00:00:00 +02:00
 default_executable: trinidad
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -111,12 +111,11 @@ files:
 - lib/trinidad/command_line_parser.rb
 - lib/trinidad/core_ext.rb
 - lib/trinidad/extensions.rb
-- lib/trinidad/rackup_web.xml
 - lib/trinidad/rackup_web_app.rb
-- lib/trinidad/rails_web.xml
 - lib/trinidad/rails_web_app.rb
 - lib/trinidad/server.rb
 - lib/trinidad/web_app.rb
+- lib/trinidad/web_app_lifecycle_listener.rb
 has_rdoc: true
 homepage: http://calavera.github.com/trinidad
 licenses: []
@@ -155,4 +154,5 @@ test_files:
 - spec/trinidad/extensions_spec.rb
 - spec/trinidad/fakeapp.rb
 - spec/trinidad/server_spec.rb
+- spec/trinidad/web_app_lifecycle_listener_spec.rb
 - spec/trinidad/web_app_spec.rb

data/lib/trinidad/rackup_web.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<web-app>
-    <servlet>
-        <servlet-name>RackServlet</servlet-name>
-        <servlet-class>org.jruby.rack.RackServlet</servlet-class>
-    </servlet>
-
-    <servlet-mapping>
-        <servlet-name>RackServlet</servlet-name>
-        <url-pattern>/*</url-pattern>
-    </servlet-mapping>
-
-    <listener>
-      <listener-class>org.jruby.rack.RackServletContextListener</listener-class>
-    </listener>
-
-</web-app>

data/lib/trinidad/rails_web.xml

@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<web-app>
-    <servlet>
-        <servlet-name>RackServlet</servlet-name>
-        <servlet-class>org.jruby.rack.RackServlet</servlet-class>
-    </servlet>
-
-    <servlet-mapping>
-        <servlet-name>RackServlet</servlet-name>
-        <url-pattern>/*</url-pattern>
-    </servlet-mapping>
-
-    <listener>
-      <listener-class>org.jruby.rack.rails.RailsServletContextListener</listener-class>
-    </listener>
-
-</web-app>