carrot_rpc 0.2.3.pre

data/lib/carrot_rpc/rpc_server.rb

@@ -0,0 +1,77 @@
+# Base RPC Server class. Other Servers should inherit from this.
+class CarrotRpc::RpcServer
+  autoload :JSONAPIResources, "carrot_rpc/rpc_server/jsonapi_resources"
+
+  using CarrotRpc::HashExtensions
+
+  attr_reader :channel, :server_queue, :logger
+  # method_reciver => object that receives the method. can be a class or anything responding to send
+
+  extend CarrotRpc::ClientServer
+
+  # Documentation advises not to share a channel connection. Create new channel for each server instance.
+  def initialize(config: nil, block: true)
+    # create a channel and exchange that both client and server know about
+    config ||= CarrotRpc.configuration
+    @channel = config.bunny.create_channel
+    @logger = config.logger
+    @block = block
+    @server_queue = @channel.queue(self.class.queue_name)
+    @exchange = @channel.default_exchange
+  end
+
+  # start da server!
+  # method => object that receives the method. can be a class or anything responding to send
+  def start
+    # subscribe is like a callback
+    @server_queue.subscribe(block: @block) do |_delivery_info, properties, payload|
+      logger.debug "Receiving message: #{payload}"
+
+      request_message = JSON.parse(payload).with_indifferent_access
+
+      process_request(request_message, properties: properties)
+    end
+  end
+
+  def process_request(request_message, properties:)
+    result = send(request_message[:method], request_message[:params])
+  rescue CarrotRpc::Error => rpc_server_error
+    logger.error(rpc_server_error)
+
+    reply_error rpc_server_error.serialized_message,
+                properties:      properties,
+                request_message: request_message
+  else
+    reply_result result,
+                 properties:      properties,
+                 request_message: request_message
+  end
+
+  private
+
+  def reply(properties:, response_message:)
+    @exchange.publish response_message.to_json,
+                      correlation_id: properties.correlation_id,
+                      routing_key: properties.reply_to
+  end
+
+  # See http://www.jsonrpc.org/specification#error_object
+  def reply_error(error, properties:, request_message:)
+    response_message = { error: error, id: request_message[:id], jsonrpc: "2.0" }
+
+    logger.debug "Publish error: #{error} to #{response_message}"
+
+    reply properties: properties,
+          response_message: response_message
+  end
+
+  # See http://www.jsonrpc.org/specification#response_object
+  def reply_result(result, properties:, request_message:)
+    response_message = { id: request_message[:id], result: result, jsonrpc: "2.0" }
+
+    logger.debug "Publishing result: #{result} to #{response_message}"
+
+    reply properties: properties,
+          response_message: response_message
+  end
+end

data/lib/carrot_rpc/server_runner/autoload_rails.rb

@@ -0,0 +1,41 @@
+# Loads the Rails application so that the servers can use the Rails gems and environment.
+module CarrotRpc::ServerRunner::AutoloadRails
+  # Path to the `config/environment.rb`, which is the file that must actually be `require`d to load Rails.
+  #
+  # @param root [String] path to the root of the Rails app
+  # @return [String]
+  def self.environment_path(root)
+    File.join(root, "config/environment.rb")
+  end
+
+  # Attempts to load Rails app at `root`.
+  #
+  # @param root [String] path to the root of the Rails app
+  # @param logger [Logger] logger to print success to.
+  # @return [true]
+  # @raise [LoadError] if rails cannot be loaded
+  def self.load_root(root, logger:)
+    rails_path = environment_path(root)
+
+    if File.exist?(rails_path)
+      logger.info "Rails app found at: #{rails_path}"
+      ENV["RACK_ENV"] ||= ENV["RAILS_ENV"] || "development"
+      require rails_path
+      ::Rails.application.eager_load!
+      true
+    else
+      require rails_path
+    end
+  end
+
+  # Loads Rails app at `root` if `CarrotRpc.configuration.autoload_rails`
+  #
+  # @param (see load_root)
+  # @return (see load_root)
+  # @raise (see load_root)
+  def self.conditionally_load_root(root, logger:)
+    if CarrotRpc.configuration.autoload_rails
+      load_root(root, logger: logger)
+    end
+  end
+end

