packet 0.1.0 → 0.1.1

data/examples/extconf.h

@@ -0,0 +1,4 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#define HAVE_SYS_EPOLL_H 1
+#endif

data/examples/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+
+unless have_header("sys/epoll.h") || have_header("sys/event.h")
+  message "epoll or kqueue required.\n"
+  exit 1
+end
+
+create_header
+create_makefile 'asteroid'
+

data/examples/persistent_print.rb

@@ -0,0 +1,24 @@
+require "rubygems"
+require "eventmachine"
+
+module Client
+  def receive_data data
+    @tokenizer.extract(data).each do |b_data|
+      client_data = b_data
+      p "Client has sent #{client_data}"
+    end
+  end
+
+  def start_push_on_client
+    send_data("Hello World : #{Time.now}\n")
+  end
+
+  def post_init
+    @tokenizer = BufferedTokenizer.new
+    EM::add_periodic_timer(1) { start_push_on_client }
+  end
+end
+
+EM.run do
+  EM.start_server("localhost",11009,Client)
+end

data/examples/sample_server.rb

@@ -0,0 +1,19 @@
+require "asteroid"
+
+module Server
+  def receive_data data
+
+  end
+
+  def post_init
+    puts "A new client connected"
+  end
+
+  def unbind
+    puts "client disconnected"
+  end
+end
+
+Asteroid::run("0.0.0.0", 11007, Server) do
+  puts "Someone connected"
+end

data/examples/use_stuff.rb

@@ -0,0 +1,3 @@
+require "concurrent_thread"
+a = ConcurrentThread.new
+a.defer

data/lib/bin_parser.rb

@@ -1,4 +1,3 @@
-# FIXME: write this stupid parser in C.
 class BinParser
   def initialize
     @size = 0
@@ -10,8 +9,8 @@ class BinParser
     @numeric_length = 0
   end
 
-  # if you look at it, it could be a suicidal function
-  def extract new_data
+  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*")
@@ -25,13 +24,22 @@ class BinParser
         if remaining.length < @numeric_length
           @data << remaining
           @numeric_length = @numeric_length - remaining.length
-        else
+        elsif remaining.length == @numeric_length
           @data << remaining
-          yield(@data.join)
+          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
@@ -41,19 +49,19 @@ class BinParser
         @numeric_length = @numeric_length - pack_data.length
       elsif pack_data.length == @numeric_length
         @data << pack_data
-        yield(@data.join)
+        extracter_block.call(@data.join)
         @data = []
         @parser_state = 0
         @length_string = ""
         @numeric_length = 0
       else
         @data << pack_data
-        yield(@data.join)
+        extracter_block.call(@data.join)
         @data = []
         @parser_state = 0
         @length_string = ""
         @numeric_length = 0
-        extract(remaining)
+        extract(remaining,&extracter_block)
       end
     end
   end

data/lib/class_helpers.rb

@@ -0,0 +1,74 @@
+module Packet
+  module ClassHelpers
+    def metaclass; class << self; self; end; end
+
+    def 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 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}
+        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
+  end # end of module ClassHelpers
+end
+

data/lib/connection.rb

@@ -2,32 +2,32 @@
 # main eventloop.
 
 module Packet
-  class Connection
-    # method gets called when connection to external server is completed
-    def connection_completed
-
-    end
-
-    # method gets called when external client is disconnected
-    def unbind
-
+  module Connection
+    def send_data p_data
+      begin
+        write_data(p_data,connection)
+      rescue DisconnectError => sock_error
+        close_connection
+      end
     end
 
-    # method gets called just at the beginning of initializing things.
-    def post_init
-
+    def invoke_init
+      @initialized = true
+      post_init if respond_to?(:post_init)
     end
 
-    def send_data
-
+    def close_connection
+      unbind if respond_to?(:unbind)
+      reactor.remove_connection(connection)
     end
 
-    def ask_worker
-
+    def close_connection_after_writing
+      connection.flush
+      close_connection
     end
 
-    def receive_data
-
+    def send_object p_object
+      dump_object(p_object,connection)
     end
   end # end of class Connection
 end # end of module Packet

data/lib/core.rb

@@ -4,17 +4,19 @@ module Packet
     def self.included(base_klass)
       base_klass.extend(ClassMethods)
       base_klass.instance_eval do
-        # iattr_accessor :connection_callbacks
         @@connection_callbacks ||= {}
+
+        iattr_accessor :thread_pool_size
         cattr_accessor :connection_callbacks
         attr_accessor :read_ios, :write_ios, :listen_sockets
         attr_accessor :connection_completion_awaited
-        attr_accessor :connections
+        attr_accessor :connections, :thread_pool, :windows_flag
         include CommonMethods
       end
     end
 
     module ClassMethods
+      include Packet::ClassHelpers
       def after_connection p_method
         connection_callbacks[:after_connection] ||= []
         connection_callbacks[:after_connection] << p_method
@@ -64,9 +66,9 @@ module Packet
 
       def accept_connection(sock_opts)
         sock_io = sock_opts[:socket]
-
         begin
           client_socket,client_sockaddr = sock_io.accept_nonblock
+          client_socket.setsockopt(Socket::IPPROTO_TCP,Socket::TCP_NODELAY,1)
         rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
           puts "not ready yet"
           return
@@ -87,7 +89,8 @@ module Packet
 
         read_ios << t_sock if actually_connected
         write_ios.delete(t_sock)
