mizuno 0.6.1 → 0.6.3

data/lib/mizuno.rb

@@ -4,23 +4,36 @@
 # Written by Don Werve <don@madwombat.com>
 #
 
+require 'java'
+
 # Save our launch environment for spawning children later.
 module Mizuno
     LAUNCH_ENV = $LOAD_PATH.map { |i| "-I#{i}" }.push($0)
-end
 
-# Load up Java dependencies.
-require 'java'
-jars = File.join(File.dirname(__FILE__), 'java', '*.jar')
-Dir[jars].each { |j| require j }
+    HOME = File.expand_path(File.dirname(__FILE__))
+
+    #
+    # Tell log4j not to complain to the console about a missing
+    # log4j.properties file, as we configure it programmatically in
+    # Mizuno::Server (http://stackoverflow.com/questions/6849887)
+    #
+    def Mizuno.initialize_logger
+        require_jars(%w(log4j slf4j-api slf4j-log4j12))
+        Java.org.apache.log4j.Logger.getRootLogger.setLevel( \
+            Java.org.apache.log4j.Level::INFO)
+    end
 
-# 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)
+    #
+    # Loads jarfiles independent of versions.
+    #
+    def Mizuno.require_jars(*names)
+        names.flatten.each do |name|
+            file = Dir[File.join(HOME, 'java', "#{name}-*.jar")].first
+            file ||= Dir[File.join(HOME, 'java', "#{name}.jar")].first
+            raise("Unknown or missing jar: #{name}") unless file
+            require file
+        end
+    end
+end
 
-require 'rack'
-require 'mizuno/rack/chunked'
-require 'mizuno/rack_servlet'
-require 'mizuno/http_server'
+Mizuno.initialize_logger

data/lib/mizuno/choices.rb

@@ -155,7 +155,7 @@ Choice.options do
         long '--version'
         desc 'Show version'
         action do
-            $stderr.puts Mizuno::HttpServer.version
+            $stderr.puts Mizuno::Server.version
             exit            
         end
     end

data/lib/mizuno/client.rb

@@ -0,0 +1,62 @@
+require 'thread'
+require 'mizuno'
+Mizuno.require_jars(%w(jetty-client jetty-http jetty-io jetty-util))
+require 'mizuno/client_exchange'
+
+module Mizuno
+    class Client
+        java_import 'org.eclipse.jetty.client.HttpClient'
+        java_import 'org.eclipse.jetty.util.thread.QueuedThreadPool'
+
+        @lock = Mutex.new
+
+        def Client.request(*args, &block)
+            @lock.synchronize { @root ||= new }
+            @root.request(*args, &block)
+        end
+
+        def Client.stop
+            @lock.synchronize do
+                return unless @root
+                @root.stop
+                @root = nil
+            end
+        end
+
+        def initialize(options = {})
+            defaults = { :timeout => 60 }
+            options = defaults.merge(options)
+            @client = HttpClient.new
+            @client.setConnectorType(HttpClient::CONNECTOR_SELECT_CHANNEL)
+            @client.setMaxConnectionsPerAddress(100)
+            @client.setThreadPool(QueuedThreadPool.new(50))
+            @client.setTimeout(options[:timeout] * 1000)
+            @client.start
+            @lock = Mutex.new
+            @exchanges = []
+        end
+
+        def stop(wait = true)
+            wait and @lock.synchronize do
+                @exchanges.each { |e| e.waitForDone }
+                @exchanges.clear
+            end
+            @client.stop
+        end
+
+        def clear(exchange)
+            return unless @lock.try_lock
+            @exchanges.delete(exchange)
+            @lock.unlock
+        end
+
+        def request(url, options = {}, &block)
+            exchange = ClientExchange.new(self)
+            @lock.synchronize { @exchanges << exchange }
+            exchange.setup(url, options, &block)
+            @client.send(exchange)
+            return(exchange)
+        end
+    end
+end
+

