metarpc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 298f8b1a42cd14096c6aea8b808c6b90fd04fdc2fec1c2a9999d4f91c1195582
+  data.tar.gz: d4ead54bba04fe30a8016c572d4871eecc6a1a5fbce8d6e0a4062dd9dd6931da
+SHA512:
+  metadata.gz: 227de707133d3ebfbf4db2184ff7ae50162b8c395f56544bd7c0fbcdda5accec9a8fb5e8a457bfd5a85f0c70b487686286cd78ab1556c37df00f921a14b20cfb
+  data.tar.gz: 22de052bee3742e3495b47edfc68f79e0e916f4e00f52fc5db1749459230cacaeffee3618b1f097b6bb659894ea533914dd9209428db59bdaf7d7955147df847

data/lib/metarpc/callable.rb

@@ -0,0 +1,126 @@
+module MetaRPC
+  # Module used to describe callable JSON RPC methods
+  module Callable
+    def self.included(klass)
+      super
+      klass.send(:extend, ClassMethods)
+    end
+
+    def json_rpc_error(code)
+      raise RPCError.new(code), "Failed to call JSON RPC method : #{code}"
+    end
+
+    def validate_item(item, contract_type)
+      case contract_type
+      when Hash
+        validate_hash(item, contract_type)
+      when Array
+        validate_array(item, contract_type)
+      when Class
+        raise json_rpc_error(:invalid_params) unless item.is_a?(contract_type)
+      when String
+        klass, nullable, spread = if contract_type.end_with?('!')
+                                    [contract_type.delete('!').constantize, true, false]
+
+                                  elsif contract_type.end_with?('!...')
+                                    [contract_type.delete('!...').constantize, true, true]
+
+                                  elsif contract_type.end_with?('...')
+                                    [contract_type.delete('...').constantize, false, true]
+
+                                  else
+                                    [contract_type.constantize, false, false]
+                                  end
+
+        if spread
+          raise json_rpc_error(:invalid_params) unless item.is_a?(Array)
+
+          item.each do |sub_item|
+            next if sub_item.nil? && nullable
+            raise json_rpc_error(:invalid_params) unless sub_item.present? && sub_item.is_a?(klass)
+          end
+        else
+          return if item.nil? && nullable
+          raise json_rpc_error(:invalid_params) unless item.present? && item.is_a?(klass)
+        end
+      else
+        raise json_rpc_error(:internal_error)
+      end
+    rescue NameError
+      raise json_rpc_error(:internal_error)
+    end
+
+    def validate_array(args, contract)
+      contract.each_with_index do |contract_type, i|
+        validate_item(args[i], contract_type)
+      end
+    end
+
+    def validate_hash(args, contract)
+      contract.each do |arg_name, contract_type|
+        raise json_rpc_error(:invalid_params) unless args.key?(arg_name)
+
+        validate_item(args[arg_name], contract_type)
+      end
+    end
+
+    # Injected class methods
+    module ClassMethods
+      def json_rpc_methods
+        @__json_rpc_hooked_methods
+      end
+
+      def handle_json_callable(method_name)
+        old_method = instance_method(method_name)
+        return if (@__json_rpc_hooked_methods ||= {}).key?(method_name)
+
+        @__ignoring_added_methods = true
+        params_contract = @__json_rpc_method_params
+        error_handler = @__on_json_rpc_error
+
+        define_method method_name do |*args, &block|
+          case params_contract
+          when nil
+            raise json_rpc_error(:invalid_params) unless args.empty?
+          when Array
+            validate_item(args, params_contract)
+          when Hash
+            validate_item(args[0], params_contract)
+          else
+            raise json_rpc_error(:internal_error)
+          end
+
+          old_method.bind(self).call(*args, &block)
+        rescue RPCError => err
+          raise err
+
+        rescue StandardError => err
+          error_handler&.call(err)
+          raise json_rpc_error(:server_error)
+        end
+
+        @__ignoring_added_methods = false
+        @__json_rpc_hooked_methods[method_name] = {
+          description: @__json_rpc_method_description,
+          params: @__json_rpc_method_params
+        }
+      end
+
+      def on_json_rpc_error(&func)
+        @__on_json_rpc_error = func
+      end
+
+      def json_rpc_method(description, params: nil)
+        @__next_method_is_json_rpc = true
+        @__json_rpc_method_description = description
+        @__json_rpc_method_params = params
+      end
+
+      def method_added(method_name)
+        super
+        handle_json_callable(method_name) if @__next_method_is_json_rpc && !@__ignoring_added_methods
+        @__next_method_is_json_rpc = false
+      end
+    end
+  end
+end

