packet 0.1.5 → 0.1.7

data/README

@@ -252,4 +252,3 @@ end
 
 
 
-

data/Rakefile

@@ -17,6 +17,7 @@ $LOAD_PATH.unshift __DIR__+'/lib'
 require 'packet'
 
 CLEAN.include ['**/.*.sw?', '*.gem', '.config','*.rbc']
+Dir["tasks/**/*.rake"].each { |rake| load rake }
 
 
 @windows = (PLATFORM =~ /win32/)
@@ -30,17 +31,6 @@ task :default => [:package]
 
 task :doc => [:rdoc]
 
-
-Rake::RDocTask.new do |rdoc|
-      files = ['README', 'MIT-LICENSE', 'CHANGELOG',
-               'lib/**/*.rb']
-      rdoc.rdoc_files.add(files)
-      rdoc.main = 'README'
-      rdoc.title = 'Packet Docs'
-      rdoc.rdoc_dir = 'doc/rdoc'
-      rdoc.options << '--line-numbers' << '--inline-source'
-end
-
 spec = Gem::Specification.new do |s|
   s.name = NAME
   s.version = Packet::VERSION
@@ -55,10 +45,10 @@ spec = Gem::Specification.new do |s|
   s.email = 'mail@gnufied.org'
   s.homepage = 'http://code.google.com/p/packet/'
   s.required_ruby_version = '>= 1.8.5'
-
   s.files = %w(MIT-LICENSE README Rakefile TODO) + Dir.glob("{spec,lib,examples}/**/*")
-
   s.require_path = "lib"
+  s.bindir = "bin"
+  s.executables = "packet_worker_runner"
 end
 
 Rake::GemPackageTask.new(spec) do |p|
@@ -75,16 +65,6 @@ task :uninstall => [:clean] do
   sh %{#{SUDO} gem uninstall #{NAME}}
 end
 
-##############################################################################
-# SVN
-##############################################################################
-
-desc "Add new files to subversion"
-task :svn_add do
-   system "svn status | grep '^\?' | sed -e 's/? *//' | sed -e 's/ /\ /g' | xargs svn add"
-end
-
-
 desc "Converts a YAML file into a test/spec skeleton"
 task :yaml_to_spec do
   require 'yaml'
@@ -93,3 +73,4 @@ task :yaml_to_spec do
     t+(s ?%.context "#{c}" do.+s.map{|d|%.\n  xspecify "#{d}" do\n  end\n.}*''+"end\n\n":'')
   }.strip
 end
+

data/bin/packet_worker_runner

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+PACKET_LIB_PATH = File.expand_path(File.dirname(__FILE__))
+["lib"].each { |x| $LOAD_PATH.unshift(File.join(PACKET_LIB_PATH,"..",x))}
+
+require "packet"
+
+module Packet
+  class WorkerRunner
+    include Packet::NbioHelper
+    def initialize args
+      cmd_args = args.split(':')
+      worker_name = cmd_args[2]
+      initial_arg_data_length = cmd_args[3].to_i
+      @worker_root = cmd_args[4]
+      @worker_load_env = cmd_args[5]
+
+
+      @worker_read_fd = UNIXSocket.for_fd(cmd_args[0].to_i)
+
+      @worker_write_fd = UNIXSocket.for_fd(cmd_args[1].to_i)
+
+      initial_arg_data = @worker_read_fd.read(initial_arg_data_length)
+
+      Packet::WorkerRunner.const_set(:WORKER_OPTIONS,Marshal.load(initial_arg_data))
+      require @worker_load_env if @worker_load_env && !@worker_load_env.empty?
+      load_worker worker_name
+    end
+
+    def load_worker worker_name
+      if @worker_root && (File.file? "#{@worker_root}/#{worker_name}.rb")
+        require "#{@worker_root}/#{worker_name}"
+        worker_klass = Object.const_get(packet_classify(worker_name))
+        worker_klass.start_worker(:read_end => @worker_read_fd,:write_end => @worker_write_fd,:options => WORKER_OPTIONS)
+      else
+        require worker_name
+        worker_klass = Object.const_get(packet_classify(worker_name))
+        if worker_klass.is_worker?
+          worker_klass.start_worker(:read_end => @worker_read_fd,:write_end => @worker_write_fd,:options => WORKER_OPTIONS)
+        else
+          raise Packet::InvalidWorker.new(worker_name)
+        end
+      end
+    end
+  end
+end
+
+Packet::WorkerRunner.new(ARGV[0])
+
+
+

data/lib/packet.rb

@@ -6,8 +6,11 @@ require "yaml"
 require "forwardable"
 require "ostruct"
 require "thread"
+require "fcntl"
+#require "enumerable"
 
 require "packet/packet_parser"
+require "packet/packet_invalid_worker"
 require "packet/packet_guid"
 require "packet/packet_helper"
 require "packet/double_keyed_hash"
