ruby_skynet 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f15ead62305cae332e890c1ad63a3f11e9085ffe
-  data.tar.gz: aa3243ae8229d4cd7a5f82ac673fd3e7cc700b17
+  metadata.gz: 5e4070e64ce70f32032c82eee9e6af0eaa94626c
+  data.tar.gz: 62ff2d291f403ac51406e17ead44a3f5feacd120
 SHA512:
-  metadata.gz: 363ed46b3ee9182fa572fb00724031f01d077600a304ac3d38ccbbb023b3c33ff25872c72b9eeb7c130e4784ce9c6c2ff807a9c522d391ef31a8de9564fdd7e3
-  data.tar.gz: 4eeb6d97725af7fb087e40afbc8b8d459c8889b84c1d4b1756885eedc3322adbf22a5afd89d44c97ad456e7441e0dd09fb90007c1a28204835638ab1e9404faf
+  metadata.gz: 66559b704a0e6f1f73967e555d23c6f3eb975c58059324cb9f06944b4eff65ae22105ce1a28f4e7533d9cdb9a84d3f20de391dce860c2aa0a58bc935a28fbf88
+  data.tar.gz: 17d54811347c21ff8c20a174923ce96469e05ed56c9603abef0d1a3374eda8a80e1536cb3f35cbc07746ccfae7b9dac9afb126eb7630e900024fea863ae26687

data/Gemfile

@@ -2,18 +2,19 @@ source :rubygems
 
 group :test do
   gem "shoulda"
-  gem "mocha", :require => false
 end
 
 gem "rake"
 gem "semantic_logger"
 gem "resilient_socket"
+# Doozer Client
+gem "ruby_doozer"
 # Thread Safe Hash and Array
 gem "thread_safe"
+# Connection pool
 gem "gene_pool"
 # For looking up Service entries in Doozer
 gem "multi_json"
-gem "ruby_protobuf"
 # Wire format when communicating with services
 gem "bson"
 gem "bson_ext", :platform => :ruby

data/Gemfile.lock

@@ -4,8 +4,8 @@ GEM
     activesupport (3.2.13)
       i18n (= 0.6.1)
       multi_json (~> 1.0)
-    atomic (1.0.1)
-    atomic (1.0.1-java)
+    atomic (1.0.2)
+    atomic (1.0.2-java)
     bourne (1.4.0)
       mocha (~> 0.13.2)
     bson (1.8.3)
@@ -21,6 +21,11 @@ GEM
     rake (10.0.3)
     resilient_socket (0.4.0)
       semantic_logger
+    ruby_doozer (0.4.0)
+      gene_pool
+      resilient_socket
+      ruby_protobuf
+      semantic_logger
     ruby_protobuf (0.4.11)
     semantic_logger (2.0.0)
       sync_attr
@@ -44,11 +49,10 @@ DEPENDENCIES
   bson
   bson_ext
   gene_pool
-  mocha
   multi_json
   rake
   resilient_socket
-  ruby_protobuf
+  ruby_doozer
   semantic_logger
   shoulda
   thread_safe

data/Rakefile

@@ -24,12 +24,12 @@ 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'
-    spec.add_dependency 'resilient_socket'
+    spec.add_dependency 'semantic_logger', '>= 2.0.0'
+    spec.add_dependency 'resilient_socket', '>= 0.4.0'
     spec.add_dependency 'multi_json', '>= 1.6.1'
-    spec.add_dependency 'bson'
-    spec.add_dependency 'ruby_protobuf'
-    spec.add_dependency 'gene_pool'
+    spec.add_dependency 'bson', '>= 1.5.2'
+    spec.add_dependency 'ruby_doozer', '>= 0.5.0'
+    spec.add_dependency 'gene_pool', '>= 1.3.0'
   end
   Gem::Package.build gemspec
 end

data/examples/echo_server.rb

@@ -7,10 +7,6 @@ require 'ruby_skynet'
 SemanticLogger::Logger.default_level = :trace
 SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('echo_server.log')
 
-# Specify Port and Hostname to listen for requests on
-RubySkynet::Server.port = 2020
-RubySkynet::Server.hostname = '127.0.0.1'
-
 # Just echo back any parameters received when the echo method is called
 class EchoService
   include RubySkynet::Service

