hive-ruby 1.0.0.pre.1

data/lib/hive/api.rb

@@ -0,0 +1,223 @@
+module Hive
+  # This ruby API works with
+  # {https://github.com/openhive-network/hive/releases hived-0.23.00} and other AppBase
+  # compatible upstreams.  To access different API namespaces, use the
+  # following:
+  #
+  #     api = Hive::Api.new
+  #     api.get_dynamic_global_properties
+  #
+  # The above example will make an instance that can access the
+  # {https://developers.hive.io/apidefinitions/condenser-api.html condenser_api}
+  # namespace.  Alternatively, you may also create a direct instances with its
+  # full name, if you prefer:
+  #
+  #     api = Hive::CondenserApi.new
+  #     api.get_dynamic_global_properties
+  #
+  # If you know the name of another API that is supported by the remote node,
+  # you can create an instance to that instead, for example:
+  #
+  #     api = Hive::MarketHistoryApi.new
+  #     api.get_volume
+  #
+  # All known API by namespace:
+  #
+  # * {AccountByKeyApi}
+  # * {AccountHistoryApi}
+  # * {BlockApi}
+  # * {DatabaseApi}
+  # * {FollowApi}
+  # * {Jsonrpc}
+  # * {MarketHistoryApi}
+  # * {NetworkBroadcastApi}
+  # * {TagsApi}
+  # * {WitnessApi}
+  #
+  # Also see: {https://developers.hive.io/apidefinitions/ Complete API Definitions}
+  class Api
+    attr_accessor :chain, :methods, :rpc_client
+    
+    # Use this for debugging naive thread handler.
+    # DEFAULT_RPC_CLIENT_CLASS = RPC::HttpClient
+    DEFAULT_RPC_CLIENT_CLASS = RPC::ThreadSafeHttpClient
+    
+    def self.api_name=(api_name)
+      @api_name = api_name.to_s.
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr('-', '_').downcase.to_sym
+    end
+    
+    def self.api_name
+      @api_name
+    end
+    
+    def self.api_class_name
+      @api_name.to_s.split('_').map(&:capitalize).join
+    end
+    
+    def self.jsonrpc=(jsonrpc, url = nil)
+      @jsonrpc ||= {}
+      @jsonrpc[url || jsonrpc.rpc_client.uri.to_s] = jsonrpc
+    end
+    
+    def self.jsonrpc(url = nil)
+      if @jsonrpc.size < 2 && url.nil?
+        @jsonrpc.values.first
+      else
+        @jsonrpc[url]
+      end
+    end
+    
+    # Override this if you want to just use your own client.  Otherwise, inject
+    # the default using:
+    #
+    #     Hive::Api.register default_rpc_client_class: MyClient
+    def self.default_rpc_client_class
+      if !!@injected_dependencies && !!@injected_dependencies[:default_rpc_client_class]
+        @injected_dependencies[:default_rpc_client_class]
+      else
+        DEFAULT_RPC_CLIENT_CLASS
+      end
+    end
+    
+    # Used for dependency injection.  Currently, the only key supported is:
+    # 
+    # `default_rpc_client_class`
+    def self.register(register)
+      @injected_dependencies ||= {}
+      @injected_dependencies = @injected_dependencies.merge register
+    end
+    
+    def initialize(options = {})
+      @chain = options[:chain] || :hive
+      @error_pipe = options[:error_pipe] || STDERR
+      @api_name = self.class.api_name ||= :condenser_api
+      
+      @rpc_client = if !!options[:rpc_client]
+        options[:rpc_client]
+      else
+        rpc_client_class = self.class.default_rpc_client_class
+        rpc_client_class.new(options.merge(api_name: @api_name))
+      end
+      
+      if @api_name == :jsonrpc
+        Api::jsonrpc = self
+      else
+        # Note, we have to wait until initialize to check this because we don't
+        # have access to instance options until now.
+        
+        Api::jsonrpc = Jsonrpc.new(options)
+        
+        @methods = begin
+          Api::jsonrpc(rpc_client.uri.to_s).get_api_methods
+        rescue => e
+          Fallback::API_METHODS
+        end
+        
+        if Jsonrpc::UNLISTED_APIS.include? @api_name
+          @methods ||= {}
+          @methods[@api_name] ||= Fallback::API_METHODS[@api_name]
+        end
+        
+        unless !!@methods[@api_name]
+          raise UnknownApiError, "#{@api_name} (known APIs: #{@methods.keys.join(' ')})"
+        end
+        
+        @methods = @methods[@api_name]
+      end
+        
+      @try_count = 0
+    end
+    
+    def inspect
+      properties = %w(chain methods).map do |prop|
+        if !!(v = instance_variable_get("@#{prop}"))
+          case v
+          when Array then "@#{prop}=<#{v.size} #{v.size == 1 ? 'element' : 'elements'}>" 
+          else; "@#{prop}=#{v}" 
+          end
+        end
+      end.compact.join(', ')
+      
+      "#<#{self.class.api_class_name} [#{properties}]>"
+    end
+  private
+    # @private
+    def args_keys_to_s(rpc_method_name)
+      args = signature(rpc_method_name).args
+      args_keys = JSON[args.to_json]
+    end
+    
+    # @private
+    def signature(rpc_method_name)
+      url = rpc_client.uri.to_s
+      
+      @@signatures ||= {}
+      @@signatures[url] ||= {}
+      
+      @@signatures[url][rpc_method_name] ||= begin
+        Api::jsonrpc(url).get_signature(method: rpc_method_name).result
+      rescue => e
+        Hashie::Mash.new({args: Fallback::API_METHOD_SIGNATURES[@api_name][rpc_method_name.split('.').last.to_sym]})
+      end
+    end
+    
+    # @private
+    def respond_to_missing?(m, include_private = false)
+      methods.nil? ? false : methods.include?(m.to_sym)
+    end
+    
+    # @private
+    def method_missing(m, *args, &block)
+      super unless respond_to_missing?(m)
+      
+      rpc_method_name = "#{@api_name}.#{m}"
+      rpc_args = case @api_name
+      when :condenser_api then args
+      when :jsonrpc then args.first
+      else
+        expected_args = signature(rpc_method_name).args || []
+        expected_args_key_string = if expected_args.size > 0
+          " (#{args_keys_to_s(rpc_method_name)})"
+        end
+        expected_args_size = expected_args.size
+        
+        begin
+          args = args.first.to_h
+          args_size = args.size
+          
+          # Some argument are optional, but if the arguments passed are greater
+          # than the expected arguments size, we can warn.
+          if args_size > expected_args_size
+            @error_pipe.puts "Warning #{rpc_method_name} expects arguments: #{expected_args_size}, got: #{args_size}"
+          end
+        rescue NoMethodError => e
+          error = Hive::ArgumentError.new("#{rpc_method_name} expects arguments: #{expected_args_size}", e)
+          raise error
+        rescue => e
+          raise UnknownError.new("#{rpc_method_name} unknown error.", e)
+        end
+        
+        args
+      end
+      
+      response = rpc_client.rpc_execute(@api_name, m, rpc_args)
+      
+      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)
+            yield r.result, r.error, r.id
+          end
+        else; yield response
+        end
+      else
+        return response
+      end
+    end
+  end
+end

