ruby_skynet 1.3.0.alpha3 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6740cfd40beae05bf039e9bd5fa02281cf6a5e8a
-  data.tar.gz: 4fe0295d46526174f6756a505982a9e67d6cd127
+  metadata.gz: bf65f91389e27d97e04be4be8a1ef49700bb245b
+  data.tar.gz: 6b26fea72828375f49fff798c931744951747698
 SHA512:
-  metadata.gz: f49f801c0796148c2269a6a82db40980f8bbf6542bffd7bd9b448aebda4497c7a316a4d7a7a9ba512898234221bcb51e634ddd91d67d631ea7ed751b9f35fd22
-  data.tar.gz: 1420af0774b7404a1fdc227ff64d64300d214f4b505b17cacba14d56ddde5147a46259fd1067d15dc18940c785caba230552742a8ac0636eb893b0665d03829f
+  metadata.gz: 20a409544353b4634fde2fb83595e0998ef808383591ad08692bf5422d6bbf07995e1bf781b5a698ceeb7d1e1ec18d840eb8ef98b9f6939d27273a8c9324574c
+  data.tar.gz: 8b049acd60bc68157ee6c632d7f44273fa366199c6bacbd6a0ef703c02d56190f1a1cec7471957452c453d07fd99a426efdba7842e6ca51383dc2abcaff6150a

data/lib/ruby_skynet.rb

@@ -2,10 +2,8 @@ require 'semantic_logger'
 require 'ruby_skynet/exceptions'
 require 'ruby_skynet/version'
 require 'ruby_skynet/ruby_skynet'
-require 'ruby_skynet/zookeeper'
 
 module RubySkynet
-  autoload :Base,            'ruby_skynet/base'
   autoload :Common,          'ruby_skynet/common'
   autoload :Connection,      'ruby_skynet/connection'
   autoload :Client,          'ruby_skynet/client'
@@ -31,18 +29,14 @@ module RubySkynet
     begin
       require 'ruby_doozer'
       require 'ruby_skynet/doozer/service_registry'
-
-      # Shortcuts to loaded Registry classes
-      ServiceRegistry = RubySkynet::Doozer::ServiceRegistry
-      CachedRegistry  = Doozer::CachedRegistry
-      Registry        = Doozer::Registry
     rescue LoadError
-      require 'ruby_skynet/static_service_registry'
-
-      # Use Static Service Registry
-      ServiceRegistry = RubySkynet::StaticServiceRegistry
+      raise LoadError, "Load either the 'zookeeper' or 'ruby_doozer' gem prior to loading RubySkynet. 'zookeeper' is preferred"
     end
 
+    # Shortcuts to loaded Registry classes
+    ServiceRegistry = RubySkynet::Doozer::ServiceRegistry
+    CachedRegistry  = Doozer::CachedRegistry
+    Registry        = Doozer::Registry
   end
 end
 

data/lib/ruby_skynet/client.rb

@@ -8,8 +8,9 @@ require 'bson'
 #
 module RubySkynet
   class Client
-    include Base
+    include Common
 
+    # Allows this instance of the client to use different versions or regions.
     attr_reader :skynet_name, :skynet_version, :skynet_region
 
     # Version of the Skynet service to use
@@ -83,14 +84,20 @@ 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
-
-      # Obtain list of servers implementing this service in order of priority
-      servers = ::RubySkynet.service_registry.servers_for(skynet_name, skynet_version, skynet_region)
-
       logger.tagged request_id do
         logger.benchmark_info "Called Skynet Service: #{skynet_name}.#{method_name}" do
-          Connection.with_connection(servers, connection_params) do |connection|
-            connection.rpc_call(request_id, skynet_name, method_name, parameters)
+          retries = 0
+          # If it cannot connect to a server, try a different server
+          begin
+            Connection.with_connection(::RubySkynet.service_registry.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)
+              retries += 1
+              retry
+            end
+            # TODO rescue ServiceUnavailable retry x times until the service becomes available
           end
         end
       end
@@ -104,7 +111,7 @@ module RubySkynet
       #
       # 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)
+      if !result.nil? && result[:exception].nil? && !self.class.method_defined?(method)
         self.class.send(:define_method, method) {|*args| call(method, *args)}
       end
       result

data/lib/ruby_skynet/common.rb

