trinidad_rack 0.1.0

data/LICENSE

@@ -0,0 +1,27 @@
+== Trinidad-Rack
+
+Copyright (c) 2011 David Calavera
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+== Additional Bundled Software
+
+lib/trinidad_rack/rack_servlet.rb is a work of Don Werve and it's licensed according to the terms of Apache License, Version 2.0 (current). 
+See http://www.apache.org/licenses/LICENSE-2.0 for details.

data/README

@@ -0,0 +1,30 @@
+Trinidad-Rack
+-------------
+
+Library that replaces Trinidad's rack layer from JRuby-Rack to the Mizuno Rack Servlet.
+
+It provides better integration with tools that relie on Rack like Capybara
+or any other Rack-Test based tool.
+
+RackServlet is a work of Don Werve and it's licensed under the Apache
+License. This library modifies its code to remove the asynchronous layer
+bounded to Jetty.
+
+Installation
+============
+
+$ jruby -S gem install trinidad_rack
+
+Execution
+=========
+
+$ jruby -S trinidad_rack
+
+or
+
+$ rackup -s Trinidad
+
+[IMPORTANT]
+
+This is totally experimental and due to Mizuno and JRuby-Rack
+work in a completely different way some features cannot work as expected.

data/Rakefile

@@ -0,0 +1,144 @@
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gem_file
+  "#{name}-#{version}.gem"
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+
+task :default => :test
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Generate RCov test coverage and open in your browser"
+task :coverage do
+  require 'rcov'
+  sh "rm -fr coverage"
+  sh "rcov test/test_*.rb"
+  sh "open coverage/index.html"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{name} #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = ['--colour', "--format documentation"]
+end
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push --tags"
+  sh "gem push pkg/#{name}-#{version}.gem"
+end
+
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+task :install => :build do
+  sh "gem install pkg/#{name}-#{version}.gem"
+end
+
+task :gemspec do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg|src|trinidad-libs|rakelib)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end

data/bin/trinidad_rack

@@ -0,0 +1,9 @@
+#!/usr/bin/env jruby
+
+require 'rack'
+
+require 'trinidad_rack'
+
+server = Rack::Server.new
+server.options[:server] = 'trinidad'
+server.start

data/lib/rack/handler/trinidad.rb

@@ -0,0 +1,18 @@
+require 'rack'
+require 'trinidad'
+
+module Rack
+  module Handler
+    class Trinidad
+      def self.run(app, options={})
+        opts = options.dup
+        opts[:app] = app
+        opts[:port] = 3000
+        opts[:address] = (options[:Host] || 'localhost')
+        ::Trinidad::Server.new(opts).start
+      end
+    end
+  end
+end
+
+Rack::Handler.register 'trinidad', 'Rack::Handler::Trinidad'

data/lib/trinidad_rack.rb

@@ -0,0 +1,10 @@
+require 'rack/handler/trinidad'
+
+require 'trinidad_rack/rack_servlet'
+require 'trinidad_rack/trinidad_ext'
+
+module Trinidad
+  module Rack
+    VERSION = '0.1.0'
+  end
+end

data/lib/trinidad_rack/rack_servlet.rb

@@ -0,0 +1,196 @@
+#
+# Wraps a Rack application in a Java servlet.
+#
+# Relevant documentation:
+#
+#     http://rack.rubyforge.org/doc/SPEC.html
+#     http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax
+#         /servlet/http/HttpServlet.html
+#
+module Trinidad
+  module Rack
+    java_import 'javax.servlet.http.HttpServlet'
+
+    class RackServlet < HttpServlet
+        java_import 'java.io.FileInputStream'
+
+        #
+        # Sets the Rack application that handles requests sent to this
+        # servlet container.
+        #
+        def rackup(app)
+            @app = app
+        end
+
+        #
+        # Takes an incoming request (as a Java Servlet) 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 service(request, response)
+            # Turn the ServletRequest into a Rack env hash
+            env = servlet_to_rack(request)
+
+            # 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
+
+            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
+
+        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.toString
+
+            # 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
+
+            # Populate the HTTP headers.
+            request.getHeaderNames.each do |header_name|
+                header = header_name.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"]
+
+            # The input stream is a wrapper around the Java InputStream.
+            env['rack.input'] = request.getInputStream.to_io
+
+            # The output stream defaults to stderr.
+            env['rack.errors'] ||= $stderr
+
+            # 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)
+
+                # Did we get a Content-Length header?
+                content_length = headers.delete('Content-Length')
+                response.setContentLength(content_length.to_i) \
+                    if content_length
+
+                # Add all the result headers.
+                headers.each { |h, v| response.addHeader(h, v) }
+            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 { |l| output.write(l.to_java_bytes) }
+            end
+
+            # Close the body if we're supposed to.
+            body.close if body.respond_to?(:close)
+
+            # All done.
+            output.flush
+        end
+    end
+  end
+end

