servicy 0.0.3

data/lib/api.rb

@@ -0,0 +1,126 @@
+# 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 }
+                            }
+
+      # We inherit from API here so that in the future we can add functionality
+      # for setting up servers, service discovery, etc.
+      # 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)
+        end
+
+        def method_descriptions
+          @@method_descriptions
+        end
+
+        # 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[:contract].valid_args?(*args)
+
+          # Dispatch the result
+          result = @instance.send(method, *args, &block)
+
+          # Check the result
+          data[:contract].valid_return?(*args, result)
+
+          # And we are good to go
+          result
+        end
+
+        # Make sure that we can respond to the things we actually do respond to.
+        def respond_to?(method)
+          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[:contract].valid_args?(*args)
+
+          # Dispatch the result
+          result = @@base_class.send(method, *args, &block)
+
+          # Check the result
+          data[:contract].valid_return?(*args, result)
+
+          # And we are good to go
+          result
+        end
+
+        def self.respond_to?(method)
+          @@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)|
+              methods.values.map { |v| v[:docs] }
+            end.flatten
+          else
+            search_in = [:class, :instance]
+            if method.is_a?(String)
+              search_in = method[0] == '.' ? [:class] : (method[0] == '#' ? [:instance] : search_in)
+            end
+            search_in.each do |type|
+              @@method_descriptions[type].each do |(name,stuff)|
+                return stuff[:docs] if method.to_s =~ /(\.|#)?#{name.to_s}$/
+              end
+            end
+            return nil
+          end
+        end
+      end
+      magic_class.extend(ExtraMethods)
+      klass.constants(false).each do |const|
+        magic_class.const_set(const, klass.const_get(const))
+      end
+
+      # Give it a good name
+      class_name = "#{klass.to_s}API"
+      Object.const_set(class_name, magic_class)
+    end
+
+    # TODO: API wrappers that create a server of some kind to serve things up
+    # TODO: A gem/library generator based on the API
+  end
+
+  module ExtraMethods
+    # This method is used by the client discovery to build the query that can be
+    # used to find remote instances of this service
+    def search_query
+      domain         = self.const_get(:DOMAIN) rescue `hostname`.strip
+      name           = "#{domain}.#{self.to_s.downcase}"
+      version        = self.const_get(:VERSION) rescue '1.0.0'
+      port           = self.const_get(:PORT) rescue 1234
+      heartbeat_port = self.const_get(:HEARTBEAT_PORT) rescue port
+
+      { 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

@@ -0,0 +1,114 @@
+require 'contraction'
+require 'api'
+
+# The client will be responsible for connecting to servers to do service
+# registration and discovery. I would like the registration to happen
+# auto-magically via reflection and system inspection, but we'll see how that
+# goes.
+module Servicy
+  class Client
+    class ServiceNotFoundError < StandardError; end;
+    attr_reader :transport
+
+    # Create a new Client instance
+    def initialize(transport=nil)
+      @transport = transport || Transport.InMemory.new
+    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)
+        @transport.send(Servicy::Transport::Message.registration(Servicy::Service.new(args)))
+      else
+        # TODO: Check if it's an API, and if so register with that.
+      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
+      service && Servicy::Service.new(service)
+    end
+
+    # Find all services matching a query
+    def find_all_services(args)
+      @transport.send(Servicy::Transport::Message.query(args)).services.map { |s| Servicy::Service.new s }
+    end
+
+    # Send a message requesting server statistics
+    def server_stats
+      @transport.send(Servicy::Transport::Message.statistics)
+    end
+
+    # Creats an api from the provided class' public methods and returns it. You
+    # can then use said API to build a service that exports it over the wire
+    # how you would like.
+    def self.create_api_for(klass)
+      # Get all the public methods, and for each one get their arguments. Parse
+      # around the method to find documentation if any is available.
+      file_contents = {}
+      methods = klass.public_instance_methods - Object.instance_methods - Module.instance_methods
+      all_methods = Contraction.methods_for klass
+      data = all_methods.inject({}) do |h, (type, methods)|
+        h[type] = methods.map do |method|
+          file, line = read_file_for_method(klass, method, type)
+          # If `file` is nil, there is no source file. Either it's an IRB
+          # session, or a standard library class.
+          next file if file.nil?
+
+          # Walking backwards through the text, we look for RDoc comments
+          lines = file[0...line-1]
+          doc = []
+          lines.reverse.each do |line|
+            line.strip!
+            break unless line.start_with? '#'
+            doc << line
+          end
+          doc.reverse!
+          next if doc.empty?
+
+          contract = Contraction::Parser.parse(doc, klass, method, type)
+
+          { method: method.to_s, docs: doc.join("\n"), contract: contract }
+        end.compact
+        h
+      end
+
+      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
+    # that the method appears on.
+    def self.read_file_for_method(klass, method_name, type)
+      file, line = nil, nil
+      if type == :class
+        file, line = klass.method(method_name).source_location
+      elsif type == :instance
+        file, line = klass.instance_method(method_name).source_location
+      else
+        raise ArgumentError.new("Unknown method type, #{type.inspect}")
+      end
+      return nil, nil unless file # For c extensions and built-ins, source_location returns nil for file.
+      filename = File.expand_path(file)
+      file_contents = File.read(filename).split("\n")
+      return [file_contents, line]
+    end
+  end
+end
+

data/lib/hash.rb

@@ -0,0 +1,14 @@
+class Hash
+  def contains_only?(*args)
+    (keys - args).empty?
+  end
+
+  alias_method :orig_acc, :[]
+  def [](k)
+    return self.orig_acc(k) if self.orig_acc(k)
+    if k.respond_to?(:to_sym)
+      return self.orig_acc(k.to_sym) if self.orig_acc(k.to_sym)
+    end
+    return self.orig_acc(k.to_s) if self.orig_acc(k.to_s)
+  end
+end

data/lib/load_balancer/random.rb

@@ -0,0 +1,12 @@
+module Servicy
+  class RandomLoadBalancer < LoadBalancer
+    def initialize
+      super
+      @last_host_index = {}
+    end
+
+    def next_for_service(service_name)
+      hosts[service_name][rand(hosts[service_name].length)]
+    end
+  end
+end

data/lib/load_balancer/round_robin.rb

@@ -0,0 +1,18 @@
+module Servicy
+  class RoundRobinLoadBalancer < LoadBalancer
+    def initialize
+      super
+      @last_host_index = {}
+    end
+
+    def next_for_service(service_name)
+      @last_host_index[service_name] ||= 0
+      service = hosts[service_name][@last_host_index[service_name]]
+      @last_host_index[service_name] += 1
+      if @last_host_index[service_name] >= hosts[service_name].length
+        @last_host_index[service_name] = 0
+      end
+      service
+    end
+  end
+end

data/lib/load_balancer.rb

@@ -0,0 +1,25 @@
+module Servicy
+  class LoadBalancer
+    attr_accessor :hosts
+
+    def initialize
+      @hosts = {}
+    end
+
+    def next(set)
+      return nil if set.empty?
+      hosts[set.first.name] ||= []
+      hosts[set.first.name] += set
+      hosts[set.first.name].uniq!
+      next_for_service(set.first.name)
+    end
+
+    def next_for_service(service_name)
+      raise 'Not implemented'
+    end
+  end
+end
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'load_balancer')) + "/*.rb"].each do |f|
+  require f.gsub(/.rb$/, '')
+end

