trinidad 1.4.1 → 1.4.3

data/lib/trinidad/command_line_parser.rb

@@ -29,7 +29,7 @@ module Trinidad
 
     # Load the configuration from the given options and return it.
     def load!(options)
-      config = config_file(options[:web_app_dir])
+      config = config_file(options[:root_dir] || options[:web_app_dir])
       if config && File.exist?(config)
         if yaml = (File.extname(config) == '.yml')
           require 'yaml'; require 'erb'
@@ -45,10 +45,12 @@ module Trinidad
     end
     alias_method :load_configuration, :load!
 
+    DEFAULT_CONFIG_FILE = 'config/trinidad.{yml,rb}'
+    
     def config_file(base_dir = nil)
       base_dir ||= Dir.pwd
       if @config_file.nil? # false means do not use no config file
-        Dir.glob(File.join(base_dir, 'config', 'trinidad.{yml,rb}')).first
+        Dir.glob(File.join(base_dir, DEFAULT_CONFIG_FILE)).first
       else
         @config_file && File.expand_path(@config_file, base_dir)
       end
@@ -59,79 +61,86 @@ module Trinidad
     def options_parser
       require 'optparse'
       @parser ||= OptionParser.new do |opts|
-        opts.banner = 'Trinidad server default options:'
+        opts.banner = 'Usage: trinidad [server options]'
         opts.separator ''
 
-        opts.on('-d', '--dir WEB_APP_DIRECTORY', 'web app directory path',
-            "default: #{Dir.pwd}") do |dir|
-          default_options[:web_app_dir] = dir
+        opts.on('-d', '--dir ROOT_DIR', 'web application root directory',
+          "default: current working directory") do |dir|
+          default_options[:root_dir] = dir
         end
 
-        opts.on('-e', '--env ENVIRONMENT', '(rails) environment',
-            "default: #{default_options[:environment]}") do |env|
+        opts.on('-e', '--env ENVIRONMENT', 'rack (rails) environment', 
+          "default: #{default(:environment)}") do |env|
           default_options[:environment] = env
         end
-
-        opts.on('-p', '--port PORT', 'port to bind to',
-            "default: #{default_options[:port]}") do |port|
-          default_options[:port] = port
+        
+        opts.on('-r', '--rackup [RACKUP_FILE]', 'rackup configuration file',
+          "default: config.ru") do |rackup|
+          default_options[:rackup] = rackup || 'config.ru'
         end
 
+        opts.on('--public', '--public PUBLIC_DIR', 'web application public root', 
+          "default: #{default(:public)}") do |public|
+          default_options[:public] = public
+        end
+        
         opts.on('-c', '--context CONTEXT_PATH', 'application context path',
-            "default: #{default_options[:context_path]}") do |path|
+          "default: #{default(:context_path)}") do |path|
           default_options[:context_path] = path
         end
-
-        opts.on('--lib', '--jars LIBS_DIR', 'directory containing java jars used by the application',
-            "default: #{default_options[:libs_dir]}") do |dir|
-          default_options[:libs_dir] = dir
-        end
-
-        opts.on('--classes', '--classes CLASSES_DIR', 'directory containing java classes used by the application',
-            "default: #{default_options[:classes_dir]}") do |dir|
-          default_options[:classes_dir] = dir
+        
+        opts.on('--monitor', '--monitor MONITOR_FILE', 'monitor for application re-deploys', 
+          "default: tmp/restart.txt") do |monitor|
+          default_options[:monitor] = monitor
         end
-
-        opts.on('-s', '--ssl [SSL_PORT]', 'enable secure socket layout',
-            "default port: 8443") do |port|
-          default_options[:ssl] = { :port => (port || 8443).to_i }
+        
+        opts.on('-t', '--threadsafe', 'force thread-safe mode (use single runtime)') do
+          default_options[:jruby_min_runtimes] = 1
+          default_options[:jruby_max_runtimes] = 1
         end
-
-        opts.on('-a', '--ajp [AJP_PORT]', 'enable ajp connections (deprecated)',
-            "default port: 8009") do |port|
-          default_options[:ajp] = { :port => (port || 8009).to_i }
+        
+        opts.on('--runtimes MIN:MAX', 'use given number of min/max jruby runtimes', 
+          "default: #{default(:jruby_min_runtimes)}:#{default(:jruby_max_runtimes)}") do 
+          |min_max| min, max = min_max.split(':')
+          default_options[:jruby_min_runtimes] = min.to_i if min
+          default_options[:jruby_max_runtimes] = max.to_i if max
         end
