stargate 0.1.1

data/lib/stargate/client.rb

@@ -0,0 +1,12 @@
+require 'stargate'
+
+module Stargate
+  module Client
+    require 'stargate/client/errors'
+    require 'stargate/client/remote_execution_error'
+    require 'stargate/client/protocol'
+    require 'stargate/client/proxy'
+    require 'stargate/client/injector'
+    require 'stargate/client/core_ext/kernel'
+  end
+end

data/lib/stargate/client/core_ext/kernel.rb

@@ -0,0 +1,8 @@
+module Kernel
+  def require_remote(url)
+    @required_remotes ||= []
+    return if @required_remotes.include?(url)
+    injector = Stargate::Client::Injector.new(url)
+    @required_remotes << url
+  end
+end

data/lib/stargate/client/errors.rb

@@ -0,0 +1,12 @@
+module Stargate
+  module Client
+    # Public: Base client error.
+    Error = Class.new(::Stargate::Error)
+
+    # Public: Raised when unable to read data from the remote.
+    FetchError = Class.new(Error)
+
+    # Public: Raised when unable to fetch directives from the remote.
+    DirectivesFetchError = Class.new(FetchError)
+  end
+end

data/lib/stargate/client/injector.rb

@@ -0,0 +1,37 @@
+module Stargate
+  module Client
+    class Injector
+      include Logging
+      include Stargate::Client
+
+      def initialize(url)
+        @uri = URI.parse(url)
+        @uri.scheme, codec_id = @uri.scheme.split('+')
+        @codec = Codec.find_by_id(codec_id)
+        @protocol = Protocol[@uri.scheme].new(@codec, @uri)
+        @definitions = @protocol.fetch_definitions
+
+        inject!
+      end
+
+      private
+
+      def inject!
+        log.debug("Injecting remote defintions", url: @protocol.safe_uri.to_s)
+        protocol = @protocol
+
+        @definitions.each do |metadata|
+          klass = Class.new(Proxy) { configure_stargate_portal(protocol, metadata) }
+          *namespaces, klass_name = metadata.name.split('::')
+
+          namespace = namespaces.inject(Object) do |namespace, name|
+            namespace.const_defined?(name) ? namespace.const_get(name) : Module.new.tap { |m| m = namespace.const_set(name, m) }
+          end
+
+          namespace.const_set(klass_name, klass)
+          log.debug("Loaded remote class", metadata.serialize)
+        end
+      end
+    end
+  end
+end

data/lib/stargate/client/protocol.rb

@@ -0,0 +1,72 @@
+module Stargate
+  module Client
+    class Protocol
+      UnsupportedProtocolError = Class.new(::Stargate::Client::Error)
+
+      include Logging
+      include Stargate::Marshal
+
+      DEFAULT_TIMEOUT = 15
+
+      @@transports = {}
+
+      def self.transports
+        @@transports
+      end
+
+      def self.register(protocols, transport)
+        protocols.each { |protocol| transports[protocol] = transport }
+      end
+
+      def self.[](protocol)
+        transports[protocol.downcase] or raise UnsupportedProtocolError, "Unsupported protocol: #{protocol}"
+      end
+
+      attr_reader :codec
+      attr_reader :uri
+      attr_reader :safe_uri
+      attr_reader :options
+
+      def initialize(codec, uri)
+        @codec        = codec
+        @uri          = uri
+        @safe_uri     = uri.dup.tap { |safe_uri| safe_uri.user, safe_uri.password = nil, nil }
+        @options      = default_options.merge(parse_options_from_uri_fragment)
+        @unmarshaller = Unmarshaller.new
+      end
+
+      def fetch_definitions
+        raise NotImplementedError
+      end
+
+      def call(klass, method, *args)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def default_options
+        { timeout: DEFAULT_TIMEOUT }
+      end
+
+      def unpack_payload(data)
+        @unmarshaller.unmarshal(data)
+      end
+
+      def unpack_definitions(definitions)
+        definitions.map { |metadata| ::Stargate::Metadata.from_hash(metadata) }
+      end
+
+      def parse_options_from_uri_fragment
+        uri.fragment.to_s.split(';').inject({}) do |options, entry|
+          k, v = entry.split('=')
+          options[k.to_sym] = v
+          options
+        end
+      end
+    end
+
+    require 'stargate/client/protocol/http'
+    require 'stargate/client/protocol/inproc'
+  end
+end

data/lib/stargate/client/protocol/http.rb