data/lib/rails/generators/ruby_skynet/config/templates/ruby_skynet.yml

@@ -1,10 +1,10 @@
 # Ruby Skynet Client & Server Configuration Parameters
 #   :region [String]
-#     Region name to use for service lookup
+#     Region name to use for service lookups
 #     Default: Rails.env
 #
 #   :services_path [String]
-#     Path within to look for service implementations that will be loaded
+#     Path within which to look for service implementations that will be loaded
 #     when RubySkynet::Server.load_services is called
 #
 #   :server_port [Integer]
@@ -53,6 +53,10 @@
 #           Randomly select a server from the list every time a connection
 #           is established, including during automatic connection recovery.
 #         Default: :ordered
+#
+#     :pool_size [Integer]
+#       Maximum size of the connection pool to doozer
+#       Default: 10
 defaults: &defaults
   :services_path: app/services
   :server_port:   2000
@@ -64,6 +68,11 @@ defaults: &defaults
     :connect_retry_count:    10
     :connect_retry_interval: 0.5
     :server_selector:        :random
+    # Doozer Connection Pool settings
+    :pool_size:              10
+    :pool_timeout:           30
+    :pool_warn_timeout:      2
+    :pool_idle_timeout:      600
 
 development:
   <<: *defaults

data/lib/ruby_skynet/client.rb

@@ -61,7 +61,7 @@ module RubySkynet
           retries = 0
           # If it cannot connect to a server, try a different server
           begin
-            Connection.with_connection(Registry.server_for(@skynet_name, @version, @region), connection_params) do |connection|
+            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)
             end
           rescue ResilientSocket::ConnectionFailure => exc

data/lib/ruby_skynet/common.rb

@@ -1,3 +1,4 @@
+require 'bson'
 require 'socket'
 
 module RubySkynet

data/lib/ruby_skynet/connection.rb

@@ -5,7 +5,7 @@ require 'resilient_socket'
 require 'sync_attr'
 
 #
-# RubySkynet Connection
+# RubySkynet Client Connection
 #
 # Handles connecting to Skynet Servers as a host:port pair
 #
@@ -237,7 +237,7 @@ module RubySkynet
       end
 
       # Cleanup corresponding connection pool when a server terminates
-      Registry.on_server_removed(server) do
+      RubySkynet.services.on_server_removed(server) do
         pool = @@connection_pools.delete(server)
         # Cannot close all the connections since they could still be in use
         pool.remove_idle(0) if pool

data/lib/ruby_skynet/railties/ruby_skynet.rake

@@ -16,7 +16,7 @@ namespace :ruby_skynet do
     end
 
     # Connect to doozer
-    RubySkynet::Registry.service_registry
+    RubySkynet.services
 
     RubySkynet::Server.load_services
 

data/lib/ruby_skynet/ruby_skynet.rb

@@ -1,4 +1,7 @@
+require 'sync_attr'
+
 module RubySkynet
+  include SyncAttr
 
   # Returns the default region for all Ruby Skynet Clients and Services
   def self.region
@@ -42,6 +45,50 @@ module RubySkynet
     @@local_ip_address = local_ip_address
   end
 
+  # Returns the services registry consisting of service names
+  # and the hosts on which they are running
+  sync_cattr_reader :services do
+    ServiceRegistry.new(
+      :root_path => "/services",
+      :doozer    => doozer_config
+    )
+  end
+
+  # Default doozer configuration
+  # To replace this default, set the config as follows:
+  #    RubySkynet::Client.doozer_config = { .... }
+  #
+  #   :servers [Array of String]
+  #     Array of URL's of doozer servers to connect to with port numbers
+  #     ['server1:2000', 'server2:2000']
+  #
+  #     The second server will only be attempted once the first server
+  #     cannot be connected to or has timed out on connect
+  #     A read failure or timeout will not result in switching to the second
+  #     server, only a connection failure or during an automatic reconnect
+  #
+  #   :read_timeout [Float]
+  #     Time in seconds to timeout on read
+  #     Can be overridden by supplying a timeout in the read call
+  #
+  #   :connect_timeout [Float]
+  #     Time in seconds to timeout when trying to connect to the server
+  #
+  #   :connect_retry_count [Fixnum]
+  #     Number of times to retry connecting when a connection fails
+  #
+  #   :connect_retry_interval [Float]
+  #     Number of seconds between connection retry attempts after the first failed attempt
+  sync_cattr_accessor :doozer_config do
+    {
+      :servers                => ['127.0.0.1:8046'],
+      :read_timeout           => 5,
+      :connect_timeout        => 3,
+      :connect_retry_interval => 1,
+      :connect_retry_count    => 30
+    }
+  end
+
   # Load the Encryption Configuration from a YAML file
   #  filename:
   #    Name of file to read.