-
+        
         opts.on('-f', '--config [CONFIG_FILE]', 'configuration file',
-            "default: config/trinidad.{yml,rb}") do |file|
+          "default: #{DEFAULT_CONFIG_FILE}") do |file|
           self.config_file = file
         end
-
-        opts.on('-r', '--rackup [RACKUP_FILE]', 'rackup configuration file',
-            'default: config.ru') do |rackup|
-          default_options[:rackup] = rackup || 'config.ru'
+        
+        opts.on('--address', '--address ADDRESS', 'host address', 
+          "default: #{default(:address)}") do |address|
+          default_options[:address] = address
         end
-
-        opts.on('--public', '--public DIRECTORY', 'public directory', 'default: public') do |public|
-          default_options[:public] = public
+        
+        opts.on('-p', '--port PORT', 'port to bind to', 
+          "default: #{default(:port)}") do |port| 
+          default_options[:port] = port
         end
 
-        opts.on('-t', '--threadsafe', 'force thread-safe mode') do
-          default_options[:jruby_min_runtimes] = 1
-          default_options[:jruby_max_runtimes] = 1
+        opts.on('-s', '--ssl [SSL_PORT]', 'enable secure socket layout',
+          "default port: 8443") do |port|
+          default_options[:ssl] = { :port => (port || 8443).to_i }
         end
 
-        opts.on('--address', '--address ADDRESS', 'host address', 'default: localhost') do |address|
-          default_options[:address] = address
+        opts.on('-a', '--ajp [AJP_PORT]', 'enable the AJP web protocol',
+          "default port: 8009") do |port|
+          default_options[:ajp] = { :port => (port || 8009).to_i }
         end
 
-        opts.on('-g', '--log LEVEL', 'log level', 'default: INFO') do |log|
-          default_options[:log] = log
+        opts.on('--java_lib LIB_DIR', '--lib LIB_DIR (deprecated use --java_lib)', 
+          'contains .jar files used by the app',
+          "default: #{default(:java_lib)}") do |lib|
+          default_options[:java_lib] = lib
         end
 
-        opts.on('-v', '--version', 'display the current version') do
-          puts "trinidad #{Trinidad::VERSION} (tomcat #{Trinidad::TOMCAT_VERSION})"
-          exit
+        opts.on('--java_classes CLASSES_DIR', '--classes CLASSES_DIR (deprecated use --java_classes)', 
+          'contains java classes used by the app',
+          "default: #{default_java_classes}") do |classes|
+          default_options[:java_classes] = classes
         end
 
         opts.on('-l', '--load EXTENSION_NAMES', Array, 'load options for extensions') do |ext_names|
@@ -140,20 +149,37 @@ module Trinidad
           end
         end
 
-        opts.on('--apps', '--apps APPS_BASE_DIR', 'applications base directory') do |path|
-          default_options[:apps_base] = path
+        opts.on('--apps_base APPS_BASE_DIR', '--apps APPS_BASE_DIR (deprecated use --apps_base)', 
+          'set applications base directory') do |apps_base|
+          default_options[:apps_base] = apps_base
         end
-
-        opts.on('--monitor' '--monitor MONITOR_FILE', 'monitor file for hot deployments') do |monitor|
-          default_options[:monitor] = monitor
+        
+        opts.on('-g', '--log LEVEL', 'set logging level') do |log|
+          default_options[:log] = log
         end
         
-        opts.on('-h', '--help', 'display the help') do
+        opts.on('-v', '--version', 'show server version') do
+          puts "Trinidad #{Trinidad::VERSION} (Tomcat #{Trinidad::TOMCAT_VERSION})"
+          exit
+        end
+        
+        opts.on('-h', '--help', 'display this help') do
           puts opts
           exit
         end
       end
     end
     
+    private
+    
+    def default(key)
+      default_options[key] || Configuration::DEFAULTS[key]
+    end
+    
+    def default_java_classes
+      default(:java_classes) || 
+        ( default(:java_lib) && File.join(default(:java_lib), 'classes') )
+    end
+    
   end
 end