data/lib/mizuno/client_exchange.rb

@@ -0,0 +1,72 @@
+require 'stringio'
+require 'mizuno/client_response'
+
+module Mizuno
+    java_import 'org.eclipse.jetty.client.ContentExchange'
+
+    # what do I want to happen on a timeout or error?
+
+    class ClientExchange < ContentExchange
+        def initialize(client)
+            super(false)
+            @client = client
+        end
+
+        def setup(url, options = {}, &block)
+            @callback = block
+            @response = ClientResponse.new(url)
+            setURL(url)
+            @response.ssl = (getScheme == 'https')
+            setMethod((options[:method] or "GET").upcase)
+            headers = options[:headers] and headers.each_pair { |k, v| 
+                setRequestHeader(k, v) }
+            return unless options[:body]
+            body = StringIO.new(options[:body].read)
+            setRequestContentSource(body.to_inputstream) 
+        end
+
+        def onResponseHeader(name, value)
+            @response[name.to_s] = value.to_s
+        end
+
+        def onResponseComplete
+            @client.clear(self)
+            @response.status = getResponseStatus
+            @response.body = getResponseContent
+            run_callback
+        end
+
+        def onExpire
+            @client.clear(self)
+            @response.timeout = true
+            @response.status = -1
+            @response.body = nil
+            run_callback
+        end
+
+        def onException(error)
+            @exception ||= error
+        end
+
+        def onConnectionFailed(error)
+            @exception ||= error
+        end
+
+        def run_callback
+            begin
+                @callback.call(@response)
+            rescue => error
+                onException(error)
+            end
+        end
+
+        def waitForDone
+            super
+            throw(@exception) if @exception
+        end
+#
+#        def finished?
+#            #FIXME: Implement.
+#        end
+    end
+end

data/lib/mizuno/client_response.rb

@@ -0,0 +1,34 @@
+require 'rack/response'
+
+module Mizuno
+    class ClientResponse
+        include Rack::Response::Helpers
+
+        attr_accessor :url, :status, :headers, :body, :ssl, :timeout
+        
+        def initialize(url)
+            @url = url
+            @headers = Rack::Utils::HeaderHash.new
+        end
+
+        def [](key)
+            @headers[key]
+        end
+
+        def []=(key, value)
+            @headers[key] = value
+        end
+
+        def ssl?
+            @ssl == true
+        end
+
+        def timeout?
+            (@timeout == true) or (@status == 408)
+        end
+
+        def success?
+            successful? or redirect?
+        end
+    end
+end

data/lib/mizuno/logger.rb

@@ -0,0 +1,87 @@
+require 'logger'
+
+module Mizuno
+    class Logger < ::Logger
+        java_import 'java.io.ByteArrayInputStream'
+        java_import 'java.util.Properties'
+        java_import 'org.apache.log4j.PropertyConfigurator'
+
+        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 }
+
+        #
+        # Configure Log4J.
+        #
+        def Logger.configure(options = {})
+            return if @options
+            @options = options
+
+            # 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.appender.default.Threshold = #{limit}
+                log4j.appender.default.layout = org.apache.log4j.PatternLayout
+            END
+
+            # Should we log to the console?
+            config.concat(<<-END) unless options[:log]
+                log4j.appender.default = org.apache.log4j.ConsoleAppender
+                log4j.appender.default.layout.ConversionPattern = %m\\n
+            END
+
+            # Are we logging to a file?
+            config.concat(<<-END) if options[:log]
+                log4j.appender.default = org.apache.log4j.FileAppender
+                log4j.appender.default.Append = true
+                log4j.appender.default.File = #{options[:log]}
+                log4j.appender.default.layout.ConversionPattern = %d %p %m\\n
+            END
+
+            # Set up Log4J via Properties.
+            properties = Properties.new
+            properties.load(ByteArrayInputStream.new(config.to_java_bytes))
+            PropertyConfigurator.configure(properties)
+
+            # Create the default logger that gets used everywhere.
+            @logger = new
+        end
+
+        def Logger.logger
+            @logger
+        end
+
+        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_servlet.rb

