ruby_skynet 0.4.0.pre2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a4505056e7cd42bd2218494f4ef40c5c46b68b8
-  data.tar.gz: a2c44053bd1e42ac9bf3f67797e0363d5002b6fa
+  metadata.gz: 16525cda69fa5554ce2851afcea16d4d379e1c3e
+  data.tar.gz: b02c07c9d88035fc5018e18548dc0e868f640716
 SHA512:
-  metadata.gz: df66afd5b487c3f1014064c39687404681f1c0cb5528e888af262daf7b2535474b10029a8d278d7e133b1ccb89f223b9621a5bd944ee19b7f413462cc4c8602f
-  data.tar.gz: 47ed383fa62a90510cb2788d520a9416e6f82610db9300fcb7a6370285fc298cfd96348c99ecbc1bcbd5bb03c708a3456283b52f524960843aeb0f0eb930d5d1
+  metadata.gz: 461650dbc05cd7febf853c2f7416e22f089cec61fa4e5aea188cef90573452e6ea1f8cc43443132b94071420e9727cacd605662a2d35423baf3a2acecbc2132e
+  data.tar.gz: 9bfa3b9751bd03753a849e34c1c4a3eb9c9f9de04af1efe34131aa7fdcd3c59aa1f8e3fb885ecbe61e79abd2aea810804a9c169c9a26ed0d553ecf0e5210be23

data/Gemfile

@@ -2,6 +2,7 @@ source :rubygems
 
 group :test do
   gem "shoulda"
+  gem "mocha", :require => false
 end
 
 gem "rake"
@@ -16,6 +17,3 @@ gem "ruby_protobuf"
 # Wire format when communicating with services
 gem "bson"
 gem "bson_ext", :platform => :ruby
-# Celluloid::IO is used to create SkyNet services in Ruby
-# multi_json?
-gem "celluloid-io", '0.13.0.pre2'

data/Gemfile.lock

@@ -1,27 +1,23 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    activesupport (3.2.12)
-      i18n (~> 0.6)
+    activesupport (3.2.13)
+      i18n (= 0.6.1)
       multi_json (~> 1.0)
     atomic (1.0.1)
     atomic (1.0.1-java)
-    bourne (1.1.2)
-      mocha (= 0.10.5)
+    bourne (1.4.0)
+      mocha (~> 0.13.2)
     bson (1.8.3)
     bson (1.8.3-java)
-    celluloid (0.13.0.pre2)
-      timers (>= 1.0.0)
-    celluloid-io (0.13.0.pre2)
-      celluloid (>= 0.13.0.pre)
-      nio4r (>= 0.4.0)
+    bson_ext (1.8.3)
+      bson (~> 1.8.3)
     gene_pool (1.3.0)
-    i18n (0.6.4)
+    i18n (0.6.1)
     metaclass (0.0.1)
-    mocha (0.10.5)
+    mocha (0.13.3)
       metaclass (~> 0.0.1)
-    multi_json (1.7.0)
-    nio4r (0.4.3-java)
+    multi_json (1.7.1)
     rake (10.0.3)
     resilient_socket (0.4.0)
       semantic_logger
@@ -29,26 +25,26 @@ GEM
     semantic_logger (2.0.0)
       sync_attr
       thread_safe
-    shoulda (3.3.2)
-      shoulda-context (~> 1.0.1)
-      shoulda-matchers (~> 1.4.1)
+    shoulda (3.4.0)
+      shoulda-context (~> 1.0, >= 1.0.1)
+      shoulda-matchers (~> 1.0, >= 1.4.1)
     shoulda-context (1.0.2)
-    shoulda-matchers (1.4.2)
+    shoulda-matchers (1.5.4)
       activesupport (>= 3.0.0)
-      bourne (~> 1.1.2)
+      bourne (~> 1.3)
     sync_attr (0.1.1)
     thread_safe (0.1.0)
       atomic
-    timers (1.1.0)
 
 PLATFORMS
   java
+  ruby
 
 DEPENDENCIES
   bson
   bson_ext
-  celluloid-io (= 0.13.0.pre2)
   gene_pool
+  mocha
   multi_json
   rake
   resilient_socket

data/Rakefile

@@ -29,7 +29,6 @@ task :gem  do |t|
     spec.add_dependency 'multi_json', '>= 1.6.1'
     spec.add_dependency 'bson'
     spec.add_dependency 'ruby_protobuf'
-    spec.add_dependency 'celluloid-io', '>= 0.13.0.pre2'
   end
   Gem::Package.build gemspec
 end

data/examples/e.rb

@@ -1,14 +0,0 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'rubygems'
-require 'ruby_skynet'
-require 'active_support/core_ext/hash/conversions'
-
-SemanticLogger::Logger.default_level = :trace
-SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('skynet.log')
-
-client = RubySkynet::Client.new('InquiriesService')
-#h = {}; 1000.times{|i| h["hello#{i}"] = i}
-#p client.call('echo', h)
-data = Hash.from_xml(File.read("../../claritybase/test/load/inquiry.xml"))['inquiry']
-p data
-p client.call('create', data)

data/lib/ruby_skynet/client.rb

@@ -54,7 +54,7 @@ module RubySkynet
     # Raises RubySkynet::SkynetException
     def call(method_name, parameters, connection_params={})
       # Skynet requires BSON RPC Calls to have the following format:
