stargate 0.1.1

data/lib/stargate/marshal/payload.rb

@@ -0,0 +1,31 @@
+require 'stargate/serialization'
+
+module Stargate
+  module Marshal
+    # Internal: We need some packaging to move stuff from one machine to another. We have to know what types
+    # are coming in. We distinguish four base types:
+    #
+    # * Simple type (string, number, booleans),
+    # * Symbol,
+    # * List (Array),
+    # * Hash
+    #
+    # Later, we can pack any other type that has been registered for exchange.
+    class Payload < Struct.new(:type, :data)
+      include Serialization
+
+      LIST   = :a
+      SIMPLE = :b
+      SYMBOL = :s
+      HASH   = :h
+
+      def serialize
+        [ type, data ]
+      end
+
+      def inspect
+        serialize.inspect
+      end
+    end
+  end
+end

data/lib/stargate/marshal/unmarshaller.rb

@@ -0,0 +1,46 @@
+module Stargate
+  module Marshal
+    # Internal: On the client side there's unmarshalling needed then. Use this unmarshaller to unpack data.
+    # Unmarshaller is assigned to a module (namespace). It shall look up within that module in case of unpacking
+    # complex objects of specific type.
+    class Unmarshaller
+      # Public: Unpacks given object from payload wrap.
+      #
+      # There are two scenarios for unpacking:
+      #
+      # * Basic value - Just return value or adapt contents (like symbol, arrays or hashes).
+      # * An object of specific type - Check if our namespace defines such class. No? Erorr. Yes. Unmarshal into.
+      #
+      # Returns object unmarshalled.
+      def unmarshal(data)
+        payload = Payload.new(*data)
+
+        case payload.type.to_sym
+        when Payload::SIMPLE
+          payload.data
+        when Payload::SYMBOL
+          payload.data.to_sym
+        when Payload::LIST
+          unmarshal_list(payload.data)
+        when Payload::HASH
+          unmarshal_hash(payload.data)
+        else
+          klass = payload.type.constantize
+          klass.new(unmarshal_hash(payload.data))
+        end
+      end
+
+      private
+
+      # Internal: Unmarshals standalone hash.
+      def unmarshal_hash(hash)
+        hash.inject({}) { |result,(k,v)| result[k] = unmarshal(v); result }
+      end
+
+      # Internal: Unmarshals list.
+      def unmarshal_list(list)
+        list.map { |obj| unmarshal(obj) }
+      end
+    end
+  end
+end

data/lib/stargate/metadata.rb

@@ -0,0 +1,68 @@
+module Stargate
+  class Metadata
+    include Serialization
+
+    def self.from_hash(hash)
+      hash.symbolize_keys!
+
+      new(hash[:klass], hash[:name]).tap do |metadata|
+        metadata.class_methods(*hash.fetch(:class_methods, []))
+        metadata.attributes(*hash.fetch(:attributes, []))
+        metadata.readers(*hash.fetch(:readers, []))
+      end
+    end
+
+    attr_reader :klass
+
+    attr_reader :name
+
+    def initialize(klass, name, &block)
+      @klass, @name = klass, name
+      @class_methods = []
+      @attributes = []
+      @readers = []
+
+      instance_eval(&block) if block_given?
+    end
+
+    def active_record?
+      @active_record
+    end
+
+    def class_methods(*names)
+      load_or_add(:class_methods, *names)
+    end
+
+    def attributes(*names)
+      load_or_add(:attributes, *names)
+    end
+
+    def readers(*names)
+      load_or_add(:readers, *names)
+    end
+
+    def serialize
+      {
+        name: name,
+        class_methods: class_methods,
+        attributes: attributes,
+        readers: readers
+      }
+    end
+
+    def inspect
+      "#<#{self.class.name} name=#{name.inspect} class_methods=#{class_methods.inspect} attributes=#{attributes.inspect} readers=#{readers.inspect}"
+    end
+
+    private
+
+    def klass_is_an_active_record?
+      defined?(::ActiveRecord) && klass && klass < ::ActiveRecord::Base
+    end
+
+    def load_or_add(method, *args)
+      value = instance_variable_get("@#{method}")
+      args.empty? ? value : value.concat(args.flatten.map(&:to_sym))
+    end
+  end
+end

data/lib/stargate/serialization.rb

