mizuno 0.5.1 → 0.6.0

data/README.markdown

@@ -11,27 +11,23 @@ container for your Rack application to run under JRuby, because Mizuno
 works just like Mongrel, WEBRick, Thin, or any other standard Rack
 handler.
 
-Mizuno is the fastest option for Rack applications on JRuby:
-
-    Mizuno: 6106.66 req/s (mean)
-    Jetty (via jruby-rack): 2011.67 req/s (mean)
-    Mongrel: 1479.15 req/sec (mean)
-
 Mizuno also supports asynchronous request handling, via the Java Servlet
 3.0 asynchronous processing mechanism
 
-All the speed comes from Jetty 7; Mizuno just ties it to Rack through
+All the speed comes from Jetty 8; Mizuno just ties it to Rack through
 JRuby's Ruby/Java integration layer.
 
 Note that Mizuno is NOT a direct replacement for jruby-rack or Warbler,
 because it doesn't produce WAR files or make any attempt to package a
 Rack application for installation in a Java web container.
 
-There's also a few features that I have yet to implement:
+You can also run Mizuno via rackup:
+
+    rackup -s mizuno
+
+Or with live reloading support:
 
-1. Route Jetty's logs into Rack::Logger.
-2. Add hooks for realtime monitoring of server performance.
-3. Fast restarts of the Rack application.
+    mizuno --reloadable
 
 Mizuno is licensed under the Apache Public License, version 2.0; see
 the LICENSE file for details, and was developed on behalf of 

data/Rakefile

@@ -6,6 +6,8 @@ RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
 
+# http://rubydoc.info/gems/pompompom/1.1.3/frames
+
 namespace :jetty do
     desc "Grab the latest Jetty from its Maven repository."
     task :update do
@@ -40,15 +42,15 @@ namespace :jetty do
         # Inventory contents of the tarball we picked up.
         inventory = `tar tzf #{tempfile}`.split(/\n/)
 
-        # Find replacements from our downloaded tarball for each of our jars.
+        # Figure out which JARs we should replce with tarball contents.
         replacements = {}
         Dir.entries(jar_path).each do |entry|
-            next unless (entry =~ /^\w.*\d\.jar$/)
+            next unless ((entry =~ /^jetty-\w.*\d\.jar$/) \
+                or (entry =~ /^servlet-api.*\d\.jar$/))
             name = entry.sub(/\-\d.*$/, '')
             matcher = /\/#{name}\-[^\/]+\d\.jar$/
             archive_file = inventory.find { |i| i =~ matcher }
-            raise("Archive missing replacement for #{entry}") \
-                unless archive_file
+            next unless archive_file
             replacements[entry] = archive_file
         end
 

data/lib/mizuno/choices.rb

@@ -76,7 +76,7 @@ Choice.options do
     end
 
     separator ''
-    separator 'Daemonization: '
+    separator 'Mizuno-specific options: '
 
     option :daemonize do
         short '-D'
@@ -105,7 +105,13 @@ Choice.options do
 
     option :reload do
         long '--reload'
-        desc 'reload a running daemon'
+        desc 'reloads a running mizuno instance'
+        default false
+    end
+
+    option :reloadable do
+        long '--reloadable'
+        desc 'sets up live reloading via mizuno/reloader'
         default false
     end
 

data/lib/mizuno/http_server.rb

@@ -1,5 +1,6 @@
 require 'mizuno/version'
 require 'mizuno/java_logger'
+require 'mizuno/reloader'
 
 module Mizuno
     class HttpServer
@@ -73,6 +74,11 @@ module Mizuno
             app_handler = ServletContextHandler.new(nil, "/", 
                 ServletContextHandler::NO_SESSIONS)
 
+            # Optionally wrap with Mizuno::Reloader.
+            threshold = (ENV['RACK_ENV'] == 'production' ? 10 : 1)
+            app = Mizuno::Reloader.new(app, threshold) \
+                if options[:reloadable]
+
             # The servlet itself.
             rack_servlet = RackServlet.new
             rack_servlet.rackup(app)