-      # https://github.com/bketelsen/skynet/blob/protocol/protocol.md
+      # 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: #{@service_name}.#{method_name}" do

data/lib/ruby_skynet/common.rb

@@ -1,3 +1,5 @@
+require 'socket'
+
 module RubySkynet
   module Common
 
@@ -18,9 +20,15 @@ module RubySkynet
 
       bytebuf.append!(bytes)
       bytebuf.append!(socket.read(sz - 4))
-      raise "Celluloid is not returning #{sz} requested bytes. #{bytebuf.length} bytes returned" unless sz == bytebuf.length
+      raise "Socket is not returning #{sz} requested bytes. #{bytebuf.length} bytes returned" unless sz == bytebuf.length
       return BSON.deserialize(bytebuf)
     end
 
+    # Returns the local ip address being used by this machine to talk to the
+    # internet. By default connects to Google and determines what IP Address is used locally
+    def self.local_ip_address(remote_ip = '64.233.187.99')
+      @@local_ip_address ||= ::UDPSocket.open {|s| s.connect(remote_ip, 1); s.addr.last }
+    end
+
   end
 end

data/lib/ruby_skynet/doozer/client.rb

@@ -25,7 +25,7 @@ module RubySkynet
         # Disable buffering the send since it is a RPC call
         params[:buffered] = false
 
-        @logger.trace "Socket Connection parameters", params
+        @logger.trace "Socket Connection parameters", params.dup
 
         # For each new connection
         params[:on_connect] = Proc.new do |socket|

data/lib/ruby_skynet/exceptions.rb

@@ -2,6 +2,7 @@ module RubySkynet
   class Exception < ::RuntimeError; end
   class ProtocolError < Exception; end
   class ServiceException < Exception; end
+  class InvalidServiceException < ServiceException; end
   class SkynetException < Exception; end
   class ServiceUnavailable < SkynetException; end
 end

data/lib/ruby_skynet/registry.rb

@@ -2,6 +2,7 @@ require 'sync_attr'
 require 'multi_json'
 require 'thread_safe'
 require 'gene_pool'
+require 'resolv'
 
 #
 # RubySkynet Registry Client
@@ -17,8 +18,8 @@ module RubySkynet
     # Service Registry has the following format
     #  Key: [String] 'service_name/version/region'
     #  Value: [Array<String>] 'host:port', 'host:port'
-    sync_cattr_accessor :service_registry do
-      start_monitoring
+    sync_cattr_reader :service_registry do
+      start
     end
 
     @@on_server_removed_callbacks = ThreadSafe::Hash.new
@@ -61,24 +62,32 @@ module RubySkynet
       }
     end
 
-    # Lazy initialize Doozer Client Connection pool
-    sync_cattr_reader :doozer_pool do
-      GenePool.new(
-        :name         =>"Doozer Connection Pool",
-        :pool_size    => 5,
-        :timeout      => 30,
-        :warn_timeout => 5,
-        :idle_timeout => 600,
-        :logger       => logger,
-        :close_proc   => :close
-      ) do
-        Doozer::Client.new(doozer_config)
+    # Register the supplied service at this Skynet Server host and Port
+    def self.register_service(name, version, region, hostname, port)
+      config = {
+        "Config" => {
+          "UUID"    => "#{hostname}:#{port}-#{$$}-#{name}-#{version}",
+          "Name"    => name,
+          "Version" => version.to_s,
+          "Region"  => region,
+          "ServiceAddr" => {
+            "IPAddress" => hostname,
+            "Port"      => port,
+            "MaxPort"   => port + 999
+          },
+        },
+        "Registered" => true
+      }
+      doozer_pool.with_connection do |doozer|
+        doozer["/services/#{name}/#{version}/#{region}/#{hostname}/#{port}"] = MultiJson.encode(config)
       end
     end
 
-    # Logging instance for this class
-    sync_cattr_reader :logger do
-      SemanticLogger::Logger.new(self, :debug)
+    # Deregister the supplied service from the Registry
+    def self.deregister_service(name, version, region, hostname, port)
+      doozer_pool.with_connection do |doozer|
+        doozer.delete("/services/#{name}/#{version}/#{region}/#{hostname}/#{port}") rescue nil
+      end
     end
 
     # Return a server that implements the specified service
@@ -115,35 +124,19 @@ module RubySkynet
     end
 
     # Returns [Array<String>] a list of servers implementing the requested service