@@ -26,5 +29,5 @@ require "packet/packet_worker"
 PACKET_APP = File.expand_path'../' unless defined?(PACKET_APP)
 
 module Packet
-  VERSION='0.1.5'
+  VERSION='0.1.7'
 end

data/lib/packet/double_keyed_hash.rb

@@ -1,31 +1,40 @@
-class DoubleKeyedHash
-  attr_accessor :internal_hash
-  def initialize
-    @keys1 = {}
-    @internal_hash = {}
-  end
+module Packet
+  class DoubleKeyedHash
+#    include Enumerable
+    attr_accessor :internal_hash
+    def initialize
+      @keys1 = {}
+      @internal_hash = {}
+    end
 
-  def []=(key1,key2,value)
-    @keys1[key2] = key1
-    @internal_hash[key1] = value
-  end
+    def []=(key1,key2,value)
+      @keys1[key2] = key1
+      @internal_hash[key1] = value
+    end
 
-  def [] key
-    @internal_hash[key] || @internal_hash[@keys1[key]]
-  end
+    def [] key
+      @internal_hash[key] || @internal_hash[@keys1[key]]
+    end
 
-  def delete(key)
-    t_key = @keys1[key]
-    if t_key
-      @keys1.delete(key)
-      @internal_hash.delete(t_key)
-    else
-      @keys1.delete_if { |key,value| value == key }
-      @internal_hash.delete(key)
+    def delete(key)
+      t_key = @keys1[key]
+      if t_key
+        @keys1.delete(key)
+        @internal_hash.delete(t_key)
+      else
+        @keys1.delete_if { |key,value| value == key }
+        @internal_hash.delete(key)
+      end
+    end
+
+    def length
+      @internal_hash.keys.length
     end
-  end
 
-  def each
-    @internal_hash.each { |key,value| yield(key,value)}
+    def each
+      @internal_hash.each { |key,value| yield(key,value)}
+    end
   end
 end
+
+

data/lib/packet/packet_callback.rb

@@ -12,3 +12,4 @@ module Packet
     end
   end
 end
+

data/lib/packet/packet_connection.rb

@@ -1,14 +1,18 @@
-# FIMXE: following class must modify the fd_watchlist thats being monitored by
-# main eventloop.
-
 module Packet
   module Connection
     attr_accessor :outbound_data,:connection_live
+    attr_accessor :worker,:connection,:reactor, :initialized,:signature
+    include NbioHelper
+
+    def unbind; end
+    def connection_completed; end
+    def post_init; end
+    def receive_data data; end
 
     def send_data p_data
       @outbound_data << p_data
       begin
-        write_and_schedule(connection) 
+        write_and_schedule(connection)
       rescue DisconnectError => sock
         close_connection
       end
@@ -18,23 +22,69 @@ module Packet
       @initialized = true
       @connection_live = true
       @outbound_data = []
-      post_init if respond_to?(:post_init)
+      post_init
     end
 
     def close_connection(sock = nil)
-      unbind if respond_to?(:unbind)
+      unbind
       reactor.cancel_write(connection)
       reactor.remove_connection(connection)
     end
 
     def close_connection_after_writing
-      connection.flush
+      connection.flush unless connection.closed?
       close_connection
     end
 
+    def get_peername
+      connection.getpeername
+    end
+
     def send_object p_object
       dump_object(p_object,connection)
     end
 
+    def ask_worker(*args)
+      worker_name = args.shift
+      data_options = *args
+      data_options[:client_signature] = connection.fileno
+      t_worker = reactor.live_workers[worker_name]
+      raise Packet::InvalidWorker.new("Invalid worker with name #{worker_name} and key #{data_options[:data][:worker_key]}") unless t_worker
+      t_worker.send_request(data_options)
+    end
+    def start_server ip,port,t_module,&block
+      reactor.start_server(ip,port,t_module,block)
+    end
+
+    def connect ip,port,t_module,&block
+      reactor.connect(ip,port,t_module,block)
+    end
+
+    def add_periodic_timer interval, &block
+      reactor.add_periodic_timer(interval,block)
+    end
+
+    def add_timer(t_time,&block)
+      reactor.add_timer(t_time,block)
+    end
+
+    def cancel_timer(t_timer)
+      reactor.cancel_timer(t_timer)
+    end
+
+    def reconnect server,port,handler
+      reactor.reconnect(server,port,handler)
+    end
+
+    def start_worker(worker_options = {})
+      reactor.start_worker(worker_options)
+    end
+
+    def delete_worker worker_options = {}
+      reactor.delete_worker(worker_options)
+    end
+
   end # end of class Connection
 end # end of module Packet
+
+

data/lib/packet/packet_core.rb

@@ -4,9 +4,8 @@ module Packet
     def self.included(base_klass)
       base_klass.extend(ClassMethods)
       base_klass.instance_eval do