data/lib/trinidad_rack/trinidad_ext.rb

@@ -0,0 +1,41 @@
+module Trinidad
+  class Server
+    alias :old_load_config :load_config
+    def load_config(config)
+      old_load_config(config)
+      trap_signals
+    end
+
+    def trap_signals
+      # trap signals and stop tomcat properly to make sure resque is also stopped properly
+      trap('INT') { tomcat.stop }
+      trap('TERM') { tomcat.stop }
+    end
+  end
+
+  class WebApp
+    def app
+      @config[:app]
+    end
+  end
+
+  module Lifecycle
+    class Default < Base
+      def configure_rack_servlet(context)
+        wrapper = context.create_wrapper
+
+        rack = Trinidad::Rack::RackServlet.new
+        rack.rackup(@webapp.app)
+        wrapper.servlet = rack
+        wrapper.name = 'RackServlet'
+
+        context.add_child(wrapper)
+        context.add_servlet_mapping('/*', wrapper.name)
+      end
+      def configure_rack_listener(context)
+        # we need to disable this method to ensure trinidad doesn't load any
+        # application listener
+      end
+    end
+  end
+end

data/trinidad_rack.gemspec

@@ -0,0 +1,73 @@
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'trinidad_rack'
+  s.version           = '0.1.0'
+  s.date              = '2011-04-10'
+  s.rubyforge_project = 'trinidad_rack'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "Simple Rack module and servlet for Trinidad"
+  s.description = "Simple Rack module and servlet for Trinidad based on Mizuno"
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["David Calavera"]
+  s.email    = 'calavera@apache.org'
+  s.homepage = 'http://github.com/trinidad/trinidad_rack'
+
+  s.executables = %w[trinidad_rack]
+  s.default_executable = 'trinidad_rack'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README LICENSE]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  s.add_dependency('trinidad', '>=1.0.1')
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  s.add_development_dependency('rspec', '>=2.2')
+  s.add_development_dependency('mocha')
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    LICENSE
+    README
+    Rakefile
+    bin/trinidad_rack
+    lib/rack/handler/trinidad.rb
+    lib/trinidad_rack.rb
+    lib/trinidad_rack/rack_servlet.rb
+    lib/trinidad_rack/trinidad_ext.rb
+    trinidad_rack.gemspec
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ /^spec\/.*\_spec.rb/ }
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: trinidad_rack
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+  - David Calavera
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-10 00:00:00 -07:00
+default_executable: trinidad_rack
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: trinidad
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.0.1
+    type: :runtime
+    version_requirements: *id001
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "2.2"
+    type: :development
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: mocha
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: "0"
+    type: :development
+    version_requirements: *id003
+description: Simple Rack module and servlet for Trinidad based on Mizuno
+email: calavera@apache.org
+executables: 
+  - trinidad_rack
+extensions: []
+
+extra_rdoc_files: 
+  - README
+  - LICENSE
+files: 
+  - LICENSE
+  - README
+  - Rakefile
+  - bin/trinidad_rack
+  - lib/rack/handler/trinidad.rb
+  - lib/trinidad_rack.rb
+  - lib/trinidad_rack/rack_servlet.rb
+  - lib/trinidad_rack/trinidad_ext.rb
+  - trinidad_rack.gemspec
+has_rdoc: true
+homepage: http://github.com/trinidad/trinidad_rack
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --charset=UTF-8
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: trinidad_rack
+rubygems_version: 1.5.1
+signing_key: 
+specification_version: 2
+summary: Simple Rack module and servlet for Trinidad
+test_files: []
+