mizuno 0.4.1 → 0.5.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+*.DS_Store
+*.gem
+Gemfile.lock
+archive/
+doc/
+tmp/

data/Rakefile

@@ -78,3 +78,22 @@ namespace :jetty do
         puts "Update complete."
     end
 end
+
+namespace :java do
+    desc "Build bundled Java source files."
+    task :build do
+        system(<<-END)
+            javac -classpath lib/java/servlet-api-3.0.jar \
+                src/org/jruby/rack/servlet/RewindableInputStream.java
+            jar cf lib/java/rewindable-input-stream.jar -C src/ \
+                org/jruby/rack/servlet/RewindableInputStream.class
+        END
+    end
+
+    desc "Clean up after building."
+    task :clean do
+        system(<<-END)
+            rm src/org/jruby/rack/servlet/RewindableInputStream.class
+        END
+    end
+end

data/bin/mizuno

@@ -2,9 +2,8 @@
 
 raise("Mizuno only runs on JRuby.") unless (RUBY_PLATFORM =~ /java/)
 
-require 'rack'
+require 'rubygems'
 require 'mizuno'
+require 'mizuno/runner'
 
-server = Rack::Server.new
-server.options[:server] = 'mizuno'
-server.start
+Mizuno::Runner.start!

data/lib/mizuno.rb

@@ -1,16 +1,26 @@
 #
-# A Rack handler for Jetty 7.
+# A Rack handler for Jetty 8.
 #
 # Written by Don Werve <don@madwombat.com>
 #
 
-# Java integration for talking to Jetty.
-require 'java'
+# Save our launch environment for spawning children later.
+module Mizuno
+    LAUNCH_ENV = $LOAD_PATH.map { |i| "-I#{i}" }.push($0)
+end
 
-# Load Jetty JARs.
+# Load up Java dependencies.
+require 'java'
 jars = File.join(File.dirname(__FILE__), 'java', '*.jar')
 Dir[jars].each { |j| require j }
 
+# Tell log4j not to complain to the console about a missing
+# log4j.properties file, as we configure it programmatically in
+# Mizuno::HttpServer (http://stackoverflow.com/questions/6849887)
+Java.org.apache.log4j.Logger.getRootLogger.setLevel( \
+    Java.org.apache.log4j.Level::INFO)
+
 require 'rack'
+require 'mizuno/rack/chunked'
 require 'mizuno/rack_servlet'
 require 'mizuno/http_server'

data/lib/mizuno/choices.rb

@@ -0,0 +1,158 @@
+Choice.options do
+    separator ''
+    separator 'Ruby options: '
+
+    option :eval do
+        short '-e'
+        long '--eval'
+        desc 'evaluate a line of code'
+        default nil
+    end
+
+    option :debug do
+        short '-d'
+        long '--debug'
+        desc 'set debugging flags (set $DEBUG to true)'
+        default false
+    end
+
+    option :warn do
+        short '-w'
+        long '--warn'
+        desc 'turn warnings on for your script'
+        default false
+    end
+
+    option :include do
+        short '-I'
+        long '--include *PATHS'
+        desc 'specify $LOAD_PATH (may be used more than once)'
+        default []
+    end
+
+    option :require do
+        short '-r'
+        long '--require *GEMS'
+        desc 'require a gem (may be used more than once)'
+        default []
+    end
+
+    separator ''
+    separator 'Rack options: '
+
+    option :host do
+        short '-o'
+        long '--host'
+        desc 'the address to listen on'
+        default '0.0.0.0'
+    end
+
+    option :port do
+        short '-p'
+        long '--port'
+        desc 'the port to listen on'
+        cast Integer
+        default 9292
+    end
+
+    option :env do
+        short '-E'
+        long '--env'
+        desc 'application environment'
+        default 'development'
+    end
+
+    option :threads do
+        long '--threads'
+        desc 'maximum size of the thread pool'
+        cast Integer
+        default 50
+    end
+
+    option :log do
+        long '--log'
+        desc 'logfile (defaults to stderr)'
+        default nil
+    end
+
+    separator ''
+    separator 'Daemonization: '
+
+    option :daemonize do
+        short '-D'
+        long '--start'
+        desc 'detach and run as a daemon'
+        default false
+    end
+
+    option :stop do
+        long '--stop'
+        desc 'stop a running daemon'
+        default false
+    end
+
+    option :kill do
+        long '--stop'
+        desc 'stop a running daemon'
+        default false
+    end
+
+    option :status do
+        long '--status'
+        desc 'get the status of a running daemon'
+        default false
+    end
+
+    option :reload do
+        long '--reload'
+        desc 'reload a running daemon'
+        default false
+    end
+
+    option :pidfile do
+        short '-P'
+        long '--pidfile'
+        desc 'pidfile for when running as a daemon'
+        default 'mizuno.pid'
+    end
+
+    option :user do
+        long '--user'
+        desc 'user to run as'
+        default nil
+    end
+
+    option :group do
+        long '--group'
+        desc 'group to run as'
+        default nil
+    end
+
+    option :root do
+        long '--root'
+        desc 'app root (defaults to the current directory)'
+        default Dir.pwd
+    end
+
+    separator ''
+    separator 'Common options: '
+
+    option :help do
+        short '-h'
+        long '--help'
+        desc 'Show this message'
+        action { Choice.help }
+    end
+
+    option :version do
+        short '-v'
+        long '--version'
+        desc 'Show version'
+        action do
+            $stderr.puts Mizuno::HttpServer.version
+            exit            
+        end
+    end
+end
+
+

