ruby_skynet 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16525cda69fa5554ce2851afcea16d4d379e1c3e
-  data.tar.gz: b02c07c9d88035fc5018e18548dc0e868f640716
+  metadata.gz: f15ead62305cae332e890c1ad63a3f11e9085ffe
+  data.tar.gz: aa3243ae8229d4cd7a5f82ac673fd3e7cc700b17
 SHA512:
-  metadata.gz: 461650dbc05cd7febf853c2f7416e22f089cec61fa4e5aea188cef90573452e6ea1f8cc43443132b94071420e9727cacd605662a2d35423baf3a2acecbc2132e
-  data.tar.gz: 9bfa3b9751bd03753a849e34c1c4a3eb9c9f9de04af1efe34131aa7fdcd3c59aa1f8e3fb885ecbe61e79abd2aea810804a9c169c9a26ed0d553ecf0e5210be23
+  metadata.gz: 363ed46b3ee9182fa572fb00724031f01d077600a304ac3d38ccbbb023b3c33ff25872c72b9eeb7c130e4784ce9c6c2ff807a9c522d391ef31a8de9564fdd7e3
+  data.tar.gz: 4eeb6d97725af7fb087e40afbc8b8d459c8889b84c1d4b1756885eedc3322adbf22a5afd89d44c97ad456e7441e0dd09fb90007c1a28204835638ab1e9404faf

data/README.md

@@ -24,9 +24,6 @@ For details on installing and running the GoLang Tutorial Service: https://githu
 require 'rubygems'
 require 'ruby_skynet'
 
-RubySkynet::Server.port = 2000
-RubySkynet::Server.hostname = '127.0.0.1'
-
 # Just echo back any parameters received when the echo method is called
 class EchoService
   include RubySkynet::Service
@@ -48,8 +45,12 @@ Client to call the above Service
 require 'rubygems'
 require 'ruby_skynet'
 
-client = RubySkynet::Client.new('EchoService')
-p client.call('echo', :hello => 'world')
+class EchoService
+  include RubySkynet::Base
+end
+
+client = EchoService.new
+p client.echo(:hello => 'world')
 ```
 
 ### Logging
@@ -64,8 +65,12 @@ require 'ruby_skynet'
 SemanticLogger::Logger.default_level = :trace
 SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('skynet.log')
 
-client = RubySkynet::Client.new('EchoService')
-p client.call('echo', :hello => 'world')
+class EchoService
+  include RubySkynet::Base
+end
+
+client = EchoService.new
+p client.echo(:hello => 'world')
 ```
 
 ### Architecture