-    def self.servers_for(service_name, version='*', region='Development', remote = false)
-      if remote
-        if version != '*'
-          registered_implementers(service_name, version, region).map do |host|
-            service = host['Config']['ServiceAddr']
-            "#{service['IPAddress']}:#{service['Port']}"
-          end
-        else
-          # Find the highest version of any particular service
-          versions = {}
-          registered_implementers(service_name, version, region).each do |host|
-            service = host['Config']['ServiceAddr']
-            (versions[version.to_i] ||= []) << "#{service['IPAddress']}:#{service['Port']}"
-          end
-          # Return the servers implementing the highest version number
-          versions.sort.last.last
-        end
-      else
-        if version == '*'
-          # Find the highest version for the named service in this region
-          version = -1
-          service_registry.keys.each do |key|
-            if match = key.match(/#{service_name}\/(\d+)\/#{region}/)
-              ver = match[1].to_i
-              version = ver if ver > version
-            end
+    def self.servers_for(service_name, version='*', region='Development')
+      if version == '*'
+        # Find the highest version for the named service in this region
+        version = -1
+        service_registry.keys.each do |key|
+          if match = key.match(/#{service_name}\/(\d+)\/#{region}/)
+            ver = match[1].to_i
+            version = ver if ver > version
           end
         end
-        service_registry["#{service_name}/#{version}/#{region}"]
+      end
+      if server_infos = service_registry["#{service_name}/#{version}/#{region}"]
+        server_infos.first.servers
       end
     end
 
@@ -155,83 +148,124 @@ module RubySkynet
       (@@on_server_removed_callbacks[server] ||= ThreadSafe::Array.new) << block
     end
 
+    IPV4_REG_EXP = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
+
+    # Returns [Integer] the score for the supplied ip_address
+    # Score currently ranges from 0 to 4 with 4 being the best score
+    # If the IP address does not match an IP v4 address a DNS lookup will
+    # be performed
+    def self.score_for_server(ip_address)
+      score = 0
+      # Each matching element adds 1 to the score
+      # 192.168.  0.  0
+      #               1
+      #           1
+      #       1
+      #   1
+      server_match = IPV4_REG_EXP.match(ip_address) || IPV4_REG_EXP.match(Resolv::DNS.new.getaddress(ip_address).to_s)
+      if server_match
+        @@local_match ||= IPV4_REG_EXP.match(Common.local_ip_address)
+        score = 0
+        (1..4).each do |i|
+          break if @@local_match[i].to_i != server_match[i].to_i
+          score += 1
+        end
+      end
+      score
+    end
+
     ############################
-    #protected
+    protected
+
+    # Logging instance for this class
+    sync_cattr_reader :logger do
+      SemanticLogger::Logger.new(self, :debug)
+    end
 
-    # Fetch the all registry information from Doozer and set the internal registry
+    # Lazy initialize Doozer Client Connection pool
+    sync_cattr_reader :doozer_pool do
+      GenePool.new(
+        :name         =>"Doozer Connection Pool",
+        :pool_size    => 5,
+        :timeout      => 30,
+        :warn_timeout => 5,
+        :idle_timeout => 600,
+        :logger       => logger,
+        :close_proc   => :close
+      ) do
+        Doozer::Client.new(doozer_config)
+      end
+    end
+
+    # Fetch the all registry information from Doozer and sets the internal registry
     # Also starts the monitoring thread to keep the registry up to date
-    def self.start_monitoring
+    def self.start
+      # Populate internal registry from doozer server
+      #   Holds a lock in this process on the service_registry so that only
+      #   this thread will pre-populate the local copy of the registry
       registry = ThreadSafe::Hash.new
       revision = nil
       doozer_pool.with_connection do |doozer|
         revision = doozer.current_revision
         doozer.walk(DOOZER_SERVICES_PATH, revision).each do |node|
-          # path: "/services/TutorialService/1/Development/127.0.0.1/9000"
-          e = node.path.split('/')
-
-          # Key: [String] 'service_name/version/region'
-          key = "#{e[2]}/#{e[3]}/#{e[4]}"
-          server = "#{e[5]}:#{e[6]}"
-
-          if node.value.strip.size > 0
-            entry = MultiJson.load(node.value)
-            if entry['Registered']
-              # Value: [Array<String>] 'host:port', 'host:port'
-              servers = (registry[key] ||= ThreadSafe::Array.new)
-              servers << server unless servers.include?(server)
-              logger.debug "#start_monitoring Add Service: #{key} => #{server}"
-            end
-          end
+          service_info_change(registry, node.path, node.value)
         end
       end
       # Start monitoring thread to keep the registry up to date
-      @@monitor_thread = Thread.new { self.watch(revision + 1) }
+      @@monitor_thread = Thread.new { watch_registry(revision + 1) }
+
+      # Cleanup when process exits
+      at_exit do
+        if @@monitor_thread
+          @@monitor_thread.kill
+          @@monitor_thread.join
+          @@monitor_thread = nil
+        end
+        doozer_pool.close
+      end
       registry
     end
 
     # Waits for any updates from Doozer and updates the internal service registry
-    def self.watch(revision)
+    def self.watch_registry(revision)
       logger.info "Start monitoring #{DOOZER_SERVICES_PATH}"
       # This thread must use its own dedicated doozer connection
       doozer = Doozer::Client.new(doozer_config)
-      doozer.watch(DOOZER_SERVICES_PATH, revision) do |node|
-        # path: "/services/TutorialService/1/Development/127.0.0.1/9000"
-        e = node.path.split('/')
 
-        # Key: [String] 'service_name/version/region'
-        key = "#{e[2]}/#{e[3]}/#{e[4]}"
-        server = "#{e[5]}:#{e[6]}"
-
-        if node.value.strip.size > 0
-          entry = MultiJson.load(node.value)
-          if entry['Registered']
-            # Value: [Array<String>] 'host:port', 'host:port'
-            servers = (@@service_registry[key] ||= ThreadSafe::Array.new)
-            servers << server unless servers.include?(server)
-            logger.debug "#monitor Add/Update Service: #{key} => #{server}"
-          else
-            logger.debug "#monitor Service deregistered, remove: #{key} => #{server}"
-            if @@service_registry[key]
-              @@service_registry[key].delete(server)
-              @@service_registry.delete(key) if @@service_registry[key].size == 0
-            end
-          end
-        else
-          # Service has stopped and needs to be removed
-          logger.debug "#monitor Service stopped, remove: #{key} => #{server}"
-          if @@service_registry[key]
-            @@service_registry[key].delete(server)
-            @@service_registry.delete(key) if @@service_registry[key].size == 0
-            server_removed(server)
-          end
-        end
-        logger.debug "Updated registry", @@service_registry
+      # Watch for any changes
+      doozer.watch(DOOZER_SERVICES_PATH, revision) do |node|
+        service_info_change(service_registry, node.path, node.value)
+        logger.trace "Updated registry", service_registry
       end
       logger.info "Stopping monitoring thread normally"
     rescue Exception => exc
       logger.error "Exception in monitoring thread", exc
     ensure
-      logger.info "Stopped monitoring"
+      doozer.close if doozer
+      logger.info "Stopped monitoring for changes in the doozer registry"
+    end
+
+    # Service information changed in doozer, so update internal registry
+    def self.service_info_change(registry, path, value)
+      # path from doozer: "/services/TutorialService/1/Development/127.0.0.1/9000"
+      e = path.split('/')
+
+      # Key: [String] 'service_name/version/region'
+      key = "#{e[2]}/#{e[3]}/#{e[4]}"
+      hostname, port = e[5], e[6]
+
+      if value.strip.size > 0
+        entry = MultiJson.load(value)
+        if entry['Registered']
+          add_server(registry, key, hostname, port)
+        else
+          # Service just de-registered
+          remove_server(registry, key, hostname, port, false)
+        end
+      else
+        # Service has stopped and needs to be removed
+        remove_server(registry, key, hostname, port, true)
+      end
     end
 
     # Invoke any registered callbacks for the specific server
@@ -248,5 +282,94 @@ module RubySkynet
       end
     end
 
+    # :score:   [Integer] Score
+    # :servers: [Array<String>] 'host:port', 'host:port'
+    ServerInfo = Struct.new(:score, :servers )
+
+    # Format of the internal services registry
+    #   key: [String] "<service_name>/<version>/<region>"
+    #   value: [ServiceInfo, ServiceInfo]
+    #          Sorted by highest score first
+
+    # Add the host to the registry based on it's score
+    def self.add_server(registry, key, hostname, port)
+      server  = "#{hostname}:#{port}"
+      logger.debug "#monitor Add/Update Service: #{key} => #{server.inspect}"
+
+      server_infos = (registry[key] ||= ThreadSafe::Array.new)
+
+      # If already present, then nothing to do
+      server_info = server_infos.find{|si| si.server == server}
+      return server_info if server_info
+
+      # Look for the same score with a different server
+      score = score_for_server(hostname)
+      if server_info = server_infos.find{|si| si.score == score}
+        server_info.servers << server
+        return server_info
+      end
+
+      # New score
+      servers = ThreadSafe::Array.new
+      servers << server
+      server_info = ServerInfo.new(score, servers)
+
+      # Insert into Array in order of score
+      if index = server_infos.find_index {|si| si.score <= score}
+        server_infos.insert(index, server_info)
+      else
+        server_infos << server_info
+      end
+      server_info
+    end
+
+    # Remove the host from the registry based
+    # Returns the server instance if it was removed
+    def self.remove_server(registry, key, hostname, port, notify)
+      server = "#{hostname}:#{port}"
+      logger.debug "Remove Service: #{key} => #{server.inspect}"
+      server_info = nil
+      if server_infos = registry[key]
+        server_infos.each do |si|
+          if si.servers.delete(server)
+            server_info = si
+            break
+          end
+        end
+
+        # Found server
+        if server_info
+          # Cleanup if no more servers in server list
+          server_infos.delete(server_info) if server_info.servers.size == 0
+
+          # Cleanup if no more server infos
+          registry.delete(key) if server_infos.size == 0
+
+          server_removed(server) if notify
+        end
+      end
+      server_info
+    end
+
+    # Check doozer for servers matching supplied criteria
+    # Code unused, consider deleting
+    def self.remote_servers_for(service_name, version='*', region='Development')
+      if version != '*'
+        registered_implementers(service_name, version, region).map do |host|
+          service = host['Config']['ServiceAddr']
+          "#{service['IPAddress']}:#{service['Port']}"
+        end
+      else
+        # Find the highest version of any particular service
+        versions = {}
+        registered_implementers(service_name, version, region).each do |host|
+          service = host['Config']['ServiceAddr']
+          (versions[version.to_i] ||= []) << "#{service['IPAddress']}:#{service['Port']}"
+        end
+        # Return the servers implementing the highest version number
+        versions.sort.last.last
+      end
+    end
+
   end
 end

data/lib/ruby_skynet/server.rb

@@ -1,8 +1,4 @@
 require 'bson'
-require 'celluloid/io'
-
-# Replace Celluloid logger immediately upon loading the Server Instance
-Celluloid.logger = SemanticLogger::Logger.new('Celluloid')
 
 #
 # RubySkynet Server
@@ -11,92 +7,80 @@ Celluloid.logger = SemanticLogger::Logger.new('Celluloid')
 #
 module RubySkynet
   class Server
-    include Celluloid::IO
     include SemanticLogger::Loggable
 
-    # TODO Make Server instance based rather than class based. Then make instance global
-    @@hostname = nil
-    @@port     = 2000
-    @@region   = 'Development'
     @@server   = nil
+    @@services = ThreadSafe::Hash.new
 
-    def self.start
-      @@server ||= supervise(hostname, port)
+    # Start a single instance of the server
+    def self.start(region = 'Development', start_port = 2000, hostname = nil)
+      @@server ||= new(region, start_port, hostname)
     end
 
+    # Stop the single instance of the server
     def self.stop
-      @@server.terminate if @@server
+      @@server.finalize if @@server
       @@server = nil
     end
 
+    # Is the single instance of the server running
     def self.running?
       (@@server != nil) && @@server.running?
     end
 
-    # Region under which to register Skynet services
-    # Default: 'Development'
-    def self.region
-      @@region
-    end
-
-    def self.region=(region)
-      @@region = region
-    end
-
-    # Port to listen to requests on
-    # Default: 2000
-    def self.port
-      @@port
-    end
-
-    def self.port=(port)
-      @@port = port
-    end
-
-    # Override the hostname at which this server is running
-    # Useful when the service is behind a firewall or NAT device
-    def self.hostname=(hostname)
-      @@hostname = hostname
-    end
-
-    # Returns [String] hostname of the current server
-    def self.hostname
-      @@hostname ||= Socket.gethostname
-    end
-
-    @@services = ThreadSafe::Hash.new
-
     # Services currently loaded and available at this server when running
     def self.services
       @@services
     end
 
-    # Registers a Service Class as being available at this port
+    # Registers a Service Class as being available at this host and port
     def self.register_service(klass)
-      logger.debug "Registering Service: #{klass.name} with name: #{klass.service_name}"
+      raise InvalidServiceException.new("#{klass.inspect} is not a RubySkynet::Service") unless klass.respond_to?(:service_name) && klass.respond_to?(:service_version)
+
+      if previous_klass = @@services[klass.service_name] && (previous_klass.name != klass.name)
+        logger.warn("Service with name: #{klass.service_name} is already registered to a different implementation:#{previous_klass.name}")
+      end
       @@services[klass.service_name] = klass
-      register_service_in_doozer(klass) if running?
+      @@server.register_service(klass) if @@server
     end
 
-    # De-register service in doozer
+    # De-register service
     def self.deregister_service(klass)
-      RubySkynet::Registry.doozer_pool.with_connection do |doozer|
-        doozer.delete(klass.service_key) rescue nil
-      end
+      raise InvalidServiceException.new("#{klass.inspect} is not a RubySkynet::Service") unless klass.respond_to?(:service_name) && klass.respond_to?(:service_version)
+
+      @@server.deregister_service(klass) if @@server
       @@services.delete(klass.service_name)
     end
 
+    # The actual port the server is running at which will be different
+    # from Server.port if that port was already in use at startup
+    attr_reader :hostname, :port, :region
+
     # Start the server so that it can start taking RPC calls
     # Returns false if the server is already running
-    def initialize(host, port)
-      # Since we included Celluloid::IO, we're actually making a
-      # Celluloid::IO::TCPServer here
-      # TODO If port is in use, try the next port in sequence
-      @server = TCPServer.new(host, port)
-      async.run
+    def initialize(region = 'Development', start_port = 2000, hostname = nil)
+      hostname ||= Common.local_ip_address
+
+      # If port is in use, try the next port in sequence
+      port_count = 0
+      begin
+        @server   = ::TCPServer.new(hostname, start_port + port_count)
+        @hostname = hostname
+        @port     = start_port + port_count
+        @region   = region
+      rescue Errno::EADDRINUSE => exc
+        if port_count < 999
+          port_count += 1
+          retry
+        end
+        raise exc
+      end
+
+      # Start Server listener thread
+      Thread.new { run }
 
       # Register services hosted by this server
-      self.class.services.each_pair {|key, klass| self.class.register_service_in_doozer(klass)}
+      self.class.services.each_value {|klass| register_service(klass)}
     end
 
     def finalize
@@ -104,21 +88,25 @@ module RubySkynet
       logger.info "Skynet Server Stopped"
 
       # Deregister services hosted by this server
-      RubySkynet::Registry.doozer_pool.with_connection do |doozer|
-        self.class.services.each_value do |klass|
-          doozer.delete(klass.service_key) rescue nil
-        end
+      self.class.services.each_value do |klass|
+        deregister_service(klass) rescue nil
       end
-      logger.info "Skynet Services De-registered in Doozer"
+      logger.info "Skynet Services De-registered"
     end
 
     def run
-      logger.info("Starting listener on #{self.class.hostname}:#{self.class.port}")
+      logger.info("Starting listener on #{hostname}:#{port}")
       loop do
         logger.debug "Waiting for a client to connect"
         begin
-          async.handle_connection(@server.accept)
-        rescue Exception => exc
+          client = @server.accept
+          # We could use a thread pool here, but JRuby already does that
+          # and MRI threads are very light weight
+          Thread.new { handle_connection(client) }
+        rescue Errno::EBADF, IOError => exc
+          logger.info "TCPServer listener thread shutting down. #{exc.class}: #{exc.message}"
+          return
+        rescue ScriptError, NameError, StandardError, Exception => exc
           logger.error "Exception while processing connection request", exc
         end
       end
@@ -152,11 +140,11 @@ module RubySkynet
         break unless request
         params = BSON.deserialize(request['in'])
         logger.trace 'Parameters', params
+        
         reply = begin
           on_message(service_name, request['method'].to_sym, params)
-        rescue Exception => exc
+        rescue ScriptError, NameError, StandardError, Exception => exc
           logger.error "Exception while calling service: #{service_name}", exc
-          # TODO Return exception in header
           { :exception => {:message => exc.message, :class => exc.class.name} }
         end
 
@@ -173,6 +161,9 @@ module RubySkynet
           break
         end
       end
+    rescue ScriptError, NameError, StandardError, Exception => exc
+      logger.error "#handle_connection Exception", exc
+    ensure
       # Disconnect from the client
       client.close
       logger.debug "Disconnected from the client"
@@ -186,37 +177,28 @@ module RubySkynet
     ############################################################################
     protected
 
-    # Register the supplied service in doozer
-    def self.register_service_in_doozer(klass)
-      config = {
-        "Config" => {
-          "UUID"    => "#{Server.hostname}:#{Server.port}-#{$$}-#{klass.name}-#{klass.object_id}",
-          "Name"    => klass.service_name,
-          "Version" => klass.service_version.to_s,
-          "Region"  => Server.region,
-          "ServiceAddr" => {
-            "IPAddress" => Server.hostname,
-            "Port"      => Server.port,
-            "MaxPort"   => Server.port + 999
-          },
-        },
-        "Registered" => true
-      }
-      RubySkynet::Registry.doozer_pool.with_connection do |doozer|
-        doozer[klass.service_key] = MultiJson.encode(config)
-      end
+    # Registers a Service Class as being available at this server
+    def register_service(klass)
+      logger.debug "Registering Service: #{klass.name} with name: #{klass.service_name}"
+      Registry.register_service(klass.service_name, klass.service_version, @region, @hostname, @port)
+    end
+
+    # De-register service from this server
+    def deregister_service(klass)
+      logger.debug "De-registering Service: #{klass.name} with name: #{klass.service_name}"
+      Registry.deregister_service(klass.service_name, klass.service_version, @region, @hostname, @port)
     end
 
     # Called for each message received from the client
     # Returns a Hash that is sent back to the caller
     def on_message(service_name, method, params)
-      logger.benchmark_debug "Called: #{service_name}##{method}" do
+      logger.benchmark_info("Skynet Call: #{service_name}##{method}") do
         logger.trace "Method Call: #{method} with parameters:", params
         klass = Server.services[service_name]
         raise "Invalid Skynet RPC call, service: #{service_name} is not available at this server" unless klass
+        # TODO Use pool of services
         service = klass.new
         raise "Invalid Skynet RPC call, method: #{method} does not exist for service: #{service_name}" unless service.respond_to?(method)
-        # TODO Use pool of services, or Celluloid here
         service.send(method, params)
       end
     end

data/lib/ruby_skynet/service.rb

@@ -29,27 +29,23 @@ module RubySkynet
       # Name of this service to Register with Skynet
       # Default: class name
       def service_name
-        @@service_name ||= name.gsub('::', '.')
+        @service_name ||= name.gsub('::', '.')
       end
 
       def service_name=(service_name)
-        @@service_name = service_name
+        @service_name = service_name
       end
 
       # Version of this service to register with Skynet, defaults to 1
       # Default: 1
       def service_version
-        @@service_version ||= 1
+        @service_version ||= 1
       end
 
       def service_version=(service_version)
-        @@service_version = service_version
+        @service_version = service_version
       end
 
-      # Key by which this service is known in the doozer registry
-      def service_key
-        "/services/#{service_name}/#{service_version}/#{Server.region}/#{Server.hostname}/#{Server.port}"
-      end
     end
 
   end

data/lib/ruby_skynet/version.rb

@@ -1,3 +1,3 @@
 module RubySkynet #:nodoc
-  VERSION = "0.4.0.pre2"
+  VERSION = "0.4.0"
 end

data/test/{ruby_skynet_client_test.rb → client_test.rb}

@@ -6,8 +6,6 @@ require 'rubygems'
 require 'test/unit'
 require 'shoulda'
 require 'ruby_skynet'
-require 'simple_server'
-require 'multi_json'
 
 # Register an appender if one is not already registered
 if SemanticLogger::Logger.appenders.size == 0
@@ -15,8 +13,33 @@ if SemanticLogger::Logger.appenders.size == 0
   SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
 end
 
+class ClientTestService
+  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
+
 # Unit Test for ResilientSocket::TCPClient
-class RubySkynetClientTest < Test::Unit::TestCase
+class ClientTest < Test::Unit::TestCase
   context RubySkynet::Client do
 
     context "without server" do
@@ -32,41 +55,17 @@ class RubySkynetClientTest < Test::Unit::TestCase
 
     context "with server" do
       setup do
-        @port = 2000
-        @read_timeout = 3.0
-        @server = SimpleServer.new(@port)
-        @server_name = "localhost:#{@port}"
+        @region = 'ClientTest'
+        RubySkynet::Server.start(@region)
 
-        # Register service in doozer
-        @service_name = "TestService"
+        @service_name = 'ClientTestService'
         @version = 1
-        @region = 'Test'
-        @ip_address = "127.0.0.1"
-        config = {
-          "Config" => {
-            "UUID" => "3978b371-15e9-40f8-9b7b-59ae88d8c7ec",
-            "Name" => @service_name,
-            "Version" => @version.to_s,
-            "Region" => @region,
-            "ServiceAddr" => {
-              "IPAddress" => @ip_address,
-              "Port" => @port,
-              "MaxPort" => @port + 999
-            },
-          },
-          "Registered" => true
-        }
-        RubySkynet::Registry.doozer_pool.with_connection do |doozer|
-          doozer["/services/#{@service_name}/#{@version}/#{@region}/#{@ip_address}/#{@port}"] = MultiJson.encode(config)
-        end
+
+        @read_timeout = 3.0
       end
 
       teardown do
-        @server.terminate if @server
-        # De-register server in doozer
-        RubySkynet::Registry.doozer_pool.with_connection do |doozer|
-          doozer.delete("/services/#{@service_name}/#{@version}/#{@region}/#{@ip_address}/#{@port}") rescue nil
-        end
+        RubySkynet::Server.stop
       end
 
       context "with client connection" do

data/test/registry_test.rb

@@ -0,0 +1,99 @@
+# Allow test to be run in-place without requiring a gem install
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha/setup'
+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
+
+# Unit Test
+class RegistryTest < Test::Unit::TestCase
+  context 'RubySkynet::Service' do
+
+    setup do
+      @service_name = 'MyRegistryService'
+      @version      = 5
+      @region       = 'RegistryTest'
+      @hostname     = '127.0.0.1'
+      @port         = 2100
+      @service_key  = "/services/#{@service_name}/#{@version}/#{@region}/#{@hostname}/#{@port}"
+    end
+
+    context "without a registered service" do
+      should "not be in doozer" do
+        RubySkynet::Registry.send(:doozer_pool).with_connection do |doozer|
+          assert_equal '', doozer[@service_key]
+        end
+      end
+    end
+
+    context "with a registered service" do
+      setup do
+        RubySkynet::Registry.register_service(@service_name, @version, @region, @hostname, @port)
+        # Allow time for doozer callback that service was registered
+        sleep 0.1
+      end
+
+      teardown do
+        RubySkynet::Registry.deregister_service(@service_name, @version, @region, @hostname, @port)
+        # Allow time for doozer callback that service was deregistered
+        sleep 0.1
+        # No servers should be in the local registry
+        assert_equal nil, RubySkynet::Registry.servers_for(@service_name, @version, @region)
+      end
+
+      should "find server using exact match" do
+        assert servers = RubySkynet::Registry.servers_for(@service_name, @version, @region)
+        assert_equal 1, servers.size
+        assert_equal "#{@hostname}:#{@port}", servers.first
+      end
+
+      should "find server using * version match" do
+        assert servers = RubySkynet::Registry.servers_for(@service_name, '*', @region)
+        assert_equal 1, servers.size
+        assert_equal "#{@hostname}:#{@port}", servers.first
+      end
+
+      should "return nil when service not found" do
+        assert_equal nil, RubySkynet::Registry.servers_for('MissingService', @version, @region)
+      end
+
+      should "return nil when version not found" do
+        assert_equal nil, RubySkynet::Registry.servers_for(@service_name, @version+1, @region)
+      end
+
+      should "return nil when region not found" do
+        assert_equal nil, RubySkynet::Registry.servers_for(@service_name, @version, 'OtherRegion')
+      end
+
+      should "be in doozer" do
+        RubySkynet::Registry.send(:doozer_pool).with_connection do |doozer|
+          assert_equal true, doozer[@service_key].length > 20
+        end
+      end
+    end
+
+    context "scoring" do
+      [
+        ['192.168.11.0',  4 ],
+        ['192.168.11.10', 3 ],
+        ['192.168.10.0',  2 ],
+        ['192.5.10.0',    1 ],
+        ['10.0.11.0',     0 ],
+      ].each do |test|
+        should "handle score #{test[1]}" do
+          RubySkynet::Common.stubs(:local_ip_address).returns("192.168.11.0")
+          assert_equal test[1], RubySkynet::Registry.score_for_server(test[0]), "Local: #{RubySkynet::Common.local_ip_address} Server: #{test[0]} Score: #{test[1]}"
+        end
+      end
+    end
+
+  end
+end

data/test/{ruby_skynet_service_test.rb → service_test.rb}

@@ -12,10 +12,6 @@ if SemanticLogger::Logger.appenders.size == 0
   SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
 end
 
-RubySkynet::Server.port = 2100
-RubySkynet::Server.region = 'Test'
-RubySkynet::Server.hostname = '127.0.0.1'
-
 class TestService
   include RubySkynet::Service
 
@@ -25,38 +21,34 @@ class TestService
   def echo(params)
     params
   end
+
+  def exception_test(params)
+    raise "Exception message"
+  end
 end
 
 # Unit Test for ResilientSocket::TCPClient
-class RubySkynetServiceTest < Test::Unit::TestCase
+class ServiceTest < Test::Unit::TestCase
   context 'RubySkynet::Service' do
     context "with server" do
       setup do
-        RubySkynet::Server.start
+        @region = 'Test'
         @service_name = 'TestService'
         @version = 1
-        @region = 'Test'
-        @doozer_key = "/services/#{@service_name}/#{@version}/#{@region}/127.0.0.1/2100"
+        RubySkynet::Server.start(@region)
+        sleep 0.2
       end
 
       teardown do
-        begin
-          RubySkynet::Server.stop
-        rescue Celluloid::DeadActorError
-        end
+        RubySkynet::Server.stop
+        SemanticLogger::Logger.flush
       end
 
-      should "have correct service key" do
-        assert_equal @doozer_key, TestService.service_key
+      should "be running" do
+        assert_equal true, RubySkynet::Server.running?
       end
 
-      should "register service" do
-        RubySkynet::Registry.doozer_pool.with_connection do |doozer|
-          assert_equal true, doozer[@doozer_key].length > 20
-        end
-      end
-
-      context "calling with a client" do
+      context "using a client" do
         setup do
           @client = RubySkynet::Client.new(@service_name, @version, @region)
         end
@@ -66,6 +58,13 @@ class RubySkynetServiceTest < Test::Unit::TestCase
           assert_equal 'some', reply.keys.first
           assert_equal 'parameters', reply.values.first
         end
+
+        # Cellulloid 0.13.0.pre2 is doing something weird here and preventing the
+        # Server from receiving the exception
+        should "handle service exceptions" do
+          reply = @client.call(:exception_test, 'some' => 'parameters')
+          assert_equal "Exception message", reply['exception']['message']
+        end
       end
 
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_skynet
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre2
+  version: 0.4.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-19 00:00:00.000000000 Z
+date: 2013-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -80,20 +80,6 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: celluloid-io
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.13.0.pre2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 0.13.0.pre2
 description: Ruby Client for invoking Skynet services
 email:
 - reidmo@gmail.com
@@ -122,10 +108,10 @@ files:
 - lib/ruby_skynet/service.rb
 - lib/ruby_skynet/version.rb
 - test.sh
+- test/client_test.rb
 - test/doozer_client_test.rb
-- test/ruby_skynet_client_test.rb
-- test/ruby_skynet_service_test.rb
-- test/simple_server.rb
+- test/registry_test.rb
+- test/service_test.rb
 homepage: https://github.com/ClarityServices/ruby_skynet
 licenses:
 - Apache License V2.0
@@ -141,9 +127,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.2

data/test/simple_server.rb

@@ -1,122 +0,0 @@
-require 'rubygems'
-require 'socket'
-require 'bson'
-require 'semantic_logger'
-require 'celluloid/io'
-
-# This a simple stand-alone server that does not use the Skynet code so that
-# the Skynet code can be tested
-
-# Simple single threaded server for testing purposes using a local socket
-# Sends and receives BSON Messages
-class SimpleServer
-  include Celluloid::IO
-
-  def initialize(port)
-    # Since we included Celluloid::IO, we're actually making a
-    # Celluloid::IO::TCPServer here
-    @server = TCPServer.new('127.0.0.1', port)
-    @logger = SemanticLogger::Logger.new(self.class)
-    async.run
-  end
-
-  def run
-    loop do
-      @logger.debug "Waiting for a client to connect"
-      async.handle_connection(@server.accept)
-    end
-  end
-
-  def finalize
-    @server.close if @server
-  end
-
-  # Called for each message received from the client
-  # Returns a Hash that is sent back to the caller
-  def on_message(method, params)
-    case method
-    when 'test1'
-      { 'result' => 'test1' }
-    when 'sleep'
-      sleep params['duration'] || 1
-      { 'result' => 'sleep' }
-    when 'fail'
-      if params['attempt'].to_i >= 2
-        { 'result' => 'fail' }
-      else
-        nil
-      end
-    else
-      { 'result' => "Unknown method: #{method}" }
-    end
-  end
-
-  # Called for each client connection
-  def handle_connection(client)
-    @logger.debug "Client connected, waiting for data from client"
-
-    # Process handshake
-    handshake = {
-      'registered' => true,
-      'clientid' => '123'
-    }
-    client.write(BSON.serialize(handshake).to_s)
-    read_bson_document(client)
-
-    while(header = read_bson_document(client)) do
-      @logger.debug "\n******************"
-      @logger.debug "Received Request"
-      @logger.trace 'Header', header
-
-      request = read_bson_document(client)
-      @logger.trace 'Request', request
-      break unless request
-
-      if reply = on_message(request['method'], BSON.deserialize(request['in']))
-        @logger.debug "Sending Header"
-        # For this test we just send back the received header
-        client.write(BSON.serialize(header).to_s)
-
-        @logger.debug "Sending Reply"
-        @logger.trace 'Reply', reply
-        client.write(BSON.serialize({'out' => BSON.serialize(reply).to_s}).to_s)
-      else
-        @logger.debug "Closing client since no reply is being sent back"
-        @server.close
-        client.close
-        @logger.debug "Server closed"
-        async.run
-        @logger.debug "Server Restarted"
-        break
-      end
-    end
-    # Disconnect from the client
-    client.close
-    @logger.debug "Disconnected from the client"
-  end
-
-  # Read the bson document, returning nil if the IO is closed
-  # before receiving any data or a complete BSON document
-  def read_bson_document(io)
-    bytebuf = BSON::ByteBuffer.new
-    # Read 4 byte size of following BSON document
-    bytes = io.read(4)
-    return unless bytes
-    # Read BSON document
-    sz = bytes.unpack("V")[0]
-    bytebuf.append!(bytes)
-    bytes = io.read(sz-4)
-    return unless bytes
-    bytebuf.append!(bytes)
-    return BSON.deserialize(bytebuf)
-  end
-
-end
-
-if $0 == __FILE__
-  SemanticLogger::Logger.default_level = :trace
-  SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new(STDOUT)
-  Celluloid.logger = SemanticLogger::Logger.new('Celluloid')
-  server = SimpleServer.new(2000)
-  server.thread.join
-end