tasks/git.rake tasks/rdoc.rake tests/packet_core_test.rb tests/packet_parser_test.rb tests/spec_helper.rb @@ -252,4 +252,3 @@ end - README @@ -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 @@ -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' @@ -94,9 +74,3 @@ task :yaml_to_spec do }.strip end -namespace :git do - desc "Push changes to central git repo" - task :push do - sh("git push origin master") - end -end Rakefile @@ -12,6 +12,10 @@ class EchoServer end def connection_completed + add_timer(3) { say_hello } + end + def say_hello + send_data("Hello \n") end def post_init bin/echo_server.rb @@ -8,13 +8,12 @@ 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] - require @worker_load_env if @worker_load_env + @worker_read_fd = UNIXSocket.for_fd(cmd_args[0].to_i) @@ -22,7 +21,8 @@ module Packet initial_arg_data = @worker_read_fd.read(initial_arg_data_length) - @worker_options = Marshal.load(initial_arg_data) + 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 @@ -30,12 +30,12 @@ module Packet 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) + 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) + 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 bin/packet_worker_runner @@ -4,26 +4,27 @@ EVAL_APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__) + "/..")) ["extras","bin","worker","lib"].each { |x| $LOAD_PATH.unshift(EVAL_APP_ROOT + "/#{x}")} WORKER_ROOT = EVAL_APP_ROOT + "/worker" -WORKER_LOAD_ENV = EVAL_APP_ROOT + "/extras/foo" +#WORKER_LOAD_ENV = EVAL_APP_ROOT + "/extras/foo" require "packet" #require "buftok" class Foo def receive_data p_data + p p_data # @tokenizer.extract(p_data).each do |t_data| # send_data(p_data) # end - @tokenizer.extract(p_data) do |complete_message| - client_data = Marshal.load(complete_message) - #p "Receieved message in server : #{client_data.join.size}" - #ask_worker(:no_proxy_worker,:data => client_data,:type => :request) - send_object(client_data) - end +# @tokenizer.extract(p_data) do |complete_message| +# client_data = Marshal.load(complete_message) +# #p "Receieved message in server : #{client_data.join.size}" +# #ask_worker(:no_proxy_worker,:data => client_data,:type => :request) +# send_object(client_data) +# end # data_callback = Packet::Callback.new { |data| show_result(data) } # workers[:no_proxy_worker].send_request(:data => p_data,:callback => data_callback) - # ask_worker(:no_proxy_worker,:data => p_data, :type => :request) + ask_worker(:no_proxy_worker,:data => p_data, :type => :request) #p reactor.live_workers # ask_worker(:dynamic_worker,:job_key => :hello_world, :data => p_data, :type => :request) end @@ -56,6 +57,9 @@ class Foo def wow #puts "Wow" end + def unbind + puts "Client disconnected" + end end Packet::Reactor.run do |t_reactor| bin/runner.rb @@ -7,8 +7,10 @@ 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" lib/packet.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 + + lib/packet/double_keyed_hash.rb @@ -12,3 +12,4 @@ module Packet end end end + lib/packet/packet_callback.rb @@ -1,9 +1,14 @@ -# 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 @@ -17,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 + + lib/packet/packet_connection.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 @@ -103,6 +103,7 @@ module Packet connections.delete(t_sock.fileno) t_sock.close rescue + puts "#{$!.message}" end end @@ -113,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 @@ -145,7 +156,7 @@ module Packet 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 @@ -177,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) @@ -211,12 +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) if handler_instance.respond_to?(:receive_data) + handler_instance.receive_data(sock_error.data) unless (sock_error.data).empty? handler_instance.close_connection end end @@ -295,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 - klass = Struct.new(:socket,:instance,:signature,:sock_addr) - connections[t_socket.fileno] = klass.new(t_socket,handler_instance,handler_instance.signature,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 + lib/packet/packet_core.rb @@ -22,4 +22,4 @@ module Packet end end end -# WOW + lib/packet/packet_event.rb @@ -14,3 +14,4 @@ module Packet end end end + lib/packet/packet_guid.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 lib/packet/packet_helper.rb @@ -1,8 +1,8 @@ module Packet class InvalidWorker < RuntimeError - attr_accessor :worker_name - def initialize worker_name - @worker_name = worker_name + attr_accessor :message + def initialize message + @message = message end end end lib/packet/packet_invalid_worker.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,29 +30,6 @@ 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 - def handle_internal_messages(t_sock) sock_fd = t_sock.fileno worker_instance = @live_workers[sock_fd] @@ -73,7 +50,7 @@ module Packet 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 @@ -94,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 @@ -112,8 +89,7 @@ module Packet io.fcntl(Fcntl::F_SETFL,Fcntl::O_NONBLOCK | f) end - - # method should use job_key if provided in options hash. + # 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 @@ -128,19 +104,14 @@ module Packet master_write_end.write(option_dump) if(!(pid = fork)) - # $0 = "ruby #{worker_klass.worker_name}" [master_write_end,master_read_end].each { |x| x.close } - [worker_read_end,worker_write_end].each { |x| enable_nonblock(x) } - -# worker_klass.start_worker(:write_end => worker_write_end,:read_end => worker_read_end,\ -# :options => worker_options) exec form_cmd_line(worker_read_end.fileno,worker_write_end.fileno,t_worker_name,option_dump_length) end - #Process.detach(pid) + 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 lib/packet/packet_master.rb @@ -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 lib/packet/packet_meta_pimp.rb @@ -5,9 +5,9 @@ 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) lib/packet/packet_nbio.rb @@ -1,8 +1,11 @@ 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 @@ -10,62 +13,63 @@ module Packet @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 + def reset + @data = [] + @parser_state = 0 + @length_string = "" + @numeric_length = 0 + 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 - 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) + yield(@data.join) + reset 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 - end - end - end -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 lib/packet/packet_parser.rb @@ -7,7 +7,6 @@ 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 = {}) @@ -22,6 +21,11 @@ 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 @@ -46,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 @@ -57,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 lib/packet/packet_worker.rb @@ -0,0 +1,5 @@ +require File.join(File.dirname(__FILE__),"spec_helper") + +context "For Packet master" do + +end tests/packet_master_test.rb @@ -8,11 +8,12 @@ class NoProxyWorker < Packet::Worker end def receive_data data_obj - puts "calling receieve data" - p data_obj[:data].join.size -# eval_data = eval(data_obj[:data]) -# data_obj[:data] = eval_data -# data_obj[:type] = :response -# send_data(data_obj) +# puts "calling receieve data" +# p data_obj[:data].join.size + eval_data = eval(data_obj[:data]) + data_obj[:data] = eval_data + data_obj[:type] = :response + send_data(data_obj) end end + worker/no_proxy_worker.rb bin/runner.rbc spec/spec_helper.rb spec/test_double_keyed_hash.rb spec/test_packet_core.rb tests/echo_server.rb tests/message_pass.rb tests/runner.rb tests/test_for_next_turn.rb tests/worker_comm.rb d713729fdb82cca4002be36e722955b82a97ed6e 67f8970f906260c8a21aae02479c4c4b45a3825f gnufied gethemant@gmail.com http://github.com/gnufied/packet/commit/3f16f7bcc3cca86d12c11d6bacef245a64ac07e7 3f16f7bcc3cca86d12c11d6bacef245a64ac07e7 2008-07-11T10:51:40-07:00 2008-07-11T10:51:40-07:00 merge changes from fork exec branch c7c34bfef06335d77c1f50836ef3bba6e3790566 gnufied gethemant@gmail.com