networking 0.0.9 → 1.0.0

data/lib/networking.rb

@@ -1,7 +1,4 @@
 require 'networking/tcp'
 
-module BBFS
-  module Networking
-
-  end
+module Networking
 end

data/lib/networking/tcp.rb

@@ -1,217 +1,216 @@
 require 'log'
 require 'socket'
 
-module BBFS
-  module Networking
-
-    Params.integer('client_retry_delay', 60, 'Number of seconds before trying to reconnect.')
-
-    # TODO(kolman): To get robustness, just use try catch + return 0 bytes on write +
-    # return false on status on read.
-    def Networking.write_to_stream(stream, obj)
-      Log.debug3('Writing to stream.')
-      marshal_data = Marshal.dump(obj)
-      Log.debug2("Writing data size: #{marshal_data.length}")
-      data_size = [marshal_data.length].pack("l")
-      if data_size.nil? || marshal_data.nil?
-        Log.debug3 'Send data size is nil!'
-      end
+module Networking
+
+  Params.integer('client_retry_delay', 60, 'Number of seconds before trying to reconnect.')
+
+  # TODO(kolman): To get robustness, just use try catch + return 0 bytes on write +
+  # return false on status on read.
+  def Networking.write_to_stream(stream, obj)
+    Log.debug3('Writing to stream.')
+    marshal_data = Marshal.dump(obj)
+    Log.debug2("Writing data size: #{marshal_data.length}")
+    data_size = [marshal_data.length].pack("l")
+    if data_size.nil? || marshal_data.nil?
+      Log.debug3 'Send data size is nil!'
+    end
+    begin
+      bytes_written = stream.write data_size
+      bytes_written += stream.write marshal_data
+      return bytes_written
+    rescue Exception => e
+      Log.warning("Could not write tcp/ip stream, #{e.to_s}")
       begin
-        bytes_written = stream.write data_size
-        bytes_written += stream.write marshal_data
-        return bytes_written
-      rescue Exception => e
-        Log.warning("Could not write tcp/ip stream, #{e.to_s}")
-        begin
-          stream.close()
-        rescue IOError => e
-          Log.warning("Could not close stream, #{e.to_s}.")
-        end
-        return 0
+        stream.close()
+      rescue IOError => e
+        Log.warning("Could not close stream, #{e.to_s}.")
       end
+      return 0
     end
+  end
 
-    # Returns pair [status(true/false), obj]
-    def Networking.read_from_stream(stream)
-      Log.debug3('Read from stream.')
+  # Returns pair [status(true/false), obj]
+  def Networking.read_from_stream(stream)
+    Log.debug3('Read from stream.')
+    begin
+      return [false, nil] unless size_of_data = stream.read(4)
+      size_of_data = size_of_data.unpack("l")[0]
+      Log.debug2("Reading data size:#{size_of_data}")
+      data = stream.read(size_of_data)
+    rescue Exception => e
+      Log.warning("Could not read tcp/ip stream, #{e.to_s}.")
       begin
-        return [false, nil] unless size_of_data = stream.read(4)
-        size_of_data = size_of_data.unpack("l")[0]
-        Log.debug2("Reading data size:#{size_of_data}")
-        data = stream.read(size_of_data)
-      rescue Exception => e
-        Log.warning("Could not read tcp/ip stream, #{e.to_s}.")
-        begin
-          stream.close()
-        rescue IOError => e
-          Log.warning("Could not close stream, #{e.to_s}.")
-        end
-        return [false, nil]
+        stream.close()
+      rescue IOError => e
+        Log.warning("Could not close stream, #{e.to_s}.")
       end
-
-      unmarshalled_data = Marshal.load(data)
-      Log.debug3('Read good.')
-      return [true, unmarshalled_data]
+      return [false, nil]
     end
 
-    # Limit on number of concurrent connections?
-    # The TCP server is not responsible for reconnection.
-    class TCPServer
-      attr_reader :tcp_thread
-
-      def initialize(port, obj_clb, new_clb=nil, closed_clb=nil, max_parallel=1)
-        @port = port
-        @obj_clb = obj_clb
-        @new_clb = new_clb
-        @closed_clb = closed_clb
-        # Max parallel connections is not implemented yet.
-        @max_parallel = max_parallel
-        @sockets = {}
-        @tcp_thread = run_server
-        @tcp_thread.abort_on_exception = true
-      end
+    unmarshalled_data = Marshal.load(data)
+    Log.debug3('Read good.')
+    return [true, unmarshalled_data]
+  end
 