@@ -175,8 +181,5 @@ module Mizuno
     end
 end
 
-# Register ourselves with Rack when this file gets loaded.
-Rack::Handler.register 'mizuno', 'Mizuno::HttpServer'
-
 # Ensure that we shutdown the server on exit.
 at_exit { Mizuno::HttpServer.stop }

data/lib/mizuno/reloader.rb

@@ -0,0 +1,147 @@
+require 'pathname'
+require 'thread'
+
+#:nodoc:
+module Mizuno
+    # 
+    # Middleware for reloading production applications; works exactly
+    # like Rack::Reloader, but rather than checking for any changed
+    # file, only looks at one specific file.
+    #
+    # Also allows for explicit reloading via a class method, as well as
+    # by sending a SIGHUP to the process.
+    # 
+    class Reloader
+        class << self
+            attr_accessor :logger, :trigger, :reloaders
+        end
+
+        def Reloader.reload!
+            reloaders.each { |r| r.reload!(true) }
+        end
+
+        def initialize(app, interval = 1)
+            Thread.exclusive do
+                self.class.reloaders ||= []
+                self.class.reloaders << self
+                self.class.logger ||= Mizuno::HttpServer.logger
+                self.class.trigger ||= "tmp/restart.txt"
+            end
+
+            @app = app
+            @interval = interval
+            @trigger = self.class.trigger
+            @logger = self.class.logger
+            @updated = @threshold = Time.now.to_i
+        end
+
+        #
+        # Reload @app on request.
+        #
+        def call(env)
+            Thread.exclusive { reload! }
+            @app.call(env)
+        end
+
+        #
+        # Reloads the application if (a) we haven't reloaded in
+        # @interval seconds, (b) the trigger file has been touched
+        # since our last check, and (c) some other thread hasn't handled
+        # the update.
+        #
+        def reload!(force = false)
+            return unless (Time.now.to_i > @threshold)
+            @threshold = Time.now.to_i + @interval
+            return unless (force or \
+                ((timestamp = mtime(@trigger)).to_i > @updated))
+            timestamp ||= Time.now.to_i
+
+            # Check updated files to ensure they're loadable.
+            missing, errors = 0, 0
+            files = find_files_for_reload do |file, file_mtime|
+                next(missing += 1 and nil) unless file_mtime
+                next unless (file_mtime >= @updated)
+                next(errors += 1 and nil) unless verify(file)
+                file
+            end
+
+            # Cowardly fail if we can't load something.
+            @logger.debug("#{missing} files missing during reload.") \
+                if (missing > 0)
+            return(@logger.error("#{errors} errors, not reloading.")) \
+                if (errors > 0)
+
+            # Reload everything that's changed.
+            files.each do |file|
+                next unless file
+                @logger.info("Reloading #{file}")
+                load(file) 
+            end
+            @updated = timestamp
+        end
+
+        #
+        # Walk through the list of every file we've loaded.
+        #
+        def find_files_for_reload
+            paths = [ './', *$LOAD_PATH ].uniq
+            [ $0, *$LOADED_FEATURES ].uniq.map do |file|
+                next if file =~ /\.(so|bundle)$/
+                yield(find(file, paths))
+            end
+        end
+
+        #
+        # Returns true if the file is loadable; uses the wrapper
+        # functionality of Kernel#load to protect the global namespace.
+        #
+        def verify(file)
+            begin
+                @logger.debug("Verifying #{file}")
+                load(file, true)
+                return(true)
+            rescue => error
+                @logger.error("Failed to verify #{file}: #{error.to_s}")
+                error.backtrace.each { |l| @logger.error("    #{l}") }
+            end
+        end
+
+        #
+        # Takes a relative or absolute +file+ name, a couple possible
+        # +paths+ that the +file+ might reside in. Returns a tuple of
+        # the full path where the file was found and its modification
+        # time, or nil if not found.
+        #
+        def find(file, paths)
+            if(Pathname.new(file).absolute?)
+                return unless (timestamp = mtime(file))
+                @logger.debug("Found #{file}")
+                [ file, timestamp ]
+            else
+                paths.each do |path|
+                    fullpath = File.expand_path((File.join(path, file)))
+                    next unless (timestamp = mtime(fullpath))
+                    @logger.debug("Found #{file} in #{fullpath}")
+                    return([ fullpath, timestamp ])
+                end
+                return(nil)
+            end
+        end
+
+        #
+        # Returns the modification time of _file_.
+        #
+        def mtime(file)
+            begin
+                return unless file
+                stat = File.stat(file)
+                stat.file? ? stat.mtime.to_i : nil
+            rescue Errno::ENOENT, Errno::ENOTDIR
+                nil
+            end
+        end
+    end
+end
+
+# Reload on SIGHUP.
+trap("SIGHUP") { Mizuno::Reloader.reload! }

