servicy 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: caf0064f89f13aec57352cff7a92d144db60444c
-  data.tar.gz: 7b95d789be54127997ed6ea51d709fd18910efe8
+  metadata.gz: d9048f3bb1f1521a29ceeb800dd7b3eb5149c9b7
+  data.tar.gz: 1c474e01e90d51469893fe19be368004cc4654d8
 SHA512:
-  metadata.gz: 0b3af8c73e8b8a5d2a61eef42c89dbef44b528a199e38436ff4ce1a54613d776a4f95fab796c73a736d9321b20917949d891b313ab66ab2cfcf86c011e3a729f
-  data.tar.gz: b4d288ad7756cd24814b5d57de1a15b8f50b1497fde40dc662ec1811d42127746337875afc3a2d6bb3da5417853729c4ff933710c81a84ce0cd1cc070188b1a1
+  metadata.gz: 7eb75dfafdc14c501aeb551579d839991aa312b3d554cadcc1efb410f1c9636651f9d6a8516b88415fe0739b867f242c95fd5e0adec9c067941d95c094e54d9b
+  data.tar.gz: 4986b4d40c49b4bb5b78f427fb5ccb25da068cb22bb225c09ca4adc245a8805af3f6ce62acb1f5b44153599a5cb740064a01700a172e9c6796ac23a5a964b126

data/README.md

@@ -245,6 +245,27 @@ with the provided query. In the last two queries, additional error information
 may be provided, but should be considered for human-use only; ie, showing an
 error message to a user.
 
+Notes on design of your objects
+===============================
+
+See [here](http://martinfowler.com/articles/distributed-objects-microservices.html).
+It's a good article. The upshot is that, while hiding weather or not an object
+is remote is good for programmer burden (ie, it reduces it), it's bad for API
+design.
+
+Servicy's goal is to make it simple for you to build microservices in Ruby that
+can either run locally or remotely without the developer having to worry about
+or care which. That said, as the developer of a service, it is _your_
+responsibility to make sure that you don't make services that suck (tm).
+
+Don't build your objects to have iterators that require multiple-traversals
+over the wire. Don't build objects that lazy-evaluate things. Don't build
+objects that themselves rely on other services that are poorly built. Etc.
+
+Do eat your own dogfood, and use your own toilet paper. If it hurts for you to
+use it, with all your insider knowledge and perspective, it is downright agony
+for other people.
+
 TODO
 ====
 
@@ -253,5 +274,8 @@ Things left to do:
 1. In the command-line tool, there is some kind of bug where the registration
    message never returns back to the client. This causes registration to hang
    forever...
-1. There are a number of just kind of ugly-code things around that I should sort out.
-1. Probably some other things that I'm forgetting.
+1. I should sit down and really think out code structure and refactor where
+   needed. Things are getting a little difficult to follow if you are jumping
+   around between files a bunch.
+1. I need to cut down on the number of latency and heartbeat entries that are
+   saved. It gets a bit out of hand.

data/Servicy.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: servicy 0.0.3 ruby lib
+# stub: servicy 0.0.5 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "servicy"
-  s.version = "0.0.3"
+  s.version = "0.0.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Thomas Luce"]
-  s.date = "2014-08-11"
+  s.date = "2014-08-15"
   s.description = "A service registration and discovery framework, as a server and client library."
   s.email = "thomas.luce@gmail.com"
   s.executables = ["servicy"]
@@ -25,6 +25,9 @@ Gem::Specification.new do |s|
     "bin/servicy",
     "lib/api.rb",
     "lib/client.rb",
+    "lib/configurable.rb",
+    "lib/formats.rb",
+    "lib/formats/json.rb",
     "lib/hash.rb",
     "lib/load_balancer.rb",
     "lib/load_balancer/random.rb",
@@ -36,6 +39,7 @@ Gem::Specification.new do |s|
     "lib/servicy.rb",
     "lib/transport/in_memory_transport.rb",
     "lib/transport/messages.rb",
+    "lib/transport/null_transport.rb",
     "lib/transport/tcp_transport.rb",
     "lib/transports.rb",
     "test.rb"
@@ -43,5 +47,17 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/thomasluce/servicy"
   s.rubygems_version = "2.2.2"
   s.summary = "A service registration and discovery framework"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<contraction>, [">= 0"])
+    else
+      s.add_dependency(%q<contraction>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<contraction>, [">= 0"])
+  end
 end
 

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.5

data/lib/api.rb

@@ -1,14 +1,8 @@
-# TODO: Investigate this kind of thing using Delegator to see if I can get
-# a speed boost. Each exported method would have to be dynamically defined
-# in the API class to do contract checking and then pass that on to the
-# delegated object. I don't, however, know if that's actually faster than
-# using method_missing. Investigate
 module Servicy
   class API
