clustered_rpc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b9bc292ea42805f08ade35dbd5ccc1856fecfdebff8443c943ee9bc4f9dd4a72
+  data.tar.gz: 3d18c96eecd6b8fe288a9130a9f15b660cc4031495d196c0fed5ea1a7aad1fb6
+SHA512:
+  metadata.gz: 54f0b6a5c19a38ef87c0acd1c75449a307fc4605812baa6986fb5ae0e4f1ac6abce3211e5b4989329212b885f7de9f9d99b89f115287ab4c6f5b89bbfe2d628d
+  data.tar.gz: 1e9fe2a6c30c8c8e970ee648b6fd57e8f9a31900507a820b5bddccccd140d68c905798fc0d40c1ae7da61f637b2c01dbc35886cd865187e2f59e65759376cbd3

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 2.0.2

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    clustered_rpc (0.1.0)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.1.3.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    awesome_print (1.8.0)
+    byebug (11.1.3)
+    concurrent-ruby (1.1.8)
+    diff-lcs (1.4.4)
+    docile (1.3.2)
+    i18n (1.8.10)
+      concurrent-ruby (~> 1.0)
+    json (2.3.0)
+    minitest (5.14.4)
+    rake (10.5.0)
+    redis (4.2.2)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  bundler (~> 2.0)
+  byebug
+  clustered_rpc!
+  rake (~> 10.0)
+  redis
+  rspec (~> 3.0)
+  simplecov
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 dhicks@verisys.com
+
+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,53 @@
+# ClusteredRpc
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/clustered`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'clustered_rpc'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install clustered_rpc
+
+## Usage
+
+Works on *static* class methods!!!
+
+```ruby
+class MyClass
+  include ClusteredRpc::Methods
+
+  def self.do_the_thing
+    # important code living on many servers in the cluster
+    puts "I'm important!"
+  end
+end
+
+# Run the method on every process running in the cluster
+MyClass.clustered_rpc.do_the_thing
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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/[USERNAME]/clustered.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://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/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "clustered"
+
+# 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/clustered_rpc.gemspec

@@ -0,0 +1,40 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "clustered_rpc/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "clustered_rpc"
+  spec.version       = ClusteredRpc::VERSION
+  spec.authors       = ["megalithtracers@gmail.com"]
+  spec.email         = ["megalithtracers@gmail.com"]
+
+  spec.summary       = %q{Allows Ruby RPC across clustered rails processes}
+  spec.description   = %q{When you need to run code on all rails processes within a cluster.  AppServers, Sidekiq, Resque, etc...}
+  spec.homepage      = "http://megalithtracers.com"
+  spec.license       = "MIT"
+
+  #  spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/megalithtracers/clustered_rpc"
+  spec.metadata["changelog_uri"] = "https://github.com/megalithtracers/clustered_rpc/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |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_dependency "activesupport"
+
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "redis"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "simplecov"
+end

data/lib/clustered_rpc.rb

@@ -0,0 +1,65 @@
+require "clustered_rpc/version"
+require "securerandom"
+require "logger"
+require "json"
+require "active_support/concern"
+require "clustered_rpc/proxy"
+require "clustered_rpc/transport/base"
+
+module ClusteredRpc
+  class Error < StandardError; end
+
+  @@instance_id = SecureRandom.hex(5)
+  @@logger = ::Logger.new(STDOUT)
+  @@transport_class = nil
+  @@transport = nil
+  @@options = {}
+
+  def self.logger=(logger); @@logger = logger; end
+  def self.logger; @@logger; end
+
+  def self.instance_id=(instance_id); @@instance_id = instance_id; end
+  def self.instance_id; @@instance_id; end
+
+  def self.transport_class=(transport_class); @@transport_class = transport_class; end
+  def self.transport_class; @@transport_class; end
+
+  def self.options=(options); @@options = options; end
+  def self.options; @@options; end
+
+  # request_id should have been returned from the call to #cluster_send
+  def self.get_result(request_id, wait_seconds = 1.0)
+    sleep(wait_seconds) if wait_seconds
+    results = @@transport.get_result(request_id)
+    results.keys.each{|k| results[k] = JSON.parse(results[k])}
+    results # ??? Rails anyone? .with_indifferent_access
+  end
+
+
+
+  def self.config(force=false, &block)
+    block.call(self)
+
+    @@instance_id ||= SecureRandom.hex(5)
+    raise "Please set transport_class in ClusteredRpc.config" if transport_class.nil? 
+    logger.info "Clustered using #{@@transport_class}"
+    @@transport = @@transport_class.new
+    @@transport.connect
+
+  end
+
+  def self.reconnect
+    @@transport.reconnect
+    @@transport
+  end
+
+  # payload will likely have keys: [:klass, :method, :args]
+  def self.publish(payload={})
+    # if :request_id is already present, then we're responding with a process-level response
+    # otherwise we're creating a new clustered_request and should generate a :request_io
+    payload[:request_id] ||= SecureRandom.hex(8)
+    @@transport.publish payload
+    payload[:request_id]
+  end
+
+end

