packet 0.1.2 → 0.1.3

data/lib/{meta_pimp.rb → packet/packet_meta_pimp.rb}

@@ -4,7 +4,7 @@
 class Packet::MetaPimp < Packet::Pimp
   # initializer of pimp
   attr_accessor :callback_hash
-  attr_accessor :worker_status, :worker_key
+  attr_accessor :worker_status, :worker_key,:worker_name
   def pimp_init
     @callback_hash ||= {}
     @worker_status = nil

data/lib/packet/packet_mongrel.rb

@@ -0,0 +1,218 @@
+# This module rewrites pieces of the very good Mongrel web server in
+# order to change it from a threaded application to an event based
+# application running inside an Packet event loop.  It should
+# be compatible with the existing Mongrel handlers for Rails,
+# Camping, Nitro, etc....
+PACKET_APP = File.expand_path(File.join(File.dirname(__FILE__) + "/.."))
+["bin","config","parser","worker","framework","lib","pimp"].each { |x| $LOAD_PATH.unshift(PACKET_APP + "/#{x}")}
+require "rubygems"
+require "packet"
+require 'mongrel'
+
+module Mongrel
+  class MongrelProtocol
+    def post_init
+      @parser = HttpParser.new
+      @params = HttpParams.new
+      @nparsed = 0
+      @request = nil
+      @request_len = nil
+      @linebuffer = ''
+    end
+
+    def receive_data data
+      @linebuffer << data
+      @nparsed = @parser.execute(@params, @linebuffer, @nparsed) unless @parser.finished?
+      if @parser.finished?
+        if @request_len.nil?
+          @request_len = @params[::Mongrel::Const::CONTENT_LENGTH].to_i
+          script_name, path_info, handlers = ::Mongrel::HttpServer::Instance.classifier.resolve(@params[::Mongrel::Const::REQUEST_PATH])
+          if handlers
+            @params[::Mongrel::Const::PATH_INFO] = path_info
+            @params[::Mongrel::Const::SCRIPT_NAME] = script_name
+            @params[::Mongrel::Const::REMOTE_ADDR] = @params[::Mongrel::Const::HTTP_X_FORWARDED_FOR] #|| ::Socket.unpack_sockaddr_in(get_peername)[1]
+            @notifiers = handlers.select { |h| h.request_notify }
+          end
+          if @request_len > ::Mongrel::Const::MAX_BODY
+            new_buffer = Tempfile.new(::Mongrel::Const::MONGREL_TMP_BASE)
+            new_buffer.binmode
+            new_buffer << @linebuffer[@nparsed..-1]
+            @linebuffer = new_buffer
+          else
+            @linebuffer = StringIO.new(@linebuffer[@nparsed..-1])
+            @linebuffer.pos = @linebuffer.length
+          end
+        end
+        if @linebuffer.length >= @request_len
+          @linebuffer.rewind
+          ::Mongrel::HttpServer::Instance.process_http_request(@params,@linebuffer,self)
+          @linebuffer.delete if Tempfile === @linebuffer
+        end
+      elsif @linebuffer.length > ::Mongrel::Const::MAX_HEADER
+        close_connection
+        raise ::Mongrel::HttpParserError.new("HEADER is longer than allowed, aborting client early.")
+      end
+    rescue ::Mongrel::HttpParserError
+      if $mongrel_debug_client
+        STDERR.puts "#{Time.now}: BAD CLIENT (#{params[Const::HTTP_X_FORWARDED_FOR] || client.peeraddr.last}): #$!"
+        STDERR.puts "#{Time.now}: REQUEST DATA: #{data.inspect}\n---\nPARAMS: #{params.inspect}\n---\n"
+      end
+      close_connection
+    rescue Exception => e
+      close_connection
+      raise e
+    end
+
+    def write data
+      send_data data
+    end
+
+    def closed?
+      false
+    end
+
+  end
+
+  class HttpServer
+    def initialize(host, port, num_processors=950, x=0, y=nil) # Deal with Mongrel 1.0.1 or earlier, as well as later.
+      @socket = nil
+      @classifier = URIClassifier.new
+      @host = host
+      @port = port
+      @workers = ThreadGroup.new
+      if y
+        @throttle = x
+        @timeout = y || 60
+      else
+        @timeout = x
+      end
+      @num_processors = num_processors #num_processors is pointless for evented....
+      @death_time = 60
+      self.class.const_set(:Instance,self)
+    end
+
+    def run
+      trap('INT') { raise StopServer }
+      trap('TERM') { raise StopServer }
+      @acceptor = Thread.new do
+        Packet::Reactor.run do |t_reactor|
+          begin
+            t_reactor.start_server(@host,@port,MongrelProtocol)
+          rescue StopServer
+            t_reactor.start_server
+          end
+        end
+      end
+    end
+
+    def process_http_request(params,linebuffer,client)
+      if not params[Const::REQUEST_PATH]
+        uri = URI.parse(params[Const::REQUEST_URI])
+        params[Const::REQUEST_PATH] = uri.request_uri
+      end
+
+      raise "No REQUEST PATH" if not params[Const::REQUEST_PATH]
+
+      script_name, path_info, handlers = @classifier.resolve(params[Const::REQUEST_PATH])
+
+      if handlers
+        notifiers = handlers.select { |h| h.request_notify }
+        request = HttpRequest.new(params, linebuffer, notifiers)
+
+        # request is good so far, continue processing the response
+        response = HttpResponse.new(client)
+
+        # Process each handler in registered order until we run out or one finalizes the response.
+        dispatch_to_handlers(handlers,request,response)
+
+        # And finally, if nobody closed the response off, we finalize it.
+        unless response.done
+          response.finished
+        else
+          response.close_connection
+        end
+      else
+        # Didn't find it, return a stock 404 response.
+        client.send_data(Const::ERROR_404_RESPONSE)
+        client.close_connection
+      end
+    end
+
+    def dispatch_to_handlers(handlers,request,response)
+      handlers.each do |handler|
+        handler.process(request, response)
+        break if response.done
+      end
+    end
+  end
+
+  class HttpRequest
+    def initialize(params, linebuffer, dispatchers)
+      @params = params
+      @dispatchers = dispatchers
+      @body = linebuffer
+    end
+  end
+
+  class HttpResponse
+    def send_file(path, small_file = false)
+      File.open(path, "rb") do |f|
+        while chunk = f.read(Const::CHUNK_SIZE) and chunk.length > 0
+          begin
+            write(chunk)
+          rescue Object => exc
+            break
+          end
+        end
+      end
+      @body_sent = true
+    end
+
+    def write(data)
+      @socket.send_data data
+    end
+
+    def close_connection_after_writing
+      @socket.close_connection
+    end
+
+    def socket_error(details)
+      @socket.close_connection
+      done = true
+      raise details
+    end
+
+    def finished
+      send_status
+      send_header
+      send_body
+      @socket.close_connection
+    end
+  end
+
+  class Configurator
+    # This version fixes a bug in the regular Mongrel version by adding
+    # initialization of groups.
+    def change_privilege(user, group)
+      if user and group
+        log "Initializing groups for {#user}:{#group}."
+        Process.initgroups(user,Etc.getgrnam(group).gid)
+      end
+
+      if group
+        log "Changing group to #{group}."
+        Process::GID.change_privilege(Etc.getgrnam(group).gid)
+      end
+
+      if user
+        log "Changing user to #{user}."
+        Process::UID.change_privilege(Etc.getpwnam(user).uid)
+      end
+    rescue Errno::EPERM
+      log "FAILED to change user:group #{user}:#{group}: #$!"
+      exit 1
+    end
+  end
+end
+
+

