msgpack_rpc_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7feba3f261abbfdb61f1f4f320d4f981fdc4b97f
+  data.tar.gz: 6beec26d066279f6c098ac88df223f80610e6a04
+SHA512:
+  metadata.gz: f84815a076edb16128aba33a22aff7bb3c18af4d2f247656eec5e73cafad0c405191f424b28741b6942c3923d9246571a8720db901f565420110447fc45b5e7c
+  data.tar.gz: 5dbf537b5ff8920da50310857ecd88d5238ca4ed182e1d09141b261725400ce16220f89770f05424ff6640aad9e9062a4188a2f181b41604d5d4d5991baa550e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 BrightBytes
+
+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,65 @@
+# MsgpackRpcClient [![CircleCI](https://circleci.com/gh/brightbytes/msgpack_rpc_client.svg?style=svg)](https://circleci.com/gh/brightbytes/msgpack_rpc_client)
+
+## A lean Ruby client for the MessagePack-RPC protocol
+
+Use this gem to achieve reliable, fault-tolerant RPC with your microservices.
+
+### Differences from the "official" implementation (the msgpack-rpc gem)
+
+The official implementation:
+
+* depends on the cool.io gem, labeled "retired" [on the homepage](https://coolio.github.io).
+* does not re-establish connections.
+* designed to be asynchronous
+* displayed instability under high load in production
+
+This implementation:
+
+* has no dependencies
+* is under 200 lines in one class
+* automatically re-establishes connections in the case of inevitable network errors, service restarts, deploys, and so on.
+* supports SSL
+* threadsafe
+* reliable
+* high load tested
+* used in production, with up to a 1000 requests per second in a single frontend request.
+* supports JRuby and MRI from version 1.9.3 - for those who have a huge legacy app that you're dying to factor into microservices!
+
+However, this implementation **does NOT support asynchronous calls** - if you require this feature, it is not for you. However, from my experience, almost no Ruby applications require asynchronous communication.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'msgpack_rpc_client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install msgpack_rpc_client
+
+## Usage
+
+``` ruby
+require 'msgpack_rpc_client'
+
+client = MsgpackRpcClient.new('127.0.0.1', 12345)
+response = client.call('HelloWorld', name: 'Ruby')
+```
+
+See the `examples` directory for a complete server-client example.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/brightbytes/msgpack_rpc_client.
+
+
+## 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/circle.yml

@@ -0,0 +1,14 @@
+machine:
+  environment:
+    RUBY_VERSIONS: 1.9.3,2.0.0,2.1.10,2.2.5,2.3.1,jruby-1.7.25,jruby-9.1.2.0
+
+dependencies:
+  override:
+    - rvm get head
+    - rvm install $RUBY_VERSIONS
+    - rvm $RUBY_VERSIONS --verbose do gem install bundler -v 1.10.6
+    - rvm $RUBY_VERSIONS --verbose do bundle install
+
+test:
+  override:
+    - rvm $RUBY_VERSIONS --verbose do bundle exec rspec spec

data/examples/benchmark.rb

@@ -0,0 +1,25 @@
+# Run server.go in a parallel process first
+
+require 'json'
+require 'msgpack_rpc_client'
+require 'benchmark/ips'
+
+msgpack_client = MsgpackRpcClient.new('127.0.0.1', 12345)
+http_uri = URI('http://localhost:12344/hello_world')
+
+Benchmark.ips do |x|
+  x.report 'http/json' do
+    req = Net::HTTP::Post.new(http_uri, 'Content-Type' => 'application/json')
+    req.body = { name: 'Ruby' }.to_json
+    res = Net::HTTP.start(http_uri.hostname, http_uri.port) do |http|
+      http.request(req)
+    end
+    JSON.parse(res.body, symbolize_keys: true)
+  end
+
+  x.report 'msgpack-rpc' do
+    msgpack_client.call('Greeter.HelloWorld', name: 'Ruby')
+  end
+
+  x.compare!
+end

data/examples/client.rb

@@ -0,0 +1,15 @@
+# Run server.go in a parallel process first
+
+require 'msgpack_rpc_client'
+
+client = MsgpackRpcClient.new('127.0.0.1', 12345)
+
+response = client.call('Greeter.HelloWorld', name: 'Ruby')
+# {:greeting=>"Hello, Ruby"}
+puts response[:greeting]
+
+puts client.call('Greeter.HelloWorld', {})
+# {:error=>"Name is required"}
+
+puts client.call('Greeter.BogusMethod', {})
+# MsgpackRpcError exception: Server responded with error: rpc: can't find method Greeter.BogusMethod

data/examples/server.go

@@ -0,0 +1,82 @@
+// go get github.com/ugorji/go/codec
+// go run server.go
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"net/rpc"
+
+	"github.com/ugorji/go/codec"
+)
+
+// The request structure type
+// JSON tags are reused by go-codec for all encoding formats
+type HelloWorldRequest struct {
+	Name string `json:"name"`
+}
+
+// The response structure type
+type HelloWorldResponse struct {
+	Greeting string `json:"greeting,omitempty"`
+	Error    string `json:"error,omitempty"`
+}
+
+// Our empty placeholder server type
+type HelloWorldServer struct{}
+
+// The request handler. It follows the usual net/rpc requirements.
+// Note that the return `error` is akin to a 500 Internal Server Error,
+// and shouldn't be used for  errors directed at the consumer.
+func (s *HelloWorldServer) HelloWorld(request *HelloWorldRequest, response *HelloWorldResponse) error {
+	if request.Name == "" {
+		response.Error = "Name is required"
+		return nil
+	}
+	response.Greeting = fmt.Sprintf("Hello, %s", request.Name)
+	return nil
+}
+
+func main() {
+	// Register the service with RPC
+	var s HelloWorldServer
+	rpc.RegisterName("Greeter", &s)
+
+	go func() {
+		// Using custom codecs with net/rpc is verbose, but isolated to this piece of code
+		var mh codec.MsgpackHandle
+		listener, err := net.Listen("tcp", "127.0.0.1:12345")
+		if err != nil {
+			log.Fatalf("failed to listen on msgpack-rpc address: %v", err)
+		}
+		log.Print("Msgpack listening on port 12345, Ctrl+C to abort")
+		for {
+			conn, err := listener.Accept()
+			if err != nil {
+				log.Fatalf("failed to accept msgpack-rpc connection: %v", err)
+			}
+			rpcCodec := codec.MsgpackSpecRpc.ServerCodec(conn, &mh)
+			go func() {
+				rpc.ServeCodec(rpcCodec)
+			}()
+		}
+	}()
+
+	// HTTP/JSON API for the benchmarking example
+	h := new(codec.JsonHandle)
+	http.HandleFunc("/hello_world", func(w http.ResponseWriter, r *http.Request) {
+		var request HelloWorldRequest
+		var response HelloWorldResponse
+
+		dec := codec.NewDecoder(r.Body, h)
+		dec.Decode(&request)
+		s.HelloWorld(&request, &response)
+		w.WriteHeader(http.StatusOK)
+		enc := codec.NewEncoder(w, h)
+		enc.Encode(response)
+	})
+	log.Print("HTTP listening on port 12344, Ctrl+C to abort")
+	http.ListenAndServe("127.0.0.1:12344", nil)
+}

