trinidad 1.4.6 → 1.5.0.B1

data/lib/trinidad/lifecycle/base.rb

@@ -6,10 +6,11 @@ module Trinidad
 
       include Trinidad::Tomcat::LifecycleListener
 
-      EVENTS = Trinidad::Tomcat::Lifecycle # :nodoc:
+      # @private
+      EVENTS = Trinidad::Tomcat::Lifecycle
 
       # The base implementation simply routes events to correspondig methods.
-      # 
+      #
       # http://tomcat.apache.org/tomcat-7.0-doc/api/org/apache/catalina/Lifecycle.html
       # http://tomcat.apache.org/tomcat-7.0-doc/api/org/apache/catalina/LifecycleListener.html
       def lifecycleEvent(event)
@@ -44,27 +45,27 @@ module Trinidad
           raise "unsupported event.type = #{event.type}"
         end
       end
-      
+
       # Event hook methods for a more Ruby-ish API :
-      
+
       def before_init(event); end
       def after_init(event); end
-      
+
       def before_start(event); end
       def configure_start(event); end
       def start(event); end
       def after_start(event); end
-      
+
       def before_stop(event); end
       def stop(event); end
       def configure_stop(event); end
       def after_stop(event); end
-      
+
       def before_destroy(event); end
       def after_destroy(event); end
-      
+
       def periodic(event); end
-      
+
     end
   end
 end

data/lib/trinidad/lifecycle/host.rb

@@ -2,17 +2,15 @@ require 'trinidad/lifecycle/base'
 
 module Trinidad
   module Lifecycle
-    # Host listener - monitors deployed applications 
+    # Host listener - monitors deployed applications
     # (re-invented HostConfig with Ruby/Rack semantics).
     class Host # TODO < Tomcat::HostConfig !
 
       include Trinidad::Tomcat::LifecycleListener
 
-      EVENTS = Trinidad::Tomcat::Lifecycle # :nodoc:
-      
+      EVENTS = Trinidad::Tomcat::Lifecycle
+
       attr_reader :server, :app_holders
-      # @deprecated (<= 1.3.5)
-      alias_method :contexts, :app_holders
 
       # #server current server instance
       # #app_holders deployed web application holders
@@ -27,7 +25,9 @@ module Trinidad
         @server, @app_holders = server, app_holders
       end
 
-      def lifecycleEvent(event) # :nodoc:
+      def contexts; @app_holders.map(&:context) end
+
+      def lifecycleEvent(event)
         case event.type
         when EVENTS::BEFORE_START_EVENT then
           before_start(event)
@@ -44,26 +44,23 @@ module Trinidad
         init_monitors
       end
 
-      def start(event); end # :nodoc:
+      def start(event); end
 
       def periodic(event)
         check_changes event.lifecycle
       end
 
-      def stop(event); end # :nodoc:
+      def stop(event); end
 
-      def tomcat; @server.tomcat; end # :nodoc: for backwards compatibility
-      
       protected
-      
+
       def check_changes(host)
         check_monitors
       end
 
       def init_monitors
-        app_holders.each do |app_holder|
-          monitor = app_holder.monitor
-          opts = 'w+'
+        for app_holder in app_holders
+          monitor = app_holder.monitor; opts = 'w+'
           if ! File.exist?(dir = File.dirname(monitor))
             Dir.mkdir dir
           elsif File.exist?(monitor)
@@ -76,13 +73,13 @@ module Trinidad
       end
 
       def check_monitors
-        app_holders.each do |app_holder|
+        for app_holder in app_holders
           # double check monitor, capistrano removes it temporarily
           unless File.exist?(monitor = app_holder.monitor)
             sleep(0.5)
             next unless File.exist?(monitor)
           end
-          
+
           mtime = File.mtime(monitor)
           if mtime > app_holder.monitor_mtime && app_holder.try_lock
             app_holder.monitor_mtime = mtime
@@ -93,13 +90,13 @@ module Trinidad
 
       autoload :RestartReload, 'trinidad/lifecycle/host/restart_reload'
       autoload :RollingReload, 'trinidad/lifecycle/host/rolling_reload'
-      
+
       RELOAD_STRATEGIES = {
         :default => :RestartReload,
         :restart => :RestartReload,
         :rolling => :RollingReload,
       }
-      
+
       def reload_application!(app_holder)
         strategy = (app_holder.web_app.reload_strategy || :default).to_sym
         strategy = RELOAD_STRATEGIES[ strategy ]
@@ -108,7 +105,7 @@ module Trinidad
         new_args << server if strategy.instance_method(:initialize).arity != 0
         strategy.new(*new_args).reload!(app_holder)
       end
-      
+
     end
   end
 end

