dpay-ruby 0.1.1

data/lib/dpay/chain_config.rb

@@ -0,0 +1,21 @@
+module DPay
+  module ChainConfig
+    EXPIRE_IN_SECS = 600
+    EXPIRE_IN_SECS_PROPOSAL = 24 * 60 * 60
+
+    NETWORKS_DPAY_CHAIN_ID = '38f14b346eb697ba04ae0f5adcfaa0a437ed3711197704aa256a14cb9b4a8f26'
+    NETWORKS_DPAY_ADDRESS_PREFIX = 'DWB'
+    NETWORKS_DPAY_CORE_ASSET = ["0", 3, "@@000000021"] # BEX
+    NETWORKS_DPAY_DEBT_ASSET = ["0", 3, "@@000000013"] # BBD
+    NETWORKS_DPAY_VEST_ASSET = ["0", 6, "@@000000037"] # VESTS
+    NETWORKS_DPAY_DEFAULT_NODE = 'https://api.dpays.io' # √
+    NETWORKS_TEST_CHAIN_ID = '46d82ab7d8db682eb1959aed0ada039a6d49afa1602491f93dde9cac3e8e6c32'
+    NETWORKS_TEST_ADDRESS_PREFIX = 'DWT'
+    NETWORKS_TEST_CORE_ASSET = ["0", 3, "@@000000021"] # TESTS
+    NETWORKS_TEST_DEBT_ASSET = ["0", 3, "@@000000013"] # TBD
+    NETWORKS_TEST_VEST_ASSET = ["0", 6, "@@000000037"] # VESTS
+    NETWORKS_TEST_DEFAULT_NODE = 'https://testnet.dpays.io'
+
+    NETWORK_CHAIN_IDS = [NETWORKS_DPAY_CHAIN_ID, NETWORKS_TEST_CHAIN_ID]
+  end
+end

data/lib/dpay/formatter.rb

@@ -0,0 +1,14 @@
+module DPay
+  class Formatter
+    def self.reputation(raw)
+      raw = raw.to_i
+      neg = raw < 0
+      level = Math.log10(raw.abs)
+      level = [level - 9, 0].max
+      level = (neg ? -1 : 1) * level
+      level = (level * 9) + 25
+      
+      level.round(1)
+    end
+  end
+end

data/lib/dpay/jsonrpc.rb

@@ -0,0 +1,108 @@
+module DPay
+  # {Jsonrpc} allows you to inspect the available methods offered by a node.
+  # If a node runs a plugin you want, then all of the API methods it can exposes
+  # will automatically be available.  This API is used internally to determine
+  # which APIs and methods are available on the node you specify.
+  #
+  # In theory, if a new plugin is created and enabled by the node, it will be
+  # available by this library without needing an update to its code.
+  class Jsonrpc < Api
+    API_METHODS = %i(get_signature get_methods)
+    
+    def self.api_methods
+      @api_methods ||= {}
+    end
+    
+    # Might help diagnose a cluster that has asymmetric plugin definitions.
+    def self.reset_api_methods
+      @api_methods = nil
+    end
+    
+    def initialize(options = {})
+      @api_name = self.class.api_name = :jsonrpc
+      @methods = API_METHODS
+      super
+    end
+    
+    def get_api_methods(&block)
+      api_methods = self.class.api_methods[@rpc_client.uri.to_s]
+      
+      if api_methods.nil?
+        get_methods do |result, error, rpc_id|
+          raise NotAppBaseError, "#{@rpc_client.uri} does not appear to run AppBase" unless defined? result.map
+          
+          methods = result.map do |method|
+            method.split('.').map(&:to_sym)
+          end
+          
+          api_methods = Hashie::Mash.new
+          
+          methods.each do |api, method|
+            api_methods[api] ||= []
+            api_methods[api] << method
+          end
+          
+          self.class.api_methods[@rpc_client.uri.to_s] = api_methods
+        end
+      end
+      
+      if !!block
+        api_methods.each do |api, methods|
+          yield api, methods
+        end
+      else
+        return api_methods
+      end
+    end
+    
+    def get_all_signatures(&block)
+      request_object = []
+      method_names = []
+      method_map = {}
+      signatures = {}
+      offset = 0
+      
+      get_api_methods do |api, methods|
+        request_object += methods.map do |method|
+          method_name = "#{api}.#{method}"
+          method_names << method_name
+          current_rpc_id = @rpc_client.rpc_id
+          offset += 1
+          method_map[current_rpc_id] = [api, method]
+          
+          {
+            jsonrpc: '2.0',
+            id: current_rpc_id,
+            method: 'jsonrpc.get_signature',
+            params: {method: method_name}
+          }
+        end
+      end
+      
+      chunks = if request_object.size > DPay::RPC::HttpClient::JSON_RPC_BATCH_SIZE_MAXIMUM
+        request_object.each_slice(DPay::RPC::HttpClient::JSON_RPC_BATCH_SIZE_MAXIMUM)
+      else
+        request_object
+      end
+      
+      for request_object in chunks do
+        @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
+          api, method = method_map[id]
+          api = api.to_sym
+          method = method.to_sym
+          
+          signatures[api] ||= {}
+          signatures[api][method] = result
+        end
+        
+        if !!block
+          signatures.each do |api, methods|
+            yield api, methods
+          end
+        end
+      end
+      
+      return signatures unless !!block
+    end
+  end
+end