-        @@connection_callbacks ||= {}
-
-        cattr_accessor :connection_callbacks
+        iattr_accessor :connection_callbacks
+        inheritable_attribute(:connection_callbacks,:default => {})
         attr_accessor :read_ios, :write_ios, :listen_sockets
         attr_accessor :connection_completion_awaited,:write_scheduled
         attr_accessor :connections, :windows_flag
@@ -22,6 +21,7 @@ module Packet
         connection_callbacks[:after_connection] << p_method
       end
 
+      # FIXME: following callbacks hasn't been tested and not usable.
       def after_unbind p_method
         connection_callbacks[:after_unbind] ||= []
         connection_callbacks[:after_unbind] << p_method
@@ -53,7 +53,9 @@ module Packet
 
       def reconnect(server,port,handler)
         raise "invalid handler" unless handler.respond_to?(:connection_completed)
-        return handler if connections.keys.include?(handler.connection.fileno)
+        if !handler.connection.closed? && connections.keys.include?(handler.connection.fileno)
+          return handler
+        end
         connect(server,port,handler)
       end
 
@@ -101,9 +103,10 @@ module Packet
           connections.delete(t_sock.fileno)
           t_sock.close
         rescue
+          puts "#{$!.message}"
         end
       end
-      
+
       def next_turn &block
         @on_next_tick = block
       end
@@ -111,7 +114,17 @@ module Packet
       # method opens a socket for listening
       def start_server(ip,port,t_module,&block)
         BasicSocket.do_not_reverse_lookup = true
-        t_socket = TCPServer.new(ip,port.to_i)
+        # Comment TCPServer for the time being
+        #t_socket = TCPServer.new(ip,port.to_i)
+        #t_socket = TCPSocket.
+
+        t_socket = Socket.new(Socket::AF_INET,Socket::SOCK_STREAM,0)
+        t_socket.setsockopt(Socket::SOL_SOCKET,Socket::SO_REUSEADDR,true)
+        sockaddr = Socket.sockaddr_in(port.to_i,ip)
+        t_socket.bind(sockaddr)
+        t_socket.listen(50)
+        t_socket.setsockopt(Socket::IPPROTO_TCP,Socket::TCP_NODELAY,1)
+
         # t_socket.setsockopt(*@tcp_defer_accept_opts) rescue nil
         listen_sockets[t_socket.fileno] = { :socket => t_socket,:block => block,:module => t_module }
         @read_ios << t_socket
@@ -124,7 +137,8 @@ module Packet
         loop do
           check_for_timer_events
           @on_next_tick.call if @on_next_tick
-          ready_read_fds,ready_write_fds,read_error_fds = select(read_ios,write_ios,nil,0.005)
+
+          ready_read_fds,ready_write_fds,read_error_fds = select(read_ios,write_ios,[],0.005)
 
           if ready_read_fds && !ready_read_fds.empty?
             handle_read_event(ready_read_fds)
@@ -135,23 +149,25 @@ module Packet
 
       end
 
-      def schedule_write(t_sock)
+      def schedule_write(t_sock,internal_instance = nil)
         fileno = t_sock.fileno
         if UNIXSocket === t_sock && internal_scheduled_write[fileno].nil?
           write_ios << t_sock
-          internal_scheduled_write[t_sock.fileno] ||= self
-        elsif write_scheduled[fileno].nil?
+          internal_scheduled_write[t_sock.fileno] ||= internal_instance
+        elsif write_scheduled[fileno].nil? && !(t_sock.is_a?(UNIXSocket))
           write_ios << t_sock
-          write_scheduled[fileno] ||= connections[fileno].instance
+          write_scheduled[fileno] ||= connections[fileno][:instance]
         end
       end
 
       def cancel_write(t_sock)
-        fileno = t_sock.fileno
-        if UNIXSocket === t_sock
-          internal_scheduled_write.delete(fileno)
-        else
-          write_scheduled.delete(fileno)
+        if !t_sock.closed?
+          fileno = t_sock.fileno
+          if UNIXSocket === t_sock
+            internal_scheduled_write.delete(fileno)
+          else
+            write_scheduled.delete(fileno)
+          end
         end
         write_ios.delete(t_sock)
       end
@@ -159,12 +175,12 @@ module Packet
       def handle_write_event(p_ready_fds)
         p_ready_fds.each do |sock_fd|
           fileno = sock_fd.fileno
-          if UNIXSocket === sock_fd && internal_scheduled_write[fileno]
-            write_and_schedule(sock_fd)
+          if UNIXSocket === sock_fd && (internal_instance = internal_scheduled_write[fileno])
+            internal_instance.write_and_schedule(sock_fd)
           elsif extern_opts = connection_completion_awaited[fileno]
             complete_connection(sock_fd,extern_opts)
           elsif handler_instance = write_scheduled[fileno]
