protobuf-nats 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8941cd6d0acf196cafb26b994e7cb71156cc9ddf
+  data.tar.gz: f87f6f7c86874688d94785e177e54f35950d91c7
+SHA512:
+  metadata.gz: abdcc5311c25b5598a8bd73ec344ab3c12a8072f689a7473645e21e6ba61e477ede2e96deea566a4a15a0f3da0d8b27a3036ce062c497d487bbb7999158d5dd8
+  data.tar.gz: f3dda5036de14aae93b0e07933897f835ad944c0e0798f9dc1b6a135bba83d7f82c2a8a265b45bf7c393dac013863519e89bc39315420c30269f8744459055b8

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.travis.yml

@@ -0,0 +1,8 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+  - jruby-9.1.7.0
+before_install:
+  - gem install bundler -v 1.14.3
+  - gem update --system

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in protobuf-nats.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Brandon Dewitt
+
+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,118 @@
+Protobuf::Nats
+==============
+
+An rpc client and server library built using the `protobuf` gem and the NATS protocol.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'protobuf-nats'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install protobuf-nats
+
+## Configuring
+
+The client and server are configured via environment variables defined in the `pure-ruby-nats` gem. However, there are a
+few params which cannot be set: `servers`, `uses_tls` and `connect_timeout`, so those my be defined in a yml file.
+
+The library will automatically look for a file with a relative path of `config/protobuf_nats.yml`, but you may override
+this by specifying a different file via the `PROTOBUF_NATS_CONFIG_PATH` env variable.
+
+An example config looks like this:
+```
+# Stored at config/protobuf_nats.yml
+---
+  production:
+    servers:
+      - "nats://127.0.0.1:4222"
+      - "nats://127.0.0.1:4223"
+      - "nats://127.0.0.1:4224"
+    uses_tls: true
+    connect_timeout: 2
+```
+
+## Usage
+
+This library is designed to be an alternative transport implementation used by the `protobuf` gem. In order to make
+`protobuf` use this library, you need to set the following env variable:
+
+```
+PB_SERVER_TYPE="protobuf/nats/runner"
+PB_CLIENT_TYPE="protobuf/nats/client"
+```
+
+## Example
+
+NOTE: For a more detailed example, look at the `warehouse` app in the `examples` directory of this project.
+
+Here's a tl;dr example. You might have a protobuf definition and implementation like this:
+
+```ruby
+require "protobuf/nats"
+
+class User < ::Protobuf::Message
+  optional :int64, :id, 1
+  optional :string, :username, 2
+end
+
+class UserService < ::Protobuf::Rpc::Service
+  rpc :create, User, User
+
+  def create
+    respond_with User.new(:id => 123, :username => request.username)
+  end
+end
+```
+
+Let's assume we saved this in a file called `app.rb`
+
+We can now start an rpc server using the protobuf-nats runner and client:
+
+```
+$ export PB_SERVER_TYPE="protobuf/nats/runner"
+$ export PB_CLIENT_TYPE="protobuf/nats/client"
+$ bundle exec rpc_server start ./app.rb
+...
+I, [2017-03-24T12:16:02.539930 #12512]  INFO -- : Creating subscriptions:
+I, [2017-03-24T12:16:02.543927 #12512]  INFO -- :   - rpc.user_service.create
+...
+```
+
+And we can start a client and begin communicating:
+
+```
+$ export PB_SERVER_TYPE="protobuf/nats/runner"
+$ export PB_CLIENT_TYPE="protobuf/nats/client"
+$ bundle exec irb -r ./app
+irb(main):001:0> UserService.client.create(User.new(:username => "testing 123"))
+=> #<User id=123 username="testing 123">
+```
+
+And we can see the message was sent to the server and the server replied with a user which now has an `id`.
+
+If we were to add another service endpoint called `search` to the `UserService` but fail to define an instance method
+`search`, then `protobuf-nats` will not subscribe to that route.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/abrandoned/protobuf-nats.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bench/client.rb