data/lib/mizuno/runner.rb

@@ -8,6 +8,59 @@ require 'etc'
 require 'rack'
 
 module Mizuno
+    require 'rbconfig'
+
+    module Daemonizer
+        def self.included?(base)
+            if(Config::CONFIG['host_os'] =~ /mswin|mingw/)
+                base.send(:extend, StubbedClassMethods)
+            else
+                base.send(:extend, UnixClassMethods)
+                base.send(:class_eval) do
+                    extend FFI::Library
+                    ffi_lib 'c'
+                    attach_function :_setuid, :setuid, [ :uint ], :int
+                    attach_function :_setgid, :setgid, [ :uint ], :int
+                end
+            end
+
+        end
+
+        module UnixClassMethods
+            #
+            # Switch the process over to a new user id; will abort the
+            # process if it fails. _options_ is the full list of options
+            # passed to a server.
+            #
+            def setuid(options)
+                entry = Etc.getpwnam(options[:user])
+                die("Can't find --user named '#{options[:user]}'") \
+                    unless entry
+                return unless (_setuid(entry.uid) != 0)
+                die("Can't switch to user '#{options[:user]}'")
+            end
+
+            #
+            # Like setuid, but for groups.
+            #
+            def setgid(options)
+                entry = Etc.getgrnam(options[:group])
+                die("Can't find --group named '#{options[:group]}'") \
+                    unless entry
+                return unless (_setgid(entry.gid) != 0)
+                die("Can't switch to group '#{options[:group]}'")
+            end
+        end
+
+        module StubbedClassMethods
+            def setuid(options)
+            end
+
+            def setgid(options)
+            end
+        end
+    end
+
     #
     # Launches Mizuno when called from the command-line, and handles
     # damonization via FFI.
@@ -15,35 +68,7 @@ module Mizuno
     # Daemonization code based on Spoon.
     #
     class Runner
-        extend FFI::Library
-
-        ffi_lib 'c'
-            
-        attach_function :_setuid, :setuid, [ :uint ], :int
-
-        attach_function :_setgid, :setgid, [ :uint ], :int
-
-        #
-        # Switch the process over to a new user id; will abort the
-        # process if it fails. _options_ is the full list of options
-        # passed to a server.
-        #
-        def Runner.setuid(options)
-            entry = Etc.getpwnam(options[:user])
-            die("Can't find --user named '#{options[:user]}'") unless entry
-            return unless (_setuid(entry.uid) != 0)
-            die("Can't switch to user '#{options[:user]}'")
-        end
-
-        #
-        # Like setuid, but for groups.
-        #
-        def Runner.setgid(options)
-            entry = Etc.getgrnam(options[:group])
-            die("Can't find --group named '#{options[:group]}'") unless entry
-            return unless (_setgid(entry.gid) != 0)
-            die("Can't switch to group '#{options[:group]}'")
-        end
+        include Daemonizer
 
         #
         # Launch Jetty, optionally as a daemon.