data/lib/{nbio.rb → packet/packet_nbio.rb}

@@ -11,48 +11,54 @@ module Packet
     end
 
     def read_data(t_sock)
-      sock_data = ""
+      sock_data = []
       begin
-        while(t_data = t_sock.recv_nonblock(1023))
-          raise DisconnectError.new(t_sock) if t_data.empty?
+        while(t_data = t_sock.recv_nonblock((16*1024)-1))
+          raise DisconnectError.new(t_sock,sock_data.join) if t_data.empty?
           sock_data << t_data
         end
       rescue Errno::EAGAIN
-        return sock_data
+        return sock_data.join
       rescue Errno::EWOULDBLOCK
-        return sock_data
+        return sock_data.join
       rescue
-        raise DisconnectError.new(t_sock)
-      end
-    end
-
-    def write_data(p_data,p_sock)
-      return unless p_data
-      if p_data.is_a? Fixnum
-        t_data = p_data.to_s
-      else
-        t_data = p_data.dup.to_s
-      end
-      t_length = t_data.length
-      begin
-        p_sock.write_nonblock(t_data)
-      rescue Errno::EAGAIN
-        return
-      rescue Errno::EPIPE
-        raise DisconnectError.new(p_sock)
+        raise DisconnectError.new(t_sock,sock_data.join)
       end
     end
 
     # method writes data to socket in a non blocking manner, but doesn't care if there is a error writing data
     def write_once(p_data,p_sock)
-      t_data = p_data.dup.to_s
+      t_data = p_data.to_s
+      written_length = 0
+      data_length = t_data.length
       begin
-        p_sock.write_nonblock(t_data)
+        written_length = p_sock.write_nonblock(t_data)
+        return "" if written_length == data_length
+        return t_data[written_length..-1]
       rescue Errno::EAGAIN
-        return
+        return t_data[written_length..-1]
       rescue Errno::EPIPE
         raise DisconnectError.new(p_sock)
+      rescue Errno::ECONNRESET
+        raise DisconnectError.new(p_sock)
+      rescue
+        raise DisconnectError.new(p_sock)
+      end
+    end
+    
+    # write the data in socket buffer and schedule the thing
+    def write_and_schedule sock
+      outbound_data.each_with_index do |t_data,index|
+        leftover = write_once(t_data,sock)
+        if leftover.empty?
+          outbound_data.delete_at(index)
+        else
+          outbound_data[index] = leftover
+          reactor.schedule_write(sock)
+          break
+        end
       end
