packet 0.1.0

data/lib/cpu_worker.rb

@@ -0,0 +1,19 @@
+module Packet
+  class CPUWorker < Packet::Worker
+    @@worker_type = 'cpu'
+    cattr_accessor :worker_type
+    # this is the place where all the worker specific inititlization has to be done
+    def worker_init
+      @worker_started = true
+    end
+
+    def receive_data p_data
+      p p_data
+    end
+
+    def receive_internal_data p_data
+      p p_data
+    end
+
+  end
+end

data/lib/deferrable.rb

@@ -0,0 +1,210 @@
+# $Id: deferrable.rb 534 2007-09-15 23:06:15Z blackhedd $
+#
+# Author:: Francis Cianfrocca (gmail: blackhedd)
+# Homepage::  http://rubyeventmachine.com
+# Date:: 16 Jul 2006
+#
+# See EventMachine and EventMachine::Connection for documentation and
+# usage examples.
+#
+#----------------------------------------------------------------------------
+#
+# Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
+# Gmail: blackhedd
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either: 1) the GNU General Public License
+# as published by the Free Software Foundation; either version 2 of the
+# License, or (at your option) any later version; or 2) Ruby's License.
+#
+# See the file COPYING for complete licensing information.
+#
+#---------------------------------------------------------------------------
+#
+#
+
+# FIXME: Packet doesn't support timers on Deferables yet
+
+require 'forwardable'
+
+module Packet
+
+  module Deferrable
+
+    # Specify a block to be executed if and when the Deferrable object receives
+    # a status of :succeeded. See #set_deferred_status for more information.
+    #
+    # Calling this method on a Deferrable object whose status is not yet known
+    # will cause the callback block to be stored on an internal list.
+    # If you call this method on a Deferrable whose status is :succeeded, the
+    # block will be executed immediately, receiving the parameters given to the
+    # prior #set_deferred_status call.
+    #
+    #--
+    # If there is no status, add a callback to an internal list.
+    # If status is succeeded, execute the callback immediately.
+    # If status is failed, do nothing.
+    #
+    def callback &block
+      return unless block
+      if @deferred_status == :succeeded
+        block.call(*@deferred_args)
+      elsif @deferred_status != :failed
+        @callbacks ||= []
+        @callbacks.unshift block # << block
+      end
+    end
+
+    # Specify a block to be executed if and when the Deferrable object receives
+    # a status of :failed. See #set_deferred_status for more information.
+    #--
+    # If there is no status, add an errback to an internal list.
+    # If status is failed, execute the errback immediately.
+    # If status is succeeded, do nothing.
+    #
+    def errback &block
+      return unless block
+      if @deferred_status == :failed
+        block.call(*@deferred_args)
+      elsif @deferred_status != :succeeded
+        @errbacks ||= []
+        @errbacks.unshift block # << block
+      end
+    end
+
+    # Sets the "disposition" (status) of the Deferrable object. See also the large set of
+    # sugarings for this method.
+    # Note that if you call this method without arguments,
+    # no arguments will be passed to the callback/errback.
+    # If the user has coded these with arguments, then the
+    # user code will throw an argument exception.
+    # Implementors of deferrable classes <b>must</b>
+    # document the arguments they will supply to user callbacks.
+    #
+    # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even
+    # on the INSIDE of a callback. This is very useful when a previously-registered
+    # callback wants to change the parameters that will be passed to subsequently-registered
+    # ones.
+    #
+    # You may give either :succeeded or :failed as the status argument.
+    #
+    # If you pass :succeeded, then all of the blocks passed to the object using the #callback
+    # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
+    # passed to the object using #errback will be discarded.
+    #
+    # If you pass :failed, then all of the blocks passed to the object using the #errback
+    # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
+    # passed to the object using # callback will be discarded.
+    #
+    # If you pass any arguments to #set_deferred_status in addition to the status argument,
+    # they will be passed as arguments to any callbacks or errbacks that are executed.
+    # It's your responsibility to ensure that the argument lists specified in your callbacks and
+    # errbacks match the arguments given in calls to #set_deferred_status, otherwise Ruby will raise
+    # an ArgumentError.
+    #
+    # --
+    # We're shifting callbacks off and discarding them as we execute them.
+    # This is valid because by definition callbacks are executed no more than
+    # once. It also has the magic effect of permitting recursive calls, which
+    # means that a callback can call #set_deferred_status and change the parameters
+    # that will be sent to subsequent callbacks down the chain.
+    #
+    # Changed @callbacks and @errbacks from push/shift to unshift/pop, per suggestion
+    # by Kirk Haines, to work around the memory leak bug that still exists in many Ruby
+    # versions.
+    #
+    # Changed 15Sep07: after processing callbacks or errbacks, CLEAR the other set of
+    # handlers. This gets us a little closer to the behavior of Twisted's "deferred,"
+    # which only allows status to be set once. Prior to making this change, it was possible
+    # to "succeed" a Deferrable (triggering its callbacks), and then immediately "fail" it,
+    # triggering its errbacks! That is clearly undesirable, but it's just as undesirable
+    # to raise an exception is status is set more than once on a Deferrable. The latter
+    # behavior would invalidate the idiom of resetting arguments by setting status from
+    # within a callback or errback, but more seriously it would cause spurious errors
+    # if a Deferrable was timed out and then an attempt was made to succeed it. See the
+    # comments under the new method #timeout.
+    #
+    def set_deferred_status status, *args
+      #cancel_timeout
+      @deferred_status = status
+      @deferred_args = args
+      case @deferred_status
+      when :succeeded
+        if @callbacks
+          while cb = @callbacks.pop
+            cb.call(*@deferred_args)
+          end
+        end
+        @errbacks.clear if @errbacks
+      when :failed
+        if @errbacks
+          while eb = @errbacks.pop
+            eb.call(*@deferred_args)
+          end
+        end
+        @callbacks.clear if @callbacks
+      end
+    end
+
+
+    # Setting a timeout on a Deferrable causes it to go into the failed state after
+    # the Timeout expires (passing no arguments to the object's errbacks).
+    # Setting the status at any time prior to a call to the expiration of the timeout
+    # will cause the timer to be cancelled.
+    #--
+    #
+    #
+    def timeout seconds
+      cancel_timeout
+      me = self
+      @deferred_timeout = EventMachine::Timer.new(seconds) {me.fail}
+    end
+
+
+    # Cancels an outstanding timeout if any. Undoes the action of #timeout.
+    #
+    #
+    def cancel_timeout
+      if @deferred_timeout
+        @deferred_timeout.cancel
+        @deferred_timeout = nil
+      end
+    end
+
+
+    # Equivalent to set_deferred_status(:succeeded, ...)
+    #
+    def set_deferred_success *args
+      set_deferred_status :succeeded, *args
+    end
+
+    # Equivalent to set_deferred_status(:failed, ...)
+    #
+    def set_deferred_failure *args
+      set_deferred_status :failed, *args
+    end
+
+    # And still more sugar
+    #
+    def succeed *args
+      set_deferred_success(*args)
+    end
+
+    # Can't get enough sugar
+    #
+    def fail *args
+      set_deferred_failure(*args)
+    end
+  end
+
+
+  # DefaultDeferrable is an otherwise empty class that includes Deferrable.
+  # This is very useful when you just need to return a Deferrable object
+  # as a way of communicating deferred status to some other part of a program.
+  #
+  class DefaultDeferrable
+    include Deferrable
+  end
+
+end
+