data/lib/clustered_rpc/info.rb

@@ -0,0 +1,59 @@
+require 'clustered/rpc_methods'
+require 'open3'
+
+module ClusteredRpc
+  class Info
+    include ClusteredRpc::Methods
+
+    def self.stats
+      require 'objspace'
+      { instance_id: ClusteredRpc.instance_id, 
+        transport_class: ClusteredRpc.transport_class.name.to_s, 
+        options: ClusteredRpc.options,
+        process_id: Process.pid,
+        uptime: get_uptime,
+        used_mb: memory_used,
+        startup_command: startup_command,
+        process_type: lookup_process_type(startup_command),
+        count_objects_size: ObjectSpace.count_objects_size,
+        gc: GC.stat,
+        count_nodes: ObjectSpace.count_nodes
+      }
+
+    end
+
+    def self.startup_command
+      "#{$0} #{$*}"
+    end
+
+    def self.memory_used
+      (((100.0 * (`ps -o rss -p #{$$}`.strip.split.last.to_f / 1024.0)).to_i) / 100.0)
+    end
+
+    def self.get_uptime 
+      Open3.capture3("ps", "-p", Process.pid.to_s, "-o", "etime=").first.split("\n").first
+    end
+
+    def self.lookup_process_type(sc = startup_command)
+      process_type = if (sc == "script/rails []") || (sc == "bin/rails []") || ( sc =~ /spring app/)
+        "Rails Console"
+      elsif (sc =~ /sidekiq/) 
+        "Sidekiq"
+      elsif (sc =~ /puma/) 
+        "Web Server"
+      elsif (sc =~ /rspec/)
+        "Rspec"
+      elsif sc =~ /scheduler/
+        "Resque Scheduler"
+      elsif sc =~ /resque:work/
+        "Resque Worker"
+      elsif sc =~ /rules:redis/
+        "Rules Engine"
+      else
+        sc
+      end
+      process_type
+    end
+
+  end
+end

data/lib/clustered_rpc/methods.rb

@@ -0,0 +1,14 @@
+module ClusteredRpc
+  module Methods
+    extend ActiveSupport::Concern
+
+    included do |base_class|
+
+      def base_class.clustered_rpc(options = {})
+        ClusteredRpc::Proxy.new(self, options)
+      end
+
+    end
+
+  end
+end

data/lib/clustered_rpc/proxy.rb

@@ -0,0 +1,18 @@
+module ClusteredRpc
+  class Proxy 
+    def initialize(target, options)
+      @target = target
+      @options = options
+    end
+
+    def method_missing(method, *args, **kwargs)
+      wait_seconds = (@options[:wait_seconds] || ENV['CLUSTERED_RPC_WAIT_SECONDS'] || 1.0).to_i
+      request_id = ::ClusteredRpc.publish({'klass' => @target.name, 'method' => method, 'args' => args, 'kwargs' => kwargs}.merge(@options))
+      {request_id: request_id, success: true, results: ::ClusteredRpc.get_result(request_id, wait_seconds)}
+    rescue => e 
+      ClusteredRpc.logger.error "ClusteredRpc::Proxy encountered errror: #{e.message}"
+      {request_id: "Error", success: false, results: e.message}
+    end
+    
+  end
+end