+      reactor.cancel_write(sock) if outbound_data.empty?
     end
 
     # method dumps the object in a protocol format which can be easily picked by a recursive descent parser
@@ -61,17 +67,11 @@ module Packet
       dump_length = object_dump.length.to_s
       length_str = dump_length.rjust(9,'0')
       final_data = length_str + object_dump
-      begin
-        p_sock.write_nonblock(final_data)
-      rescue Errno::EAGAIN
-        puts "EAGAIN Error while writing socket"
-        return
-      rescue Errno::EINTR
-        puts "Interrupt error"
-        return
-      rescue Errno::EPIPE
-        puts "Pipe error"
-        raise DisconnectError.new(p_sock)
+      outbound_data << final_data
+      begin 
+        write_and_schedule(p_sock) 
+      rescue DisconnectError => sock
+        close_connection(sock)
       end
     end
   end

data/lib/{pimp.rb → packet/packet_pimp.rb}

@@ -6,13 +6,15 @@ module Packet
     iattr_accessor :pimp_name
     attr_accessor :lifeline, :pid, :signature
     attr_accessor :fd_write_end
-    attr_accessor :workers, :reactor
+    attr_accessor :workers, :reactor,:outbound_data
+
 
     def initialize(lifeline_socket,worker_pid,p_reactor)
       @lifeline = lifeline_socket
       @pid = worker_pid
       @reactor = p_reactor
       @signature = Guid.hexdigest
+      @outbound_data = []
       pimp_init if self.respond_to?(:pimp_init)
     end
 

data/lib/{worker.rb → packet/packet_worker.rb}

@@ -14,17 +14,16 @@ module Packet
       # @fd_reader = args.shift if args.length > 2
       @msg_writer = messengers[:write_end]
       @msg_reader = messengers[:read_end]
-      @fd_reader = messengers[:read_fd]
       t_instance = new
       t_instance.worker_options = messengers[:options]
       t_instance.worker_init if t_instance.respond_to?(:worker_init)
       t_instance.start_reactor
+      t_instance
     end
 
     def initialize
       super
       @read_ios << msg_reader
-      @read_ios << fd_reader
       @tokenizer = BinParser.new
     end
 
@@ -61,7 +60,6 @@ module Packet
       class << handler_instance
         extend Forwardable
         attr_accessor :worker, :connection, :reactor, :initialized, :signature
-        attr_accessor :thread_pool
         include NbioHelper
         include Connection
         def_delegators :@reactor, :start_server, :connect, :add_periodic_timer, :add_timer, :cancel_timer,:reconnect
@@ -69,7 +67,6 @@ module Packet
       handler_instance.connection = connection
       handler_instance.worker = self
       handler_instance.reactor = self
-      handler_instance.thread_pool = @thread_pool
     end
 
     def log log_data

data/lib/{timer_store.rb → packet/timer_store.rb}

@@ -3,6 +3,9 @@
  Nothing more, nothing less.
 =end
 
+require "event" 
+require "packet_guid" 
+
 module Packet
   class TimerStore
     attr_accessor :order
@@ -16,15 +19,21 @@ module Packet
       @container[int_time] ||= []
       @container[int_time] << timer
 
-      if @container.empty?
+      if @container.empty? or @order.empty?
         @order << int_time
         return
       end
-      if @order.last <= key
+
+
+      if @order.last <= int_time
         @order << int_time
       else
-        index = bin_search_for_key(o,@order.length - 1,int_time)
-        @order.insert(index,int_time)
+        index = bin_search_for_key(0,@order.length - 1,int_time)
+        if(int_time < @order[index-1] && index != 0)
+          @order.insert(index-1,int_time)
+        else
+          @order.insert(index,int_time)
+        end
       end
     end
 
@@ -39,25 +48,24 @@ module Packet
         bin_search_for_key(lower_index,pivot,key)
       end
     end
-  end
 
-  def each
-    @order.each_with_index do |x,i|
-      if x <= Time.now.to_i
-        @container[x].each { |timer| yield x }
-        @container.delete(x)
-        @order.delete_at(i)
+    def each
+      @order.each_with_index do |x,i|
+        @container[x].each do |timer| 
+          yield timer
+        end
+        # @container.delete(x) if @container[x].empty?
+        # @order.delete_at(i)
       end
     end
-  end
 
-  def delete(timer)
-    int_time = timer.scheduled_time
-    @container[int_time] && @container[int_time].delete(timer)
+    def delete(timer)
+      int_time = timer.scheduled_time.to_i
+      @container[int_time] && @container[int_time].delete(timer)
 
-    if(!@container[int_time] || @container[int_time].empty?)
-      @order.delete(timer)
+      if(!@container[int_time] || @container[int_time].empty?)
+        @order.delete(timer)
+      end
     end
   end
 end
-