data/lib/disconnect_error.rb

@@ -0,0 +1,8 @@
+module Packet
+  class DisconnectError < RuntimeError
+    attr_accessor :disconnected_socket
+    def initialize(t_sock)
+      @disconnected_socket = t_sock
+    end
+  end
+end

data/lib/double_keyed_hash.rb

@@ -0,0 +1,19 @@
+class DoubleKeyedHash
+  def initialize
+    @keys1 = {}
+    @internal_hash = {}
+  end
+
+  def []=(key1,key2,value)
+    @keys1[key2] = key1
+    @internal_hash[key1] = value
+  end
+
+  def [] key
+    @internal_hash[key] || @internal_hash[@keys1[key]]
+  end
+
+  def each
+    @internal_hash.each { |key,value| yield(key,value)}
+  end
+end

data/lib/event.rb

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

data/lib/io_worker.rb

@@ -0,0 +1,6 @@
+module Packet
+  class IOWorker < Packet::Worker
+    @@worker_type = :io
+    cattr_accessor :worker_type
+  end
+end

data/lib/meta_pimp.rb

@@ -0,0 +1,66 @@
+# Class acts as a pimp for workers, which doesn't have a manually created pimp
+# The idea behind a manually added pimp is to let client handle low level messaging
+# beween workers. A meta pimp, does it for you.
+class Packet::MetaPimp < Packet::Pimp
+  # initializer of pimp
+  attr_accessor :callback_hash
+  attr_accessor :worker_status
+  def pimp_init
+    @callback_hash ||= {}
+    @worker_status = 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)
+      handle_object(t_data)
+    end
+  end
+
+  def handle_object data_options = {}
+    case data_options[:type]
+    when :request
+      process_request(data_options)
+    when :response
+      process_response(data_options)
+    when :status
+      save_worker_status(data_options)
+    end
+  end
+
+  def save_worker_status(data_options = { })
+    @worker_status = data_options[:data]
+  end
+
+  def process_request(data_options = {})
+    if requested_worker = data_options[:requested_worker]
+      reactor.live_workers[requested_worker].send_request(data_options)
+    end
+  end
+
+  def process_response(data_options = {})
+    if callback_signature = data_options[:callback_signature]
+      callback = callback_hash[callback_signature]
+      callback.call(data_options)
+    elsif client_signature = data_options[:client_signature]
+      reactor.connections[client_signature].instance.worker_receive(data_options)
+    end
+  end
+
+  # can be used to send request to correspoding worker
+  def send_request(data_options = { })
+    if callback = data_options[:callback]
+      callback_hash[callback.signature] = callback
+      data_options.delete(:callback)
+      data_options[:callback_signature] = callback.signature
+      send_data(data_options)
+    else
+      send_data(data_options)
+    end
+  end
+end
+