data/lib/mizuno/http_server.rb

@@ -1,15 +1,20 @@
-# Have Jetty log to stdout for the time being.
-java.lang.System.setProperty("org.eclipse.jetty.util.log.class", 
-    "org.eclipse.jetty.util.log.StdErrLog")
+require 'mizuno/version'
+require 'mizuno/java_logger'
 
 module Mizuno
     class HttpServer
+        include_class 'java.util.Properties'
+        include_class 'java.io.ByteArrayInputStream'
+        include_class 'org.apache.log4j.PropertyConfigurator'
         include_class 'org.eclipse.jetty.server.Server'
         include_class 'org.eclipse.jetty.servlet.ServletContextHandler'
         include_class 'org.eclipse.jetty.servlet.ServletHolder'
         include_class 'org.eclipse.jetty.server.nio.SelectChannelConnector'
         include_class 'org.eclipse.jetty.util.thread.QueuedThreadPool'
-        include_class 'org.eclipse.jetty.servlet.DefaultServlet'
+#        include_class 'org.eclipse.jetty.servlet.DefaultServlet'
+#        include_class 'org.eclipse.jetty.server.handler.HandlerCollection'
+#        include_class 'org.eclipse.jetty.server.handler.RequestLogHandler'
+#        include_class 'org.eclipse.jetty.server.NCSARequestLog'
 
         #
         # Provide accessors so we can set a custom logger and a location
@@ -32,19 +37,26 @@ module Mizuno
         #     String or integer with the port to bind to; defaults 
         #     to 9292.
         #
-        # FIXME: Clean up options hash (all downcase, all symbols)
+        # http://wiki.eclipse.org/Jetty/Tutorial/RequestLog
         #
-        def self.run(app, options = {})
+        # FIXME: Add SSL suport.
+        #
+        def HttpServer.run(app, options = {})
+            # Symbolize and downcase keys.
+            @options = options = Hash[options.map { |k, v| 
+                [ k.to_s.downcase.to_sym, v ] }]
+            options[:quiet] ||= true if options[:embedded]
+
             # The Jetty server
+            configure_logging(options)
             @server = Server.new
-
-            options = Hash[options.map { |o| 
-                [ o[0].to_s.downcase.to_sym, o[1] ] }]
+            @server.setSendServerVersion(false)
 
             # Thread pool
+            threads = options[:threads] || 50
             thread_pool = QueuedThreadPool.new