@@ -0,0 +1,21 @@
+module Stargate
+  # Internal: This tiny mixin provides serialization directives for includee class. The target class must
+  # implement #serialize method.
+  module Serialization
+    def serialize
+      raise NotImplementedError, "Not implemented: #{self.class.name}#serialize"
+    end
+
+    def to_json(*args)
+      serialize.to_json(*args)
+    end
+
+    def to_msgpack(*args)
+      serialize.to_msgpack(*args)
+    end
+
+    def bencode
+      serialize.bencode
+    end
+  end
+end

data/lib/stargate/server.rb

@@ -0,0 +1,10 @@
+require 'stargate'
+
+module Stargate
+  module Server
+    require 'stargate/server/errors'
+    require 'stargate/server/registry_version'
+    require 'stargate/server/registry'
+    require 'stargate/server/caller'
+  end
+end

data/lib/stargate/server/caller.rb

@@ -0,0 +1,21 @@
+module Stargate
+  module Server
+    class Caller
+      include Logging
+      include Stargate::Marshal
+
+      def initialize(registry_version)
+        @marshaller       = Marshaller.new(registry_version)
+        @registry_version = registry_version
+      end
+
+      def call(klass_name, method, *args)
+        method, metadata = method.to_sym, @registry_version[klass_name]
+        metadata.class_methods.include?(method) or raise MethodNotExposedError, "Method not exposed: #{klass_name}.#{method}"
+        result = metadata.klass.send(method, *args)
+        log.debug("Method call performed", class: klass_name, method: method, result:result.inspect)
+        @marshaller.marshal(result)
+      end
+    end
+  end
+end

data/lib/stargate/server/engine/inproc.rb

@@ -0,0 +1,15 @@
+require 'stargate/server'
+
+module Stargate
+  module Server
+    module Engine
+      class Inproc
+        def self.register(name, registry)
+          registry.each do |version_number, actual_registry|
+            ::Stargate::INPROC["inproc://#{name}/v#{version_number}"] = actual_registry
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stargate/server/engine/sinatra.rb

@@ -0,0 +1,97 @@
+require 'stargate/server'
+
+module Stargate
+  module Server
+    module Engine
+      class Sinatra
+        include Logging
+
+        def initialize(registry)
+          require 'sinatra/base'
+
+          logger = log
+
+          @app = ::Sinatra.new do
+            helpers Helpers
+
+            registry.each do |version_number, actual_registry|
+              caller = Caller.new(actual_registry)
+
+              get "/v#{version_number}/definitions" do
+                log.debug("Serving registry definitions")
+                content_type(response_codec.content_type)
+                response_codec.encode(actual_registry)
+              end
+
+              post "/v#{version_number}/:klass_name.:method" do |klass_name, method|
+                args = parse_args
+                log.debug("Executing call", class: klass_name, method: method, args: args)
+                result = caller.call(klass_name, method, *args)
+                content_type(response_codec.content_type)
+                response_codec.encode(result)
+              end
+            end
+
+            error Stargate::Server::NotFoundError do
+              error_response(404)
+            end
+
+            error Stargate::Codec::Error do
+              error_response(400)
+            end
+
+            error NotImplementedError do
+              error_response(501)
+            end
+
+            error 500 do
+              error_response(500)
+            end
+          end
+
+          @app.set(:default_mime_type, ::Stargate::Codec::JSON.content_type)
+          @app.set(:show_exceptions, false)
+          @app.set(:logger, log)
+        end
+
+        def call(env)
+          @app.call(env)
+        end
+
+        module Helpers
+          def log
+            settings.logger
+          end
+
+          def parse_args
+            request.body.rewind
+
+            args = body_codec.decode(request.body.read)
+            args = [] if args.nil?
+            args = [ args ] if args.kind_of?(Hash)
+            args
+          end
+
+          def error_response(code)
+            status(code)
+            err = env['sinatra.error']
+            log.error(err)
+            response_codec.encode({error: err.class.name, message: err.message})
+          end
+
+          def body_codec
+            Codec[request.media_type || settings.default_mime_type]
+          end
+
+          def response_codec
+            Codec[accept_type || settings.default_mime_type]
+          end
+
+          def accept_type
+            accept = env['HTTP_ACCEPT'] and accept.split(/\s*[;,]\s*/, 2).first.downcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stargate/server/errors.rb

