servicy 0.0.3

data/lib/service.rb

@@ -0,0 +1,200 @@
+require 'timeout'
+
+module Servicy
+  class Service
+    include Comparable
+    attr_reader :name, :version, :host, :port, :heartbeat_port, :protocol,
+      :api, :heartbeat_check_rate, :latencies, :heartbeats
+    attr_accessor :heartbeat_last_check
+
+    NAME_REGEX    = /[^\.]+\.([^\.]+\.?)+/
+    VERSION_REGEX = /\d+\.\d+\.\d+(-p?\d+)?/
+
+    # Create a new service.
+    # (see Servicy::Server#register)
+    def initialize(args={})
+      args = args.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+      raise ArgumentError.new("Must provide a service name") unless args[:name]
+      raise ArgumentError.new("Must provide a service host") unless args[:host]
+      raise ArgumentError.new("Must provide a service port") unless args[:port]
+
+      unless args[:name] =~ NAME_REGEX
+        raise ArgumentError.new("Service name must be in inverse-domain format")
+      end
+
+      args[:version] ||= '1.0.0'
+      unless args[:version] =~ VERSION_REGEX
+        raise ArgumentError.new("Service version must be in formation M.m.r(-p)?")
+      end
+
+      if !args[:port].is_a?(Fixnum) || args[:port] < 1 || args[:port] > 65535
+        raise ArgumentError.new("Service port must be an integer betwee 1-65535")
+      end
+
+      args[:heartbeat_port] ||= args[:port]
+      if !args[:heartbeat_port].is_a?(Fixnum) || args[:heartbeat_port] < 1 || args[:heartbeat_port] > 65535
+        raise ArgumentError.new("Service heartbeat port must be an integer betwee 1-65535")
+      end
+
+      if args[:api]
+        raise ArgumentError.new("Service api not correctly defiend") unless check_api(args[:api])
+      end
+
+      args[:protocol] ||= 'HTTP/S'
+
+      @name                 = args[:name]
+      @version              = args[:version]
+      @host                 = args[:host]
+      @protocol             = args[:protocol]
+      @port                 = args[:port]
+      @heartbeat_port       = args[:heartbeat_port]
+      @api                  = args[:api] || {}
+      @heartbeat_check_rate = args[:heartbeat_check_rate] || 1
+      @heartbeat_last_check = 0
+      @latencies            = []
+      @heartbeats           = []
+    end
+
+    # Get a configuration value
+    # This method exists mostly so that I wouldn't have to change a bunch of
+    # early tests, and because I know some people like to access things like a
+    # hash.
+    # @param[Symbol] thing The config value to get.
+    # @return [Object,nil] The value if found, nil otherwise.
+    def [](thing)
+      return self.send(thing) if self.respond_to?(thing)
+      nil
+    end
+
+    # Build a hash of the configuration values for this object.
+    # Used to dump json configurations.
+    # @return [Hash] Configuration data for the Service
+    def as_json
+      {
+        name: name,
+        version: version,
+        host: host,
+        protocol: protocol,
+        port: port,
+        heartbeat_port: heartbeat_port,
+        api: api
+      }
+    end
+
+    # Used by the Comparable mixin for comparing two services.
+    # (see Comparable)
+    def <=>(other)
+      self.as_json <=> other.as_json
+    end
+
+    # Returns the version of the current service as a number that we can use
+    # for comparisons to other version numbers.
+    # @return [Integer] A number representing the version
+    def version_as_number
+      self.class.version_as_number(version)
+    end
+
+    # (see #version_as_number)
+    # @param [String] A version string as per {Servicy::Server#register}
+    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)
+    end
+
+    # Check weather or not a service is up, based on connecting to the hearbeat
+    # port, and reading a single byte.
+    def up?
+      t1 = Time.now
+      s = TCPSocket.new(host, heartbeat_port)
+      Timeout.timeout(5) do
+        s.recvfrom(1)
+      end
+      record_heartbeat(1)
+      return true
+    rescue
+      record_heartbeat(0)
+      return false
+    ensure
+      s.close rescue nil
+      t2 = Time.now
+      record_latency(t1, t2)
+    end
+
+    # Returns what the avg latency for a service is, based on the timings of
+    # their heartbeat connections.
+    # @return [Float] avg latency is ms
+    def avg_latency
+      latencies.reduce(0.0, &:+) / latencies.length.to_f
+    end
+
+    # Returns the uptime for a service based on heartbeat checks as a float
+    # between 0 and 1 -- a percentage.
+    # @return [Float] avg uptime as a percentage (0..1)
+    def uptime
+      heartbeats.reduce(0, &:+) / heartbeats.length.to_f
+    end
+
+    # Get a nice, printable name
+    # return [String]
+    def to_s
+      name + "#" + host
+    end
+
+    # Returns a hash with the configuration options needed for registration and
+    # remote service operation.
+    def to_h
+      {
+        name: name,
+        version: version,
+        host: host,
+        port: port,
+        heartbeat_port: heartbeat_port,
+        protocol: protocol,
+        api: api
+      }
+    end
+
+    # Return the api for a given method (instance, or class) or nil if not
+    # found.
+    def api_for(method_type, method)
+      api[method_type] && api[method_type].select { |a| a[:name] == method }.first
+    end
+
+    private
+
+    # These are just to keep us from filling up memory.
+    def record_latency(t1, t2)
+      @latencies << t2 - t1
+      @latencies = @latencies[0...10] if @latencies.length > 10
+    end
+
+    def record_heartbeat(h)
+      @heartbeats << h
+      @heartbeats = @heartbeats[0...10] if @heartbeats.length > 10
+    end
+
+    # The api is broken into two kinds of methods; instance and class. Each can
+    # define method name, argument number and types, and return types.
+    def check_api(api_def)
+      raise ArgumentError.new("API can only define instance and class methods") unless api_def.contains_only?(:instance, :class)
+
+      api_def.each do |(_, methods)|
+        # Each method is itself a hash of name, args, return type, and docs.
+        methods.each do |method|
+          raise ArgumentError.new("Methods can only contain name, args, return, and docs") unless method.contains_only?(:name, :args, :return, :docs)
+          raise ArgumentError.new("Methods must define a name") unless method.include? :name
+
+          method[:args].each do |arg|
+            # Each argument is an optional name, and optional type, and an
+            # option "required" flag.
+            raise ArgumentError.new("Arguments can only define name, type, and required") unless arg.contains_only?(:name, :type, :required)
+          end
+
+          return false if method[:return] && !method[:return].contains_only?(:type)
+        end
+      end
+    end
+  end
+end
+