-            handler_instance.write_scheduled(sock_fd)
+            handler_instance.write_and_schedule(sock_fd)
           end
         end
       end
@@ -172,7 +188,7 @@ module Packet
       def handle_read_event(p_ready_fds)
         ready_fds = p_ready_fds.flatten.compact
         ready_fds.each do |t_sock|
-          if(unix? && t_sock.is_a?(UNIXSocket))
+          if(t_sock.is_a?(UNIXSocket))
             handle_internal_messages(t_sock)
           else
             handle_external_messages(t_sock)
@@ -206,11 +222,12 @@ module Packet
       end
 
       def read_external_socket(t_sock)
-        handler_instance = connections[t_sock.fileno].instance
+        handler_instance = connections[t_sock.fileno][:instance]
         begin
           t_data = read_data(t_sock)
-          handler_instance.receive_data(t_data) if handler_instance.respond_to?(:receive_data)
+          handler_instance.receive_data(t_data)
         rescue DisconnectError => sock_error
+          handler_instance.receive_data(sock_error.data) unless (sock_error.data).empty?
           handler_instance.close_connection
         end
       end
@@ -275,7 +292,7 @@ module Packet
           end
         end
       end
-      
+
       # close the connection with internal specified socket
       def close_connection(sock = nil)
         begin
@@ -289,28 +306,38 @@ module Packet
         return p_module if(!p_module.is_a?(Class) and !p_module.is_a?(Module))
         handler =
           if(p_module and p_module.is_a?(Class))
-            p_module
+            p_module and p_module.send(:include,Connection)
           else
-            Class.new(Connection) { p_module and include p_module }
+            Class.new { include Connection; include p_module; }
           end
         return handler.new
       end
 
       def decorate_handler(t_socket,actually_connected,sock_addr,t_module,&block)
         handler_instance = initialize_handler(t_module)
-        connection_callbacks[:after_connection].each { |t_callback| self.send(t_callback,handler_instance,t_socket)}
+        after_connection_callbacks = connection_callbacks ? connection_callbacks[:after_connection] : nil
+        after_connection_callbacks && after_connection_callbacks.each { |t_callback| self.send(t_callback,handler_instance,t_socket)}
+        handler_instance.worker = self
+        handler_instance.connection = t_socket
+        handler_instance.reactor = self
         handler_instance.invoke_init unless handler_instance.initialized
         unless actually_connected
-          handler_instance.unbind if handler_instance.respond_to?(:unbind)
+          handler_instance.unbind
           return
         end
         handler_instance.signature = binding_str
-        connections[t_socket.fileno] =
-          OpenStruct.new(:socket => t_socket, :instance => handler_instance, :signature => handler_instance.signature,:sock_addr => sock_addr)
+        # FIXME: An Struct is more fashionable, but will have some performance hit, can use a simple hash here
+        # klass = Struct.new(:socket,:instance,:signature,:sock_addr)
+        connection_data = { :socket => t_socket,:instance => handler_instance,:signature => binding_str,:sock_addr => sock_addr }
+        connections[t_socket.fileno] = connection_data
+#         connections[t_socket.fileno] = klass.new(t_socket,handler_instance,handler_instance.signature,sock_addr)
+
         block.call(handler_instance) if block
-        handler_instance.connection_completed if handler_instance.respond_to?(:connection_completed)
+        handler_instance.connection_completed #if handler_instance.respond_to?(:connection_completed)
+        handler_instance
       end
 
     end # end of module#CommonMethods
   end #end of module#Core
 end #end of module#Packet
+

data/lib/packet/packet_event.rb

@@ -22,4 +22,4 @@ module Packet
     end
   end
 end
-# WOW
+

data/lib/packet/packet_guid.rb

@@ -14,3 +14,4 @@ module Packet
     end
   end
 end
+

data/lib/packet/packet_helper.rb

@@ -23,52 +23,24 @@ module Packet
         end
       end
     end # end of method iattr_accessor
-
-    def cattr_reader(*syms)
-      syms.flatten.each do |sym|
-        next if sym.is_a?(Hash)
-        class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
-
-        def #{sym}
-          @@#{sym}
+    
+    def inheritable_attribute *options_args
+      option_hash = options_args.last
+      args = options_args[0..-2]
+      args.each {|attr| instance_variable_set(:"@#{attr}",option_hash[:default] || nil )}
+      metaclass.instance_eval { attr_accessor *args }
+      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
-        EOS
       end
     end