@@ -0,0 +1,26 @@
+ENV["PB_CLIENT_TYPE"] = "protobuf/nats/client"
+ENV["PB_SERVER_TYPE"] = "protobuf/nats/runner"
+
+require "benchmark/ips"
+require "./examples/warehouse/app"
+
+payload = ::Warehouse::Shipment.new(:guid => ::SecureRandom.uuid, :address => "123 yolo st")
+request = ::Protobuf::Socketrpc::Request.new(:service_name => "::Warehouse::ShipmentService",
+                                             :method_name => "create",
+                                             :request_proto => payload.encode).encode
+
+nats = ::NATS::IO::Client.new
+nats.connect({:servers => ["nats://127.0.0.1:4222"]})
+
+subscription_key_and_queue = "rpc.warehouse.shipment_service.create"
+
+Protobuf::Logging.logger = ::Logger.new(nil)
+
+Benchmark.ips do |config|
+  config.warmup = 10
+  config.time = 10
+
+  config.report("single threaded performance") do
+    nats.request(subscription_key_and_queue, request)
+  end
+end

data/bench/real_client.rb

@@ -0,0 +1,21 @@
+ENV["PB_CLIENT_TYPE"] = "protobuf/nats/client"
+ENV["PB_SERVER_TYPE"] = "protobuf/nats/runner"
+
+require "benchmark/ips"
+require "./examples/warehouse/app"
+
+payload = ::Warehouse::Shipment.new(:guid => ::SecureRandom.uuid, :address => "123 yolo st")
+nats = ::NATS::IO::Client.new
+nats.connect({:servers => ["nats://127.0.0.1:4222"]})
+
+Protobuf::Logging.logger = ::Logger.new(nil)
+
+Benchmark.ips do |config|
+  config.warmup = 10
+  config.time = 10
+
+  config.report("single threaded performance") do
+    req = Warehouse::Shipment.new(:guid => SecureRandom.uuid)
+    Warehouse::ShipmentService.client.create(req)
+  end
+end

data/bench/real_server.sh

@@ -0,0 +1 @@
+PB_SERVER_TYPE="protobuf/nats/runner" PB_CLIENT_TYPE="protobuf/nats/client" bundle exec rpc_server start --threads=20 ./examples/warehouse/app.rb > /dev/null

data/bench/server.rb

@@ -0,0 +1,39 @@
+require "nats/io/client"
+require "concurrent"
+require "protobuf"
+require 'protobuf/message'
+require 'protobuf/rpc/service'
+
+module Warehouse
+  class Shipment < ::Protobuf::Message
+    optional :string, :guid, 1
+    optional :string, :address, 2
+    optional :double, :price, 3
+    optional :string, :package_guid, 4
+  end
+end
+
+$thread_pool = ::Concurrent::FixedThreadPool.new(20)
+payload = ::Warehouse::Shipment.new(:guid => ::SecureRandom.uuid, :address => "123 yolo st")
+$response = ::Protobuf::Socketrpc::Response.new(:response_proto => payload.encode).encode
+
+$nats = ::NATS::IO::Client.new
+$nats.connect({:servers => ["nats://127.0.0.1:4222"]})
+
+subscription_key_and_queue = "Warehouse::ShipmentService::create"
+$nats.subscribe(subscription_key_and_queue, :queue => subscription_key_and_queue) do |request_data, reply_id, _subject|
+  ::Concurrent::Promise.new(:executor => $thread_pool).then do
+    $nats.publish(reply_id, $response)
+  end.on_error do |error|
+    logger.error error
+    if error.respond_to?(:backtrace) && error.backtrace.is_a?(::Array)
+      logger.error error.backtrace.join("\n")
+    end
+  end.execute
+end
+
+puts "Server started!"
+
+loop do
+  sleep 1
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "protobuf/nats"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/warehouse/app.rb