data/lib/servicy.rb

@@ -0,0 +1,9 @@
+$: << 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 'server'
+require 'client'
+require 'api'

data/lib/transport/in_memory_transport.rb

@@ -0,0 +1,44 @@
+require 'transports'
+require 'socket'
+require 'tempfile'
+
+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 InMemoryTransport < Servicy::Transport
+    def send(message)
+      socket = UNIXSocket.new socket_path
+      socket.puts message.body
+      message = Message.new(socket.gets)
+      socket.close
+      message
+    end
+
+    def start
+      @server = UNIXServer.open(socket_path)
+      while s = @server.accept
+        Thread.new do
+          message = Message.new s.gets
+          result = yield message
+          s.puts result.body
+          s.close
+        end
+      end
+    end
+
+    def stop
+      @server && @server.close
+    end
+
+    def socket_path
+      @socket_path ||= begin
+                         file = Tempfile.new(@config[:path] || 'servicy-in-memory-transport')
+                         file.close
+                         path = file.path
+                         file.delete
+                         path
+                       end
+    end
+  end
+end

data/lib/transport/messages.rb

@@ -0,0 +1,141 @@
+module Servicy
+  class Transport
+    # The Message class contains messages passed between client and server, as
+    # well as utility methods for making messages to be sent.
+    class Message
+      include Comparable
+
+      attr_reader :struct
+
+      # Create a new message that will be sent over some transport.
+      # @param [Hash] stuff A hash that will constitute the message. You should
+      #   likely never call this directy (i.e. Message.new), and instead use the
+      #   class methods {#registration}, {#query}, etc.
+      def initialize(stuff)
+        if stuff.is_a?(Hash)
+          @struct = stuff
+        else
+          @struct = JSON.parse(stuff)
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        return struct[name] if struct.keys.include?(name)
+        return struct[name.to_s] if struct.keys.include?(name.to_s)
+        super
+      end
+
+      # The body of the message for cases where you send the message over the
+      # wire, or through a database.
+      # @return [String] A JSON representation of the message
+      def body
+        struct.to_json
+      end
+
+      # The response code.
+      # @return [Integer] 200 if successful, 404 if not-found, 500 if error.
+      def response_code
+        !!struct[:success] ? 200 : struct[:response_code]
+      end
+
+      # Create a service registration message
+      # @param [{Servicy::Service}] service The service that is being registered.
+      # @return [{Message}] A {Message} that can be sent through a
+      #   {Servicy::Transport}
+      def self.registration(service)
+        new({
+          message: "registration",
+          service: service.as_json
+        })
+      end
+
+      # Create a service discovery message.
+      # @param [Hash] args A hash that defines the query. (see Servicy::Server#find)
+      # @return [{Message}] A {Message} that can be sent through a
+      #   {Servicy::Transport}
+      def self.query(args, only_one=false)
+        raise ArgumentError.new("Invalid search query") unless query_valid?(args)
+        new({
+          message: "query",
+          query: args,
+          only_one: only_one
+        })
+      end
+
+      # Create a service discover message where I only want one provider.
+      # (see .query)
+      def self.query_one(args)
+        query(args, true)
+      end
+
+      # Create a services search response message
+      # @param [Array<{Servicy::Service}>] services The services that were
+      #   found based on a {Servicy::Server} query
+      # @return [{Message}] A {Message} that can be sent through a
+      #   {Servicy::Transport}
+      def self.services(services)
+        new({
+          success: true,
+          message: "services",
+          services: services.map { |s| s.as_json }
+        })
+      end
+
+      # Create an error response message
+      # @param [String] error_message The error message to report
+      # @param [Integer] response_code The response code for the error.
+      #    Defaults to 500
+      # @return [{Message}] A {Message} that can be sent through a
+      #   {Servicy::Transport}
+      def self.error(error_message, response_code=500)
+        new({
+          success: false,
+          error: error_message
+        })
+      end
+
+      # A utility method for 404 Not-Found error message
+      # (see .error)
+      def self.not_found
+        error "No results found", 404
+      end
+
+      # A generic success message
+      def self.success
+        new({
+          success: true
+        })
+      end
+
+      # A message sent to a server to gather statistics about the server, also
+      # used by the server to send the response back to the client.
+      # @param [Hash,nil] stats The stats to report, if any.
+      def self.statistics(stats=nil)
+        new({
+          message: "stats",
+          stats: stats
+        })
+      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.
+      def <=>(b)
+        self.struct == b.struct ? 0 : -1
+      end
+
+      private
+
+      def self.query_valid?(args)
+        return false if !args[:name] && !args[:api]
+        if args[:min_version] && args[:max_version]
+          min = Servicy::Service.version_as_number(args[:min_version])
+          max = Servicy::Service.version_as_number(args[:max_version])
+          return false if min > max
+        end
+        return false if args[:version] && (args[:min_version] || args[:max_version])
+        true
+      end
+    end
+  end
+end