@@ -11,16 +11,21 @@ require 'rack/response'
 #         /servlet/http/HttpServlet.html
 #
 module Mizuno
-    include_class javax.servlet.http.HttpServlet
+    java_import 'javax.servlet.http.HttpServlet'
 
     class RackServlet < HttpServlet
-        include_class java.io.FileInputStream
-        include_class org.eclipse.jetty.continuation.ContinuationSupport
-        include_class org.jruby.rack.servlet.RewindableInputStream
+        java_import 'java.io.FileInputStream'
+        java_import 'org.eclipse.jetty.continuation.ContinuationSupport'
+        java_import 'org.jruby.rack.servlet.RewindableInputStream'
 
         # Regex for splitting on newlines.
         NEWLINE = /\n/
 
+        def initialize(server)
+            @server = server
+            super()
+        end
+
         #
         # Sets the Rack application that handles requests sent to this
         # servlet container.
@@ -67,7 +72,7 @@ module Mizuno
 
                 # Add an callback that can be used to add results to the
                 # response asynchronously.
-                env['async.callback'] = lambda do |rack_response|
+                env['async.callback'] = Proc.new do |rack_response|
                     servlet_response = continuation.getServletResponse
                     rack_to_servlet(rack_response, servlet_response) \
                         and continuation.complete
@@ -117,7 +122,7 @@ module Mizuno
             env['SCRIPT_NAME'] = ""
 
             # Rack says URI, but it hands off a URL.
-            env['REQUEST_URI'] = request.getRequestURL.toString
+            env['REQUEST_URI'] = request.getRequestURL.to_s
 
             # Java chops off the query string, but a Rack application will
             # expect it, so we'll add it back if present
@@ -151,8 +156,8 @@ module Mizuno
                 if env["HTTP_CONTENT_LENGTH"]
 
             # Route errors through the logger.
-            env['rack.errors'] ||= HttpServer.logger
-            env['rack.logger'] ||= HttpServer.logger
+            env['rack.errors'] ||= @server.logger
+            env['rack.logger'] ||= @server.logger
 
             # All done, hand back the Rack request.
             return(env)
@@ -244,7 +249,7 @@ module Mizuno
                 message = "Exception: #{error}"
                 message << "\n#{error.backtrace.join("\n")}" \
                     if (error.respond_to?(:backtrace))
-                HttpServer.logger.error(message)
+                Server.logger.error(message)
                 return if response.isCommitted
                 response.reset
                 response.setStatus(500)

data/lib/mizuno/reloader.rb

@@ -12,6 +12,10 @@ module Mizuno
     # by sending a SIGHUP to the process.
     # 
     class Reloader
+        @reloaders = []
+
+        @trigger = 'tmp/restart.txt'
+
         class << self
             attr_accessor :logger, :trigger, :reloaders
         end
@@ -20,14 +24,15 @@ module Mizuno
             reloaders.each { |r| r.reload!(true) }
         end
 
-        def initialize(app, interval = 1)
+        def Reloader.add(reloader)
             Thread.exclusive do
-                self.class.reloaders ||= []
-                self.class.reloaders << self
-                self.class.logger ||= Mizuno::HttpServer.logger
-                self.class.trigger ||= "tmp/restart.txt"
+                @logger ||= Mizuno::Server.logger
+                @reloaders << reloader
             end
+        end
 
+        def initialize(app, interval = 1)
+            Reloader.add(self)
             @app = app
             @interval = interval
             @trigger = self.class.trigger

data/lib/mizuno/runner.rb

@@ -1,11 +1,14 @@
 require 'ffi'
 require 'net/http'
 require 'choice'