@@ -1,28 +1,28 @@
-require 'bson'
+require 'stringio'
 require 'socket'
+require 'semantic_logger'
+require 'bson'
 
 module RubySkynet
   module Common
 
+    BINARY_ENCODING = Encoding.find("binary")
+
     # Returns a BSON document read from the socket.
     # Returns nil if the operation times out or if a network
     #         connection failure occurs
     def self.read_bson_document(socket)
-      bytebuf = BSON::ByteBuffer.new
       # Read 4 byte size of following BSON document
-      bytes = socket.read(4)
-
-      # No more data
-      return unless bytes
+      if bytes = socket.read(4)
+        bytes.force_encoding(BINARY_ENCODING)
+        # Read BSON document
+        sz = bytes.unpack("V")[0]
+        raise "Invalid Data received from server:#{bytes.inspect}" unless sz
 
-      # Read BSON document
-      sz = bytes.unpack("V")[0]
-      raise "Invalid Data received from server:#{bytes.inspect}" unless sz
-
-      bytebuf.append!(bytes)
-      bytebuf.append!(socket.read(sz - 4))
-      raise "Socket is not returning #{sz} requested bytes. #{bytebuf.length} bytes returned" unless sz == bytebuf.length
-      return BSON.deserialize(bytebuf)
+        bytes << socket.read(sz - 4)
+        raise "Socket is not returning #{sz} requested bytes. #{bytes.length} bytes returned" unless sz == bytes.length
+        Hash.from_bson(StringIO.new(bytes))
+      end
     end
 
     # Returns the local ip address being used by this machine to talk to the
@@ -31,5 +31,45 @@ module RubySkynet
       @@local_ip_address ||= ::UDPSocket.open {|s| s.connect(remote_ip, 1); s.addr.last }
     end
 
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_eval do
+        include SemanticLogger::Loggable
+      end
+    end
+
+    module ClassMethods
+      # Name of this service to Register with Skynet
+      # Default: class name
+      def skynet_name
+        @skynet_name ||= name.gsub('::', '.')
+      end
+
+      def skynet_name=(skynet_name)
+        @skynet_name = skynet_name
+      end
+
+      # Version of this service to register with Skynet
+      # Default: nil
+      def skynet_version
+        @skynet_version ||= nil
+      end
+
+      def skynet_version=(skynet_version)
+        @skynet_version = skynet_version
+      end
+
+      # Region within which this service is defined
+      # Default: RubySkynet.region
+      def skynet_region
+        @skynet_region || ::RubySkynet.region
+      end
+
+      def skynet_region=(skynet_region)
+        @skynet_region = skynet_region
+      end
+
+    end
+
   end
 end

data/lib/ruby_skynet/connection.rb

@@ -1,4 +1,5 @@
 require 'bson'
+require 'gene_pool'
 require 'thread_safe'
 require 'resilient_socket'
 require 'sync_attr'
@@ -16,6 +17,20 @@ module RubySkynet
     # Returns the underlying socket being used by a Connection instance
     attr_reader :socket
 
+    # Default Pool configuration
+    sync_cattr_accessor :pool_config do
+      {
+        :pool_size    => 30,   # Maximum number of connections to any one server
+        :warn_timeout => 2,    # Log a warning if no connections are available after the :warn_timeout seconds
+        :timeout      => 10,   # Raise a Timeout exception if no connections are available after the :timeout seconds
+        :idle_timeout => 600,  # Renew a connection if it has been idle for this period of time
+      }
+    end
+
+    # For each server there is a connection pool keyed on the
+    # server address: 'host:port'
+    @@connection_pools = ThreadSafe::Hash.new
+
     # Returns a new RubySkynet connection to the server
     #
     # Parameters:
@@ -35,8 +50,8 @@ module RubySkynet
     #   :connect_retry_interval [Float]
     #     Number of seconds between connection retry attempts after the first failed attempt
     #     Default: 0.5
-    def initialize(servers, params = {})
-      params = params.dup
+    def initialize(server, params = {})
+      self.logger = SemanticLogger["#{self.class.name} [#{server}]"]
 
       # User configurable options
       params[:read_timeout]           ||= 60
@@ -76,12 +91,12 @@ module RubySkynet
         client_handshake = { 'clientid' => client_id }
         logger.debug "Sending Client Handshake"
         logger.trace 'Client Handshake', client_handshake