-
-    def cattr_writer(*syms)
-      options = syms.last.is_a?(Hash) ? syms.pop : {}
-      syms.flatten.each do |sym|
-        class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-            @@#{sym} = obj
-        end
-
-        #{"
-        def #{sym}=(obj)
-          @@#{sym} = obj
-        end
-        " unless options[:instance_writer] == false }
-      EOS
-     end
-   end
-
-   def cattr_accessor(*syms)
-     cattr_reader(*syms)
-     cattr_writer(*syms)
-   end
-   module_function :metaclass,:iattr_accessor, :cattr_writer, :cattr_reader, :cattr_accessor
+   module_function :metaclass,:iattr_accessor,:inheritable_attribute
   end # end of module ClassHelpers
 end
 

data/lib/packet/packet_invalid_worker.rb

@@ -0,0 +1,8 @@
+module Packet
+  class InvalidWorker < RuntimeError
+    attr_accessor :message
+    def initialize message
+      @message = message
+    end
+  end
+end

data/lib/packet/packet_master.rb

@@ -6,7 +6,7 @@ module Packet
     attr_accessor :result_hash
 
     attr_accessor :live_workers
-    after_connection :provide_workers
+    #after_connection :provide_workers
 
     def self.server_logger= (log_file_name)
       @@server_logger = log_file_name
@@ -30,62 +30,34 @@ module Packet
       @result_hash[worker_key.to_sym] = result
     end
 
-    def provide_workers(handler_instance,t_sock)
-      class << handler_instance
-        extend Forwardable
-        attr_accessor :workers,:connection,:reactor, :initialized,:signature
-        include NbioHelper
-        include Connection
-        def ask_worker(*args)
-          worker_name = args.shift
-          data_options = *args
-          worker_name_key = gen_worker_key(worker_name,data_options[:job_key])
-          data_options[:client_signature] = connection.fileno
-          reactor.live_workers[worker_name_key].send_request(data_options)
-        end
-
-        def_delegators(:@reactor, :start_server, :connect, :add_periodic_timer, \
-                         :add_timer, :cancel_timer,:reconnect, :start_worker,:delete_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
+        worker_instance.receive_data(sock_error.data) if worker_instance.respond_to?(:receive_data)
         remove_worker(t_sock)
       end
     end
-    
+
 
     def remove_worker(t_sock)
       @live_workers.delete(t_sock.fileno)
       read_ios.delete(t_sock)
     end
-    
+
     def delete_worker(worker_options = {})
       worker_name = worker_options[:worker]
-      worker_name_key = gen_worker_key(worker_name,worker_options[:job_key])
+      worker_name_key = gen_worker_key(worker_name,worker_options[:worker_key])
       worker_options[:method] = :exit
       @live_workers[worker_name_key].send_request(worker_options)
     end
 
     def load_workers
-      if defined?(WORKER_ROOT)
-        worker_root = WORKER_ROOT
-      else
-        worker_root = "#{PACKET_APP}/worker"
-      end
+      worker_root = defined?(WORKER_ROOT) ? WORKER_ROOT : "#{PACKET_APP}/worker"
+
       t_workers = Dir["#{worker_root}/**/*.rb"]
       return if t_workers.empty?
       t_workers.each do |b_worker|
@@ -99,7 +71,7 @@ module Packet
 
     def start_worker(worker_options = { })
       worker_name = worker_options[:worker].to_s
-      worker_name_key = gen_worker_key(worker_name,worker_options[:job_key])
+      worker_name_key = gen_worker_key(worker_name,worker_options[:worker_key])
       return if @live_workers[worker_name_key]
       worker_options.delete(:worker)
       begin
@@ -107,15 +79,17 @@ module Packet
         worker_klass = Object.const_get(packet_classify(worker_name))
         fork_and_load(worker_klass,worker_options)
       rescue LoadError
-        puts "no such worker #{worker_name}" 
-      rescue MissingSourceFile
-        puts "no such worker #{worker_name}" 
+        puts "no such worker #{worker_name}"
         return
       end
     end
 
-    # method forks given worker file in a new process
-    # method should use job_key if provided in options hash.
+    def enable_nonblock io
+      f = io.fcntl(Fcntl::F_GETFL,0)
+      io.fcntl(Fcntl::F_SETFL,Fcntl::O_NONBLOCK | f)
+    end
+
+    # method should use worker_key if provided in options hash.
     def fork_and_load(worker_klass,worker_options = { })
       t_worker_name = worker_klass.worker_name
       worker_pimp = worker_klass.worker_proxy.to_s
@@ -124,18 +98,20 @@ module Packet
       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,master_read_end].each { |x| x.close }
+      option_dump = Marshal.dump(worker_options)
+      option_dump_length = option_dump.length
+      master_write_end.write(option_dump)
 
-        worker_klass.start_worker(:write_end => worker_write_end,:read_end => worker_read_end,\
-                                  :options => worker_options)
+      if(!(pid = fork))
+        [master_write_end,master_read_end].each { |x| x.close }
+        [worker_read_end,worker_write_end].each { |x| enable_nonblock(x) }
+        exec form_cmd_line(worker_read_end.fileno,worker_write_end.fileno,t_worker_name,option_dump_length)
       end
       Process.detach(pid)