@@ -83,20 +88,10 @@ project for marshaling data for communicating with doozer
 - [ruby_protobuf](https://github.com/macks/ruby-protobuf)
 - [multi_json](https://github.com/intridea/multi_json)
 
-The server to host services in Ruby also requires:
-- [Celluloid::io](https://github.com/celluloid/celluloid-io)
-
 ### Install
 
     gem install ruby_skynet
 
-### Future
-
-* Immediately drop connections to a service on a host when that instance
-  shuts down or stops. ( Doozer::Wait )
-* More intelligent selection of available Skynet services. For example
-  nearest, or looking at load etc.
-
 Development
 -----------
 
@@ -139,7 +134,7 @@ Reid Morrison :: reidmo@gmail.com :: @reidmorrison
 License
 -------
 
-Copyright 2012 Clarity Services, Inc.
+Copyright 2012,2013 Clarity Services, Inc.
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/Rakefile

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

data/lib/rails/generators/ruby_skynet/config/config_generator.rb

@@ -0,0 +1,20 @@
+module RubySkynet
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      desc "Creates a Ruby Skynet configuration file at config/ruby_skynet.yml"
+
+      def self.source_root
+        @_ruby_skynet_source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def app_name
+        Rails::Application.subclasses.first.parent.to_s.underscore
+      end
+
+      def create_config_file
+        template 'ruby_skynet.yml', File.join('config', "ruby_skynet.yml")
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# Ruby Skynet Client & Server Configuration Parameters
+#   :region [String]
+#     Region name to use for service lookup
+#     Default: Rails.env
+#
+#   :services_path [String]
+#     Path within to look for service implementations that will be loaded
+#     when RubySkynet::Server.load_services is called
+#
+#   :server_port [Integer]
+#     Optional: Only required when running a server locally
+#     Starting port for server to listen on
+#     If this port is in use the next available port will be used
+#     upto 999 above the server_port value
+#
+#   :local_ip_address [String]
+#     Optional: The ip address at which this server instance can be reached
+#     by remote Skynet clients
+#     Note: Must be an IP address, not the hostname
+#
+#   Doozer Configuration Parameters
+#   :doozer
+#     :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
+#
+#     :server_selector [Symbol]
+#       When multiple doozer servers are supplied using :servers, this option will
+#       determine which server is selected from the list
+#         :ordered
+#           Select a server in the order supplied in the array, with the first
+#           having the highest priority. The second server will only be connected
+#           to if the first server is unreachable
+#         :random
+#           Randomly select a server from the list every time a connection
+#           is established, including during automatic connection recovery.
+#         Default: :ordered
+defaults: &defaults
+  :services_path: app/services
+  :server_port:   2000
+  :doozer:
+    :servers:
+    - 127.0.0.1:8046
+    :read_timeout:           5
+    :connect_timeout:        3
+    :connect_retry_count:    10
+    :connect_retry_interval: 0.5
+    :server_selector:        :random
+
+development:
+  <<: *defaults
+  :region: Development
+
+test:
+  <<: *defaults
+  :region: Test
+
+release:
+  <<: *defaults
+  :region: Release
+
+hotfix:
+  <<: *defaults
+  :region: Hotfix
+
+production:
+  <<: *defaults
+  :region: Production

data/lib/ruby_skynet/base.rb

@@ -0,0 +1,65 @@
+require 'semantic_logger'
+
+# Base class for RubySkynet Clients and Services
+module RubySkynet
+  module Base
+    def self.included(base)
+      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
+
+    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/client.rb

@@ -14,7 +14,7 @@ module RubySkynet
     # concurrently from multiple threads at the same time
     #
     # Parameters:
-    #   :service_name
+    #   :skynet_name
     #     Name of the service to look for and connect to on Skynet
     #
     #   :version
@@ -33,9 +33,9 @@ module RubySkynet
     #
     #  tutorial_service = RubySkynet::Client.new('TutorialService')
     #  p tutorial_service.call('Add', :value => 5)
-    def initialize(service_name, version='*', region='Development')
-      @service_name = service_name
-      @logger       = SemanticLogger::Logger.new("#{self.class.name}: #{service_name}/#{version}/#{region}")
+    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
     end
@@ -57,12 +57,12 @@ module RubySkynet
       # 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
+        @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(Registry.server_for(@service_name, @version, @region), connection_params) do |connection|
-              connection.rpc_call(request_id, @service_name, method_name, parameters)
+            Connection.with_connection(Registry.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
             if (retries < 3) && exc.cause.is_a?(Errno::ECONNREFUSED)

data/lib/ruby_skynet/connection.rb

@@ -108,7 +108,7 @@ module RubySkynet
     # Performs a synchronous call to a Skynet server
     #
     # Parameters:
-    #   service_name [String|Symbol]:
+    #   skynet_name [String|Symbol]:
     #     Name of the method to pass in the request
     #   method_name [String|Symbol]:
     #     Name of the method to pass in the request
@@ -122,14 +122,14 @@ module RubySkynet
     #
     # Raises RubySkynet::ProtocolError
     # Raises RubySkynet::SkynetException
-    def rpc_call(request_id, service_name, method_name, parameters, idempotent=false)
+    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' => "#{service_name}.Forward",
+          'servicemethod' => "#{skynet_name}.Forward",
           'seq'           => socket.user_data[:seq]
         }
 

data/lib/ruby_skynet/doozer/client.rb

@@ -8,10 +8,10 @@ module RubySkynet
   module Doozer
     class Client
 
+      include SemanticLogger::Loggable
+
       # Create a resilient client connection to a Doozer server
       def initialize(params={})
-        @logger = SemanticLogger::Logger.new(self.class)
-
         # User configurable options
         params[:read_timeout]           ||= 5
         params[:connect_timeout]        ||= 3
@@ -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.dup
+        logger.trace "Socket Connection parameters", params.dup
 
         # For each new connection
         params[:on_connect] = Proc.new do |socket|

data/lib/ruby_skynet/exceptions.rb

@@ -3,6 +3,7 @@ module RubySkynet
   class ProtocolError < Exception; end
   class ServiceException < Exception; end
   class InvalidServiceException < ServiceException; end
+  class InvalidConfigurationException < ServiceException; end
   class SkynetException < Exception; end
   class ServiceUnavailable < SkynetException; end
 end

data/lib/ruby_skynet/railtie.rb

@@ -0,0 +1,30 @@
+module RubySkynet #:nodoc:
+  class Railtie < Rails::Railtie #:nodoc:
+
+    # Exposes RubySkynet configuration to the Rails application configuration.
+    #
+    # @example Set up configuration in the Rails app.
+    #   module MyApplication
+    #     class Application < Rails::Application
+    #       config.ruby_skynet.region = "Development"
+    #     end
+    #   end
+    config.ruby_skynet = ::RubySkynet
+
+    rake_tasks do
+      load "ruby_skynet/railties/ruby_skynet.rake"
+    end
+
+    # Load RubySkynet Configuration
+    config.before_configuration do
+      config_file = Rails.root.join("config", "ruby_skynet.yml")
+      if config_file.file?
+        ::RubySkynet.configure!(config_file, Rails.env)
+      else
+        puts "\nRuby Skynet config not found."
+        puts "To generate one for the first time: rails generate ruby_skynet:config\n\n"
+      end
+    end
+
+  end
+end

data/lib/ruby_skynet/railties/ruby_skynet.rake

@@ -0,0 +1,28 @@
+namespace :ruby_skynet do
+
+  desc "Start the Ruby Skynet Server.\n Rails Example: rake ruby_skynet:server\n Without Rails: SKYNET_ENV=production SKYNET_CONFIG=config/ruby_skynet rake ruby_skynet:server"
+  task :server => :environment do
+    # Configuration is automatically loaded when running under Rails
+    # so skip it here under Rails
+    unless defined?(Rails)
+      # Environment to use in config file
+      environment = ENV['SKYNET_ENV']
+
+      # Environment to use in config file
+      cfg_file = ENV['SKYNET_CONFIG']
+
+      # Load the configuration file
+      RubySkynet.configure!(cfg_file, environment)
+    end
+
+    # Connect to doozer
+    RubySkynet::Registry.service_registry
+
+    RubySkynet::Server.load_services
+
+    # Start the server
+    RubySkynet::Server.start
+    RubySkynet::Server.wait_until_server_stops
+  end
+
+end

data/lib/ruby_skynet/registry.rb

@@ -16,10 +16,12 @@ module RubySkynet
     include SyncAttr
 
     # Service Registry has the following format
-    #  Key: [String] 'service_name/version/region'
+    #  Key: [String] 'name/version/region'
     #  Value: [Array<String>] 'host:port', 'host:port'
     sync_cattr_reader :service_registry do
-      start
+      logger.benchmark_info "Connected to Doozer" do
+        start
+      end
     end
 
     @@on_server_removed_callbacks = ThreadSafe::Hash.new
@@ -91,12 +93,12 @@ module RubySkynet
     end
 
     # Return a server that implements the specified service
-    def self.server_for(service_name, version='*', region='Development')
-      if servers = servers_for(service_name, version, region)
+    def self.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: #{service_name} with version: #{version} in region: #{region}"
+        msg = "No servers available for service: #{name} with version: #{version} in region: #{region}"
         logger.warn msg
         raise ServiceUnavailable.new(msg)
       end
@@ -105,17 +107,17 @@ module RubySkynet
     # Returns [Array] of the hostname and port pair [String] that implements a particular service
     # Performs a doozer lookup to find the servers
     #
-    #   service_name:
+    #   name:
     #     Name of the service to lookup
     #   version:
     #     Version of service to locate
     #     Default: All versions
     #   region:
     #     Region to look for the service in
-    def self.registered_implementers(service_name='*', version='*', region='Development')
+    def self.registered_implementers(name='*', version='*', region='Development')
       hosts = []
       doozer_pool.with_connection do |doozer|
-        doozer.walk("/services/#{service_name}/#{version}/#{region}/*/*").each do |node|
+        doozer.walk("/services/#{name}/#{version}/#{region}/*/*").each do |node|
           entry = MultiJson.load(node.value)
           hosts << entry if entry['Registered']
         end
@@ -124,18 +126,18 @@ module RubySkynet
     end
 
     # Returns [Array<String>] a list of servers implementing the requested service
-    def self.servers_for(service_name, version='*', region='Development')
+    def self.servers_for(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}/)
+          if match = key.match(/#{name}\/(\d+)\/#{region}/)
             ver = match[1].to_i
             version = ver if ver > version
           end
         end
       end
-      if server_infos = service_registry["#{service_name}/#{version}/#{region}"]
+      if server_infos = service_registry["#{name}/#{version}/#{region}"]
         server_infos.first.servers
       end
     end
@@ -164,7 +166,7 @@ module RubySkynet
       #   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)
+        @@local_match ||= IPV4_REG_EXP.match(RubySkynet.local_ip_address)
         score = 0
         (1..4).each do |i|
           break if @@local_match[i].to_i != server_match[i].to_i
@@ -178,9 +180,7 @@ module RubySkynet
     protected
 
     # Logging instance for this class
-    sync_cattr_reader :logger do
-      SemanticLogger::Logger.new(self, :debug)
-    end
+    include SemanticLogger::Loggable
 
     # Lazy initialize Doozer Client Connection pool
     sync_cattr_reader :doozer_pool do
@@ -250,7 +250,7 @@ module RubySkynet
       # path from doozer: "/services/TutorialService/1/Development/127.0.0.1/9000"
       e = path.split('/')
 
-      # Key: [String] 'service_name/version/region'
+      # Key: [String] 'name/version/region'
       key = "#{e[2]}/#{e[3]}/#{e[4]}"
       hostname, port = e[5], e[6]
 
@@ -287,7 +287,7 @@ module RubySkynet
     ServerInfo = Struct.new(:score, :servers )
 
     # Format of the internal services registry
-    #   key: [String] "<service_name>/<version>/<region>"
+    #   key: [String] "<name>/<version>/<region>"
     #   value: [ServiceInfo, ServiceInfo]
     #          Sorted by highest score first
 
@@ -353,16 +353,16 @@ module RubySkynet
 
     # Check doozer for servers matching supplied criteria
     # Code unused, consider deleting
-    def self.remote_servers_for(service_name, version='*', region='Development')
+    def self.remote_servers_for(name, version='*', region='Development')
       if version != '*'
-        registered_implementers(service_name, version, region).map do |host|
+        registered_implementers(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|
+        registered_implementers(name, version, region).each do |host|
           service = host['Config']['ServiceAddr']
           (versions[version.to_i] ||= []) << "#{service['IPAddress']}:#{service['Port']}"
         end

data/lib/ruby_skynet/ruby_skynet.rb

@@ -0,0 +1,69 @@
+module RubySkynet
+
+  # Returns the default region for all Ruby Skynet Clients and Services
+  def self.region
+    @@region ||= 'Development'
+  end
+
+  # Sets the default region to use for Skynet Clients and Services
+  def self.region=(region)
+    @@region = region
+  end
+
+  # Returns the service_path where services are located
+  def self.services_path
+    @@services_path ||= 'app/services'
+  end
+
+  # Sets the service_path where services are located
+  def self.services_path=(services_path)
+    @@services_path = services_path
+  end
+
+  # Returns the starting port for the server to listen on
+  # If this port is in use the next available port will be used
+  # upto 999 above the server_port value
+  def self.server_port
+    @@server_port ||= 2000
+  end
+
+  def self.server_port=(server_port)
+    @@server_port = server_port
+  end
+
+  # The ip address at which this server instance can be reached
+  # by remote Skynet clients
+  # Note: Must be an IP address, not the hostname
+  def self.local_ip_address
+    @@local_ip_address ||= Common::local_ip_address
+  end
+
+  def self.local_ip_address=(local_ip_address)
+    @@local_ip_address = local_ip_address
+  end
+
+  # Load the Encryption Configuration from a YAML file
+  #  filename:
+  #    Name of file to read.
+  #        Mandatory for non-Rails apps
+  #        Default: Rails.root/config/ruby_skynet.yml
+  #  environment:
+  #    Which environment config to load. Usually: production, development, etc.
+  #    Default: Rails.env
+  def self.configure!(filename=nil, environment=nil)
+    config_file = filename.nil? ? Rails.root.join('config', 'ruby_skynet.yml') : Pathname.new(filename)
+    raise "ruby_skynet config not found. Create a config file at: config/ruby_skynet.yml" unless config_file.file?
+
+    cfg = YAML.load(ERB.new(File.new(config_file).read).result)[environment || Rails.env]
+    raise("Environment #{Rails.env} not defined in config/ruby_skynet.yml") unless cfg
+
+    RubySkynet.region = cfg.delete(:region) if [:region]
+    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]
+
+    cfg.each_pair {|k,v| RubySkynet::Server.logger.warn "Ignoring unknown RubySkynet config option #{k} => #{v}"}
+  end
+
+end

data/lib/ruby_skynet/server.rb

@@ -13,8 +13,14 @@ module RubySkynet
     @@services = ThreadSafe::Hash.new
 
     # Start a single instance of the server
-    def self.start(region = 'Development', start_port = 2000, hostname = nil)
-      @@server ||= new(region, start_port, hostname)
+    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 doozer
+      at_exit do
+        ::RubySkynet::Server.stop
+      end
     end
 
     # Stop the single instance of the server
@@ -28,6 +34,11 @@ module RubySkynet
       (@@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
@@ -35,39 +46,49 @@ module RubySkynet
 
     # 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?(:service_name) && klass.respond_to?(:service_version)
+      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)
 
-      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}")
+      if previous_klass = @@services[klass.skynet_name] && (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.service_name] = klass
+      @@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?(:service_name) && klass.respond_to?(:service_version)
+      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.service_name)
+      @@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 which will be different
-    # from Server.port if that port was already in use at startup
-    attr_reader :hostname, :port, :region
+    # The actual port the server is running at
+    attr_reader :hostname, :port
 
     # Start the server so that it can start taking RPC calls
     # Returns false if the server is already running
-    def initialize(region = 'Development', start_port = 2000, hostname = nil)
-      hostname ||= Common.local_ip_address
+    def initialize(start_port = nil, ip_address = nil)
+      ip_address ||= RubySkynet.local_ip_address
+      start_port = (start_port || RubySkynet.server_port).to_i
+      raise InvalidConfigurationException.new("Invalid Starting Port number: #{start_port}") unless start_port > 0
 
       # 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
+        @server   = ::TCPServer.new(ip_address, start_port + port_count)
+        @hostname = ip_address
         @port     = start_port + port_count
-        @region   = region
       rescue Errno::EADDRINUSE => exc
         if port_count < 999
           port_count += 1
@@ -77,7 +98,7 @@ module RubySkynet
       end
 
       # Start Server listener thread
-      Thread.new { run }
+      @listener_thread = Thread.new { run }
 
       # Register services hosted by this server
       self.class.services.each_value {|klass| register_service(klass)}
@@ -94,6 +115,19 @@ module RubySkynet
       logger.info "Skynet Services De-registered"
     end
 
+    # Returns whether the server is running
+    def running?
+      (@server != nil) && !@server.closed?
+    end
+
+    # Wait forever until the running server stops
+    def wait_until_server_stops
+      @listener_thread.join
+    end
+
+    ############################################################################
+    protected
+
     def run
       logger.info("Starting listener on #{hostname}:#{port}")
       loop do
@@ -129,22 +163,22 @@ module RubySkynet
         logger.debug "Received Request"
         logger.trace 'Header', header
 
-        service_name = header['servicemethod']  # "#{service_name}.Forward",
-        raise "Invalid Skynet RPC Request, missing servicemethod" unless service_name
-        match = service_name.match /(.*)\.Forward$/
+        name = header['servicemethod']
+        raise "Invalid Skynet RPC Request, missing servicemethod" unless name
+        match = name.match /(.*)\.Forward$/
         raise "Invalid Skynet RPC Request, servicemethod must end with '.Forward'" unless match
-        service_name = match[1]
+        name = match[1]
 
         request = Common.read_bson_document(client)
         logger.trace 'Request', request
         break unless request
         params = BSON.deserialize(request['in'])
         logger.trace 'Parameters', params
-        
+
         reply = begin
-          on_message(service_name, request['method'].to_sym, params)
+          on_message(name, request['method'].to_sym, params)
         rescue ScriptError, NameError, StandardError, Exception => exc
-          logger.error "Exception while calling service: #{service_name}", exc
+          logger.error "Exception while calling service: #{name}", exc
           { :exception => {:message => exc.message, :class => exc.class.name} }
         end
 
@@ -169,36 +203,28 @@ module RubySkynet
       logger.debug "Disconnected from the client"
     end
 
-    # Returns whether the server is running
-    def running?
-      (@server != nil) && !@server.closed?
-    end
-
-    ############################################################################
-    protected
-
     # 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)
+      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)
     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)