-    def self.create(klass, method_descriptions)
-      @klass = klass
-      method_descriptions = { class:    method_descriptions[:class].inject({}) { |h, info| h[info[:method].to_sym] = info; h },
-                              instance: method_descriptions[:instance].inject({}) { |h, info| h[info[:method].to_sym] = info; h }
+    def self.create(klass, mds)
+      method_descriptions = { class:    mds[:class].inject({}) { |h, info| h[info[:method].to_sym] = info; h },
+                              instance: mds[:instance].inject({}) { |h, info| h[info[:method].to_sym] = info; h }
                             }
 
       # We inherit from API here so that in the future we can add functionality
@@ -16,27 +10,42 @@ module Servicy
       # This may change to Client at some point... Who
       # knows.
       magic_class = Class.new(Servicy::API) do
-        @@base_class = klass
-        @@method_descriptions = method_descriptions
-
         def initialize(*args)
-          @instance = @@base_class.new(*args)
+          @instance = self.class.const_get('BASE_CLASS').new(*args)
         end
 
-        def method_descriptions
-          @@method_descriptions
+        def self.set_remote(client)
+          @remote = client
+        end
+        def self.remote?
+          @remote
+        end
+        def self.client
+          @remote
         end
 
+        # TODO: I'm thinking that I might be able to do this with
+        # #define_method's instead. That will spead things up aroud 2-5x.
+
         # The magic happens in the two method_missing methods.
         # Meta-programming-averse; gaze upon my works, ye haughty, and despair!
         def method_missing(method, *args, &block)
           # Verify the contract
-          data = method_descriptions[:instance][method]
-          raise NoMethodError.new("#{@klass.to_s} does not expose an API endpoint called, #{method.to_s}") unless data
+          data = self.class.const_get('METHOD_DESCRIPTIONS')[:instance][method]
+          raise NoMethodError.new("#{self.class.const_get('BASE_CLASS')} does not expose an API endpoint called, #{method.to_s}") unless data
           data[:contract].valid_args?(*args)
 
           # Dispatch the result
-          result = @instance.send(method, *args, &block)
+          result = nil
+          if self.class.remote?
+            params = data[:contract].params.each_with_index.inject({}) do |h, (param, index)|
+              h[param.to_s] = args[index]
+              h
+            end
+            result = self.class.client.transport.remote_request(method, params)
+          else
+            result = @instance.send(method, *args, &block)
+          end
 
           # Check the result
           data[:contract].valid_return?(*args, result)
@@ -47,17 +56,26 @@ module Servicy
 
         # Make sure that we can respond to the things we actually do respond to.
         def respond_to?(method)
-          method_descriptions[:instance].include?(method) || super
+          self.class.const_get('METHOD_DESCRIPTIONS')[:instance].include?(method) || super
         end
 
         def self.method_missing(method, *args, &block)
           # Verify the contract
-          data = @@method_descriptions[:class][method]
-          raise NoMethodError.new("#{@klass.to_s} does not expose an API endpoint called, #{method.to_s}") unless data
+          data = self.const_get('METHOD_DESCRIPTIONS')[:class][method]
+          raise NoMethodError.new("#{self.const_get('BASE_CLASS')} does not expose an API endpoint called, #{method.to_s}") unless data
           data[:contract].valid_args?(*args)
 
           # Dispatch the result
-          result = @@base_class.send(method, *args, &block)
+          result = nil
+          if remote?
+            params = data[:contract].params.each_with_index.inject({}) do |h, (param, index)|
+              h[param.to_s] = args[index]
+              h
+            end
+            result = client.transport.remote_request(method, params)
+          else
+            result = self.const_get('BASE_CLASS').send(method, *args, &block)
+          end
 
           # Check the result
           data[:contract].valid_return?(*args, result)
@@ -67,14 +85,14 @@ module Servicy
         end
 
         def self.respond_to?(method)
-          @@method_descriptions[:class].include?(method) || super
+          const_get('METHOD_DESCRIPTIONS')[:class].include?(method) || super
         end
 
         # Send back either all the documentation, or just for a particular
         # method.
         def self.docs(method=nil)
           if method.nil?
-            return @@method_descriptions.map do |(type, methods)|
+            return const_get('METHOD_DESCRIPTIONS').map do |(type, methods)|
               methods.values.map { |v| v[:docs] }
             end.flatten
           else
@@ -83,7 +101,7 @@ module Servicy
               search_in = method[0] == '.' ? [:class] : (method[0] == '#' ? [:instance] : search_in)
             end
             search_in.each do |type|
-              @@method_descriptions[type].each do |(name,stuff)|
+              const_get('METHOD_DESCRIPTIONS')[type].each do |(name,stuff)|
                 return stuff[:docs] if method.to_s =~ /(\.|#)?#{name.to_s}$/
               end
             end
@@ -95,6 +113,8 @@ module Servicy
       klass.constants(false).each do |const|
         magic_class.const_set(const, klass.const_get(const))
       end
+      magic_class.const_set('BASE_CLASS', klass)
+      magic_class.const_set('METHOD_DESCRIPTIONS', method_descriptions)
 
       # Give it a good name
       class_name = "#{klass.to_s}API"
@@ -117,10 +137,5 @@ module Servicy
 
       { name: name, host: 'localhost', port: port, version: version, heartbeat_port: heartbeat_port }
     end
-
-    # Sets the remote configuration options
-    def set_remote_configuration(config)
-      @remote_config = config
-    end
   end
 end

data/lib/client.rb

@@ -12,23 +12,35 @@ module Servicy
 
     # Create a new Client instance
     def initialize(transport=nil)
-      @transport = transport || Transport.InMemory.new
+      @transport = transport || Servicy.client.transport
+    end
+
+    # Return weather or not you are connected to a remote servicy server
+    def connected?
+      @transport.send(Servicy::Transport::Message.query(name: 'com.servicy.not.a.real.service')) rescue return false
+      true
     end
 
     # Register a service with the service discovery portal found at the other
     # end of @transport
     def register_service(args)
+      if !args.is_a?(Hash) && args.ancestors.include?(Servicy::API)
+        args = args.search_query
+      end
+
       if args.is_a?(Hash)
         @transport.send(Servicy::Transport::Message.registration(Servicy::Service.new(args)))
       else
-        # TODO: Check if it's an API, and if so register with that.
+        raise ArgumentError.new("Don't know how to register type, #{args.inspect}")
       end
     end
 
     # Find a single service matching a query. This will cause the server to use
     # whatever configured load-balancing mechanism is configured for it.
     def find_service(args)
-      service = @transport.send(Servicy::Transport::Message.query_one(args)).services.first
+      result = @transport.send(Servicy::Transport::Message.query_one(args))
+      services = result && result.services
+      service = services && services.first
       service && Servicy::Service.new(service)
     end
 
@@ -79,18 +91,6 @@ module Servicy
       API.create klass, data
     end
 
-    # Ask the server at the other end of transport for a provider for the
-    # provided API object, and configure the API object to use the remote
-    # service.
-    def self.find_service_provider_for(api, transport)
-      client  = Client.new(transport)
-      service = client.find_service(api.search_query)
-      raise ServiceNotFoundError.new(api.search_query) unless service
-
-      api.set_remote_configuration(service.to_h)
-      api
-    end
-
     private
 
     # Get the contents of a file that contains a method, along with the line

data/lib/configurable.rb

@@ -0,0 +1,19 @@
+class Configurable
+  def initialize
+    @stuff = {}
+  end
+
+  def method_missing(name, *args, &block)
+    if name.to_s =~ /=$/
+      @stuff[name.to_s.sub(/=$/, '')] = args.first
+      return
+    end
+
+    return @stuff[name] if @stuff[name]
+    @stuff[name] = Configurable.new
+  end
+
+  def nil?
+    true
+  end
+end

data/lib/formats/json.rb

@@ -0,0 +1,18 @@
+require 'json'
+
+module Servicy
+  module Formats
+    class JSON < Servicy::Format
+      class << self
+        def format(things)
+          things.to_json
+        end
+
+        def unformat(things)
+          return nil if things == "null"
+          return ::JSON.parse(things) rescue ::JSON.parse("[#{things.inspect}]").first
+        end
+      end
+    end
+  end
+end

data/lib/formats.rb

@@ -0,0 +1,36 @@
+# Formats decide how a thing is encoded over the wire, regardless of what
+# transport protocol is used. So, if you want to send protobufs over HTTP go
+# nuts, dude.
+module Servicy
+  # This represents an abstract class that should be overwritten for individual
+  # formats.
+  class Format
+    class << self
+      # @param [Hash] things is a key-value pairing where the values are the
+      # things to be encoded. You can call this recursively for nested objects.
+      def format(things)
+        raise NotImplementedError.new
+      end
+
+      # Turn a formatted thing back into a native representation
+      def unformat(thing)
+        raise NotImplementedError.new
+      end
+    end
+  end
+
+  module Formats
+    def self.method_missing(name, *args, &block)
+      c = Servicy::Formats.const_get(name)
+      return c if c && c.ancestors.include?(Servicy::Format)
+    rescue
+      super
+    end
+  end
+end
+
+# Load all the formatters
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'formats', '*.rb'))].each do |file|
+  next if file.start_with?('.') || File.directory?(file)
+  require File.expand_path(file)
+end

