ruby-ajp 0.1.5 → 0.2.0

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake/rdoctask'
 require 'rake/gempackagetask'
 
 Rake::TestTask.new do |t|
-  t.libs << "test"
+  t.libs << "test" << "lib"
   t.pattern = [ 'test/**/test_ajp13*.rb', 'test/**/more_test_ajp13*.rb' ]
   t.verbose = true
 end

data/example/dump-server.rb

@@ -1,5 +1,5 @@
 #!/usr/bin/ruby
-require 'net/ajp13server'
+require 'net/ajp13/server'
 require 'erb'
 
 class DumpServer < Net::AJP13::Server
@@ -58,7 +58,7 @@ __END__
   <% if req.body_stream %>
    <% body = req.body_stream.read %>
    <% if %r(\Atext/) =~ req['content-type'] or 
-     req['content-type'] == 'application/x-form-www-urlencoded' %>
+     req['content-type'] == 'application/x-www-form-urlencoded' %>
     <pre><%=h body %></pre>
    <% else %>
     <pre><%=[body].pack('m')%></pre>

data/lib/net/ajp13/ajp13cgi.rb

@@ -0,0 +1,187 @@
+require 'net/ajp13'
+require 'cgi'
+require 'forwardable'
+
+# The adapter to adapt Net::AJP13::Request and Net::AJP13::Response into
+# CGI's interface.
+class Net::AJP13::AJP13CGI
+  include ::CGI::QueryExtension
+  extend Forwardable
+
+  def initialize(req)
+    @req = req
+    if req.method == "POST" and
+      %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n.match(req['content-type']) then
+      boundary = $1.dup
+      @multipart = true
+      @params = read_multipart(boundary, req.content_length)
+    elsif req.body_stream and 
+      req['content-type'] == 'application/x-www-form-urlencoded'
+      @multipart = false
+      @params = CGI::parse(req.body = req.body_stream.read)
+      req.body_stream = nil
+    elsif qs = query_string
+      @multipart = false
+      @params = CGI::parse(qs)
+    else
+      @multipart = false
+      @params = {}
+    end
+
+    @env_table = self.method(:env)
+    class << @env_table
+      def include?(key)
+        call(key).nil?
+      end
+      alias :key? :include?
+    end
+    @cookies = CGI::Cookie::parse(req['cookie'])
+  end
+
+  # Created AJP13::Response object.
+  attr_reader :response
+
+  MESSAGE_TO_STATUS = {
+    :OK                  => [200, "OK"],
+    :PARTIAL_CONTENT     => [206, "Partial Content"],
+    :MULTIPLE_CHOICES    => [300, "Multiple Choices"],
+    :MOVED               => [301, "Moved Permanently"],
+    :REDIRECT            => [302, "Found"],
+    :NOT_MODIFIED        => [304, "Not Modified"],
+    :BAD_REQUEST         => [400, "Bad Request"],
+    :AUTH_REQUIRED       => [401, "Authorization Required"],
+    :FORBIDDEN           => [403, "Forbidden"],
+    :NOT_FOUND           => [404, "Not Found"],
+    :METHOD_NOT_ALLOWED  => [405, "Method Not Allowed"],
+    :NOT_ACCEPTABLE      => [406, "Not Acceptable"],
+    :LENGTH_REQUIRED     => [411, "Length Required"],
+    :PRECONDITION_FAILED => [412, "Rrecondition Failed"],
+    :SERVER_ERROR        => [500, "Internal Server Error"],
+    :NOT_IMPLEMENTED     => [501, "Method Not Implemented"],
+    :BAD_GATEWAY         => [502, "Bad Gateway"],
+    :VARIANT_ALSO_VARIES => [506, "Variant Also Negotiates"],
+  }.freeze
+
+  def header(arg = "text/html")
+    if arg.kind_of? String
+      @response = Net::AJP13::Response.new(200)
+      @response['content-type'] = arg
+    elsif arg.respond_to?(:each) and arg.respond_to?(:[])
+      if status = arg['status'] 
+        raise ArgumentError, "Unrecognized status line format: #{status}" unless          /\A(?:([0-9]{3}) )?(\w+)\Z/ =~ status
+        status_line = $1 ? [$1.to_i, $2] : MESSAGE_TO_STATUS[$2.to_sym]
+	raise ArgumentError, "Unrecognized status line: #{status}" unless status_line
+	@response = Net::AJP13::Response.new(status_line[0], :reason_phrase => status_line[1])
+      else
+        @response = Net::AJP13::Response.new(200)
+      end
+      type = nil; charset = nil
+      arg.each do |name, value|
+        case name.downcase
+	when 'nph', 'status'
+	  # do nothing
+	when "type"
+	  type = value
+	when "charset"
+	  charset = value
+	when 'length'
+	  @response['content-length'] = value.to_s
+	when 'language'
+	  @response['content-language'] = value
+	when 'cookie'
+	  case value
+	  when String
+	    @respose.add_header('set-cookie', value)
+	  when Array, Hash
+	    value.each {|val| @response.add_header('set-cookie', val.to_s) }
+	  end
+        else
+	  @response[name] = value
+	end
+      end
+      type = 'text/html' unless type
+      @response['content-type'] = charset ? ("%s; charset=%s" % [type, charset]) : type
+    else
+      raise ArgumentError, "argument is not a String nor Hash"
+    end
+  end
+
+
+  def output(arg = 'text/html')
+    content = yield
+    header(arg)
+    @response['content-length'] ||= content.length
+    unless content.nil? or @request.method == 'HEAD'
+      @response.body = content
+    end
+  end
+
+  # Method object that contains #env
+  attr_reader :env_table
+
+  # Simulates environment variable table that Common Gateway Interface defines.
+  def env(name)
+    name = name.downcase
+    key = name.to_sym
+    if [
+      :auth_type, :content_length, :content_type, :gateway_interface,
+      :path_info, :path_translated, :query_string, :remote_addr, :remote_host,
+      :remote_ident, :remote_user, :request_method, :request_url, :script_name,
+      :server_name, :server_port, :server_protocol, :server_software
+    ].include?(key) then
+      return __send__(key)
+    elsif /\Ahttp_(\w+)\Z/ =~ name
+      return @req[$1.tr('_', '-')]
+    else
+      return nil
+    end
+  end
+  private :env
+
+  def_delegators :@req, 
+    :content_length, :remote_addr, :remote_host, :server_name, :server_port
+
+  [
+    :auth_type, 
+   # :path_info, 
+    :path_translated,
+    :remote_ident, :remote_user, 
+    :script_name, :server_software
+  ].each do |attr_name|
+    define_method(attr_name) do
+      val = @req.get_attributes(attr_name.to_s)
+      val and val[0]
+    end
+  end
+
+  def content_type
+    @req['content-type']
+  end
+
+  def gateway_interface
+    'AJP/1.3'
+  end
+
+  def path_info
+    #val = @req.get_attributes('path_info')
+    #val && val[0] or @req.path
+    @req.path
+  end
+
+  def query_string
+    qs = @req.get_attributes('query_string')
+    qs and qs.join('&')
+  end
+
+  def request_method
+    @req.method
+  end
+
+  def request_url
+    @req.path
+  end
+
+  def server_protocol
+    @req.protocol
+  end
+end