@@ -0,0 +1,55 @@
+require "protobuf/nats"
+
+require 'protobuf/message'
+require 'protobuf/rpc/service'
+
+module Warehouse
+
+  ##
+  # Message Classes
+  #
+  class Shipment < ::Protobuf::Message; end
+  class ShipmentRequest < ::Protobuf::Message; end
+  class Shipments < ::Protobuf::Message; end
+
+
+  ##
+  # Message Fields
+  #
+  class Shipment
+    optional :string, :guid, 1
+    optional :string, :address, 2
+    optional :double, :price, 3
+    optional :string, :package_guid, 4
+  end
+
+  class ShipmentRequest
+    repeated :string, :guid, 1
+    repeated :string, :address, 2
+    repeated :string, :package_guid, 3
+  end
+
+  class Shipments
+    repeated ::Warehouse::Shipment, :records, 1
+  end
+
+
+  ##
+  # Service Classes
+  #
+  class ShipmentService < ::Protobuf::Rpc::Service
+    rpc :create, ::Warehouse::Shipment, ::Warehouse::Shipment
+    rpc :not_implemented, ::Warehouse::Shipment, ::Warehouse::Shipment
+    rpc :search, ::Warehouse::ShipmentRequest, ::Warehouse::Shipments
+
+    def create
+      respond_with request
+    end
+
+    def search
+      shipment = ::Warehouse::Shipment.new(:guid => SecureRandom.uuid, :address => "123 LAME ST", :price => 100.0, :package_guid => SecureRandom.uuid)
+      respond_with ::Warehouse::Shipments.new(:records => [shipment])
+    end
+  end
+
+end

data/examples/warehouse/start_client.sh

@@ -0,0 +1,7 @@
+echo "Examples:"
+echo "req = Warehouse::ShipmentRequest.new"
+echo "res = Warehouse::ShipmentService.client.search(req)"
+echo ""
+echo "req = Warehouse::Shipment.new"
+echo "res = Warehouse::ShipmentService.client.create(req)"
+PB_SERVER_TYPE="protobuf/nats/runner" PB_CLIENT_TYPE="protobuf/nats/client" bundle exec irb -I lib -r ./examples/warehouse/app.rb

data/examples/warehouse/start_server.sh

@@ -0,0 +1 @@
+PB_SERVER_TYPE="protobuf/nats/runner" PB_CLIENT_TYPE="protobuf/nats/client" bundle exec rpc_server start ./examples/warehouse/app.rb

data/lib/protobuf/nats/client.rb

@@ -0,0 +1,99 @@
+require "protobuf/nats"
+require "protobuf/rpc/connectors/base"
+require "monitor"
+
+module Protobuf
+  module Nats
+    class Client < ::Protobuf::Rpc::Connectors::Base
+      def initialize(options)
+        # may need to override to setup connection at this stage ... may also do on load of class
+        super
+
+        ::Protobuf::Nats.ensure_client_nats_connection_was_started
+      end
+
+      def close_connection
+        # no-op (I think for now), the connection to server is persistent
+      end
+
+      def self.subscription_key_cache
+        @subscription_key_cache ||= {}
+      end
+
+      def send_request
+        retries ||= 3
+
+        setup_connection
+        request_options = {:timeout => 60, :ack_timeout => 5}
+        @response_data = nats_request_with_two_responses(cached_subscription_key, @request_data, request_options)
+        parse_response
+      rescue ::NATS::IO::Timeout
+        # Nats response timeout.
+        retry if (retries -= 1) > 0
+        raise
+      end
+
+      def cached_subscription_key
+        klass = @options[:service]
+        method_name = @options[:method]
+
+        method_name_cache = self.class.subscription_key_cache[klass] ||= {}
+        method_name_cache[method_name] ||= begin
+          ::Protobuf::Nats.subscription_key(klass, method_name)
+        end
+      end
+
+      # This is a request that expects two responses.
+      # 1. An ACK from the server. We use a shorter timeout.
+      # 2. A PB message from the server. We use a longer timoeut.
+      def nats_request_with_two_responses(subject, data, opts)
+        nats = Protobuf::Nats.client_nats_connection
+        inbox = nats.new_inbox
+        lock = ::Monitor.new
+        ack_condition = lock.new_cond
+        pb_response_condition = lock.new_cond
+        response = nil
+        sid = nats.subscribe(inbox, :max => 2) do |message|
+          lock.synchronize do
+            case message
+            when ::Protobuf::Nats::Messages::ACK
+              ack_condition.signal
+              next
+            else
+              response = message
+              pb_response_condition.signal
+            end
+          end
+        end
+
+        lock.synchronize do
+          # Publish to server
+          nats.publish(subject, data, inbox)
+
+          # Wait for the ACK from the server
+          ack_timeout = opts[:ack_timeout] || 5
+          with_timeout(ack_timeout) { ack_condition.wait(ack_timeout) }
+
+          # Wait for the protobuf response
+          timeout = opts[:timeout] || 60
+          with_timeout(timeout) { pb_response_condition.wait(timeout) } unless response
+        end
+
+        response
+      ensure
+        # Ensure we don't leave a subscription sitting around.
+        nats.unsubscribe(sid) if response.nil?
+      end
+
+      # This is a copy of #with_nats_timeout
+      def with_timeout(timeout)
+        start_time = ::NATS::MonotonicTime.now
+        yield
+        end_time = ::NATS::MonotonicTime.now
+        duration = end_time - start_time
+        raise ::NATS::IO::Timeout.new("nats: timeout") if duration > timeout
+      end
+
+    end
+  end
+end