@@ -61,7 +108,7 @@ module RubySkynet
     RubySkynet.services_path = cfg.delete(:services_path) if [:services_path]
     RubySkynet.server_port = cfg.delete(:server_port) if [:server_port]
     RubySkynet.local_ip_address = cfg.delete(:local_ip_address) if [:local_ip_address]
-    RubySkynet::Registry.doozer_config = cfg.delete(:doozer) if [:doozer]
+    RubySkynet.doozer_config = cfg.delete(:doozer) if [:doozer]
 
     cfg.each_pair {|k,v| RubySkynet::Server.logger.warn "Ignoring unknown RubySkynet config option #{k} => #{v}"}
   end

data/lib/ruby_skynet/server.rb

@@ -1,4 +1,4 @@
-require 'bson'
+require 'thread_safe'
 
 #
 # RubySkynet Server
@@ -206,13 +206,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}"
-      Registry.register_service(klass.skynet_name, klass.skynet_version || 1, klass.skynet_region, @hostname, @port)
+      ::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}"
-      Registry.deregister_service(klass.skynet_name, klass.skynet_version || 1, klass.skynet_region, @hostname, @port)
+      ::RubySkynet.services.deregister_service(klass.skynet_name, klass.skynet_version || 1, klass.skynet_region, @hostname, @port)
     end
 
     # Called for each message received from the client

data/lib/ruby_skynet/service_registry.rb