+      [master_read_end,master_write_end].each { |x| enable_nonblock(x) }
 
-      worker_name_key = gen_worker_key(t_worker_name,worker_options[:job_key])
+      worker_name_key = gen_worker_key(t_worker_name,worker_options[:worker_key])
 
       if worker_pimp && !worker_pimp.empty?
         require worker_pimp
@@ -152,5 +128,12 @@ module Packet
       worker_write_end.close
       read_ios << master_read_end
     end # end of fork_and_load method
+
+    def form_cmd_line *args
+      min_string = "packet_worker_runner #{args[0]}:#{args[1]}:#{args[2]}:#{args[3]}"
+      min_string << ":#{WORKER_ROOT}" if defined? WORKER_ROOT
+      min_string << ":#{WORKER_LOAD_ENV}" if defined? WORKER_LOAD_ENV
+      min_string
+    end
   end # end of Reactor class
 end # end of Packet module

data/lib/packet/packet_meta_pimp.rb

@@ -10,7 +10,7 @@ class Packet::MetaPimp < Packet::Pimp
     @worker_status = nil
     @worker_result = nil
     @worker_key = nil
-    @tokenizer = BinParser.new
+    @tokenizer = Packet::BinParser.new
   end
 
   # will be invoked whenever there is a response from the worker
@@ -44,7 +44,7 @@ class Packet::MetaPimp < Packet::Pimp
   end
 
   def process_request(data_options = {})
-    if requested_worker = data_options[:requested_worker]
+    if((requested_worker = data_options[:requested_worker]) && (reactor.live_workers[requested_worker]))
       reactor.live_workers[requested_worker].send_request(data_options)
     end
   end
@@ -59,7 +59,7 @@ class Packet::MetaPimp < Packet::Pimp
       end
     elsif client_signature = data_options[:client_signature]
       begin
-        reactor.connections[client_signature].instance.worker_receive(data_options)
+        reactor.connections[client_signature][:instance].worker_receive(data_options)
       rescue
       end
     end

data/lib/packet/packet_nbio.rb

@@ -5,16 +5,16 @@ module Packet
       return word_parts.map { |x| x.capitalize}.join
     end
 
-    def gen_worker_key(worker_name,job_key = nil)
-      return worker_name if job_key.nil?
-      return "#{worker_name}_#{job_key}".to_sym
+    def gen_worker_key(worker_name,worker_key = nil)
+      return worker_name if worker_key.nil?
+      return "#{worker_name}_#{worker_key}".to_sym
     end
 
     def read_data(t_sock)
       sock_data = []
       begin
-        while(t_data = t_sock.recv_nonblock((16*1024)-1))
-          raise DisconnectError.new(t_sock,sock_data.join) if t_data.empty?
+        while(t_data = t_sock.read_nonblock((16*1024)-1))
+          #raise DisconnectError.new(t_sock,sock_data.join) if t_data.empty?
           sock_data << t_data
         end
       rescue Errno::EAGAIN
@@ -45,22 +45,31 @@ module Packet
         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)
+          outbound_data[index] = nil
         else
           outbound_data[index] = leftover
-          reactor.schedule_write(sock)
+          reactor.schedule_write(sock,self)
           break
         end
       end
+      outbound_data.compact!
       reactor.cancel_write(sock) if outbound_data.empty?
     end
 
+    # returns Marshal dump of the specified object
+    def object_dump p_data
+      object_dump = Marshal.dump(p_data)
+      dump_length = object_dump.length.to_s
+      length_str = dump_length.rjust(9,'0')
+      final_data = length_str + object_dump
+    end
+
     # method dumps the object in a protocol format which can be easily picked by a recursive descent parser
     def dump_object(p_data,p_sock)
       object_dump = Marshal.dump(p_data)
@@ -68,8 +77,8 @@ module Packet
       length_str = dump_length.rjust(9,'0')
       final_data = length_str + object_dump
       outbound_data << final_data
-      begin 
-        write_and_schedule(p_sock) 
+      begin
+        write_and_schedule(p_sock)
       rescue DisconnectError => sock
         close_connection(sock)
       end

data/lib/packet/packet_parser.rb

@@ -1,69 +1,75 @@
-class BinParser
-  def initialize
-    @size = 0
-    @data = []
-    # 0 => reading length
-    # 1 => reading actual data
-    @parser_state = 0
-    @length_string = ""
-    @numeric_length = 0
-  end
+module Packet
+  class BinParser
+    attr_accessor :data,:numeric_length,:length_string,:remaining
+    attr_accessor :parser_state
+    def initialize
+      @size = 0
+      @data = []
+      @remaining = ""
+      # 0 => reading length
+      # 1 => reading actual data
+      @parser_state = 0
+      @length_string = ""
+      @numeric_length = 0
+    end
 