data/lib/trinidad/configuration.rb

@@ -9,10 +9,10 @@ module Trinidad
     config = ( self.configuration ||= Configuration.new )
     args.compact!
     if options = args.shift
-      options = Trinidad::Configuration.symbolize_options(options)
+      options = Configuration.symbolize_options(options)
       args.each do |opts|
-        opts = Trinidad::Configuration.symbolize_options(opts)
-        options = Trinidad::Configuration.merge_options(options, opts)
+        opts = Configuration.symbolize_options(opts)
+        options = Configuration.merge_options(options, opts)
       end
       config.update!(options)
     end
@@ -32,20 +32,22 @@ module Trinidad
   # the instance using Trinidad#configuration
   class Configuration
     
+    DEFAULTS = {
+      :port => 3000,
+      :address => 'localhost',
+      :environment => 'development',
+      :context_path => '/',
+      :public => 'public',
+      :java_lib => 'lib/java',
+      :default_web_xml => 'config/web.xml',
+      :jruby_min_runtimes => 1,
+      :jruby_max_runtimes => 5,
+      :log => 'INFO',
+      :trap => true
+    }
+    
     def initialize(options = {})
-      @config = {
-        :port => 3000,
-        :address => 'localhost', 
-        :environment => 'development',
-        :context_path => '/',
-        :libs_dir => 'lib',
-        :classes_dir => 'classes',
-        :default_web_xml => 'config/web.xml',
-        :jruby_min_runtimes => 1,
-        :jruby_max_runtimes => 5,
-        :log => 'INFO',
-        :trap => true
-      }
+      @config = DEFAULTS.clone
       update!(options)
     end
 
@@ -77,15 +79,16 @@ module Trinidad
     end
     
     %w{ port address environment context_path
-        libs_dir classes_dir default_web_xml
-        jruby_min_runtimes jruby_max_runtimes
-        rackup servlet public hosts
+        java_lib libs_dir java_classes classes_dir default_web_xml
+        jruby_min_runtimes jruby_max_runtimes jruby_compat_version
+        rackup servlet rack_servlet default_servlet public hosts
         http ajp ssl extensions
         apps_base web_apps web_app_dir
-        monitor log trap }.each do |method|
+        monitor reload_strategy log trap }.each do |method|
       class_eval "def #{method}; self[:'#{method}']; end"
       class_eval "def #{method}=(value); self[:'#{method}'] = value; end"
     end
+    # TODO #deprecate libs_dir classes_dir servlet
     
     # a Hash like #symbolize helper
     def self.symbolize_options(options, deep = true)

data/lib/trinidad/lifecycle/host.rb

@@ -1,3 +1,5 @@
+require 'trinidad/lifecycle/base'
+
 module Trinidad
   module Lifecycle
     # A host lifecycle listener - monitors deployed web apps.

data/lib/trinidad/lifecycle/web_app/default.rb

@@ -1,3 +1,6 @@
+require 'trinidad/lifecycle/base'
+require 'trinidad/lifecycle/web_app/shared'
+
 module Trinidad
   module Lifecycle
     module WebApp
@@ -14,47 +17,65 @@ module Trinidad
           configure_context_params(context)
           configure_context_loader(context)
         end
-
+        
+        def before_init(event)
+          super
+          set_context_xml event.lifecycle
+          # AFTER_INIT_EVENT ContextConfig#init() will pick this up
+        end
+        
         protected
         
+        @@_add_context_config = true # due backward compatibility
+        
         def configure_deployment_descriptor(context)
-          if descriptor = web_app.deployment_descriptor
+          descriptor = web_app.deployment_descriptor
+          if descriptor && File.exist?(descriptor)
             listeners = context.findLifecycleListeners
             context_config = listeners && listeners.find do |listener|
               listener.is_a?(Trinidad::Tomcat::ContextConfig)
             end
 
-            unless context_config
-              context_config = Trinidad::Tomcat::ContextConfig.new
-              context.addLifecycleListener(context_config)
+            if context_config.nil?
+              if @@_add_context_config
+                context_config = Trinidad::Tomcat::ContextConfig.new
+                context.addLifecycleListener(context_config)
+              else
+                raise "initialized context is missing a ContextConfig listener"
+              end
             end
 
             context_config.setDefaultWebXml(descriptor)
+            descriptor
           end