-        socket.write(BSON.serialize(client_handshake).to_s)
+        socket.write(client_handshake.to_bson)
       end
 
       # To prevent strange issues if user incorrectly supplies server names
-      params.delete(:server)
-      params[:servers] = servers
+      params.delete(:servers)
+      params[:server] = server
 
       @socket = ResilientSocket::TCPClient.new(params)
     end
@@ -116,12 +131,12 @@ module RubySkynet
 
           logger.debug "Sending Header"
           logger.trace 'Header', header
-          socket.write(BSON.serialize(header).to_s)
+          socket.write(header.to_bson)
 
           # 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),
+            'in'          => BSON::Binary.new(parameters.to_bson),
             'method'      => method_name.to_s,
             'requestinfo' => {
               'requestid'     => request_id,
@@ -137,7 +152,7 @@ module RubySkynet
           logger.debug "Sending Request"
           logger.trace 'Request', request
           logger.trace 'Parameters:', parameters
-          socket.write(BSON.serialize(request).to_s)
+          socket.write(request.to_bson)
 
           # Since Send does not affect state on the server we can also retry reads
           if idempotent
@@ -186,7 +201,7 @@ module RubySkynet
 
         # 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'])
+        result = Hash.from_bson(StringIO.new(response['out'].data))
         logger.trace 'Return Value', result
         result
       end
@@ -194,19 +209,44 @@ module RubySkynet
 
     # Execute the supplied block with a connection from the pool
     def self.with_connection(server, params={}, &block)
-      conn = nil
-      begin
-        conn = new(server, params)
-        block.call(conn)
-      ensure
-        conn.close if conn
-      end
+      (@@connection_pools[server] ||= new_connection_pool(server, params)).with_connection(&block)
     end
 
     def close
       @socket.close if @socket
     end
 
+    ########################
+    protected
+
+    # Returns a new connection pool for the specified server
+    def self.new_connection_pool(server, params={})
+      # 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
+
+      pool = GenePool.new(pool_config) do
+        new(server, params)
+      end
+
+      # Cleanup corresponding connection pool when a server terminates
+      RubySkynet.service_registry.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
+        #pool.close if pool
+        logger.debug "Connection pool released"
+      end
+
+      pool
+    end
+
   end
+
 end
 

data/lib/ruby_skynet/doozer/service_registry.rb

@@ -1,5 +1,6 @@
 require 'semantic_logger'
 require 'thread_safe'
+require 'gene_pool'
 require 'resolv'
 
 #
@@ -61,6 +62,18 @@ module RubySkynet
         @registry.delete("#{name}/#{version}/#{region}/#{hostname}/#{port}")
       end
 
+      # Return a server that implements the specified service
+      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)]
+        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=RubySkynet.region)
         if version == '*'
@@ -73,11 +86,9 @@ module RubySkynet
             end
           end
         end
-        servers = if server_infos = @cache["#{name}/#{version}/#{region}"]
+        if server_infos = @cache["#{name}/#{version}/#{region}"]
           server_infos.first.servers
         end
-        raise ServiceUnavailable.new("No servers available for service: #{name} with version: #{version} in region: #{region}") unless servers
-        servers
       end
 
       # Invokes registered callbacks when a specific server is shutdown or terminates

data/lib/ruby_skynet/railties/ruby_skynet.rake

@@ -6,28 +6,25 @@ namespace :ruby_skynet do
     # so skip it here under Rails
     unless defined?(Rails)
       # Environment to use in config file
+      # Defaults to Rails.env
       environment = ENV['SKYNET_ENV']
 
       # Environment to use in config file
+      # Defaults to config/ruby_skynet.yml
       cfg_file = ENV['SKYNET_CONFIG']
 
       # Load the configuration file
       RubySkynet.configure!(cfg_file, environment)
     end
 
-    # Connect to services registry
-    RubySkynet.services
-
-    RubySkynet::Server.load_services
-
+    server = nil
     begin
-      # Start the server
-      RubySkynet::Server.start
-      RubySkynet::Server.wait_until_server_stops
+      server = RubySkynet::Server.new
+      server.register_services_in_path
+      server.wait_until_server_stops
     ensure
-      RubySkynet::Server.stop
+      server.close if server
     end
-
   end
 
 end

data/lib/ruby_skynet/ruby_skynet.rb

