trinidad 1.4.0.RC → 1.4.0

data/History.txt

@@ -1,5 +1,8 @@
-== Trinidad 1.4.0.RC (2012-07-03)
+== Trinidad 1.4.0 (2012-07-24)
 
+* fix incorrect context-param parsing and only configure logging when 
+  deployment descriptor did not specified jruby.rack.logging param (#76)
+* deep symbolize_options should account for arrays of hashes (#80)
 * requires latest Tomcat 7.0.28 (jars 1.0.5) due context reloading fix
 * requires latest jruby-rack 1.1.7 due delegating RackLogger to JUL
 * Trinidad::WebApp API revisited some changes are non-backwards compatible !

data/README.md

@@ -145,15 +145,23 @@ Context with name [/] has completed rolling
 ```
 
 It also prints warnings and error messages on error output, while application 
-specific log messages (e.g. logs from `Rails.logger`) go into the expected file 
-location at *log/{environment}.log*. 
+specific log messages (e.g. logs from `Rails.logger`) always go into the expected
+file location at *log/{environment}.log*. 
 
-Application logging performs daily rolling out of the box and only prints 
-messages from an application to the console while it runs in development mode.
+Application logging performs daily file rolling out of the box and only prints 
+messages to the console while it runs in development mode, that means you won't
+see any application specific output on the console say in production !
 
 Please note that these logging details as well as the logging format will be 
 configurable with *trinidad.yml/.rb* within the next **1.4.x** release.
 
+If you plan to use a slice of Java with your JRuby and require a logger, consider 
+using `ServletContext#log`. By default it is setup in a way that logging with 
+`ServletContext` ends up in the same location as the Rails log. 
+If this is not enough you can still configure a Java logging library e.g. SLF4J,
+just make sure you tell Trinidad to use it as well, if needed, using the 
+**jruby.rack.logging** context parameter in *web.xml*.
+
 ## Hot Deployment
 
 Trinidad supports monitoring a file to reload applications, when the file 
@@ -170,10 +178,10 @@ Since version **1.4.0** Trinidad supports 2 reload strategies :
 
 * **rolling** "zero-downtime" (asynchronous) reloading strategy similar to 
   Passenger's rolling reloads. This has been the default since **1.1.0** up till
-  Trinidad version **1.3.0**. If you use this you should account that while 
-  rolling memory requirements for the JVM might increase quite a lot since 
-  requests are being served and there's 2 versions of your application loaded at 
-  the same time.
+  the **1.3.x** line. If you use this you should account that your JVM memory
+  requirements might increase quite a lot (esp. if you reload under heavy loads)
+  since requests are being served while there's another version of the
+  application being loaded.
 
 Configure the reload strategy per web application or globally e.g. :
 

data/lib/trinidad/configuration.rb

@@ -90,8 +90,13 @@ module Trinidad
     # a Hash like #symbolize helper
     def self.symbolize_options(options, deep = true)
       new_options = options.class.new
-      options.each do |key, value|
-        if deep && options_like?(value)
+      options.each do |key, value|    
+        if deep && value.is_a?(Array) # YAML::Omap is an Array
+          array = new_options[key.to_sym] = value.class.new
+          value.each do |v|
+            array << ( options_like?(v) ? symbolize_options(v, deep)  : v )
+          end
+        elsif deep && options_like?(value)
           new_options[key.to_sym] = symbolize_options(value, deep)
         else
           new_options[key.to_sym] = value

data/lib/trinidad/logging.rb

@@ -52,14 +52,14 @@ module Trinidad
     def self.configure_web_app(web_app, context)
       param_name, param_value = 'jruby.rack.logging', 'JUL'
       # 1. delegate (jruby-rack) servlet log to JUL
-      if set_value = context.find_parameter(param_name)
+      if set_value = web_app_context_param(web_app, context, param_name)
         return nil if set_value.upcase != param_value
       else
         context.add_parameter(param_name, param_value)
       end
       # 2. use Tomcat's JUL logger name (unless set) :
       param_name = 'jruby.rack.logging.name'
-      unless logger_name = context.find_parameter(param_name)
+      unless logger_name = web_app_context_param(web_app, context, param_name)
         # for a context path e.g. '/foo' most likely smt of the following :
         # org.apache.catalina.core.ContainerBase.[Tomcat].[localhost].[/foo]
         context.add_parameter(param_name, logger_name = context.send(:logName))
@@ -118,6 +118,10 @@ module Trinidad
       logger.level = JUL::Level::WARNING if logger
     end
     
+    def self.web_app_context_param(web_app, context, name)
+      context.find_parameter(name) || web_app.web_xml_context_param(name)
+    end
+    
     # we'd achieve logging to a production.log file while rotating it (daily)
     class FileHandler < Java::OrgApacheJuli::FileHandler # :nodoc
       

data/lib/trinidad/version.rb

@@ -1,3 +1,3 @@
 module Trinidad
-  VERSION = '1.4.0.RC'
+  VERSION = '1.4.0'
 end

data/lib/trinidad/web_app.rb

@@ -147,29 +147,31 @@ module Trinidad
       config[:web_app_dir] ||= default_config[:web_app_dir] || Dir.pwd
     end
     
+    public
+    
     def web_xml_servlet?(servlet_class, servlet_name = nil)
       !!( web_xml_doc && (
-          web_xml_doc.root.elements["/web-app/servlet[contains(servlet-class, '#{servlet_class}')]"]
+          web_xml_doc.root.elements["/web-app/servlet[servlet-class = '#{servlet_class}']"]
         )
       )
     end
 
     def web_xml_filter?(filter_class)
       !!( web_xml_doc && (
-          web_xml_doc.root.elements["/web-app/filter[contains(filter-class, '#{filter_class}')]"]
+          web_xml_doc.root.elements["/web-app/filter[filter-class = '#{filter_class}']"]
         )
       )
     end
     
     def web_xml_listener?(listener_class)
       !!( web_xml_doc &&
-          web_xml_doc.root.elements["/web-app/listener[contains(listener-class, '#{listener_class}')]"]
+          web_xml_doc.root.elements["/web-app/listener[listener-class = '#{listener_class}']"]
       )
     end
     
     def web_xml_context_param(name)
       if web_xml_doc && 
-          param = web_xml_doc.root.elements["/web-app/context-param[contains(param-name, '#{name}')]"]
+          param = web_xml_doc.root.elements["/web-app/context-param[param-name = '#{name}']"]
         param.elements['param-value'].text
       end
     end

data/trinidad.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |s|
   s.files = `git ls-files`.split("\n").sort.
     reject { |file| file =~ /^\./ }. # .gitignore, .travis.yml
     reject { |file| file =~ /^spec\// }. # spec/**/*.spec
+    reject { |file| file =~ /^src\// }. # src/* patched into tomcat-core.jar
     # reject trinidad_jars.gemspec files :
     reject { |file| file == 'trinidad_jars.gemspec' || 
                     file == 'lib/trinidad/jars.rb'  || 

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: trinidad
 version: !ruby/object:Gem::Version 
-  prerelease: 6
-  version: 1.4.0.RC
+  prerelease: 
+  version: 1.4.0
 platform: ruby
 authors: 
   - David Calavera
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-03 00:00:00 Z
+date: 2012-07-24 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: trinidad_jars
@@ -135,7 +135,6 @@ files:
   - rakelib/tomcat.rake
   - rakelib/trinidad.rake
   - rakelib/trinidad_jars.rake
-  - src/java/org/apache/juli/FileHandler.java
   - trinidad.gemspec
 homepage: http://github.com/trinidad/trinidad
 licenses: []
@@ -154,9 +153,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.3.1
+        version: "0"
 requirements: []
 
 rubyforge_project: trinidad

data/src/java/org/apache/juli/FileHandler.java

@@ -1,401 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-package org.apache.juli;
-
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.OutputStream;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.UnsupportedEncodingException;
-import java.sql.Timestamp;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.logging.ErrorManager;
-import java.util.logging.Filter;
-import java.util.logging.Formatter;
-import java.util.logging.Handler;
-import java.util.logging.Level;
-import java.util.logging.LogManager;
-import java.util.logging.LogRecord;
-import java.util.logging.SimpleFormatter;
-
-/**
- * Implementation of <b>Handler</b> that appends log messages to a file
- * named {prefix}{date}{suffix} in a configured directory.
- *
- * <p>The following configuration properties are available:</p>
- * 
- * <ul>
- *   <li><code>directory</code> - The directory where to create the log file.
- *    If the path is not absolute, it is relative to the current working
- *    directory of the application. The Apache Tomcat configuration files usually
- *    specify an absolute path for this property,
- *    <code>${catalina.base}/logs</code> 
- *    Default value: <code>logs</code></li>
- *   <li><code>rotatable</code> - If <code>true</code>, the log file will be
- *    rotated on the first write past midnight and the filename will be
- *    <code>{prefix}{date}{suffix}</code>, where date is yyyy-MM-dd. If <code>false</code>,
- *    the file will not be rotated and the filename will be <code>{prefix}{suffix}</code>.
- *    Default value: <code>true</code></li>
- *   <li><code>prefix</code> - The leading part of the log file name.
- *    Default value: <code>juli.</code></li>
- *   <li><code>suffix</code> - The trailing part of the log file name. Default value: <code>.log</code></li>
- *   <li><code>bufferSize</code> - Configures buffering. The value of <code>0</code>
- *    uses system default buffering (typically an 8K buffer will be used). A
- *    value of <code>&lt;0</code> forces a writer flush upon each log write. A
- *    value <code>&gt;0</code> uses a BufferedOutputStream with the defined
- *    value but note that the system default buffering will also be
- *    applied. Default value: <code>-1</code></li>
- *   <li><code>encoding</code> - Character set used by the log file. Default value:
- *    empty string, which means to use the system default character set.</li>
- *   <li><code>level</code> - The level threshold for this Handler. See the
- *    <code>java.util.logging.Level</code> class for the possible levels.
- *    Default value: <code>ALL</code></li>
- *   <li><code>filter</code> - The <code>java.util.logging.Filter</code>
- *    implementation class name for this Handler. Default value: unset</li>
- *   <li><code>formatter</code> - The <code>java.util.logging.Formatter</code>
- *    implementation class name for this Handler. Default value:
- *    <code>java.util.logging.SimpleFormatter</code></li>
- * </ul>
- *
- * @version $Id$
- */
-
-public class FileHandler
-    extends Handler {
-
-
-    // ------------------------------------------------------------ Constructor
-
-    
-    public FileHandler() {
-        this(null, null, null);
-    }
-    
-    
-    public FileHandler(String directory, String prefix, String suffix) {
-        this.directory = directory;
-        this.prefix = prefix;
-        this.suffix = suffix;
-        configure();
-    }
-
-    public FileHandler(String directory, String prefix, String suffix, boolean rotatable, int bufferSize) {
-        this.directory = directory;
-        this.prefix = prefix;
-        this.suffix = suffix;
-        this.rotatable = rotatable;
-        this.bufferSize = bufferSize;
-        configure();
-    }
-
-    // ----------------------------------------------------- Instance Variables
-
-
-    /**
-     * The directory in which log files are created.
-     */
-    private String directory;
-
-    /**
-     * The prefix that is added to log file filenames.
-     */
-    private String prefix;
-
-    /**
-     * The suffix that is added to log file filenames.
-     */
-    private String suffix;
-
-    /**
-     * Determines whether the logfile is rotatable
-     */
-    private Boolean rotatable;
-
-    /**
-     * Log buffer size.
-     */
-    private Integer bufferSize;
-
-    /**
-     * The as-of date for the currently open log file, or null if there is no 
-     * open log file.
-     */
-    private volatile String date = null;
-    
-    /**
-     * The PrintWriter to which we are currently logging, if any.
-     */
-    private volatile PrintWriter writer = null;
-
-    /**
-     * Lock used to control access to the writer.
-     */
-    protected final ReadWriteLock writerLock = new ReentrantReadWriteLock();
-
-    // --------------------------------------------------------- Public Methods
-
-
-    /**
-     * Format and publish a <tt>LogRecord</tt>.
-     *
-     * @param  record  description of the log event
-     */
-    @Override
-    public void publish(LogRecord record) {
-
-        if (!isLoggable(record)) {
-            return;
-        }
-
-        final String tsDate = rotatable ? 
-            new Timestamp(System.currentTimeMillis()).toString().substring(0, 10) : "";
-        
-        try {
-            writerLock.readLock().lock();
-            // If the date has changed, switch log files
-            // Construct the timestamp we will use, if requested
-            // (... if not rotatable this will happen only once)
-            if ( !tsDate.equals(date) ) {
-                try {
-                    // Update to writeLock before we switch
-                    writerLock.readLock().unlock();
-                    writerLock.writeLock().lock();
-
-                    // Make sure another thread hasn't already done this
-                    if ( !tsDate.equals(date) ) {
-                        closeWriter();
-                        date = tsDate;
-                        openWriter();
-                    }
-                } finally {
-                    writerLock.writeLock().unlock();
-                    // Down grade to read-lock. This ensures the writer remains valid
-                    // until the log message is written
-                    writerLock.readLock().lock();
-                }
-            }
-
-            String result = null;
-            try {
-                result = getFormatter().format(record);
-            } catch (Exception e) {
-                reportError(null, e, ErrorManager.FORMAT_FAILURE);
-                return;
-            }
-
-            try {
-                if (writer!=null) {
-                    writer.write(result);
-                    if (bufferSize == null || bufferSize < 0) {
-                        writer.flush();
-                    }
-                } else {
-                    reportError("FileHandler is closed or not yet initialized, unable to log ["+result+"]", null, ErrorManager.WRITE_FAILURE);
-                }
-            } catch (Exception e) {
-                reportError(null, e, ErrorManager.WRITE_FAILURE);
-                return;
-            }
-        } finally {
-            writerLock.readLock().unlock();
-        }
-    }
-    
-    
-    // -------------------------------------------------------- Private Methods
-
-
-    /**
-     * Close the currently open log file (if any).
-     */
-    @Override
-    public void close() {
-        closeWriter();
-    }
-
-    protected void closeWriter() {
-        
-        writerLock.writeLock().lock();
-        try {
-            if (writer == null)
-                return;
-            writer.write(getFormatter().getTail(this));
-            writer.flush();
-            writer.close();
-            writer = null;
-            date = null;
-        } catch (Exception e) {
-            reportError(null, e, ErrorManager.CLOSE_FAILURE);
-        } finally {
-            writerLock.writeLock().unlock();
-        }
-    }
-
-
-    /**
-     * Flush the writer.
-     */
-    @Override
-    public void flush() {
-        
-        writerLock.readLock().lock();
-        try {
-            if (writer == null)
-                return;
-            writer.flush();
-        } catch (Exception e) {
-            reportError(null, e, ErrorManager.FLUSH_FAILURE);
-        } finally {
-            writerLock.readLock().unlock();
-        }
-        
-    }
-    
-    /**
-     * Configure from <code>LogManager</code> properties.
-     */
-    private void configure() {
-        
-        Timestamp ts = new Timestamp(System.currentTimeMillis());
-        date = ts.toString().substring(0, 10);
-
-        String className = this.getClass().getName(); //allow classes to override
-        
-        ClassLoader cl = Thread.currentThread().getContextClassLoader();
-        
-        // Retrieve configuration of logging file name
-        if (rotatable == null)
-            rotatable = Boolean.parseBoolean(getProperty(className + ".rotatable", "true"));
-        if (directory == null)
-            directory = getProperty(className + ".directory", "logs");
-        if (prefix == null)
-            prefix = getProperty(className + ".prefix", "juli.");
-        if (suffix == null)
-            suffix = getProperty(className + ".suffix", ".log");
-        if (bufferSize == null) {
-            String sBufferSize = getProperty(className + ".bufferSize", null);
-            try {
-                bufferSize = sBufferSize != null ? Integer.parseInt(sBufferSize) : null;
-            } catch (NumberFormatException ignore) { /* no op */ }
-        }
-        // Get encoding for the logging file
-        String encoding = getProperty(className + ".encoding", null);
-        if (encoding != null && encoding.length() > 0) {
-            try {
-                setEncoding(encoding);
-            } catch (UnsupportedEncodingException ex) {
-                // Ignore
-            }
-        }
-
-        // Get logging level for the handler
-        setLevel(Level.parse(getProperty(className + ".level", "" + Level.ALL)));
-
-        // Get filter configuration
-        String filterName = getProperty(className + ".filter", null);
-        if (filterName != null) {
-            try {
-                setFilter((Filter) cl.loadClass(filterName).newInstance());
-            } catch (Exception e) {
-                // Ignore
-            }
-        }
-
-        // Set formatter
-        String formatterName = getProperty(className + ".formatter", null);
-        if (formatterName != null) {
-            try {
-                setFormatter((Formatter) cl.loadClass(formatterName).newInstance());
-            } catch (Exception e) {
-                // Ignore and fallback to defaults
-                setFormatter(new SimpleFormatter());
-            }
-        } else {
-            setFormatter(new SimpleFormatter());
-        }
-        
-        // Set error manager
-        setErrorManager(new ErrorManager());
-        
-    }
-
-    
-    private String getProperty(String name, String defaultValue) {
-        String value = LogManager.getLogManager().getProperty(name);
-        if (value == null) {
-            value = defaultValue;
-        } else {
-            value = value.trim();
-        }
-        return value;
-    }
-    
-    
-    /**
-     * Open the new log file for the date specified by <code>date</code>.
-     */
-    public void open() {
-        openWriter();
-    }
-    
-    protected void openWriter() {
-        
-        // Create the directory if necessary
-        final File dir = new File(directory);
-        if ( !checkDir(dir) ) {
-            writer = null; return;
-        }
-        
-        // Open the current log file
-        writerLock.writeLock().lock();
-        String logFileName = prefix + (rotatable ? date : "") + suffix;
-        try {
-            File logFile = new File(dir.getAbsoluteFile(), logFileName);
-            if ( !checkDir(logFile.getParentFile()) ) {
-                writer = null; return;
-            }
-            String encoding = getEncoding();
-            FileOutputStream fos = new FileOutputStream(logFile, true);
-            OutputStream os = (bufferSize != null && bufferSize > 0) ? 
-                    new BufferedOutputStream(fos, bufferSize) : fos;
-            writer = new PrintWriter(
-                    (encoding != null) ? new OutputStreamWriter(os, encoding)
-                                       : new OutputStreamWriter(os), false);
-            writer.write(getFormatter().getHead(this));
-        } catch (Exception e) {
-            reportError(null, e, ErrorManager.OPEN_FAILURE);
-            writer = null;
-        } finally {
-            writerLock.writeLock().unlock();
-        }
-
-    }
-
-    private boolean checkDir(final File dir) {
-        if ( !dir.mkdirs() && !dir.isDirectory() ) {
-            reportError("Unable to create [" + dir + "]", null, ErrorManager.OPEN_FAILURE);
-            return false;
-        }
-        return true;
-    }
-
-}