data/lib/server/server.rb

@@ -9,52 +9,47 @@ module Servicy
     # TODO: I should really make this take an options hash, but that will
     # require changing a lot of shit...
     def initialize(transport=nil, load_balancer=nil, logger_stream=nil, config_file=nil)
-      @transport            = transport || InMemoryTransport.new
+      @transport            = transport || Servicy.config.server.transport
       @services             = [] # All services
       @deactivated_services = [] # Dead services
-      @load_balancer        = load_balancer || RoundRobinLoadBalancer.new
-      logger_stream       ||= File.open(File.join('/var', 'log', 'servicy_server.log'), 'a')
-      @logger               = Logger.new(logger_stream)
-      @config_file          = config_file || File.expand_path("~/.servicy.conf")
+      @load_balancer        = load_balancer || Servicy.config.server.load_balancer
+      @config_file          = config_file   || Servicy.config.server.config_file
       start_heartbeat_process
     end
 
     # Starts the {Servicy::Transport} listening (whatever that means for the
     # implementation), gets messages, handles them, and sends replies.
-    # TODO: I think I might need to invert this so that it tells the transport
-    # to start, and passes a block to the start method that handles the
-    # messages... That way I can have the transport fork when a connection
-    # comes in, handle it, and clean up the fork when it's done, allowing
-    # everything to keep chugging along.
     def go!
       transport.start do |message|