+      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)
     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_info("Skynet Call: #{service_name}##{method}") do
+    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[service_name]
-        raise "Invalid Skynet RPC call, service: #{service_name} is not available at this server" unless klass
+        klass = Server.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
-        raise "Invalid Skynet RPC call, method: #{method} does not exist for service: #{service_name}" unless service.respond_to?(method)
+        raise "Invalid Skynet RPC call, method: #{method} does not exist for service: #{skynet_name}" unless service.respond_to?(method)
         service.send(method, params)
       end
     end

data/lib/ruby_skynet/service.rb

@@ -1,6 +1,4 @@
-# Doozer entries are in json
-require 'multi_json'
-require 'thread_safe'
+require 'semantic_logger'
 
 #
 # RubySkynet Service
@@ -11,43 +9,17 @@ require 'thread_safe'
 #
 module RubySkynet
   module Service
+
     def self.included(base)
-      base.extend ClassMethods
+      base.extend ::RubySkynet::Base::ClassMethods
       base.class_eval do
         include SemanticLogger::Loggable
-
-        sync_cattr_reader :logger do
-          SemanticLogger::Logger.new(self)
-        end
       end
       # Register the service with the Server
       # The server will publish the server to Doozer when the server is running
       Server.register_service(base)
     end
 
-    module ClassMethods
-      # Name of this service to Register with Skynet
-      # Default: class name
-      def service_name
-        @service_name ||= name.gsub('::', '.')
-      end
-
-      def 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
-      end
-
-      def service_version=(service_version)
-        @service_version = service_version
-      end
-
-    end
-
   end
 end
 

