ruby_skynet 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e4070e64ce70f32032c82eee9e6af0eaa94626c
-  data.tar.gz: 62ff2d291f403ac51406e17ead44a3f5feacd120
+  metadata.gz: 09c9a8e2a436c89fd46211dc103f0b55946fbfc2
+  data.tar.gz: e2683cdb8fae60e831c7793fca87e4f1ae573095
 SHA512:
-  metadata.gz: 66559b704a0e6f1f73967e555d23c6f3eb975c58059324cb9f06944b4eff65ae22105ce1a28f4e7533d9cdb9a84d3f20de391dce860c2aa0a58bc935a28fbf88
-  data.tar.gz: 17d54811347c21ff8c20a174923ce96469e05ed56c9603abef0d1a3374eda8a80e1536cb3f35cbc07746ccfae7b9dac9afb126eb7630e900024fea863ae26687
+  metadata.gz: 87a5e433d14d3c986c44472f0c19baeebd54a87362e071478d046238217470072fae4712af21ada8b16e771c326c44aa5a7b69ac96b124a0f3bab7e7994f2226
+  data.tar.gz: 5baff9cf4822187512543ef599f7e6842a5dab2a95744da5a55461a9d711c820f738018b8783672b8f3da12d1903a66c70bfc955395217d2df83db8f8ac5fb15

data/Gemfile

@@ -5,7 +5,7 @@ group :test do
 end
 
 gem "rake"
-gem "semantic_logger"
+gem "semantic_logger", ">= 2.1"
 gem "resilient_socket"
 # Doozer Client
 gem "ruby_doozer"

data/Gemfile.lock

@@ -21,7 +21,7 @@ GEM
     rake (10.0.3)
     resilient_socket (0.4.0)
       semantic_logger
-    ruby_doozer (0.4.0)
+    ruby_doozer (0.5.0)
       gene_pool
       resilient_socket
       ruby_protobuf

data/Rakefile