data/lib/server/server.rb

@@ -0,0 +1,222 @@
+module Servicy
+  class Server
+    attr_reader :services, :deactivated_services
+    attr_accessor :load_balancer, :transport
+
+    # Create a new server that is used to register and find Services.
+    # @param [{Servicy::Transport}] transport The transport used to send and
+    #    receive messages.
+    # 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
+      @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")
+      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}"
+        last_service_count = @services.length
+
+        result = nil
+        if message.message == 'registration'
+          self.register message.service
+          result = Transport::Message.success
+        elsif message.message == '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'
+          # Gather stats about the running system, and return it
+          # TODO: Other stats?
+          result = Transport::Message.statistics(num_services: last_service_count,
+                                                 uptimes: uptimes,
+                                                 latencies: latencies
+                                                )
+        else
+          result = Transport::Message.error("Bad message type, #{message.inspect}")
+        end
+
+        if @services.length > last_service_count
+          self.save!(@config_file)
+          last_service_count = @services.length
+        end
+        result
+      end
+
+      transport.stop
+    end
+
+    # Shut the server down
+    def stop!
+      transport.stop
+      @heartbeat_thread.kill
+    end
+
+    # Loads a server configuration off disk
+    # @param [String] filename The path of the file to load
+    # @return [Servicy::Server] configured server
+    def self.load(filename)
+      s = Servicy::Server.new
+      s.load!(filename)
+      s
+    end
+
+    # Register a new service
+    # @param [Hash{Symbol => String,Fixnum,Array<Hash>}] args The arguments for the
+    #    service to register. This must include:
+    #      :name
+    #      :host
+    #      :port
+    #    You can also provide optional data,
+    #      :version
+    #      :heartbeat_port
+    #      :protocol
+    #      :api
+    #   :name is the name of the service you are registering, in
+    #   inverted-domain format (ie, "com.foo.api").
+    #   :host must be either an IP address or hostname/domain name that is
+    #   reachable by the Server instance (and any API consumers, of course.)
+    #   :port must be an integer between 1 and 65535, as with :heartbeat_port,
+    #   and is the port used to connect to the service provider.
+    #   :heartbeat_port is the port to connect to to make sure that things are
+    #   still running, and will default to the same as :port.
+    #   :version is the version of the API/service that you are registering,
+    #   and must be in the "major.minor.revision-patch" format, where the patch
+    #   section is optional. For example, "1.0.3-p124". It defaults to,
+    #   "1.0.0".
+    #   :protocol can be anything you like, but is the protocol used to connect
+    #   to the api. It defaults to "HTTP/S", meaning either HTTP or HTTP/TLS
+    #   :api can be an array of hashes that describe the API provided. See the
+    #   tests and README.md for examples.
+    def register(args)
+      service = Service.new(args)
+      @logger.info "Registering service, #{service.inspect}..."
+      if service.up?
+        @logger.info "Service, #{service}, up; registered."
+        @services << service
+        return service
+      else
+        @logger.info "Service, #{service}, down; not registered."
+        return false
+      end
+    end
+
+    # Un-register a previously registered service. This removes it from the
+    # 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}"
+      @deactivated_services << service
+    end
+
+    # Removes a service from the deactivated list if it's there. No
+    # side-effects otherwise.
+    # @param [{Service}] service The service to remove from deactivated list
+    def reregister(service)
+      if @deactivated_services.delete(service)
+        @logger.info "Re-registering service, #{service}"
+      end
+    end
+
+    # Save the service configuration to disk
+    # @param [String] filename The path to where the config should be saved
+    def save!(filename)
+      File.open(filename, 'w') do |f|
+        f.write services.map(&:as_json).to_json
+      end
+    end
+
+    # Load a configuration from disk, and override the current one with it.
+    # @param [String] filename The path to the configuration file.
+    def load!(filename)
+      json = ''
+      File.open(filename, 'r') do |f|
+        json = f.read
+      end
+
+      @config_file = filename
+
+      @services = JSON.parse(json).map do |s|
+        s = s.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+        Servicy::Service.new s
+      end
+    end
+
+    # Find one or more services based on some search criteria.
+    # TODO: Give more documentation about this here.
+    def find(args={})
+      @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}"
+      searcher.services
+    end
+
+    # (see #find)
+    # Return only the first load-balanced instance. If you want load-balancing,
+    # use this.
+    def find_one(args={})
+      load_balancer.next(find(args))
+    end
+
+    # Get a hash of uptimes for each service, where the key is the service name
+    # and hostname, joined with a '#', and the value is the uptime for that
+    # service on that host.
+    # @return [Hash{String => Float}] the uptimes of all services per host.
+    def uptimes
+      services.inject({}) { |h, s| h[s.to_s] = s.uptime; h }
+    end
+
+    # (see #uptimes)
+    # Hash is in the same format, but the values are avg latencies.
+    def latencies
+      services.inject({}) { |h, s| h[s.to_s] = s.avg_latency; h }
+    end
+
+    private
+
+    def start_heartbeat_process
+      @heartbeat_thread = Thread.new(self) do |server|
+        timer = 0
+        while true
+          server.services.each do |service|
+            time_to_beat = service.heartbeat_check_rate
+            time_to_beat *= 2 if server.deactivated_services.include?(service)
+            if timer - service.heartbeat_last_check >= time_to_beat
+              service.heartbeat_last_check = timer
+              if service.up?
+                server.reregister(service)
+              else
+                server.unregister(service)
+              end
+            end
+
+            timer += 1
+            sleep 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/server/service_searcher.rb