@@ -2,6 +2,7 @@ require 'sync_attr'
 
 module RubySkynet
   include SyncAttr
+  @@config = nil
 
   # Returns the default region for all Ruby Skynet Clients and Services
   def self.region
@@ -51,7 +52,7 @@ module RubySkynet
   # By default it connects to a local ZooKeeper instance
   # Use .configure! to supply a configuration file with any other settings
   sync_cattr_reader :service_registry do
-    ServiceRegistry.new(registry: {})
+    ServiceRegistry.new
   end
 
   # Returns the current Registry Config information
@@ -69,11 +70,6 @@ module RubySkynet
     @@service_registry = service_registry
   end
 
-  # DEPRECATED - Use RubySkynet.service_registry
-  def self.services
-    @@service_registry
-  end
-
   # Load the Configuration information from a YAML file
   #  filename:
   #    Name of file to read.
@@ -104,7 +100,4 @@ module RubySkynet
     config.each_pair {|k,v| warn "Ignoring unknown RubySkynet config option #{k} => #{v}"}
   end
 
-  # Initialize internal class variable
-  @@config = nil
-
 end

data/lib/ruby_skynet/server.rb

@@ -9,73 +9,8 @@ module RubySkynet
   class Server
     include SemanticLogger::Loggable
 
-    @@server   = nil
-    @@services = ThreadSafe::Hash.new
-
-    # Start a single instance of the server
-    def self.start(start_port = nil, ip_address = nil)
-      @@server ||= new(start_port, ip_address)
-
-      # Stop the skynet server on shutdown
-      # To ensure services are de-registered in the service registry
-      at_exit do
-        ::RubySkynet::Server.stop
-      end
-    end
-
-    # Stop the single instance of the server
-    def self.stop
-      @@server.finalize if @@server
-      @@server = nil
-    end
-
-    # Is the single instance of the server running
-    def self.running?
-      (@@server != nil) && @@server.running?
-    end
-
-    # Wait forever until the running server stops
-    def self.wait_until_server_stops
-      (@@server != nil) && @@server.wait_until_server_stops
-    end
-
-    # Services currently loaded and available at this server when running
-    def self.services
-      @@services
-    end
-
-    # Registers a Service Class as being available at this host and port
-    def self.register_service(klass)
-      raise InvalidServiceException.new("#{klass.inspect} is not a RubySkynet::Service") unless klass.respond_to?(:skynet_name) && klass.respond_to?(:skynet_version) && klass.respond_to?(:skynet_region)
-
-      previous_klass = @@services[klass.skynet_name]
-      if previous_klass && (previous_klass.name != klass.name)
-        logger.warn("Service with name: #{klass.skynet_name} is already registered to a different implementation:#{previous_klass.name}")
-      end
-      @@services[klass.skynet_name] = klass
-      @@server.register_service(klass) if @@server
-    end
-
-    # De-register service
-    def self.deregister_service(klass)
-      raise InvalidServiceException.new("#{klass.inspect} is not a RubySkynet::Service") unless klass.respond_to?(:skynet_name) && klass.respond_to?(:skynet_version) && klass.respond_to?(:skynet_region)
-
-      @@server.deregister_service(klass) if @@server
-      @@services.delete(klass.skynet_name)
-    end
-
-    # Load and register all services found in the supplied path and it's sub-directories
-    def self.load_services
-      RubySkynet::Server.logger.benchmark_info "Loaded Skynet Services" do
-        # Load services
-        Dir.glob("#{RubySkynet.services_path}/**/*.rb").each do |path|
-          load path
-        end
-      end
-    end
-
     # The actual port the server is running at
-    attr_reader :hostname, :port
+    attr_reader :hostname, :port, :services
 
     # Start the server so that it can start taking RPC calls
     # Returns false if the server is already running
@@ -101,16 +36,16 @@ module RubySkynet
       # Start Server listener thread
       @listener_thread = Thread.new { run }
 
-      # Register services hosted by this server
-      self.class.services.each_value {|klass| register_service(klass)}
+      # Array[RubySkynet::Service] List of services registered with this server instance
+      @services = ThreadSafe::Hash.new
     end
 
-    def finalize
+    def close
       @server.close if @server
       logger.info "Skynet Server Stopped"
 
       # Deregister services hosted by this server