data/lib/hive/base_error.rb

@@ -0,0 +1,218 @@
+module Hive
+  class BaseError < StandardError
+    def initialize(error = nil, cause = nil)
+      @error = error
+      @cause = cause
+    end
+    
+    def to_s
+      detail = {}
+      detail[:error] = @error if !!@error
+      detail[:cause] = @cause if !!@cause
+      
+      JSON[detail] rescue detail.to_s
+    end
+    
+    def self.build_error(error, context)
+      if error.message == 'Unable to acquire database lock'
+        raise Hive::RemoteDatabaseLockError, error.message, build_backtrace(error)
+      end
+      
+      if error.message.include? 'Internal Error'
+        raise Hive::RemoteNodeError, error.message, build_backtrace(error)
+      end
+      
+      if error.message.include? 'Server error'
+        raise Hive::RemoteNodeError, error.message, build_backtrace(error)
+      end
+      
+      if error.message.include? 'plugin not enabled'
+        raise Hive::PluginNotEnabledError, error.message, build_backtrace(error)
+      end
+      
+      if error.message.include? 'argument'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Invalid params'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.start_with? 'Bad Cast:'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'prefix_len'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Parse Error'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'unknown key'
+        raise Hive::ArgumentError, "#{context}: #{error.message} (or content has been deleted)", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Comment is not in account\'s comments'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Could not find comment'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'unable to convert ISO-formatted string to fc::time_point_sec'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Input data have to treated as object.'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'base.amount > share_type(0)'
+        raise Hive::ArgumentError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'blk->transactions.size() > itr->trx_in_block'
+        raise Hive::VirtualOperationsNotAllowedError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'A transaction must have at least one operation'
+        raise Hive::EmptyTransactionError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'transaction expiration exception'
+        raise Hive::TransactionExpiredError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Duplicate transaction check failed'
+        raise Hive::DuplicateTransactionError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'signature is not canonical'
+        raise Hive::NonCanonicalSignatureError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'attempting to push a block that is too old'
+        raise Hive::BlockTooOldError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'irrelevant signature'
+        raise Hive::IrrelevantSignatureError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'missing required posting authority'
+        raise Hive::MissingPostingAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'missing required active authority'
+        raise Hive::MissingActiveAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'missing required owner authority'
+        raise Hive::MissingOwnerAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'missing required other authority'
+        raise Hive::MissingOtherAuthorityError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Upstream response error'
+        raise Hive::UpstreamResponseError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Bad or missing upstream response'
+        raise Hive::BadOrMissingUpstreamResponseError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'operator has disabled operation indexing by transaction_id'
+        raise Hive::TransactionIndexDisabledError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'is_valid_account_name'
+        raise Hive::InvalidAccountError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include?('Method') && error.message.include?(' does not exist.')
+        raise Hive::UnknownMethodError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Invalid operation name'
+        raise Hive::UnknownOperationError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message =~ /Invalid object name: .+_operation/
+        raise Hive::UnknownOperationError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Author not found'
+        raise Hive::AuthorNotFoundError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? ' != fc::time_point_sec::maximum()'
+        raise Hive::ReachedMaximumTimeError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Cannot transfer a negative amount (aka: stealing)'
+        raise Hive::TheftError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'Must transfer a nonzero amount'
+        raise Hive::NonZeroRequiredError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      if error.message.include? 'is_asset_type'
+        raise Hive::UnexpectedAssetError, "#{context}: #{error.message}", build_backtrace(error)
+      end
+      
+      puts JSON.pretty_generate(error) if ENV['DEBUG']
+      raise UnknownError, "#{context}: #{error.message}", build_backtrace(error)
+    end
+  private
+    def self.build_backtrace(error)
+      backtrace = Thread.current.backtrace.reject{ |line| line =~ /base_error/ }
+      JSON.pretty_generate(error) + "\n" + backtrace.join("\n")
+    end
+  end
+  
+  class DeserializationError < BaseError; end
+  class SerializationMismatchError < BaseError; end
+  class UnsupportedChainError < BaseError; end
+  class ArgumentError < BaseError; end
+  class TypeError < BaseError; end
+  class EmptyTransactionError < ArgumentError; end
+  class InvalidAccountError < ArgumentError; end
+  class AuthorNotFoundError < ArgumentError; end
+  class ReachedMaximumTimeError < ArgumentError; end
+  class VirtualOperationsNotAllowedError < ArgumentError; end
+  class TheftError < ArgumentError; end
+  class NonZeroRequiredError < ArgumentError; end
+  class UnexpectedAssetError < ArgumentError; end
+  class TransactionExpiredError < BaseError; end
+  class DuplicateTransactionError < TransactionExpiredError; end
+  class NonCanonicalSignatureError < TransactionExpiredError; end
+  class BlockTooOldError < BaseError; end
+  class IrrelevantSignatureError < BaseError; end
+  class MissingAuthorityError < BaseError; end
+  class MissingPostingAuthorityError < MissingAuthorityError; end
+  class MissingActiveAuthorityError < MissingAuthorityError; end
+  class MissingOwnerAuthorityError < MissingAuthorityError; end
+  class MissingOtherAuthorityError < MissingAuthorityError; end
+  class IncorrectRequestIdError < BaseError; end
+  class IncorrectResponseIdError < BaseError; end
+  class RemoteNodeError < BaseError; end
+  class UpstreamResponseError < RemoteNodeError; end
+  class RemoteDatabaseLockError < UpstreamResponseError; end
+  class PluginNotEnabledError < UpstreamResponseError; end
+  class BadOrMissingUpstreamResponseError < UpstreamResponseError; end
+  class TransactionIndexDisabledError < BaseError; end
+  class NotAppBaseError < BaseError; end
+  class UnknownApiError < BaseError; end
+  class UnknownMethodError < BaseError; end
+  class UnknownOperationError < BaseError; end
+  class JsonRpcBatchMaximumSizeExceededError < BaseError; end
+  class TooManyTimeoutsError < BaseError; end
+  class TooManyRetriesError < BaseError; end
+  class UnknownError < BaseError; end
+end