data/lib/trinidad/lifecycle/host/rolling_reload.rb

@@ -9,52 +9,64 @@ module Trinidad
         @server = server
       end
 
-      def reload!(app_holder)
+      def reload!(app_holder, wait = false)
         web_app, old_context = app_holder.web_app, app_holder.context
+
+        millis = java.lang.System.currentTimeMillis
+        context_name = old_context.name.split('-')
+        context_name.pop if context_name.last.to_i.to_s.size == millis.to_s.size
+        context_name = context_name.join('-')
+
         logger = self.class.logger
-        logger.info "Context with name [#{old_context.name}] has started rolling"
+        logger.info "Context with name [#{context_name}] has started rolling"
 
         web_app.reset! # force a new class loader + re-read state (from config)
         no_host = org.apache.catalina.Host.impl {} # do not add to parent yet
         new_context = @server.add_web_app(web_app, no_host, false)
         # Tomcat requires us to have unique names for its containers :
-        new_context.name = "#{old_context.name}-#{java.lang.System.currentTimeMillis}"
+        new_context.name = "#{context_name}-#{millis}"
         new_context.add_lifecycle_listener(takeover = Takeover.new(old_context))
         app_holder.context = new_context
 
-        Thread.new do
+        thread = Thread.new do
+          if ( thread = thread.to_java ).respond_to?(:native_thread)
+            thread.native_thread.name = "Trinidad::Lifecycle::Host::RollingReload #{context_name}"
+          end
           begin
             logger.debug "Starting a new Context for [#{new_context.path}]"
             old_context.parent.add_child new_context # NOTE: likely starts!
-            
+
             new_context.start unless new_context.state_name =~ /START|STOP|FAILED/i
-            
+
             if new_context.state_name =~ /STOP|FAILED/i
-              logger.error("Context with name [#{old_context.name}] failed rolling")
+              logger.error("Context with name [#{context_name}] failed rolling")
               takeover.failed!(new_context)
             else
-              logger.info "Context with name [#{old_context.name}] has completed rolling"
+              logger.info "Context with name [#{context_name}] has completed rolling"
             end
-          rescue => error
-            e = org.jruby.exceptions.RaiseException.new(error)
-            logger.error("Context with name [#{old_context.name}] failed rolling", e)
-            takeover.failed!(new_context)
           rescue java.lang.Exception => e
-            logger.error("Context with name [#{old_context.name}] failed rolling", e)
+            logger.error("Context with name [#{context_name}] failed rolling", e)
+            takeover.failed!(new_context)
+          rescue => error
+            e = org.jruby.exceptions.RaiseException.new(error, false)
+            logger.error("Context with name [#{context_name}] failed rolling", e)
             takeover.failed!(new_context)
           ensure
             app_holder.unlock
           end
         end
+        thread.join if wait
         false # not yet reloaded do not release lock
       end
 
+      # @private
       def self.logger # log into the same location as context.reload does :
         Trinidad::Logging::LogFactory.getLog('org.apache.catalina.core.StandardContext')
       end
-      
-      class Takeover < Trinidad::Lifecycle::Base # :nodoc
-        
+
+      # @private
+      class Takeover < Trinidad::Lifecycle::Base
+
         def initialize(context)
           @old_context = context
         end
@@ -76,19 +88,19 @@ module Trinidad
         def failed!(new_context)
           # NOTE: this will also likely destroy() the child - new context :
           @old_context.parent.remove_child new_context
-          logger.info "Failed to start new Context for [#{@old_context.path}] " + 
+          logger.info "Failed to start new Context for [#{@old_context.path}] " <<
                       "(check application logs) keeping the old one running ..."
           new_context.remove_lifecycle_listener(self)
         end
-        
+
         private
-        
+
         def logger
           Trinidad::Lifecycle::Host::RollingReload.logger
         end
-        
+
       end
-      
+
     end
   end
 end

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

@@ -6,7 +6,7 @@ module Trinidad
     module WebApp
       class Default < Lifecycle::Base
         include Shared
-        
+
         def configure(context)
           super
           deployment_descriptor = configure_deployment_descriptor(context)
@@ -14,20 +14,26 @@ module Trinidad
             configure_rack_servlet(context)
             configure_rack_listener(context)
           end
-          configure_context_params(context)
           configure_context_loader(context)
+          configure_context_params(context)
         end
-        
+
         def before_init(event)
           super
           set_context_xml event.lifecycle
           # AFTER_INIT_EVENT ContextConfig#init() will pick this up
         end
-        
+
+        def before_start(event)
+          super
+          # on CONFIGURE_START context.jar_scanner is used
+          set_jar_scanner event.lifecycle
+        end
+
         protected
