ruby_skynet 0.2.0 → 0.3.0

data/Gemfile

@@ -4,6 +4,7 @@ group :test do
   gem "shoulda"
 end
 
+gem "rake"
 gem "semantic_logger"
 gem "resilient_socket"
 # Thread Safe Hash and Array
@@ -14,4 +15,7 @@ gem "multi_json"
 gem "ruby_protobuf"
 # Wire format when communicating with services
 gem "bson"
-gem "bson_ext", :platform => :ruby
+gem "bson_ext", :platform => :ruby
+# Celluloid::IO is used to create SkyNet services in Ruby
+# multi_json?
+gem "celluloid-io"

data/Gemfile.lock

@@ -1,26 +1,46 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    activesupport (3.2.8)
+    activesupport (3.2.9)
       i18n (~> 0.6)
       multi_json (~> 1.0)
-    bson (1.7.0)
-    bson_ext (1.7.0)
-      bson (~> 1.7.0)
+    bourne (1.1.2)
+      mocha (= 0.10.5)
+    bson (1.8.0)
+      activesupport
+    bson_ext (1.8.0)
+      bson (~> 1.8.0)
+    celluloid (0.12.3)
+      facter (>= 1.6.12)
+      timers (>= 1.0.0)
+    celluloid-io (0.12.0)
+      celluloid (~> 0.12.0)
+      nio4r (>= 0.4.0)
+    facter (1.6.16)
+    gene_pool (1.3.0)
     i18n (0.6.1)
-    multi_json (1.3.6)
-    resilient_socket (0.2.1)
+    metaclass (0.0.1)
+    mocha (0.10.5)
+      metaclass (~> 0.0.1)
+    multi_json (1.4.0)
+    nio4r (0.4.3)
+    rake (10.0.2)
+    resilient_socket (0.4.0)
       semantic_logger
     ruby_protobuf (0.4.11)
-    semantic_logger (0.7.0)
+    semantic_logger (0.11.4)
       sync_attr
-    shoulda (3.3.0)
-      shoulda-context (~> 1.0)
-      shoulda-matchers (~> 1.4)
-    shoulda-context (1.0.0)
-    shoulda-matchers (1.4.0)
+      thread_safe
+    shoulda (3.3.2)
+      shoulda-context (~> 1.0.1)
+      shoulda-matchers (~> 1.4.1)
+    shoulda-context (1.0.1)
+    shoulda-matchers (1.4.2)
       activesupport (>= 3.0.0)
+      bourne (~> 1.1.2)
     sync_attr (0.1.1)
+    thread_safe (0.0.3)
+    timers (1.0.1)
 
 PLATFORMS
   ruby
@@ -28,8 +48,12 @@ PLATFORMS
 DEPENDENCIES
   bson
   bson_ext
+  celluloid-io
+  gene_pool
   multi_json
+  rake
   resilient_socket
   ruby_protobuf
   semantic_logger
   shoulda
+  thread_safe

data/README.md

@@ -1,22 +1,56 @@
 ruby_skynet
 ===========
 