-      def send_obj(obj, addr_info=nil)
-        Log.debug3("addr_info=#{addr_info}")
-        unless addr_info.nil?
-          if @sockets.key?(addr_info)
-            Networking.write_to_stream(@sockets[addr_info], obj)
-          else
-            Log.warning("Could not find client socket: #{addr_info}")
-            return 0
-          end
+  # Limit on number of concurrent connections?
+  # The TCP server is not responsible for reconnection.
+  class TCPServer
+    attr_reader :tcp_thread
+
+    def initialize(port, obj_clb, new_clb=nil, closed_clb=nil, max_parallel=1)
+      @port = port
+      @obj_clb = obj_clb
+      @new_clb = new_clb
+      @closed_clb = closed_clb
+      # Max parallel connections is not implemented yet.
+      @max_parallel = max_parallel
+      @sockets = {}
+      @tcp_thread = run_server
+      @tcp_thread.abort_on_exception = true
+    end
+
+    def send_obj(obj, addr_info=nil)
+      Log.debug3("addr_info=#{addr_info}")
+      unless addr_info.nil?
+        if @sockets.key?(addr_info)
+          Networking.write_to_stream(@sockets[addr_info], obj)
         else
-          out = {}
-          @sockets.each { |key, sock| out[key] = Networking.write_to_stream(sock, obj) }
-          return out
+          Log.warning("Could not find client socket: #{addr_info}")
+          return 0
         end
+      else
+        out = {}
+        @sockets.each { |key, sock| out[key] = Networking.write_to_stream(sock, obj) }
+        return out
       end
+    end
 
