elementary-rpc 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f92f4aa5b2489be4f30f3bd8f1c36a005f59b554
+  data.tar.gz: f876e99e9f8851fdb23802492f7f66428e0ab38e
+SHA512:
+  metadata.gz: 5d3994a1a15f0313ab25ab9ff820a29076de9a88c852df1a7e4c1a1bb768e28359d1c6ad7bb7609581bab8b0cacb03d8f079492c33c4fc5692f6f29ef3d1e492
+  data.tar.gz: fe24f7fc72437bf9bbd54fd394ee4448b44582449b8483af0fe3af0a00cd8bb8c4bd02273aa2ec857ca8bd7bbd616d69755542de82b9265cb139ef4d6f51fba4

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.swp
+.ruby-*

data/.rspec

@@ -0,0 +1 @@
+--color --order random --fail-fast

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in elementary-rpc.gemspec
+gemspec
+
+gem 'rack'
+gem 'protobuf', :github => 'lookout/protobuf',
+                :ref => 'wip/http'
+
+group :test do
+  gem 'rspec'
+end
+
+group :development do
+  gem 'pry'
+  gem 'debugger', :platform => :mri
+  gem 'debugger-pry', :platform => :mri
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 R. Tyler Croy
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# Elementary RPC
+
+Elementary RPC is a basic
+[Protobuf](https://developers.google.com/protocol-buffers/docs/overview) HTTP
+RPC gem which aims to provide:
+
+ * Easy RPC usage
+ * Parallelism by default
+ * An easily extended RPC request pipeline
+
+### Sample Usage
+
+For the following Protobuf RPC service definition:
+
+```
+package echoserv;
+
+message String {
+  required string data  = 1;
+  optional int64 status = 2;
+}
+
+service Simple {
+  rpc Echo (String) returns (String);
+  rpc Reverse (String) returns (String);
+}
+```
+
+A corresponding Ruby client might look something like this:
+
+```ruby
+require 'rubygems'
+require 'elementary'
+
+require 'echoserv/service.pb' # Include our protobuf object declarations
+
+
+hosts = [{:host => 'localhost', :port => '9292', :prefix => '/rpcserv'}]
+
+
+# Let's use the Statsd middleware to send RPC timing and count information to 
+# Graphite (this presumes we have already used `Statsd.create_instance` elsewhere
+# in our code)
+Elementary.use(Elementary::Middleware::Statsd, :client => Statsd.instance)
+
+
+# Create our Connection object that knows about our Protobuf service
+# definition
+c = Elementary::Connection.new(Echoserv::Simple, :hosts => hosts)
+
+# Create a Protobuf message to send over RPC
+msg = Echoserv::String.new(:data => str)
+
+
+echoed = c.rpc.echo(msg) # => Elementary::Future
+reversed = c.rpc.reverse(msg) # => Elementary::Future
+
+sleep 10 # Twiddle our thumbs doing other things
+
+puts {
+  :echoed => echoed.value, # resolve the future and get our value out
+  :reversed => reversed.value,
+}.to_json
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'elementary-rpc'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install elementary-rpc
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/elementary-rpc/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new
+
+task :default => ['protobuf:spec', 'spec', 'build']
+
+namespace :protobuf do
+  desc 'Generate rspec protos'
+  task :spec do
+    sh "protoc --proto_path=./spec/support/proto --ruby_out=./spec/support #{Dir['./spec/support/proto/**/*.proto'].join(' ')}"
+  end
+end

data/elementary-rpc.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'elementary/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "elementary-rpc"
+  spec.version       = Elementary::VERSION
+  spec.authors       = ["R. Tyler Croy"]
+  spec.email         = ["tyler@monkeypox.org"]
+  spec.summary       = "Gem supporting Protobuf RPC in a simple way"
+  spec.description   = "BLANK"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency 'concurrent-ruby', '~> 0.6.0'
+  spec.add_dependency 'faraday', '~> 0.9.0'
+  spec.add_dependency 'net-http-persistent', '~> 2.9.4'
+  spec.add_dependency 'lookout-statsd', '~> 0.9.0'
+end

data/lib/elementary.rb

@@ -0,0 +1,21 @@
+module Elementary
+  def self.middleware
+    @middleware ||= []
+  end
+
+  def self.use(klass, opts={})
+    if klass.nil?
+      raise ArgumentError, "Cannot add a nil middleware"
+    end
+    self.middleware << [klass, opts]
+    return true
+  end
+
+  def self.flush_middleware
+    @middleware = []
+  end
+end
+
+require 'elementary/version'
+require 'elementary/connection'
+require 'elementary/middleware'

data/lib/elementary/connection.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'protobuf'
+
+require 'elementary/middleware'
+require 'elementary/transport'
+
+module Elementary
+  class Connection
+    attr_reader :raise_on_error, :service
+
+    DEFAULT_HOSTS = [{:host => 'localhost', :port => 8000}].freeze
+
+    # Initialize a connection to the +Protobuf::Rpc::Service+
+    #
+    # @param [Protobuf::Rpc::Service] service
+    # @param [Hash] opts
+    # @options opts [Symbol] :transport Defaults to :http, must map to a class
+    #   in the +Elementary::Transport+ module
+    # @optiosn opts [Array] :hosts An array of {:host => 'localhost', :port =>
+    #   8080} hashes to instruct the connection
+    def initialize(service, opts={})
+      if service.nil? || service.superclass != Protobuf::Rpc::Service
+        raise ArgumentError,
+          "Cannot construct an Elementary::Connection with `#{service}` (#{service.class})"
+      end
+
+      @service = service
+      @transport = opts[:transport]
+      @hosts = opts[:hosts] || DEFAULT_HOSTS
+    end
+
+    def rpc
+      @rpc ||= Elementary::Executor.new(@service, select_transport)
+    end
+
+    def select_transport
+      Elementary::Transport::HTTP.new(@hosts)
+    end
+  end
+end

data/lib/elementary/errors.rb

@@ -0,0 +1,7 @@
+module Elementary
+  module Errors
+    # A simple root class to signify an failure on the RPC server side (see
+    #   "rpc_failed 'message'")
+    class RPCFailure < StandardError; end;
+  end
+end

data/lib/elementary/executor.rb

@@ -0,0 +1,32 @@
+
+module Elementary
+  class Executor
+    attr_reader :service, :transport
+
+    def initialize(service, transport)
+      @service = service
+      @transport = transport
+    end
+
+    def method_missing(method_name, *params)
+      rpc_method = service.rpcs[method_name.to_sym]
+      # XXX: explode if rpc_method is nil
+
+      future = Elementary::Future.new do
+        # This is effectively a Rack middleware stack. yay.
+        #
+        # Easiest to think of it like this:
+        #   Statsd.new(HTTP.new(nil))
+        stack = Elementary.middleware.inject(transport) do |accumulator, middleware|
+          klass = middleware.first
+          options = middleware.last
+          klass.new(accumulator, options)
+        end
+
+        stack.call(service, rpc_method, *params)
+      end
+
+      return future.execute
+    end
+  end
+end

data/lib/elementary/future.rb

@@ -0,0 +1,21 @@
+require 'rubygems'
+require 'concurrent'
+
+module Elementary
+  class Future < Concurrent::Future
+    # Invoke undefined methods on the value of the future
+    #
+    # E.g.
+    #   results = c.rpc.search(query)
+    #   # sleep maxint
+    #   results.each do |result|
+    #     # work
+    #   end
+    # 
+    # Which would really invoke:
+    #   results.value.each
+    def method_missing(method, *params)
+      self.value.send(method, *params)
+    end
+  end
+end

data/lib/elementary/middleware.rb

@@ -0,0 +1,4 @@
+# Include all our built in middlewares
+Dir[File.expand_path(File.dirname(__FILE__) + '/**/*.rb')].each do |f|
+  require f
+end

data/lib/elementary/middleware/dummy.rb

@@ -0,0 +1,15 @@
+module Elementary
+  module Middleware
+    class Dummy
+      def initialize(app, opts={})
+        @app = app
+        @opts = opts
+      end
+
+      def call(service, rpc_method, *params)
+        puts "#{self.class.name}#call (options: #{@opts}"
+        @app.call(service, rpc_method, *params)
+      end
+    end
+  end
+end

data/lib/elementary/middleware/statsd.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'statsd'
+
+module Elementary
+  module Middleware
+    class Statsd
+      # Create a new Statsd middleware for Elementary
+      #
+      # @param [Hash] opts Hash of optional parameters
+      # @option opts [::Statsd::Client] :client Set to an existing instance of
+      # a +Statsd::Client+
+      def initialize(app, opts={})
+        @app = app
+
+        @statsd = opts[:client] || ::Statsd::Client.new
+      end
+
+      def call(service, rpc_method, *params)
+        @statsd.timing(metric_name(service.name, rpc_method.method)) do
+          @app.call(service, rpc_method, *params)
+        end
+      end
+
+      def metric_name(service_name, method_name)
+        service_name = service_name.gsub('::', '.').downcase
+        return "elementary.#{service_name}.#{method_name}"
+      end
+    end
+  end
+end

data/lib/elementary/transport.rb

@@ -0,0 +1,6 @@
+module Elementary
+  module Transport
+  end
+end
+
+require 'elementary/transport/http'

data/lib/elementary/transport/http.rb

@@ -0,0 +1,64 @@
+require 'rubygems'
+require 'cgi'
+require 'faraday'
+require 'socket'
+
+require 'elementary/errors'
+require 'elementary/future'
+
+module Elementary
+  module Transport
+    class HTTP
+      ERROR_HEADER_MSG = 'x-protobuf-error'
+      ERROR_HEADER_CODE = 'x-protobuf-error-reason'
+
+      def initialize(hosts)
+        @hosts = hosts
+      end
+
+      def call(service, rpc_method, *params)
+        begin
+          response = client.post do |h|
+            path = "#{CGI.escape(service.name)}/#{rpc_method.method}"
+            h.url(path)
+            h.body = params[0].encode
+          end
+
+          error_msg = response.headers[ERROR_HEADER_MSG]
+          error_code = response.headers[ERROR_HEADER_CODE]
+
+          if error_msg
+            raise Elementary::Errors::RPCFailure, "Error #{error_code}: #{error_msg}"
+          end
+
+          return rpc_method[:response_type].decode(response.body)
+        rescue StandardError => e
+          #puts "EXCEPTION #{e.inspect}"
+          raise
+        end
+      end
+
+      private
+
+      def host_url
+        # XXX: need to support a full collection of hosts similar to
+        # elasticsearch-ruby
+        host = @hosts.first
+        prefix = host[:prefix]
+        return "http://#{host[:host]}:#{host[:port]}/#{prefix}"
+      end
+
+      def client
+        return @client if @client
+
+        @client = Faraday.new(:url => host_url) do |f|
+          f.response :logger
+          f.adapter :net_http_persistent
+        end
+
+        return @client
+      end
+    end
+  end
+end
+

data/lib/elementary/version.rb

@@ -0,0 +1,4 @@
+
+module Elementary
+  VERSION = "1.0.0"
+end

data/spec/connection_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'elementary/connection'
+
+describe Elementary::Connection do
+  describe '#initialize' do
+    subject(:connection) { described_class.new(service, opts) }
+    let(:opts) { {} }
+
+    context 'without a Protobuf::Rpc::Service' do
+      let(:service) { nil }
+
+      it 'should raise ArgumentError' do
+        expect { connection }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with a Protobuf::Rpc::Service' do
+      let(:service) { Elementary::Rspec::Simple }
+
+      it { should be_instance_of described_class }
+    end
+  end
+
+  let(:connection) do
+    described_class.new(Elementary::Rspec::Simple)
+  end
+
+  describe '#select_transport' do
+    subject(:transport) { connection.select_transport }
+
+    context 'by default' do
+      it { should be_instance_of Elementary::Transport::HTTP }
+    end
+  end
+
+
+  describe 'an error request', :type => :integration do
+    describe 'rpc' do
+      describe '#error' do
+        subject(:response) { connection.rpc.error(request) }
+        let(:request) { Elementary::Rspec::String.new(:data => 'rspec') }
+
+        before :each do
+          response.value
+        end
+
+        it { should be_rejected }
+      end
+    end
+  end
+
+  describe 'an echo request', :type => :integration do
+    after :each do
+      Elementary.flush_middleware
+    end
+
+    describe 'rpc' do
+      describe '#echo' do
+        let(:request) { Elementary::Rspec::String.new(:data => 'rspec') }
+        subject(:response) { connection.rpc.echo(request) }
+
+        before :each do
+          Elementary.use Elementary::Middleware::Dummy, :rspec => true
+          expect_any_instance_of(Elementary::Middleware::Dummy).to \
+                  receive(:call).and_call_original
+        end
+
+        it 'should have a value containing the echoed string' do
+          puts "Sending req #{Time.now.to_f}"
+          expect(response).to be_instance_of Elementary::Future
+
+          puts "Waiting for future #{Time.now.to_f}"
+          value = response.value # Wait on the future
+          puts "Future responded: #{Time.now.to_f}"
+
+          expect(response).not_to be_rejected
+          expect(value.data).to eql('rspec')
+        end
+      end
+    end
+  end
+end

data/spec/elementary_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'elementary'
+
+describe Elementary do
+  after :each do
+    described_class.flush_middleware
+  end
+
+  describe '.middleware' do
+    subject { described_class.middleware }
+
+    it { should be_instance_of Array }
+  end
+
+  describe '.use' do
+    let(:mw) { nil }
+    subject { described_class.use(mw) }
+
+    context 'with nil' do
+      it 'should raise' do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+
+    context 'with a class' do
+      let(:mw) { Elementary::Middleware::Statsd }
+
+      it { should be true }
+    end
+  end
+end

data/spec/executor_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'elementary/executor'
+
+describe Elementary::Executor do
+  let(:executor) { described_class.new(service, transport) }
+  let(:service) { nil }
+  let(:transport) { nil }
+end

data/spec/future_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'elementary/future'
+
+describe Elementary::Future do
+  let(:future) { described_class.new do 1 end }
+
+  describe '#method_missing' do
+    context 'methods defined on Concurrent::Future' do
+      it 'should invoke the methods directly on the future' do
+        expect(future).to receive(:value)
+        future.value
+      end
+    end
+
+    context 'methods not defined on Concurrent::Future' do
+      let(:actual) do
+        double('Elementary::Future#value mock')
+      end
+
+      before :each do
+        expect(future).to receive(:value).and_return(actual)
+      end
+
+      it 'should invoke the method on the value of the future' do
+        value = 1337
+        expect(actual).to receive(:number).and_return(value)
+
+        expect(future.number).to eql(value)
+      end
+
+      it 'should invoke the method with params on the value of the future' do
+        expect(actual).to receive(:add).with(2, 2).and_return(5)
+
+        expect(future.add(2, 2)).to eql(5)
+      end
+    end
+  end
+end

data/spec/middleware/statsd_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'elementary/middleware/statsd'
+
+describe Elementary::Middleware::Statsd do
+  let(:statsd) { described_class.new(nil) }
+
+  describe '#metric_name' do
+    subject(:metric) { statsd.metric_name(service_name, method_name) }
+
+    let(:service_name) { 'My::Rpc::Service' }
+    let(:method_name) { 'echo' }
+
+    it { should eql 'elementary.my.rpc.service.echo' }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../'))
+require 'elementary'
+
+unless RUBY_PLATFORM == 'java'
+  require 'debugger'
+  require 'debugger/pry'
+end
+
+# Reequire all our generate test protos
+Dir[File.expand_path(File.dirname(__FILE__) + '/support/**/*.pb.rb')].each do |f|
+  require f
+end

data/spec/support/proto/simpleservice.proto

@@ -0,0 +1,12 @@
+
+package elementary.rspec;
+
+message String {
+  required string data  = 1;
+  optional int64 status = 2;
+}
+
+service Simple {
+  rpc Echo (String) returns (String);
+  rpc Error (String) returns (String);
+}

data/spec/support/simpleservice.pb.rb

@@ -0,0 +1,36 @@
+##
+# This file is auto-generated. DO NOT EDIT!
+#
+require 'protobuf/message'
+require 'protobuf/rpc/service'
+
+module Elementary
+  module Rspec
+
+    ##
+    # Message Classes
+    #
+    class String < ::Protobuf::Message; end
+
+
+    ##
+    # Message Fields
+    #
+    class String
+      required :string, :data, 1
+      optional :int64, :status, 2
+    end
+
+
+    ##
+    # Service Classes
+    #
+    class Simple < ::Protobuf::Rpc::Service
+      rpc :echo, ::Elementary::Rspec::String, ::Elementary::Rspec::String
+      rpc :error, ::Elementary::Rspec::String, ::Elementary::Rspec::String
+    end
+
+  end
+
+end
+

data/spec/support/simpleservice.rb

@@ -0,0 +1,19 @@
+require './spec/support/simpleservice.pb'
+
+module Elementary
+  module Rspec
+    class Simple
+      def echo
+        puts "ECHOING #{request.inspect}"
+        sleep 1
+
+        respond_with(String.new(:data => request.data))
+      end
+
+      def error
+        rpc_failed 'sample failure'
+      end
+    end
+  end
+end
+

data/spec/transport/http_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'elementary/transport/http'
+
+describe Elementary::Transport::HTTP do
+  let(:hosts) { [] }
+  let(:http) { described_class.new(hosts) }
+
+  describe '#host_url' do
+    subject(:host_url) { http.send(:host_url) }
+
+    context 'without a prefix' do
+      let(:hosts) do
+        [
+          {
+            :host => 'localhost',
+            :port => 8080,
+          }
+        ]
+      end
+
+      it { should eql 'http://localhost:8080/' }
+    end
+
+    context 'with a prefix' do
+      let(:hosts) do
+        [
+          {
+            :host => 'localhost',
+            :port => 8080,
+            :prefix => 'rspec'
+          }
+        ]
+      end
+
+      it { should eql 'http://localhost:8080/rspec' }
+    end
+  end
+
+  describe '#client' do
+    let(:hosts) do
+      [
+        {
+          :host => 'localhost',
+          :port => 8080,
+        }
+      ]
+    end
+    subject(:client) { http.send(:client) }
+
+    it { should be_instance_of Faraday::Connection }
+
+    it 'should cache connections' do
+      first = http.send(:client)
+      second = http.send(:client)
+
+      # Object identity!
+      expect(first).to be second
+    end
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: elementary-rpc
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- R. Tyler Croy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.9.4
+- !ruby/object:Gem::Dependency
+  name: lookout-statsd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+description: BLANK
+email:
+- tyler@monkeypox.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- elementary-rpc.gemspec
+- lib/elementary.rb
+- lib/elementary/connection.rb
+- lib/elementary/errors.rb
+- lib/elementary/executor.rb
+- lib/elementary/future.rb
+- lib/elementary/middleware.rb
+- lib/elementary/middleware/dummy.rb
+- lib/elementary/middleware/statsd.rb
+- lib/elementary/transport.rb
+- lib/elementary/transport/http.rb
+- lib/elementary/version.rb
+- spec/connection_spec.rb
+- spec/elementary_spec.rb
+- spec/executor_spec.rb
+- spec/future_spec.rb
+- spec/middleware/statsd_spec.rb
+- spec/spec_helper.rb
+- spec/support/proto/simpleservice.proto
+- spec/support/simpleservice.pb.rb
+- spec/support/simpleservice.rb
+- spec/transport/http_spec.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Gem supporting Protobuf RPC in a simple way
+test_files:
+- spec/connection_spec.rb
+- spec/elementary_spec.rb
+- spec/executor_spec.rb
+- spec/future_spec.rb
+- spec/middleware/statsd_spec.rb
+- spec/spec_helper.rb
+- spec/support/proto/simpleservice.proto
+- spec/support/simpleservice.pb.rb
+- spec/support/simpleservice.rb
+- spec/transport/http_spec.rb