@@ -0,0 +1,47 @@
+require 'rest-client'
+
+module Stargate
+  module Client
+    class Protocol::HTTP < Protocol
+      def fetch_definitions
+        log.debug("Loading remote definitions", url: safe_uri.to_s)
+
+        request('definitions', 'GET') do |response|
+          raise DirectivesFetchError, "Unable to fetch directives from #{safe_uri.to_s}" unless response.code == 200
+          data = codec.decode(response.body.to_s)
+          definitions = data['definitions'] or return []
+          unpack_definitions(definitions)
+        end
+      end
+
+      def call(klass, method, *args)
+        log.debug("Executing remote method", class: klass.remote_name, method: method)
+
+        request_options = {}
+        request_options[:payload] = codec.encode(args)
+        request_options[:timeout] = options[:timeout] if options[:timeout]
+        request_headers = { 'Content-Type': codec.content_type }
+
+        request("#{klass.remote_name}.#{method}", 'POST', request_options, request_headers) do |response|
+          data = codec.decode(response.body.to_s)
+          raise RemoteExecutionError.from_hash(data) unless response.code == 200
+          unpack_payload(data)
+        end
+      end
+
+      private
+
+      def request(path, method, options = {}, headers = {}, &block)
+        options = {
+          url: File.join(uri.to_s, path),
+          method: method,
+          headers: { 'Accept': codec.content_type, 'User-Agent': 'Stargate' }.merge(headers)
+        }.merge(options)
+
+        RestClient::Request.execute(options, &block)
+      end
+
+      register %w[http https], self
+    end
+  end
+end

data/lib/stargate/client/protocol/inproc.rb

@@ -0,0 +1,28 @@
+require 'rest-client'
+
+module Stargate
+  module Client
+    class Protocol::Inproc < Protocol
+      RegistryNotFoundError = Class.new(::Stargate::Client::Error)
+
+      def initialize(*)
+        super
+        @registry_version = ::Stargate::INPROC[uri.to_s]
+        @caller = ::Stargate::Server::Caller.new(@registry_version)
+        raise RegistryNotFoundError, "Local registry not found: #{uri.to_s}" unless @registry_version
+      end
+
+      def fetch_definitions
+        unpack_definitions(@registry_version.definitions.map(&:serialize))
+      end
+
+      def call(klass, method, *args)
+        unpack_payload(@caller.call(klass.remote_name, method, *args))
+      rescue => err
+        raise RemoteExecutionError.new(err.class.to_s, err.message)
+      end
+
+      register %w[inproc], self
+    end
+  end
+end

data/lib/stargate/client/proxy.rb

@@ -0,0 +1,52 @@
+module Stargate
+  module Client
+    class Proxy
+      def self.metaclass
+        class << self; self; end
+      end
+
+      def self.configure_stargate_portal(protocol, metadata)
+        metaclass.instance_eval do
+          metadata.class_methods.each do |method|
+            define_method(method) do |*args|
+              protocol.call(self, method, *args)
+            end
+          end
+
+          define_method(:remote_name) do
+            metadata.name
+          end
+        end
+
+        define_attributes(*metadata.attributes)
+        define_readers(*metadata.readers)
+      end
+
+      def self.define_attributes(*names)
+        names.each { |name| attr_accessor(name) }
+      end
+
+      def self.define_readers(*names)
+        names.each do |name|
+          name = name.to_s
+          simple_name = name.split('?').first
+          attr_reader(simple_name)
+          alias name simple_name if simple_name != name
+        end
+      end
+
+      def initialize(attributes = {})
+        attributes.each do |name,value|
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      def to_h
+        self.class.stargate_directives.attributes.inject({}) do |hash,name|
+          hash[name] = instance_variable_get("@#{name}")
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/stargate/client/remote_execution_error.rb

@@ -0,0 +1,22 @@
+module Stargate
+  module Client
+    # Public: Raised when data has been fetched but execution failed.
+    class RemoteExecutionError < Error
+      def self.from_hash(hash)
+        hash.symbolize_keys!
+        new(hash[:error], hash[:message])
+      end
+
+      attr_reader :cause_type
+
+      def initialize(cause_type, message)
+        @cause_type = cause_type
+        super(message)
+      end
+
+      def inspect
+        "#{self.class.name} caused by #{cause_type}: #{message}"
+      end
+    end
+  end
+end

data/lib/stargate/codec.rb

@@ -0,0 +1,34 @@
+module Stargate
+  module Codec
+    # Public: Base codec error.
+    Error = Class.new(::Stargate::Error)
+
+    # Public: Raised when given codec is not registered.
+    UndefinedCodecError = Class.new(Error)
+
+    # Public: Raised when codec cannot decode given data string.
+    DecodeError = Class.new(Error)
+
+    @@codecs = {}
+
+    def self.codecs
+      @@codecs
+    end
+
+    def self.register(codec)
+      codecs[codec.content_type.to_s] = codec
+    end
+
+    def self.find_by_id(id)
+      codecs.values.find { |codec| codec.id == id.to_sym } or raise UndefinedCodecError, "No such codec: #{id}"
+    end
+
+    def self.[](content_type)
+      codecs[content_type.to_s] or raise UndefinedCodecError, "No codec for type: #{content_type}"
+    end
+
+    require 'stargate/codec/json'
+    require 'stargate/codec/bencode'
+    require 'stargate/codec/message_pack'
+  end
+end

