fishwife 1.9.0-java → 1.10.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 601c734db28498a70a3c7f24d973b7b0e2c479a3
-  data.tar.gz: 714d5e5fd5431590b2890b6565a4671626037847
+SHA256:
+  metadata.gz: e03291bc98a777e051010275b8cd1f16bf5887d45d84a315cae65c1983e5f822
+  data.tar.gz: e12785a24dd82799a8df83d0c9d64bbe93d2f809e13144d26ad0705cfcc4996a
 SHA512:
-  metadata.gz: a53a415a0fa11dd101fbeb4ac1ee3c9c46d7b23bdfe6a877e60c029933b7f69f11b8bcd81c8285519f5541fbbf3210f5adde15c20e560afba9874dd2aa9ca56e
-  data.tar.gz: 354dcf246450f3b55faced05224d4f671ae0abcd394c5e98768eb3ca665781ca83470c1b5dd6cd57e9ac86bbfdb1aa1d73efdee9c5634255768cb856688a41e4
+  metadata.gz: d881973e3c17742a28c7cf00315f2bf593be244b3d4d9eb6210674b1f0c8f5b8ca26b0a59a83d8336094fd1823b19177f689fd1ae9310680d54328f97ba6349c
+  data.tar.gz: 4b66135628a938cad6ddb9e3adc02a31588fe8c8424f58a94d1ae7511707cc3fc2828a04deea269707978d479e4dd0329f2997e4ff05cf927a5b337f7a61e4c5

data/History.rdoc