-        @logger.info "Received message, #{message.inspect}"
+        Servicy.logger.info "Received message, #{message.inspect}"
         last_service_count = @services.length
 
-        result = nil
-        if message.message == 'registration'
+        result = case message.message
+        when 'registration'
           self.register message.service
-          result = Transport::Message.success
-        elsif message.message == 'query'
+          Transport::Message.success
+        when 'query'
           if message.only_one
             temp = [self.find_one(message.query)].compact
           else
             temp = self.find(message.query)
           end
-          result = Transport::Message.services temp
-        elsif message.message == 'stats'
+          Transport::Message.services temp
+        when 'stats'
           # Gather stats about the running system, and return it
           # TODO: Other stats?
-          result = Transport::Message.statistics(num_services: last_service_count,
+          Transport::Message.statistics(num_services: last_service_count,
                                                  uptimes: uptimes,
                                                  latencies: latencies
                                                 )
         else
-          result = Transport::Message.error("Bad message type, #{message.inspect}")
+          Transport::Message.error("Bad message type, #{message.inspect}")
         end
 
         if @services.length > last_service_count
+          Servicy.logger.debug("Saving to #{@config_file}")
           self.save!(@config_file)
+          Servicy.logger.debug("Saved")
           last_service_count = @services.length
         end
         result
@@ -107,13 +102,17 @@ module Servicy
     #   tests and README.md for examples.
     def register(args)
       service = Service.new(args)
-      @logger.info "Registering service, #{service.inspect}..."
+      Servicy.logger.info "Registering service, #{service}..."
       if service.up?
-        @logger.info "Service, #{service}, up; registered."
-        @services << service
+        if @services.include? service
+          Servicy.logger.info "Service, #{service}, already exists. Not duplicating"
+        else
+          @services << service
+          Servicy.logger.info "Service, #{service}, up; registered."
+        end
         return service
       else
-        @logger.info "Service, #{service}, down; not registered."
+        Servicy.logger.info "Service, #{service}, down; not registered."
         return false
       end
     end
@@ -122,7 +121,8 @@ module Servicy
     # active list of services that are available to searches, etc.
     # @param [{Service}] service the service to de-register
     def unregister(service)
-      @logger.info "De-registering service, #{service}"
+      return if @deactivated_services.include?(service)
+      Servicy.logger.info "De-registering service, #{service}"
       @deactivated_services << service
     end
 
@@ -131,7 +131,7 @@ module Servicy
     # @param [{Service}] service The service to remove from deactivated list
     def reregister(service)
       if @deactivated_services.delete(service)
-        @logger.info "Re-registering service, #{service}"
+        Servicy.logger.info "Re-registering service, #{service}"
       end
     end
 
@@ -160,16 +160,53 @@ module Servicy
     end
 
     # Find one or more services based on some search criteria.
-    # TODO: Give more documentation about this here.
+    # When finding things, you can search by any single or combination of name,
+    # version, and api definition. When searching for name:
+    #
+    #    find(name: 'com.foobar.baz')
+    #
+    # ... or for wild-cards if you don't care who provides a thing
+    #
+    #    find(name: '.baz')
+    #
+    # For searching by version, you can search by absolute version number,
+    # minimum, maximum, or a range (by passing min and max together):
+    #
+    #    # Absolute version
+    #    find(version: '1.2.4-p123')
+    #
+    #    # Min and max as range
+    #    find(min_version: '1.2.0', max_version: '2.0.0')
+    #
+    # All version numbers must follow the format:
+    #
+    #   (major).(minor).(revision)(-patch)?
+    #
+    # And are compared to one another by converting the version to numbers and
+    # comparing those numbers. The version happens by:
+    #
+    #    (major * 1000) + (minor * 100) + (revision * 10) + (1/patch)
+    #
+    # Searching by api can be used to search for a service that provides a
+    # certain interface, even if you don't know what that interface is called.
+    # For example, if you don't know what your authorization service is called,
+    # but you know that it takes 2 strings (username and password) and returns
+    # either false or a User object, you can search by:
+    #
+    #    find(api: '.login/2[String,String] -> User|nil')
+    #
+    # NOTE The query syntax listed here isn't working currently. See
+    # {Servicy::ServiceSearcher} for information on how to actually search by
+    # api in the current version.
     def find(args={})
-      @logger.info "Finding #{args.inspect}..."
+      Servicy.logger.info "Finding #{args.inspect}..."
 
       searcher = Servicy::ServiceSearcher.new(services - deactivated_services)
       searcher.filter_by_name args[:name]
       searcher.filter_by_versions args[:min_version], args[:max_version], args[:version]
       searcher.filter_by_api args[:api]
 
-      @logger.info "Found #{searcher.services.inspect}"
+      Servicy.logger.info "Found #{searcher.services.length} providers for #{args.inspect}"
       searcher.services
     end
 

data/lib/server.rb

@@ -3,6 +3,5 @@ require 'json'
 require 'transports'
 require 'transport/in_memory_transport'
 require 'load_balancer'
-require 'logger'
 require 'server/service_searcher'
 require 'server/server'

data/lib/service.rb

@@ -4,7 +4,7 @@ module Servicy
   class Service
     include Comparable
     attr_reader :name, :version, :host, :port, :heartbeat_port, :protocol,
-      :api, :heartbeat_check_rate, :latencies, :heartbeats
+      :api, :heartbeat_check_rate, :latencies, :heartbeats, :no_heartbeat
     attr_accessor :heartbeat_last_check
 
     NAME_REGEX    = /[^\.]+\.([^\.]+\.?)+/
@@ -50,9 +50,14 @@ module Servicy
       @heartbeat_port       = args[:heartbeat_port]
       @api                  = args[:api] || {}
       @heartbeat_check_rate = args[:heartbeat_check_rate] || 1
+      @transport            = transport_from_class_or_string(args[:protocol] || Servicy.config.client.transport)
+      if @transport
+        args[:protocol] = @transport.protocol_string # This is to make sure that it loads correctly after saving to disk.
+      end
       @heartbeat_last_check = 0
       @latencies            = []
       @heartbeats           = []
+      @no_heartbeat         = !!args[:no_heartbeat]
     end
 
     # Get a configuration value
@@ -99,12 +104,13 @@ module Servicy
     def self.version_as_number(version)
       parts = version.split('.')
       parts.last.gsub(/\D/, '')
-      parts[0].to_i * 1000 + parts[1].to_i * 100 + parts[2].to_i * 10 + (parts[3] || 0)
+      parts[0].to_i * 1000 + parts[1].to_i * 100 + parts[2].to_i * 10 + (1 / (parts[3] || 1).to_f)
     end
 
     # Check weather or not a service is up, based on connecting to the hearbeat
     # port, and reading a single byte.
     def up?
+      return true if skip_heartbeat?
       t1 = Time.now
       s = TCPSocket.new(host, heartbeat_port)
       Timeout.timeout(5) do
@@ -161,11 +167,37 @@ module Servicy
       api[method_type] && api[method_type].select { |a| a[:name] == method }.first
     end
 
+    # Make a call to a remote end-point.
+    def remote_call(method, *args)
+      # TODO: think about handling errors in a sane way
+
+      # Encode things for the transports formatter
+      args = @transport.format(args)
+
+      # Make the call
+      @transport.remote_request(method, args)
+
+      # Decode things coming back
+      @transport.unformat(result)
+    end
+
     private
 
+    def skip_heartbeat?
+      !!no_heartbeat
+    end
+
+    def transport_from_class_or_string(transport)
+      transport.is_a?(Servicy::Transport) ? transport : transport_from_string(transport)
+    end
+
+    def transport_from_string(transport)
+      Servicy::Transport.all.select { |t| t.protocol_string == transport }.first
+    end
+
     # These are just to keep us from filling up memory.
     def record_latency(t1, t2)
-      @latencies << t2 - t1
+      @latencies << t2.to_i - t1.to_i
       @latencies = @latencies[0...10] if @latencies.length > 10
     end
 

data/lib/servicy.rb

@@ -1,9 +1,163 @@
 $: << File.expand_path(File.join(File.dirname(__FILE__)))
 
-# NOTE: You will almost never need both of these things. In all likeliness, you
-# will want to do something like `require 'servicy/client'` yourself. This is
-# here mostly as a convinience to rspec.
 require 'hash'
+require 'formats'
 require 'server'
 require 'client'
 require 'api'
+require 'configurable'
+require 'logger'
+
+module Servicy
+  # Get a logger instance that we can do something useful with.
+  def self.logger
+    @logger ||= begin
+                  stream = config.server.logger_stream
+                  stream = stream || File.open(File.join('/var', 'log', 'servicy_server.log'), 'a')
+                  Logger.new(stream)
+                end
+  end
+
+  # After this method gets done running, you either have the state of the world
+  # exactly the same as it was, or your object is replaced in the global Object
+  # scope with a new object that will proxy methods to a remote service
+  # provider.
+  #
+  # To define a service provider is a bit more work, and less auto-magic
+  # because the exact details of the infrastructure and architecture of your
+  # setup will be very different from others. So Servicy doesn't make
+  # assumptions about how you want to do things. That said, it's relatively
+  # simple:
+  #
+  #   # In some server class
+  #   Servicy::Server.new(...).go!
+  #
+  #   # In some service provider, possibly on a different box
+  #   api = Servicy::Client.create_api_for(MyServiceClass)
+  #   Servicy::Client.register_service(api)
+  # FIXME: @__api, and it's ilk, get overridden in the even that there is more
+  # than one.
+  def self.included(mod)
+    make_service_listener(mod)
+
+    # Attempt to find the service
+    client = Servicy::Client.new(config.server.transport)
+    raise 'go to bottom' unless client.connected?
+
+    # Create a new api object
+    @__api = Servicy::Client.create_api_for(mod)
+    port = Servicy.config.send(mod.to_s.to_sym).port
+    Servicy.logger.debug("Chose port, #{port} for service, #{mod.to_s}")
+    @__api.const_set("PORT", port) unless port.nil?
+    # TODO: for the other things as well
+
+    @__service = client.find_service(@__api.search_query)
+    raise 'go to bottom' unless @__service
+
+    # If all went well, then we can wrap the object to call to the remote
+    # service.
+    client = Servicy::Client.new(config.client.transport.class.new(port: port))
+    @__api.set_remote(client)
+
+    # ... and delegate that ish. We do it by killing off the original object,
+    # and replacing it with our own.
+    Object.send(:remove_const, mod.name.to_sym)
+    Object.const_set(mod.name.to_sym, @__api)
+  rescue => e
+    # Something went wrong, just give up silently, but don't do anything
+    # else; use this object as a regular-ass object. This is to allow you to
+    # use your API objects as normal objects in an environment where the
+    # object is bundled as part of a gem (,say, ) and there is no remote
+    # handler for it: use it locally
+  end
+
+  def self.make_service_listener(mod)
+    # If we didn't manage to connect to a remote client, then we are, by
+    # definition, the provider. We should start the transports api_server, and
+    # dispatch requests here.
+    mod.send(:define_singleton_method, :start_servicy_server) do
+      begin
+        Thread.new do
+          begin
+            port      = Servicy.config.send(self.to_s.to_sym).port    || Servicy.config.server.port
+            transport = Servicy.config.service.transport
+            transport = transport.nil? ? Servicy.config.server.transport : transport
+            client = Servicy::Client.new(transport.class.new(port: port))
+
+            client.transport.start_api do |request|
+              method = nil
+              begin
+                method = self.method(request.method_name.to_sym)
+              rescue
+                method = self.instance_method(request.method_name.to_sym)
+                method = method.bind(self.new)
+              end
+              things = transport.unformat(request.args)
+              args = method.parameters.map do |param|
+                things[param.last.to_s]
+              end
+
+              Servicy.logger.info "Calling #{method} with #{args.inspect}"
+              begin
+                result = method.call(*args)
+                Servicy::Transport::Message.api_response(result)
+              rescue => e
+                Servicy::Transport::Message.error(e.to_s + "\n" + e.backtrace.join("\n"))
+              end
+            end
+
+            client.transport.stop
+          rescue => e
+            Servicy::Transport::Message.error(e.to_s + "\n" + e.backtrace.join("\n"))
+          end
+        end
+
+        Servicy.logger.info "Creating #{self.to_s} api"
+        api = Servicy::Client.create_api_for(self)
+        port = Servicy.config.send(mod.to_s.to_sym).port
+        port = port.nil? ? Servicy.config.server.port : port
+        api.const_set 'PORT', port
+        # TODO: the other things, too
+        Servicy.logger.debug("Chose port, #{port} for service, #{mod.to_s}")
+
+        server_port = Servicy.config.server.port
+        transport = Servicy.config.server.transport
+        client    = Servicy::Client.new(transport.class.new(port: server_port))
+        Servicy.logger.info "Registering api, #{api.to_s}"
+        client.register_service api
+      rescue => e
+        Servicy.logger.error "An error occurred with the service: #{e.to_s}\n#{e.backtrace.join("\n")}"
+      end
+    end
+  rescue => e
+    # Again, just let it die silently. There is no reason to make things not
+    # work locally.
+    Servicy.logger.error(e)
+  end
+
+  # Use this method to configure Servicy for other services
+  def self.configure(&block)
+    conf = Configurable.new
+
+    # Give some reasonable defaults
+    conf.server.host          = 'localhost'
+    conf.server.transport     = Servicy::Transport.InMemory.new
+    conf.server.load_balancer = Servicy::RoundRobinLoadBalancer.new
+    conf.server.logger_stream = File.open(File.join('/var', 'log', 'servicy_server.log'), 'a')
+    conf.server.config_file   = File.expand_path("~/.servicy.conf")
+    # To set something for a given object, you would do something like:
+    # conf.transport.port = 1234
+
+    conf.client.transport = Servicy::Transport.InMemory.new
+    conf.transport.format = Servicy::Formats.JSON
+
+    conf = yield conf if block_given?
+
+    # Set the options
+    @_config = conf
+  end
+
+  def self.config
+    @_config ||= configure
+  end
+end

data/lib/transport/in_memory_transport.rb

@@ -33,7 +33,7 @@ module Servicy
 
     def socket_path
       @socket_path ||= begin
-                         file = Tempfile.new(@config[:path] || 'servicy-in-memory-transport')
+                         file = Tempfile.new(@config[:path] || Servicy.config.transport.path || 'servicy-in-memory-transport')
                          file.close
                          path = file.path
                          file.delete

data/lib/transport/messages.rb

@@ -15,7 +15,8 @@ module Servicy
         if stuff.is_a?(Hash)
           @struct = stuff
         else
-          @struct = JSON.parse(stuff)
+          # TODO: should this be a formatter that I can swap out?
+          @struct = JSON.parse(stuff || stuff.to_s)
         end
       end
 
@@ -117,6 +118,25 @@ module Servicy
         })
       end
 