data/lib/ruby_skynet/version.rb

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

data/lib/ruby_skynet.rb

@@ -1,14 +1,20 @@
 require 'semantic_logger'
 require 'ruby_skynet/exceptions'
 require 'ruby_skynet/version'
+require 'ruby_skynet/ruby_skynet'
 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'
 end
+
+if defined?(Rails)
+  require 'ruby_skynet/railtie'
+end

data/test/base_test.rb

@@ -0,0 +1,89 @@
+# 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

data/test/client_test.rb

@@ -56,7 +56,8 @@ class ClientTest < Test::Unit::TestCase
     context "with server" do
       setup do
         @region = 'ClientTest'
-        RubySkynet::Server.start(@region)
+        RubySkynet.region = @region
+        RubySkynet::Server.start
 
         @service_name = 'ClientTestService'
         @version = 1

data/test/registry_test.rb

@@ -89,7 +89,7 @@ class RegistryTest < Test::Unit::TestCase
         ['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")
+          RubySkynet.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

data/test/service_test.rb

@@ -35,7 +35,8 @@ class ServiceTest < Test::Unit::TestCase
         @region = 'Test'
         @service_name = 'TestService'
         @version = 1
-        RubySkynet::Server.start(@region)
+        RubySkynet.region = @region
+        RubySkynet::Server.start
         sleep 0.2
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_skynet
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-22 00:00:00.000000000 Z
+date: 2013-03-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -80,6 +80,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: gene_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby Client for invoking Skynet services
 email:
 - reidmo@gmail.com
@@ -95,7 +109,10 @@ files:
 - examples/e.rb
 - examples/echo_client.rb
 - examples/echo_server.rb
+- lib/rails/generators/ruby_skynet/config/config_generator.rb
+- lib/rails/generators/ruby_skynet/config/templates/ruby_skynet.yml
 - lib/ruby_skynet.rb
+- lib/ruby_skynet/base.rb
 - lib/ruby_skynet/client.rb
 - lib/ruby_skynet/common.rb
 - lib/ruby_skynet/connection.rb
@@ -103,11 +120,15 @@ files:
 - lib/ruby_skynet/doozer/exceptions.rb
 - lib/ruby_skynet/doozer/msg.pb.rb
 - lib/ruby_skynet/exceptions.rb
+- lib/ruby_skynet/railtie.rb
+- lib/ruby_skynet/railties/ruby_skynet.rake
 - lib/ruby_skynet/registry.rb
+- lib/ruby_skynet/ruby_skynet.rb
 - lib/ruby_skynet/server.rb
 - lib/ruby_skynet/service.rb
 - lib/ruby_skynet/version.rb
 - test.sh
+- test/base_test.rb
 - test/client_test.rb
 - test/doozer_client_test.rb
 - test/registry_test.rb