data/lib/carrot_rpc/server_runner/logger.rb

@@ -0,0 +1,31 @@
+# Constructs a logger based on the {CarrotRpc.configuration} and Rails environment
+module CarrotRpc::ServerRunner::Logger
+  # A `Logger` configured based on `CarrotRpc.configuration.logfile` and `CarrotRpc.configuration.loglevel`
+  #
+  # Fallbacks:
+  # * `Rails.logger` if `Rails` is loaded
+  # * `Logger` to `STDOUT` if `Rails` is not loaded
+  #
+  # @return [Logger]
+  def self.configured
+    logger = from_file
+
+    if logger.nil?
+      logger = if defined?(::Rails)
+                 CarrotRpc::TaggedLog.new(logger: Rails.logger, tags: ["Carrot RPC"])
+               else
+                 Logger.new(STDOUT)
+               end
+    end
+
+    logger.level = CarrotRpc.configuration.loglevel
+
+    logger
+  end
+
+  def self.from_file
+    return nil unless CarrotRpc.configuration.logfile
+
+    ::Logger.new(CarrotRpc.configuration.logfile)
+  end
+end

data/lib/carrot_rpc/server_runner/pid.rb

@@ -0,0 +1,142 @@
+# Pid and pid path for {CarrotRpc::ServerRunner}
+class CarrotRpc::ServerRunner::Pid
+  # Attributes
+
+  # @return [Logger]
+  attr_reader :logger
+
+  # @return [String]
+  attr_reader :path
+
+  # Methods
+
+  ## Class Methods
+
+  # The status of the given `pid` number.
+  #
+  # @param pid [Integer] a 0 or positive PID
+  # @return [:dead] if `pid` is `0`
+  # @return (see number_error_check_status)
+  def self.number_status(pid)
+    if pid == 0
+      :dead
+    else
+      number_error_check_status(pid)
+    end
+  end
+
+  # The status of the given `non_zero_pid` number.
+  #
+  # @param non_zero_pid [Integer] a non-zero pid
+  # @return [:dead] if `pid` cannot be contacted
+  # @return [:not_owned] if interacting with `pid` raises a permission error
+  # @return [:running] if `pid` is running
+  def self.number_error_check_status(non_zero_pid)
+    # sending signal `0` just performs error checking
+    Process.kill(0, non_zero_pid)
+  rescue Errno::ESRCH
+    # Invalid pid
+    :dead
+  rescue Errno::EPERM
+    # no privilege to interact with process
+    :not_owned
+  else
+    :running
+  end
+
+  # Status of the `pid` inside `path`.
+  #
+  # @return [:exited] if `path` does not exist, which indicates the server never ran or exited cleanly
+  # @return [:not_owned] if `path` cannot be read
+  # @return (see number_status)
+  def self.path_status(path)
+    pid = File.read(path).to_i
+  rescue Errno::ENOENT
+    # File does not exist
+    :exited
+  rescue Errno::EPERM
+    # File cannot be read
+    :not_owned
+  else
+    number_status(pid)
+  end
+
+  ## Initialize
+
+  # @param path [Path, nil] path to pid path
+  def initialize(path:, logger:)
+    unless path.nil?
+      # daemonization will change CWD so expand relative paths now
+      @path = File.expand_path(path)
+    end
+
+    @logger = logger
+  end
+
+  ## Instance Methods
+
+  # Exits if {#status} indicates server is already running, otherwise deletes {#path}.
+  #
+  # @return [void]
+  def check
+    if path?
+      case self.class.path_status(path)
+      when :running, :not_owned
+        logger.warn "A server is already running. Check #{path}"
+        exit(1)
+      when :dead
+        delete
+      end
+    end
+  end
+
+  # Deletes `path` if it is set
+  #
+  # @return [void]
+  def delete
+    if path? && File.exist?(path)
+      File.delete(path)
+    end
+  end
+
+  # Registers an `at_exit` handler to {#delete}.
+  #
+  # @return [void]
+  def delete_at_exit
+    at_exit do
+      delete
+    end
+  end
+
+  # Keeps trying to write {#path} until it succeeds
+  def ensure_written
+    if path?
+      begin
+        write
+      rescue Errno::EEXIST
+        check
+
+        retry
+      else
+        delete_at_exit
+      end
+    end
+  end
+
+  # Whether {#path} is set.
+  #
+  # @return [true] if {#path} is not `nil`.
+  # @return [false] otherwise
+  def path?
+    !path.nil?
+  end
+
+  # Write to process id path
+  #
+  # @return [void]
+  def write
+    File.open(path, File::CREAT | File::EXCL | File::WRONLY) do |f|
+      f.write(Process.pid.to_s)
+    end
+  end
+end