+      # Make a remote API call.
+      # @param [String] method The method to call on the remote implementor.
+      # @param [Hash{String => Object}] args The arguments to pass to the method.
+      #    These are expected to be pre-formatted by an appropriate Formatter
+      def self.api(method, args)
+        new({
+          message: 'api',
+          method_name: method,
+          args: args
+        })
+      end
+
+      def self.api_response(result)
+        new({
+          message: 'api_response',
+          result: result
+        })
+      end
+
       # Allow comparing of messages. This doesn't make for useful sorting, at
       # the moment, but does make it easy to know if two things are saying the
       # same thing.

data/lib/transport/null_transport.rb

@@ -0,0 +1,22 @@
+require 'transports'
+
+# A transport which does nothing
+module Servicy
+  # This is a simple transport implementation that is to be used primarily for
+  # testing, so that I don't have to have a bunch of servers running just to
+  # run rspec...
+  class NilTransport < Servicy::Transport
+    def send(message)
+      nil
+    end
+
+    def start
+      while true
+      end
+    end
+
+    def stop
+      nil
+    end
+  end
+end

data/lib/transport/tcp_transport.rb

@@ -7,44 +7,65 @@ module Servicy
   # file" business works out well...
   class TCPTransport < Servicy::Transport
     HELLO = "Servicy says HI!"