-Ruby Client for calling [Skynet](https://github.com/bketelsen/skynet) services.
-Will also implement the server side so that [Skynet](https://github.com/bketelsen/skynet) Services can be hosted in Ruby
+Ruby Client for calling [Skynet](https://github.com/skynetservices/skynet) services, and
+the server side so that [Skynet](https://github.com/skynetservices/skynet) services can be hosted in Ruby
 
-* http://github.com/ClarityServices/ruby_skynet
+* http://github.com/skynetservices/ruby_skynet
 
-### Example
+### Client Example
 
 ```ruby
 require 'rubygems'
 require 'ruby_skynet'
-RubySkynet::Client.connect('TutorialService') do |tutorial_service|
-  p tutorial_service.call('AddOne', 'value' => 5)
+
+client = RubySkynet::Client.new('TutorialService')
+p client.call('AddOne', :value => 5)
+```
+
+For details on installing and running the GoLang Tutorial Service: https://github.com/skynetservices/skynet/wiki/Service-Tutorial
+
+### Server Example
+
+```ruby
+require 'rubygems'
+require 'ruby_skynet'
+
+RubySkynet::Server.port = 2000
+RubySkynet::Server.hostname = 'localhost'
+
+# Just echo back any parameters received when the echo method is called
+class EchoService
+  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 echo(params)
+    params
+  end
 end
+
+# Start the server
+RubySkynet::Server.start
 ```
 
-For details on installing and running the Tutorial Service: https://github.com/bketelsen/skynet/wiki/Service-Tutorial
+Client to call the above Service
+```ruby
+require 'rubygems'
+require 'ruby_skynet'
+
+client = RubySkynet::Client.new('EchoService')
+p client.call('echo', :hello => 'world')
+```
 
 ### Logging
 
@@ -26,12 +60,12 @@ calls can be enabled as follows:
 ```ruby
 require 'rubygems'
 require 'ruby_skynet'
+
 SemanticLogger::Logger.default_level = :trace
 SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('skynet.log')
 
-RubySkynet::Client.connect('TutorialService') do |tutorial_service|
-  p tutorial_service.call('AddOne', 'value' => 5)
-end
+client = RubySkynet::Client.new('EchoService')
+p client.call('echo', :hello => 'world')
 ```
 
 ### Architecture
@@ -45,17 +79,19 @@ project for marshaling data for communicating with doozer
 
 - Ruby MRI 1.8.7 (or above), Ruby 1.9.3,  Or JRuby 1.6.3 (or above)
 - [SemanticLogger](http://github.com/ClarityServices/semantic_logger)
-- [ResilientSocket](http://github.com/ClarityServices/ruby_skynet)
+- [ResilientSocket](https://github.com/ClarityServices/resilient_socket)
 - [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
 
-* Implement Skynet Service in Ruby so that it can be called from Go lang, etc.
 * 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
@@ -68,7 +104,7 @@ Want to contribute to Ruby Skynet?
 
 First clone the repo and run the tests:
 
-    git clone git://github.com/ClarityServices/ruby_skynet.git
+    git clone git://github.com/skynetservices/ruby_skynet.git
     cd ruby_skynet
     ruby -S rake test
 
@@ -82,15 +118,15 @@ Once you've made your great commits:
 1. [Fork](http://help.github.com/forking/) ruby_skynet
 2. Create a topic branch - `git checkout -b my_branch`
 3. Push to your branch - `git push origin my_branch`
-4. Create an [Issue](http://github.com/ClarityServices/ruby_skynet/issues) with a link to your branch
+4. Create an [Issue](http://github.com/skynetservices/ruby_skynet/issues) with a link to your branch
 5. That's it!
 
 Meta
 ----
 
-* Code: `git clone git://github.com/ClarityServices/ruby_skynet.git`
-* Home: <https://github.com/ClarityServices/ruby_skynet>
-* Bugs: <http://github.com/ClarityServices/ruby_skynet/issues>
+* Code: `git clone git://github.com/skynetservices/ruby_skynet.git`
+* Home: <https://github.com/skynetservices/ruby_skynet>
+* Bugs: <http://github.com/skynetservices/ruby_skynet/issues>
 * Gems: <http://rubygems.org/gems/ruby_skynet>
 
 This project uses [Semantic Versioning](http://semver.org/).

data/Rakefile

@@ -5,6 +5,7 @@ require 'rubygems'
 require 'rake/clean'
 require 'rake/testtask'
 require 'date'
+require 'semantic_logger'
 require 'ruby_skynet/version'
 
 desc "Build gem"

data/lib/ruby_skynet.rb

@@ -1,13 +1,14 @@
 require 'semantic_logger'
-require 'resilient_socket'
-
 require 'ruby_skynet/exceptions'
 require 'ruby_skynet/version'
 module RubySkynet
   module Doozer
-    autoload :Client, 'ruby_skynet/doozer/client'
+    autoload :Client,   'ruby_skynet/doozer/client'
   end
   autoload :Registry,   'ruby_skynet/registry'
   autoload :Connection, 'ruby_skynet/connection'
+  autoload :Common,     'ruby_skynet/common'
   autoload :Client,     'ruby_skynet/client'
+  autoload :Service,    'ruby_skynet/service'
+  autoload :Server,     'ruby_skynet/server'
 end

data/lib/ruby_skynet/client.rb

@@ -8,8 +8,6 @@ require 'bson'
 #
 module RubySkynet
   class Client
-    include SyncAttr
-
     # Returns a new RubySkynet Client for the named service
     #
     # Calls to an instance of the Client are thread-safe and can be called

data/lib/ruby_skynet/common.rb

@@ -0,0 +1,22 @@
+module RubySkynet
+  module Common
+
+    # 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)
+
+      # 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))
+      return BSON.deserialize(bytebuf)
+    end
+
+  end
+end

data/lib/ruby_skynet/connection.rb

@@ -1,6 +1,7 @@
 require 'bson'
 require 'gene_pool'
 require 'thread_safe'
+require 'resilient_socket'
 
 #
 # RubySkynet Connection
@@ -80,7 +81,7 @@ module RubySkynet
         # ClientID string
         #   ClientID is a UUID that is used by the client to identify itself in RPC requests.
         @logger.debug "Waiting for Service Handshake"
-        service_handshake = self.class.read_bson_document(socket)
+        service_handshake = Common.read_bson_document(socket)
         @logger.trace 'Service Handshake', service_handshake
 
         # #TODO When a reconnect returns registered == false need to throw an exception
@@ -159,12 +160,12 @@ module RubySkynet
         # Since Send does not affect state on the server we can also retry reads
         if idempotent
           @logger.debug "Reading header from server"
-          header = self.class.read_bson_document(socket)
+          header = Common.read_bson_document(socket)
           @logger.debug 'Response Header', header
 
           # Read the BSON response document
           @logger.debug "Reading response from server"
-          response = self.class.read_bson_document(socket)
+          response = Common.read_bson_document(socket)
           @logger.trace 'Response', response
         end
       end
@@ -174,12 +175,12 @@ module RubySkynet
       unless idempotent
         # Read header first as a separate BSON document
         @logger.debug "Reading header from server"
-        header = self.class.read_bson_document(socket)
+        header = Common.read_bson_document(socket)
         @logger.debug 'Response Header', header
 
         # Read the BSON response document
         @logger.debug "Reading response from server"
-        response = self.class.read_bson_document(socket)
+        response = Common.read_bson_document(socket)
         @logger.trace 'Response', response
       end
 
@@ -220,23 +221,6 @@ module RubySkynet
     ########################
     protected
 
-    # 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)
-
-      # 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))
-      return BSON.deserialize(bytebuf)
-    end
-
     # Returns a new connection pool for the specified server
     def self.new_connection_pool(server, params={})
       # Connection pool configuration options

data/lib/ruby_skynet/server.rb

@@ -0,0 +1,235 @@
+require 'bson'
+require 'celluloid/io'
+
+# Replace Celluloid logger immediately upon loading the Server Instance
+Celluloid.logger = SemanticLogger::Logger.new('Celluloid')
+
+#
+# RubySkynet Server
+#
+# Hosts one or more Skynet Services
+#
+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
+
+    # 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
+    def self.register_service(klass)
+      logger.debug "Registering Service: #{klass.name} with name: #{klass.service_name}"
+      @@services[klass.service_name] = klass
+      register_service_in_doozer(klass) if running?
+    end
+
+    # De-register service in doozer
+    def self.deregister_service(klass)
+      RubySkynet::Registry.doozer_pool.with_connection do |doozer|
+        doozer.delete(klass.service_key) rescue nil
+      end
+      @@services.delete(klass.service_name)
+    end
+
+    # Returns whether the server is running
+    def self.running?
+      (@@server != nil) && @@server.running?
+    end
+
+    # Start the Server
+    def self.start
+      @@server = new
+      @@server.start
+    end
+
+    # Stop the Server
+    def self.stop
+      @@server.terminate
+      @@server = nil
+    end
+
+    def finalize
+      @server.close if @server
+      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
+      end
+      logger.info "Skynet Services De-registered in Doozer"
+    end
+
+    # Returns whether the server is running
+    def running?
+      (@server != nil) && !@server.closed?
+    end
+
+    ############################################################################
+    protected
+
+    attr_accessor :server
+
+    # 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
+    end
+
+    # Start the server so that it can start taking RPC calls
+    # Returns false if the server is already running
+    def start
+      return false if running?
+
+      # 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
+      # TODO make port to listen on configurable
+      @server = TCPServer.new('0.0.0.0', self.class.port)
+      run!
+
+      # Register services hosted by this server
+      self.class.services.each_pair {|key, klass| self.class.register_service_in_doozer(klass)}
+      true
+    end
+
+    def run
+      logger.info("Starting listener on #{self.class.hostname}:#{self.class.port}")
+      loop do
+        logger.debug "Waiting for a client to connect"
+        begin
+          handle_connection!(@server.accept)
+        rescue Exception => exc
+          logger.error "Exception while processing connection request", exc
+        end
+      end
+    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.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
+        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
+
+    # Called for each client connection
+    def handle_connection(client)
+      logger.debug "Client connected, waiting for data from client"
+
+      # Process handshake
+      handshake = {
+        'registered' => true,
+        'clientid'   => BSON::ObjectId.new.to_s
+      }
+      client.write(BSON.serialize(handshake))
+      Common.read_bson_document(client)
+
+      while(header = Common.read_bson_document(client)) do
+        logger.debug "\n******************"
+        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$/
+        raise "Invalid Skynet RPC Request, servicemethod must end with '.Forward'" unless match
+        service_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)
+        rescue 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
+
+        if reply
+          logger.debug "Sending Header"
+          # For this test we just send back the received header
+          client.write(BSON.serialize(header))
+
+          logger.debug "Sending Reply"
+          logger.trace 'Reply', reply
+          client.write(BSON.serialize({'out' => BSON.serialize(reply).to_s}))
+        else
+          logger.debug "Closing client since no reply is being sent back"
+          break
+        end
+      end
+      # Disconnect from the client
+      client.close
+      logger.debug "Disconnected from the client"
+    end
+
+  end
+end

data/lib/ruby_skynet/service.rb

@@ -0,0 +1,58 @@
+# Doozer entries are in json
+require 'multi_json'
+require 'thread_safe'
+
+#
+# RubySkynet Service
+#
+# Supports
+#   Hosting Skynet Services
+#   Skynet Service registration
+#
+module RubySkynet
+  module Service
+    def self.included(base)
+      base.extend 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 te 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
+
+      # 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
+end
+
+

data/lib/ruby_skynet/version.rb

@@ -1,3 +1,3 @@
 module RubySkynet #:nodoc
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/test/doozer_client_test.rb

@@ -6,9 +6,6 @@ require 'test/unit'
 require 'shoulda'
 require 'ruby_skynet/doozer/client'
 
-SemanticLogger::Logger.default_level = :trace
-SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
-
 # NOTE:
 # This test assumes that doozerd is running locally on the default port of 8046
 

data/test/ruby_skynet_client_test.rb

@@ -9,8 +9,11 @@ require 'ruby_skynet'
 require 'simple_server'
 require 'multi_json'
 
-SemanticLogger::Logger.default_level = :trace
-SemanticLogger::Logger.appenders << SemanticLogger::Appender::File.new('test.log')
+# 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 for ResilientSocket::TCPClient
 class RubySkynetClientTest < Test::Unit::TestCase
@@ -59,7 +62,7 @@ class RubySkynetClientTest < Test::Unit::TestCase
       end
 
       teardown do
-        @server.stop if @server
+        @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

data/test/ruby_skynet_service_test.rb

@@ -0,0 +1,73 @@
+# 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 '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
+
+RubySkynet::Server.port = 2100
+RubySkynet::Server.region = 'Test'
+RubySkynet::Server.hostname = 'localhost'
+
+class TestService
+  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 echo(params)
+    params
+  end
+end
+
+# Unit Test for ResilientSocket::TCPClient
+class RubySkynetServiceTest < Test::Unit::TestCase
+  context 'RubySkynet::Service' do
+    context "with server" do
+      setup do
+        RubySkynet::Server.start
+        @service_name = 'TestService'
+        @version = 1
+        @region = 'Test'
+        @doozer_key = "/services/#{@service_name}/#{@version}/#{@region}/localhost/2100"
+      end
+
+      teardown do
+        begin
+          RubySkynet::Server.stop
+        rescue Celluloid::DeadActorError
+        end
+      end
+
+      should "have correct service key" do
+        assert_equal @doozer_key, TestService.service_key
+      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
+        setup do
+          @client = RubySkynet::Client.new(@service_name, @version, @region)
+        end
+
+        should "successfully send and receive data" do
+          reply = @client.call(:echo, 'some' => 'parameters')
+          assert_equal 'some', reply.keys.first
+          assert_equal 'parameters', reply.values.first
+        end
+      end
+
+    end
+  end
+end

data/test/simple_server.rb

@@ -2,11 +2,11 @@ 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
 
-
 # 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)
@@ -26,35 +26,25 @@ end
 # Simple single threaded server for testing purposes using a local socket
 # Sends and receives BSON Messages
 class SimpleServer
-  attr_reader :thread
-  def initialize(port = 2000)
-    start(port)
-  end
+  include Celluloid::IO
 
-  def start(port)
-    @server = TCPServer.open(port)
+  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)
+    run!
+  end
 
-    @thread = Thread.new do
-      loop do
-        @logger.debug "Waiting for a client to connect"
-
-        # Wait for a client to connect
-        on_request(@server.accept)
-      end
+  def run
+    loop do
+      @logger.debug "Waiting for a client to connect"
+      handle_connection!(@server.accept)
     end
   end
 
-  def stop
-    if @thread
-      @thread.kill
-      @thread.join
-      @thread = nil
-    end
-    begin
-      @server.close if @server
-    rescue IOError
-    end
+  def finalize
+    @server.close if @server
   end
 
   # Called for each message received from the client
@@ -78,8 +68,7 @@ class SimpleServer
   end
 
   # Called for each client connection
-  # In a real server each request would be handled in a separate thread
-  def on_request(client)
+  def handle_connection(client)
     @logger.debug "Client connected, waiting for data from client"
 
     # Process handshake
@@ -87,7 +76,7 @@ class SimpleServer
       'registered' => true,
       'clientid' => '123'
     }
-    client.print(BSON.serialize(handshake))
+    client.write(BSON.serialize(handshake))
     read_bson_document(client)
 
     while(header = read_bson_document(client)) do
@@ -102,19 +91,17 @@ class SimpleServer
       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.print(BSON.serialize(header))
+        client.write(BSON.serialize(header))
 
         @logger.debug "Sending Reply"
         @logger.trace 'Reply', reply
-        client.print(BSON.serialize({'out' => BSON.serialize(reply).to_s}))
+        client.write(BSON.serialize({'out' => BSON.serialize(reply).to_s}))
       else
         @logger.debug "Closing client since no reply is being sent back"
         @server.close
         client.close
         @logger.debug "Server closed"
-        #@thread.kill
-        @logger.debug "thread killed"
-        start(2000)
+        run!
         @logger.debug "Server Restarted"
         break
       end
@@ -123,12 +110,12 @@ class SimpleServer
     client.close
     @logger.debug "Disconnected from the client"
   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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_skynet
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-18 00:00:00.000000000 Z
+date: 2012-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: semantic_logger
@@ -98,31 +98,34 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- dev.log
 - Gemfile
 - Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ruby_skynet.rb
 - lib/ruby_skynet/client.rb
+- lib/ruby_skynet/common.rb
 - lib/ruby_skynet/connection.rb
 - lib/ruby_skynet/doozer/client.rb
 - lib/ruby_skynet/doozer/exceptions.rb
 - lib/ruby_skynet/doozer/msg.pb.rb
 - lib/ruby_skynet/exceptions.rb
 - lib/ruby_skynet/registry.rb
+- lib/ruby_skynet/server.rb
+- lib/ruby_skynet/service.rb
 - lib/ruby_skynet/version.rb
-- lib/ruby_skynet.rb
-- LICENSE.txt
 - nbproject/private/config.properties
 - nbproject/private/private.properties
 - nbproject/private/private.xml
 - nbproject/private/rake-d.txt
 - nbproject/project.properties
 - nbproject/project.xml
-- Rakefile
-- README.md
+- test.log
 - test/doozer_client_test.rb
 - test/ruby_skynet_client_test.rb
+- test/ruby_skynet_service_test.rb
 - test/simple_server.rb
-- test.log
 homepage: https://github.com/ClarityServices/ruby_skynet
 licenses: []
 post_install_message: 
@@ -137,7 +140,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4330021218658134009
+      hash: 434624136862152057
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: