trinidad 1.3.5 → 1.4.0.RC

data/Gemfile

@@ -1,3 +1,9 @@
-source :gemcutter
+source 'http://rubygems.org'
 
-gemspec :name => "trinidad"
+gemspec :name => "trinidad"
+
+# for the integration tests :
+group :test do
+  gem "rails", "~> 3.2"
+  gem "jruby-openssl"
+end

data/History.txt

@@ -1,3 +1,46 @@
+== Trinidad 1.4.0.RC (2012-07-03)
+
+* 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 !
+* enable running multiple applications with different ruby versions (using the 
+  jruby_compat_version configuration option)
+* allow arbitrary keys to be stored with Trinidad::Configuration
+* changed Trinidad::Lifecycle::Base to be a (ruby-like) base lifecycle listener
+  skeleton implementation, thus removed all web app specifics from the class
+  (include Trinidad::Lifecycle::WebApp::Shared to gain the same functionality)
+* removed unused Trinidad::Rack module and KeyTool from Trinidad::Tomcat
+* reinvented server/application logging with Trinidad::Logging :
+  - refactored Trinidad's global logging configuration with JUL
+  - application logs into log/env.log by default with daily rolling
+  - console logs are now less chatty and only print logs from applications 
+    running in development mode (configuration to come in a later release)
+  - make sure Trinidad's custom log formatter prints thrown exceptions
+  - use local timestamps with (file) log formatter by default
+* Trinidad::Server#add_web_app for code re-use during rolling redeploys
+* refactored application (monitor based `touch 'tmp/restart.txt'`) reloading
+  - bring back synchronous context reloading and make it default
+  - "zero downtime" async rolling reload is still supported and configurable via 
+    the reload_strategy: rolling configuration option
+  - updated the context restart code - hot deploys should now work reliably (#75)
+  - moved Trinidad::Lifecycle::Host under Trinidad::Lifecycle::WebApp::Host
+  - Trinidad::Lifecycle::Host now accepts a server instance instead of a tomcat
+  - introduced Trinidad::WebApp::Holder to be used instead of bare Hash
+* add async_supported attribute for servlet (3.0) configuration
+
+== Trinidad_jars 1.0.5 (2012-07-03)
+
+* Upgrade to Tomcat 7.0.28
+* Patched org.apache.juli.FileHandler to allow daily rolling customization
+
+== Trinidad_jars 1.0.4 (2012-06-14)
+
+* Upgrade to Tomcat 7.0.27
+
+== Trinidad_jars 1.0.3 (2012-04-04)
+
+* Upgrade to Tomcat 7.0.26
+
 == Trinidad 1.3.5 (2012-04-04)
 
 * Correctly detect :rackup from main config for web apps (#66)

data/LICENSE

@@ -1,6 +1,6 @@
 == Trinidad
 
-Copyright (c) 2009 David Calavera
+Copyright (c) 2009-2012 David Calavera
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -23,4 +23,5 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 == Additional Bundled Software
 
-Apache Tomcat is licensed according to the terms of Apache License, Version 2.0 (current). See http://www.apache.org/licenses/LICENSE-2.0 for details.
+Apache Tomcat is licensed according to the terms of Apache License, Version 2.0 (current). 
+See http://www.apache.org/licenses/LICENSE-2.0 for details.

data/README.md

@@ -1,10 +1,11 @@
 # Trinidad
 
-Trinidad allows you to run a rails or rackup applications within an embedded Apache Tomcat container.
+Trinidad allows you to run Rails or Rack applications within an embedded 
+Apache Tomcat container.
 
-* Mail list: http://groups.google.com/group/rails-trinidad
-* Bug tracker: http://github.com/trinidad/trinidad/issues
-* Irc channel on Freenode: #trinidad
+* Mailing List: http://groups.google.com/group/rails-trinidad
+* Bug Tracker: http://github.com/trinidad/trinidad/issues
+* IRC Channel (on FreeNode): #trinidad
 
 ## Installation
 
@@ -19,39 +20,43 @@ $ cd myapp
 $ jruby -S trinidad
 ```
 
-### Advanced Rackup setup
+### Setup
 
-**Sinatra**
-
-You can run your Sinatra application with Trinidad from the command line like this:
+If you use Bundler, you might want to add Trinidad to your *Gemfile*:
 
 ```
-$ ruby app.rb -s Trinidad
+gem 'trinidad', :require => nil
 ```
 
-Or tou can configure your application to always use it:
+**Rails**
 
-```ruby
-require 'sinatra'
-require 'trinidad'
+If you have Trinidad in your Gemfile you can start it with `rails server`:
 
-configure do
-  set :server, :trinidad
-end
+```
+$ rails s trinidad
 ```
 
-If you use Bundler, make sure you add Trinidad to your Gemfile:
+or simply, if you prefer not to use the Rack handler, use:
 
 ```
-gem 'trinidad'
+$ trinidad
 ```
 
-**Rails**
-
-If you already have Trinidad in your Gemfile you can start the server with the rails command:
+**Sinatra**
 
 ```
-$ rails s trinidad
+$ ruby app.rb -s Trinidad
+```
+
+or configure your application to always use Trinidad:
+
+```ruby
+require 'sinatra'
+require 'trinidad'
+
+configure do
+  set :server, :trinidad
+end
 ```
 
 **Rackup**
@@ -70,7 +75,8 @@ Or you can set Trinidad by default in your `config.ru` file:
 
 ## Configuration
 
-Trinidad allows you to configure some parameters when the server is started from the command line, the following is a list of the currently supported options:
+Trinidad allows you to configure parameters from the command line, the following 
+is a list of the currently supported options (try `trinidad -h`):
 
 ```
   * -p, --port PORT               =>  port to bind to.
@@ -86,47 +92,109 @@ Trinidad allows you to configure some parameters when the server is started from
   * -g, --log LEVEL               =>  set the log level, default INFO.
   * --apps APPS_BASE_DIRECTORY    =>  set the applications base directory.
 ```
-You can also specify a default web.xml to configure your web application. By default the server tries to load the file `config/web.xml` but you can modify this path by adding the option `default_web_xml` within your configuration file.
 
-Other advanced options can be found on the wiki: http://wiki.github.com/trinidad/trinidad/advanced-configuration
+You can also specify a default *web.xml* to configure your web application. 
+By default the server tries to load the file *config/web.xml* but you can change
+the path by adding the option `default_web_xml` within your configuration file.
 
-### Yaml comfiguration
+### YAML Configuration
+
+The server can also be configured from a .yml file. By default, if a file is 
+not specified, the server tries to load *config/trinidad.yml*.
+Within this file you can specify options available on the command line and tune 
+server settings or configure multiple applications to be hosted on the server.
+
+Advanced configuration options are explained in the wiki: 
+http://wiki.github.com/trinidad/trinidad/advanced-configuration
 
-The server can also be configured from a yaml file. By default, if a file is not specified, the server tries to load the file `config/trinidad.yml`. Within this file you can add other options like jruby.min.runtimes(:jruby _ min _ runtimes) or jruby.max.runtimes(:jruby _ max _ runtimes).
 
 ```
-$ jruby -S trinidad --config my_custom_configuration.yml
+$ jruby -S trinidad --config my_trinidad.yml
 ```
 
 ```yml
 ---
-  port: 4000
+  port: 4242
   address: 0.0.0.0
 ```
 
-### Ruby configuration
+### Ruby Configuration
 
-You can use pure ruby to configure Trinidad. Actually, the yaml configuration file is mapped directly into this configuration. It follows the same convention as the yaml configuration so the file `config/trinidad.rb` is loaded by default if if exists.
+As an alternative to the *config/trinidad.yml* file, a .rb configuration file 
+might be used to setup Trinidad. It follows the same convention as the yaml 
+configuration - the file `config/trinidad.rb` is loaded by default if exists.
 
 ```ruby
 Trinidad.configure do |config|
-  config.port = 4000
+  config.port = 4242
   config.address = '0.0.0.0'
 end
 ```
 
-## Hot deployment
+### Logging
+
+As you might notice on your first `trinidad` the server uses standard output :
+
+```
+kares@theborg:~/workspace/trinidad/MegaUpload$ trinidad -p 8000 -e staging
+Initializing ProtocolHandler ["http-bio-8000"]
+Starting Servlet Engine: Apache Tomcat/7.0.28
+Starting ProtocolHandler ["http-bio-8000"]
+Context with name [/] has started rolling
+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*. 
+
+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.
+
+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.
 
-Although the early versions of Trinidad used an extension to let deploy applications monitorizing a file, since Trinidad 1.1.0 this feature is integrated into the core. When the file `tmp/restart.txt` is modified, the server reloads the application that the file belongs. This file can be modified with the option `monitor`.
+## Hot Deployment
 
-## Virtual hosts
+Trinidad supports monitoring a file to reload applications, when the file 
+*tmp/restart.txt* is updated (e.g. `touch tmp/restart.txt`), the server reloads 
+the application the file belongs. 
+The file monitor can be customized with the `monitor` configuration option.
 
-It's posible to configure Trinidad with multiple hosts and load the applications under them automatically. Take into account that each host must have its applications in a different directory.
+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
+  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.
+
+* **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.
+
+Configure the reload strategy per web application or globally e.g. :
+
+```yml
+---
+  port: 8080
+  environment: production
+  reload_strategy: rolling
+```
+
+## Virtual Hosts
+
+It's possible to use Trinidad with multiple hosts and load the applications under 
+them automatically. Please remember that each host must have its applications in 
+a different directory.
 
 ```ruby
 Trinidad.configure do |config|
   config.hosts = {
-    # applications_path => host_name_list (the first one in the list is real host name, the other ones are aliases)
+    # applications_path => host_name_list 
+    # (first one is the real host name, the other ones are aliases)
     'app_local' => ['localhost', '127.0.0.1'],
     'apps_lol'  => ['lolhost', 'lol'],
     'apps_foo'  => 'foo'
@@ -134,14 +202,16 @@ Trinidad.configure do |config|
 end
 ```
 
-If the applications are configured via the web_apps section, the host for each app can be added with the key `hosts` under each application. If several applications belong to the same host put them under the same directory and specify the name of the host for each one:
+If applications are configured via the `web_apps` section, the host for each app
+can be added with the `hosts` key under each application. 
+If several applications belong to the same host put them under the same directory
+and specify the name of the host for each one e.g. :
 
 ```ruby
 Trinidad.configure do |config|
   config.web_apps = {
     :mock1 => {
       :web_app_dir => 'rails_apps/mock1',
-      # host_name_list (the first one in the list is real host name, the other ones are aliases)
       :hosts       => ['rails.virtual.host', 'rails.host']
     },
     :mock2 => {
@@ -150,7 +220,6 @@ Trinidad.configure do |config|
     },
     :mock3 => {
       :web_app_dir => 'rack_apps/mock3',
-      # host_name_list (the first one in the list is real host name, the other ones are aliases)
       :hosts       => ['rack.virtual.host', 'rack.host']
     }
   }
@@ -159,20 +228,21 @@ end
 
 ## Extensions
 
-From the version 0.8.0 Trinidad allows to extend the server with more Tomcat features, here there is a list with the current available extensions:
+Trinidad allows to extend itself with more (not just Tomcat) features, 
+here is a list of the available extensions that are "officially supported":
 
-
-* Database connection pooling: https://github.com/trinidad/trinidad_dbpool_extension
-* Daemon based on Akuma (ala GF gem): http://github.com/trinidad/trinidad_daemon_extension
-* Init services based on Apache Commons Daemon (supports Unix and Windows systems): http://github.com/trinidad/trinidad_init_services
-* Sandbox, management console and REST api: http://github.com/trinidad/trinidad_sandbox_extension
-* Logging, enhance the Trinidad's logging system: http://github.com/trinidad/trinidad_logging_extension
-* Lifecycle, application and server lifecycle management: http://github.com/trinidad/trinidad_lifecycle_extension
+* Database Connection Pooling: http://github.com/trinidad/trinidad_dbpool_extension
+* Daemonize Trinidad, based on Akuma: http://github.com/trinidad/trinidad_daemon_extension
+* Init Services (for Unix and Windows), based on Commons Daemon: http://github.com/trinidad/trinidad_init_services
+* Logging, enhance Trinidad's logging system: http://github.com/trinidad/trinidad_logging_extension
+* Application and Server Lifecycle Management: http://github.com/trinidad/trinidad_lifecycle_extension
+* Trinidad's Management Console and REST API: http://github.com/trinidad/trinidad_sandbox_extension
 * Scheduler, based on Quartz: http://github.com/trinidad/trinidad_scheduler_extension
+* Valves - components inserted into the request pipeline (e.g. Access Log): http://github.com/trinidad/trinidad_valve_extension
 
-
-You can find further information on how to write your own extension in the wiki: http://wiki.github.com/trinidad/trinidad/extensions
+You can find further information on how to write extensions in the wiki: 
+http://wiki.github.com/trinidad/trinidad/extensions
 
 ## Copyright
 
-Copyright (c) 2011 David Calavera<calavera@apache.org>. See LICENSE for details.
+Copyright (c) 2011-2012 David Calavera. See LICENSE for details.

data/Rakefile

@@ -18,9 +18,8 @@ def release(name, gem_file, version)
     exit!
   end
   sh "git commit --allow-empty -a -m 'Release #{name} #{version}'"
-  sh "git tag v#{name}-#{version}"
-  sh "git push origin master"
-  sh "git push --tags"
+  sh "git tag #{name}-#{version}"
+  sh "git push origin master --tags"
   sh "gem push pkg/#{gem_file}"
 end
 

data/lib/trinidad.rb

@@ -3,19 +3,15 @@ require 'java'
 require 'jruby-rack'
 
 require 'trinidad/version'
-require 'trinidad/core_ext'
 require 'trinidad/extensions'
 require 'trinidad/configuration'
 require 'trinidad/command_line_parser'
 require 'trinidad/jars'
+require 'trinidad/logging'
 require 'trinidad/server'
-require 'trinidad/log_formatter'
-require 'trinidad/lifecycle/takeover'
-require 'trinidad/lifecycle/lifecycle_listener_host'
-require 'trinidad/lifecycle/lifecycle_listener_base'
-require 'trinidad/lifecycle/lifecycle_listener_default'
-require 'trinidad/lifecycle/lifecycle_listener_war'
+require 'trinidad/lifecycle/base'
+require 'trinidad/lifecycle/host'
+require 'trinidad/lifecycle/web_app/shared'
+require 'trinidad/lifecycle/web_app/default'
+require 'trinidad/lifecycle/web_app/war'
 require 'trinidad/web_app'
-require 'trinidad/rails_web_app'
-require 'trinidad/rackup_web_app'
-require 'trinidad/war_web_app'

data/lib/trinidad/command_line_parser.rb

@@ -1,8 +1,5 @@
 module Trinidad
-  require 'optparse'
-
   class CommandLineParser
-    attr_reader :default_options
 
     def self.parse(argv)
       CommandLineParser.new.parse!(argv)
@@ -12,10 +9,13 @@ module Trinidad
       CommandLineParser.new.load!(options)
     end
     
+    attr_reader :default_options
+    
     def initialize
       @default_options = {}
     end
 
+    # Parse the arguments and return the loaded Trinidad configuration.
     def parse!(argv)
       begin
         options_parser.parse!(argv)
@@ -27,107 +27,106 @@ module Trinidad
       load!(default_options)
     end
 
+    # Load the configuration from the given options and return it.
     def load!(options)
-      base_dir = options[:web_app_dir] || Dir.pwd
-      config = options.delete(:config) || Dir.glob(File.join(base_dir, 'config', 'trinidad.{yml,rb}')).first
-      if config and config = File.expand_path(config, base_dir)
-        if yaml_configuration?(config)
-          require 'yaml'
-          require 'erb'
+      config = config_file(options[:web_app_dir])
+      if config && File.exist?(config)
+        if yaml = (File.extname(config) == '.yml')
+          require 'yaml'; require 'erb'
           config_options = YAML.load(ERB.new(File.read(config)).result(binding))
-          options.deep_merge!(config_options.symbolize!)
         end
+        # NOTE: provided options should override configuration values :
+        Trinidad.configure(config_options, options) do
+          load config unless yaml # if not .yml assume it's ruby (.rb)
+        end
+      else
+        Trinidad.configure(options)
       end
-
-      Trinidad.configure(options)
-      if ruby_configuration?(config)
-        load config
-      end
-
-      options
     end
     alias_method :load_configuration, :load!
 
-    def yaml_configuration?(config)
-      config && File.exist?(config) && config =~ /\.yml$/
-    end
-
-    def ruby_configuration?(config)
-      config && File.exist?(config) && config =~ /\.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
+      else
+        @config_file && File.expand_path(@config_file, base_dir)
+      end
     end
-
+    
+    attr_writer :config_file
+    
     def options_parser
+      require 'optparse'
       @parser ||= OptionParser.new do |opts|
         opts.banner = 'Trinidad server default options:'
         opts.separator ''
 
-        opts.on('-d', '--dir WEB_APP_DIRECTORY', 'Web app directory path',
-            "default: #{Dir.pwd}") do |v|
-          default_options[:web_app_dir] = v
+        opts.on('-d', '--dir WEB_APP_DIRECTORY', 'web app directory path',
+            "default: #{Dir.pwd}") do |dir|
+          default_options[:web_app_dir] = dir
         end
 
-        opts.on('-e', '--env ENVIRONMENT', 'Rails environment',
-            "default: #{default_options[:environment]}") do |v|
-          default_options[:environment] = v
+        opts.on('-e', '--env ENVIRONMENT', '(rails) environment',
+            "default: #{default_options[:environment]}") do |env|
+          default_options[:environment] = env
         end
 
-        opts.on('-p', '--port PORT', 'Port to bind to',
-            "default: #{default_options[:port]}") do |v|
-          default_options[:port] = v
+        opts.on('-p', '--port PORT', 'port to bind to',
+            "default: #{default_options[:port]}") do |port|
+          default_options[:port] = port
         end
 
-        opts.on('-c', '--context CONTEXT_PATH', 'The application context path',
-            "default: #{default_options[:context_path]}") do |v|
-          default_options[:context_path] = v
+        opts.on('-c', '--context CONTEXT_PATH', 'application context path',
+            "default: #{default_options[:context_path]}") do |path|
+          default_options[:context_path] = path
         end
 
-        opts.on('--lib', '--jars LIBS_DIR', 'Directory containing jars used by the application',
-            "default: #{default_options[:libs_dir]}") do |v|
-          default_options[:libs_dir] = v
+        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 classes used by the application',
-            "default: #{default_options[:classes_dir]}") do |v|
-          default_options[:classes_dir] = v
+        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
         end
 
-        opts.on('-s', '--ssl [SSL_PORT]', 'Enable secure socket layout',
-            "default port: 8443") do |v|
-          ssl_port = v.nil? ? 8443 : v.to_i
-          default_options[:ssl] = {:port => ssl_port}
+        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('-a', '--ajp [AJP_PORT]', 'Enable ajp connections',
-            "default port: 8009") do |v|
-          ajp_port = v.nil? ? 8009 : v.to_i
-          default_options[:ajp] = {:port => ajp_port}
+        opts.on('-a', '--ajp [AJP_PORT]', 'enable ajp connections (deprecated)',
+            "default port: 8009") do |port|
+          default_options[:ajp] = { :port => (port || 8009).to_i }
         end
 
-        opts.on('-f', '--config [CONFIG_FILE]', 'Configuration file',
-            "default: config/trinidad.yml") do |file|
-          default_options[:config] = file || 'config/trinidad.yml'
+        opts.on('-f', '--config [CONFIG_FILE]', 'configuration file',
+            "default: config/trinidad.{yml,rb}") do |file|
+          self.config_file = file
         end
 
-        opts.on('-r', '--rackup [RACKUP_FILE]', 'Rackup configuration file',
-            'default: config.ru') do |v|
-          default_options[:rackup] = v || 'config.ru'
+        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 DIRECTORY', 'Public directory', 'default: public') do |v|
-          default_options[:public] = v
+        opts.on('--public', '--public DIRECTORY', 'public directory', 'default: public') do |public|
+          default_options[:public] = public
         end
 
-        opts.on('-t', '--threadsafe', 'Threadsafe mode') do
+        opts.on('-t', '--threadsafe', 'force thread-safe mode') do
           default_options[:jruby_min_runtimes] = 1
           default_options[:jruby_max_runtimes] = 1
         end
 
-        opts.on('--address', '--address ADDRESS', 'Trinidad host address', 'default: localhost') do |v|
-          default_options[:address] = v
+        opts.on('--address', '--address ADDRESS', 'host address', 'default: localhost') do |address|
+          default_options[:address] = address
         end
 
-        opts.on('-g', '--log LEVEL', 'Log level', 'default: INFO') do |v|
-          default_options[:log] = v
+        opts.on('-g', '--log LEVEL', 'log level', 'default: INFO') do |log|
+          default_options[:log] = log
         end
 
         opts.on('-v', '--version', 'display the current version') do
@@ -137,7 +136,7 @@ module Trinidad
 
         opts.on('-l', '--load EXTENSION_NAMES', Array, 'load options for extensions') do |ext_names|
           ext_names.each do |ext|
-            Trinidad::Extensions.configure_options_extensions({ext => {}}, opts, default_options)
+            Trinidad::Extensions.configure_options_extensions({ ext => {} }, opts, default_options)
           end
         end
 
@@ -148,12 +147,13 @@ module Trinidad
         opts.on('--monitor' '--monitor MONITOR_FILE', 'monitor file for hot deployments') do |monitor|
           default_options[:monitor] = monitor
         end
-
+        
         opts.on('-h', '--help', 'display the help') do
           puts opts
           exit
         end
       end
     end
+    
   end
 end