data/lib/metarpc/interpreter.rb

@@ -0,0 +1,96 @@
+module MetaRPC
+  # Used to interpret RPC requests and execute them securely
+  class Interpreter
+    attr_reader :input
+
+    def initialize(raw_request)
+      raw_input = JSON.parse(raw_request)
+
+      @input = if raw_input.is_a?(Array)
+                 raw_input.map(&method(:validate_json_rpc_call))
+               else
+                 validate_json_rpc_call(raw_input)
+               end
+    rescue JSON::ParserError
+      raise_error(:parse_error)
+    end
+
+    def execute(executor)
+      return input.map { |inp| execute_method(executor, inp) } if input.is_a?(Array)
+
+      execute_method(executor, input)
+    end
+
+    def execute_method(executor, inp)
+      raise_error(:method_not_found) unless executor.class.json_rpc_methods.key?(inp[:method])
+
+      result = if inp[:params].is_a?(Array)
+                 executor.public_send(inp[:method], *inp[:params])
+               elsif inp[:params].is_a?(Hash)
+                 executor.public_send(inp[:method], inp[:params])
+               elsif inp[:params].nil?
+                 executor.public_send(inp[:method])
+               else
+                 raise_error(:internal_error)
+               end
+
+      {
+        jsonrpc: '2.0',
+        result: result,
+        id: inp[:id]
+      }
+    rescue RPCError => err
+      {
+        jsonrpc: '2.0',
+        error: err.to_h,
+        id: inp[:id]
+      }
+    end
+
+    def validate_json_rpc_call(item)
+      # Containing the required key
+      valid = item.key?('jsonrpc') && item.key?('method')
+
+      # Does not contain unknown keys
+      valid &&= (item.keys - %w[jsonrpc method params id]).empty?
+
+      # Defining the correct JSONRPC version
+      valid &&= item['jsonrpc'] == '2.0'
+
+      # Defining a correct ID
+      valid &&= valid_id(item['id'])
+
+      # Defining a correct params object
+      valid &&= valid_params(item['params'])
+
+      # Defining a correct method name
+      valid &&= valid_method_name(item['method'])
+
+      raise_error(:invalid_request) unless valid
+
+      item.deep_symbolize_keys.tap do |h|
+        h[:method] = h[:method].to_sym
+      end
+    end
+
+    def valid_id(id)
+      return true if id.nil?
+
+      id.is_a?(String) || id.nil? || id.is_a?(Integer) || id.is_a?(Float)
+    end
+
+    def valid_params(params)
+      return true if params.nil?
+
+      params.is_a?(Array) || params.is_a?(Hash)
+    end
+
+    def valid_method_name(method)
+      method.is_a?(String) && !method.start_with?('rpc.')
+    end
+
+    def raise_error(code)
+      raise RPCError.new(code), 'Error on interpreter'
+    end
+  end
+end

data/lib/metarpc/rpc_error.rb

@@ -0,0 +1,41 @@
+module MetaRPC
+  # RPC possible errors
+  class RPCError < StandardError
+    attr_reader :code
+
+    CODE_TO_MESSAGE = {
+      parse_error: {
+        code: -32_700,
+        message: 'Invalid JSON was received by the server.'
+      },
+      invalid_request: {
+        code: -32_600,
+        message: 'The JSON sent is not a valid Request object.'
+      },
+      method_not_found: {
+        code: -32_601,
+        message: 'The method does not exist / is not available.'
+      },
+      invalid_params: {
+        code: -32_602,
+        message: 'Invalid method parameter(s).'
+      },
+      internal_error: {
+        code: -32_603,
+        message: 'Internal JSON-RPC error.'
+      },
+      server_error: {
+        code: -32_000,
+        message: 'Server error occurred.'
+      }
+    }.freeze
+
+    def initialize(code)
+      @code = code
+    end
+
+    def to_h
+      CODE_TO_MESSAGE[code]
+    end
+  end
+end

data/lib/metarpc.rb

@@ -0,0 +1,6 @@
+require 'json'
+require 'active_support/all'
+
+require_relative 'metarpc/rpc_error'
+require_relative 'metarpc/callable'
+require_relative 'metarpc/interpreter'

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: metarpc
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Thesaurio Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '5'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.63.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.63.1
+description: Build a RPC API with ease
+email: hello@thesaur.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/metarpc.rb
+- lib/metarpc/callable.rb
+- lib/metarpc/interpreter.rb
+- lib/metarpc/rpc_error.rb
+homepage: http://rubygems.org/gems/hola
+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: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: A classy way of handling RPC calls in Ruby
+test_files: []