-        decorate_handler(t_sock,actually_connected,sock_opts[:sock_addr],sock_opts[:module],&sock_opts[:block])
+        decorate_handler(t_sock,actually_connected,sock_opts[:sock_addr],\
+                           sock_opts[:module],&sock_opts[:block])
         connection_completion_awaited.delete(t_sock.fileno)
       end
 
@@ -110,12 +113,9 @@ module Packet
 
       # method opens a socket for listening
       def start_server(ip,port,t_module,&block)
-        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)
+        BasicSocket.do_not_reverse_lookup = true
+        t_socket = TCPServer.new(ip,port.to_i)
+        # 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
       end
@@ -126,11 +126,15 @@ module Packet
         Signal.trap("INT") { shutdown }
         loop do
           check_for_timer_events
+          user_thread_window #=> let user level threads run for a while
           ready_fds = select(@read_ios,@write_ios,nil,0.005)
-          next if ready_fds.blank?
+          #next if ready_fds.blank?
+
+          next if !ready_fds or ready_fds.empty?
+
           ready_fds = ready_fds.flatten.compact
           ready_fds.each do |t_sock|
-            if t_sock.is_a? UNIXSocket
+            if(unix? && t_sock.is_a?(UNIXSocket))
               handle_internal_messages(t_sock)
             else
               handle_external_messages(t_sock)
@@ -139,11 +143,18 @@ module Packet
         end
       end
 
+      def user_thread_window
+        # run_user_threads if respond_to?(:run_user_threads)
+        @thread_pool.exclusive_run
+      end
+
       def terminate_me
+        # FIXME: close the open sockets
         exit
       end
 
       def shutdown
+        # FIXME: close the open sockets
         exit
       end
 
@@ -182,6 +193,7 @@ module Packet
 
       def add_timer(elapsed_time,&block)
         t_timer = Event.new(elapsed_time,&block)
+        # @timer_hash.store(timer)
         @timer_hash[t_timer.timer_signature] = t_timer
         return t_timer
       end
@@ -197,11 +209,24 @@ module Packet
         @connections ||= {}
         @listen_sockets ||= {}
 
+        # @timer_hash = Packet::TimerStore
         @timer_hash ||= {}
+        @thread_pool = ThreadPool.new(thread_pool_size || 20)
+        @windows_flag = windows?
+      end
+
+      def windows?
+        return true if RUBY_PLATFORM =~ /win32/i
+        return false
+      end
+
+      def unix?
+        !@windows_flag
       end
 
       def check_for_timer_events
         @timer_hash.each do |key,timer|
+          @timer_hash.delete(key) if timer.cancel_flag
           if timer.run_now?
             timer.run
             @timer_hash.delete(key) if !timer.respond_to?(:interval)
@@ -231,7 +256,7 @@ module Packet
         t_signature = Guid.hexdigest
         handler_instance.signature = t_signature
         connections[t_socket.fileno] =
-          OpenStruct.new( :socket => t_socket, :instance => handler_instance, :signature => t_signature,:sock_addr => sock_addr)
+          OpenStruct.new(:socket => t_socket, :instance => handler_instance, :signature => t_signature,:sock_addr => sock_addr)
         block.call(handler_instance) if block
         handler_instance.connection_completed if handler_instance.respond_to?(:connection_completed)
       end

data/lib/double_keyed_hash.rb

@@ -1,4 +1,5 @@
 class DoubleKeyedHash
+  attr_accessor :internal_hash
   def initialize
     @keys1 = {}
     @internal_hash = {}
@@ -13,6 +14,11 @@ class DoubleKeyedHash
     @internal_hash[key] || @internal_hash[@keys1[key]]
   end
 
+  def delete(key)
+    @keys1.delete(key)
+    @internal_hash.delete(key)
+  end
+
   def each
     @internal_hash.each { |key,value| yield(key,value)}
   end

data/lib/meta_pimp.rb

@@ -4,16 +4,16 @@
 class Packet::MetaPimp < Packet::Pimp
   # initializer of pimp
   attr_accessor :callback_hash
-  attr_accessor :worker_status
+  attr_accessor :worker_status, :worker_key
   def pimp_init
     @callback_hash ||= {}
     @worker_status = nil
+    @worker_result = nil
+    @worker_key = nil
     @tokenizer = BinParser.new
   end
 
   # will be invoked whenever there is a response from the worker
-  # Possible bug with reading large responses.
-  # response would be binary but base64 encoded and must be decoded and then loaded
   def receive_data p_data
     @tokenizer.extract(p_data) do |b_data|
       t_data = Marshal.load(b_data)
@@ -29,11 +29,18 @@ class Packet::MetaPimp < Packet::Pimp
       process_response(data_options)
     when :status
       save_worker_status(data_options)
+    when :result
+      save_worker_result(data_options)
     end
   end
 
+  def save_worker_result(data_options = { })
+    @worker_result = data_options[:data]
+  end
+
   def save_worker_status(data_options = { })
-    @worker_status = data_options[:data]
+    # @worker_status = data_options[:data]
+    reactor.update_result(worker_key,data_options[:data])
   end
 
   def process_request(data_options = {})
@@ -45,9 +52,16 @@ class Packet::MetaPimp < Packet::Pimp
   def process_response(data_options = {})
     if callback_signature = data_options[:callback_signature]
       callback = callback_hash[callback_signature]
-      callback.call(data_options)
+      # there coule be bug when you are trying to send the data back to the client
+      begin
+        callback.invoke(data_options)
+      rescue
+      end
     elsif client_signature = data_options[:client_signature]
-      reactor.connections[client_signature].instance.worker_receive(data_options)
+      begin
+        reactor.connections[client_signature].instance.worker_receive(data_options)
+      rescue
+      end
     end
   end