data/lib/net/{ajp13server.rb → ajp13/server.rb}

@@ -83,7 +83,6 @@ class Net::AJP13::Server
   end
 
   def start(sock = nil)
-    logger.info("Starting #{self.class}")
     if sock
       @sock = sock
     else
@@ -96,13 +95,12 @@ class Net::AJP13::Server
         accepted = @sock.accept
 	Thread.new {
 	  begin
-	    until accepted.closed?
-              process(accepted)
-	    end
+	    accepted.sync = false
+            process(accepted)
 	  rescue StandardError => err
-	    logger.error("#{err.message} from #{err.backtrace("\n")}")
+	    logger.error("#{err.message} from #{err.backtrace.join("\n")}")
 	  rescue Object => err
-	    logger.fatal("#{err.message} from #{err.backtrace("\n")}")
+	    logger.fatal("#{err.message} from #{err.backtrace.join("\n")}")
 	  else
 	    logger.debug("closed")
 	  ensure
@@ -133,18 +131,23 @@ class Net::AJP13::Server
 
   # +conn+:: Accepted connection. +conn+ is an IO object or something like it.
   def process(conn)
-    packet = Net::AJP13::Packet.from_io(conn)
-    case packet.message_type
-    when FORWARD_REQUEST
-      process_forward_request(packet, conn)
-    when SHUTDOWN
-      process_shutdown(packet, conn)
-    when PING
-      process_ping(packet, conn)
-    when CPING
-      process_cping(packet, conn)
-    else
-      raise AJPPacketError, "Unrecognized packet type #{packet.message_type}"
+    loop do
+      break unless c = conn.getc
+      conn.ungetc c
+
+      packet = Net::AJP13::Packet.from_io(conn)
+      case packet.message_type
+      when FORWARD_REQUEST
+        process_forward_request(packet, conn)
+      when SHUTDOWN
+        process_shutdown(packet, conn)
+      when PING
+        process_ping(packet, conn)
+      when CPING
+        process_cping(packet, conn)
+      else
+        raise AJPPacketError, "Unrecognized packet type #{packet.message_type}"
+      end
     end
   end
 
@@ -178,6 +181,7 @@ class Net::AJP13::Server
       conn.write "\x41\x42#{[message.length + 4].pack('n')}\x03#{[message.length].pack('n')}#{message}\x00"
     else
       # SEND_HEADERS packet
+      res ||= Net::AJP13::Response.new(500)
       res['content-length'] ||= res.body.length.to_s if res.body 
       res.send_to conn
 
@@ -241,6 +245,7 @@ class Net::AJP13::Server
       @sock = sock
       @packet = Net::AJP13::Packet.from_io(sock)
       @length = length
+      packet_content_length = @packet.read_integer
       @read_length = 0
     end
 
@@ -346,7 +351,8 @@ class Net::AJP13::Server
 	  # this means eof
 	  break
 	else
-	  chunk = @packet.read_bytes(length - written_length)
+          packet_content_length = @packet.read_integer
+	  chunk = @packet.read_bytes([length - written_length, packet_content_length].min)
 	  buf[written_length, chunk.length] = chunk
 	  written_length += chunk.length
 	  @read_length += chunk.length

data/lib/net/ajp13.rb

@@ -1,9 +1,9 @@
 # = Ruby/AJP
-# An implementation of AJP(Apache Jserv Protocol) 1.3 in Ruby, 
+# Ruby/AJP is an implementation of AJP(Apache Jserv Protocol) 1.3 in Ruby, 
 # based on http://tomcat.apache.org/connectors-doc/common/ajpv13a.html.
 #
 # [Net::AJP13::Client] provides high-level API to implement AJP clients.
-#                      The interface of the client-side library is similar to
+#                      The interface of this client-side library is similar to
 #                      net/http.
 #                      see ajp13client.rb[link:files/lib/net/ajp13client_rb.html]
 #                      for more detail.
@@ -33,9 +33,8 @@
 
 require 'net/http'
 
-# :stopdoc:
-module Net; end
-# :startdoc:
+module Net #:nodoc:
+end
 
 module Net::AJP13
   module Constants 
@@ -93,7 +92,7 @@ class Net::AJP13::Request
   }.freeze
   SC_REQ_HEADER_NAMES.each_key {|k| k.freeze}
 