data/lib/clustered_rpc/transport/base.rb

@@ -0,0 +1,46 @@
+module ClusteredRpc
+  module Transport
+    class Base
+
+      def get_result(request_id)
+        raise "Subclassers must implement this to retrieve results"
+      end
+
+      def connect
+        # Subclassers should implement this
+      end
+
+      def subscribed?
+        # Subclassers should implement this if they offer keep_alive guarantees
+      end
+
+      def reconnect
+        # Subclassers should implement this if they offer keep_alive guarantees
+      end
+
+      def run_method_from_message(payload)
+        klass=payload['klass']
+        method=payload['method']
+        klass = Object.const_get(klass) rescue nil if klass.is_a? String  
+        if klass
+          start_time = Time.now
+          args = payload['args']
+          kwargs = payload['kwargs']
+          kwargs = Hash[kwargs.map{|k,v| [k.to_sym, v] }] if kwargs
+          result = if args && args.length > 0 && kwargs && kwargs.length > 0
+            klass.send method.to_sym, *args, **kwargs
+          elsif kwargs && kwargs.length > 0
+            klass.send method.to_sym, **kwargs
+          elsif args && args.length > 0
+            klass.send method.to_sym, *args
+          else           
+            klass.send method.to_sym
+          end          
+          seconds = Time.now - start_time        
+        end
+        {seconds: seconds, result: result}
+      end
+
+    end
+  end
+end

data/lib/clustered_rpc/transport/local_process.rb

@@ -0,0 +1,20 @@
+module ClusteredRpc
+  module Transport
+    class LocalProcess < ClusteredRpc::Transport::Base
+
+
+      def publish(payload={})
+        result = run_method_from_message(payload)
+        Thread.current[:clustered_pass_through_result] = { ClusteredRpc.instance_id => result.to_json}
+      end
+
+      def get_result(request_id)
+        Thread.current[:clustered_pass_through_result]
+      end
+
+      def method_missing(method, *args)
+        raise "LocalProcess cluster attempted to call missing method [#{method}].  Do you have missing Redis configuration?"
+      end
+    end
+  end
+end

data/lib/clustered_rpc/transport/redis_cluster.rb

