packet 0.1.0

data/bin/runner.rb

@@ -0,0 +1,35 @@
+EVAL_APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__) + "/.."))
+["bin","worker","lib"].each { |x| $LOAD_PATH.unshift(EVAL_APP_ROOT + "/#{x}")}
+WORKER_ROOT = EVAL_APP_ROOT + "/worker"
+
+require "packet"
+class Foo
+  def receive_data p_data
+    ask_worker(:no_proxy_worker,:data => p_data, :type => :request)
+  end
+
+  def worker_receive p_data
+    send_data "#{p_data[:data]}\n"
+  end
+
+  def show_result p_data
+    send_data("#{p_data[:response]}\n")
+  end
+
+  def connection_completed
+  end
+
+  def post_init
+  end
+
+  def wow
+    puts "Wow"
+  end
+end
+
+Packet::Reactor.run do |t_reactor|
+  t_reactor.start_server("localhost", 11006,Foo) do |instance|
+    instance.wow
+  end
+end
+

data/lib/attribute_accessors.rb

@@ -0,0 +1,48 @@
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
+  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
+end

data/lib/bin_parser.rb

@@ -0,0 +1,61 @@
+# FIXME: write this stupid parser in C.
+class BinParser
+  def initialize
+    @size = 0
+    @data = []
+    # 0 => reading length
+    # 1 => reading actual data
+    @parser_state = 0
+    @length_string = ""
+    @numeric_length = 0
+  end
+
+  # if you look at it, it could be a suicidal function
+  def extract new_data
+    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
+        else
+          @data << remaining
+          yield(@data.join)
+          @data = []
+          @parser_state = 0
+          @length_string = ""
+          @numeric_length = 0
+        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
+        yield(@data.join)
+        @data = []
+        @parser_state = 0
+        @length_string = ""
+        @numeric_length = 0
+      else
+        @data << pack_data
+        yield(@data.join)
+        @data = []
+        @parser_state = 0
+        @length_string = ""
+        @numeric_length = 0
+        extract(remaining)
+      end
+    end
+  end
+end
+

data/lib/buftok.rb

@@ -0,0 +1,127 @@
+# BufferedTokenizer - Statefully split input data by a specifiable token
+#
+# Authors:: Tony Arcieri, Martin Emde
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Tony Arcieri and Martin Emde
+# 
+# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
+#
+#---------------------------------------------------------------------------
+#
+
+# (C)2006 Tony Arcieri, Martin Emde
+# Distributed under the Ruby license (http://www.ruby-lang.org/en/LICENSE.txt)
+
+# BufferedTokenizer takes a delimiter upon instantiation, or acts line-based
+# by default.  It allows input to be spoon-fed from some outside source which
+# receives arbitrary length datagrams which may-or-may-not contain the token
+# by which entities are delimited.
+
+class BufferedTokenizer
+  # New BufferedTokenizers will operate on lines delimited by "\n" by default
+  # or allow you to specify any delimiter token you so choose, which will then
+  # be used by String#split to tokenize the input data
+  def initialize(delimiter = "\n", size_limit = nil)
+    # Store the specified delimiter
+    @delimiter = delimiter
+
+    # Store the specified size limitation
+    @size_limit = size_limit
+
+    # The input buffer is stored as an array.  This is by far the most efficient
+    # approach given language constraints (in C a linked list would be a more
+    # appropriate data structure).  Segments of input data are stored in a list
+    # which is only joined when a token is reached, substantially reducing the
+    # number of objects required for the operation.
+    @input = []
+
+    # Size of the input buffer
+    @input_size = 0
+  end
+
+  # Extract takes an arbitrary string of input data and returns an array of
+  # tokenized entities, provided there were any available to extract.  This
+  # makes for easy processing of datagrams using a pattern like:
+  #
+  #   tokenizer.extract(data).map { |entity| Decode(entity) }.each do ...
+  def extract(data)
+    # Extract token-delimited entities from the input string with the split command.
+    # There's a bit of craftiness here with the -1 parameter.  Normally split would
+    # behave no differently regardless of if the token lies at the very end of the 
+    # input buffer or not (i.e. a literal edge case)  Specifying -1 forces split to
+    # return "" in this case, meaning that the last entry in the list represents a
+    # new segment of data where the token has not been encountered
+    entities = data.split @delimiter, -1
+
+    # Check to see if the buffer has exceeded capacity, if we're imposing a limit
+    if @size_limit
+      raise 'input buffer full' if @input_size + entities.first.size > @size_limit
+      @input_size += entities.first.size
+    end
+    
+    # Move the first entry in the resulting array into the input buffer.  It represents
+    # the last segment of a token-delimited entity unless it's the only entry in the list.
+    @input << entities.shift
+
+    # If the resulting array from the split is empty, the token was not encountered
+    # (not even at the end of the buffer).  Since we've encountered no token-delimited
+    # entities this go-around, return an empty array.
+    return [] if entities.empty?
+
+    # At this point, we've hit a token, or potentially multiple tokens.  Now we can bring
+    # together all the data we've buffered from earlier calls without hitting a token,
+    # and add it to our list of discovered entities.
+    entities.unshift @input.join
+
+=begin
+	# Note added by FC, 10Jul07. This paragraph contains a regression. It breaks
+	# empty tokens. Think of the empty line that delimits an HTTP header. It will have
+	# two "\n" delimiters in a row, and this code mishandles the resulting empty token.
+	# It someone figures out how to fix the problem, we can re-enable this code branch.
+    # Multi-character token support.
+    # Split any tokens that were incomplete on the last iteration buf complete now.
+    entities.map! do |e|
+      e.split @delimiter, -1
+    end
+    # Flatten the resulting array.  This has the side effect of removing the empty
+    # entry at the end that was produced by passing -1 to split.  Add it again if
+    # necessary.
+    if (entities[-1] == [])
+      entities.flatten! << []
+    else
+      entities.flatten!
+    end
+=end
+
+    # Now that we've hit a token, joined the input buffer and added it to the entities
+    # list, we can go ahead and clear the input buffer.  All of the segments that were
+    # stored before the join can now be garbage collected.
+    @input.clear
+    
+    # The last entity in the list is not token delimited, however, thanks to the -1
+    # passed to split.  It represents the beginning of a new list of as-yet-untokenized  
+    # data, so we add it to the start of the list.
+    @input << entities.pop
+    
+    # Set the new input buffer size, provided we're keeping track
+    @input_size = @input.first.size if @size_limit
+
+    # Now we're left with the list of extracted token-delimited entities we wanted
+    # in the first place.  Hooray!
+    entities
+  end
+  
+  # Flush the contents of the input buffer, i.e. return the input buffer even though
+  # a token has not yet been encountered
+  def flush
+    buffer = @input.join
+    @input.clear
+    buffer
+  end
+
+  def empty?
+    @input.empty?
+  end
+end