-      self.class.services.each_value do |klass|
+      @services.each_value do |klass|
         deregister_service(klass) rescue nil
       end
       logger.info "Skynet Services De-registered"
@@ -128,19 +63,59 @@ module RubySkynet
 
     # Registers a Service Class as being available at this server
     def register_service(klass)
+      raise InvalidServiceException.new("#{klass.inspect} is not a RubySkynet::Service") unless klass.respond_to?(:skynet_name) && klass.respond_to?(:skynet_version) && klass.respond_to?(:skynet_region)
+
+      previous_klass = @services[klass.skynet_name]
+      if previous_klass && (previous_klass.name != klass.name)
+        logger.warn("Service with name: #{klass.skynet_name} is already registered to a different implementation:#{previous_klass.name}")
+      end
+      @services[klass.skynet_name] = klass
+
       logger.info "Registering Service: #{klass.name} with name: #{klass.skynet_name}"
       ::RubySkynet.service_registry.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)
+      raise InvalidServiceException.new("#{klass.inspect} is not a RubySkynet::Service") unless klass.respond_to?(:skynet_name) && klass.respond_to?(:skynet_version) && klass.respond_to?(:skynet_region)
+
       logger.info "De-registering Service: #{klass.name} with name: #{klass.skynet_name}"
       ::RubySkynet.service_registry.deregister_service(klass.skynet_name, klass.skynet_version || 1, klass.skynet_region, @hostname, @port)
+      @services.delete(klass.skynet_name)
+    end
+
+    # Loads and registers all services found in the supplied path and it's sub-directories
+    # Returns [RubySkynet::Service] the list of Services registered
+    def register_services_in_path(path=RubySkynet.services_path)
+      logger.benchmark_info "Loaded Skynet Services" do
+        # Load services
+        klasses = []
+        Dir.glob("#{path}/**/*.rb").each do |filename|
+          partial = filename.sub(path,'').sub('.rb', '')
+          load filename
+          camelized = partial.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+          begin
+            klass = constantize(camelized)
+            # Register the service
+            register_service(klass)
+            klasses << klass
+          rescue Exception => exc
+            p exc
+            raise "Expected to find class #{camelized} in file #{filename}"
+          end
+        end
+        klasses
+      end
     end
 
     ############################################################################
     protected
 
+    # Re-Register services hosted by this server in the registry
+    def re_register_services_in_registry
+      @services.each_value {|klass| register_service(klass)}
+    end
+
     def run
       logger.info("Starting listener on #{hostname}:#{port}")
       loop do
@@ -168,7 +143,7 @@ module RubySkynet
         'registered' => true,
         'clientid'   => BSON::ObjectId.new.to_s
       }
-      client.write(BSON.serialize(handshake).to_s)
+      client.write(handshake.to_bson)
       Common.read_bson_document(client)
 
       while(header = Common.read_bson_document(client)) do
@@ -185,7 +160,7 @@ module RubySkynet
         request = Common.read_bson_document(client)
         logger.trace 'Request', request
         break unless request
-        params = BSON.deserialize(request['in'])
+        params = Hash.from_bson(StringIO.new(request['in'].data))
         logger.trace 'Parameters', params
 
         reply = begin
@@ -198,11 +173,11 @@ module RubySkynet
         if reply
           logger.debug "Sending Header"
           # For this test we just send back the received header
-          client.write(BSON.serialize(header).to_s)
+          client.write(header.to_bson)
 
           logger.debug "Sending Reply"
           logger.trace 'Reply', reply
-          client.write(BSON.serialize('out' => BSON::Binary.new(BSON.serialize(reply))).to_s)
+          client.write({'out' => BSON::Binary.new(reply.to_bson)}.to_bson)
         else
           logger.debug "Closing client since no reply is being sent back"
           break
@@ -221,7 +196,7 @@ module RubySkynet
     def on_message(skynet_name, method, params)
       logger.benchmark_info("Skynet Call: #{skynet_name}##{method}") do
         logger.trace "Method Call: #{method} with parameters:", params
-        klass = Server.services[skynet_name]
+        klass = services[skynet_name]
         raise "Invalid Skynet RPC call, service: #{skynet_name} is not available at this server" unless klass
         # TODO Use pool of services
         service = klass.new
@@ -230,5 +205,17 @@ module RubySkynet
       end
     end
 
+    # Returns the supplied camel_cased string as it's class
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+
   end
 end