@@ -0,0 +1,112 @@
+require 'redis'
+
+module ClusteredRpc
+  module Transport
+    class RedisCluster < ClusteredRpc::Transport::Base
+
+      def initialize
+        @redis_subscriber = nil
+        @redis_publish = nil
+        @redis_message_pubsub_key = "__cluster_messages"
+        connect
+      end
+
+      def publish(payload={})
+        @redis_publish.publish @redis_message_pubsub_key, payload.to_json
+      rescue => e 
+        ClusteredRpc.logger.error "ClusteredRpc.publish encountered errror: #{e.message}"
+        raise e
+      end
+
+      def get_result(request_id)
+        hgetall("request:#{request_id}")
+      end
+
+      def reconnect
+        @redis_publish = nil
+        if @subscriber_thread
+          ClusteredRpc.logger.warn "ClusteredRpc: killing subscriber thread"
+          @subscriber_thread.kill
+          @redis_subscriber = nil
+        end
+        connect
+      end
+
+      def hgetall(key_name) 
+        @redis_publish.hgetall key_name
+      end
+
+      def subscribed?
+        @subscribed
+      end
+
+      def connect 
+        return if !@redis_subscriber.nil? # already connected - call reconnect...
+        @redis_subscriber = ::Redis.new(ClusteredRpc.options)
+        @redis_publish = ::Redis.new(ClusteredRpc.options)
+        @subscribed = false
+        @subscriber_thread = Thread.new do 
+          begin
+            @redis_subscriber.subscribe( @redis_message_pubsub_key ) do |on|
+              on.subscribe do |channel, subscriptions|
+                @retry_count = 0
+                ClusteredRpc.logger.info {"ClusteredRpc: Subscribed to ##{channel} (#{subscriptions} subscriptions)"}
+                @subscribed = true
+              end
+
+              on.message do |channel, message|
+                ClusteredRpc.logger.debug {"ClusteredRpc: Handling message ##{channel}: #{message}"}
+                begin
+                  message = JSON.parse(message) rescue message
+                  if message.is_a? Hash
+                    result = run_method_from_message(message)
+                    ClusteredRpc.logger.debug {"ClusteredRpc: Got result: #{result}"}
+                    request_id = message['request_id'] 
+                    if request_id
+                      # Store the result for 10 minutes in hash identified by the request_id and for this particular PID
+                      ClusteredRpc.logger.debug {"Setting ClusterSend result:  request:#{request_id}[#{Process.pid}]"}
+                      @redis_publish.pipelined do 
+                        @redis_publish.hmset "request:#{request_id}", ClusteredRpc.instance_id, result.to_json
+                        @redis_publish.expire "request:#{request_id}", 600
+                      end
+                    end
+                  else
+                    ClusteredRpc.logger.warn "Unknown message type: #{message.class}"
+                  end
+                rescue => e
+                  ClusteredRpc.logger.error e.backtrace.join("\n")
+                  ClusteredRpc.logger.error "Error[#{e.message}] Handling message ##{channel}: #{message}"
+                end
+              end
+
+              on.unsubscribe do |channel, subscriptions|
+                ClusteredRpc.logger.info {"ClusteredRpc: Unsubscribed from ##{channel} (#{subscriptions} subscriptions)"}
+              end
+            end
+          rescue Redis::BaseConnectionError => e
+            ClusteredRpc.logger.error e.message
+            @retry_count ||= 0
+            @retry_count += 1
+            sleep_seconds = [[@retry_count,10].min, 5].max 
+            ClusteredRpc.logger.warn "ClusteredRpc: Retrying redis connection in #{sleep_seconds} seconds: #{@retry_count}"
+            ClusteredRpc.logger.info @config
+            sleep sleep_seconds
+            retry if @retry_count <= 300
+            ClusteredRpc.logger.warn "ClusteredRpc: Could not reconnect to Redis"
+          ensure
+            ClusteredRpc.logger.info "ClusteredRpc: Subscription thread terminated..."
+            @subscribed = false
+          end # begin
+        end # @subscriber_thread = Thread.new do
+        # Give the subscriber a chance to connect in background thread before returning
+        attempts = 0
+        while !subscribed? do
+          sleep(1)
+          attempts += 1
+          ClusteredRpc.logger.info "ClusteredRpc: Waiting for subscription...#{attempts} times"
+          raise "ClusteredRpc: Could not subscribe after #{attempts} attempts" if attempts > 15
+        end
+      end # def connect
+    end # class RedisCluster < Clustered::Transport::Base
+  end # module Transport
+end # module Clustered

data/lib/clustered_rpc/version.rb

@@ -0,0 +1,3 @@
+module ClusteredRpc
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: clustered_rpc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- megalithtracers@gmail.com
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-04-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: awesome_print
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  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: 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: redis
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: When you need to run code on all rails processes within a cluster.  AppServers,
+  Sidekiq, Resque, etc...
+email:
+- megalithtracers@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- clustered_rpc.gemspec
+- lib/clustered_rpc.rb
+- lib/clustered_rpc/info.rb
+- lib/clustered_rpc/methods.rb
+- lib/clustered_rpc/proxy.rb
+- lib/clustered_rpc/transport/base.rb
+- lib/clustered_rpc/transport/local_process.rb
+- lib/clustered_rpc/transport/redis_cluster.rb
+- lib/clustered_rpc/version.rb
+homepage: http://megalithtracers.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://megalithtracers.com
+  source_code_uri: https://github.com/megalithtracers/clustered_rpc
+  changelog_uri: https://github.com/megalithtracers/clustered_rpc/CHANGELOG.md
+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: []
+rubygems_version: 3.2.16
+signing_key:
+specification_version: 4
+summary: Allows Ruby RPC across clustered rails processes
+test_files: []