data/lib/nbio.rb

@@ -0,0 +1,81 @@
+module Packet
+  module NbioHelper
+    # nonblocking method of reading data
+    # when method returns nil it probably means that client diconnected
+    def read_data(t_sock)
+      sock_data = ""
+      begin
+        while(sock_data << t_sock.read_nonblock(1023)); end
+      rescue Errno::EAGAIN
+        return sock_data
+      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
+      end
+
+#       loop do
+#         begin
+#           written_length = p_sock.write_nonblock(t_data)
+#         rescue Errno::EAGAIN
+#           break
+#         end
+#         break if written_length >= t_length
+#         t_data = t_data[written_length..-1]
+#         break if t_data.empty?
+#         t_length = t_data.length
+#       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
+      begin
+        p_sock.write_nonblock(t_data)
+      rescue Errno::EAGAIN
+        return
+      end
+    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)
+      dump_length = object_dump.length.to_s
+      length_str = dump_length.rjust(9,'0')
+      final_data = length_str + object_dump
+
+#       total_length = final_data.length
+#       loop do
+#         begin
+#           written_length = p_sock.write_nonblock(final_data)
+#         rescue Errno::EAGAIN
+#           break
+#         end
+#         break if written_length >= total_length
+#         final_data = final_data[written_length..-1]
+#         break if final_data.empty?
+#         total_length = final_data.length
+#       end
+
+      begin
+        p_sock.write_nonblock(final_data)
+      rescue Errno::EAGAIN
+        return
+      end
+    end
+
+  end
+end

data/lib/packet.rb

@@ -0,0 +1,37 @@
+require "socket"
+require "yaml"
+require "forwardable"
+require "attribute_accessors"
+require "buftok"
+require "bin_parser"
+
+require "ostruct"
+require "socket"
+
+require "packet_guid"
+require "ruby_hacks"
+require "double_keyed_hash"
+require "event"
+
+require "periodic_event"
+require "disconnect_error"
+require "callback"
+
+require "nbio"
+require "pimp"
+require "meta_pimp"
+require "core"
+
+require "packet_master"
+require "connection"
+require "worker"
+
+# This file is just a runner of things and hence does basic initialization of thingies required for running
+# the application.
+
+
+PACKET_APP = File.expand_path'../' unless defined?(PACKET_APP)
+
+module Packet
+  VERSION='0.1.0'
+end