+
     def send(message)
+      Servicy.logger.debug("Connecting")
       socket = TCPSocket.new host, port
       hello = socket.gets
       raise "Not a servicy server" unless hello.strip == HELLO
-      socket.send message.body + "\n", 0
-      # FIXME: For some reason, this stalls when using the command-line client.
-      # Wireshark isn't helpful while I'm on the vpn, so I will have to fix
-      # this later.
-      message = Message.new(socket.gets)
+      Servicy.logger.debug("Sending #{message.body}")
+      socket.puts message.body
+      response = socket.gets
+      Servicy.logger.debug("Received #{response}")
+      message = Message.new(response)
       socket.close
       message
     end
 
     def start(&block)
       @server = TCPServer.open(port)
-      while s = @server.accept
-        Thread.new do
-          s.puts HELLO
-          message = Message.new s.gets
-          result = yield message
-          s.puts result.body
-          s.close
+
+      loop do
+        Thread.start(@server.accept) do |client|
+          client.puts HELLO
+          message = Message.new client.gets
+          Servicy.logger.debug("Got #{message.body}")
+          result = block.call(message)
+          Servicy.logger.debug("Replying #{result.body}")
+          client.puts result.body
+          client.close
+          Servicy.logger.debug("Closed connection")
         end
       end
     end