data/lib/dpay/mixins/retriable.rb

@@ -0,0 +1,58 @@
+module DPay
+  module Retriable
+    # @private
+    MAX_RETRY_COUNT = 30
+    
+    MAX_RETRY_ELAPSE = 60
+    
+    # @private
+    MAX_BACKOFF = MAX_RETRY_ELAPSE / 4
+    
+    RETRYABLE_EXCEPTIONS = [
+      NonCanonicalSignatureError, IncorrectRequestIdError,
+      IncorrectResponseIdError, RemoteDatabaseLockError
+    ]
+    
+    def can_retry?(e = nil)
+      @retry_count ||= 0
+      
+      return false if @retry_count >= MAX_RETRY_COUNT
+      
+      @retry_count = if retry_reset?
+        @first_retry_at = nil
+      else
+        @retry_count + 1
+      end
+      
+      can_retry = case e
+      when *RETRYABLE_EXCEPTIONS then true
+      else; false
+      end
+      
+      backoff if can_retry
+      
+      can_retry
+    end
+  private
+    # @private
+    def first_retry_at
+      @first_retry_at ||= Time.now.utc
+    end
+    
+    # @private
+    def retry_reset?
+      Time.now.utc - first_retry_at > MAX_RETRY_ELAPSE
+    end
+    
+    # Expontential backoff.
+    #
+    # @private
+    def backoff
+      @backoff ||= 0.1
+      @backoff *= 2
+      @backoff = 0.1 if @backoff > MAX_BACKOFF
+      
+      sleep @backoff
+    end
+  end
+end

data/lib/dpay/rpc/base_client.rb