-      private
-      # Creates new thread/pool
-      def run_server
-        Log.debug3('run_server')
-        return Thread.new do
-          Log.debug3('run_server2')
-          loop {
-            begin
-              Socket.tcp_server_loop(@port) do |sock, addr_info|
-                Log.debug3("----- #{@port} -----")
-                Log.debug3("tcp_server_loop... #{sock} #{addr_info.inspect}")
-                @sockets[addr_info] = sock
-                @new_clb.call(addr_info) if @new_clb != nil
-                loop do
-                  # Blocking read.
-                  Log.debug3('read_from_stream')
-                  stream_ok, obj = Networking.read_from_stream(sock)
-                  Log.debug3("Server returned from read: #{stream_ok}")
-                  @obj_clb.call(addr_info, obj) if @obj_clb != nil && stream_ok
-                  break if !stream_ok
-                end
-                Log.warning("Connection broken, #{addr_info.inspect}")
-                begin
-                  @sockets[addr_info].close() unless @sockets[addr_info].nil?
-                rescue IOError => e
-                  Log.warning("Could not close socket, #{e.to_s}.")
-                end
-                @sockets.delete(addr_info)
-                @closed_clb.call(addr_info) if @closed_clb != nil
+    private
+    # Creates new thread/pool
+    def run_server
+      Log.debug3('run_server')
+      return Thread.new do
+        Log.debug3('run_server2')
+        loop {
+          begin
+            Socket.tcp_server_loop(@port) do |sock, addr_info|
+              Log.debug3("----- #{@port} -----")
+              Log.debug3("tcp_server_loop... #{sock} #{addr_info.inspect}")
+              @sockets[addr_info] = sock
+              @new_clb.call(addr_info) if @new_clb != nil
+              loop do
+                # Blocking read.
+                Log.debug3('read_from_stream')
+                stream_ok, obj = Networking.read_from_stream(sock)
+                Log.debug3("Server returned from read: #{stream_ok}")
+                @obj_clb.call(addr_info, obj) if @obj_clb != nil && stream_ok
+                break if !stream_ok
+              end
+              Log.warning("Connection broken, #{addr_info.inspect}")
+              begin
+                @sockets[addr_info].close() unless @sockets[addr_info].nil?
+              rescue IOError => e
+                Log.warning("Could not close socket, #{e.to_s}.")
               end
+              @sockets.delete(addr_info)
+              @closed_clb.call(addr_info) if @closed_clb != nil
+            end
             # !!! note this break is needed for tests only !!!! server loop should never end.
             # and if it ends, it will fail, and rescue will work.
             break
-            rescue IOError => e
-              Log.info("Connection broken during tcp_server_loop. Restarting server loop " \
+          rescue IOError => e
+            Log.info("Connection broken during tcp_server_loop. Restarting server loop " \
                        "port:#{port}.")
-            end
-          }
-        end
-      end
-    end  # TCPServer
-
-    class TCPClient
-      attr_reader :tcp_thread
-
-      def initialize(host, port, obj_clb=nil, reconnected_clb=nil)
-        @host = host
-        @port = port
-        @tcp_socket = nil
-        @obj_clb = obj_clb
-        @reconnected_clb = reconnected_clb
-        Log.debug1('TCPClient init.')
-        Log.debug1("TCPClient init...#{@obj_clb}...")
-        if @obj_clb != nil
-          @tcp_thread = start_reading
-          @tcp_thread.abort_on_exception = true
-        end
-        # Variable to signal when remote server is ready.
-        @remote_server_available = ConditionVariable.new
-        @remote_server_available_mutex = Mutex.new
-        open_socket unless socket_good?
+          end
+        }
       end
+    end
+  end  # TCPServer
 
-      def send_obj(obj)
-        Log.debug1('send_obj')
-        open_socket unless socket_good?
-        Log.debug1('after open')
-        if !socket_good?
-          Log.warning('Socket not opened for writing, skipping send.')
-          return false
-        end
-        Log.debug1('writing...')
-        #Log.debug3("socket port: #{@tcp_socket.peeraddr}")
-        bytes_written = Networking.write_to_stream(@tcp_socket, obj)
-        return bytes_written
+  class TCPClient
+    attr_reader :tcp_thread
+
+    def initialize(host, port, obj_clb=nil, reconnected_clb=nil)
+      @host = host
+      @port = port
+      @tcp_socket = nil
+      @obj_clb = obj_clb
+      @reconnected_clb = reconnected_clb
+      Log.debug1('TCPClient init.')
+      Log.debug1("TCPClient init...#{@obj_clb}...")
+      if @obj_clb != nil
+        @tcp_thread = start_reading
+        @tcp_thread.abort_on_exception = true
       end
+      # Variable to signal when remote server is ready.
+      @remote_server_available = ConditionVariable.new
+      @remote_server_available_mutex = Mutex.new
+      open_socket unless socket_good?
+    end
 
-      # This function may be executed only from one thread!!! or in synchronized manner.
-      # private
-      def open_socket
-        Log.debug1("Connecting to content server #{@host}:#{@port}.")
-        begin
-          @tcp_socket = TCPSocket.new(@host, @port)
-        rescue Errno::ECONNREFUSED
-          Log.warning('Connection refused')
-        end
-        Log.debug1("Reconnect clb: '#{@reconnected_clb.nil? ? 'nil' : @reconnected_clb}'")
-        if socket_good?
-          @remote_server_available_mutex.synchronize {
-            @remote_server_available.signal
-          }
-          @reconnected_clb.call if @reconnected_clb != nil && socket_good?
-        end
+    def send_obj(obj)
+      Log.debug1('send_obj')
+      open_socket unless socket_good?
+      Log.debug1('after open')
+      if !socket_good?
+        Log.warning('Socket not opened for writing, skipping send.')
+        return false
       end
+      Log.debug1('writing...')
+      #Log.debug3("socket port: #{@tcp_socket.peeraddr}")
+      bytes_written = Networking.write_to_stream(@tcp_socket, obj)
+      return bytes_written
+    end
 
-      private
-      def socket_good?
-        Log.debug1 "socket_good? #{@tcp_socket != nil && !@tcp_socket.closed?}"
-        return @tcp_socket != nil && !@tcp_socket.closed?
+    # This function may be executed only from one thread!!! or in synchronized manner.
+    # private
+    def open_socket
+      Log.debug1("Connecting to content server #{@host}:#{@port}.")
+      begin
+        @tcp_socket = TCPSocket.new(@host, @port)
+      rescue Errno::ECONNREFUSED
+        Log.warning('Connection refused')
+      end
+      Log.debug1("Reconnect clb: '#{@reconnected_clb.nil? ? 'nil' : @reconnected_clb}'")
+      if socket_good?
+        @remote_server_available_mutex.synchronize {
+          @remote_server_available.signal
+        }
+        @reconnected_clb.call if @reconnected_clb != nil && socket_good?
       end
+    end
+
+    private
+    def socket_good?
+      Log.debug1 "socket_good? #{@tcp_socket != nil && !@tcp_socket.closed?}"
+      return @tcp_socket != nil && !@tcp_socket.closed?
+    end
 
-      private
-      def start_reading
-        Log.debug1('start_reading (TCPClient).')
-        return Thread.new do
-          loop do
-            Log.debug3('Start blocking read (TCPClient).')
-            # Blocking read.
-            if !socket_good?
-              Log.warning("Socket not good, waiting for reconnection with " \
+    private
+    def start_reading
+      Log.debug1('start_reading (TCPClient).')
+      return Thread.new do
+        loop do
+          Log.debug3('Start blocking read (TCPClient).')
+          # Blocking read.
+          if !socket_good?
+            Log.warning("Socket not good, waiting for reconnection with " \
                           "#{Params['client_retry_delay']} seconds timeout.")
-              @remote_server_available_mutex.synchronize {
-                @remote_server_available.wait(@remote_server_available_mutex,
-                                              Params['client_retry_delay'])
-              }
-            else
-              read_ok, obj = Networking.read_from_stream(@tcp_socket)
-              Log.debug3("Client returned from read: #{read_ok}")
-              # Handle case when socket is closed in middle.
-              # In that case we should not call obj_clb.
-              @obj_clb.call(obj) if (read_ok && @obj_clb != nil)
-            end
+            @remote_server_available_mutex.synchronize {
+              @remote_server_available.wait(@remote_server_available_mutex,
+                                            Params['client_retry_delay'])
+            }
+          else
+            read_ok, obj = Networking.read_from_stream(@tcp_socket)
+            Log.debug3("Client returned from read: #{read_ok}")
+            # Handle case when socket is closed in middle.
+            # In that case we should not call obj_clb.
+            @obj_clb.call(obj) if (read_ok && @obj_clb != nil)
           end
         end
       end
-    end  # TCPClient
-  end
+    end
+  end  # TCPClient
 end
+

data/lib/networking/version.rb

@@ -1,5 +1,3 @@
-module BBFS
-  module Networking
-    VERSION = "0.0.9"
-  end
+module Networking
+  VERSION = "1.0.0"
 end

data/spec/networking/tcp_spec.rb

@@ -6,91 +6,90 @@ require 'stringio'
 require_relative '../../lib/networking/tcp'
 
 # Uncomment to debug spec.
-BBFS::Params['log_write_to_console'] = true
-BBFS::Params['log_debug_level'] = 0
-BBFS::Log.init
-
-module BBFS
-  module Networking
-    module Spec
-
-      describe 'TCPClient' do
-        it 'should warn when destination host+port are bad' do
-          data = 'kuku!!!'
-          stream = StringIO.new
-          stream.close()
-          ::TCPSocket.stub(:new).and_return(stream)
-          BBFS::Log.should_receive(:warning).with('Socket not opened for writing, skipping send.')
-
-          # Send data first.
-          tcp_client = TCPClient.new('kuku', 5555)
-          # Send has to fail.
-          tcp_client.send_obj(data).should be(false)
-        end
-
-        it 'should send data and server should receive callback function' do
-          info = 'info'
-          data = 'kuku!!!'
-          stream = StringIO.new
-          ::Socket.stub(:tcp_server_loop).and_yield(stream, info)
-          ::TCPSocket.stub(:new).and_return(stream)
-
-          # Send data first.
-          tcp_client = TCPClient.new('kuku', 5555)
-          # Send has to be successful.
-          tcp_client.send_obj(data).should be(21)
-
-          # Note this is very important so that reading the stream from beginning.
+Params['log_write_to_console'] = true
+Params['log_debug_level'] = 0
+Log.init
+
+module Networking
+  module Spec
+
+    describe 'TCPClient' do
+      it 'should warn when destination host+port are bad' do
+        data = 'kuku!!!'
+        stream = StringIO.new
+        stream.close()
+        ::TCPSocket.stub(:new).and_return(stream)
+        Log.should_receive(:warning).with('Socket not opened for writing, skipping send.')
+
+        # Send data first.
+        tcp_client = TCPClient.new('kuku', 5555)
+        # Send has to fail.
+        tcp_client.send_obj(data).should be(false)
+      end
+
+      it 'should send data and server should receive callback function' do
+        info = 'info'
+        data = 'kuku!!!'
+        stream = StringIO.new
+        ::Socket.stub(:tcp_server_loop).and_yield(stream, info)
+        ::TCPSocket.stub(:new).and_return(stream)
+
+        # Send data first.
+        tcp_client = TCPClient.new('kuku', 5555)
+        # Send has to be successful.
+        tcp_client.send_obj(data).should be(21)
+
+        # Note this is very important so that reading the stream from beginning.
+        stream.rewind
+
+        func = lambda { |info, data| Log.info("info, data: #{info}, #{data}") }
+        # Check data is received.
+        func.should_receive(:call).with(info, data)
+
+        tcp_server = TCPServer.new(5555, func)
+        # Wait on server thread.
+        tcp_server.tcp_thread.join
+      end
+
+      # TODO(kolman): Don't work, missing client send_obj/open_socket execution in
+      # the correct place.
+      it 'should connect and receive callback from server' do
+        info = 'info'
+        data = 'kuku!!!'
+        stream = StringIO.new
+        ::Socket.stub(:tcp_server_loop).once.and_yield(stream, info)
+        ::TCPSocket.stub(:new).and_return(stream)
+
+        tcp_server = nil
+        new_clb = lambda { |i|
+          Log.info("#2 - After after @sockets is filled. Send has to be successful.")
+          tcp_server.send_obj(data).should eq({info => 21})
+
           stream.rewind
 
-          func = lambda { |info, data| Log.info("info, data: #{info}, #{data}") }
-          # Check data is received.
-          func.should_receive(:call).with(info, data)
-
-          tcp_server = TCPServer.new(5555, func)
-          # Wait on server thread.
-          tcp_server.tcp_thread.join
-         end
-
-        # TODO(kolman): Don't work, missing client send_obj/open_socket execution in
-        # the correct place.
-        it 'should connect and receive callback from server' do
-          info = 'info'
-          data = 'kuku!!!'
-          stream = StringIO.new
-          ::Socket.stub(:tcp_server_loop).once.and_yield(stream, info)
-          ::TCPSocket.stub(:new).and_return(stream)
-
-          tcp_server = nil
-          new_clb = lambda { |i|
-            Log.info("#2 - After after @sockets is filled. Send has to be successful.")
-            tcp_server.send_obj(data).should eq({info => 21})
-
-            stream.rewind
-
-            func = lambda { |d|
-              Log.info("#6, After client initialized, it should send object.")
-              Log.info("data: #{d}")
-              # Validate received data.
-              d.should eq(data)
-              # Exit tcp client reading loop thread.
-              Thread.exit
-            }
-
-            Log.info("#4 - Create client and wait for read data.")
-            tcp_client = TCPClient.new('kuku', 5555, func)
-            tcp_client.tcp_thread.abort_on_exception = true
-            tcp_client.tcp_thread.join()
-            # We can finish now. Exit tcp server listening loop.
+          func = lambda { |d|
+            Log.info("#6, After client initialized, it should send object.")
+            Log.info("data: #{d}")
+            # Validate received data.
+            d.should eq(data)
+            # Exit tcp client reading loop thread.
             Thread.exit
           }
 
-          Log.info("#1 - Create server, send data and wait.")
-          tcp_server = TCPServer.new(5555, nil, new_clb)
-          tcp_server.tcp_thread.abort_on_exception = true
-          tcp_server.tcp_thread.join()
-        end
+          Log.info("#4 - Create client and wait for read data.")
+          tcp_client = TCPClient.new('kuku', 5555, func)
+          tcp_client.tcp_thread.abort_on_exception = true
+          tcp_client.tcp_thread.join()
+          # We can finish now. Exit tcp server listening loop.
+          Thread.exit
+        }
+
+        Log.info("#1 - Create server, send data and wait.")
+        tcp_server = TCPServer.new(5555, nil, new_clb)
+        tcp_server.tcp_thread.abort_on_exception = true
+        tcp_server.tcp_thread.join()
       end
     end
   end
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: networking
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-13 00:00:00.000000000 Z
+date: 2013-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: params
@@ -28,7 +28,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Easy to use simple tools for networking (tcp/ip, ect,...).
-email: kolmanv@gmail.com
+email: bbfsdev@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -37,7 +37,7 @@ files:
 - lib/networking/tcp.rb
 - lib/networking/version.rb
 - spec/networking/tcp_spec.rb
-homepage: http://github.com/kolmanv/bbfs
+homepage: http://github.com/bbfsdev/bbfs
 licenses: []
 post_install_message: 
 rdoc_options: []