-require 'mizuno/choices'
 require 'childprocess'
 require 'fileutils'
 require 'etc'
 require 'rack'
+require 'mizuno'
+require 'mizuno/choices'
+require 'mizuno/server'
+require 'rack/handler/mizuno'
 
 module Mizuno
     require 'rbconfig'
@@ -99,7 +102,7 @@ module Mizuno
 
             # Fire up Mizuno as if it was called from Rackup.
             Dir.chdir(options[:root])
-            HttpServer.configure_logging(options)
+            Logger.configure(options)
             ENV['RACK_ENV'] = options[:env]
             server = Rack::Server.new
             server.options = options.merge(:server => 'mizuno',
@@ -260,7 +263,7 @@ module Mizuno
         #
         # Exit with a message and a status value.
         #
-        # FIXME: Dump these in the logfile if called from HttpServer?
+        # FIXME: Dump these in the logfile if called from Server?
         #
         def Runner.die(message, success = false)
             $stderr.puts(message)
@@ -268,3 +271,6 @@ module Mizuno
         end
     end
 end
+
+# Ensure that we shutdown the server on exit.
+at_exit { Mizuno::Server.stop }

data/lib/mizuno/server.rb

@@ -0,0 +1,138 @@
+# FIXME: mizuno/http_server needs to still work, but we will throw out a
+# deprecation notice and remove it in later versions.
+
+require 'rack'
+require 'mizuno'
+Mizuno.require_jars(%w(jetty-continuation jetty-http jetty-io jetty-jmx
+    jetty-security jetty-server jetty-servlet jetty-servlets jetty-util
+    servlet-api rewindable-input-stream))
+require 'mizuno/version'
+require 'mizuno/rack/chunked'
+require 'mizuno/rack_servlet'
+require 'mizuno/logger'
+require 'mizuno/reloader'
+
+module Mizuno
+    class Server
+        java_import 'org.eclipse.jetty.servlet.ServletContextHandler'
+        java_import 'org.eclipse.jetty.servlet.ServletHolder'
+        java_import 'org.eclipse.jetty.server.nio.SelectChannelConnector'
+        java_import 'org.eclipse.jetty.util.thread.QueuedThreadPool'
+
+        attr_accessor :logger
+
+        @lock ||= Mutex.new
+
+        def Server.run(app, options = {})
+            @lock.synchronize do
+                return if @server
+                @server = new
+                @server.run(app, options)
+            end
+        end
+
+        def Server.stop
+            @lock.synchronize do 
+                return unless @server
+                @server.stop
+                @server = nil
+            end
+        end
+
+        def Server.logger
+            Logger.logger
+        end
+
+        #
+        # Start up an instance of Jetty, running a Rack application.
+        # Options can be any of the follwing, and are not
+        # case-sensitive:
+        #
+        # :host::
+        #     String specifying the IP address to bind to; defaults 
+        #     to 0.0.0.0.
+        #
+        # :port::
+        #     String or integer with the port to bind to; defaults 
+        #     to 9292.
+        #
+        def 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
+            Logger.configure(options)
+            @logger = Logger.logger
+            @server = Java.org.eclipse.jetty.server.Server.new
+            @server.setSendServerVersion(false)
+
+            # Thread pool
+            threads = options[:threads] || 50
+            thread_pool = QueuedThreadPool.new
+            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
+            connector = SelectChannelConnector.new
+            connector.setPort(options[:port].to_i)
+            connector.setHost(options[:host])
+            @server.addConnector(connector)
+
+            # 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)
+
+            # 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(self)
+            rack_servlet.rackup(app)
+            holder = ServletHolder.new(rack_servlet)
+            app_handler.addServlet(holder, "/")
+
+            # Add the context to the server and start.
+            @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]
+
+            # Stop the server when we get The Signal.
+            trap("SIGINT") { @server.stop and exit }
+
+            # Join with the server thread, so that currently open file
+            # descriptors don't get closed by accident.
+            # http://www.ruby-forum.com/topic/209252
+            @server.join
+        end
+
+        #
+        # Shuts down an embedded Jetty instance.
+        #
+        def stop
+            return unless @server
+            $stderr.print "Stopping Jetty..." unless @options[:quiet]
+            @server.stop
+            $stderr.puts "done." unless @options[:quiet]
+        end
+
+        #
+        # Returns the full version string.
+        #
+        def version
+            "Mizuno #{Mizuno::VERSION} (Jetty #{Java.org.eclipse.jetty.server.Server.getVersion})"
+        end
+    end
+end