@@ -0,0 +1,25 @@
+module Stargate
+  module Server
+    # Public: Base server error.
+    Error = Class.new(::Stargate::Error)
+
+    # Public: Base class for not-found type errors.
+    NotFoundError = Class.new(Error)
+
+    # Public: Raised when trying to get non-existent registry version.
+    RegistryVersionUndefinedError = Class.new(Error)
+
+    # Public: Raised when requested class is not exposed/registered.
+    ClassNotExposedError = Class.new(NotFoundError)
+
+    # Public: Raised when called method is not exposed.
+    MethodNotExposedError = Class.new(NotFoundError)
+
+    # Public: Raised when trying to register the same class twice within single registry.
+    ClassAlreadyRegisteredError = Class.new(Error)
+
+    # Public: Raised when trying to return (and pack into payload) data of unregistered or unsupported type.
+    # For example when exposed class method returns value of type different than itself, hash or basic.
+    UnregisteredClassExposureError = Class.new(Error)
+  end
+end

data/lib/stargate/server/registry.rb

@@ -0,0 +1,26 @@
+module Stargate
+  module Server
+    class Registry
+      include Enumerable
+
+      attr_reader :versions
+
+      def initialize(&block)
+        @versions = {}
+        instance_eval(&block) if block_given?
+      end
+
+      def version(number, &block)
+        @versions[number] ||= RegistryVersion.new(number, &block)
+      end
+
+      def [](version)
+        versions[version] or raise RegistryVersionUndefinedError, "No such registry version: #{version}"
+      end
+
+      def each(&block)
+        versions.each(&block)
+      end
+    end
+  end
+end

data/lib/stargate/server/registry_version.rb

@@ -0,0 +1,59 @@
+require 'forwardable'
+
+module Stargate
+  module Server
+    class RegistryVersion
+      include Logging
+      include Enumerable
+      include Serialization
+
+      attr_reader :version
+
+      attr_reader :definitions
+
+      def initialize(version = 1, &block)
+        @version = version
+        @definitions = []
+
+        instance_eval(&block) if block_given?
+      end
+
+      def serve(klass, params = {}, &block)
+        raise ClassAlreadyRegisteredError, "Class already registered: #{klass.name}" if registered?(klass)
+
+        params.symbolize_keys!
+        klass_name = params[:as] || klass.name
+        log.debug("Registering class", local_class_name: klass.name, serve_as: klass_name)
+        @definitions << Metadata.new(klass, klass_name, &block)
+
+        self
+      end
+
+      def registered?(klass)
+        @definitions.find { |metadata| metadata.klass == klass }
+      end
+
+      def metadata_for(obj)
+        metadata = @definitions.find { |metadata| metadata.klass == obj.class }
+        metadata or raise ClassNotExposedError, "Class not registered: #{obj.class.name}"
+      end
+
+      def [](klass_name)
+        metadata = @definitions.find { |metadata| metadata.name == klass_name }
+        metadata or raise ClassNotExposedError, "Class not registered under name: #{klass_name}"
+      end
+
+      def each(&block)
+        @definitions.each(&block)
+      end
+
+      def size
+        @definitions.size
+      end
+
+      def serialize
+        { version: @version, definitions: @definitions.map(&:serialize) }
+      end
+    end
+  end
+end

data/lib/stargate/version.rb

@@ -0,0 +1,3 @@
+module Stargate
+  VERSION = '0.1.1'
+end

data/stargate.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stargate/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "stargate"
+  spec.version = Stargate::VERSION
+  spec.authors = ["jobandtalent", "Kris Kovalik"]
+  spec.email = ["kris.kovalik@jobandtalent.com", "hi@kkvlk.me"]
+
+  spec.summary = %q{A portal to remote services.}
+  spec.description = %q{Stargate opens a portal to call remote methods via simple and reliable RPC protocols.}
+  spec.homepage = "https://github.com/jobandtalent/stargate"
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.8"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1"
+  spec.add_development_dependency "rack-test", "~> 0.6"
+  spec.add_development_dependency "mocha", "~> 1.1"
+  spec.add_development_dependency "webmock", "~> 1.22"
+  spec.add_development_dependency "puma", "~> 2.11"
+  spec.add_development_dependency "vcr", "~> 3.0"
+  spec.add_development_dependency "rake-bump", "~> 0.4", ">= 0.4.6"
+
+  spec.add_dependency "json", "~> 1.8"
+  spec.add_dependency "msgpack", "~> 0.7"
+  spec.add_dependency "bencode", "~> 0.8"
+  spec.add_dependency "activemodel", ">= 3.0"
+  spec.add_dependency "activesupport", ">= 3.0"
+  spec.add_dependency "sinatra", "~> 1.4"
+  spec.add_dependency "rest-client", "~> 1.8"
+  spec.add_dependency "log4r", "~> 1.1"
+  spec.add_dependency "perfume", "~> 0.3", ">= 0.3.1"
+end