networking 0.0.8

data/lib/networking/tcp.rb

@@ -0,0 +1,217 @@
+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
+      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
+      end
+    end
+
+    # 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
+          stream.close()
+        rescue IOError => e
+          Log.warning("Could not close stream, #{e.to_s}.")
+        end
+        return [false, nil]
+      end
+
+      unmarshalled_data = Marshal.load(data)
+      Log.debug3('Read good.')
+      return [true, unmarshalled_data]
+    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
+            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
+              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 " \
+                       "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
+
+      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
+
+      # 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 " \
+                          "#{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
+          end
+        end
+      end
+    end  # TCPClient
+  end
+end

data/lib/networking/version.rb

@@ -0,0 +1,5 @@
+module BBFS
+  module Networking
+    VERSION = "0.0.8"
+  end
+end

data/lib/networking.rb

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

data/spec/networking/tcp_spec.rb

@@ -0,0 +1,96 @@
+require 'log'
+require 'rspec'
+require 'socket'
+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.
+          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.
+            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
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: networking
+version: !ruby/object:Gem::Version
+  version: 0.0.8
+  prerelease: 
+platform: ruby
+authors:
+- Kolman Vornovitsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: params
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easy to use simple tools for networking (tcp/ip, ect,...).
+email: kolmanv@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/networking.rb
+- lib/networking/tcp.rb
+- lib/networking/version.rb
+- spec/networking/tcp_spec.rb
+homepage: http://github.com/kolmanv/bbfs
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Easy to use simple tools for networking (tcp/ip, ect,...).
+test_files:
+- spec/networking/tcp_spec.rb