@@ -24,11 +24,11 @@ task :gem  do |t|
     spec.files       = FileList["./**/*"].exclude(/\.gem$/, /\.log$/,/nbproject/).map{|f| f.sub(/^\.\//, '')}
     spec.license     = "Apache License V2.0"
     spec.has_rdoc    = true
-    spec.add_dependency 'semantic_logger', '>= 2.0.0'
-    spec.add_dependency 'resilient_socket', '>= 0.4.0'
+    spec.add_dependency 'semantic_logger', '>= 2.1.0'
+    spec.add_dependency 'resilient_socket', '>= 0.5.0'
     spec.add_dependency 'multi_json', '>= 1.6.1'
     spec.add_dependency 'bson', '>= 1.5.2'
-    spec.add_dependency 'ruby_doozer', '>= 0.5.0'
+    spec.add_dependency 'ruby_doozer', '>= 0.6.0'
     spec.add_dependency 'gene_pool', '>= 1.3.0'
   end
   Gem::Package.build gemspec

data/examples/echo_client.rb

@@ -3,8 +3,12 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'rubygems'
 require 'ruby_skynet'
 
-SemanticLogger::Logger.default_level = :trace
-SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('echo_client.log')
+SemanticLogger.default_level = :info
+SemanticLogger.add_appender(STDOUT)
 
-client = RubySkynet::Client.new('EchoService')
-p client.call('echo', :hello => 'world')
+class Echo < RubySkynet::Client
+  self.skynet_name = "EchoService"
+end
+
+client = Echo.new
+p client.echo(:hello => 'world')

data/examples/echo_server.rb

@@ -3,18 +3,20 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 require 'rubygems'
 require 'ruby_skynet'
 
-# Log trace information to a log file
-SemanticLogger::Logger.default_level = :trace
-SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('echo_server.log')
+SemanticLogger.default_level = :info
+SemanticLogger.add_appender(STDOUT)
 
 # Just echo back any parameters received when the echo method is called
 class EchoService
   include RubySkynet::Service
 
+  skynet_name = "JoeService"
+
   # Methods implemented by this service
   # Must take a Hash as input
   # Must Return a Hash response or nil for no response
   def echo(params)
+    params['echo'] = true
     params
   end
 end
@@ -25,4 +27,3 @@ RubySkynet::Server.start
 puts "Press enter to shutdown server"
 gets
 
-RubySkynet::Server.stop

data/lib/ruby_skynet/base.rb

@@ -7,24 +7,6 @@ module RubySkynet
       base.extend ClassMethods
       base.class_eval do
         include SemanticLogger::Loggable
-        include InstanceMethods
-      end
-    end
-
-    module InstanceMethods
-      # Implement methods that call the remote Service
-      def method_missing(method, *args, &block)
-        result = ruby_skynet_client.call(method, *args)
-        # Define the method if the call was successful and no-one else already
-        # created the method
-        if result[:exception].nil? && !self.class.method_defined?(method)
-          self.class.send(:define_method, method) {|*args| ruby_skynet_client.call(method, *args)}
-        end
-        result
-      end
-
-      def ruby_skynet_client
-        @ruby_skynet_client ||= RubySkynet::Client.new(self.class.skynet_name, self.class.skynet_version || '*', self.class.skynet_region)
       end
     end
 

data/lib/ruby_skynet/client.rb

@@ -8,6 +8,17 @@ require 'bson'
 #
 module RubySkynet
   class Client
+    include Base
+
+    attr_reader :skynet_name, :skynet_version, :skynet_region
+
+    # Version of the Skynet service to use
+    # By default it will connect to the latest version
+    # Default: '*'
+    def self.skynet_version
+      @skynet_version ||= '*'
+    end
+
     # Returns a new RubySkynet Client for the named service
     #
     # Calls to an instance of the Client are thread-safe and can be called
@@ -15,29 +26,45 @@ module RubySkynet
     #
     # Parameters:
     #   :skynet_name
+    #     Only required when creating instance of RubySkynet::Client directly
+    #     Otherwise it defaults to the name of the class
     #     Name of the service to look for and connect to on Skynet
     #
-    #   :version
+    #   :skynet_version
     #     Optional version number of the service in Skynet
     #     Default: '*' being the latest version of the service
     #
-    #   :region
+    #   :skynet_region
     #     Optional region for this service in Skynet
-    #     Default: 'Development'
+    #     Default: RubySkynet.region
+    #
+    # Example using Client class
+    #
+    #  require 'ruby_skynet'
+    #  SemanticLogger.default_level = :info
+    #  SemanticLogger.add_appender(STDOUT)
     #
-    # Example
+    #  class EchoService < RubySkynet::Client
+    #  end
+    #
+    #  echo_service = EchoService.new
+    #  p echo_service.echo(:value => 5)
+    #
+    # Example using Ruby Client directly
     #
     #  require 'ruby_skynet'
-    #  SemanticLogger.default_level = :trace
-    #  SemanticLogger.appenders << SemanticLogger::Appender::File(STDOUT)
+    #  SemanticLogger.default_level = :info
+    #  SemanticLogger.add_appender(STDOUT)
     #
     #  tutorial_service = RubySkynet::Client.new('TutorialService')
     #  p tutorial_service.call('Add', :value => 5)
-    def initialize(skynet_name, version='*', region='Development')
-      @skynet_name = skynet_name
-      @logger       = SemanticLogger::Logger.new("#{self.class.name}: #{skynet_name}/#{version}/#{region}")
-      @version      = version
-      @region       = region
+    def initialize(skynet_name=self.class.skynet_name, skynet_version=self.class.skynet_version, skynet_region=self.class.skynet_region)
+      @skynet_name    = skynet_name
+      @skynet_version = skynet_version
+      @skynet_region  = skynet_region
+      self.logger = SemanticLogger["#{self.class.name}: #{@skynet_name}/#{@skynet_version}/#{@skynet_region}"]
+
+      raise "skynet_name is mandatory when using RubySkynet::Client directly" if @skynet_name == RubySkynet::Client.name
     end
 
     # Performs a synchronous call to the Skynet Service
@@ -56,13 +83,13 @@ module RubySkynet
       # Skynet requires BSON RPC Calls to have the following format:
       # https://github.com/skynetservices/skynet/blob/master/protocol.md
       request_id = BSON::ObjectId.new.to_s
-      @logger.tagged request_id do
-        @logger.benchmark_info "Called Skynet Service: #{@skynet_name}.#{method_name}" do
+      logger.tagged request_id do
+        logger.benchmark_info "Called Skynet Service: #{skynet_name}.#{method_name}" do
           retries = 0
           # If it cannot connect to a server, try a different server
           begin
-            Connection.with_connection(::RubySkynet.services.server_for(@skynet_name, @version, @region), connection_params) do |connection|
-              connection.rpc_call(request_id, @skynet_name, method_name, parameters)
+            Connection.with_connection(::RubySkynet.services.server_for(skynet_name, skynet_version, skynet_region), connection_params) do |connection|
+              connection.rpc_call(request_id, skynet_name, method_name, parameters)
             end
           rescue ResilientSocket::ConnectionFailure => exc
             if (retries < 3) && exc.cause.is_a?(Errno::ECONNREFUSED)
@@ -75,5 +102,19 @@ module RubySkynet
       end
     end
 
+    # Implement methods that call the remote Service
+    def method_missing(method, *args, &block)
+      result = call(method, *args)
+
+      # #TODO if Service returns method undefined, call super
+      #
+      # Define the method if the call was successful and no other thread has
+      # already created the method
+      if result[:exception].nil? && !self.class.method_defined?(method)
+        self.class.send(:define_method, method) {|*args| call(method, *args)}
+      end
+      result
+    end
+
   end
 end

data/lib/ruby_skynet/connection.rb

@@ -12,6 +12,7 @@ require 'sync_attr'
 module RubySkynet
   class Connection
     include SyncAttr
+    include SemanticLogger::Loggable
 
     # Returns the underlying socket being used by a Connection instance
     attr_reader :socket
@@ -26,11 +27,6 @@ module RubySkynet
       }
     end
 
-    # Logging instance for the connection pool
-    sync_cattr_reader :logger do
-      SemanticLogger::Logger.new(self)
-    end
-
     # For each server there is a connection pool keyed on the
     # server address: 'host:port'
     @@connection_pools = ThreadSafe::Hash.new
@@ -55,7 +51,7 @@ module RubySkynet
     #     Number of seconds between connection retry attempts after the first failed attempt
     #     Default: 0.5
     def initialize(server, params = {})
-      @logger = SemanticLogger::Logger.new("#{self.class.name}: #{server}")
+      self.logger = SemanticLogger["#{self.class.name} [#{server}]"]
 
       # User configurable options
       params[:read_timeout]           ||= 60
@@ -71,7 +67,7 @@ module RubySkynet
         # Reset user_data on each connection
         socket.user_data = {
           :seq    => 0,
-          :logger => @logger
+          :logger => logger
         }
 
         # Receive Service Handshake
@@ -81,9 +77,9 @@ module RubySkynet
         #
         # ClientID string
         #   ClientID is a UUID that is used by the client to identify itself in RPC requests.
-        @logger.debug "Waiting for Service Handshake"
+        logger.debug "Waiting for Service Handshake"
         service_handshake = Common.read_bson_document(socket)
-        @logger.trace 'Service Handshake', service_handshake
+        logger.trace 'Service Handshake', service_handshake
 
         # #TODO When a reconnect returns registered == false need to throw an exception
         # so that this host connection is not used
@@ -93,8 +89,8 @@ module RubySkynet
 
         # Send blank ClientHandshake
         client_handshake = { 'clientid' => client_id }
-        @logger.debug "Sending Client Handshake"
-        @logger.trace 'Client Handshake', client_handshake
+        logger.debug "Sending Client Handshake"
+        logger.trace 'Client Handshake', client_handshake
         socket.write(BSON.serialize(client_handshake).to_s)
       end
 
@@ -123,91 +119,92 @@ module RubySkynet
     # Raises RubySkynet::ProtocolError
     # Raises RubySkynet::SkynetException
     def rpc_call(request_id, skynet_name, method_name, parameters, idempotent=false)
-      retry_count = 0
-      header = nil
-      response = nil
-
-      socket.retry_on_connection_failure do |socket|
-        header = {
-          'servicemethod' => "#{skynet_name}.Forward",
-          'seq'           => socket.user_data[:seq]
-        }
+      logger.benchmark_info "Called #{skynet_name}.#{method_name}" do
+        retry_count = 0
+        header = nil
+        response = nil
+        socket.retry_on_connection_failure do |socket|
+          header = {
+            'servicemethod' => "#{skynet_name}.Forward",
+            'seq'           => socket.user_data[:seq]
+          }
 
-        @logger.debug "Sending Header"
-        @logger.trace 'Header', header
-        socket.write(BSON.serialize(header).to_s)
-
-        # The parameters are placed in the request object in BSON serialized form
-        request = {
-          'clientid'    => socket.user_data[:client_id],
-          'in'          => BSON::Binary.new(BSON.serialize(parameters).to_s),
-          'method'      => method_name.to_s,
-          'requestinfo' => {
-            'requestid'     => request_id,
-            # Increment retry count to indicate that the request may have been tried previously
-            'retrycount' => retry_count,
-            # TODO: this should be forwarded along in case of services also
-            # being a client and calling additional services. If empty it will
-            # be stuffed with connecting address
-            'originaddress' => ''
+          logger.debug "Sending Header"
+          logger.trace 'Header', header
+          socket.write(BSON.serialize(header).to_s)
+
+          # The parameters are placed in the request object in BSON serialized form
+          request = {
+            'clientid'    => socket.user_data[:client_id],
+            'in'          => BSON::Binary.new(BSON.serialize(parameters).to_s),
+            'method'      => method_name.to_s,
+            'requestinfo' => {
+              'requestid'     => request_id,
+              # Increment retry count to indicate that the request may have been tried previously
+              'retrycount' => retry_count,
+              # TODO: this should be forwarded along in case of services also
+              # being a client and calling additional services. If empty it will
+              # be stuffed with connecting address
+              'originaddress' => ''
+            }
           }
-        }
 
-        @logger.debug "Sending Request"
-        @logger.trace 'Request', request
-        @logger.trace 'Parameters:', parameters
-        socket.write(BSON.serialize(request).to_s)
+          logger.debug "Sending Request"
+          logger.trace 'Request', request
+          logger.trace 'Parameters:', parameters
+          socket.write(BSON.serialize(request).to_s)
+
+          # Since Send does not affect state on the server we can also retry reads
+          if idempotent
+            logger.debug "Reading header from server"
+            header = Common.read_bson_document(socket)
+            logger.debug 'Response Header', header
+
+            # Read the BSON response document
+            logger.debug "Reading response from server"
+            response = Common.read_bson_document(socket)
+            logger.trace 'Response', response
+          end
+        end
 
-        # Since Send does not affect state on the server we can also retry reads
-        if idempotent
-          @logger.debug "Reading header from server"
+        # Perform the read outside the retry block since a successful write
+        # means that the servers state may have been changed
+        unless idempotent
+          # Read header first as a separate BSON document
+          logger.debug "Reading header from server"
           header = Common.read_bson_document(socket)
-          @logger.debug 'Response Header', header
+          logger.debug 'Response Header', header
 
           # Read the BSON response document
-          @logger.debug "Reading response from server"
+          logger.debug "Reading response from server"
           response = Common.read_bson_document(socket)
-          @logger.trace 'Response', response
+          logger.trace 'Response', response
         end
-      end
 
-      # Perform the read outside the retry block since a successful write
-      # means that the servers state may have been changed
-      unless idempotent
-        # Read header first as a separate BSON document
-        @logger.debug "Reading header from server"
-        header = Common.read_bson_document(socket)
-        @logger.debug 'Response Header', header
-
-        # Read the BSON response document
-        @logger.debug "Reading response from server"
-        response = Common.read_bson_document(socket)
-        @logger.trace 'Response', response
-      end
-
-      # Ensure the sequence number in the response header matches the
-      # sequence number sent in the request
-      seq_no = header['seq']
-      if seq_no != socket.user_data[:seq]
-        raise ProtocolError.new("Incorrect Response received, expected seq=#{socket.user_data[:seq]}, received: #{header.inspect}")
-      end
+        # Ensure the sequence number in the response header matches the
+        # sequence number sent in the request
+        seq_no = header['seq']
+        if seq_no != socket.user_data[:seq]
+          raise ProtocolError.new("Incorrect Response received, expected seq=#{socket.user_data[:seq]}, received: #{header.inspect}")
+        end
 
-      # Increment Sequence number only on successful response
-      socket.user_data[:seq] += 1
+        # Increment Sequence number only on successful response
+        socket.user_data[:seq] += 1
 
-      # If an error is returned from Skynet raise a Skynet exception
-      error = header['error']
-      raise SkynetException.new(error) if error.to_s.length > 0
+        # If an error is returned from Skynet raise a Skynet exception
+        error = header['error']
+        raise SkynetException.new(error) if error.to_s.length > 0
 
-      # If an error is returned from the service raise a Service exception
-      error = response['error']
-      raise ServiceException.new(error) if error.to_s.length > 0
+        # If an error is returned from the service raise a Service exception
+        error = response['error']
+        raise ServiceException.new(error) if error.to_s.length > 0
 
-      # Return Value
-      # The return value is inside the response object, it's a byte array of it's own and needs to be deserialized
-      result = BSON.deserialize(response['out'])
-      @logger.trace 'Return Value', result
-      result
+        # Return Value
+        # The return value is inside the response object, it's a byte array of it's own and needs to be deserialized
+        result = BSON.deserialize(response['out'])
+        logger.trace 'Return Value', result
+        result
+      end
     end
 
     # Execute the supplied block with a connection from the pool
@@ -227,10 +224,11 @@ module RubySkynet
       # Connection pool configuration options
       config = pool_config.dup
 
+      logger = SemanticLogger::Logger.new("#{self.class.name} [#{server}]")
+
       # Method to call to close idle connections
       config[:close_proc] = :close
       config[:logger]     = logger
-      config[:name]       = "Connection pool for #{server}"
 
       pool = GenePool.new(pool_config) do
         new(server, params)
@@ -242,7 +240,7 @@ module RubySkynet
         # Cannot close all the connections since they could still be in use
         pool.remove_idle(0) if pool
         #pool.close if pool
-        logger.debug "Connection pool for server:#{server} has been released"
+        logger.debug "Connection pool released"
       end
 
       pool

data/lib/ruby_skynet/server.rb

@@ -205,13 +205,13 @@ module RubySkynet
 
     # Registers a Service Class as being available at this server
     def register_service(klass)
-      logger.debug "Registering Service: #{klass.name} with name: #{klass.skynet_name}"
+      logger.info "Registering Service: #{klass.name} with name: #{klass.skynet_name}"
       ::RubySkynet.services.register_service(klass.skynet_name, klass.skynet_version || 1, klass.skynet_region, @hostname, @port)
     end
 
     # De-register service from this server
     def deregister_service(klass)
-      logger.debug "De-registering Service: #{klass.name} with name: #{klass.skynet_name}"
+      logger.info "De-registering Service: #{klass.name} with name: #{klass.skynet_name}"
       ::RubySkynet.services.deregister_service(klass.skynet_name, klass.skynet_version || 1, klass.skynet_region, @hostname, @port)
     end
 

data/lib/ruby_skynet/service_registry.rb

@@ -99,7 +99,7 @@ module RubySkynet
     end
 
     # Return a server that implements the specified service
-    def server_for(name, version='*', region='Development')
+    def server_for(name, version='*', region=RubySkynet.region)
       if servers = servers_for(name, version, region)
         # Randomly select one of the servers offering the service
         servers[rand(servers.size)]
@@ -111,7 +111,7 @@ module RubySkynet
     end
 
     # Returns [Array<String>] a list of servers implementing the requested service
-    def servers_for(name, version='*', region='Development')
+    def servers_for(name, version='*', region=RubySkynet.region)
       if version == '*'
         # Find the highest version for the named service in this region
         version = -1
@@ -173,7 +173,6 @@ module RubySkynet
     # Add the host to the registry based on it's score
     def add_server(key, hostname, port)
       server  = "#{hostname}:#{port}"
-      logger.debug "#monitor Add/Update Service: #{key} => #{server.inspect}"
 
       server_infos = (@registry[key] ||= ThreadSafe::Array.new)
 
@@ -183,6 +182,7 @@ module RubySkynet
 
       # Look for the same score with a different server
       score = self.class.score_for_server(hostname, RubySkynet.local_ip_address)
+      logger.info "Service: #{key} now running at #{server} with score #{score}"
       if server_info = server_infos.find{|si| si.score == score}
         server_info.servers << server
         return server_info
@@ -206,7 +206,7 @@ module RubySkynet
     # Returns the server instance if it was removed
     def remove_server(key, hostname, port, notify)
       server = "#{hostname}:#{port}"
-      logger.debug "Remove Service: #{key} => #{server.inspect}"
+      logger.info "Service: #{key} stopped running at #{server}"
       server_info = nil
       if server_infos = @registry[key]
         server_infos.each do |si|
@@ -235,7 +235,7 @@ module RubySkynet
       if @on_server_removed_callbacks && (callbacks = @on_server_removed_callbacks.delete(server))
         callbacks.each do |block|
           begin
-            logger.info "Calling callback for server: #{server}"
+            logger.debug "Calling callback for server: #{server}"
             block.call(server)
           rescue Exception => exc
             logger.error("Exception during a callback for server: #{server}", exc)

data/lib/ruby_skynet/version.rb

@@ -1,3 +1,3 @@
 module RubySkynet #:nodoc
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/test/client_test.rb

@@ -8,10 +8,8 @@ require 'shoulda'
 require 'ruby_skynet'
 
 # Register an appender if one is not already registered
-if SemanticLogger::Logger.appenders.size == 0
-  SemanticLogger::Logger.default_level = :trace
-  SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
-end
+SemanticLogger.default_level = :trace
+SemanticLogger.add_appender('test.log') if SemanticLogger.appenders.size == 0
 
 class ClientTestService
   include RubySkynet::Service
@@ -38,17 +36,21 @@ class ClientTestService
 
 end
 
+# Test Client Class
+class ClientTestServiceClient < RubySkynet::Client
+end
+
 # Unit Test for ResilientSocket::TCPClient
 class ClientTest < Test::Unit::TestCase
   context RubySkynet::Client do
 
     context "without server" do
-      should "raise exception when cannot reach server after 5 retries" do
+      should "raise exception when not registered" do
         exception = assert_raise RubySkynet::ServiceUnavailable do
-          client = RubySkynet::Client.new('SomeService')
+          client = RubySkynet::Client.new('SomeService','*','ClientTest')
           client.call(:test, :hello => 'there')
         end
-        assert_match /No servers available for service: SomeService with version: \* in region: Development/, exception.message
+        assert_match /No servers available for service: SomeService with version: \* in region: ClientTest/, exception.message
       end
 
     end
@@ -90,8 +92,29 @@ class ClientTest < Test::Unit::TestCase
           end
           assert_match /Timedout after #{@read_timeout} seconds trying to read/, exception.message
         end
+      end
+
+      context "using client class" do
+        setup do
+          @client = ClientTestServiceClient.new("ClientTestService")
+        end
+
+        should "successfully send and receive data" do
+          reply = @client.test1('some' => 'parameters')
+          assert_equal 'test1', reply['result']
+        end
 
+        should "timeout on receive" do
+          request = { 'duration' => @read_timeout + 0.5}
+
+          exception = assert_raise ResilientSocket::ReadTimeout do
+            # Read 4 bytes from server
+            @client.sleep(request, :read_timeout => @read_timeout)
+          end
+          assert_match /Timedout after #{@read_timeout} seconds trying to read/, exception.message
+        end
       end
+
     end
   end
 end

data/test/service_registry_test.rb

@@ -7,10 +7,8 @@ require 'shoulda'
 require 'ruby_skynet'
 
 # Register an appender if one is not already registered
-if SemanticLogger::Logger.appenders.size == 0
-  SemanticLogger::Logger.default_level = :trace
-  SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
-end
+SemanticLogger.default_level = :trace
+SemanticLogger.add_appender('test.log') if SemanticLogger.appenders.size == 0
 
 # Unit Test
 class ServiceRegistryTest < Test::Unit::TestCase
@@ -23,12 +21,17 @@ class ServiceRegistryTest < Test::Unit::TestCase
       @hostname     = '127.0.0.1'
       @port         = 2100
       @service_key  = "/services/#{@service_name}/#{@version}/#{@region}/#{@hostname}/#{@port}"
+      RubySkynet.local_ip_address = @hostname
+    end
+
+    teardown do
+      RubySkynet.local_ip_address = nil
     end
 
     context "without a registered service" do
       should "not be in doozer" do
         RubySkynet.services.send(:doozer_pool).with_connection do |doozer|
-          assert_equal '', doozer[@service_key]
+          assert_equal nil, doozer[@service_key]
         end
       end
     end
@@ -36,12 +39,14 @@ class ServiceRegistryTest < Test::Unit::TestCase
     context "with a registered service" do
       setup do
         RubySkynet.services.register_service(@service_name, @version, @region, @hostname, @port)
+        RubySkynet.services.register_service(@service_name, @version, @region+'BLAH', @hostname, @port)
         # Allow time for doozer callback that service was registered
         sleep 0.1
       end
 
       teardown do
         RubySkynet.services.deregister_service(@service_name, @version, @region, @hostname, @port)
+        RubySkynet.services.deregister_service(@service_name, @version, @region+'BLAH', @hostname, @port)
         # Allow time for doozer callback that service was deregistered
         sleep 0.1
         # No servers should be in the local registry
@@ -78,9 +83,10 @@ class ServiceRegistryTest < Test::Unit::TestCase
 
         should "using * version match" do
           assert servers = RubySkynet.services.servers_for(@service_name, '*', @region)
-          assert_equal 3, servers.size, RubySkynet.services.to_h.to_s
-          assert_equal "#{@hostname}:#{@port}", servers.first
-          assert_equal "#{@hostname}:#{@port+3}", servers.last
+          assert_equal 3, servers.size, servers
+          assert_equal true, servers.include?("#{@hostname}:#{@port}"), servers
+          assert_equal true, servers.include?("#{@hostname}:#{@port+1}"), servers
+          assert_equal true, servers.include?("#{@hostname}:#{@port+3}"), servers
         end
       end
 

data/test/service_test.rb

@@ -7,10 +7,8 @@ require 'shoulda'
 require 'ruby_skynet'
 
 # Register an appender if one is not already registered
-if SemanticLogger::Logger.appenders.size == 0
-  SemanticLogger::Logger.default_level = :trace
-  SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
-end
+SemanticLogger.default_level = :trace
+SemanticLogger.add_appender('test.log') if SemanticLogger.appenders.size == 0
 
 class TestService
   include RubySkynet::Service

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_skynet
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-01 00:00:00.000000000 Z
+date: 2013-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: resilient_socket
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 - !ruby/object:Gem::Dependency
   name: gene_pool
   requirement: !ruby/object:Gem::Requirement
@@ -124,7 +124,6 @@ files:
 - lib/ruby_skynet/service_registry.rb
 - lib/ruby_skynet/version.rb
 - test.sh
-- test/base_test.rb
 - test/client_test.rb
 - test/service_registry_test.rb
 - test/service_test.rb

data/test/base_test.rb

@@ -1,89 +0,0 @@
-# Allow test to be run in-place without requiring a gem install
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-$LOAD_PATH.unshift File.dirname(__FILE__)
-
-require 'rubygems'
-require 'test/unit'
-require 'shoulda'
-require 'ruby_skynet'
-
-# Register an appender if one is not already registered
-if SemanticLogger::Logger.appenders.size == 0
-  SemanticLogger::Logger.default_level = :debug
-  SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
-end
-
-# Service implementation
-class BaseTestService
-  include RubySkynet::Service
-
-  # Methods implemented by this service
-  # Must take a Hash as input
-  # Must Return a Hash response or nil for no response
-  def test1(params)
-    { 'result' => 'test1' }
-  end
-
-  def sleep(params)
-    Kernel.sleep params['duration'] || 1
-    { 'result' => 'sleep' }
-  end
-
-  def fail(params)
-    if params['attempt'].to_i >= 2
-      { 'result' => 'fail' }
-    else
-      nil
-    end
-  end
-
-end
-
-# Service Client
-class BaseTestServiceClient
-  include RubySkynet::Base
-
-  # Override Name registered in skynet to match server above
-  self.skynet_name = 'BaseTestService'
-end
-
-# Unit Test
-class BaseTest < Test::Unit::TestCase
-  context RubySkynet::Base do
-
-    context "with server" do
-      setup do
-        RubySkynet.region = @region
-        RubySkynet::Server.start
-
-        @read_timeout = 3.0
-      end
-
-      teardown do
-        RubySkynet::Server.stop
-      end
-
-      context "with client connection" do
-        setup do
-          @client = BaseTestServiceClient.new
-        end
-
-        should "successfully send and receive data" do
-          reply = @client.test1('some' => 'parameters')
-          assert_equal 'test1', reply['result']
-        end
-
-        should "timeout on receive" do
-          request = { 'duration' => @read_timeout + 0.5}
-
-          exception = assert_raise ResilientSocket::ReadTimeout do
-            # Read 4 bytes from server
-            @client.sleep(request, :read_timeout => @read_timeout)
-          end
-          assert_match /Timedout after #{@read_timeout} seconds trying to read/, exception.message
-        end
-
-      end
-    end
-  end
-end