packet 0.1.0

data/lib/packet_guid.rb

@@ -0,0 +1,16 @@
+module Packet
+  class Guid
+    def self.hexdigest
+      values = [
+                rand(0x0010000),
+                rand(0x0010000),
+                rand(0x0010000),
+                rand(0x0010000),
+                rand(0x0010000),
+                rand(0x1000000),
+                rand(0x1000000),
+               ]
+      "%04x%04x%04x%04x%04x%06x%06x" % values
+    end
+  end
+end

data/lib/packet_master.rb

@@ -0,0 +1,148 @@
+# FIXME: Some code is duplicated between worker class and this Reactor class, that can be fixed
+# with help of creation of Connection class and enabling automatic inheritance of that class and
+# mixing in of methods from that class.
+module Packet
+  class Reactor
+    include Core
+    attr_accessor :fd_writers, :msg_writers,:msg_reader
+    attr_accessor :live_workers
+    after_connection :provide_workers
+
+    def self.run
+      master_reactor_instance = new
+      master_reactor_instance.live_workers = DoubleKeyedHash.new
+      yield(master_reactor_instance)
+      master_reactor_instance.load_workers
+      master_reactor_instance.start_reactor
+    end # end of run method
+
+    def provide_workers(handler_instance,t_sock)
+      class << handler_instance
+        extend Forwardable
+        attr_accessor :workers,:connection,:reactor, :initialized,:signature
+        include NbioHelper
+        def send_data p_data
+          begin
+            write_data(p_data,connection)
+          rescue Errno::EPIPE
+            # probably a callback, when there is a error in writing to the socket
+          end
+        end
+        def invoke_init
+          @initialized = true
+          post_init
+        end
+
+        def close_connection
+          unbind
+          reactor.remove_connection(connection)
+        end
+
+        def close_connection_after_writing
+          connection.flush
+          unbind
+          reactor.remove_connection(connection)
+        end
+
+        def ask_worker(*args)
+          worker_name = args.shift
+          data_options = *args
+          data_options[:client_signature] = connection.fileno
+          workers[worker_name].send_request(data_options)
+        end
+
+        def send_object p_object
+          dump_object(p_object,connection)
+        end
+        def_delegators :@reactor, :start_server, :connect, :add_periodic_timer, :add_timer, :cancel_timer,:reconnect, :start_worker
+      end
+      handler_instance.workers = @live_workers
+      handler_instance.connection = t_sock
+      handler_instance.reactor = self
+    end
+
+    # FIXME: right now, each worker is tied to its connection and this can be problematic
+    # what if a worker wants to return results in a async manner
+    def handle_internal_messages(t_sock)
+      sock_fd = t_sock.fileno
+      worker_instance = @live_workers[sock_fd]
+      begin
+        raw_data = read_data(t_sock)
+        # t_data = Marshal.load(raw_data)
+        worker_instance.receive_data(raw_data) if worker_instance.respond_to?(:receive_data)
+      rescue DisconnectError => sock_error
+        read_ios.delete(t_sock)
+      end
+    end
+
+    # method loads workers in new processes
+    # FIXME: this method can be fixed, so as worker code can be actually, required
+    # only in forked process and hence saving upon the memory involved
+    # where worker is actually required in master as well as in worker.
+    def load_workers
+
+      if defined?(WORKER_ROOT)
+        worker_root = WORKER_ROOT
+      else
+        worker_root = "#{PACKET_APP}/worker"
+      end
+      t_workers = Dir["#{worker_root}/**/*.rb"]
+      return if t_workers.blank?
+      t_workers.each do |b_worker|
+        worker_name = File.basename(b_worker,".rb")
+        require worker_name
+        worker_klass = Object.const_get(worker_name.classify)
+        next if worker_klass.no_auto_load
+        fork_and_load(worker_klass)
+      end
+
+      # FIXME: easiest and yet perhaps a bit ugly, its just to make sure that from each
+      # worker proxy one can access other workers
+      @live_workers.each do |key,worker_instance|
+        worker_instance.workers = @live_workers
+      end
+    end
+
+    def start_worker(worker_name,options = {})
+      require worker_name.to_s
+      worker_klass = Object.const_get(worker_name.classify)
+      fork_and_load(worker_klass,options)
+    end
+
+    # method forks given worker file in a new process
+    def fork_and_load(worker_klass,worker_options = { })
+      t_worker_name = worker_klass.worker_name
+      worker_pimp = worker_klass.worker_proxy.to_s
+
+      # socket from which master process is going to read
+      master_read_end,worker_write_end = UNIXSocket.pair(Socket::SOCK_STREAM)
+      # socket to which master process is going to write
+      worker_read_end,master_write_end = UNIXSocket.pair(Socket::SOCK_STREAM)
+      worker_read_fd,master_write_fd = UNIXSocket.pair
+
+      if((pid = fork()).nil?)
+        $0 = "ruby #{worker_klass.worker_name}"
+        master_write_end.close
+        master_read_end.close
+        master_write_fd.close
+        # master_write_end.close if master_write_end
+        worker_klass.start_worker(:write_end => worker_write_end,:read_end => worker_read_end,:read_fd => worker_read_fd,:options => worker_options)
+      end
+      Process.detach(pid)
+
+      unless worker_pimp.blank?
+        require worker_pimp
+        pimp_klass = Object.const_get(worker_pimp.classify)
+        @live_workers[t_worker_name,master_read_end.fileno] = pimp_klass.new(master_write_end,pid,self)
+      else
+        @live_workers[t_worker_name,master_read_end.fileno] = Packet::MetaPimp.new(master_write_end,pid,self)
+      end
+
+      worker_read_end.close
+      worker_write_end.close
+      worker_read_fd.close
+      read_ios << master_read_end
+    end # end of fork_and_load method
+
+  end # end of Reactor class
+end # end of Packet module