data/lib/callback.rb

@@ -0,0 +1,14 @@
+# class implements a simple callback mechanism for invoking callbacks
+module Packet
+  class Callback
+    attr_accessor :signature,:stored_proc
+    def initialize(&block)
+      @signature = Guid.hexdigest
+      @stored_proc = block
+    end
+
+    def invoke(*args)
+      @stored_proc.call(*args)
+    end
+  end
+end

data/lib/connection.rb

@@ -0,0 +1,33 @@
+# FIMXE: following class must modify the fd_watchlist thats being monitored by
+# 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
+
+    end
+
+    # method gets called just at the beginning of initializing things.
+    def post_init
+
+    end
+
+    def send_data
+
+    end
+
+    def ask_worker
+
+    end
+
+    def receive_data
+
+    end
+  end # end of class Connection
+end # end of module Packet

data/lib/core.rb

@@ -0,0 +1,241 @@
+# FIXME: timer implementation can be optimized
+module Packet
+  module Core
+    def self.included(base_klass)
+      base_klass.extend(ClassMethods)
+      base_klass.instance_eval do
+        # iattr_accessor :connection_callbacks
+        @@connection_callbacks ||= {}
+        cattr_accessor :connection_callbacks
+        attr_accessor :read_ios, :write_ios, :listen_sockets
+        attr_accessor :connection_completion_awaited
+        attr_accessor :connections
+        include CommonMethods
+      end
+    end
+
+    module ClassMethods
+      def after_connection p_method
+        connection_callbacks[:after_connection] ||= []
+        connection_callbacks[:after_connection] << p_method
+      end
+
+      def after_unbind p_method
+        connection_callbacks[:after_unbind] ||= []
+        connection_callbacks[:after_unbind] << p_method
+      end
+
+      def before_unbind p_method
+        connection_callbacks[:before_unbind] ||= []
+        connection_callbacks[:before_unbind] << p_method
+      end
+    end # end of module#ClassMethods
+
+    module CommonMethods
+      include NbioHelper
+      # method
+      def connect(ip,port,t_module,&block)
+        t_socket = Socket.new(Socket::AF_INET,Socket::SOCK_STREAM,0)
+        t_sock_addr = Socket.sockaddr_in(port,ip)
+        t_socket.setsockopt(Socket::IPPROTO_TCP,Socket::TCP_NODELAY,1)
+
+        connection_completion_awaited[t_socket.fileno] =
+          { :sock_addr => t_sock_addr, :module => t_module,:block => block }
+        begin
+          t_socket.connect_nonblock(t_sock_addr)
+          immediate_complete(t_socket,t_sock_addr,t_module,&block)
+        rescue Errno::EINPROGRESS
+          write_ios << t_socket
+        end
+      end
+
+      def reconnect(server,port,handler)
+        raise "invalid handler" unless handler.respond_to?(:connection_completed)
+        return handler if connections.keys.include?(handler.connection.fileno)
+        connect(server,port,handler)
+      end
+
+      def immediate_complete(t_socket,sock_addr,t_module,&block)
+        read_ios << t_socket
+        write_ios.delete(t_socket)
+        decorate_handler(t_socket,true,sock_addr,t_module,&block)
+        connection_completion_awaited.delete(t_socket.fileno)
+      end
+
+      def accept_connection(sock_opts)
+        sock_io = sock_opts[:socket]
+
+        begin
+          client_socket,client_sockaddr = sock_io.accept_nonblock
+        rescue Errno::EAGAIN, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR
+          puts "not ready yet"
+          return
+        end
+        read_ios << client_socket
+        decorate_handler(client_socket,true,client_sockaddr,sock_opts[:module],&sock_opts[:block])
+      end
+
+      def complete_connection(t_sock,sock_opts)
+        actually_connected = true
+        begin
+          t_sock.connect_nonblock(sock_opts[:sock_addr])
+        rescue Errno::EISCONN
+          puts "Socket already connected"
+        rescue Errno::ECONNREFUSED
+          actually_connected = false
+        end
+
+        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])
+        connection_completion_awaited.delete(t_sock.fileno)
+      end
+
+      # method removes the connection and closes the socket
+      def remove_connection(t_sock)
+        @read_ios.delete(t_sock)
+        @write_ios.delete(t_sock)
+        connections.delete(t_sock.fileno)
+        t_sock.close
+      end
+
+      def socket_really_connected?(t_sock)
+        begin
+          t_data = read_data(t_sock)
+          return true
+        rescue DisconnectError
+          return false
+        end
+      end
+
+      # 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)
+        listen_sockets[t_socket.fileno] = { :socket => t_socket,:block => block,:module => t_module }
+        @read_ios << t_socket
+      end
+
+      # method starts event loop in the process
+      def start_reactor
+        Signal.trap("TERM") { terminate_me }
+        Signal.trap("INT") { shutdown }
+        loop do
+          check_for_timer_events
+          ready_fds = select(@read_ios,@write_ios,nil,0.005)
+          next if ready_fds.blank?
+          ready_fds = ready_fds.flatten.compact
+          ready_fds.each do |t_sock|
+            if t_sock.is_a? UNIXSocket
+              handle_internal_messages(t_sock)
+            else
+              handle_external_messages(t_sock)
+            end
+          end
+        end
+      end
+
+      def terminate_me
+        exit
+      end
+
+      def shutdown
+        exit
+      end
+
+      def handle_internal_messages(t_sock)
+        raise "Method should be implemented by concerned classes"
+      end
+
+      def handle_external_messages(t_sock)
+        sock_fd = t_sock.fileno
+        if sock_opts = listen_sockets[sock_fd]
+          accept_connection(sock_opts)
+        elsif extern_opts = connection_completion_awaited[sock_fd]
+          complete_connection(t_sock,extern_opts)
+        else
+          read_external_socket(t_sock)
+        end
+      end
+
+      def read_external_socket(t_sock)
+        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)
+        rescue DisconnectError => sock_error
+          handler_instance.unbind if handler_instance.respond_to?(:unbind)
+          connections.delete(t_sock.fileno)
+          read_ios.delete(t_sock)
+        end
+      end
+
+      def add_periodic_timer(interval,&block)
+        t_timer = PeriodicEvent.new(interval,&block)
+        @timer_hash[t_timer.timer_signature] = t_timer
+        return t_timer
+      end
+
+      def add_timer(elapsed_time,&block)
+        t_timer = Event.new(elapsed_time,&block)
+        @timer_hash[t_timer.timer_signature] = t_timer
+        return t_timer
+      end
+
+      def cancel_timer(t_timer)
+        @timer_hash.delete(t_timer.timer_signature)
+      end
+
+      def initialize
+        @read_ios ||= []
+        @write_ios ||= []
+        @connection_completion_awaited ||= {}
+        @connections ||= {}
+        @listen_sockets ||= {}
+
+        @timer_hash ||= {}
+      end
+
+      def check_for_timer_events
+        @timer_hash.each do |key,timer|
+          if timer.run_now?
+            timer.run
+            @timer_hash.delete(key) if !timer.respond_to?(:interval)
+          end
+        end
+      end
+
+      def initialize_handler(p_module)
+        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
+          else
+            Class.new(Connection) { p_module and 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)}
+        handler_instance.invoke_init unless handler_instance.initialized
+        unless actually_connected
+          handler_instance.unbind if handler_instance.respond_to?(:unbind)
+          return
+        end
+        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)
+        block.call(handler_instance) if block
+        handler_instance.connection_completed if handler_instance.respond_to?(:connection_completed)
+      end
+
+    end # end of module#CommonMethods
+  end #end of module#Core
+end #end of module#Packet