@@ -0,0 +1,115 @@
+# The searcher is a class that handles all the search functionality for the server.
+module Servicy
+  class ServiceSearcher
+    attr_reader :services
+
+    # Create a new searcher instance with the services that you want to filter
+    # down. To start with, we will just start it with all the server services,
+    # but as things get whiddled down, we will create more of these interfaces
+    # with new sets. It's a sort-of recursive class.
+    def initialize(services)
+      @services = services
+    end
+
+    # Filter based on the name of given, with some simple wild-carding.
+    def filter_by_name(name)
+      return unless name
+      @services = services.select { |s| name_matches_query?(s.name, name) }
+    end
+
+    # Filter down the services based on the version options. You can do min,
+    # max, by extension ranges, and exact matching.
+    def filter_by_versions(min=nil, max=nil, exact=nil)
+      if min
+        mv = Servicy::Service.version_as_number(min)
+        @services = services.select do |s|
+          s.version_as_number >= mv
+        end
+      end
+
+      if max
+        mv = Servicy::Service.version_as_number(max)
+        @services = services.select do |s|
+          s.version_as_number <= mv
+        end
+      end
+
+      if exact
+        mv = Servicy::Service.version_as_number(exact)
+        @services = services.select do |s|
+          s.version_as_number == mv
+        end
+      end
+    end
+
+    # To search by api you can define either class or instance methods by name
+    # with optional arity, arguments by name, type, or both, and return types.
+    # TODO: Support a simple query language ("#foo/-1[String]", etc)
+    def filter_by_api(api)
+      return unless api
+
+      new_set = []
+      api.each do |(type, methods)|
+        methods.each do |method|
+          services.each do |service|
+            if service.api && service.api[type]
+              service_api = service.api_for(type, method[:name])
+              next unless service_api
+              next unless check_arity(service_api, method)
+              next unless check_arguments(service_api, method)
+              next unless check_return_type(service_api, method)
+
+              new_set << service
+            end
+          end
+        end
+      end
+
+      @services = new_set
+    end
+
+    private
+
+    # Check simple wild-cards. If you end a query with a single dot, then you
+    # are looking for something that starts with the query, instead of a
+    # complete match.
+    # TODO: Support *, %, others (?)
+    def name_matches_query?(name, query)
+      if query[-1] == "."
+        name.start_with? query
+      else
+        name == query
+      end
+    end
+
+    # Check the return type against a method query
+    def check_return_type(service_api, method)
+      return true unless method[:return]
+      return true unless service_api[:return]
+      return false if method[:return][:type] != service_api[:return][:type]
+      true
+    end
+
+    # Check if the arguments given in an api query match the argument
+    # definition for a given method.
+    def check_arguments(service_api, method)
+      return true unless method[:args]
+      return true unless service_api[:args]
+
+      return false if method[:args].length != service_api[:args].length
+      names = service_api[:args].map { |a| a[:name] }
+      return false if method[:args].any? { |a| !names.include? a[:name] }
+      return false if method[:args].any? do |a|
+        named_arg = service_api[:args].select { |b| b[:name] == a[:name] }.first
+        a.include?(:required) && named_arg.include?(:required) && a[:required] != named_arg[:required]
+      end
+      true
+    end
+
+    # True if matching arity, false otherwise.
+    def check_arity(service_api, method)
+      return true unless method[:arity]
+      method[:arity] == (service_api[:args] || []).length
+    end
+  end
+end

data/lib/server.rb

@@ -0,0 +1,8 @@
+require 'service'
+require 'json'
+require 'transports'
+require 'transport/in_memory_transport'
+require 'load_balancer'
+require 'logger'
+require 'server/service_searcher'
+require 'server/server'