-  def extract new_data, &block
-    extracter_block = block
-    if @parser_state == 0
-      length_to_read =  9 - @length_string.length
-      len_str,remaining = new_data.unpack("a#{length_to_read}a*")
-      if len_str.length < length_to_read
-        @length_string << len_str
-        return
-      else
-        @length_string << len_str
-        @numeric_length = @length_string.to_i
-        @parser_state = 1
-        if remaining.length < @numeric_length
-          @data << remaining
-          @numeric_length = @numeric_length - remaining.length
-        elsif remaining.length == @numeric_length
-          @data << remaining
-          extracter_block.call(@data.join)
-          @data = []
-          @parser_state = 0
-          @length_string = ""
-          @numeric_length = 0
-        else
-          pack_data,remaining = remaining.unpack("a#{@numeric_length}a*")
-          @data << pack_data
-          extracter_block.call(@data.join)
-          @data = []
-          @parser_state = 0
-          @length_string = ""
-          @numeric_length = 0
-          extract(remaining,&extracter_block)
-        end
-      end
-    elsif @parser_state == 1
-      pack_data,remaining = new_data.unpack("a#{@numeric_length}a*")
-      if pack_data.length < @numeric_length
-        @data << pack_data
-        @numeric_length = @numeric_length - pack_data.length
-      elsif pack_data.length == @numeric_length
-        @data << pack_data
-        extracter_block.call(@data.join)
-        @data = []
-        @parser_state = 0
-        @length_string = ""
-        @numeric_length = 0
-      else
-        @data << pack_data
-        extracter_block.call(@data.join)
-        @data = []
-        @parser_state = 0
-        @length_string = ""
-        @numeric_length = 0
-        extract(remaining,&extracter_block)
-      end
+    def reset
+      @data = []
+      @parser_state = 0
+      @length_string = ""
+      @numeric_length = 0
     end
-  end
-end
+
+    def extract new_data
+      remaining = new_data
+
+      loop do
+        if @parser_state == 0
+          length_to_read =  9 - @length_string.length
+          len_str,remaining = remaining.unpack("a#{length_to_read}a*")
+          break if len_str !~ /^\d+$/
+          if len_str.length < length_to_read
+            @length_string << len_str
+            break
+          else
+            @length_string << len_str
+            @numeric_length = @length_string.to_i
+            @parser_state = 1
+            if remaining.length < @numeric_length
+              @data << remaining
+              @numeric_length = @numeric_length - remaining.length
+              break
+            elsif remaining.length == @numeric_length
+              @data << remaining
+              yield(@data.join)
+              reset
+              break
+            else
+              pack_data,remaining = remaining.unpack("a#{@numeric_length}a*")
+              @data << pack_data
+              yield(@data.join)
+              reset
+            end
+          end
+        elsif @parser_state == 1
+          pack_data,remaining = remaining.unpack("a#{@numeric_length}a*")
+          if pack_data.length < @numeric_length
+            @data << pack_data
+            @numeric_length = @numeric_length - pack_data.length
+            break
+          elsif pack_data.length == @numeric_length
+            @data << pack_data
+            yield(@data.join)
+            reset
+            break
+          else
+            @data << pack_data
+            yield(@data.join)
+            reset
+          end
+        end # end of beginning if condition
+      end # end of loop do
+    end # end of extract method
+  end # end of BinParser class
+end # end of packet module
 

data/lib/packet/packet_pimp.rb

@@ -8,7 +8,6 @@ module Packet
     attr_accessor :fd_write_end
     attr_accessor :workers, :reactor,:outbound_data
 
-
     def initialize(lifeline_socket,worker_pid,p_reactor)
       @lifeline = lifeline_socket
       @pid = worker_pid

data/lib/packet/packet_worker.rb

@@ -7,13 +7,13 @@ module Packet
     iattr_accessor :no_auto_load
 
     attr_accessor :worker_started, :worker_options
-    after_connection :provide_workers
 
     # method initializes the eventloop for the worker
     def self.start_worker(messengers = {})
       # @fd_reader = args.shift if args.length > 2
       @msg_writer = messengers[:write_end]
       @msg_reader = messengers[:read_end]
+
       t_instance = new
       t_instance.worker_options = messengers[:options]
       t_instance.worker_init if t_instance.respond_to?(:worker_init)
@@ -21,6 +21,13 @@ module Packet
       t_instance
     end
 
+    # copy the inherited attribute in class thats inheriting this class
+    def self.inherited(subklass)
+      subklass.send(:"connection_callbacks=",connection_callbacks)
+    end
+
+    def self.is_worker?; true; end
+
     def initialize
       super
       @read_ios << msg_reader
@@ -43,8 +50,13 @@ module Packet
 
     # method handles internal requests from internal sockets
     def handle_internal_messages(t_sock)