data/lib/stargate/codec/bencode.rb

@@ -0,0 +1,28 @@
+require 'bencode'
+
+module Stargate
+  module Codec
+    # Internal: BEncode (BitTorrent encoding) powered codec.
+    class BEncode
+      def self.id
+        :bencode
+      end
+
+      def self.content_type
+        'application/bencode'
+      end
+
+      def self.encode(obj)
+        obj.bencode
+      end
+
+      def self.decode(str)
+        ::BEncode::Parser.new(str).parse!
+      rescue ::BEncode::DecodeError => err
+        raise DecodeError, "Arguments cannot be decoded: bencode parser error"
+      end
+    end
+
+    register BEncode
+  end
+end

data/lib/stargate/codec/json.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+module Stargate
+  module Codec
+    # Internal: Default codec based on JSON parser.
+    class JSON
+      def self.id
+        :json
+      end
+
+      def self.content_type
+        'application/json'
+      end
+
+      def self.encode(obj)
+        obj.to_json
+      end
+
+      def self.decode(str)
+        ::JSON.parse(str)
+      rescue ::JSON::ParserError => err
+        raise DecodeError, "Arguments cannot be decoded: JSON parser error"
+      end
+    end
+
+    register JSON
+  end
+end

data/lib/stargate/codec/message_pack.rb

@@ -0,0 +1,28 @@
+require 'msgpack'
+
+module Stargate
+  module Codec
+    # Internal: Serialization done with MessagePack format.
+    class MessagePack
+      def self.id
+        :msgpack
+      end
+
+      def self.content_type
+        'application/msgpack'
+      end
+
+      def self.encode(obj)
+        ::MessagePack.pack(obj)
+      end
+
+      def self.decode(str)
+        ::MessagePack.unpack(str)
+      rescue ::MessagePack::MalformedFormatError => err
+        raise DecodeError, "Arguments cannot be decoded: MessagePack parser error"
+      end
+    end
+
+    register MessagePack
+  end
+end

data/lib/stargate/errors.rb

@@ -0,0 +1,4 @@
+module Stargate
+  # Public: Base error.
+  Error = Class.new(StandardError)
+end

data/lib/stargate/marshal.rb

@@ -0,0 +1,7 @@
+module Stargate
+  module Marshal
+    require 'stargate/marshal/payload'
+    require 'stargate/marshal/marshaller'
+    require 'stargate/marshal/unmarshaller'
+  end
+end

data/lib/stargate/marshal/marshaller.rb

@@ -0,0 +1,58 @@
+module Stargate
+  module Marshal
+    # Internal: Use it in order to pack data for exchange. Marshaller is created per instance of registry
+    # version. It packs basic values and objects of registered classes into Stargate::Marshal::Payload wraps.
+    class Marshaller
+      # Public: Constructor. Initializes marshaller for given registry version object.
+      def initialize(registry_version)
+        @registry_version = registry_version
+      end
+
+      # Public: Returns given object after marshalling.
+      def marshal(obj)
+        case obj
+        when String, Numeric, TrueClass, FalseClass, Float, BigDecimal, NilClass
+          Payload.new(Payload::SIMPLE, obj)
+        when Symbol
+          Payload.new(Payload::SYMBOL, obj.to_s)
+        when Hash
+          Payload.new(Payload::HASH, marshal_hash(obj))
+        when Array
+          Payload.new(Payload::LIST, marshal_list(obj))
+        else
+          Payload.new(*marshal_complex_object(obj))
+        end
+      end
+
+      private
+
+      # Internal: Returns array marshalled.
+      def marshal_list(obj)
+        obj.map { |x| marshal(x) }
+      end
+
+      # Internal: Returns hash marshalled.
+      def marshal_hash(obj)
+        obj.inject({}) do |res,(k,v)|
+          res[k.to_s] = marshal(v)
+          res
+        end
+      end
+
+      # Internal: Checks if type of given object is registered for exchange. No? Raises an error. Yes? Marshals
+      # all public attributes and computed readers.
+      #
+      # Returns marshalled object.
+      def marshal_complex_object(obj)
+        metadata = @registry_version.metadata_for(obj)
+
+        attributes = (metadata.attributes + metadata.readers).inject({}) do |result,key|
+          result[key.to_s] = marshal(obj.send(key.to_sym))
+          result
+        end
+
+        [ metadata.name, attributes ]
+      end
+    end
+  end
+end