@@ -75,6 +100,7 @@ module Mizuno
             # Fire up Mizuno as if it was called from Rackup.
             Dir.chdir(options[:root])
             HttpServer.configure_logging(options)
+            ENV['RACK_ENV'] = options[:env]
             server = Rack::Server.new
             server.options = options.merge(:server => 'mizuno',
                 :environment => options[:env])
@@ -105,7 +131,7 @@ module Mizuno
             File.open(options[:pidfile], 'w') { |f| f.puts(child.pid) }
 
             # Wait until the server starts or we time out waiting for it.
-            exit if wait_for_server(options)
+            exit if wait_for_server(options, 60)
             child.stop
             die("Failed to start Mizuno.")
         end

data/lib/mizuno/version.rb

@@ -1,3 +1,3 @@
 module Mizuno
-    VERSION = "0.5.1"
+    VERSION = "0.6.0"
 end

data/lib/rack/handler/mizuno.rb

@@ -0,0 +1,4 @@
+require 'mizuno'
+
+# Register ourselves with Rack when this file gets loaded.
+Rack::Handler.register 'mizuno', 'Mizuno::HttpServer'

data/mizuno.gemspec

@@ -23,9 +23,11 @@ Gem::Specification.new do |spec|
         lib/mizuno/java_logger.rb
         lib/mizuno/rack/chunked.rb
         lib/mizuno/rack_servlet.rb
+        lib/mizuno/reloader.rb
         lib/mizuno/runner.rb
         lib/mizuno/version.rb
         lib/mizuno.rb
+        lib/rack/handler/mizuno.rb
         bin/mizuno)
     jars = Dir.entries("lib/java").grep(/\.jar$/)
     spec.files.concat(jars.map { |j| "lib/java/#{j}" })

metadata

@@ -2,7 +2,7 @@
 name: mizuno
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors: 
   - Don Werve
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-17 00:00:00 Z
+date: 2012-04-09 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: rack
@@ -120,19 +120,21 @@ files:
   - lib/mizuno/java_logger.rb
   - lib/mizuno/rack/chunked.rb
   - lib/mizuno/rack_servlet.rb
+  - lib/mizuno/reloader.rb
   - lib/mizuno/runner.rb
   - lib/mizuno/version.rb
   - lib/mizuno.rb
+  - lib/rack/handler/mizuno.rb
   - bin/mizuno
-  - lib/java/jetty-continuation-8.0.4.v20111024.jar
-  - lib/java/jetty-http-8.0.4.v20111024.jar
-  - lib/java/jetty-io-8.0.4.v20111024.jar
-  - lib/java/jetty-jmx-8.0.4.v20111024.jar
-  - lib/java/jetty-security-8.0.4.v20111024.jar
-  - lib/java/jetty-server-8.0.4.v20111024.jar
-  - lib/java/jetty-servlet-8.0.4.v20111024.jar
-  - lib/java/jetty-servlets-8.0.4.v20111024.jar
-  - lib/java/jetty-util-8.0.4.v20111024.jar
+  - lib/java/jetty-continuation-8.1.2.v20120308.jar
+  - lib/java/jetty-http-8.1.2.v20120308.jar
+  - lib/java/jetty-io-8.1.2.v20120308.jar
+  - lib/java/jetty-jmx-8.1.2.v20120308.jar
+  - lib/java/jetty-security-8.1.2.v20120308.jar
+  - lib/java/jetty-server-8.1.2.v20120308.jar
+  - lib/java/jetty-servlet-8.1.2.v20120308.jar
+  - lib/java/jetty-servlets-8.1.2.v20120308.jar
+  - lib/java/jetty-util-8.1.2.v20120308.jar
   - lib/java/log4j-1.2.16.jar
   - lib/java/rewindable-input-stream.jar
   - lib/java/servlet-api-3.0.jar