+    alias_method :start_api, :start
 
     def stop
       @server && @server.close
     end
 
+    # This makes a request as an actual API consumer over the wire, and returns
+    # the results.
+    def remote_request(name, args)
+      args = format(args)
+      response = send(Message.api(name, args))
+      if response.struct['error']
+        raise response.error
+      else
+        results = unformat(response.result)
+      end
+    end
+
     private
 
     def host
-      @config[:host]
+      host = Servicy.config.client.host
+      host = host.nil? ? 'localhost' : host
+      @config[:host] || host
     end
 
     def port
-      @config[:port]
+      @config[:port] || Servicy.config.transport.port
     end
   end
 end

data/lib/transports.rb

@@ -16,7 +16,7 @@ module Servicy
 
     # Override this method to send a message from {Client} to {Server}
     def send(messge)
-      raise 'Not implemented'
+      raise NotImplementedError.new
     end
 
     # Override this method to yield a message when received on the {Server}. It
@@ -24,7 +24,12 @@ module Servicy
     # {Transport::Message} object, and send back the return value of the block
     # to the client.
     def start(&block)
-      raise 'Not implemented'
+      raise NotImplementedError.new
+    end
+
+    # Same as start, but used in creation of API handlers.
+    def start_api(&block)
+      raise NotImplementedError.new
     end
 
     # Called when a transport is stopped
@@ -44,6 +49,39 @@ module Servicy
     rescue
       super
     end
+
+    def self.all
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+
+    # Returns a printable string representing what protocol this would be used
+    # as. Override if you like.
+    def self.protocol_string
+      self.name.split("Transport").first
+    end
+
+    # @param [Hash] values Key-value pairs for things to encode.
+    def format(values)
+      formatter.format(values);
+    end
+
+    def unformat(values)
+      formatter.unformat(values)
+    end
+
+    # Method called to make a remote request of an API call. To be implemented
+    # per transport.
+    # @return [Object] the raw values coming back from the request, to be
+    #    passed to the formatter for unformatting.
+    def remote_request(name, args)
+      raise NotImplementedError.new
+    end
+
+    private
+
+    def formatter
+      @formatter ||= @config['format'] || Servicy.config.transport.format
+    end
   end
 end
 

data/test.rb

@@ -1,74 +1,100 @@
 require './lib/servicy'
 
-class Foo
-  def initialize(thing)
-    @thing = thing
-  end
-
-  # Do some foobar work
-  # @param [String] a
-  # @param [Integer] b
-  def foobar(a,b)
-    p a
-    p b
-  end
-
-  # Do something on the class
-  # @return [Hash{Integer => Array<String>}]
-  def self.barbaz
-    puts "OH MY GOD!"
-    { 1 => ['foo', 'bar'] }
-  end
+Servicy.configure do |config|
+  config.server.transport = Servicy::Transport.TCP.new(port: 1234)
+  config
 end
 