-          descriptor
         end
 
         def configure_rack_servlet(context)
           wrapper = context.create_wrapper
-          if web_app.rack_servlet[:instance]
-            wrapper.servlet = web_app.rack_servlet[:instance]
+          rack_servlet = web_app.rack_servlet
+          if rack_servlet[:instance]
+            wrapper.servlet = rack_servlet[:instance]
           else
-            wrapper.servlet_class = web_app.rack_servlet[:class]
-            wrapper.async_supported = web_app.rack_servlet[:async_supported]
+            wrapper.servlet_class = rack_servlet[:class]
+            wrapper.async_supported = rack_servlet[:async_supported]
+            wrapper.load_on_startup = rack_servlet[:load_on_startup]
+            add_init_params wrapper, rack_servlet[:init_params]
           end
-          wrapper.name = web_app.rack_servlet[:name]
+          name = wrapper.name = rack_servlet[:name]
 
           context.add_child(wrapper)
-          context.add_servlet_mapping('/*', wrapper.name)
+          add_servlet_mapping(context, rack_servlet[:mapping], name)
         end
 
         def configure_rack_listener(context)
-          context.addApplicationListener(web_app.rack_listener) unless web_app.rack_servlet[:instance]
+          unless web_app.rack_servlet[:instance]
+            context.add_application_listener(web_app.rack_listener)
+          end
         end
 
         def configure_context_params(context)
           web_app.context_params.each do |name, value|
-            context.addParameter(name, value)
+            context.add_parameter(name, value)
           end
         end
         # @deprecated use {#configure_context_params}
@@ -63,28 +84,41 @@ module Trinidad
         def configure_context_loader(context)
           class_loader = web_app.class_loader
 
-          add_application_jars(class_loader)
           add_application_java_classes(class_loader)
+          add_application_jars(class_loader) # classes takes precedence !
 
           loader = Trinidad::Tomcat::WebappLoader.new(class_loader)
           context.loader = loader # does loader.container = context
         end
 
         def add_application_jars(class_loader)
-          return unless web_app.libs_dir
-
-          resources_dir = File.join(web_app.web_app_dir, web_app.libs_dir, '**', '*.jar')
-
-          Dir[resources_dir].each do |resource|
-            class_loader.addURL(java.io.File.new(resource).to_url)
+          return unless lib_dir = web_app.java_lib_dir
+          Dir[ File.join(lib_dir, "**/*.jar") ].each do |jar|
+            logger.debug "[#{web_app.context_path}] adding jar: #{jar}"
+            class_loader.addURL java.io.File.new(jar).to_url
           end
         end
 
         def add_application_java_classes(class_loader)
-          return unless web_app.classes_dir
-
-          resources_dir = File.join(web_app.web_app_dir, web_app.classes_dir)
-          class_loader.addURL(java.io.File.new(resources_dir).to_url)
+          return unless classes_dir = web_app.java_classes_dir
+          class_loader.addURL java.io.File.new(classes_dir).to_url
+        end
+        
+        def set_context_xml(context)
+          # behave similar to a .war - checking /META-INF/context.xml on CP
+          context_xml = web_app.context_xml
+          context_xml = 'META-INF/context.xml' if context_xml.nil?
+          if context_xml
+            # NOTE: make it absolute to ContextConfig to not use a baseDir :
+            unless java.io.File.new(context_xml).absolute?
+              if web_app.java_classes_dir
+                context_xml = File.join(web_app.java_classes_dir, context_xml)
+              else
+                context_xml = File.expand_path(context_xml, web_app.root_dir)
+              end
+            end
+            context.setDefaultContextXml(context_xml)
+          end
         end
         
       end

data/lib/trinidad/lifecycle/web_app/shared.rb

@@ -17,37 +17,138 @@ module Trinidad
           super
           configure(event.lifecycle)
         end
-
+        
         # Configure the web application before it's started.
         def configure(context)
+          adjust_context(context)
           remove_defaults(context)
+          configure_default_servlet(context)
+          configure_jsp_servlet(context)
           configure_logging(context)
         end
 
         protected