data/lib/protobuf/nats/config.rb

@@ -0,0 +1,69 @@
+require "openssl"
+require "yaml"
+
+module Protobuf
+  module Nats
+    class Config
+      attr_accessor :uses_tls, :servers, :connect_timeout
+
+      CONFIG_MUTEX = ::Mutex.new
+
+      DEFAULTS = {
+        :uses_tls => false,
+        :connect_timeout => nil,
+        :servers => nil
+      }.freeze
+
+      def initialize
+        DEFAULTS.each_pair do |key, value|
+          __send__("#{key}=", value)
+        end
+      end
+
+      def load_from_yml(reload = false)
+        CONFIG_MUTEX.synchronize do
+          @load_from_yml = nil if reload
+          @load_from_yml ||= begin
+            env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["APP_ENV"] || "development"
+
+            yaml_config = {}
+            config_path = ENV["PROTOBUF_NATS_CONFIG_PATH"] || ::File.join("config", "protobuf_nats.yml")
+            absolute_config_path = ::File.expand_path(config_path)
+            if ::File.exists?(absolute_config_path)
+              yaml_config = ::YAML.load_file(absolute_config_path)[env]
+            end
+
+            DEFAULTS.each_pair do |key, value|
+              setting = yaml_config[key.to_s]
+              __send__("#{key}=", setting) if setting
+            end
+
+            # Reload the connection options hash
+            connection_options(true)
+
+            true
+          end
+        end
+      end
+
+      def connection_options(reload = false)
+        @connection_options = false if reload
+        @connection_options || begin
+          options = {
+            servers: servers,
+            connect_timeout: connect_timeout
+          }
+          options[:tls] = {:context => new_tls_context} if uses_tls
+          options
+        end
+      end
+
+      def new_tls_context
+        tls_context = ::OpenSSL::SSL::SSLContext.new
+        tls_context.ssl_version = :TLSv1_2
+        tls_context
+      end
+
+    end
+  end
+end

data/lib/protobuf/nats/fixed_thread_pool_with_no_queue.rb

@@ -0,0 +1,32 @@
+require "concurrent"
+
+module Protobuf
+  module Nats
+    class FixedThreadPoolWithNoQueue < ::Concurrent::FixedThreadPool
+      def ns_initialize(opts)
+        min_length = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
+        max_length = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
+        idletime = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
+        @fallback_policy = opts.fetch(:fallback_policy, :abort)
+
+        if ::Concurrent.on_jruby?
+          super(opts)
+
+          # We need to use a synchronous queue to ensure we only perform work
+          # when a thread is available.
+          queue = java.util.concurrent.SynchronousQueue.new
+          @executor = java.util.concurrent.ThreadPoolExecutor.new(
+            min_length, max_length,
+            idletime, java.util.concurrent.TimeUnit::SECONDS,
+            queue, FALLBACK_POLICY_CLASSES[@fallback_policy].new)
+        else
+          # MRI will take a max queue of -1 to mean no queue.
+          opts[:max_queue] = -1
+          super(opts)
+        end
+
+        @max_queue = -1
+      end
+    end
+  end
+end