data/lib/mizuno/version.rb

@@ -1,3 +1,3 @@
 module Mizuno
-    VERSION = "0.6.1"
+    VERSION = "0.6.3"
 end

data/lib/rack/handler/mizuno.rb

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

metadata

@@ -1,171 +1,169 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: mizuno
-version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.6.1
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.6.3
 platform: ruby
-authors: 
-  - Don Werve
-autorequire: 
+authors:
+- Don Werve
+autorequire:
 bindir: bin
 cert_chain: []
-
-date: 2012-04-23 00:00:00 Z
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: rack
-    prerelease: false
-    requirement: &id001 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: 1.0.0
-    type: :runtime
-    version_requirements: *id001
-  - !ruby/object:Gem::Dependency 
-    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: *id005
-  - !ruby/object:Gem::Dependency 
-    name: rspec-core
-    prerelease: false
-    requirement: &id006 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: 2.7.0
-    type: :development
-    version_requirements: *id006
-  - !ruby/object:Gem::Dependency 
-    name: json_pure
-    prerelease: false
-    requirement: &id007 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: 1.6.0
-    type: :development
-    version_requirements: *id007
-  - !ruby/object:Gem::Dependency 
-    name: nokogiri
-    prerelease: false
-    requirement: &id008 !ruby/object:Gem::Requirement 
-      none: false
-      requirements: 
-        - - ">="
-          - !ruby/object:Gem::Version 
-            version: "0"
-    type: :development
-    version_requirements: *id008
+date: 2012-04-29 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  version_requirements: &2056 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    none: false
+  requirement: *2056
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: ffi
+  version_requirements: &2074 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+    none: false
+  requirement: *2074
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: choice
+  version_requirements: &2090 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    none: false
+  requirement: *2090
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: childprocess
+  version_requirements: &2106 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.6
+    none: false
+  requirement: *2106
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: &2122 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+    none: false
+  requirement: *2122
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  version_requirements: &2140 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.7.0
+    none: false
+  requirement: *2140
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: json_pure
+  version_requirements: &2156 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+    none: false
+  requirement: *2156
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  version_requirements: &2172 !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  requirement: *2172
+  prerelease: false
+  type: :development
 description: Jetty-powered running shoes for JRuby/Rack.
 email: don@madwombat.com