-            thread_pool.min_threads = 5
-            thread_pool.max_threads = 50
+            thread_pool.min_threads = [ threads.to_i / 10, 5 ].max
+            thread_pool.max_threads = [ threads.to_i, 10 ].max
             @server.set_thread_pool(thread_pool)
 
             # Connector
@@ -53,20 +65,36 @@ module Mizuno
             connector.setHost(options[:host])
             @server.addConnector(connector)
 
-            # Servlet context.
-            context = ServletContextHandler.new(nil, "/", 
+            # Switch to a different user or group if we were asked to.
+            Runner.setgid(options) if options[:group]
+            Runner.setuid(options) if options[:user]
+
+            # Servlet handler.
+            app_handler = ServletContextHandler.new(nil, "/", 
                 ServletContextHandler::NO_SESSIONS)
 
             # The servlet itself.
             rack_servlet = RackServlet.new
             rack_servlet.rackup(app)
             holder = ServletHolder.new(rack_servlet)
-            context.addServlet(holder, "/")
+            app_handler.addServlet(holder, "/")
+
+#            # Our request log.
+#            request_log = NCSARequestLog.new
+#            request_log.setLogTimeZone("GMT")
+#            request_log_handler = RequestLogHandler.new
+#            request_log_handler.setRequestLog(request_log)
+#
+#            # Add handlers in order.
+#            handlers = HandlerCollection.new
+#            handlers.addHandler(request_log_handler)
+#            handlers.addHandler(app_handler)
 
             # Add the context to the server and start.
-            @server.set_handler(context)
-            puts "Listening on #{connector.getHost}:#{connector.getPort}"
+            @server.set_handler(app_handler)
             @server.start
+            $stderr.printf("%s listening on %s:%s\n", version,
+                connector.host, connector.port) unless options[:quiet]
 
             # If we're embeded, we're done.
             return if options[:embedded]
@@ -83,10 +111,66 @@ module Mizuno
         #
         # Shuts down an embedded Jetty instance.
         #
-        def self.stop
+        def HttpServer.stop
             return unless @server
-            puts "Stopping Jetty..."
+            $stderr.print "Stopping Jetty..." unless @options[:quiet]
             @server.stop
+            $stderr.puts "done." unless @options[:quiet]
+        end
+
+        #
+        # Returns the full version string.
+        #
+        def HttpServer.version
+            "Mizuno #{Mizuno::VERSION} (Jetty #{Server.getVersion})"
+        end
+
+        #
+        # Configure Log4J.
+        #
+        def HttpServer.configure_logging(options)
+            return if @logger
+
+            # Default logging threshold.
+            limit = options[:warn] ? "WARN" : "ERROR"
+            limit = "DEBUG" if ($DEBUG or options[:debug])
+
+            # Base logging configuration.
+            config = <<-END
+                log4j.rootCategory = #{limit}, default
+                log4j.logger.org.eclipse.jetty.util.log = #{limit}, default
+                log4j.logger.ruby = INFO, ruby
+                log4j.appender.default.Threshold = #{limit}
+                log4j.appender.default.layout = org.apache.log4j.PatternLayout
+                log4j.appender.default.layout.ConversionPattern = %d %p %m
+                log4j.appender.ruby.Threshold = INFO
+                log4j.appender.ruby.layout = org.apache.log4j.PatternLayout
+                log4j.appender.ruby.layout.ConversionPattern = %m
+            END
+
+            # Should we log to the console?
+            config.concat(<<-END) unless options[:log]
+                log4j.appender.default = org.apache.log4j.ConsoleAppender
+                log4j.appender.ruby = org.apache.log4j.ConsoleAppender
+            END
+
+            # Are we logging to a file?
+            config.concat(<<-END) if options[:log]
+                log4j.appender.default = org.apache.log4j.FileAppender
+                log4j.appender.default.File = #{options[:log]}
+                log4j.appender.default.Append = true
+                log4j.appender.ruby = org.apache.log4j.FileAppender
+                log4j.appender.ruby.File = #{options[:log]}
+                log4j.appender.ruby.Append = true
+            END
+
+            # Set up Log4J via Properties.
+            properties = Properties.new
+            properties.load(ByteArrayInputStream.new(config.to_java_bytes))
+            PropertyConfigurator.configure(properties)
+
+            # Use log4j for our logging as well.
+            @logger = JavaLogger.new
         end
     end
 end

data/lib/mizuno/java_logger.rb

@@ -0,0 +1,37 @@
+require 'logger'
+
+module Mizuno
+    class JavaLogger < Logger
+        LEVELS = {
+            Logger::DEBUG => Java.org.apache.log4j.Level::DEBUG,
+            Logger::INFO => Java.org.apache.log4j.Level::INFO,
+            Logger::WARN => Java.org.apache.log4j.Level::WARN,
+            Logger::ERROR => Java.org.apache.log4j.Level::ERROR,
+            Logger::FATAL => Java.org.apache.log4j.Level::FATAL }
+
+        def initialize
+            @log4j = Java.org.apache.log4j.Logger.getLogger('ruby')
+        end
+
+        def add(severity, message = nil, progname = nil)
+            content = (message or (block_given? and yield) or progname)
+            @log4j.log(LEVELS[severity], content)
+        end
+
+        def puts(message)
+            write(message.to_s)
+        end
+
+        def write(message)
+            add(INFO, message)
+        end
+
+        def flush
+            # No-op.
+        end
+
+        def close
+            # No-op.
+        end
+    end
+end

data/lib/mizuno/rack/chunked.rb

@@ -0,0 +1,19 @@
+require 'rack/utils'
+
+#
+# We replace the default Rack::Chunked implementation with a non-op
+# version, as Jetty handles chunking for us.
+#
+module Rack
+    class Chunked
+        include Rack::Utils
+
+        def initialize(app)
+            @app = app
+        end
+
+        def call(env)
+            @app.call(env)
+        end
+    end
+end

data/lib/mizuno/rack_servlet.rb

@@ -1,4 +1,5 @@
 require 'stringio'
+require 'rack/response'
 
 #
 # Wraps a Rack application in a Java servlet.
@@ -15,6 +16,7 @@ module Mizuno
     class RackServlet < HttpServlet
         include_class java.io.FileInputStream
         include_class org.eclipse.jetty.continuation.ContinuationSupport
+        include_class org.jruby.rack.servlet.RewindableInputStream
 
         #
         # Sets the Rack application that handles requests sent to this
@@ -40,47 +42,49 @@ module Mizuno
         # empty body, we declare the async response finished.
         #
         def service(request, response)
-            # Turn the ServletRequest into a Rack env hash
-            env = servlet_to_rack(request)
-
-            # Handle asynchronous responses via Servlet continuations.
-            continuation = ContinuationSupport.getContinuation(request)
-
-            # If this is an expired connection, do nothing.
-            return if continuation.isExpired
-
-            # We should never be re-dispatched.
-            raise("Request re-dispatched.") unless continuation.isInitial
-
-            # Add our own special bits to the rack environment so that 
-            # Rack middleware can have access to the Java internals.
-            env['rack.java.servlet'] = true
-            env['rack.java.servlet.request'] = request
-            env['rack.java.servlet.response'] = response
-            env['rack.java.servlet.continuation'] = continuation
-
-            # Add an callback that can be used to add results to the
-            # response asynchronously.
-            env['async.callback'] = lambda do |rack_response|
-                servlet_response = continuation.getServletResponse
-                rack_to_servlet(rack_response, servlet_response) \
-                    and continuation.complete
-            end
+            handle_exceptions(response) do
+                # Turn the ServletRequest into a Rack env hash
+                env = servlet_to_rack(request)
+
+                # Handle asynchronous responses via Servlet continuations.
+                continuation = ContinuationSupport.getContinuation(request)
+
+                # If this is an expired connection, do nothing.
+                return if continuation.isExpired
+
+                # We should never be re-dispatched.
+                raise("Request re-dispatched.") unless continuation.isInitial
+
+                # Add our own special bits to the rack environment so that 
+                # Rack middleware can have access to the Java internals.
+                env['rack.java.servlet'] = true
+                env['rack.java.servlet.request'] = request
+                env['rack.java.servlet.response'] = response
+                env['rack.java.servlet.continuation'] = continuation
+
+                # Add an callback that can be used to add results to the
+                # response asynchronously.
+                env['async.callback'] = lambda do |rack_response|
+                    servlet_response = continuation.getServletResponse
+                    rack_to_servlet(rack_response, servlet_response) \
+                        and continuation.complete
+                end
 
-            # Execute the Rack request.
-            catch(:async) do
-                rack_response = @app.call(env)
-               
-                # For apps that don't throw :async.
-                unless(rack_response[0] == -1)
-                    # Nope, nothing asynchronous here.
-                    rack_to_servlet(rack_response, response)
-                    return
+                # Execute the Rack request.
+                catch(:async) do
+                    rack_response = @app.call(env)
+                   
+                    # For apps that don't throw :async.
+                    unless(rack_response[0] == -1)
+                        # Nope, nothing asynchronous here.
+                        rack_to_servlet(rack_response, response)
+                        return
+                    end
                 end
-            end
 
-            # If we got here, this is a continuation.
-            continuation.suspend(response)
+                # If we got here, this is a continuation.
+                continuation.suspend(response)
+            end
         end
 
         private
@@ -123,12 +127,12 @@ module Mizuno
             env['rack.run_once'] = false
 
             # The input stream is a wrapper around the Java InputStream.
-            env['rack.input'] = request.getInputStream.to_io.binmode
+            env['rack.input'] = RewindableInputStream.new( \
+                request.getInputStream).to_io.binmode
 
             # Force encoding if we're on Ruby 1.9
             env['rack.input'].set_encoding(Encoding.find("ASCII-8BIT")) \
                 if env['rack.input'].respond_to?(:set_encoding)
-#            puts "**** rack.input.encoding: #{env['rack.input'].encoding}"
 
             # Populate the HTTP headers.
             request.getHeaderNames.each do |header_name|
@@ -143,8 +147,9 @@ module Mizuno
             env["CONTENT_LENGTH"] = env.delete("HTTP_CONTENT_LENGTH") \
                 if env["HTTP_CONTENT_LENGTH"]
 
-            # The output stream defaults to stderr.
-            env['rack.errors'] ||= $stderr
+            # Route errors through the logger.
+            env['rack.errors'] ||= HttpServer.logger
+            env['rack.logger'] ||= HttpServer.logger
 
             # All done, hand back the Rack request.
             return(env)
@@ -179,7 +184,7 @@ module Mizuno
             # data out on an async request.
             unless(response.isCommitted)
                 # Set the HTTP status code.
-                response.setStatus(status)
+                response.setStatus(status.to_i)
 
                 # Did we get a Content-Length header?
                 content_length = headers.delete('Content-Length')
@@ -222,5 +227,22 @@ module Mizuno
             # All done.
             output.flush
         end
+
+        #
+        # Handle exceptions, returning a generic 500 error response.
+        #
+        def handle_exceptions(response)
+            begin
+                yield
+            rescue => error
+                message = "Exception: #{error}"
+                message << "\n#{error.backtrace.join("\n")}" \
+                    if (error.respond_to?(:backtrace))
+                HttpServer.logger.error(message)
+                return if response.isCommitted
+                response.reset
+                response.setStatus(500)
+            end
+        end
     end
 end

data/lib/mizuno/runner.rb

@@ -0,0 +1,244 @@
+require 'ffi'
+require 'net/http'
+require 'choice'
+require 'mizuno/choices'
+require 'childprocess'
+require 'fileutils'
+require 'etc'
+require 'rack'
+
+module Mizuno
+    #
+    # Launches Mizuno when called from the command-line, and handles
+    # damonization via FFI.
+    #
+    # 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
+
+        #
+        # Launch Jetty, optionally as a daemon.
+        #
+        def Runner.start!
+            # Default rackup is in config.ru
+            config = (Choice.rest.first or "config.ru")
+
+            # Create an options hash with only symbols.
+            choices = Choice.choices.merge(:config => config)
+            options = Hash[choices.map { |k, v| [ k.to_sym, v ] }]
+
+            # Resolve relative paths to the logfile, etc.
+            root = options[:root]
+            options[:pidfile] = Runner.resolve_path(root, options[:pidfile])
+            options[:log] = Runner.resolve_path(root, options[:log])
+            options[:public] = Runner.resolve_path(root, options[:public])
+
+            # Require multiple libraries.
+            options.delete(:require).each { |r| require r }
+
+            # Handle daemon-related commands.
+            Runner.status(options) if options.delete(:status)
+            Runner.reload(options) if options.delete(:reload)
+            Runner.stop(options) if options.delete(:stop)
+            Runner.kill(options) if options.delete(:kill)
+            Runner.daemonize(options) if options.delete(:daemonize)
+
+            # Fire up Mizuno as if it was called from Rackup.
+            Dir.chdir(options[:root])
+            HttpServer.configure_logging(options)
+            server = Rack::Server.new
+            server.options = options.merge(:server => 'mizuno',
+                :environment => options[:env])
+            server.start
+        end
+
+        #
+        # Relaunch as a daemon.
+        #
+        def Runner.daemonize(options)
+            # Ensure that Mizuno isn't running.
+            Runner.pid(options) and die("Mizuno is already running.")
+
+            # Build a command line that should launch JRuby with the
+            # appropriate options; this depends on the proper jruby
+            # being in the $PATH
+            config = options.delete(:config)
+            args = Mizuno::LAUNCH_ENV.concat(options.map { |k, v| 
+                (v.to_s.empty?) ? nil : [ "--#{k}", v.to_s ] }.compact.flatten)
+            args.push(config)
+            args.unshift('jruby')
+
+            # Launch a detached child process.
+            child = ChildProcess.build(*args)
+            child.io.inherit!
+            child.detach = true
+            child.start
+            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)
+            child.stop
+            die("Failed to start Mizuno.")
+        end
+
+        #
+        # Return the status of a running daemon.
+        #
+        def Runner.status(options)
+            die("Mizuno doesn't appear to be running.") \
+                unless (pid = Runner.pid(options))
+            die("Mizuno is running, but not online.") \
+                unless(wait_for_server(options))
+            die("Mizuno is running.", true)
+        end
+
+        #
+        # Reload a running daemon by SIGHUPing it.
+        #
+        def Runner.reload(options)
+            pid = Runner.pid(options) or die("Mizuno isn't running.")
+            Process.kill("HUP", pid)
+            die("Mizuno signaled to reload app.", true)
+        end
+
+        #
+        # Stop a running daemon (SIGKILL)
+        #
+        def Runner.stop(options)
+            pid = Runner.pid(options) or die("Mizuno isn't running.")
+            print "Stopping Mizuno..."
+            Process.kill("KILL", pid)
+            die("failed") unless wait_for_server_to_die(options)
+            FileUtils.rm(options[:pidfile])
+            die("stopped", true)
+        end
+
+        #
+        # Really stop a running daemon (SIGTERM)
+        #
+        def Runner.kill(options)
+            pid = Runner.pid(options) or die("Mizuno isn't running.")
+            $stderr.puts "Terminating Mizuno with extreme prejudice..."
+            Process.kill("TERM", pid)
+            die("failed") unless wait_for_server_to_die(options)
+            FileUtils.rm(options[:pidfile])
+            die("stopped", true)
+        end
+
+        #
+        # Transform a relative path to an absolute path.
+        #
+        def Runner.resolve_path(root, path)
+            return(path) unless path.is_a?(String)
+            return(path) if (path =~ /^\//)
+            File.expand_path(File.join(root, path))
+        end
+
+        #
+        # Fetches the PID from the :pidfile.
+        #
+        def Runner.pid(options)
+            options[:pidfile] or die("Speficy a --pidfile to daemonize.") 
+            return unless File.exists?(options[:pidfile])
+            pid = File.read(options[:pidfile]).to_i
+
+            # FIXME: This is a hacky way to get the process list, but I
+            # haven't found a good cross-platform solution yet; this
+            # should work on MacOS and Linux, possibly Solaris and BSD,
+            # and almost definitely not on Windows.
+            process = `ps ax`.lines.select { |l| l =~ /^\s*#{pid}\s*/ }
+            return(pid) if (process.join =~ /\bmizuno\b/)
+
+            # Stale pidfile; remove.
+            $stderr.puts("Removing stale pidfile '#{options[:pidfile]}'")
+            FileUtils.rm(options[:pidfile])
+            return(nil)
+        end
+
+        #
+        # Wait until _timeout_ seconds for a successful http connection;
+        # returns true if we could connect and didn't get a server
+        # error, false otherwise.
+        #
+        def Runner.wait_for_server(options, timeout = 10)
+            begin
+                Net::HTTP.start(options[:host], options[:port]) do |http|
+                    http.read_timeout = timeout
+                    response = http.get("/")
+                    return(response.code.to_i < 500)
+                end
+            rescue Errno::ECONNREFUSED => error
+                return(false) unless ((timeout -= 0.5) > 0)
+                sleep(0.5)
+                retry
+            rescue => error
+                puts "HTTP Error '#{error}'"
+                return(false)
+            end
+        end
+
+        #
+        # Like wait_for_server, but returns true when the server goes
+        # offline. If we hit _timeout_ seconds and the server is still
+        # responding, returns false.
+        #
+        def Runner.wait_for_server_to_die(options, timeout = 10)
+            begin
+                while(timeout > 0)
+                    Net::HTTP.start(options[:host], options[:port]) do |http|
+                        http.read_timeout = timeout
+                        response = http.get("/")
+                        puts "**** (die) response: #{response}"
+                    end
+                    timeout -= 0.5
+                    sleep(0.5)
+                end
+                return(false)
+            rescue Errno::ECONNREFUSED => error
+                return(true)
+            rescue => error
+                puts "**** http error: #{error}"
+                return(true)
+            end
+        end
+
+        #
+        # Exit with a message and a status value.
+        #
+        # FIXME: Dump these in the logfile if called from HttpServer?
+        #
+        def Runner.die(message, success = false)
+            $stderr.puts(message)
+            exit(success ? 0 : 1)
+        end
+    end
+end

data/lib/mizuno/version.rb

@@ -0,0 +1,3 @@
+module Mizuno
+    VERSION = "0.5.0"
+end

data/mizuno.gemspec

@@ -1,14 +1,16 @@
+require 'lib/mizuno/version'
+
 Gem::Specification.new do |spec|
     spec.name = "mizuno"
-    spec.version = "0.4.1"
+    spec.version = Mizuno::VERSION
     spec.required_rubygems_version = Gem::Requirement.new(">= 1.2") \
         if spec.respond_to?(:required_rubygems_version=)
     spec.authors = [ "Don Werve" ]
     spec.description = 'Jetty-powered running shoes for JRuby/Rack.'
-    spec.summary = 'Rack handler for Jetty 7 on JRuby.  Features multithreading, event-driven I/O, and async support.'
+    spec.summary = 'Rack handler for Jetty 8 on JRuby. Features multithreading, event-driven I/O, and async support.'
     spec.email = 'don@madwombat.com'
-    # FIXME: We're not getting put in bin/
     spec.executables = [ "mizuno" ]
+    # FIXME: Use Dir.glob for this
     spec.files = %w(.gitignore
         README.markdown
         LICENSE
@@ -16,8 +18,13 @@ Gem::Specification.new do |spec|
         Gemfile
         mizuno.gemspec
         tmp/.gitkeep
+        lib/mizuno/choices.rb
         lib/mizuno/http_server.rb
+        lib/mizuno/java_logger.rb
+        lib/mizuno/rack/chunked.rb
         lib/mizuno/rack_servlet.rb
+        lib/mizuno/runner.rb
+        lib/mizuno/version.rb
         lib/mizuno.rb
         bin/mizuno)
     jars = Dir.entries("lib/java").grep(/\.jar$/)
@@ -27,8 +34,11 @@ Gem::Specification.new do |spec|
     spec.require_paths = [ "lib" ]
     spec.rubygems_version = '1.3.6'
     spec.add_dependency('rack', '>= 1.0.0')
+    spec.add_dependency('ffi', '>= 1.0.0')
+    spec.add_dependency('choice', '>= 0.1.0')
+    spec.add_dependency('childprocess', '>= 0.2.6')
     spec.add_development_dependency('rspec', '>= 2.7.0')
     spec.add_development_dependency('rspec-core', '>= 2.7.0')
-    spec.add_development_dependency('json_pure', '>= 1.6.1')
+    spec.add_development_dependency('json_pure', '>= 1.6.0')
     spec.add_development_dependency('nokogiri')
 end

metadata

@@ -2,7 +2,7 @@
 name: mizuno
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors: 
   - Don Werve
@@ -10,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-19 00:00:00 +09:00
-default_executable: 
+date: 2012-01-08 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: rack
@@ -25,49 +24,82 @@ dependencies:
     type: :runtime
     version_requirements: *id001
   - !ruby/object:Gem::Dependency 
-    name: rspec
+    name: ffi
     prerelease: false
     requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.0.0
+    type: :runtime
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: choice
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.1.0
+    type: :runtime
+    version_requirements: *id003
+  - !ruby/object:Gem::Dependency 
+    name: childprocess
+    prerelease: false
+    requirement: &id004 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.2.6
+    type: :runtime
+    version_requirements: *id004
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id005 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: 2.7.0
     type: :development
-    version_requirements: *id002
+    version_requirements: *id005
   - !ruby/object:Gem::Dependency 
     name: rspec-core
     prerelease: false
-    requirement: &id003 !ruby/object:Gem::Requirement 
+    requirement: &id006 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: 2.7.0
     type: :development
-    version_requirements: *id003
+    version_requirements: *id006
   - !ruby/object:Gem::Dependency 
     name: json_pure
     prerelease: false
-    requirement: &id004 !ruby/object:Gem::Requirement 
+    requirement: &id007 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: 1.6.1
+            version: 1.6.0
     type: :development
-    version_requirements: *id004
+    version_requirements: *id007
   - !ruby/object:Gem::Dependency 
     name: nokogiri
     prerelease: false
-    requirement: &id005 !ruby/object:Gem::Requirement 
+    requirement: &id008 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
             version: "0"
     type: :development
-    version_requirements: *id005
+    version_requirements: *id008
 description: Jetty-powered running shoes for JRuby/Rack.
 email: don@madwombat.com
 executables: 
@@ -84,8 +116,13 @@ files:
   - Gemfile
   - mizuno.gemspec
   - tmp/.gitkeep
+  - lib/mizuno/choices.rb
   - lib/mizuno/http_server.rb
+  - lib/mizuno/java_logger.rb
+  - lib/mizuno/rack/chunked.rb
   - lib/mizuno/rack_servlet.rb
+  - lib/mizuno/runner.rb
+  - lib/mizuno/version.rb
   - lib/mizuno.rb
   - bin/mizuno
   - lib/java/jetty-continuation-8.0.4.v20111024.jar
@@ -97,8 +134,11 @@ files:
   - 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/log4j-1.2.16.jar
+  - lib/java/rewindable-input-stream.jar
   - lib/java/servlet-api-3.0.jar
-has_rdoc: true
+  - lib/java/slf4j-api-1.6.4.jar
+  - lib/java/slf4j-log4j12-1.6.4.jar
 homepage: http://github.com/matadon/mizuno
 licenses: []
 
@@ -122,9 +162,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.1
+rubygems_version: 1.8.9
 signing_key: 
 specification_version: 3
-summary: Rack handler for Jetty 7 on JRuby.  Features multithreading, event-driven I/O, and async support.
+summary: Rack handler for Jetty 8 on JRuby. Features multithreading, event-driven I/O, and async support.
 test_files: []