-  SC_A_REQ_ATTRIBUTE = 0xA0
+  SC_A_REQ_ATTRIBUTE = 0x0A
   # Maps request attribute names into their codes
   SC_A_NAMES = {
     :context => 0x01, 
@@ -194,7 +193,7 @@ class Net::AJP13::Request
       else
         header_name = packet.read_string
       end
-      req[header_name] = packet.read_string
+      req.add_field(header_name, packet.read_string)
     end
     loop do
       case attr_name = packet.read_byte
@@ -252,6 +251,7 @@ class Net::AJP13::Request
   # HTTP-side connection is over SSL or not.
   attr_accessor :is_ssl
   alias :is_ssl? :is_ssl
+  alias :ssl? :is_ssl
   def is_ssl=(value) #:nodoc:
     @is_ssl = !!value
   end 
@@ -562,7 +562,7 @@ end
 class Net::AJP13::AJPPacketError < IOError
 end
 
-# :stopdoc:
+# :enddoc:
 # Represents AJP1.3 Packet
 class Net::AJP13::Packet
   include Net::AJP13::Constants

data/ruby-ajp.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name = "ruby-ajp"
-  spec.version = "0.1.5"
+  spec.version = "0.2.0"
   spec.required_ruby_version = ">= 1.8.3"
   spec.summary = "An implementation of Apache Jserv Protocol 1.3 in Ruby"
   spec.author = "Yugui"
@@ -20,8 +20,7 @@ Gem::Specification.new do |spec|
     "COPYING"
   spec.files.reject! {|fn| fn.include?('.svn') }
   spec.test_files = [
-    'packet', 'request',
-    'response', 'client'
+    'packet', 'request', 'response', 'client', 'server'
   ].map{|x| "test/net/test_ajp13#{x}.rb"}
   spec.has_rdoc = true
 end

data/test/net/test_ajp13cgi.rb

@@ -0,0 +1,104 @@
+require 'test/unit'
+require 'stringio'
+require File.dirname(__FILE__) + "/../../lib/net/ajp13/ajp13cgi.rb"
+
+class Net::AJP13::AJP13CGITest < Test::Unit::TestCase
+  def setup
+    @encoded_body = 
+      "test%5Bfirst%5Fname%5D=foo" +
+      "&test%5blast%5Fname%5D=bar+hoge" +
+      "&test%5Bemail%5D=foo%2Dbar%40yet%2Eanother%2Edomain%2Etest" +
+      "&key+with+SP=huga" +
+      "&nanika=unyuu" +
+      "&last=%5Ce" +
+      ""
+    @encoded_body.freeze
+    @qs = "last=%5Cufin.%5Ce"
+
+    req = Net::AJP13::PostRequest.new('/path/to/resource')
+    req.server_name = 'www.domain.test'
+    req.server_port = 8181
+    req.is_ssl = true
+    req.body_stream = StringIO.new(@encoded_body)
+    req['Host'] = 'www.domain.test'
+    req['Content-Length'] = @encoded_body.length.to_s
+    req['Content-Type'] = 'application/x-www-form-urlencoded'
+    req['Content-Language'] = 'ja-JP'
+    req['User-Agent'] = @ua = "testcase #{__FILE__}:#{__LINE__}"
+    req.set_attribute('QUERY_STRING', @qs)
+
+    @cgi = Net::AJP13::AJP13CGI.new(req)
+  end
+
+  def test_at
+    assert_equal 'foo', @cgi['test[first_name]']
+    assert_equal 'bar hoge', @cgi['test[last_name]']
+    assert_equal 'foo-bar@yet.another.domain.test', @cgi['test[email]']
+    assert_equal 'huga', @cgi['key with SP']
+    assert_equal 'unyuu', @cgi['nanika']
+    assert_equal '\e', @cgi['last']
+    assert_equal '', @cgi['test[invalid_key]']
+    assert_equal '', @cgi['']
+
+    assert_equal '', @cgi['Test[first_name]'] # case sensitive
+    assert_equal '', @cgi['test[Last_name]']  # case sensitive
+  end
+
+  def test_has_key?
+    assert @cgi.has_key?('test[first_name]')
+    assert @cgi.has_key?('test[last_name]')
+    assert @cgi.has_key?('test[email]')
+    assert @cgi.has_key?('key with SP')
+    assert !@cgi.has_key?('test[invalid_key]')
+    assert !@cgi.has_key?('')
+
+    assert !@cgi.has_key?('Test[first_name]')
+  end
+
+  def test_env_table
+    assert_equal @encoded_body.length, @cgi.env_table['CONTENT_LENGTH']
+    assert_equal 8181, @cgi.env_table['SERVER_PORT']
+    assert_equal 'www.domain.test', @cgi.env_table['HTTP_HOST']
+    assert_equal @qs, @cgi.env_table['Query_String']
+    assert_equal 'application/x-www-form-urlencoded', @cgi.env_table['content_type']
+    assert_equal 'AJP/1.3', @cgi.env_table['gateway_interface']
+    assert_equal @ua, @cgi.env_table['HTTP_USER_AGENT']
+    assert_equal 'ja-JP', @cgi.env_table['HTTP_CONTENT_LANGUAGE']
+  end
+
+  def test_params
+    assert_equal ['foo'], @cgi.params['test[first_name]']
+    assert_equal ['bar hoge'], @cgi.params['test[last_name]']
+    assert_equal ['foo-bar@yet.another.domain.test'], @cgi.params['test[email]']
+    assert_equal ['huga'], @cgi.params['key with SP']
+    assert_equal ['unyuu'], @cgi.params['nanika']
+    assert_equal ['\e'], @cgi.params['last']
+    assert_equal [], @cgi.params['test[invalid_key]']
+    assert_equal [], @cgi.params['']
+
+    assert_equal [], @cgi.params['Test[first_name]'] # case sensitive
+    assert_equal [], @cgi.params['test[Last_name]']  # case sensitive
+  end
+
+  def test_header_0
+    assert_nil @cgi.response
+    @cgi.header
+    assert_equal 'text/html', @cgi.response['Content-Type']
+  end
+
+  def test_header_1
+    assert_nil @cgi.response
+    @cgi.header('text/plain')
+    assert_equal 'text/plain', @cgi.response['Content-Type']
+  end
+
+  def test_header
+    assert_nil @cgi.response
+    @cgi.header(
+      "status" => "200 OK",
+      "charset" => "EUC-KR"
+    )
+    assert_equal 'text/html; charset=EUC-KR', @cgi.response['Content-Type']
+    assert_equal 'OK', @cgi.response.message
+  end
+end

data/test/net/test_ajp13client.rb

@@ -1,5 +1,5 @@
 require 'test/unit'
-require File.dirname(__FILE__) + '/../../lib/net/ajp13client'
+require File.dirname(__FILE__) + '/../../lib/net/ajp13/client'
 
 class Net::AJP13::ClientTest < Test::Unit::TestCase
   def setup

data/test/net/test_ajp13request.rb

@@ -159,8 +159,8 @@ class Net::AJP13::RequestTest < Test::Unit::TestCase
           assert_equal "deflate, gzip, x-gzip, identity, *;q=0", value
         when 'cookie'
           assert_block {
-            "JSESSIONID=54104A3A77560CEF8967D263F1A7193" == value or
-              "$Version=1" == value
+            "JSESSIONID=54104A3A775650CEF8967D263F1A7193, $Version=1" == value or
+            "$Version=1, JSESSIONID=54104A3A775650CEF8967D263F1A7193" == value
           }
         when 'cache-control'
           assert_equal "no-cache", value

data/test/net/test_ajp13server.rb

@@ -1,6 +1,6 @@
 require 'test/unit'
 require 'stringio'
-require File.dirname(__FILE__) + '/../../lib/net/ajp13server'
+require File.dirname(__FILE__) + '/../../lib/net/ajp13/server'
 
 class Net::AJP13::Server
   unless method_defined?(:fcall)
@@ -26,7 +26,7 @@ class Net::AJP13::Server::BodyInputTest < Test::Unit::TestCase
   class MockSocket
     def initialize(contents)
       @bodies = (
-        contents.map{|c| "\x12\x34#{[c.length].pack('n')}" + c } << 
+        contents.map{|c|"\x12\x34#{[c.length+2, c.length].pack('nn')}" + c } << 
 	"\x12\x34\x00\x00"
       ).map {|str| StringIO.new(str)}
       @write_buf = ''

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ruby-ajp
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
-date: 2006-01-09 00:00:00 +09:00
+  version: 0.2.0
+date: 2006-01-24 00:00:00 +09:00
 summary: An implementation of Apache Jserv Protocol 1.3 in Ruby
 require_paths: 
 - lib
@@ -28,9 +28,11 @@ cert_chain:
 authors: 
 - Yugui
 files: 
-- lib/net/ajp13server.rb
 - lib/net/ajp13.rb
-- lib/net/ajp13client.rb
+- lib/net/ajp13/server.rb
+- lib/net/ajp13/ajp13cgi.rb
+- lib/net/ajp13/client.rb
+- test/net/test_ajp13cgi.rb
 - test/net/test_ajp13request.rb
 - test/net/test_ajp13server.rb
 - test/net/test_ajp13response.rb
@@ -59,6 +61,7 @@ test_files:
 - test/net/test_ajp13request.rb
 - test/net/test_ajp13response.rb
 - test/net/test_ajp13client.rb
+- test/net/test_ajp13server.rb
 rdoc_options: []
 
 extra_rdoc_files: []