-# Create a new class that wraps foo. It will be called FooAPI, and will behave
-# just like foo, but with contract checking. It will be the place that in the
-# future we extend to behave more like an API
-api = Servicy::Client.create_api_for Foo
-# p api
-
-# Instance-y-stuff
-foo = api.new(:something)
-foo.foobar('string',1)
+server = Servicy::Server.new
+Thread.new { server.go! }
 
-# Class-y stuff
-api.barbaz
-
-# Now we should get some explosions for failing to comply with the contracts
-begin
-  foo.foobar(:not_a_string, 'or an integer')
-rescue => e
-  puts e
+class Foobar
 end
+api = Servicy::Client.create_api_for(Foobar)
 
-###############################################################################
-# Making a working api with an api object. This is just some ideas to outline
-# how I would like the interface to look, not really any working code just yet.
-#
-
-# Finding a registered service and using a remote service instead of a local
-# object. This would take the API object, gather information about it, make the
-# query to the service discovery portal, and return a new api model (that is
-# the same specifications as the original) that talks with the remote service
-# instead of the local object, raising an error if something goes wrong.
-transport = Servicy::Transport.TCP.new(port: 1234)
-api = Servicy::Client.find_service_provider_for(api, transport)
-
-# This should also be able to work with non-API objects given to it. In the
-# case of a library that you don't have installed locally.
-service = Servicy::Client.find_service(name: 'foobar') # This alredy exists
-api     = service.api
+server.register(api.search_query)
 
-# Starting a server with a given client/api object. Ideally, you can start
-# multipl servers.
-api.start_server('HTTP', 80)
-api.start_server('HTTPS', 443)
-api.start_server('TCP', 1235)
+class Foobar
+  # @param [String] a
+  def foo(a)
+    puts "If you see this, something went wrong"
+  end
 
-# Maybe it would be better to do it with Transport objects...
-t = Transport.tcp.new(1235)
-api.start_server t
+  include Servicy
+end
 
-# Combining registration and server starting
-api.register_with('127.0.0.1:1234', Transport.TCP.new(1235))
+f = Foobar.new
+p f
 
+# class Foo
+#   def initialize(thing)
+#     @thing = thing
+#   end
+# 
+#   # Do some foobar work
+#   # @param [String] a
+#   # @param [Integer] b
+#   def foobar(a,b)
+#     p a
+#     p b
+#   end
+# 
+#   # Do something on the class
+#   # @return [Hash{Integer => Array<String>}]
+#   def self.barbaz
+#     puts "OH MY GOD!"
+#     { 1 => ['foo', 'bar'] }
+#   end
+# end
+# 
+# # Create a new class that wraps foo. It will be called FooAPI, and will behave
+# # just like foo, but with contract checking. It will be the place that in the
+# # future we extend to behave more like an API
+# api = Servicy::Client.create_api_for Foo
+# # p api
+# 
+# # Instance-y-stuff
+# foo = api.new(:something)
+# foo.foobar('string',1)
+# 
+# # Class-y stuff
+# api.barbaz
+# 
+# # Now we should get some explosions for failing to comply with the contracts
+# begin
+#   foo.foobar(:not_a_string, 'or an integer')
+# rescue => e
+#   puts e
+# end
+# 
+# ###############################################################################
+# # Making a working api with an api object. This is just some ideas to outline
+# # how I would like the interface to look, not really any working code just yet.
+# #
+# 
+# # Finding a registered service and using a remote service instead of a local
+# # object. This would take the API object, gather information about it, make the
+# # query to the service discovery portal, and return a new api model (that is
+# # the same specifications as the original) that talks with the remote service
+# # instead of the local object, raising an error if something goes wrong.
+# transport = Servicy::Transport.TCP.new(port: 1234)
+# api = Servicy::Client.find_service_provider_for(api, transport)
+# 
+# # This should also be able to work with non-API objects given to it. In the
+# # case of a library that you don't have installed locally.
+# service = Servicy::Client.find_service(name: 'foobar') # This alredy exists
+# api     = service.api
+# 
+# # Starting a server with a given client/api object. Ideally, you can start
+# # multipl servers.
+# api.start_server('HTTP', 80)
+# api.start_server('HTTPS', 443)
+# api.start_server('TCP', 1235)
+# 
+# # Maybe it would be better to do it with Transport objects...
+# t = Transport.tcp.new(1235)
+# api.start_server t
+# 
+# # Combining registration and server starting
+# api.register_with('127.0.0.1:1234', Transport.TCP.new(1235))
+# 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: servicy
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Thomas Luce
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-11 00:00:00.000000000 Z
-dependencies: []
+date: 2014-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: contraction
+  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: A service registration and discovery framework, as a server and client
   library.
 email: thomas.luce@gmail.com
@@ -25,6 +39,9 @@ files:
 - bin/servicy
 - lib/api.rb
 - lib/client.rb
+- lib/configurable.rb
+- lib/formats.rb
+- lib/formats/json.rb
 - lib/hash.rb
 - lib/load_balancer.rb
 - lib/load_balancer/random.rb
@@ -36,6 +53,7 @@ files:
 - lib/servicy.rb
 - lib/transport/in_memory_transport.rb
 - lib/transport/messages.rb
+- lib/transport/null_transport.rb
 - lib/transport/tcp_transport.rb
 - lib/transports.rb
 - test.rb