data/lib/protobuf/nats/runner.rb

@@ -0,0 +1,55 @@
+require "ostruct"
+require "thread"
+
+require "protobuf/nats"
+
+module Protobuf
+  module Nats
+    class Runner
+
+      def initialize(options)
+        @options = case
+                   when options.is_a?(OpenStruct) then
+                     options.marshal_dump
+                   when options.respond_to?(:to_hash) then
+                     options.to_hash.symbolize_keys
+                   else
+                     fail "Cannot parse Nats Server - server options"
+                   end
+      end
+
+      def run
+        @server = ::Protobuf::Nats::Server.new(@options)
+        register_signals
+        @server.run do
+          yield if block_given?
+        end
+      end
+
+      def running?
+        @server.try :running?
+      end
+
+      def stop
+        @server.try :stop
+      end
+
+      private
+
+      def register_signals
+        trap(:TRAP) do
+          ::Thread.list.each do |thread|
+            logger.info do
+              <<-THREAD_TRACE
+                #{thread.inspect}:
+                  #{thread.backtrace.try(:join, $INPUT_RECORD_SEPARATOR)}"
+              THREAD_TRACE
+            end
+          end
+        end
+
+      end
+    end
+
+  end
+end

data/lib/protobuf/nats/server.rb

@@ -0,0 +1,106 @@
+require "active_support/core_ext/class/subclasses"
+require "protobuf/nats/fixed_thread_pool_with_no_queue"
+require "protobuf/rpc/server"
+require "protobuf/rpc/service"
+
+module Protobuf
+  module Nats
+    class Server
+      include ::Protobuf::Rpc::Server
+      include ::Protobuf::Logging
+
+      attr_reader :nats, :thread_pool, :subscriptions
+
+      def initialize(options)
+        @options = options
+        @running = true
+        @stopped = false
+
+        @nats = options[:client] || ::NATS::IO::Client.new
+        @nats.connect(::Protobuf::Nats.config.connection_options)
+
+        @thread_pool = ::Protobuf::Nats::FixedThreadPoolWithNoQueue.new(options[:threads])
+
+        @subscriptions = []
+      end
+
+      def service_klasses
+        ::Protobuf::Rpc::Service.implemented_services.map(&:safe_constantize)
+      end
+
+      def execute_request_promise(request_data, reply_id)
+        ::Concurrent::Promise.new(:executor => thread_pool).then do
+          # Publish an ACK.
+          nats.publish(reply_id, ::Protobuf::Nats::Messages::ACK)
+          # Process request.
+          response_data = handle_request(request_data)
+          # Publish response.
+          nats.publish(reply_id, response_data)
+        end.on_error do |error|
+          logger.error error.to_s
+          if error.respond_to?(:backtrace) && error.backtrace.is_a?(::Array)
+            logger.error error.backtrace.join("\n")
+          end
+        end.execute
+      rescue ::Concurrent::RejectedExecutionError
+        nil
+      end
+
+      def subscribe_to_services
+        logger.info "Creating subscriptions:"
+
+        service_klasses.each do |service_klass|
+          service_klass.rpcs.each do |service_method, _|
+            # Skip services that are not implemented.
+            next unless service_klass.method_defined? service_method
+
+            subscription_key_and_queue = ::Protobuf::Nats.subscription_key(service_klass, service_method)
+            logger.info "  - #{subscription_key_and_queue}"
+
+            subscriptions << nats.subscribe(subscription_key_and_queue, :queue => subscription_key_and_queue) do |request_data, reply_id, _subject|
+              unless execute_request_promise(request_data, reply_id)
+                logger.error { "Thread pool is full! Dropping message for: #{subscription_key_and_queue}" }
+              end
+            end
+          end
+        end
+      end
+
+      def run
+        nats.on_reconnect do
+          logger.warn "Reconnected to NATS server!"
+        end
+
+        nats.on_disconnect do
+          logger.warn "Disconnected from NATS server!"
+        end
+
+        subscribe_to_services
+
+        yield if block_given?
+
+        loop do
+          break unless @running
+          sleep 1
+        end
+
+        subscriptions.each do |subscription_id|
+          nats.unsubscribe(subscription_id)
+        end
+
+        thread_pool.shutdown
+        thread_pool.wait_for_termination
+      ensure
+        @stopped = true
+      end
+
+      def running?
+        @stopped
+      end
+
+      def stop
+        @running = false
+      end
+    end
+  end
+end

