trinidad 1.4.3 → 1.4.4

data/History.txt

@@ -1,3 +1,20 @@
+== Trinidad 1.4.4 (2012-10-19)
+
+* make sure setting FileHandler's rotatable to false works (#82)
+* first draft for web-app logging configuration to avoid use hacks e.g. 
+  for disabling rotation (this feature is not yet official and might change)
+* fix new lines (ala default Rails.logger) in console output
+* set correct (JRuby-Rack) layout for web apps and use app.root 
+  (besides rails.root)
+* check whether (jruby.) params are specified in system properties (#92)
+* fix JUL::ConsoleHandler - not setting up JRuby streams correctly (#88)
+
+== Trinidad_jars 1.1.1 (2012-10-17)
+
+* Tomcat 7.0.32 http://tomcat.apache.org/tomcat-7.0-doc/changelog.html
+* avoid using the "global" (and redundant) TRINIDAD_LIBS constant
+* load the .jar files instead of requiring them (no more $: polution)
+
 == Trinidad 1.4.3 (2012-09-20)
 
 * allow to keep (and configure) the jsp servlet (support for serving .jsp pages)

data/README.md

@@ -235,7 +235,7 @@ This monitor file can be customized with the `monitor` configuration option.
 Since version **1.4.0** Trinidad supports 2 reload strategies :
 
 * **restart** (default) synchronous reloading (exposed by Tomcat). This strategy
-  pauses incoming requests while it reloads the application and than serves them
+  pauses incoming requests while it reloads the application and then serves them
   once ready (or timeouts if it takes too long). It has been chosen as the default
   strategy since **1.4.0** due it's more predictable memory requirements.
 

data/lib/trinidad/configuration.rb

@@ -40,8 +40,10 @@ module Trinidad
       :public => 'public',
       :java_lib => 'lib/java',
       :default_web_xml => 'config/web.xml',
-      :jruby_min_runtimes => 1,
-      :jruby_max_runtimes => 5,
+      :jruby_min_runtimes => 
+        java.lang.System.getProperty('jruby.min.runtimes') || 1,
+      :jruby_max_runtimes => 
+        java.lang.System.getProperty('jruby.max.runtimes') || 5,
       :log => 'INFO',
       :trap => true
     }
@@ -110,6 +112,7 @@ module Trinidad
     
     # a Hash like deep_merge helper
     def self.merge_options(target, current, deep = true)
+      return target unless current
       target_dup = target.dup
       current.keys.each do |key|
         target_dup[key] = 

data/lib/trinidad/logging.rb

@@ -15,13 +15,11 @@ module Trinidad
       
       root_logger = JUL::Logger.getLogger('')
       level = parse_log_level(log_level, :INFO)
-
-      out_handler  = JUL::ConsoleHandler.new
-      out_handler.setOutputStream JRuby.runtime.out
+      
+      out_handler = new_console_handler JRuby.runtime.out
       out_handler.formatter = console_formatter
 
-      err_handler  = JUL::ConsoleHandler.new
-      err_handler.setOutputStream JRuby.runtime.err
+      err_handler = new_console_handler JRuby.runtime.err
       err_handler.formatter = console_formatter
       err_handler.level = level.intValue > JUL::Level::WARNING.intValue ?
         level : JUL::Level::WARNING # only >= WARNING on STDERR
@@ -69,16 +67,24 @@ module Trinidad
       logger = JUL::Logger.getLogger(logger_name) # exclusive for web app
       # avoid duplicate calls - do not configure our FileHandler twice :
       return false if logger.handlers.find { |h| h.is_a?(FileHandler) }
-      level = parse_log_level(web_app.log, nil)
-      logger.level = level # inherits level from parent if nil
+      logging = web_app.logging
+      logger.level = parse_log_level(logging[:level], nil)
       # delegate to root (console) output only in development mode :
-      logger.use_parent_handlers = ( web_app.environment == 'development' )
-      
-      prefix, suffix = web_app.environment, '.log' # {prefix}{date}{suffix}
-      file_handler = FileHandler.new(web_app.log_dir, prefix, suffix)
-      file_handler.rotatable = true # {prefix}{date}{suffix}
-      file_handler.formatter = web_app_formatter
-      logger.add_handler(file_handler)
+      logger.use_parent_handlers = logging[:use_parent_handlers]
+      # logging:
+      #  file:
+      #    dir: log # [RAILS_ROOT]/log
+      #    prefix: production
+      #    suffix: .log
+      if file = logging[:file]
+        prefix, suffix = file[:prefix], file[:suffix] # {prefix}{date}{suffix}
+        file_handler = FileHandler.new(file[:dir] || file[:directory], prefix, suffix)
+        file_handler.rotatable = file.key?(:rotatable) ? file[:rotatable] : file[:rotate]
+        file_handler.buffer_size = file[:buffer_size] if file[:buffer_size]
+        format = file.key?(:format) ? file[:format] : logging[:format]
+        file_handler.formatter = web_app_formatter(format) # nil uses default
+        logger.add_handler(file_handler)
+      end
       logger
     end
     
@@ -88,9 +94,9 @@ module Trinidad
       MessageFormatter.new
     end
     
-    def self.web_app_formatter
+    def self.web_app_formatter(format = nil)
       # format used by Rails "2012-06-13 16:42:21 +0200"
-      DefaultFormatter.new("yyyy-MM-dd HH:mm:ss Z")
+      DefaultFormatter.new(format.nil? ? 'yyyy-MM-dd HH:mm:ss Z' : format)
     end
     
     private
@@ -122,6 +128,24 @@ module Trinidad
       context.find_parameter(name) || web_app.web_xml_context_param(name)
     end
     
+    JUL::ConsoleHandler.class_eval do
+      field_accessor :sealed rescue nil
+      field_writer :writer rescue nil
+    end
+    
+    def self.new_console_handler(stream)
+      handler = JUL::ConsoleHandler.new # sets output stream to System.err
+      handler.writer = nil if handler.respond_to?(:writer=) # avoid writer.close
+      if handler.respond_to?(:sealed) && handler.sealed
+        handler.sealed = false # avoid manager security checks
+        handler.setOutputStream(stream) # closes previous writer if != null
+        handler.sealed = true
+      else
+        handler.setOutputStream(stream)
+      end
+      handler
+    end
+    
     # we'd achieve logging to a production.log file while rotating it (daily)
     class FileHandler < Java::OrgApacheJuli::FileHandler # :nodoc
       
@@ -133,7 +157,7 @@ module Trinidad
       
       def initialize(directory, prefix, suffix)
         super(directory, prefix, suffix)
-        self._date = '' # to openWriter on first #publish(record)
+        self._date = nil # to openWriter on first #publish(record)
       end
       
       def openWriter
@@ -223,7 +247,7 @@ module Trinidad
         msg << formatThrown(record).to_s
         # since we're going to print Rails.logger logs and they tend
         # to already have the ending "\n" handle such cases nicely :
-        if web_app_path(record.getLoggerName)
+        if context_name(record.getLoggerName)
           (lns = LINE_SEP) == msg[-1, 1] ? msg : msg << lns
         else
           msg << LINE_SEP
@@ -231,10 +255,11 @@ module Trinidad
       end
       
       # e.g. org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/foo]
-      WEB_APP_LOGGER_NAME = /org\.apache\.catalina\.core\.ContainerBase.*?\[(\/.*?)\]$/
+      # or org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[default]
+      WEB_APP_LOGGER_NAME = /^org\.apache\.catalina\.core\.ContainerBase.*?\[(.*?)\]$/
       
       private
-      def web_app_path(name)
+      def context_name(name)
         ( match = (name || '').match(WEB_APP_LOGGER_NAME) ) && match[1]
       end
       

data/lib/trinidad/server.rb

@@ -190,7 +190,7 @@ module Trinidad
         # We must create them before creating the applications.
         @config[:web_apps].each do |_, app_config|
           if host_names = app_config.delete(:hosts)
-            dir = app_config[:web_app_dir] || Dir.pwd
+            dir = web_app_root_dir(app_config)
             apps_base = File.dirname(dir) == '.' ? dir : File.dirname(dir)
             app_config[:host] = create_host(apps_base, host_names)
           end
@@ -225,10 +225,10 @@ module Trinidad
     private
     
     def add_default_web_app!(config)
-      if !config[:web_apps] && !config[:apps_base] && !config[:hosts]
+      if ! config[:web_apps] && ! config[:apps_base] && ! config[:hosts]
         default_app = {
           :context_path => config[:context_path],
-          :web_app_dir => config[:web_app_dir] || Dir.pwd,
+          :root_dir => web_app_root_dir(config),
           :log => config[:log]
         }
         default_app[:rackup] = config[:rackup] if config[:rackup]
@@ -237,6 +237,10 @@ module Trinidad
       end
     end
     
+    def web_app_root_dir(config, default = Dir.pwd)
+      config[:root_dir] || config[:web_app_dir] || default
+    end
+    
     def generate_default_keystore(config)
       keystore_file = java.io.File.new(config[:keystoreFile])
 

data/lib/trinidad/version.rb

@@ -1,3 +1,3 @@
 module Trinidad
-  VERSION = '1.4.3'
+  VERSION = '1.4.4'
 end

data/lib/trinidad/web_app.rb

@@ -30,12 +30,13 @@ module Trinidad
       use_default ? default_config.key?(key) : false
     end
     
-    %w{ root_dir jruby_compat_version
-        rackup log async_supported reload_strategy }.each do |method|
+    %w{ root_dir rackup log async_supported reload_strategy }.each do |method|
       class_eval "def #{method}; self[:'#{method}']; end"
     end
     alias_method :web_app_dir, :root_dir # is getting deprecated soon
     
+    def app_root; root_dir; end
+    
     def context_path
       path = self[:context_path] || self[:path]
       path ? path.to_s : path
@@ -54,7 +55,7 @@ module Trinidad
       if min = config[:jruby_min_runtimes]
         return min.to_i # min specified overrides :threadsafe
       else # but :threadsafe takes precendence over default :
-        self[:threadsafe] ? 1 : default_config[:jruby_min_runtimes]
+        self[:threadsafe] ? 1 : fetch_default_config_value(:jruby_min_runtimes)
       end
     end
     
@@ -62,12 +63,25 @@ module Trinidad
       if max = config[:jruby_max_runtimes]
         return max.to_i # max specified overrides :threadsafe
       else # but :threadsafe takes precendence over default :
-        self[:threadsafe] ? 1 : default_config[:jruby_max_runtimes]
+        self[:threadsafe] ? 1 : fetch_default_config_value(:jruby_max_runtimes)
+      end
+    end
+    
+    def jruby_initial_runtimes
+      if ini = config[:jruby_initial_runtimes]
+        return ini.to_i # min specified overrides :threadsafe
+      else # but :threadsafe takes precendence over default :
+        self[:threadsafe] ? 1 : 
+          fetch_default_config_value(:jruby_initial_runtimes, jruby_min_runtimes)
       end
     end
     
     def jruby_runtime_acquire_timeout
-      self[:jruby_runtime_acquire_timeout] || 5.0 # default 10s seems too high
+      fetch_config_value(:jruby_runtime_acquire_timeout, 5.0) # default 10s seems too high
+    end
+
+    def jruby_compat_version
+      fetch_config_value(:jruby_compat_version, RUBY_VERSION)
     end
     
     def environment; self[:environment] || @@defaults[:environment]; end # TODO check web.xml
@@ -125,10 +139,11 @@ module Trinidad
       @context_params ||= {}
       add_context_param 'jruby.min.runtimes', jruby_min_runtimes
       add_context_param 'jruby.max.runtimes', jruby_max_runtimes
-      add_context_param 'jruby.initial.runtimes', jruby_min_runtimes
+      add_context_param 'jruby.initial.runtimes', jruby_initial_runtimes
       add_context_param 'jruby.runtime.acquire.timeout', jruby_runtime_acquire_timeout
-      add_context_param 'jruby.compat.version', jruby_compat_version || RUBY_VERSION
-      add_context_param 'public.root', File.join('/', public_root)
+      add_context_param 'jruby.compat.version', jruby_compat_version
+      add_context_param 'public.root', public_root
+      add_context_param 'jruby.rack.layout_class', layout_class
       @context_params
     end
     # @deprecated replaced with {#context_params}
@@ -141,6 +156,22 @@ module Trinidad
       end
     end
 
+    def logging
+      @logging ||= begin
+        defaults = {
+          :level => log, # backwards compatibility
+          :use_parent_handlers => environment == 'development',
+          :file => {
+            :dir => log_dir,
+            :prefix => environment,
+            :suffix => '.log',
+            :rotate => true
+          }
+        }
+        Trinidad::Configuration.merge_options(defaults, self[:logging])
+      end
+    end
+    
     def deployment_descriptor
       return nil if @deployment_descriptor == false
       @deployment_descriptor ||= expand_path(web_xml) || false
@@ -357,8 +388,25 @@ module Trinidad
       raise NotImplementedError.new "context_listener expected to be redefined"
     end
     
+    if Gem::Version.create(JRuby::Rack::VERSION) > Gem::Version.create('1.1.10')
+      def layout_class
+        'JRuby::Rack::FileSystemLayout' # handles Rails as well as Rack
+      end
+    else
+      def layout_class
+        # NOTE: we'll also need to do a GEM_PATH hack to avoid a bug :
+        if gem_path = ENV['GEM_PATH']
+          add_context_param 'gem.path', gem_path
+          # ENV['GEM_PATH'] will contain twice the same entry(ies) ...
+        end
+        add_context_param 'rails.root', app_root # still boots a rack app
+        'JRuby::Rack::RailsFilesystemLayout' # no plain FS layout defined !
+      end
+    end
+    
     def complete_config!
       config[:root_dir] ||= self.class.root_dir(config, default_config)
+      config[:root_dir] = File.expand_path(config[:root_dir])
       config[:context_path] = self.class.context_path(config, default_config)
     end
     
@@ -439,6 +487,21 @@ module Trinidad
         end
       end
     end
+
+    def fetch_config_value(name, default = nil)
+      value = config[name]
+      value.nil? ? fetch_default_config_value(name, default) : value
+    end
+    
+    def fetch_default_config_value(name, default = nil)
+      value = default_config[name]
+      if value.nil?
+        # JRuby-Rack names: jruby_min_runtimes -> jruby.min.runtimes :
+        value = java.lang.System.getProperty(name.to_s.gsub('_', '.'))
+        value ||= default
+      end
+      value
+    end
     
     def logger
       @logger ||= Trinidad::Logging::LogFactory.getLog('')
@@ -570,6 +633,7 @@ module Trinidad
   class RackupWebApp < WebApp
 
     def context_params
+      add_context_param 'app.root', app_root
       add_context_param 'rack.env', environment
       if rackup = self.rackup
         rackup = File.join(rackup, 'config.ru') if File.directory?(rackup)
@@ -586,8 +650,8 @@ module Trinidad
   class RailsWebApp < WebApp
 
     def context_params
+      add_context_param 'rails.root', app_root
       add_context_param 'rails.env', environment
-      add_context_param 'rails.root', '/'
       super
     end
 
@@ -604,6 +668,10 @@ module Trinidad
       end
     end
     
+    #def layout_class
+      #'JRuby::Rack::RailsFileSystemLayout'
+    #end
+    
     private
     
     def self.threadsafe?(app_base, environment)
@@ -623,7 +691,7 @@ module Trinidad
     def context_path
       super.gsub(/\.war$/, '')
     end
-
+    
     def log_dir
       @log_dir ||= self[:log_dir] || File.join(work_dir, 'log')
     end
@@ -640,6 +708,10 @@ module Trinidad
       Trinidad::Lifecycle::WebApp::War.new(self)
     end
     
+    def layout_class
+      'JRuby::Rack::WebInfLayout'
+    end
+    
   end
   
 end

metadata

@@ -2,7 +2,7 @@
 name: trinidad
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 1.4.3
+  version: 1.4.4
 platform: ruby
 authors: 
   - David Calavera
@@ -10,96 +10,96 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-09-20 00:00:00 Z
+date: 2012-10-19 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: trinidad_jars
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
+    version_requirements: &id001 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: 1.1.0
+    requirement: *id001
+    prerelease: false
     type: :runtime
-    version_requirements: *id001
   - !ruby/object:Gem::Dependency 
     name: jruby-rack
-    prerelease: false
-    requirement: &id002 !ruby/object:Gem::Requirement 
+    version_requirements: &id002 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: 1.1.10
+    requirement: *id002
+    prerelease: false
     type: :runtime
-    version_requirements: *id002
   - !ruby/object:Gem::Dependency 
     name: rack
-    prerelease: false
-    requirement: &id003 !ruby/object:Gem::Requirement 
+    version_requirements: &id003 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: "0"
+    requirement: *id003
+    prerelease: false
     type: :development
-    version_requirements: *id003
   - !ruby/object:Gem::Dependency 
     name: rake
-    prerelease: false
-    requirement: &id004 !ruby/object:Gem::Requirement 
+    version_requirements: &id004 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: "0"
+    requirement: *id004
+    prerelease: false
     type: :development
-    version_requirements: *id004
   - !ruby/object:Gem::Dependency 
     name: rspec
-    prerelease: false
-    requirement: &id005 !ruby/object:Gem::Requirement 
+    version_requirements: &id005 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ~>
           - !ruby/object:Gem::Version 
             version: "2.10"
+    requirement: *id005
+    prerelease: false
     type: :development
-    version_requirements: *id005
   - !ruby/object:Gem::Dependency 
     name: mocha
-    prerelease: false
-    requirement: &id006 !ruby/object:Gem::Requirement 
+    version_requirements: &id006 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: "0"
+    requirement: *id006
+    prerelease: false
     type: :development
-    version_requirements: *id006
   - !ruby/object:Gem::Dependency 
     name: fakefs
-    prerelease: false
-    requirement: &id007 !ruby/object:Gem::Requirement 
+    version_requirements: &id007 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: 0.4.0
+    requirement: *id007
+    prerelease: false
     type: :development
-    version_requirements: *id007
   - !ruby/object:Gem::Dependency 
     name: sinatra
-    prerelease: false
-    requirement: &id008 !ruby/object:Gem::Requirement 
+    version_requirements: &id008 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: "0"
+    requirement: *id008
+    prerelease: false
     type: :development
-    version_requirements: *id008
 description: Trinidad allows you to run Rails or Rack applications within an embedded Apache Tomcat container. Serves your requests with the elegance of a cat !
 email: calavera@apache.org
 executables: 
@@ -147,17 +147,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 2
+        segments: 
+          - 0
         version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 2
+        segments: 
+          - 0
         version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Web server for Rails/Rack applications built upon JRuby::Rack and Apache Tomcat