@@ -0,0 +1,248 @@
+require 'sync_attr'
+require 'multi_json'
+require 'thread_safe'
+require 'gene_pool'
+require 'resolv'
+require 'ruby_doozer'
+
+#
+# RubySkynet Sevices Registry
+#
+# Based on the Skynet Services Registry, obtains and keeps up to date a list of
+# all services and which servers they are available on.
+#
+module RubySkynet
+  class ServiceRegistry < RubyDoozer::Registry
+    include SyncAttr
+    include SemanticLogger::Loggable
+
+    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, local_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(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
+
+    # Create a service registry
+    # See: RubyDoozer::Registry for the parameters
+    def initialize(params)
+      super
+
+      # Registry has the following format
+      #  Key: [String] 'name/version/region'
+      #  Value: [Array<String>] 'host:port', 'host:port'
+      @registry = ThreadSafe::Hash.new
+
+      path = "#{@root_path}/**"
+      doozer_pool.with_connection do |doozer|
+        @current_revision = doozer.current_revision
+        # Fetch all the configuration information from Doozer and set the internal copy
+        doozer.walk(path, @current_revision) do |path, value|
+          service_info_changed(relative_path(path), value)
+        end
+      end
+
+      # Start monitoring thread
+      monitor_thread
+
+      # Register Callbacks
+      on_update {|path, value| service_info_changed(path, value) }
+      on_delete {|path, value| service_info_changed(path) }
+    end
+
+    # Returns the Service Registry as a Hash
+    def to_h
+      @registry.dup
+    end
+
+    # Register the supplied service at this Skynet Server host and Port
+    def 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
+      }
+      self["#{name}/#{version}/#{region}/#{hostname}/#{port}"] = MultiJson.encode(config)
+    end
+
+    # Deregister the supplied service from the Registry
+    def deregister_service(name, version, region, hostname, port)
+      delete("#{name}/#{version}/#{region}/#{hostname}/#{port}")
+    end
+
+    # Return a server that implements the specified service
+    def server_for(name, version='*', region='Development')
+      if servers = servers_for(name, version, region)
+        # Randomly select one of the servers offering the service
+        servers[rand(servers.size)]
+      else
+        msg = "No servers available for service: #{name} with version: #{version} in region: #{region}"
+        logger.warn msg
+        raise ServiceUnavailable.new(msg)
+      end
+    end
+
+    # Returns [Array<String>] a list of servers implementing the requested service
+    def servers_for(name, version='*', region='Development')
+      if version == '*'
+        # Find the highest version for the named service in this region
+        version = -1
+        @registry.keys.each do |key|
+          if match = key.match(/#{name}\/(\d+)\/#{region}/)
+            ver = match[1].to_i
+            version = ver if ver > version
+          end
+        end
+      end
+      if server_infos = @registry["#{name}/#{version}/#{region}"]
+        server_infos.first.servers
+      end
+    end
+
+    # Invokes registered callbacks when a specific server is shutdown or terminates
+    # Not when a server de-registers itself
+    # The callback will only be called once and will need to be re-registered
+    # after being called if future callbacks are required for that server
+    def on_server_removed(server, &block)
+      ((@on_server_removed_callbacks ||= ThreadSafe::Hash.new)[server] ||= ThreadSafe::Array.new) << block
+    end
+
+    ############################
+    protected
+
+    # Service information changed in doozer, so update internal registry
+    def service_info_changed(path, value=nil)
+      # path: "TutorialService/1/Development/127.0.0.1/9000"
+      e = path.split('/')
+
+      # Key: [String] 'name/version/region'
+      key = "#{e[0]}/#{e[1]}/#{e[2]}"
+      hostname, port = e[3], e[4]
+
+      if value
+        entry = MultiJson.load(value)
+        if entry['Registered']
+          add_server(key, hostname, port)
+        else
+          # Service just de-registered
+          remove_server(key, hostname, port, false)
+        end
+      else
+        # Service has stopped and needs to be removed
+        remove_server(key, hostname, port, true)
+      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] "<name>/<version>/<region>"
+    #   value: [ServiceInfo, ServiceInfo]
+    #          Sorted by highest score first
+
+    # 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)
+
+      # If already present, then nothing to do
+      server_info = server_infos.find{|si| si.servers.include?(server)}
+      return server_info if server_info
+
+      # Look for the same score with a different server
+      score = self.class.score_for_server(hostname, RubySkynet.local_ip_address)
+      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 remove_server(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
+
+    # Invoke any registered callbacks for the specific server
+    def server_removed(server)
+      if @on_server_removed_callbacks && (callbacks = @on_server_removed_callbacks.delete(server))
+        callbacks.each do |block|
+          begin
+            logger.info "Calling callback for server: #{server}"
+            block.call(server)
+          rescue Exception => exc
+            logger.error("Exception during a callback for server: #{server}", exc)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/ruby_skynet/version.rb

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

data/lib/ruby_skynet.rb

@@ -2,17 +2,16 @@ require 'semantic_logger'
 require 'ruby_skynet/exceptions'
 require 'ruby_skynet/version'
 require 'ruby_skynet/ruby_skynet'
+require 'ruby_doozer'
+
 module RubySkynet
-  module Doozer
-    autoload :Client,   'ruby_skynet/doozer/client'
-  end
-  autoload :Registry,   'ruby_skynet/registry'
-  autoload :Connection, 'ruby_skynet/connection'
-  autoload :Base,       'ruby_skynet/base'
-  autoload :Common,     'ruby_skynet/common'
-  autoload :Client,     'ruby_skynet/client'
-  autoload :Service,    'ruby_skynet/service'
-  autoload :Server,     'ruby_skynet/server'
+  autoload :Base,            'ruby_skynet/base'
+  autoload :Common,          'ruby_skynet/common'
+  autoload :Connection,      'ruby_skynet/connection'
+  autoload :Client,          'ruby_skynet/client'
+  autoload :Service,         'ruby_skynet/service'
+  autoload :Server,          'ruby_skynet/server'
+  autoload :ServiceRegistry, 'ruby_skynet/service_registry'
 end
 
 if defined?(Rails)

data/test/client_test.rb

@@ -58,6 +58,8 @@ class ClientTest < Test::Unit::TestCase
         @region = 'ClientTest'
         RubySkynet.region = @region
         RubySkynet::Server.start
+        # Give doozer time to push out the presence of the service above
+        sleep 0.1
 
         @service_name = 'ClientTestService'
         @version = 1