-      t_data = read_data(t_sock)
-      receive_internal_data(t_data)
+      begin
+        t_data = read_data(t_sock)
+        receive_internal_data(t_data)
+      rescue DisconnectError => sock_error
+        # Means, when there is an error from sockets from which we are reading better just terminate
+        terminate_me()
+      end
     end
 
     def receive_internal_data data
@@ -54,21 +66,6 @@ module Packet
       end
     end
 
-    # FIXME: this method is being duplicated between packet and worker classes, may be its a
-    # good idea to merge them.
-    def provide_workers(handler_instance,connection)
-      class << handler_instance
-        extend Forwardable
-        attr_accessor :worker, :connection, :reactor, :initialized, :signature
-        include NbioHelper
-        include Connection
-        def_delegators :@reactor, :start_server, :connect, :add_periodic_timer, :add_timer, :cancel_timer,:reconnect
-      end
-      handler_instance.connection = connection
-      handler_instance.worker = self
-      handler_instance.reactor = self
-    end
-
     def log log_data
       send_data(:requested_worker => :log_worker,:data => log_data,:type => :request)
     end
@@ -91,3 +88,4 @@ module Packet
   end # end of class#Worker
 end
 
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: packet
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors: 
 - Hemant Kumar
@@ -9,14 +9,14 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-28 00:00:00 +05:30
+date: 2008-07-12 00:00:00 +05:30
 default_executable: 
 dependencies: []
 
 description: Packet, A Pure Ruby library for Event Driven Network Programming.
 email: mail@gnufied.org
-executables: []
-
+executables: 
+- packet_worker_runner
 extensions: []
 
 extra_rdoc_files: 
@@ -28,12 +28,10 @@ files:
 - README
 - Rakefile
 - TODO
-- spec/test_double_keyed_hash.rb
-- spec/spec_helper.rb
-- spec/test_packet_core.rb
 - lib/packet
 - lib/packet/disconnect_error.rb
 - lib/packet/packet_pimp.rb
+- lib/packet/packet_invalid_worker.rb
 - lib/packet/packet_connection.rb
 - lib/packet/packet_guid.rb
 - lib/packet/double_keyed_hash.rb
@@ -50,7 +48,6 @@ files:
 - lib/packet/packet_event.rb
 - lib/packet/packet_nbio.rb
 - lib/packet.rb
-- lib/packet.rbc
 - lib/packet_mongrel.rb
 - examples/concurrent_thread.c
 - examples/sample_server.rb
@@ -59,7 +56,6 @@ files:
 - examples/persistent_print.rb
 - examples/use_stuff.rb
 - examples/extconf.h
-- examples/netbeans.jpg
 - examples/asteroid.c
 - examples/extconf.rb
 has_rdoc: true
@@ -84,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 0.9.5
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Packet, A Pure Ruby library for Event Driven Network Programming.

data/spec/spec_helper.rb

@@ -1,10 +0,0 @@
-PACKET_APP = File.expand_path(File.join(File.dirname(__FILE__) + "/.."))
-["lib"].each { |x| $LOAD_PATH.unshift(EVAL_APP_ROOT + "/#{x}")}
-require "packet" 
-require "rubygems" 
-require "test/spec" 
-require "mocha" 
-
-
-
-

data/spec/test_double_keyed_hash.rb

@@ -1,14 +0,0 @@
-require File.join(File.dirname(__FILE__) + "/spec_helper")
-context "Double Keyed Hash in general" do
-  xspecify "should allow muliple keys while storing the value in hash" do
-  end
-
-  xspecify "should return correct value when either of the keys is used" do
-  end
-
-  xspecify "should return nil if nither of keys match" do
-  end
-
-  xspecify "should allow deletion of value from hash based on either of keys" do
-  end
-end

data/spec/test_packet_core.rb

@@ -1,39 +0,0 @@
-require File.join(File.dirname(__FILE__) + "/spec_helper")
-
-context "Packet Core in general when mixed inside a class" do
-  xspecify "allow the class to act as a reactor" do
-  end
-
-  xspecify "should start a server on specified port" do
-  end
-
-  xspecify "should let clients connect to the server" do
-  end
-
-  xspecify "should be able to connect to external servers" do
-  end
-
-  xspecify "should be able to read data from clients when socket is ready" do
-  end
-
-  xspecify "should be able to write data to clients when socket is ready for write" do
-  end
-
-  xspecify "should invoke receive_data method data is receieved from clients" do
-  end
-
-  xspecify "should invoke post_init when client connects" do
-  end
-
-  xspecify "should invoke unbind when a client disconnects" do
-  end
-
-  xspecify "should invoke connection_completed when connection to external server is connected." do
-  end
-
-  xspecify "should check for ready timers on each iteration" do
-  end
-
-  xspecify "should run proper timer on each iteration." do
-  end
-end