data/lib/packet_mongrel.rb

@@ -0,0 +1,214 @@
+# 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....
+ 
+require 'packet'
+require 'mongrel'
+
+module Mongrel
+	class MongrelProtocol < Packet::Connection
+		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/periodic_event.rb

@@ -0,0 +1,27 @@
+module Packet
+  class PeriodicEvent
+    attr_accessor :block, :timer_signature, :interval, :cancel_flag
+    def initialize(interval, &block)
+      @cancel_flag = false
+      @timer_signature = Guid.hexdigest
+      @block = block
+      @scheduled_time = Time.now + interval
+      @interval = interval
+    end
+
+    def run_now?
+      return true if @scheduled_time <= Time.now
+      return false
+    end
+
+    def cancel
+      @cancel_flag = true
+    end
+
+    def run
+      @scheduled_time += @interval
+      @block.call
+    end
+
+  end
+end

data/lib/pimp.rb

@@ -0,0 +1,31 @@
+module Packet
+  class Pimp
+    include NbioHelper
+    extend Forwardable
+    iattr_accessor :pimp_name
+    attr_accessor :lifeline, :pid, :signature
+    attr_accessor :fd_write_end
+    attr_accessor :workers, :reactor
+
+    def initialize(lifeline_socket,worker_pid,p_reactor)
+      @lifeline = lifeline_socket
+      @pid = worker_pid
+      @reactor = p_reactor
+      @signature = Guid.hexdigest
+      pimp_init if self.respond_to?(:pimp_init)
+    end
+
+    # encode the data, before writing to the socket
+    def send_data p_data
+      dump_object(p_data,@lifeline)
+    end
+
+    def send_fd sock_fd
+      @fd_write_end.send_io(sock_fd)
+    end
+
+    alias_method :do_work, :send_data
+    def_delegators :@reactor, :connections
+  end
+end
+

data/lib/ruby_hacks.rb

@@ -0,0 +1,125 @@
+# FIXME: ultimate goal should be remove dependence from activesupport gem altogether.
+
+class Object
+  def deep_copy
+    Marshal.load(Marshal.dump(self))
+  end
+
+  def nothing?
+    if respond_to?(:empty?) && respond_to?(:strip)
+      empty? or strip.empty?
+    elsif respond_to?(:empty?)
+      empty?
+    elsif respond_to?(:zero?)
+      zero?
+    else
+      !self
+    end
+  end
+
+  def clean!
+    if respond_to?(:empty?) && respond_to?(:strip)
+      return nil if empty?
+      (strip.empty?) ? nil : (self.strip)
+    elsif respond_to?(:empty?)
+      empty? ? nil : self
+    else
+      self
+    end
+  end
+
+  def blank?
+    if respond_to?(:empty?) && respond_to?(:strip)
+      empty? or strip.empty?
+    elsif respond_to?(:empty?)
+      empty?
+    else
+      !self
+    end
+  end
+
+  def self.metaclass; class << self; self; end; end
+
+  def self.iattr_accessor *args
+
+    metaclass.instance_eval do
+      attr_accessor *args
+      args.each do |attr|
+        define_method("set_#{attr}") do |b_value|
+          self.send("#{attr}=",b_value)
+        end
+      end
+    end
+
+    args.each do |attr|
+      class_eval do
+        define_method(attr) do
+          self.class.send(attr)
+        end
+        define_method("#{attr}=") do |b_value|
+          self.class.send("#{attr}=",b_value)
+        end
+      end
+    end
+  end
+end
+
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+  def clean!
+    (empty?) ? nil : self
+  end
+
+  def extract_options!
+    last.is_a?(Hash) ? pop : {}
+  end
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+  def clean!
+    (empty?) ? nil : self
+  end
+end
+
+class String #:nodoc:
+  def blank?
+    empty? || strip.empty?
+  end
+
+  def clean!
+    return nil if empty?
+    t_val = self.strip
+    (t_val.empty?) ? nil : t_val
+  end
+
+  def classify
+    word_parts = split('_')
+    return word_parts.map { |x| x.capitalize}.join
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end