-
+        
+        def adjust_context(context)
+          context.name = web_app.context_name if web_app.context_name
+          context.doc_base = web_app.doc_base if web_app.doc_base
+          context.work_dir = web_app.work_dir if web_app.work_dir
+          context.aliases  = web_app.aliases  if web_app.aliases
+          
+          context.caching_allowed = web_app.caching_allowed?
+          context.cache_ttl = web_app.cache_ttl if web_app.cache_ttl
+          if max_size = web_app.cache_max_size
+            context.cache_max_size = max_size
+          end
+          if object_max_size = web_app.cache_object_max_size
+            context.cache_object_max_size = object_max_size
+          end
+        end
+        
+        def configure_default_servlet(context)
+          configure_builtin_servlet(context, 
+            web_app.default_servlet, 
+            Trinidad::WebApp::DEFAULT_SERVLET_NAME
+          )
+        end
+        
+        def configure_jsp_servlet(context)
+          wrapper = configure_builtin_servlet(context, 
+            web_app.jsp_servlet, 
+            Trinidad::WebApp::JSP_SERVLET_NAME
+          )
+          if wrapper == false # jsp servlet removed
+            context.process_tlds = false
+          end
+          wrapper
+        end
+        
         def configure_logging(context)
           Trinidad::Logging.configure_web_app(web_app, context)
         end
-
+        
         private
 
+        def configure_builtin_servlet(context, servlet_config, name)
+          name_wrapper = context.find_child(name)
+          case servlet_config
+          when true
+            return true # nothing to do leave built-in servlet as is
+          when false
+            # remove what Tomcat set-up (e.g. use one from web.xml)
+            remove_servlet_mapping(context, name)
+            context.remove_child(name_wrapper)
+            return false
+          else
+            wrapper, name = name_wrapper, name
+            if servlet = servlet_config[:instance]
+              wrapper = context.create_wrapper
+              wrapper.name = name = servlet_config[:name] || name
+              wrapper.servlet = servlet
+              context.remove_child(name_wrapper)
+              context.add_child(wrapper)
+            elsif servlet_class = servlet_config[:class]
+              wrapper.servlet_class = servlet_class
+            end
+            # do not remove wrapper but only "update" the default :
+            wrapper.load_on_startup = ( servlet_config[:load_on_startup] || 
+                name_wrapper.load_on_startup ).to_i
+            add_init_params(wrapper, servlet_config[:init_params])
+            if mapping = servlet_config[:mapping]
+              # NOTE: we override the default mapping :
+              remove_servlet_mapping(context, name)
+              add_servlet_mapping(context, mapping, name)
+              # else keep the servlet mapping as is ...
+            end
+            wrapper
+          end
+        end
+        
         def remove_defaults(context)
-          context.remove_welcome_file('index.jsp')
           context.remove_welcome_file('index.htm')
           context.remove_welcome_file('index.html')
-
-          jsp_servlet = context.find_child('jsp')
-          context.remove_child(jsp_servlet) if jsp_servlet
-
-          context.remove_servlet_mapping('*.jspx')
-          context.remove_servlet_mapping('*.jsp')
-
-          context.process_tlds = false
-          context.xml_validation = false
+          context.remove_welcome_file('index.jsp')
+        end
+        
+        def add_init_params(wrapper, params)
+          return unless params
+          params.each do |param, value|
+            val = value.to_s unless value.nil?
+            wrapper.add_init_parameter(param.to_s, val)
+          end
+        end
+        
+        def add_servlet_mapping(context, mapping, name)
+          if mapping.is_a?(String) || mapping.is_a?(Symbol) 
+            context.add_servlet_mapping(mapping.to_s, name)
+          else
+            mapping.each { |m| add_servlet_mapping(context, m, name) }
+          end
+        end
+        
+        # Remove all servlet mappings for given (servlet) name.
+        def remove_servlet_mapping(context, name)
+          find_servlet_mapping(context, name).each do
+            |pattern| context.remove_servlet_mapping(pattern)
+          end
+        end
+        
+        # Find all servlet mappings for given (servlet) name.
+        def find_servlet_mapping(context, name)
+          name_mapping = []
+          context.find_servlet_mappings.each do |pattern|
+            mapping_for = context.find_servlet_mapping(pattern)
+            name_mapping << pattern if mapping_for == name
+          end
+          name_mapping
+        end
+        
+        def logger
+          @logger ||= Trinidad::Logging::LogFactory.
+            getLog('org.apache.catalina.core.StandardContext')
         end
         
       end
-    end 
+    end
   end
 end