data/lib/hive/block_api.rb

@@ -0,0 +1,78 @@
+module Hive
+  # {BlockApi} is used to query values related to the block plugin.  It can also
+  # be used to access a range of multiple blocks by using
+  # {http://www.jsonrpc.org/specification#batch JSON-RPC 2.0 batch} requests.
+  #
+  # Also see: {https://developers.hive.io/apidefinitions/block-api.html Block API Definitions}
+  class BlockApi < Api
+    MAX_RANGE_SIZE = 50
+    
+    def initialize(options = {})
+      self.class.api_name = :block_api
+      super
+    end
+    
+    # Uses a batched requst on a range of block headers.
+    #
+    # @param options [Hash] The attributes to get a block range with.
+    # @option options [Range] :block_range starting on one block number and ending on an higher block number.
+    def get_block_headers(options = {block_range: (0..0)}, &block)
+      get_block_objects(options.merge(object: :block_header), block)
+    end
+    
+    # Uses a batched requst on a range of blocks.
+    #
+    # @param options [Hash] The attributes to get a block range with.
+    # @option options [Range] :block_range starting on one block number and ending on an higher block number.
+    def get_blocks(options = {block_range: (0..0)}, &block)
+      get_block_objects(options.merge(object: :block), block)
+    end
+  private
+    def get_block_objects(options = {block_range: (0..0)}, block = nil)
+      object = options[:object]
+      object_method = "get_#{object}".to_sym
+      block_range = options[:block_range] || (0..0)
+      
+      if (start = block_range.first) < 1
+        raise Hive::ArgumentError, "Invalid starting block: #{start}"
+      end
+      
+      chunks = if block_range.size > MAX_RANGE_SIZE
+        block_range.each_slice(MAX_RANGE_SIZE)
+      else
+        [block_range]
+      end
+      
+      for sub_range in chunks do
+        request_object = []
+        
+        for i in sub_range do
+          @rpc_client.put(self.class.api_name, object_method, block_num: i, request_object: request_object)
+        end
+        
+        if !!block
+          index = 0
+          @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
+            block_num = sub_range.to_a[index]
+            index = index + 1
+            
+            case object
+            when :block_header
+              block.call(result.nil? ? nil : result[:header], block_num)
+            else
+              block.call(result.nil? ? nil : result[object], block_num)
+            end
+          end
+        else
+          blocks = []
+          
+          @rpc_client.rpc_batch_execute(request_object: request_object) do |result, error, id|
+            blocks << result
+          end
+        end
+      end
+      
+      blocks
+    end
+  end
+end