@@ -0,0 +1,166 @@
+module DPay
+  module RPC
+    class BaseClient
+      include ChainConfig
+
+      attr_accessor :url, :chain, :error_pipe
+
+      # @private
+      MAX_TIMEOUT_RETRY_COUNT = 100
+
+      # @private
+      MAX_TIMEOUT_BACKOFF = 30
+
+      # @private
+      TIMEOUT_ERRORS = [Net::ReadTimeout, Errno::EBADF, IOError]
+
+      def initialize(options = {})
+        @chain = options[:chain] || :dpay
+        @error_pipe = options[:error_pipe] || STDERR
+        @api_name = options[:api_name]
+        @url = case @chain
+        when :dpay then options[:url] || NETWORKS_DPAY_DEFAULT_NODE
+        when :test then options[:url] || NETWORKS_TEST_DEFAULT_NODE
+        else; raise UnsupportedChainError, "Unsupported chain: #{@chain}"
+        end
+      end
+
+      def uri
+        @uri ||= URI.parse(url)
+      end
+
+      # Adds a request object to the stack.  Usually, this method is called
+      # internally by {BaseClient#rpc_execute}.  If you want to create a batched
+      # request, use this method to add to the batch then execute {BaseClient#rpc_batch_execute}.
+      def put(api_name = @api_name, api_method = nil, options = {})
+        current_rpc_id = rpc_id
+        rpc_method_name = "#{api_name}.#{api_method}"
+        options ||= {}
+        request_object = defined?(options.delete) ? options.delete(:request_object) : []
+        request_object ||= []
+
+        request_object << {
+          jsonrpc: '2.0',
+          id: current_rpc_id,
+          method: rpc_method_name,
+          params: options
+        }
+
+        request_object
+      end
+
+      # @abstract Subclass is expected to implement #rpc_execute.
+      # @!method rpc_execute
+
+      # @abstract Subclass is expected to implement #rpc_batch_execute.
+      # @!method rpc_batch_execute
+
+      # To be called by {BaseClient#rpc_execute} and {BaseClient#rpc_batch_execute}
+      # when a response has been consructed.
+      def yield_response(response, &block)
+        if !!block
+          case response
+          when Hashie::Mash then yield response.result, response.error, response.id
+          when Hashie::Array
+            response.each do |r|
+              r = Hashie::Mash.new(r)
+              block.call r.result, r.error, r.id
+            end
+          else; block.call response
+          end
+        end
+
+        response
+      end
+
+      # Checks json-rpc request/response for corrilated id.  If they do not
+      # match, {IncorrectResponseIdError} is thrown.  This is usually caused by
+      # the client, involving thread safety.  It can also be caused by the node
+      # responding without an id.
+      #
+      # To avoid {IncorrectResponseIdError}, make sure you implement your client
+      # correctly.
+      #
+      # Setting DEBUG=true in the envrionment will cause this method to output
+      # both the request and response json.
+      #
+      # @param options [Hash] options
+      # @option options [Boolean] :debug Enable or disable debug output.
+      # @option options [Hash] :request to compare id
+      # @option options [Hash] :response to compare id
+      # @option options [String] :api_method
+      # @see {ThreadSafeHttpClient}
+      def evaluate_id(options = {})
+        debug = options[:debug] || ENV['DEBUG'] == 'true'
+        request = options[:request]
+        response = options[:response]
+        api_method = options[:api_method]
+        req_id = request[:id].to_i
+        res_id = !!response['id'] ? response['id'].to_i : nil
+        method = [@api_name, api_method].join('.')
+
+        if debug
+          req = JSON.pretty_generate(request)
+          res = JSON.parse(response) rescue response
+          res = JSON.pretty_generate(response) rescue response
+
+          error_pipe.puts '=' * 80
+          error_pipe.puts "Request:"
+          error_pipe.puts req
+          error_pipe.puts '=' * 80
+          error_pipe.puts "Response:"
+          error_pipe.puts res
+          error_pipe.puts '=' * 80
+          error_pipe.puts Thread.current.backtrace.join("\n")
+        end
+
+        error = response['error'].to_json if !!response['error']
+
+        if req_id != res_id
+          raise IncorrectResponseIdError, "#{method}: The json-rpc id did not match.  Request was: #{req_id}, got: #{res_id.inspect}", BaseError.send(:build_backtrace, error)
+        end
+      end
+
+      # Current json-rpc id used for a request.  This version auto-increments
+      # for each call.  Subclasses can use their own strategy.
+      def rpc_id
+        @rpc_id ||= 0
+        @rpc_id += 1
+      end
+    private
+      # @private
+      def reset_timeout
+        @timeout_retry_count = 0
+        @back_off = 0.1
+      end
+
+      # @private
+      def retry_timeout(context, cause = nil)
+        @timeout_retry_count += 1
+
+        if @timeout_retry_count > MAX_TIMEOUT_RETRY_COUNT
+          raise TooManyTimeoutsError.new("Too many timeouts for: #{context}", cause)
+        elsif @timeout_retry_count % 10 == 0
+          msg = "#{@timeout_retry_count} retry attempts for: #{context}"
+          msg += "; cause: #{cause}" if !!cause
+          error_pipe.puts msg
+        end
+
+        backoff_timeout
+
+        context
+      end
+
+      # Expontential backoff.
+      #
+      # @private
+      def backoff_timeout
+        @backoff ||= 0.1
+        @backoff *= 2
+        @backoff = 0.1 if @backoff > MAX_TIMEOUT_BACKOFF
+
+        sleep @backoff
+      end
+    end
+  end
+end

data/lib/dpay/rpc/http_client.rb