-        
+
         @@_add_context_config = true # due backward compatibility
-        
+
         def configure_deployment_descriptor(context)
           descriptor = web_app.deployment_descriptor
           if descriptor && File.exist?(descriptor)
@@ -39,7 +45,7 @@ module Trinidad
             if context_config.nil?
               if @@_add_context_config
                 context_config = Trinidad::Tomcat::ContextConfig.new
-                context.addLifecycleListener(context_config)
+                context.add_lifecycle_listener(context_config)
               else
                 raise "initialized context is missing a ContextConfig listener"
               end
@@ -55,6 +61,7 @@ module Trinidad
           rack_servlet = web_app.rack_servlet
           if rack_servlet[:instance]
             wrapper.servlet = rack_servlet[:instance]
+            web_app[:add_jruby_rack_jar] = false
           else
             wrapper.servlet_class = rack_servlet[:class]
             wrapper.async_supported = rack_servlet[:async_supported]
@@ -69,7 +76,9 @@ module Trinidad
 
         def configure_rack_listener(context)
           unless web_app.rack_servlet[:instance]
-            context.add_application_listener(web_app.rack_listener)
+            if rack_listener = web_app.rack_listener
+              context.add_application_listener(rack_listener)
+            end
           end
         end
 
@@ -82,28 +91,41 @@ module Trinidad
         alias_method :configure_init_params, :configure_context_params
 
         def configure_context_loader(context)
-          class_loader = web_app.class_loader
-
-          add_application_java_classes(class_loader)
-          add_application_jars(class_loader) # classes takes precedence !
+          loader = new_context_loader
+          add_jruby_rack_jar(loader)
+          add_application_java_classes(loader)
+          add_application_jars(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)
+        def add_jruby_rack_jar(loader)
+          return if web_app[:add_jruby_rack_jar] == false
+          if jruby_rack_jar = JRUBY_RACK_JAR_PATH
+            logger.debug "[#{web_app.context_path}] adding jar: #{jruby_rack_jar}"
+            loader.addRepository to_url_path(jruby_rack_jar)
+          end
+        end
+
+        def add_application_jars(loader)
           return unless lib_dir = web_app.java_lib_dir
+          # loader.setJarPath(lib_dir) no point since startInternal re-sets it
           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
+            loader.addRepository to_url_path(jar)
           end
         end
 
-        def add_application_java_classes(class_loader)
+        def add_application_java_classes(loader)
           return unless classes_dir = web_app.java_classes_dir
-          class_loader.addURL java.io.File.new(classes_dir).to_url
+          logger.debug "[#{web_app.context_path}] adding dir: #{classes_dir}"
+          loader.addRepository to_url_path(classes_dir)
         end
-        
+
+        def set_jar_scanner(context)
+          context.setJarScanner Java::RbTrinidadContext::DefaultJarScanner.new(context)
+        end
+
         def set_context_xml(context)
           # behave similar to a .war - checking /META-INF/context.xml on CP
           context_xml = web_app.context_xml
@@ -120,7 +142,16 @@ module Trinidad
             context.setDefaultContextXml(context_xml)
           end
         end
-        
+
+        private
+
+        def new_context_loader
+          class_loader = JRuby.runtime.jruby_class_loader
+          Java::RbTrinidadContext::DefaultLoader.new(class_loader)
+        end
+
+        def to_url_path(path); Helpers.to_url(path).to_s end
+
       end
     end
     Default = Trinidad::Lifecycle::WebApp::Default # backwards compatibility

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

@@ -1,6 +1,14 @@
 module Trinidad
   module Lifecycle
     module WebApp
+
+      # @private
+      JRUBY_RACK_JAR_PATH = if defined?(JRuby::Rack::JAR_PATH)
+        JRuby::Rack::JAR_PATH
+      else
+        JRubyJars.jruby_rack_jar_path
+      end
+
       # Shared web application lifecycle hook,
       # does #configure before the context starts.
       module Shared

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

@@ -18,7 +18,7 @@ module Trinidad
 
         def configure(context)
           super # Shared#configure
-          configure_class_loader(context)
+          # configure_class_loader(context)
         end
 
         protected
@@ -38,7 +38,7 @@ module Trinidad
         end
 
         def configure_class_loader(context)
-          class_loader = web_app.class_loader || JRuby.runtime.jruby_class_loader
+          class_loader = JRuby.runtime.jruby_class_loader
           loader = Trinidad::Tomcat::WebappLoader.new(class_loader)
           loader.container = context
           context.loader = loader

data/lib/trinidad/logging.rb

@@ -137,11 +137,19 @@ module Trinidad
         'org.apache.catalina.core.StandardService',
         'org.apache.catalina.core.StandardEngine',
         'org.apache.catalina.startup.ContextConfig',