data/lib/msgpack_rpc_client.rb

@@ -0,0 +1,142 @@
+require "msgpack_rpc_client/version"
+require 'msgpack'
+require 'socket'
+
+# MessagePack-RPC client
+class MsgpackRpcClient
+  class Error < RuntimeError; end
+
+  DEFAULT_MAX_RETRIES = 10
+  DEFAULT_MAX_CONNECT_RETRIES = 5
+  DEFAULT_CONNECT_RETRY_WAIT = 0.1 # seconds
+  MAX_MSGID = 1_000_000_000
+
+  attr_reader :host, :port, :use_ssl, :max_retries, :max_connect_retries, :connect_retry_wait
+
+  # Initialize client and establish connection to server.
+  #
+  # (While it may seem beneficial to not connect in the constructor and wait for
+  # the first RPC call, I believe it's better to fail early.
+  #
+  # * host, port, use_ssl - configure your connection
+  # * logger - logger (default nil, set to Rails.logger in a Rails app)
+  #
+  # Parameters that are better left alone:
+  # * max_retries - number of times to retry sending a request
+  # * max_connect_retries - number of times to retry connecting to the server
+  # * connect_retry_wait - wait between connection retry attempts
+  #
+  # TODO: once we are long past the <2.0.0 legacy, replace with named args
+  def initialize(options={})
+    @host = options.fetch(:host)
+    @port = options.fetch(:port)
+    @use_ssl = options.fetch(:use_ssl, false)
+    @logger = options.fetch(:logger, nil)
+    @max_retries = options.fetch(:max_retries, DEFAULT_MAX_RETRIES)
+    @max_connect_retries = options.fetch(:max_connect_retries, DEFAULT_MAX_CONNECT_RETRIES)
+    @connect_retry_wait = options.fetch(:connect_retry_wait, DEFAULT_CONNECT_RETRY_WAIT)
+    @msgid = 1
+    @call_mutex = Mutex.new
+    init_socket
+  end
+
+  # Call an RPC method. Will reconnect if the server is down. Threadsafe.
+  #
+  # * Params is anything serializable with Messagepack.
+  # * Hashes in response will be deserialized with symbolized keys
+  def call(method_name, *params)
+    request = nil
+    response = nil
+
+    @call_mutex.synchronize do
+      request = [0, @msgid, method_name, params]
+      @msgid = (@msgid % MAX_MSGID) + 1
+      response = make_request_with_retries(request)
+    end
+
+    if response[0] != 1
+      raise MsgpackRpcClient::Error, 'Response does not bear the proper type flag - something is very wrong'
+    end
+    if response[1] != request[1]
+      raise MsgpackRpcClient::Error, 'Response message id does not match request message id - something is very wrong'
+    end
+    if response[2] != nil
+      raise MsgpackRpcClient::Error, "Server responded with error: #{response[2]}"
+    end
+
+    response[3]
+  end
+
+  private
+
+  # Handles socket connectivity details of sending and receiving. Retries on error.
+  def make_request_with_retries(request)
+    retry_count = 0
+    begin
+      @packer.write(request).flush
+      @unpacker.read
+    rescue EOFError, IOError, Errno::EPIPE, Errno::ETIMEDOUT, Errno::ECONNRESET
+      @logger.error("[MSGPACK-RPC] Msgpack-RPC socket interrupted. Re-establishing commmunications.") if @logger
+      retry_count += 1
+      if retry_count == max_retries
+        raise MsgpackRpcClient::Error, "Failed to re-establish communications with server"
+      else
+        init_socket
+        retry
+      end
+    end
+  end
+
+  # Opens a socket according to provided configuration. Retries on error.
+  def init_socket
+    @socket.close if @socket
+    retry_count = 0
+    begin
+      @logger.info("[MSGPACK-RPC] Connecting to Msgpack-RPC server...") if @logger
+      @socket = TCPSocket.new(host, port)
+      configure_socket_keepalive
+      init_ssl if use_ssl
+    rescue Errno::ECONNREFUSED
+      @logger.error("[MSGPACK-RPC] Connection refused") if @logger
+      retry_count += 1
+      if retry_count == max_connect_retries
+        raise MsgpackRpcClient::Error, "Could not connect to MsgPack-RPC server"
+      else
+        sleep(connect_retry_wait)
+        # might have a chance with a different instance
+        retry
+      end
+    end
+    # Attach streaming packer/unpacker to the socket
+    @packer = MessagePack::Packer.new(@socket)
+    @unpacker = MessagePack::Unpacker.new(@socket, symbolize_keys: true)
+  end
+
+  # Configure the TCP stack to send keepalive messages, as we want a long-living
+  # connection.
+  #
+  # (Not 100% reliable)
+  def configure_socket_keepalive
+    @socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+    if defined?(Socket::TCP_KEEPINTVL) # Not available on JRuby
+      @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPINTVL, 10)
+      @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPCNT, 5)
+    end
+    if defined?(Socket::TCP_KEEPIDLE) # Not available on BSD / OSX
+      @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPIDLE, 50)
+    end
+  end
+
+  # Open an SSL socket on top of the TCP socket.
+  #
+  # VERIFY_PEER is mandatory; if you have problems with it, just don't use SSL -
+  # without verification it gives no security benefits but only increases cpu load.
+  def init_ssl
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.set_params(verify_mode: OpenSSL::SSL::VERIFY_PEER)
+    # We are overwriting the TCP socket with the SSL socket here.
+    @socket = OpenSSL::SSL::SSLSocket.new(@socket, ctx)
+    @socket.sync_close = true
+    @socket.connect
+  end
+end