@@ -0,0 +1,127 @@
+module DPay
+  module RPC
+    # {HttpClient} is intended for single-threaded applications.  For
+    # multi-threaded apps, use {ThreadSafeHttpClient}.
+    class HttpClient < BaseClient
+      # Timeouts are lower level errors, related in that retrying them is
+      # trivial, unlike, for example TransactionExpiredError, that *requires*
+      # the client to do something before retrying.
+      # 
+      # These situations are hopefully momentary interruptions or rate limiting
+      # but they might indicate a bigger problem with the node, so they are not
+      # retried forever, only up to MAX_TIMEOUT_RETRY_COUNT and then we give up.
+      # 
+      # *Note:* {JSON::ParserError} is included in this list because under
+      # certain timeout conditions, a web server may respond with a generic
+      # http status code of 200 and HTML page.
+      # 
+      # @private
+      TIMEOUT_ERRORS = [Net::OpenTimeout, JSON::ParserError, Net::ReadTimeout,
+        Errno::EBADF, IOError, Errno::ENETDOWN]
+      
+      # @private
+      POST_HEADERS = {
+        'Content-Type' => 'application/json; charset=utf-8',
+        'User-Agent' => DPay::AGENT_ID
+      }
+      
+      JSON_RPC_BATCH_SIZE_MAXIMUM = 50
+      
+      def http
+        @http ||= Net::HTTP.new(uri.host, uri.port).tap do |http|
+          http.use_ssl = true if uri.to_s =~ /^https/i
+          http.keep_alive_timeout = 150 # seconds
+          
+          # WARNING This method opens a serious security hole. Never use this
+          # method in production code.
+          # http.set_debug_output(STDOUT) if !!ENV['DEBUG']
+        end
+      end
+      
+      def http_post
+        @http_post ||= Net::HTTP::Post.new(uri.request_uri, POST_HEADERS)
+      end
+      
+      def http_request(request)
+        http.request(request)
+      end
+      
+      # This is the main method used by API instances to actually fetch data
+      # from the remote node.  It abstracts the api namespace, method name, and
+      # parameters so that the API instance can be decoupled from the protocol.
+      # 
+      # @param api_name [String] API namespace of the method being called.
+      # @param api_method [String] API method name being called.
+      # @param options [Hash] options
+      # @option options [Object] :request_object Hash or Array to become json in request body.
+      def rpc_execute(api_name = @api_name, api_method = nil, options = {}, &block)
+        reset_timeout
+        
+        catch :tota_cera_pila do; begin
+          request = http_post
+          
+          request_object = if !!api_name && !!api_method
+            put(api_name, api_method, options)
+          elsif !!options && defined?(options.delete)
+            options.delete(:request_object)
+          end
+          
+          if request_object.size > JSON_RPC_BATCH_SIZE_MAXIMUM
+            raise JsonRpcBatchMaximumSizeExceededError, "Maximum json-rpc-batch is #{JSON_RPC_BATCH_SIZE_MAXIMUM} elements."
+          end
+          
+          request.body = if request_object.class == Hash
+            request_object
+          elsif request_object.size == 1
+            request_object.first
+          else
+            request_object
+          end.to_json
+          
+          response = catch :http_request do; begin; http_request(request)
+          rescue *TIMEOUT_ERRORS => e
+            throw retry_timeout(:http_request, e)
+          end; end
+          
+          if response.nil?
+            throw retry_timeout(:tota_cera_pila, 'response was nil')
+          end
+          
+          case response.code
+          when '200'
+            response = catch :parse_json do; begin; JSON[response.body]
+            rescue *TIMEOUT_ERRORS => e
+              throw retry_timeout(:parse_json, e)
+            end; end
+            
+            response = case response
+            when Hash
+              Hashie::Mash.new(response).tap do |r|
+                evaluate_id(request: request_object.first, response: r, api_method: api_method)
+              end
+            when Array
+              Hashie::Array.new(response).tap do |r|
+                request_object.each_with_index do |req, index|
+                  evaluate_id(request: req, response: r[index], api_method: api_method)
+                end
+              end
+            else; response
+            end
+            
+            yield_response response, &block
+          when '504' # Gateway Timeout
+            throw retry_timeout(:tota_cera_pila, response.body)
+          when '502' # Bad Gateway
+            throw retry_timeout(:tota_cera_pila, response.body)
+          else
+            raise UnknownError, "#{api_name}.#{api_method}: #{response.body}"
+          end
+        end; end
+      end
+      
+      def rpc_batch_execute(options = {}, &block)
+        yield_response rpc_execute(nil, nil, options), &block
+      end
+    end
+  end
+end