protein 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 640ce556cbb7f7709579ad076cd242880081d3bd
+  data.tar.gz: 682c86726085e8ab7c794a2bea141726a718edf9
+SHA512:
+  metadata.gz: d1015ee49c77d00f0e16d9816f2f80a05d36750844482c9fc1d0a4ef54658e534816b41c3749ee2d39f59ae6ae77fb2c3312567060c46bcb1df768541b0e2497
+  data.tar.gz: 41d4c03428c44c138ff8e9be1a7d2161393c0ab6cc9c610a58feefd7bcffcbd9951f166ea565a01b4dca48192167b5fb98f40d12b14d163dcbc932bddbdb390e

data/README.md

@@ -0,0 +1,32 @@
+# Protein for Ruby
+
+***Multi-platform remote procedure call (RPC) system based on Protocol Buffers***
+
+Features:
+
+- Implement RPC services and clients for Elixir and Ruby platforms
+- Call remote services using unified, simple client API
+- Call to services for an immediate response or push non-blocking requests to async services
+- Define services via unified, configurable DSL
+- Define service input/outputs using the widely acclaimed Google Protocol Buffers format
+- Transport your calls via HTTP or AMQP transports
+
+Packages:
+
+- [Protein for Elixir](http://github.com/surgeventures/protein-elixir)
+- [Protein for Ruby](http://github.com/surgeventures/protein-ruby)
+
+## Getting Started
+
+Add `protein` as a dependency to your project in `Gemfile`:
+
+```elixir
+gem "protein", "~> x.x.x"
+```
+
+Then run `bundle install` to fetch it.
+
+## Documentation
+
+We don't provide documentation for Ruby package at the moment. Please look for answers in the code
+and in documentation for Elixir package - basic concepts and API shapes are akin.

data/lib/protein.rb

@@ -0,0 +1,17 @@
+require "protein/errors"
+require "protein/proto_compiler"
+require "protein/get_const"
+
+require "protein/router"
+require "protein/client"
+require "protein/server"
+require "protein/processor"
+require "protein/payload"
+
+require "protein/pointer"
+require "protein/service_error"
+require "protein/service"
+
+require "protein/transport"
+require "protein/http_adapter"
+require "protein/amqp_adapter"

data/lib/protein/amqp_adapter.rb

@@ -0,0 +1,132 @@
+require "bunny"
+require "thread"
+
+module Protein
+class AMQPAdapter
+  class << self
+    def from_hash(hash)
+      if (new_url = hash[:url])
+        url(new_url)
+      end
+
+      if (new_queue = hash[:queue])
+        queue(new_queue)
+      end
+
+      if hash.has_key?(:timeout)
+        timeout(hash[:timeout])
+      end
+    end
+
+    def url(url = nil)
+      @url = url if url
+      @url || raise(DefinitionError, "url is not defined")
+    end
+
+    def queue(queue = nil)
+      @queue = queue if queue
+      @queue || raise(DefinitionError, "queue is not defined")
+    end
+
+    def timeout(timeout = :not_set)
+      @timeout = timeout if timeout != :not_set
+      instance_variable_defined?("@timeout") ? @timeout : 15_000
+    end
+
+    attr_reader :reply_queue
+    attr_accessor :response, :call_id
+    attr_reader :lock, :condition
+
+    def call(request_payload)
+      prepare_client
+
+      @call_id = SecureRandom.uuid
+
+      @x.publish(request_payload,
+        correlation_id: @call_id,
+        routing_key: @server_queue,
+        reply_to: @reply_queue.name,
+        expiration: timeout)
+
+      self.response = nil
+      lock.synchronize { condition.wait(lock, timeout && timeout * 0.001) }
+
+      if response == nil
+        raise(TransportError, "timeout after #{timeout}ms")
+      elsif response == "ESRV"
+        raise(TransportError, "failed to process the request")
+      else
+        response
+      end
+    end
+
+    def push(message_payload)
+      prepare_client
+
+      @x.publish(message_payload,
+        routing_key: @server_queue)
+    end
+
+    def serve(router)
+      @conn = Bunny.new(url)
+      @conn.start
+      @ch = @conn.create_channel
+      @q = @ch.queue(queue)
+      @x = @ch.default_exchange
+
+      Rails.logger.info "Connected to #{url}, serving RPC calls from #{queue}"
+
+      loop do
+        begin
+          @q.subscribe(block: true, manual_ack: true) do |delivery_info, properties, payload|
+            begin
+              @error = nil
+              response = Processor.call(router, payload)
+            rescue Exception => error
+              @error = error
+              response = "ESRV"
+            end
+
+            if response
+              @x.publish(response,
+                routing_key: properties.reply_to,
+                correlation_id: properties.correlation_id)
+            end
+
+            @ch.ack(delivery_info.delivery_tag)
+
+            raise(@error) if @error
+          end
+        rescue StandardError => e
+          Rails.logger.info "RPC server error: #{e.inspect}, restarting the server in 5s..."
+          sleep 5
+        end
+      end
+    end
+
+    private
+
+    def prepare_client
+      return if @conn
+
+      @conn = Bunny.new(url)
+      @conn.start
+      @ch = @conn.create_channel
+      @x = @ch.default_exchange
+      @server_queue = queue
+      @reply_queue = @ch.queue("", exclusive: true)
+      @lock = Mutex.new
+      @condition = ConditionVariable.new
+
+      that = self
+
+      @reply_queue.subscribe do |delivery_info, properties, payload|
+        if properties[:correlation_id] == that.call_id
+          that.response = payload
+          that.lock.synchronize{that.condition.signal}
+        end
+      end
+    end
+  end
+end
+end

data/lib/protein/client.rb

@@ -0,0 +1,82 @@
+module Protein
+class Client
+  class << self
+    def route(router)
+      @router = Router.define(router)
+    end
+
+    def service(service)
+      @router ||= Class.new(Router)
+      @router.service(service)
+    end
+
+    def proto(proto)
+      service = Class.new(Service)
+      service.proto(proto)
+
+      @router ||= Class.new(Router)
+      @router.service(service)
+    end
+
+    def router
+      GetConst.call(@router)
+    end
+
+    def transport(transport, opts = {})
+      @transport_class = Transport.define(transport, opts)
+    end
+
+    def transport_class
+      GetConst.call(@transport_class)
+    end
+
+    def call(request)
+      service_class = router.resolve_by_request(request)
+
+      raise(ArgumentError, "called to non-responding service") unless service_class.response?
+
+      service_name = service_class.service_name
+      request_class = service_class.request_class
+      request_buf = request_class.encode(request)
+      request_payload = Payload::Request.encode(service_name, request_buf)
+
+      response_payload = transport_class.call(request_payload)
+      response_buf, errors = Payload::Response.decode(response_payload)
+      service_instance = service_class.new(request)
+
+      if response_buf
+        response = service_class.response_class.decode(response_buf)
+        service_instance.resolve(response)
+      elsif errors
+        service_instance.reject(errors)
+      end
+
+      service_instance
+    end
+
+    def call!(request)
+      service_instance = call(request)
+      if service_instance.failure?
+        raise(CallError, service_instance.errors)
+      end
+
+      service_instance.response
+    end
+
+    def push(request)
+      service_class = router.resolve_by_request(request)
+
+      raise(ArgumentError, "pushed to responding service") if service_class.response?
+
+      service_name = service_class.service_name
+      request_class = service_class.request_class
+      request_buf = request_class.encode(request)
+      request_payload = Payload::Request.encode(service_name, request_buf)
+
+      transport_class.push(request_payload)
+
+      nil
+    end
+  end
+end
+end

data/lib/protein/errors.rb

@@ -0,0 +1,16 @@
+module Protein
+  class CallError < StandardError
+    def initialize(errors)
+      super(
+        errors.map do |error|
+          error.reason.inspect + (error.pointer ? " (at #{error.pointer})" : "")
+        end.join(", ")
+      )
+    end
+  end
+  class DefinitionError < StandardError; end
+  class PointerError < StandardError; end
+  class ProcessingError < StandardError; end
+  class RoutingError < StandardError; end
+  class TransportError < StandardError; end
+end

data/lib/protein/get_const.rb

@@ -0,0 +1,19 @@
+module Protein
+class GetConst
+  class << self
+    def call(input)
+      if input.is_a?(String)
+        input.constantize
+      elsif input != nil
+        input
+      else
+        raise DefinitionError, "unset required option"
+      end
+    end
+
+    def map(array)
+      array.map { |input| call(input) }
+    end
+  end
+end
+end

data/lib/protein/http_adapter.rb

@@ -0,0 +1,94 @@
+require "net/http"
+require "json"
+
+module Protein
+class HTTPAdapter
+  HTTPS_SCHEME = "https".freeze
+
+  class Middleware
+    def initialize(router, secret)
+      @router = router
+      @secret = secret
+    end
+
+    def call(env)
+      check_secret(env)
+
+      request_payload = env["rack.input"].read
+      response_payload = Processor.call(@router, request_payload)
+
+      ["200", {}, [response_payload]]
+    end
+
+    private
+
+    def check_secret(env)
+      return if @secret == env["HTTP_X_RPC_SECRET"]
+
+      raise(TransportError, "invalid secret")
+    end
+  end
+
+  class << self
+    def from_hash(hash)
+      if (new_url = hash[:url])
+        url(new_url)
+      end
+
+      if (new_path = hash[:path])
+        path(new_path)
+      end
+
+      if (new_secret = hash[:secret])
+        secret(new_secret)
+      end
+    end
+
+    def url(url = nil)
+      if url
+        @url = url
+        @path = URI(url).path
+      end
+
+      @url || raise(DefinitionError, "url is not defined")
+    end
+
+    def path(path = nil)
+      @path = path if path
+      @path || raise(DefinitionError, "path is not defined")
+    end
+
+    def secret(secret = nil)
+      @secret = secret if secret
+      @secret || raise(DefinitionError, "secret is not defined")
+    end
+
+    def call(request_payload)
+      make_http_request(request_payload, build_headers())
+    end
+
+    private
+
+    def build_headers
+      { "X-RPC-Secret" => secret }
+    end
+
+    def make_http_request(body, headers)
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == HTTPS_SCHEME
+      http_request = Net::HTTP::Post.new(uri.path, headers)
+      http_request.body = body
+      http_response = http.request(http_request)
+
+      unless http_response.is_a?(Net::HTTPSuccess)
+        raise(TransportError, "HTTP request failed with code #{http_response.code}")
+      end
+
+      http_response.body
+    rescue SystemCallError => e
+      raise(TransportError, e.to_s)
+    end
+  end
+end
+end

data/lib/protein/payload.rb

@@ -0,0 +1,71 @@
+require "net/http"
+require "json"
+
+module Protein
+module Payload
+  class Request
+    class << self
+      def encode(service_name, request_buf)
+        JSON.dump({
+          "service_name" => service_name,
+          "request_buf_b64" => Base64.strict_encode64(request_buf)
+        })
+      end
+
+      def decode(payload)
+        hash = JSON.parse(payload)
+        service_name = hash["service_name"]
+        request_buf_b64 = hash["request_buf_b64"]
+        request_buf = Base64.strict_decode64(request_buf_b64)
+
+        [service_name, request_buf]
+      end
+    end
+  end
+
+  class Response
+    class << self
+      def encode(response_buf, errors)
+        JSON.dump({
+          "response_buf_b64" => response_buf && Base64.strict_encode64(response_buf),
+          "errors" => encode_errors(errors)
+        })
+      end
+
+      def decode(payload)
+        hash = JSON.parse(payload)
+        response_buf_b64 = hash["response_buf_b64"]
+        response_buf = response_buf_b64 && Base64.strict_decode64(response_buf_b64)
+        errors = hash["errors"]
+        errors = errors && decode_errors(errors)
+
+        [response_buf, errors]
+      end
+
+      private
+
+      def encode_errors(errors)
+        errors && errors.map do |error|
+          {
+            "reason" => error.reason.is_a?(Symbol) ? ":#{error.reason}" : error.reason,
+            "pointer" => error.pointer && error.pointer.dump
+          }
+        end
+      end
+
+      def decode_errors(errors)
+        errors && errors.map do |error|
+          reason_string = error["reason"]
+          reason = reason_string =~ /^\:/ ? reason_string[1..-1].to_sym : reason_string
+          pointer = error["pointer"]
+
+          ServiceError.new(
+            reason: reason,
+            pointer: pointer && Pointer.new(nil, "request").load(pointer)
+          )
+        end
+      end
+    end
+  end
+end
+end

data/lib/protein/pointer.rb

@@ -0,0 +1,93 @@
+module Protein
+class Pointer
+  def initialize(base, base_name = "context", input = nil)
+    @base = base
+    @base_name = base_name
+
+    if input.is_a?(String)
+      parse(input)
+    end
+  end
+
+  def dump
+    @access_path || raise(ProcessingError, "pointer can't be empty")
+  end
+
+  def load(input)
+    @access_path = input.map do |type, key|
+      [type.to_sym, key]
+    end
+
+    traverse_access_path(traverse_values: false)
+
+    self
+  end
+
+  def parse(input)
+    unless input =~ Regexp.new("^#{@base_name}")
+      raise PointerError, "access path should start with `#{@base_name}`"
+    end
+
+    access_path = input.scan(/(\.(\w+))|(\[(\d+)\])|(\[['"](\w+)['"]\])/).map do |match|
+      if (key = match[1])
+        [:struct, key]
+      elsif (key = match[3])
+        [:repeated, key.to_i]
+      elsif (key = match[5])
+        [:map, key]
+      end
+    end
+
+    if access_path.empty?
+      raise PointerError, "access path should not be empty"
+    end
+
+    @access_path = access_path
+    traverse_access_path
+  end
+
+  def to_s
+    @access_strings.join
+  end
+
+  def inspect_path
+    @access_values.each_with_index do |access_value, index|
+      if index > 0
+        accessor_type, accessor_key = @access_path[index - 1]
+        puts "Accessing #{accessor_type} with key #{accessor_key.inspect}"
+      end
+      puts "At #{access_value.inspect}"
+    end
+  end
+
+  private
+
+  def traverse_access_path(traverse_values: true)
+    if traverse_values
+      access_value = @base
+      access_values = [@base]
+    end
+    access_strings = [@base_name]
+
+    begin
+      @access_path.each do |type, key|
+        case type
+        when :struct
+          access_strings << ".#{key}"
+          access_value = access_value.send(key) if traverse_values
+        when :repeated, :map
+          access_strings << "[#{key.inspect}]"
+          access_value = access_value[key] if traverse_values
+        end
+
+        access_values << access_value if traverse_values
+      end
+    rescue StandardError
+      raise PointerError, "unable to access #{access_strings.join}"
+    end
+
+    @access_values = access_values if traverse_values
+    @access_strings = access_strings
+  end
+end
+end

data/lib/protein/processor.rb

@@ -0,0 +1,67 @@
+module Protein
+class Processor
+  class << self
+    def call(router, request_payload)
+      service_name, request_buf = Payload::Request.decode(request_payload)
+      service_class = router.resolve_by_name(service_name)
+
+      if service_class.response?
+        process_and_log_call(service_name, service_class, request_buf)
+      else
+        process_and_log_push(service_name, service_class, request_buf)
+      end
+    end
+
+    private
+
+    def process_and_log_call(service_name, service_class, request_buf)
+      Rails.logger.info "Processing RPC call: #{service_name}"
+
+      start_time = Time.now
+      response_buf, errors = process_call(service_class, request_buf)
+      duration_ms = ((Time.now - start_time) * 1000).round
+
+      Rails.logger.info "#{response_buf ? 'Resolved' : 'Rejected'} in #{duration_ms}ms"
+
+      Payload::Response.encode(response_buf, errors) if service_class.response?
+    end
+
+    def process_call(service_class, request_buf)
+      request_class = service_class.request_class
+      request = request_class.decode(request_buf)
+      service_instance = service_class.new(request)
+
+      service_instance.process
+
+      if service_instance.success?
+        response_class = service_class.response_class
+        response_buf = response_class.encode(service_instance.response)
+
+        [response_buf, nil]
+      else
+        [nil, service_instance.errors]
+      end
+    end
+
+    def process_and_log_push(service_name, service_class, request_buf)
+      Rails.logger.info "Processing RPC push: #{service_name}"
+
+      start_time = Time.now
+      process_push(service_class, request_buf)
+      duration_ms = ((Time.now - start_time) * 1000).round
+
+      Rails.logger.info "Processed in #{duration_ms}ms"
+
+      nil
+    end
+
+    def process_push(service_class, request_buf)
+      request_class = service_class.request_class
+      request = request_class.decode(request_buf)
+      service_instance = service_class.new(request)
+
+      service_instance.process
+    end
+  end
+end
+end

data/lib/protein/proto_compiler.rb

@@ -0,0 +1,42 @@
+module Protein
+class ProtoCompiler
+  class << self
+    def call(proto_directory: "./lib", namespace: nil)
+      proto_files = Dir.glob("#{proto_directory}/**/*.proto")
+
+      proto_files.each do |proto_file|
+        puts "Compiling #{proto_file}"
+
+        cmd_args = [
+          "protoc",
+          "-I", proto_directory,
+          "--ruby_out", proto_directory,
+          proto_file
+        ]
+
+        output = `#{cmd_args.shelljoin} 2>&1`
+
+        unless $?.success?
+          raise "Proto compilation failed:\n#{output}"
+        end
+      end
+
+      rewrite_namespace(proto_directory, namespace) if namespace
+    end
+
+    private
+
+    def rewrite_namespace(proto_directory, namespace)
+      proto_files = Dir.glob("#{proto_directory}/**/*_pb.rb")
+
+      proto_files.each do |proto_file|
+        puts "Namespacing #{proto_file} to #{namespace}"
+
+        old_content = File.read(proto_file)
+
+        File.write(proto_file, "module #{namespace}\n#{old_content}\nend\n")
+      end
+    end
+  end
+end
+end

data/lib/protein/router.rb

@@ -0,0 +1,55 @@
+module Protein
+class Router
+  class << self
+    def define(router)
+      if router.is_a?(Class) || router.is_a?(String)
+        router
+      elsif router.is_a?(Hash)
+        router_class = Class.new(Router)
+        router_class.from_hash(router)
+        router_class
+      else
+        raise(DefinitionError, "invalid router definition")
+      end
+    end
+
+    def from_hash(hash)
+      if hash[:services]
+        hash[:services].each do |each_service|
+          service(each_service)
+        end
+      end
+
+      if hash[:protos]
+        hash[:protos].each do |each_proto|
+          service_class = Class.new(Service)
+          service_class.proto(each_proto)
+
+          service(service_class)
+        end
+      end
+    end
+
+    def service(service_class)
+      @services ||= []
+      @services << service_class
+    end
+
+    def services
+      GetConst.map(@services || [])
+    end
+
+    def resolve_by_name(service_name)
+      services.find do |service|
+        service.service_name == service_name.to_s
+      end || raise(RoutingError, "service #{service_name.inspect} not found")
+    end
+
+    def resolve_by_request(request)
+      services.find do |service|
+        request.is_a?(service.request_class)
+      end || raise(RoutingError, "service for #{request.class} not found")
+    end
+  end
+end
+end

data/lib/protein/server.rb

@@ -0,0 +1,30 @@
+module Protein
+class Server
+  class << self
+    def route(router)
+      @router = Router.define(router)
+    end
+
+    def service(service)
+      @router ||= Class.new(Router)
+      @router.service(service)
+    end
+
+    def router
+      GetConst.call(@router)
+    end
+
+    def transport(transport, opts = {})
+      @transport_class = Transport.define(transport, opts)
+    end
+
+    def transport_class
+      GetConst.call(@transport_class)
+    end
+
+    def start
+      transport_class.serve(router)
+    end
+  end
+end
+end

data/lib/protein/service.rb

@@ -0,0 +1,130 @@
+module Protein
+class Service
+  class << self
+    def service(service_name)
+      @service_name = service_name
+    end
+
+    def service_name
+      @service_name || raise(DefinitionError, "service name is not defined")
+    end
+
+    def proto(proto_module = nil)
+      @proto_module = proto_module
+      @service_name ||= proto_module.to_s.split("::").last.underscore
+      @request_class ||= "#{proto_module}::Request"
+      @response_class ||= "#{proto_module}::Response"
+    end
+
+    def proto_module
+      GetConst.call(@proto_module)
+    end
+
+    def request(request_class)
+      @request_class = request_class
+    end
+
+    def request_class
+      GetConst.call(@request_class)
+    end
+
+    def response?
+      response_class != false &&
+        (!response_class.is_a?(String) || !response_class.safe_constantize.nil?)
+    rescue NameError
+      false
+    end
+
+    def response(response_class)
+      @response_class = response_class
+    end
+
+    def response_class
+      GetConst.call(@response_class)
+    end
+  end
+
+  attr_reader :request, :response, :errors
+  delegate :response?, :response_class, to: :class
+
+  def initialize(request)
+    @request = request
+  end
+
+  def process
+    @success = nil
+    @response = response_class.new if response?
+    @errors = []
+
+    call
+
+    raise(ProcessingError, "resolve/reject must be called") if response? && @success.nil?
+  end
+
+  def resolve(response = nil)
+    raise(ProcessingError, "can't resolve non-responding service") unless response?
+    raise(ProcessingError, "unable to resolve with previous errors") if @errors && @errors.any?
+
+    @success = true
+    @response =
+      if !response
+        @response
+      elsif response.is_a?(response_class)
+        response
+      else
+        response_class.new(response)
+      end
+  end
+
+  def reject(*args)
+    raise(ProcessingError, "can't reject non-responding service") unless response?
+    if args.any? && @errors && @errors.any?
+      raise(ProcessingError, "unable to reject with both rejection value and previous errors")
+    end
+
+    @success = false
+    @errors =
+      if args.empty? && @errors && @errors.any?
+        @errors
+      elsif args.empty?
+        [build_error(:error)]
+      elsif args.length == 1 && args[0].is_a?(Array) && args[0].any?
+        args[0].map { |error| build_error(error) }
+      else
+        [build_error(*args)]
+      end
+  end
+
+  def success?
+    raise(ProcessingError, "resolve/reject must be called first") if @success.nil?
+
+    @success
+  end
+
+  def failure?
+    !success?
+  end
+
+  def add_error(*args)
+    @errors << build_error(*args)
+  end
+
+  private
+
+  def build_error(*args)
+    if args[0].is_a?(String) || args[0].is_a?(Symbol)
+      reason = args[0]
+      pointer =
+        if args[1].is_a?(Hash) && (at = args[1][:at])
+          Pointer.new(request, "request", at)
+        end
+
+      ServiceError.new(reason: reason, pointer: pointer)
+    elsif args[0].is_a?(ServiceError)
+      args[0]
+    elsif args[0].is_a?(Hash)
+      ServiceError.new(reason: args[0][:reason], pointer: args[0][:pointer])
+    end
+  end
+end
+end

data/lib/protein/service_error.rb

@@ -0,0 +1,15 @@
+module Protein
+class ServiceError
+  attr_reader :reason
+  attr_accessor :pointer
+
+  def initialize(reason: nil, pointer: nil)
+    @reason = reason if reason
+    @pointer = pointer if pointer
+
+    unless @reason.is_a?(String) || @reason.is_a?(Symbol)
+      raise(ProcessingError, "error reason must be a string or symbol")
+    end
+  end
+end
+end

data/lib/protein/transport.rb

@@ -0,0 +1,27 @@
+module Protein
+class Transport
+  class << self
+    def define(transport, opts = {})
+      if transport.is_a?(Class) || transport.is_a?(String)
+        transport_class
+      elsif transport.is_a?(Symbol)
+        transport_base_class =
+          case transport
+          when :http
+            Protein::HTTPAdapter
+          when :amqp
+            Protein::AMQPAdapter
+          else
+            raise(DefinitionError, "invalid transport: #{transport.inspect}")
+          end
+
+        transport_class = Class.new(transport_base_class)
+        transport_class.from_hash(opts)
+        transport_class
+      else
+        raise(DefinitionError, "invalid transport definition")
+      end
+    end
+  end
+end
+end

data/lib/protein/version.rb

@@ -0,0 +1,3 @@
+module Protein
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: protein
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Karol Słuszniak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-12 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: karol@shedul.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/protein.rb
+- lib/protein/amqp_adapter.rb
+- lib/protein/client.rb
+- lib/protein/errors.rb
+- lib/protein/get_const.rb
+- lib/protein/http_adapter.rb
+- lib/protein/payload.rb
+- lib/protein/pointer.rb
+- lib/protein/processor.rb
+- lib/protein/proto_compiler.rb
+- lib/protein/router.rb
+- lib/protein/server.rb
+- lib/protein/service.rb
+- lib/protein/service_error.rb
+- lib/protein/transport.rb
+- lib/protein/version.rb
+homepage: http://github.com/surgeventures/protein-ruby
+licenses:
+- MIT
+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.6.8
+signing_key: 
+specification_version: 4
+summary: Multi-platform remote procedure call (RPC) system based on Protocol Buffers
+test_files: []