data/lib/transport/tcp_transport.rb

@@ -0,0 +1,50 @@
+require 'transports'
+require 'socket'
+
+module Servicy
+  # This is a transport that is almost an exact duplicate of the UNIXSocket
+  # transport, but can actually go over the wire. That whole, "Everything is a
+  # file" business works out well...
+  class TCPTransport < Servicy::Transport
+    HELLO = "Servicy says HI!"
+    def send(message)
+      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)
+      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
+        end
+      end
+    end
+
+    def stop
+      @server && @server.close
+    end
+
+    private
+
+    def host
+      @config[:host]
+    end
+
+    def port
+      @config[:port]
+    end
+  end
+end

data/lib/transports.rb

@@ -0,0 +1,54 @@
+require 'service'
+require 'transport/messages'
+
+module Servicy
+  # The Transport class is an abstract class whos implementations handle the
+  # actual communication over the wire or in memory between server and client.
+  # However, in the abstract, it doesn't matter how things are transported,
+  # only that they are and conform to the format described here.
+  class Transport
+    attr_reader :config
+
+    # @param [Hash] config Configuration options for the transport
+    def initialize(config={})
+      @config = config
+    end
+
+    # Override this method to send a message from {Client} to {Server}
+    def send(messge)
+      raise 'Not implemented'
+    end
+
+    # Override this method to yield a message when received on the {Server}. It
+    # should yield to the provided block the message received as a
+    # {Transport::Message} object, and send back the return value of the block
+    # to the client.
+    def start(&block)
+      raise 'Not implemented'
+    end
+
+    # Called when a transport is stopped
+    def stop
+    end
+
+    # This attempts to load a service based on the name.
+    def self.method_missing(name, *args, &block)
+      class_name = "#{name.to_s}Transport"
+      begin
+        c = Module.const_get(class_name)
+        return c if c && c.ancestors.include?(Servicy::Transport)
+      rescue NameError
+        c = Servicy.const_get(class_name)
+        return c if c && c.ancestors.include?(Servicy::Transport)
+      end
+    rescue
+      super
+    end
+  end
+end
+
+# Load all the transports
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'transport', '*.rb'))].each do |file|
+  next if file.start_with?('.') || File.directory?(file)
+  require File.expand_path(file)
+end

data/test.rb

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

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: servicy
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Thomas Luce
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-11 00:00:00.000000000 Z
+dependencies: []
+description: A service registration and discovery framework, as a server and client
+  library.
+email: thomas.luce@gmail.com
+executables:
+- servicy
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- Servicy.gemspec
+- VERSION
+- bin/servicy
+- lib/api.rb
+- lib/client.rb
+- lib/hash.rb
+- lib/load_balancer.rb
+- lib/load_balancer/random.rb
+- lib/load_balancer/round_robin.rb
+- lib/server.rb
+- lib/server/server.rb
+- lib/server/service_searcher.rb
+- lib/service.rb
+- lib/servicy.rb
+- lib/transport/in_memory_transport.rb
+- lib/transport/messages.rb
+- lib/transport/tcp_transport.rb
+- lib/transports.rb
+- test.rb
+homepage: https://github.com/thomasluce/servicy
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A service registration and discovery framework
+test_files: []