data/lib/carrot_rpc/server_runner/signals.rb

@@ -0,0 +1,21 @@
+# Traps all {the signals NAMES} that should be intercepted by a long-running background process.
+module CarrotRpc::ServerRunner::Signals
+  # CONSTANTS
+
+  # The name of the signals to trap.
+  NAMES = %w(HUP INT QUIT TERM).freeze
+
+  # Traps all {NAMES}.
+  #
+  # @yield [name] Block to call when the signal is trapped.
+  # @yieldparam name [String] the name of the signal that was trapped
+  # @yieldreturn [void]
+  # @return [void]
+  def self.trap
+    NAMES.each do |name|
+      Kernel.trap(name) do
+        yield name
+      end
+    end
+  end
+end

data/lib/carrot_rpc/server_runner.rb

@@ -0,0 +1,156 @@
+require "active_support/core_ext/string/inflections"
+
+# Automatically detects, loads, and runs all {CarrotRpc::RpcServer} subclasses under `app/servers` in the project root.
+class CarrotRpc::ServerRunner
+  extend ActiveSupport::Autoload
+
+  autoload :AutoloadRails
+  autoload :Logger
+  autoload :Pid
+  autoload :Signals
+
+  # Attributes
+
+  attr_reader :quit, :servers
+
+  # @return [CarrotRpc::ServerRunner::Pid]
+  attr_reader :pid
+
+  # Methods
+
+  # Instantiate the ServerRunner.
+  def initialize(rails_path: ".", pidfile: nil, runloop_sleep: 0, daemonize: false)
+    @runloop_sleep = runloop_sleep
+    @daemonize = daemonize
+    @servers = []
+
+    CarrotRpc::ServerRunner::AutoloadRails.conditionally_load_root(rails_path, logger: logger)
+    trap_signals
+
+    @pid = CarrotRpc::ServerRunner::Pid.new(
+      path:   pidfile,
+      logger: logger
+    )
+  end
+
+  # Start the servers and the run loop.
+  def run!
+    pid.check
+    daemonize && suppress_output if daemonize?
+    pid.ensure_written
+
+    # Initialize the servers. Set logger.
+    run_servers
+
+    # Sleep for a split second.
+    until quit
+      sleep @runloop_sleep
+    end
+    # When runtime gets here, quit signal is received.
+    stop_servers
+  end
+
+  # Shutdown all servers defined.
+  def stop_servers
+    logger.info "#{@siginal_name} signal received!"
+    @servers.each do |s|
+      logger.info "Shutting Down Server Queue: #{s.server_queue.name}"
+      s.channel.close
+    end
+    # Close the connection once all the other servers are shutdown
+    CarrotRpc.configuration.bunny.close
+  end
+
+  # Find and require all servers in the app/servers dir.
+  # @param dirs [Array] directories relative to root of host application where RpcServers can be loaded
+  # @return [Array] of RpcServers loaded and initialized
+  def run_servers(dirs: %w(app servers))
+    files = server_files(dirs)
+    fail "No servers found!" if files.empty?
+
+    # Load each server defined in the project dir
+    files.each do |file|
+      @servers << run_server_file(file)
+    end
+
+    @servers
+  end
+
+  def run_server_file(file)
+    require file
+    server_klass_name = file.to_s.split("/").last.gsub(".rb", "").camelize
+    server_klass = server_klass_name.constantize
+
+    logger.info "Starting #{server_klass}..."
+
+    server = server_klass.new(block: false)
+    server.start
+
+    server
+  end
+
+  def server_files(dirs)
+    Dir[server_glob(dirs)]
+  end
+
+  def server_glob(dirs)
+    regex = %r{\A/.*/#{dirs.join("/")}\z}
+    $LOAD_PATH.find { |p|
+      p.match(regex)
+    } + "/*.rb"
+  end
+
+  # Convenience method to wrap the logger object.
+  def logger
+    @logger ||= set_logger
+  end
+
+  # attr_reader doesn't allow adding a `?` to the method name, so I think this is a false positive
+  # rubocop:disable Style/TrivialAccessors
+
+  # Attribute to determine when to daemonize the process.
+  def daemonize?
+    @daemonize
+  end
+
+  # rubocop:enable Style/TrivialAccessors
+
+  # Background the ruby process.
+  def daemonize
+    exit if fork
+    Process.setsid
+    exit if fork
+    Dir.chdir "/"
+  end
+
+  # Part of daemonizing process. Prevents application from outputting info to terminal.
+  def suppress_output
+    $stderr.reopen("/dev/null", "a")
+    $stdout.reopen($stderr)
+  end
+
+  # Set a value to signal shutdown.
+  def shutdown(name)
+    @signal_name = name
+    @quit = true
+  end
+
+  # Handle signal events.
+  def trap_signals
+    CarrotRpc::ServerRunner::Signals.trap do |name|
+      # @note can't log from a trap context: since Ruby 2.0 traps don't allow mutexes as it could lead to a dead lock,
+      #   so `logger.info` here would return "log writing failed. can't be called from trap context"
+      shutdown(name)
+    end
+  end
+
+  private
+
+  # Determine how to create logger. Config can specify log file.
+  def set_logger
+    logger = CarrotRpc::ServerRunner::Logger.configured
+    CarrotRpc.configuration.logger = logger
+
+    logger
+  end
+end

data/lib/carrot_rpc/tagged_log.rb

@@ -0,0 +1,24 @@
+# Wrap the Logger object with convenience methods.
+class CarrotRpc::TaggedLog
+  attr_reader :logger, :tags
+
+  def initialize(logger:, tags:)
+    @logger = logger
+    @tags = *tags
+  end
+
+  def level
+    logger.level
+  end
+
+  def level=(level)
+    logger.level = level
+  end
+
+  # Dyanmically define logger methods with a tagged reference. Makes filtering of logs possible.
+  %i(debug info warn error fatal unknown).each do |level|
+    define_method(level) do |msg|
+      logger.tagged(tags) { logger.send(level, msg) }
+    end
+  end
+end

data/lib/carrot_rpc/version.rb

@@ -0,0 +1,3 @@
+module CarrotRpc
+  VERSION = "0.2.3.pre".freeze
+end

data/lib/carrot_rpc.rb

@@ -0,0 +1,46 @@
+# gem dependencies
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/hash/except"
+require "active_support/dependencies/autoload"
+require "bunny"
+
+# standard library
+require "json"
+require "optparse"
+
+# project
+require "carrot_rpc/version"
+
+# An opinionated approach to doing Remote Procedure Call (RPC) with RabbitMQ and the bunny gem. CarrotRpc serves as a
+# way to streamline the RPC workflow so developers can focus on the implementation and not the plumbing when working
+# with RabbitMQ.
+module CarrotRpc
+  extend ActiveSupport::Autoload
+
+  autoload :CLI
+  autoload :ClientServer
+  autoload :Configuration
+  autoload :Error
+  autoload :HashExtensions
+  autoload :RpcClient
+  autoload :RpcServer
+  autoload :ServerRunner
+  autoload :TaggedLog
+
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  # Resets the configuration back to a new instance. Should only be used in testing.
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+end