+        #'org.apache.coyote.http11.Http11Protocol',
+        'org.apache.catalina.core.ApplicationContext',
+        #'org.apache.catalina.core.AprLifecycleListener',
+        'org.apache.catalina.loader.WebappClassLoader',
+        'org.apache.tomcat.websocket.server.WsSci',
       ]
       for name in logger_names
         logger = JUL::Logger.getLogger(name)
         set_log_level(logger, level) if logger
       end
+
+      #set_log_level(JUL::Logger.getLogger('rb.trinidad.context.DefaultLoader'), JUL::Level::FINEST)
+
     end
 
     def self.web_app_context_param(web_app, context, name)

data/lib/trinidad/server.rb

@@ -13,8 +13,6 @@ module Trinidad
       configure_logging config[:logging] || config[:log]
       @config = config.freeze
     end
-     # @deprecated replaced with {#configure}
-    def load_config(config); configure(config); end
 
     def hosts
       @hosts ||= @config[:hosts]
@@ -74,10 +72,15 @@ module Trinidad
 
       tomcat = Tomcat.new # @see Trinidad::Tomcat
       tomcat.base_dir = config[:base_dir] || Dir.pwd
-      address = config[:address] if config.key?(:address)
+      if config.key?(:address)
+        address = config[:address]; address = '0.0.0.0' if address == '*'
+      end
       tomcat.hostname = address || 'localhost'
       tomcat.server.address = address || nil unless address.nil?
       tomcat.port = config[:port].to_i if config.key?(:port)
+
+      set_tomcat_class_loader(tomcat)
+
       default_host(tomcat)
       create_hosts(tomcat)
       tomcat.enable_naming
@@ -109,8 +112,6 @@ module Trinidad
       Extensions.configure_server_extensions(config[:extensions], tomcat)
     end
     protected :initialize_tomcat
-    # #deprecated renamed to {#initialize_tomcat}
-    def load_tomcat_server; initialize_tomcat; end
 
     def add_host_monitor(app_holders)
       for host in tomcat.engine.find_children
@@ -119,8 +120,6 @@ module Trinidad
       end
     end
     protected :add_host_monitor
-    # @deprecated replaced with {#setup_host_monitor}
-    def load_host_monitor(web_apps); add_host_monitor(web_apps); end
 
     def add_ajp_connector(options = config[:ajp], tomcat = nil)
       # backwards compatibility - single argument (tomcat = @tomcat)
@@ -131,7 +130,7 @@ module Trinidad
       end if tomcat.nil?
 
       options = options.respond_to?(:[]) ? options.dup : {}
-      options[:address] = config[:address] unless options.key?(:address)
+      options[:address] = config[:address] if ! options.key?(:address) && config.key?(:address)
 
       add_service_connector(options, 'AJP/1.3', tomcat)
     end
@@ -146,7 +145,7 @@ module Trinidad
 
       options = options.respond_to?(:[]) ? options.dup : {}
       options[:port] = config[:port] || 3000 unless options.key?(:port)
-      options[:address] = config[:address] unless options.key?(:address)
+      options[:address] = config[:address] if ! options.key?(:address) && config.key?(:address)
 
       if options.delete(:nio)
         options[:protocol_handler] ||= 'org.apache.coyote.http11.Http11NioProtocol'
@@ -171,7 +170,7 @@ module Trinidad
       end if tomcat.nil?
 
       options = { :scheme => 'https', :secure => true }.merge!( options.respond_to?(:[]) ? options : {} )
-      options[:address] = config[:address] unless options.key?(:address)
+      options[:address] = config[:address] if ! options.key?(:address) && config.key?(:address)
 
       if keystore_file = options.delete(:keystore) || options.delete(:keystore_file)
         options[:keystoreFile] ||= keystore_file
@@ -429,8 +428,14 @@ module Trinidad
     def set_system_properties(system = Java::JavaLang::System)
       system.set_property("org.apache.catalina.startup.EXIT_ON_INIT_FAILURE", 'true')
     end
-    # @deprecated renamed to {#set_system_properties}
-    def load_default_system_properties; set_system_properties; end
+
+    def set_tomcat_class_loader(tomcat)
+      # NOTE: allows for Java class-resolution to work from within Tomcat :
+      tomcat_loader = tomcat.server.getParentClassLoader
+      if tomcat_loader.nil? || tomcat_loader == Java::JavaLang::ClassLoader.getSystemClassLoader
+        tomcat.server.setParentClassLoader JRuby.runtime.jruby_class_loader
+      end
+    end
 
     def configure_logging(logging)
       Trinidad::Logging.configure(logging)