mizuno-aspace 9.4.44

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/rack/chunked.rb

@@ -0,0 +1,35 @@
+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
+
+        class Body
+            include Rack::Utils
+
+            def initialize(body)
+                @body = body
+            end
+
+            def each(&block)
+                @body.each(&block)
+            end
+
+            def close
+                @body.close if @body.respond_to?(:close)
+            end
+        end
+
+        def initialize(app)
+            @app = app
+        end
+
+        def call(env)
+            @app.call(env)
+        end
+    end
+end

data/lib/mizuno/rack_handler.rb

@@ -0,0 +1,259 @@
+require 'stringio'
+require 'rack/response'
+
+#
+# Wraps a Rack application in a Jetty handler.
+#
+module Mizuno
+    java_import 'org.eclipse.jetty.server.handler.AbstractHandler'
+
+    class RackHandler < AbstractHandler
+        java_import 'java.io.FileInputStream'
+        java_import 'org.eclipse.jetty.continuation.ContinuationSupport'
+
+        # Regex for splitting on newlines.
+        NEWLINE = /\n/
+
+        def initialize(server)
+            @server = server
+            super()
+        end
+
+        #
+        # Sets the Rack application that handles requests sent to this
+        # Jetty handler.
+        #
+        def rackup(app)
+            @app = app
+        end
+
+        java_signature %{@Override void handle(String target,
+            Request baseRequest, HttpServletRequest request,
+            HttpServletResponse response) throws IOException, ServletException}
+
+        #
+        # Takes an incoming request (as a HttpServletRequest) and dispatches
+        # it to the rack application setup via [rackup]. All this really
+        # involves is translating the various bits of the Servlet API into
+        # the Rack API on the way in, and translating the response back on
+        # the way out.
+        #
+        # Also, we implement a common extension to the Rack api for
+        # asynchronous request processing.  We supply an 'async.callback'
+        # parameter in env to the Rack application.  If we catch an
+        # :async symbol thrown by the app, we initiate a Jetty continuation.
+        #
+        # When 'async.callback' gets a response with empty headers and an
+        # empty body, we declare the async response finished.
+        #
+        def handle(target, base_request, request, response)
+            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'] = Proc.new 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
+                    end
+                end
+
+                # If we got here, this is a continuation.
+                continuation.suspend(response)
+            end
+        end
+
+        private
+
+        #
+        # Turns a Servlet request into a Rack request hash.
+        #
+        def servlet_to_rack(request)
+            # The Rack request that we will pass on.
+            env = Hash.new
+
+            # Map Servlet bits to Rack bits.
+            env['REQUEST_METHOD'] = request.getMethod
+            env['QUERY_STRING'] = request.getQueryString.to_s
+            env['SERVER_NAME'] = request.getServerName
+            env['SERVER_PORT'] = request.getServerPort.to_s
+            env['rack.version'] = Rack::VERSION
+            env['rack.url_scheme'] = request.getScheme
+            env['HTTP_VERSION'] = request.getProtocol
+            env["SERVER_PROTOCOL"] = request.getProtocol
+            env['REMOTE_ADDR'] = request.getRemoteAddr
+            env['REMOTE_HOST'] = request.getRemoteHost
+
+            # request.getPathInfo seems to be blank, so we're using the URI.
+            env['REQUEST_PATH'] = request.getRequestURI
+            env['PATH_INFO'] = request.getRequestURI
+            env['SCRIPT_NAME'] = ""
+
+            # Rack says URI, but it hands off a URL.
+            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
+            env['REQUEST_URI'] << "?#{env['QUERY_STRING']}" \
+                if env['QUERY_STRING']
+
+            # JRuby is like the matrix, only there's no spoon or fork().
+            env['rack.multiprocess'] = false
+            env['rack.multithread'] = true
+            env['rack.run_once'] = false
+
+            # The input stream is a wrapper around the Java InputStream.
+            env['rack.input'] = @server.rewindable(request)
+
+            # 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)
+
+            # Populate the HTTP headers.
+            request.getHeaderNames.each do |header_name|
+                header = header_name.to_s.upcase.tr('-', '_')
+                env["HTTP_#{header}"] = request.getHeader(header_name)
+            end
+
+            # Rack Weirdness: HTTP_CONTENT_TYPE and HTTP_CONTENT_LENGTH
+            # both need to have the HTTP_ part dropped.
+            env["CONTENT_TYPE"] = env.delete("HTTP_CONTENT_TYPE") \
+                if env["HTTP_CONTENT_TYPE"]
+            env["CONTENT_LENGTH"] = env.delete("HTTP_CONTENT_LENGTH") \
+                if env["HTTP_CONTENT_LENGTH"]
+
+            # Route errors through the logger.
+            # env['rack.errors'] ||= @server.logger
+            # env['rack.logger'] ||= @server.logger
+
+            # All done, hand back the Rack request.
+            return(env)
+        end
+
+        #
+        # Turns a Rack response into a Servlet response; can be called
+        # multiple times.  Returns true if this is the full request (either
+        # a synchronous request or the last part of an async request),
+        # false otherwise.
+        #
+        # Note that keep-alive *only* happens if we get either a pathname
+        # (because we can find the length ourselves), or if we get a
+        # Content-Length header as part of the response.  While we can
+        # readily buffer the response object to figure out how long it is,
+        # we have no guarantee that we aren't going to be buffering
+        # something *huge*.
+        #
+        # http://docstore.mik.ua/orelly/java-ent/servlet/ch05_03.htm
+        #
+        def rack_to_servlet(rack_response, response)
+            # Split apart the Rack response.
+            status, headers, body = rack_response
+
+            # We assume the request is finished if we got empty headers,
+            # an empty body, and we have a committed response.
+            finished = (headers.empty? and \
+                body.respond_to?(:empty?) and body.empty?)
+            return(true) if (finished and response.isCommitted)
+
+            # No need to send headers again if we've already shipped
+            # data out on an async request.
+            unless(response.isCommitted)
+                # Set the HTTP status code.
+                response.setStatus(status.to_i)
+
+                # Servlets require that we set Content-Length and
+                # Content-Type differently than other headers.
+                content_length = headers.delete('Content-Length') \
+                    and response.setContentLength(content_length.to_i)
+                content_type = headers.delete('Content-Type') \
+                    and response.setContentType(content_type)
+
+                # Add all the result headers.
+                headers.each { |h, v| v.split(NEWLINE).each { |l|
+                    response.addHeader(h, l) } }
+            end
+
+            # How else would we write output?
+            output = response.getOutputStream
+
+            # Turn the body into something nice and Java-y.
+            if(body.respond_to?(:to_path))
+                # We've been told to serve a file; use FileInputStream to
+                # stream the file directly to the servlet, because this
+                # is a lot faster than doing it with Ruby.
+                file = java.io.File.new(body.to_path)
+
+                # We set the content-length so we can use Keep-Alive,
+                # unless this is an async request.
+                response.setContentLength(file.length) \
+                    unless content_length
+
+                # Stream the file directly.
+                buffer = Java::byte[4096].new
+                input_stream = FileInputStream.new(file)
+                while((count = input_stream.read(buffer)) != -1)
+                    output.write(buffer, 0, count)
+                end
+                input_stream.close
+            else
+                body.each do |chunk|
+                    output.write(chunk.to_java_bytes)
+                    output.flush
+                end
+            end
+
+            # Close the body if we're supposed to.
+            body.close if body.respond_to?(:close)
+
+            # 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))
+                #Server.logger.error(message)
+                $stderr.puts(message)
+                return if response.isCommitted
+                response.reset
+                response.setStatus(500)
+            end
+        end
+    end
+end

data/lib/mizuno/reloader.rb

@@ -0,0 +1,152 @@
+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
+        @reloaders = []
+
+        @trigger = 'tmp/restart.txt'
+
+        class << self
+            attr_accessor :logger, :trigger, :reloaders
+        end
+
+        def Reloader.reload!
+            reloaders.each { |r| r.reload!(true) }
+        end
+
+        def Reloader.add(reloader)
+            Thread.exclusive do
+                @logger ||= Mizuno::Server.logger
+                @reloaders << reloader
+            end
+        end
+
+        def initialize(app, interval = 1)
+            Reloader.add(self)
+            @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, Errno::ESRCH
+                nil
+            end
+        end
+    end
+end
+
+# Reload on SIGHUP.
+trap("SIGHUP") { Mizuno::Reloader.reload! }