data/lib/protobuf/nats/version.rb

@@ -0,0 +1,5 @@
+module Protobuf
+  module Nats
+    VERSION = "0.1.0"
+  end
+end

data/lib/protobuf/nats.rb

@@ -0,0 +1,57 @@
+require "protobuf/nats/version"
+
+require "protobuf"
+# We don't need this, but the CLI attempts to terminate.
+require "protobuf/rpc/service_directory"
+
+require "connection_pool"
+
+require "nats/io/client"
+
+require "protobuf/nats/client"
+require "protobuf/nats/server"
+require "protobuf/nats/runner"
+require "protobuf/nats/config"
+
+module Protobuf
+  module Nats
+    class << self
+      attr_accessor :client_nats_connection
+    end
+
+    module Messages
+      ACK = "\1".freeze
+    end
+
+    def self.config
+      @config ||= begin
+        config = ::Protobuf::Nats::Config.new
+        config.load_from_yml
+        config
+      end
+    end
+
+    # Eagerly load the yml config.
+    config
+
+    def self.subscription_key(service_klass, service_method)
+      service_class_name = service_klass.name.underscore.gsub("/", ".")
+      service_method_name = service_method.to_s.underscore
+      "rpc.#{service_class_name}.#{service_method_name}"
+    end
+
+    def self.start_client_nats_connection
+      @client_nats_connection = ::NATS::IO::Client.new
+      @client_nats_connection.connect(config.connection_options)
+
+      # Ensure we have a valid connection to the NATS server.
+      @client_nats_connection.flush(5)
+
+      true
+    end
+
+    def self.ensure_client_nats_connection_was_started
+      @ensure_client_nats_connection_was_started ||= start_client_nats_connection
+    end
+  end
+end

data/protobuf-nats.gemspec

@@ -0,0 +1,43 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'protobuf/nats/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "protobuf-nats"
+  spec.version       = Protobuf::Nats::VERSION
+  spec.authors       = ["Brandon Dewitt"]
+  spec.email         = ["brandonsdewitt@gmail.com"]
+
+  spec.summary       = %q{ ruby-protobuf client/server for nats }
+  spec.description   = %q{ ruby-protobuf client/server for nats }
+  #spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "protobuf", "3.7.0.pre3"
+  spec.add_runtime_dependency "connection_pool"
+  spec.add_runtime_dependency "concurrent-ruby"
+  spec.add_runtime_dependency "nats-pure"
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "benchmark-ips"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: protobuf-nats
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brandon Dewitt
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.7.0.pre3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.7.0.pre3
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nats-pure
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: benchmark-ips
+  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: pry
+  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'
+description: " ruby-protobuf client/server for nats "
+email:
+- brandonsdewitt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bench/client.rb
+- bench/real_client.rb
+- bench/real_server.sh
+- bench/server.rb
+- bin/console
+- bin/setup
+- examples/warehouse/app.rb
+- examples/warehouse/start_client.sh
+- examples/warehouse/start_server.sh
+- lib/protobuf/nats.rb
+- lib/protobuf/nats/client.rb
+- lib/protobuf/nats/config.rb
+- lib/protobuf/nats/fixed_thread_pool_with_no_queue.rb
+- lib/protobuf/nats/runner.rb
+- lib/protobuf/nats/server.rb
+- lib/protobuf/nats/version.rb
+- protobuf-nats.gemspec
+homepage: 
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.5.2
+signing_key: 
+specification_version: 4
+summary: ruby-protobuf client/server for nats
+test_files: []