data/lib/msgpack_rpc_client/version.rb

@@ -0,0 +1,3 @@
+class MsgpackRpcClient
+  VERSION = "0.1.0"
+end

data/msgpack_rpc_client.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'msgpack_rpc_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "msgpack_rpc_client"
+  spec.version       = MsgpackRpcClient::VERSION
+  spec.authors       = ["BrightBytes", "Leonid Shevtsov"]
+  spec.email         = ["leonid@shevtsov.me"]
+
+  spec.summary       = %q{A lean Ruby client for the MessagePack-RPC protocol.}
+  spec.homepage      = "https://github.com/brightbytes/msgpack_rpc_client"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "msgpack"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: msgpack_rpc_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- BrightBytes
+- Leonid Shevtsov
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  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.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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'
+description: 
+email:
+- leonid@shevtsov.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- circle.yml
+- examples/benchmark.rb
+- examples/client.rb
+- examples/server.go
+- lib/msgpack_rpc_client.rb
+- lib/msgpack_rpc_client/version.rb
+- msgpack_rpc_client.gemspec
+homepage: https://github.com/brightbytes/msgpack_rpc_client
+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.5.2
+signing_key: 
+specification_version: 4
+summary: A lean Ruby client for the MessagePack-RPC protocol.
+test_files: []
+has_rdoc: