trinidad 1.3.5 → 1.4.0.RC

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

@@ -0,0 +1,401 @@
+/*
+ * 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;
+    }
+
+}

data/trinidad.gemspec

@@ -3,10 +3,6 @@ $:.push File.expand_path("../lib", __FILE__)
 require 'trinidad/version'
 
 Gem::Specification.new do |s|
-  s.specification_version = 2 if s.respond_to? :specification_version=
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.rubygems_version = '1.3.5'
-  
   s.name              = 'trinidad'
   s.rubyforge_project = 'trinidad'
   s.version = Trinidad::VERSION
@@ -25,19 +21,19 @@ Gem::Specification.new do |s|
   s.rdoc_options = ["--charset=UTF-8"]
   s.extra_rdoc_files = %w[README.md LICENSE]
   
-  s.add_dependency('trinidad_jars', ">= 1.0.2")
-  s.add_dependency('jruby-rack', ">= 1.1.5")
+  s.add_dependency('trinidad_jars', ">= 1.0.5")
+  s.add_dependency('jruby-rack', ">= 1.1.7")
   
   s.add_development_dependency('rack')
   s.add_development_dependency('rake')
-  s.add_development_dependency('rspec', '~> 2.7')
+  s.add_development_dependency('rspec', '~> 2.10')
   s.add_development_dependency('mocha')
   s.add_development_dependency('fakefs', '>= 0.4.0')
+  s.add_development_dependency('sinatra')
 
   s.files = `git ls-files`.split("\n").sort.
     reject { |file| file =~ /^\./ }. # .gitignore, .travis.yml
-    # TODO backward compatibility - include no spec files ?!
-    reject { |file| file =~ /^spec\// }.
+    reject { |file| file =~ /^spec\// }. # spec/**/*.spec
     # 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: 
-  version: 1.3.5
+  prerelease: 6
+  version: 1.4.0.RC
 platform: ruby
 authors: 
   - David Calavera
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-04 00:00:00 Z
+date: 2012-07-03 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: trinidad_jars
@@ -20,7 +20,7 @@ dependencies:
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: 1.0.2
+            version: 1.0.5
     type: :runtime
     version_requirements: *id001
   - !ruby/object:Gem::Dependency 
@@ -31,7 +31,7 @@ dependencies:
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: 1.1.5
+            version: 1.1.7
     type: :runtime
     version_requirements: *id002
   - !ruby/object:Gem::Dependency 
@@ -64,7 +64,7 @@ dependencies:
       requirements: 
         - - ~>
           - !ruby/object:Gem::Version 
-            version: "2.7"
+            version: "2.10"
     type: :development
     version_requirements: *id005
   - !ruby/object:Gem::Dependency 
@@ -89,6 +89,17 @@ dependencies:
             version: 0.4.0
     type: :development
     version_requirements: *id007
+  - !ruby/object:Gem::Dependency 
+    name: sinatra
+    prerelease: false
+    requirement: &id008 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id008
 description: Trinidad allows you to run a rails or rackup applications within an embedded Apache Tomcat container
 email: calavera@apache.org
 executables: 
@@ -109,23 +120,22 @@ files:
   - lib/trinidad.rb
   - lib/trinidad/command_line_parser.rb
   - lib/trinidad/configuration.rb
-  - lib/trinidad/core_ext.rb
   - lib/trinidad/extensions.rb
-  - lib/trinidad/lifecycle/lifecycle_listener_base.rb
-  - lib/trinidad/lifecycle/lifecycle_listener_default.rb
-  - lib/trinidad/lifecycle/lifecycle_listener_host.rb
-  - lib/trinidad/lifecycle/lifecycle_listener_war.rb
-  - lib/trinidad/lifecycle/takeover.rb
-  - lib/trinidad/log_formatter.rb
-  - lib/trinidad/rackup_web_app.rb
-  - lib/trinidad/rails_web_app.rb
+  - lib/trinidad/lifecycle/base.rb
+  - lib/trinidad/lifecycle/host.rb
+  - lib/trinidad/lifecycle/host/restart_reload.rb
+  - lib/trinidad/lifecycle/host/rolling_reload.rb
+  - lib/trinidad/lifecycle/web_app/default.rb
+  - lib/trinidad/lifecycle/web_app/shared.rb
+  - lib/trinidad/lifecycle/web_app/war.rb
+  - lib/trinidad/logging.rb
   - lib/trinidad/server.rb
   - lib/trinidad/version.rb
-  - lib/trinidad/war_web_app.rb
   - lib/trinidad/web_app.rb
   - 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: []
@@ -144,15 +154,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version 
-        version: "0"
+        version: 1.3.1
 requirements: []
 
 rubyforge_project: trinidad
 rubygems_version: 1.8.15
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Simple library to run rails applications into an embedded Tomcat
 test_files: []