@@ -1,3 +1,12 @@
+=== 1.10.0 (2017-6-16)
+* Broaden to rjack-jetty [9.2.11, 9.5) (tested with 9.4.6)
+
+* Replace the vestigial/broken `async.callback` implementation
+  with \Rack 1.5+ compliant, response (after-headers) only
+  {Hijacking}[http://www.rubydoc.info/github/rack/rack/file/SPEC#Hijacking]
+  support via `rack.hijack`, Fishwife::HijackedIO (with Theo
+  Hultberg, #15 #16 #17)
+
 === 1.9.0 (2017-2-13)
 * Upgrade/broaden to rack [1.6.4, 2.1). Note that the rack 2.0.1 gem
   lists ruby 2.2.2 as its minimum ruby version, thus you will need to

data/Manifest.txt

@@ -10,6 +10,7 @@ example/giant.ru
 example/ssl.ru
 lib/fishwife/base.rb
 lib/fishwife.rb
+lib/fishwife/hijacked_io.rb
 lib/fishwife/http_server.rb
 lib/fishwife/rack_servlet.rb
 lib/rack/handler/fishwife.rb
@@ -19,4 +20,5 @@ spec/test_app.rb
 spec/data/hello.txt
 spec/data/localhost.keystore
 spec/data/reddit-icon.png
-lib/fishwife/fishwife-1.9.0.jar
+spec/fishwife/hijacked_io_spec.rb
+lib/fishwife/fishwife-1.10.0.jar

data/README.rdoc

@@ -1,4 +1,4 @@
-= Fishwife
+= \Fishwife
 
 * http://github.com/dekellum/fishwife
 * Travis CI: {<img src="https://travis-ci.org/dekellum/fishwife.svg?branch=fishwife-dev" />}[https://travis-ci.org/dekellum/fishwife]
@@ -6,38 +6,44 @@
 == Description
 
 A hard working threaded HTTP 1.1 Rack server for JRuby using
-{Jetty}[http://www.eclipse.org/jetty/] 7.x or 9.x. Fishwife deploys
+{Jetty}[http://www.eclipse.org/jetty/] 9. \Fishwife deploys
 and operates like other Ruby HTTP servers/rack handlers such as
 Mongrel or Puma. No Java legacy war files (e.g. warbler) required.
 
 As compared to similar projects, most notably
 {Mizuno}[https://github.com/matadon/mizuno]
-from which it was originally forked, Fishwife offers the following
+from which it was originally forked, \Fishwife offers the following
 unique features:
 
-* Depends on the {rjack-jetty}[http://rjack.gravitext.com/jetty]
-  gem which closely tracks the upstream Jetty project, currently for
-  versions 7.x and 9.x.  You can test and control the version of Jetty
-  you use, for example via Bundler, independent of the Fishwife release.
+* Depends on the {rjack-jetty}[http://rjack.gravitext.com/jetty] gem
+  which closely tracks the upstream Jetty project.  You can test and
+  control the version of Jetty you use, for example via Bundler,
+  independent of the \Fishwife release.
 
-* Fishwife may itself be embedded in your own custom server/launcher
+* \Fishwife may itself be embedded in your own custom server/launcher
   where you have total control over JVM options like heap size, number
   of threads, and other initialization/configuration details. For an
   example, see:
   {boxed-geminabox}[https://github.com/dekellum/boxed-geminabox#readme]
   and notes in {#6}[https://github.com/dekellum/fishwife/issues/6].
 
-* Logging is unified across Jetty, Fishwife, and your application via
-  rjack-slf4j and on to any supported output adapter. (See Logging below)
+* Logging is unified across Jetty, \Fishwife, and your application via
+  rjack-slf4j and on to any supported output adapter
+  (see {Logging}[#label-Logging] below).
+
+* Includes \Rack 1.5
+  {Hijacking}[http://www.rubydoc.info/github/rack/rack/file/SPEC#Hijacking]
+  support for asynchronous response (after headers) streaming via
+  Jetty's (Servlets 3.1) asynchronous implementation.
 
 * Rack output streaming is optimized in a custom java extension.
 
 * Simple foreground server. Compatible with several real process
-  monitors (See Process Monitoring below)
+  monitors (see {Process Monitoring}[#label-Process+Monitoring] below).
 
 == Synopsis
 
-To use Fishwife with your Rack app and config.ru:
+To use \Fishwife with your \Rack app and config.ru:
 
     gem install fishwife
     cd /path/to/my/rack/app
@@ -58,41 +64,33 @@ See also:
 
 == Logging
 
-Fishwife requires
+\Fishwife requires
 {rjack-slf4j}[http://rjack.gravitext.com/slf4j/RJack/SLF4J.html] which
 provides a unified interface for Java/Ruby logging. Jetty auto-detect
 SLF4J's presence and logs there. A logging output provider must also
 be loaded. The fishwife script will load
 {rjack-logback}[http://rjack.gravitext.com/logback/RJack/Logback.html]
 if found or otherwise fall back to `rjack-slf4j/simple`.  If you are
-starting Fishwife through some other means than the fishwife script, you
+starting \Fishwife through some other means than the fishwife script, you
 will need to load an output provider (see linked docs and notes in
 {#6}[https://github.com/dekellum/fishwife/issues/6]).
 
 == Process Monitoring
 
-We assume this isn't your only production ruby server and don't
-include any one-off, half-baked process control and monitoring
+We assume this isn't your only production Ruby or Java server and
+don't include any one-off or half-baked process control and monitoring
 features. Note that Unix-like fork(2) is not safe on the JVM and thus
 from JRuby so its not practical to support a fishwife --daemon
-flag. Fishwife simply logs to STDERR by default.  Instead consider
+flag. \Fishwife simply logs to STDERR by default.  Instead consider
 using:
 
+* Linux systemd, which supports foreground processes (Type=simple)
+
 * {Bluepill}[https://github.com/arya/bluepill#readme] or God (MRI
-  Ruby) process monitors support self-forking of foreground processes,
-  for example `rackup` or `fishwife`.
+  Ruby) process monitors support foreground processes.
 
 * The {Iyyov}[https://github.com/dekellum/iyyov#readme] (JRuby)
-  process monitor supports self-daemonizing via the hashdot
-  launcher.  Your app can also be packaged/updated as a gem if
-  desired. For an example see:
-  {boxed-geminabox}[https://github.com/dekellum/boxed-geminabox#readme].
-
-* Linux systemd
-
-All options also support redirecting log output (including any
-JVM-level errors) to a file. Iyyov supports log rotation internally.
-Unix-like logrotate(8) may be used with the former process monitors.
+  process monitor supports self-daemonizing via the hashdot launcher.
 
 == Building from Source and Contributing
 

data/Rakefile

@@ -12,3 +12,10 @@ task :publish_rdoc => [ :clean, :rerdoc ] do
     aws s3 sync --acl public-read doc/ s3://rdoc.gravitext.com/fishwife/
   SH
 end
+
+task :rdoc do
+  sh <<-SH
+    rm -rf doc/fonts
+    cp rdoc_css/*.css doc/css/
+  SH
+end

data/lib/fishwife.rb

@@ -32,4 +32,5 @@ end
 require 'rack'
 require 'fishwife/rack_servlet'
 require 'fishwife/http_server'
+require 'fishwife/hijacked_io'
 require 'rack/handler/fishwife'

data/lib/fishwife/base.rb

@@ -15,6 +15,6 @@
 #++
 
 module Fishwife
-  VERSION = '1.9.0'
+  VERSION = '1.10.0'
   LIB_DIR = File.dirname( __FILE__ )
 end

data/lib/fishwife/hijacked_io.rb

@@ -0,0 +1,99 @@
+#--
+# Copyright (c) 2017 Theo Hultberg, David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You may
+# obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+module Fishwife
+
+  # Wraps a Java Servlets
+  # {AsyncContext}[http://docs.oracle.com/javaee/7/api/javax/servlet/AsyncContext.html]
+  # as a ruby ::IO-like class for use in \Rack response (after headers)
+  # {Hijacking}[http://www.rubydoc.info/github/rack/rack/file/SPEC#Hijacking].
+  #
+  # This currently supports only (blocking) #write, #flush, and
+  # #close. Other methods raise NotImplementedError.
+  class HijackedIO
+    def initialize(async_context)
+      @async_context = async_context
+      @closed = false
+    end
+
+    # Writes the given str to the #output_stream as bytes. If str is
+    # not a ruby String, it will be converted using Object#to_s.
+    # Returns the bytesize of the String (Java's OutputStream#write is
+    # never partial).
+    def write(str)
+      str = str.to_s
+      IOUtil.write(str, out_stream)
+      str.bytesize
+    end
+
+    # Write the given Array of ruby ::String instances to the output
+    # stream as bytes. This is included here, because #write(ary.to_s)
+    # would otherwise result in inspect-styled output.
+    def write_array(ary)
+      IOUtil.write_body(ary, out_stream)
+    end
+
+    # Flushes the underlying #output_stream and returns self.
+    def flush
+      out_stream.flush
+      self
+    end
+
+    # Calls complete on the underlying AsyncContext. Subsequent calls
+    # after the first are ignored.
+    def close
+      if !@closed
+        @async_context.complete
+        @closed = true
+      end
+      nil
+    end
+
+    alias_method :close_write, :close
+
+    # Return true if #close has been called.
+    def closed?
+      @closed
+    end
+
+    # Raises NotImplementedError.
+    def read(*)
+      raise NotImplementedError, "##{__method__} on hijacked IO is not supported"
+    end
+
+    # Raises NotImplementedError.
+    def read_nonblock(*)
+      raise NotImplementedError, "##{__method__} on hijacked IO is not supported"
+    end
+
+    # Raises NotImplementedError.
+    def write_nonblock(*)
+      raise NotImplementedError, "##{__method__} on hijacked IO is not supported"
+    end
+
+    # Raises NotImplementedError.
+    def close_read
+      raise NotImplementedError, "##{__method__} on hijacked IO is not supported"
+    end
+
+    private
+
+    def out_stream
+      @out_stream ||= @async_context.response.output_stream
+    end
+
+  end
+end

data/lib/fishwife/rack_servlet.rb

@@ -38,10 +38,14 @@ module Fishwife
   #
   class RackServlet < HttpServlet
     java_import 'java.io.FileInputStream'
-    java_import 'org.eclipse.jetty.continuation.ContinuationSupport'
 
     ASCII_8BIT = Encoding.find( "ASCII-8BIT" ) if defined?( Encoding )
 
+    REQ_HIJACK_NOT_SUPPORTED = lambda do
+      raise( NotImplementedError,
+             'Only response hijacking is supported, not request hijacking' )
+    end
+
     def initialize( app, opts = {} )
       super()
       @log = RJack::SLF4J[ self.class ]
@@ -56,57 +60,19 @@ module Fishwife
     # 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 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
-
-      # 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)
 
+      rack_response = @app.call(env)
+      rack_to_servlet(rack_response, request, response)
+      nil
     rescue RequestBodyTooLarge => e
       @log.warn( "On service: #{e.class.name}: #{e.message}" )
       response.sendError( 413 )
@@ -183,6 +149,9 @@ module Fishwife
       # The output stream defaults to stderr.
       env['rack.errors'] ||= $stderr
 
+      env['rack.hijack?'] = true
+      env['rack.hijack'] = REQ_HIJACK_NOT_SUPPORTED
+
       # All done, hand back the Rack request.
       env
     end
@@ -226,10 +195,7 @@ module Fishwife
       io
     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.
+    # Turns a Rack response into a Servlet response.
     #
     # Note that keep-alive *only* happens if we get either a pathname
     # (because we can find the length ourselves), or if we get a
@@ -239,61 +205,55 @@ module Fishwife
     # something *huge*.
     #
     # http://docstore.mik.ua/orelly/java-ent/servlet/ch05_03.htm
-    def rack_to_servlet(rack_response, response)
+    def rack_to_servlet(rack_response, request, 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)
-
-        # Add all the result headers.
-        headers.each do |h, v|
-          case h
-          when 'Content-Length'
-            # Did we get a Content-Length header?
-            response.setContentLength(v.to_i) if v
-          when 'Content-Type'
-            # Did we get a Content-Type header?
-            response.setContentType(v) if v
-          else
-            v.split("\n").each { |val| response.addHeader(h, val) }
-          end
+      # Set the HTTP status code.
+      response.setStatus(status.to_i)
+
+      response_hijack_callback = nil
+
+      # Add all the result headers.
+      headers.each do |h, v|
+        case h
+        when 'Content-Length'
+          response.setContentLength(v.to_i) if v
+        when 'Content-Type'
+          response.setContentType(v) if v
+        when 'rack.hijack'
+          response_hijack_callback = v
+        else
+          v.split("\n").each { |val| response.addHeader(h, val) }
         end
       end
 
-      output = response.getOutputStream
+      if response_hijack_callback
+        response_hijack_callback.call( HijackedIO.new(request.start_async) )
+      else
+        output = response.getOutputStream
 
-      if body.respond_to?( :to_path )
+        if body.respond_to?( :to_path )
 
-        path = body.to_path
+          path = body.to_path
 
-        # Set Content-Length unless this is an async request.
-        unless headers['Content-Length']
-          response.setContentLength( File.size( path ) )
-        end
+          unless headers['Content-Length']
+            response.setContentLength( File.size( path ) )
+          end
 
-        # FIXME: Support ranges?
+          # FIXME: Support ranges?
 
-        IOUtil.write_file( path, output )
-      else
-        IOUtil.write_body( body, output )
-      end
+          IOUtil.write_file( path, output )
+        else
+          IOUtil.write_body( body, output )
+        end
 
-      # Close the body if we're supposed to.
-      body.close if body.respond_to?(:close)
+        # Close the body if we're supposed to.
+        body.close if body.respond_to?(:close)
 
-      # All done.
-      output.close
-      false
+        # All done.
+        output.close
+      end
     end
   end
 end

data/pom.xml

@@ -4,7 +4,7 @@
   <groupId>fishwife</groupId>
   <artifactId>fishwife</artifactId>
   <packaging>jar</packaging>
-  <version>1.9.0</version>
+  <version>1.10.0</version>
   <name>Fishwife Java Extension</name>
 
   <properties>

data/spec/fishwife/hijacked_io_spec.rb

@@ -0,0 +1,105 @@
+#--
+# Copyright (c) 2017 Theo Hultberg, David Kellum
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you
+# may not use this file except in compliance with the License.  You may
+# obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+# implied.  See the License for the specific language governing
+# permissions and limitations under the License.
+#++
+
+require 'spec_helper'
+
+describe Fishwife::HijackedIO do
+  subject :io do
+    described_class.new(async_context)
+  end
+
+  let :async_context do
+    double(:async_context)
+  end
+
+  let :buffer do
+    StringIO.new
+  end
+
+  let :output_stream do
+    buffer.to_outputstream
+  end
+
+  before do
+    response = double(:response)
+    async_context.stub(:response).and_return(response)
+    async_context.stub(:complete)
+    response.stub(:output_stream).and_return(output_stream)
+  end
+
+  describe '#write' do
+    it 'writes a string to the response output stream' do
+      io.write('hello')
+      buffer.string.should eq('hello')
+    end
+
+    it 'returns the number of bytes written' do
+      io.write('hello').should eq(5)
+      io.write("\u2603").should eq(3)
+    end
+  end
+
+  describe '#flush' do
+    let :output_stream do
+      double(:output_stream)
+    end
+
+    before do
+      output_stream.stub(:flush)
+    end
+
+    it 'flushes the response output stream' do
+      output_stream.should_receive(:flush)
+      io.flush
+    end
+
+    it 'returns self' do
+      io.flush.should equal(io)
+    end
+  end
+
+  [:close, :close_write].each do |method_name|
+    describe "##{method_name}" do
+      before do
+        async_context.stub(:complete)
+      end
+
+      it 'completes the async processing' do
+        async_context.should_receive(:complete)
+        io.send(method_name)
+      end
+
+      it 'returns nil' do
+        io.send(method_name).should be_nil
+      end
+    end
+  end
+
+  describe '#closed?' do
+    context 'before #close has been called' do
+      it 'returns false' do
+        io.should_not be_closed
+      end
+    end
+
+    context 'after #close has been called' do
+      it 'returns true' do
+        io.close
+        io.should be_closed
+      end
+    end
+  end
+end

data/spec/fishwife_spec.rb

@@ -28,12 +28,16 @@ describe Fishwife do
 
     describe "for #{scheme.to_s} scheme" do
 
-      def get(path, headers = {})
+      def get(path, headers = {}, &block )
         Net::HTTP.start(@options[:host], @options[:port],
                         nil, nil, nil, nil, #Irrelevant http proxy parameters
                         @https_client_opts) do |http|
           request = Net::HTTP::Get.new(path, headers)
-          http.request(request)
+          if block
+            http.request(request, &block)
+          else
+            http.request(request)
+          end
         end
       end
 
@@ -232,31 +236,38 @@ describe Fishwife do
         response.body.should == '8da4b60a9bbe205d4d3699985470627e'
       end
 
-      it "handles async requests" do
-        pending "Causes intermittent 30s pauses, TestApp.push/pull is sketchy"
-        lock = Mutex.new
-        buffer = Array.new
-
-        clients = 10.times.map do |index|
-          Thread.new do
-            Net::HTTP.start(@options[:host], @options[:port]) do |http|
-              response = http.get("/pull")
-              lock.synchronize {
-                buffer << "#{index}: #{response.body}" }
-            end
+      it "handles frozen Rack responses" do
+        response = get("/frozen_response")
+        response.code.should == "200"
+      end
+
+      it "handles response hijacking" do
+        chunks = []
+        get( "/hijack" ) do |resp|
+          resp.code.should == '200'
+          resp.read_body do |chunk|
+            chunks << chunk
           end
         end
+        chunks.should == [ "hello", " world\n" ]
+      end
 
-        lock.synchronize { buffer.should be_empty }
-        post("/push", 'message' => "one")
-        clients.each { |c| c.join }
-        lock.synchronize { buffer.should_not be_empty }
-        lock.synchronize { buffer.count.should == 10 }
+      it "handles ugly response hijacking" do
+        chunks = []
+        get( "/hijack?ugly=t" ) do |resp|
+          resp.code.should == '200'
+          resp.read_body do |chunk|
+            chunks << chunk
+          end
+        end
+        chunks.should == [ "hello", " world\n" ]
       end
 
-      it "handles frozen Rack responses" do
-        response = get("/frozen_response")
-        response.code.should == "200"
+      it "gracefully declines request hijacking" do
+        chunks = []
+        resp = get( "/request_hijack" )
+        resp.code.should == '200'
+        resp.body.should =~ /^Only response hijacking is supported/
       end
 
     end

data/spec/test_app.rb

@@ -28,10 +28,6 @@ require 'json'
 #
 # /file:: Returns a file for downloading.
 #
-# /push:: Publishes a message to async listeners.
-#
-# /pull:: Recieves messages sent via /push using async.
-#
 # A request to any endpoint not listed above will return a 404 error.
 class TestApp
   def initialize
@@ -84,33 +80,6 @@ class TestApp
     [ 204, { "Warning" => %w[ warn-1 warn-2 ].join( "\n" ) }, [] ]
   end
 
-  def push(request)
-    message = request.params['message']
-
-    @subscribers.reject! do |subscriber|
-      begin
-        response = Rack::Response.new
-        if(message.empty?)
-          subscriber.call(response.finish)
-          next(true)
-        else
-          response.write(message)
-          subscriber.call(response.finish)
-          next(false)
-        end
-      rescue java.io.IOException => error
-        next(true)
-      end
-    end
-
-    ping(request)
-  end
-
-  def pull(request)
-    @subscribers << request.env['async.callback']
-    throw(:async)
-  end
-
   def download(request)
     file = File.new( File.dirname( __FILE__ ) + "/data/reddit-icon.png" )
     def file.to_path
@@ -130,4 +99,59 @@ class TestApp
   def frozen_response(request)
     [200, {}.freeze, [].freeze].freeze
   end
+
+  def hijack(request)
+    if request.env['rack.hijack?']
+      hm = request.params['ugly'] ? :ugly_response : :hijack_response
+      [200, {'rack.hijack' => method(hm)}, []]
+    else
+      [501, {}, ['Hijack not supported']]
+    end
+  end
+
+  def request_hijack(request)
+    if request.env['rack.hijack?']
+      hm = request.env['rack.hijack']
+      if hm
+        io = hm.call
+        [503, {}, ['Should not get IO: ', io.inspect]]
+      else
+        [502, {}, ['rack.hijack: ', hm.inspect]]
+      end
+    else
+      [501, {}, ['Hijack not supported']]
+    end
+  rescue NotImplementedError => e
+    [200, {}, [e.to_s]]
+  end
+
+  private
+
+  def hijack_response(io)
+    Thread.start do
+      io.write(:hello)
+      io.flush
+      io.write(" world\n")
+      io.close
+    end
+  end
+
+  def ugly_response(io)
+    Thread.start do
+      sleep( rand * 0.1 )
+      io.write('h')
+      io.write('ello')
+      io.write(nil)
+      io.flush
+      io.flush
+      io.write('')
+      io.flush
+      io.write(" world\n")
+      io.write(nil)
+      io.flush
+      io.close
+      io.close
+    end
+    sleep( rand * 0.1 )
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fishwife
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 1.10.0
 platform: java
 authors:
 - David Kellum
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-02-13 00:00:00.000000000 Z
+date: 2017-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +38,7 @@ dependencies:
         version: 9.2.11
     - - "<"
       - !ruby/object:Gem::Version
-        version: '9.4'
+        version: '9.5'
   name: rjack-jetty
   prerelease: false
   type: :runtime
@@ -49,7 +49,7 @@ dependencies:
         version: 9.2.11
     - - "<"
       - !ruby/object:Gem::Version
-        version: '9.4'
+        version: '9.5'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -120,7 +120,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
-description: A hard working threaded HTTP 1.1 Rack server for JRuby using Jetty 7.x or 9.x. Fishwife deploys and operates like other Ruby HTTP servers/rack handlers such as Mongrel or Puma. No Java legacy war files (e.g. warbler) required.
+description: A hard working threaded HTTP 1.1 Rack server for JRuby using Jetty 9.
+  \Fishwife deploys and operates like other Ruby HTTP servers/rack handlers such as
+  Mongrel or Puma. No Java legacy war files (e.g. warbler) required.
 email:
 - dek-oss@gravitext.com
 executables:
@@ -141,7 +143,8 @@ files:
 - example/ssl.ru
 - lib/fishwife.rb
 - lib/fishwife/base.rb
-- lib/fishwife/fishwife-1.9.0.jar
+- lib/fishwife/fishwife-1.10.0.jar
+- lib/fishwife/hijacked_io.rb
 - lib/fishwife/http_server.rb
 - lib/fishwife/rack_servlet.rb
 - lib/rack/handler/fishwife.rb
@@ -149,6 +152,7 @@ files:
 - spec/data/hello.txt
 - spec/data/localhost.keystore
 - spec/data/reddit-icon.png
+- spec/fishwife/hijacked_io_spec.rb
 - spec/fishwife_spec.rb
 - spec/spec_helper.rb
 - spec/test_app.rb
@@ -173,7 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.6.8
+rubygems_version: 2.6.11
 signing_key:
 specification_version: 4
 summary: A Jetty based Rack HTTP 1.1 server.