-executables: 
-  - mizuno
+executables:
+- mizuno
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-  - .gitignore
-  - README.markdown
-  - LICENSE
-  - Rakefile
-  - Gemfile
-  - mizuno.gemspec
-  - bin/mizuno
-  - lib/mizuno.rb
-  - lib/mizuno/choices.rb
-  - lib/mizuno/http_server.rb
-  - lib/mizuno/java_logger.rb
-  - lib/mizuno/rack_servlet.rb
-  - lib/mizuno/reloader.rb
-  - lib/mizuno/runner.rb
-  - lib/mizuno/version.rb
-  - lib/mizuno/rack/chunked.rb
-  - lib/rack/handler/mizuno.rb
-  - 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
-  - lib/java/slf4j-api-1.6.4.jar
-  - lib/java/slf4j-log4j12-1.6.4.jar
+files:
+- .gitignore
+- README.markdown
+- LICENSE
+- Rakefile
+- Gemfile
+- mizuno.gemspec
+- bin/mizuno
+- lib/mizuno.rb
+- lib/mizuno/choices.rb
+- lib/mizuno/client.rb
+- lib/mizuno/client_exchange.rb
+- lib/mizuno/client_response.rb
+- lib/mizuno/logger.rb
+- lib/mizuno/rack_servlet.rb
+- lib/mizuno/reloader.rb
+- lib/mizuno/runner.rb
+- lib/mizuno/server.rb
+- lib/mizuno/version.rb
+- lib/mizuno/rack/chunked.rb
+- lib/rack/handler/mizuno.rb
+- lib/java/jetty-client-8.1.3.v20120416.jar
+- lib/java/jetty-continuation-8.1.3.v20120416.jar
+- lib/java/jetty-http-8.1.3.v20120416.jar
+- lib/java/jetty-io-8.1.3.v20120416.jar
+- lib/java/jetty-jmx-8.1.3.v20120416.jar
+- lib/java/jetty-security-8.1.3.v20120416.jar
+- lib/java/jetty-server-8.1.3.v20120416.jar
+- lib/java/jetty-servlet-8.1.3.v20120416.jar
+- lib/java/jetty-servlets-8.1.3.v20120416.jar
+- lib/java/jetty-util-8.1.3.v20120416.jar
+- lib/java/log4j-1.2.16.jar
+- lib/java/rewindable-input-stream.jar
+- lib/java/servlet-api-3.0.jar
+- lib/java/slf4j-api-1.6.4.jar
+- lib/java/slf4j-log4j12-1.6.4.jar
 homepage: http://github.com/matadon/mizuno
 licenses: []
-
-post_install_message: 
+post_install_message:
 rdoc_options: []
-
-require_paths: 
-  - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.2'
   none: false
-  requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "1.2"
 requirements: []
-
-rubyforge_project: 
+rubyforge_project:
 rubygems_version: 1.8.15
-signing_key: 
+signing_key:
 specification_version: 3
 summary: Rack handler for Jetty 8 on JRuby. Features multithreading, event-driven I/O, and async support.
 test_files: []
-
+...

data/lib/mizuno/http_server.rb

@@ -1,185 +0,0 @@
-require 'mizuno/version'
-require 'mizuno/java_logger'
-require 'mizuno/reloader'
-
-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.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
-        # for static assets.
-        #
-        class << self
-            attr_accessor :logger
-        end
-
-        #
-        # Start up an instance of Jetty, running a Rack application.
-        # Options can be any of the follwing, and are not
-        # case-sensitive:
-        #
-        # :host::
-        #     String specifying the IP address to bind to; defaults 
-        #     to 0.0.0.0.
-        #
-        # :port::
-        #     String or integer with the port to bind to; defaults 
-        #     to 9292.
-        #
-        # http://wiki.eclipse.org/Jetty/Tutorial/RequestLog
-        #
-        # 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
-            @server.setSendServerVersion(false)
-
-            # Thread pool
-            threads = options[:threads] || 50
-            thread_pool = QueuedThreadPool.new
-            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
-            connector = SelectChannelConnector.new
-            connector.setPort(options[:port].to_i)
-            connector.setHost(options[:host])
-            @server.addConnector(connector)
-
-            # 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)
-
-            # 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)
-            holder = ServletHolder.new(rack_servlet)
-            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(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]
-
-            # Stop the server when we get The Signal.
-            trap("SIGINT") { @server.stop and exit }
-
-            # Join with the server thread, so that currently open file
-            # descriptors don't get closed by accident.
-            # http://www.ruby-forum.com/topic/209252
-            @server.join
-        end
-
-        #
-        # Shuts down an embedded Jetty instance.
-        #
-        def HttpServer.stop
-            return unless @server
-            $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
-
-# Ensure that we shutdown the server on exit.
-at_exit { Mizuno::HttpServer.stop }

data/lib/mizuno/java_logger.rb

@@ -1,37 +0,0 @@
-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