ruby-ajp 0.1.5

data/lib/net/ajp13server.rb

@@ -0,0 +1,430 @@
+# == Ruby/AJP server
+# === Examples
+# See example/ directory
+#
+# === Copyright
+# Author:: Yugui (mailto:yugui@yugui.sakura.ne.jp)
+# Copyright:: Copyright (c) 2006 Yugui
+# License:: LGPL
+#           
+#           This library is free software; you can redistribute it and/or
+#           modify it under the terms of the GNU Lesser General Public
+#           License as published by the Free Software Foundation; version 2.1
+#           of the License any later version.
+#
+#           This library is distributed in the hope that it will be useful,
+#           but WITHOUT ANY WARRANTY; without even the implied warranty of
+#           MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#           Lesser General Public License for more details.
+#
+#           You should have received a copy of the GNU Lesser General Public
+#           License along with this library; if not, write to the Free Software
+#           Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, 
+#           MA  02110-1301  USA
+#
+
+require 'socket'
+require 'ipaddr'
+require 'mutex_m'
+require 'timeout'
+require 'stringio'
+require 'net/ajp13'
+
+# :stopdoc:
+module Net; end
+module Net::AJP13; end
+# :startdoc:
+
+# Provides a skeleton to implement an AJP 1.3 server.
+class Net::AJP13::Server
+  include Net::AJP13::Constants
+  include Mutex_m
+
+  # 
+  # +host+:: Host to bind. If ommited or +nil+, the server will accept requests
+  #          from any hosts.
+  # +serivce+:: Port number to bind. It can be a service name registered in
+  #             /etc/services (or NIS). 
+  def initialize(*args) #:args: [host,] service = DEFAULT_PORT
+    @host = nil
+    @service = DEFAULT_PORT
+
+    case args.length
+    when 2
+      @host = args[0] if args[0]
+      @service = args[1] if args[1]
+      @open_socket = lambda{ TCPServer.new(@host, @service) }
+    when 1
+      @service = args[0] if args[0]
+      @open_socket = lambda{ TCPServer.new(@service) }
+    when 0
+      @open_socket = lambda{ TCPServer.new(@service) }
+    else
+      raise ArgumentError, "wrong number of arguments (#{args.length} for 0..2)"
+    end
+  end
+
+  # The instance accepts only requests from #host.
+  # If host is +nil+, it accepts requests from any hosts.
+  # See Also:: TCPServer.new, bind(2)
+  attr_reader :host
+
+  # The port number to bind.
+  attr_reader :service
+
+  # logger
+  attr_accessor :logger
+  def logger
+    unless @logger
+      require 'logger'
+      @logger = Logger.new(STDOUT)
+    end
+    @logger
+  end
+
+  def start(sock = nil)
+    logger.info("Starting #{self.class}")
+    if sock
+      @sock = sock
+    else
+      @sock = @open_socket.call
+    end
+
+    @sock.listen(5)
+    begin
+      until @shutdown
+        accepted = @sock.accept
+	Thread.new {
+	  begin
+	    until accepted.closed?
+              process(accepted)
+	    end
+	  rescue StandardError => err
+	    logger.error("#{err.message} from #{err.backtrace("\n")}")
+	  rescue Object => err
+	    logger.fatal("#{err.message} from #{err.backtrace("\n")}")
+	  else
+	    logger.debug("closed")
+	  ensure
+	    accepted.close unless accepted.closed?
+	  end
+	}
+      end
+    end
+
+    logger.info("Exited normally.")
+  rescue Interrupt
+    logger.info("Exited by Interrupt.")
+  ensure
+    @sock.close if @sock and !@sock.closed?
+  end
+
+
+  # You must override this method. The default implementation simply raises
+  # a ProcessRequestNotImplementedError.
+  # +request+:: The Net::AJP13::Request object that represents an accepted
+  #             AJP request.
+  # The return value must be a Net::AJP13::Response object.
+  def process_request(request)
+    raise ProcessRequestNotImplementedError, "Must be overridden."
+  end
+
+  private
+
+  # +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}"
+    end
+  end
+
+  def process_forward_request(packet, conn)
+    req = Net::AJP13::Request.from_packet(packet)
+    if req['content-length'] and req.content_length > 0
+      req.body_stream = BodyInput.new(conn, req.content_length)
+    end
+
+    user_code_error = nil
+    begin
+      res = process_request(req)
+    rescue ProcessRequestNotImplementedError
+      raise
+    rescue Object => err
+      user_code_error = err
+    end
+
+    if user_code_error
+      # sends backtrace
+      message = user_code_error.message + ": " +
+        user_code_error.backtrace.join("\n")
+      logger.error(message)
+
+      message = message[0, MAX_PACKET_SIZE - 4] if
+        message.length > MAX_PACKET_SIZE - 4
+      res = Net::AJP13::Response.new(500)
+      res['content-type'] = 'text/plain'
+      res['content-length'] = message.length.to_s
+      res.send_to conn
+      conn.write "\x41\x42#{[message.length + 4].pack('n')}\x03#{[message.length].pack('n')}#{message}\x00"
+    else
+      # SEND_HEADERS packet
+      res['content-length'] ||= res.body.length.to_s if res.body 
+      res.send_to conn
+
+      # SEND_BODY_CHUNK packets
+      if res.body
+        stream = StringIO.new(res.body)
+        until stream.eof?
+          chunk = stream.read(MAX_PACKET_SIZE - 4)
+          packet = Net::AJP13::Packet.new
+          packet.direction = :from_app
+	  packet.append_byte SEND_BODY_CHUNK
+
+          # differ from ajpv13a.html, but Tomcat5 acts like this. 
+	  packet.append_string chunk
+
+	  packet.send_to conn
+        end
+      end
+    end
+
+    # END_RESPONSE packet
+    packet = Net::AJP13::Packet.new
+    packet.direction = :from_app
+    packet.append_byte END_RESPONSE
+    packet.append_boolean !user_code_error
+    packet.send_to conn
+
+    conn.close if user_code_error
+  end
+
+  def process_cping(packet, conn)
+    packet = Net::AJP13::Packet.new
+    packet.direction = :from_app
+    packet.append_byte CPONG_REPLY
+    packet.send_to conn
+  end
+
+  def process_shutdown(packet, conn)
+    if IPAddr.new(conn.addr[3]) == IPAddr.new(conn.peeraddr[3])
+      shutdown
+    end
+  end
+
+  def shutdown(force = false)
+    @shutdown = true
+    @sock.close if force
+  end
+
+  class ProcessRequestNotImplementedError < NotImplementedError
+  end
+
+  # Input stream that corresponds the request body from the web server.
+  # BodyInput object acts as an IO except writing methods.
+  class BodyInput
+    include Net::AJP13::Constants
+    include Enumerable
+
+    # +sock+:: socket connection to the web server
+    # +length+:: Content-Length
+    def initialize(sock, length)
+      @sock = sock
+      @packet = Net::AJP13::Packet.from_io(sock)
+      @length = length
+      @read_length = 0
+    end
+
+    # Content-Length
+    attr_reader :length
+    alias :size :length
+
+    # Does nothing
+    def binmode; self end
+
+    # Raises TypeError. You can't clone BodyInput.
+    def clone
+      raise TypeError, "can't clone #{self.class}"
+    end
+    alias :dup :clone
+
+    # Closes the BodyInput. 
+    # Note that this method does not close the internal socket connection.
+    def close
+      @packet = @sock = nil
+    end
+
+    # Returns true if the BodyInput is closed.
+    def closed?
+      @sock.nil?
+    end
+    alias :close_read :close
+
+    # Same as IO#each_byte
+    def each_byte
+      while ch = getc
+        yield ch
+      end
+    end
+
+    def eof?
+      @read_length >= @length 
+    end
+    alias :eof :eof?
+
+    # Raises NotImplementedError
+    def fcntl(*args)
+      raise NotImplementedError, "#{self} does not support fcntl"
+    end
+    # Raises NotImplementedError
+    def iocntl(*args)
+      raise NotImplementedError, "#{self} does not support iocntl"
+    end
+
+    # Always returns nil
+    def fileno; nil end
+    alias :to_i :fileno
+
+    def getc
+      str = read(1)
+      str and str[0]
+    end
+    
+    # Returns false
+    def isatty; false end
+    alias :tty? :isatty
+
+    def lineno; @lineno end
+
+    # Returns nil
+    def pid; nil end
+
+    # Returns current read position.
+    def pos; @read_length end
+    alias :tell :pos
+
+    def read(length = nil, buf = '') #:args: [length[, buf]]
+      raise TypeError, "can't modify frozen stream" if frozen?
+      raise IOError, 'closed stream' if closed?
+      if length.nil?
+        return '' if eof?
+	length = [0, @length - @read_length].max
+      else
+        raise ArgumentError, "negative length #{length} given" if length < 0
+        if eof?
+          buf[0..-1] = ''
+	  return nil
+	end
+      end
+
+      if @packet.eof?
+        written_length = 0
+      else
+        chunk = @packet.read_bytes(length)
+        written_length = chunk.length
+	@read_length += written_length
+        buf[0, written_length] = chunk
+      end
+      while written_length < length and !eof?
+        packet = Net::AJP13::Packet.new
+	packet.direction = :from_app
+	packet.append_byte GET_BODY_CHUNK
+	packet.append_integer [@length - @read_length, MAX_BODY_CHUNK_SIZE].min
+	packet.send_to @sock
+
+        @packet = Net::AJP13::Packet.from_io(@sock)
+	if @packet.length == 0
+	  # this means eof
+	  break
+	else
+	  chunk = @packet.read_bytes(length - written_length)
+	  buf[written_length, chunk.length] = chunk
+	  written_length += chunk.length
+	  @read_length += chunk.length
+	end
+      end
+      if written_length < buf.length
+        buf[written_length..-1] = ''
+      end
+      
+      return buf
+    end
+
+
+    def readchar
+      str = read(1)
+      if str.nil?
+        raise EOFError
+      else
+        str[0]
+      end
+    end
+
+    GETS_BLOCK_SIZE = 256 # :nodoc:
+    def gets(rs = $/)
+      return read if rs.nil?
+      @lineno ||= 0
+      @line ||= ''
+      pattern = /\A.+?#{rs=='' ? "\\r?\\n\\r?\\n" : Regexp.escape(rs)}/
+      until md = pattern.match(@line)
+        block = read(GETS_BLOCK_SIZE)
+	if block.nil?
+	  line = @line
+	  @line = nil
+	  @lineno += 1
+	  return line == '' ? nil : line
+	else
+          @line << block
+	end
+      end
+      @line = md.post_match
+      @lineno += 1
+      return md.to_s
+    end
+    def readline(rs = $/)
+      line = gets(rs)
+      if line.nil? 
+        raise EOFError
+      else
+        line
+      end
+    end
+    def each_line(rs = $/)
+      while line = gets(rs)
+        yield line
+      end
+    end
+    alias :each :each_line
+
+    # Raises NotImplementedError
+    def reopen(*args)
+      raise NotImplementedError, "#{self.class} does not support reopen"
+    end
+
+    def sync; @sock.sync end
+    def sync=(val); @sock.sync = val end
+
+    alias :sysread :read
+
+    # Returns self
+    def to_io; self end
+
+    def ungetc(char)
+      raise TypeError, "#{char} is not a Fixnum" unless char.is_a? Fixnum
+      raise ArgumentError, "#{char} must be a byte, but negative" if char < 0
+      raise ArgumentError, "#{char} is too large to treat as a byte" if char > 0xFF
+      @packet.unread_byte(char)
+      @read_length -= 1
+      nil
+    end
+  end
+end

data/ruby-ajp.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |spec|
+  spec.name = "ruby-ajp"
+  spec.version = "0.1.5"
+  spec.required_ruby_version = ">= 1.8.3"
+  spec.summary = "An implementation of Apache Jserv Protocol 1.3 in Ruby"
+  spec.author = "Yugui"
+  spec.email = "yugui@yugui.sakura.ne.jp"
+  spec.rubyforge_project = "ruby-ajp"
+  spec.files = 
+    Dir.glob("lib/**/*.rb") +
+    Dir.glob("test/**/test_*.rb") +
+    Dir.glob("test/**/data/*") +
+    Dir.glob("example/**/*.rb") +
+    Dir.glob("NEWS.{en,ja}") + 
+    Dir.glob("Install.{en,ja}") + 
+    Dir.glob("README.{en,ja}") <<
+    "Rakefile" <<
+    "ruby-ajp.gemspec" <<
+    "setup.rb" <<
+    "COPYING"
+  spec.files.reject! {|fn| fn.include?('.svn') }
+  spec.test_files = [
+    'packet', 'request',
+    'response', 'client'
+  ].map{|x| "test/net/test_ajp13#{x}.rb"}
+  spec.has_rdoc = true
+end