Class: Radiator::Api

Inherits:

Object

• Object
• Radiator::Api

Includes:

Utils

Defined in:

lib/radiator/api.rb

Overview

Radiator::Api allows you to call remote methods to interact with the STEEM blockchain. The ‘Api` class is a shortened name for `Radiator::CondenserApi`.

Examples:

api = Radiator::Api.new
response = api.get_dynamic_global_properties
virtual_supply = response.result.virtual_supply

… or …

api = Radiator::Api.new
virtual_supply = api.get_dynamic_global_properties do |prop|
  prop.virtual_supply
end

If you need access to the ‘error` property, they can be accessed as follows:

api = Radiator::Api.new
response = api.get_dynamic_global_properties
if response.result.nil?
  puts response.error
  exit
end

virtual_supply = response.result.virtual_supply

… or …

api = Radiator::Api.new
virtual_supply = api.get_dynamic_global_properties do |prop, error|
  if prop.nil?
    puts error
    exis
  end

  prop.virtual_supply
end

List of remote methods:

set_subscribe_callback
set_pending_transaction_callback
set_block_applied_callback
cancel_all_subscriptions
get_trending_tags
get_tags_used_by_author
get_post_discussions_by_payout
get_comment_discussions_by_payout
get_discussions_by_trending
get_discussions_by_trending30
get_discussions_by_created
get_discussions_by_active
get_discussions_by_cashout
get_discussions_by_payout
get_discussions_by_votes
get_discussions_by_children
get_discussions_by_hot
get_discussions_by_feed
get_discussions_by_blog
get_discussions_by_comments
get_discussions_by_promoted
get_block_header
get_block
get_ops_in_block
get_state
get_trending_categories
get_best_categories
get_active_categories
get_recent_categories
get_config
get_dynamic_global_properties
get_chain_properties
get_feed_history
get_current_median_history_price
get_witness_schedule
get_hardfork_version
get_next_scheduled_hardfork
get_accounts
get_account_references
lookup_account_names
lookup_accounts
get_account_count
get_conversion_requests
get_account_history
get_owner_history
get_recovery_request
get_escrow
get_withdraw_routes
get_account_bandwidth
get_savings_withdraw_from
get_savings_withdraw_to
get_order_book
get_open_orders
get_liquidity_queue
get_transaction_hex
get_transaction
get_required_signatures
get_potential_signatures
verify_authority
verify_account_authority
get_active_votes
get_account_votes
get_content
get_content_replies
get_discussions_by_author_before_date
get_replies_by_last_update
get_witnesses
get_witness_by_account
get_witnesses_by_vote
lookup_witness_accounts
get_witness_count
get_active_witnesses
get_miner_queue
get_reward_fund

These methods and their characteristics are copied directly from methods marked as ‘database_api` in `steem-js`:

raw.githubusercontent.com/steemit/steem-js/master/src/api/methods.js

See Also:

• https://steemit.github.io/steemit-docs/#accounts

Direct Known Subclasses

AccountByKeyApi, AccountHistoryApi, BlockApi, ChainStatsApi, CondenserApi, DatabaseApi, FollowApi, MarketHistoryApi, NetworkBroadcastApi, Stream, TagApi

Constant Summary

DEFAULT_STEEM_URL =

'https://api.steemit.com'

DEFAULT_STEEM_FAILOVER_URLS =

[
  DEFAULT_STEEM_URL,
  'https://appbasetest.timcliff.com',
  'https://api.steem.house',
  'https://steemd.minnowsupportproject.org',
  'https://steemd.privex.io',
  'https://rpc.steemviz.com',
  'https://anyx.io',
  'httpd://rpc.usesteem.com'
]

POST_HEADERS =

{
  'Content-Type' => 'application/json',
  'User-Agent' => Radiator::AGENT_ID
}

HEALTH_URI =

'/health'

Class Method Summary

• .default_failover_urls(chain) ⇒ Object
• .default_url(chain) ⇒ Object

Instance Method Summary

• #api_name ⇒ Object
• #get_blocks(block_number, &block) ⇒ ::Array

  Get a specific block or range of blocks.

• #initialize(options = {}) ⇒ Api constructor

  Cretes a new instance of Radiator::Api.

• #inspect ⇒ Object
• #method_missing(m, *args, &block) ⇒ Object
• #method_names ⇒ Object
• #respond_to_missing?(m, include_private = false) ⇒ Boolean
• #shutdown ⇒ Object

  Stops the persistant http connections.

• #stopped? ⇒ Boolean
• #use_condenser_namespace? ⇒ Boolean

Methods included from Utils

#debug, #error, #extract_signatures, #hexlify, #pakArr, #pakC, #pakHash, #pakI, #pakL!, #pakS, #pakStr, #pakc, #paks, #send_log, #unhexlify, #varint, #warning

Constructor Details

#initialize(options = {}) ⇒ Api

Cretes a new instance of Radiator::Api.

Examples:

api = Radiator::Api.new(url: 'https://api.example.com')

Parameters:

• options (::Hash) (defaults to: {}) —

  The attributes to initialize the Radiator::Api with.

Options Hash (options):

• :url (String) —

  URL that points at a full node, like ‘api.steemit.com`. Default from DEFAULT_URL.

• :failover_urls (::Array<String>) —

  An array that contains one or more full nodes to fall back on. Default from DEFAULT_FAILOVER_URLS.

• :logger (Logger) —

  An instance of ‘Logger` to send debug messages to.

• :recover_transactions_on_error (Boolean) —

  Have Radiator try to recover transactions that are accepted but could not be confirmed due to an error like network timeout. Default: ‘true`

• :max_requests (Integer) —

  Maximum number of requests on a connection before it is considered expired and automatically closed.

• :pool_size (Integer) —

  Maximum number of connections allowed.

• :reuse_ssl_sessions (Boolean) —

  Reuse a previously opened SSL session for a new connection. There’s a slight performance improvement by enabling this, but at the expense of reliability during long execution. Default false.

• :persist (Boolean) —

  Enable or disable Persistent HTTP. Using Persistent HTTP keeps the connection alive between API calls. Default: ‘true`

# File 'lib/radiator/api.rb', line 188

def initialize(options = {})
  @user = options[:user]
  @password = options[:password]
  @chain = options[:chain] || :steem
  @url = options[:url] || Api::default_url(@chain)
  @preferred_url = @url.dup
  @failover_urls = options[:failover_urls]
  @debug = !!options[:debug]
  @max_requests = options[:max_requests] || 30
  @ssl_verify_mode = options[:ssl_verify_mode] || OpenSSL::SSL::VERIFY_PEER
  @ssl_version = options[:ssl_version]

  @self_logger = false
  @logger = if options[:logger].nil?
    @self_logger = true
    Radiator.logger
  else
    options[:logger]
  end
  
  @self_hashie_logger = false
  @hashie_logger = if options[:hashie_logger].nil?
    @self_hashie_logger = true
    Logger.new(nil)
  else
    options[:hashie_logger]
  end
  
  if @failover_urls.nil?
    @failover_urls = Api::default_failover_urls(@chain) - [@url]
  end
  
  @failover_urls = [@failover_urls].flatten.compact
  @preferred_failover_urls = @failover_urls.dup
  
  unless @hashie_logger.respond_to? :warn
    @hashie_logger = Logger.new(@hashie_logger)
  end
  
  @recover_transactions_on_error = if options.keys.include? :recover_transactions_on_error
    options[:recover_transactions_on_error]
  else
    true
  end
  
  @persist_error_count = 0
  @persist = if options.keys.include? :persist
    options[:persist]
  else
    true
  end
  
  @reuse_ssl_sessions = if options.keys.include? :reuse_ssl_sessions
    options[:reuse_ssl_sessions]
  else
    true
  end
  
  @use_condenser_namespace = if options.keys.include? :use_condenser_namespace
    options[:use_condenser_namespace]
  else
    true
  end
  
  if defined? Net::HTTP::Persistent::DEFAULT_POOL_SIZE
    @pool_size = options[:pool_size] || Net::HTTP::Persistent::DEFAULT_POOL_SIZE
  end
  
  Hashie.logger = @hashie_logger
  @method_names = nil
  @uri = nil
  @http_id = nil
  @http_memo = {}
  @api_options = options.dup.merge(chain: @chain)
  @api = nil
  @block_api = nil
  @backoff_at = nil
  @jussi_supported = []
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(m, *args, &block) ⇒ Object

# File 'lib/radiator/api.rb', line 364

def method_missing(m, *args, &block)
  super unless respond_to_missing?(m)
  
  current_rpc_id = rpc_id
  method_name = [api_name, m].join('.')
  response = nil
  options = if api_name == :condenser_api
    {
      jsonrpc: "2.0",
      method: method_name,
      params: args,
      id: current_rpc_id,
    }
  else
    rpc_args = if args.empty?
      {}
    else
      args.first
    end
    
    {
      jsonrpc: "2.0",
      method: method_name,
      params: rpc_args,
      id: current_rpc_id,
    }
  end
  
  tries = 0
  timestamp = Time.now.utc
  
  loop do
    tries += 1
    
    if tries > 5 && flappy? && !check_file_open?
      raise ApiError, 'PANIC: Out of file resources'
    end
    
    begin
      if tries > 1 && @recover_transactions_on_error && api_name == :network_broadcast_api
        signatures, exp = extract_signatures(options)
        
        if !!signatures && signatures.any?
          offset = [(exp - timestamp).abs, 30].min
          
          if !!(response = recover_transaction(signatures, current_rpc_id, timestamp - offset))
            response = Hashie::Mash.new(response)
          end
        end
      end
      
      if response.nil?
        response = request(options)
        
        response = if response.nil?
          error "No response, retrying ...", method_name
        elsif !response.kind_of? Net::HTTPSuccess
          warning "Unexpected response (code: #{response.code}): #{response.inspect}, retrying ...", method_name, true
        else
          detect_jussi(response)
          
          case response.code
          when '200'
            body = response.body
            response = JSON[body]
            
            if response['id'] != options[:id]
              debug_payload(options, body) if ENV['DEBUG'] == 'true'
              
              if !!response['id']
                warning "Unexpected rpc_id (expected: #{options[:id]}, got: #{response['id']}), retrying ...", method_name, true
              else
                # The node has broken the jsonrpc spec.
                warning "Node did not provide jsonrpc id (expected: #{options[:id]}, got: nothing), retrying ...", method_name, true
              end
              
              if response.keys.include?('error')
                handle_error(response, options, method_name, tries)
              end
            elsif response.keys.include?('error')
              handle_error(response, options, method_name, tries)
            else
              Hashie::Mash.new(response)
            end
          when '400' then warning 'Code 400: Bad Request, retrying ...', method_name, true
          when '429' then warning 'Code 429: Too Many Requests, retrying ...', method_name, true
          when '502' then warning 'Code 502: Bad Gateway, retrying ...', method_name, true
          when '503' then warning 'Code 503: Service Unavailable, retrying ...', method_name, true
          when '504' then warning 'Code 504: Gateway Timeout, retrying ...', method_name, true
          else
            warning "Unknown code #{response.code}, retrying ...", method_name, true
            warning response
          end
        end
      end
    rescue Net::HTTP::Persistent::Error => e
      warning "Unable to perform request: #{e} :: #{!!e.cause ? "cause: #{e.cause.message}" : ''}, retrying ...", method_name, true
      if e.cause.class == Net::HTTPMethodNotAllowed
        warning 'Node upstream is misconfigured.'
        drop_current_failover_url method_name
      end
      
      @persist_error_count += 1
    rescue ConnectionPool::Error => e
      warning "Connection Pool Error (#{e.message}), retrying ...", method_name, true
    rescue Errno::ECONNREFUSED => e
      warning 'Connection refused, retrying ...', method_name, true
    rescue Errno::EADDRNOTAVAIL => e
      warning 'Node not available, retrying ...', method_name, true
    rescue Errno::ECONNRESET => e
      warning "Connection Reset (#{e.message}), retrying ...", method_name, true
    rescue Errno::EBUSY => e
      warning "Resource busy (#{e.message}), retrying ...", method_name, true
    rescue Errno::ENETDOWN => e
      warning "Network down (#{e.message}), retrying ...", method_name, true
    rescue Net::ReadTimeout => e
      warning 'Node read timeout, retrying ...', method_name, true
    rescue Net::OpenTimeout => e
      warning 'Node timeout, retrying ...', method_name, true
    rescue RangeError => e
      warning 'Range Error, retrying ...', method_name, true
    rescue OpenSSL::SSL::SSLError => e
      warning "SSL Error (#{e.message}), retrying ...", method_name, true
    rescue SocketError => e
      warning "Socket Error (#{e.message}), retrying ...", method_name, true
    rescue JSON::ParserError => e
      warning "JSON Parse Error (#{e.message}), retrying ...", method_name, true
      drop_current_failover_url method_name if tries > 5
      response = nil
    rescue ApiError => e
      warning "ApiError (#{e.message}), retrying ...", method_name, true
    # rescue => e
    #   warning "Unknown exception from request, retrying ...", method_name, true
    #   warning e
    end
    
    if !!response
      @persist_error_count = 0
      
      if !!block
        if api_name == :condenser_api
          return yield(response.result, response.error, response.id)
        else
          if defined?(response.result.size) && response.result.size == 0
            return yield(nil, response.error, response.id)
          elsif (
            defined?(response.result.size) && response.result.size == 1 &&
            defined?(response.result.values)
          )
            return yield(response.result.values.first, response.error, response.id)
          else
            return yield(response.result, response.error, response.id)
          end
        end
      else
        return response
      end
    end

    backoff
  end # loop
end

Class Method Details

.default_failover_urls(chain) ⇒ Object

# File 'lib/radiator/api.rb', line 166

def self.default_failover_urls(chain)
  case chain.to_sym
  when :steem then DEFAULT_STEEM_FAILOVER_URLS
  else; raise ApiError, "Unsupported chain: #{chain}"
  end
end

.default_url(chain) ⇒ Object

# File 'lib/radiator/api.rb', line 159

def self.default_url(chain)
  case chain.to_sym
  when :steem then DEFAULT_STEEM_URL
  else; raise ApiError, "Unsupported chain: #{chain}"
  end
end

Instance Method Details

#api_name ⇒ Object

# File 'lib/radiator/api.rb', line 354

def api_name
  :condenser_api
end

#get_blocks(block_number, &block) ⇒ ::Array

Get a specific block or range of blocks.

Example:

api = Radiator::Api.new
blocks = api.get_blocks(10..20)
transactions = blocks.flat_map(&:transactions)

… or …

api = Radiator::Api.new
transactions = []
api.get_blocks(10..20) do |block|
  transactions += block.transactions
end

Parameters:

• block_number (Fixnum || ::Array<Fixnum>)
• block —

  the block to execute for each result, optional.

Returns:

• (::Array)

# File 'lib/radiator/api.rb', line 287

def get_blocks(block_number, &block)
  block_number = [*(block_number)].flatten
  
  if !!block
    block_number.each do |i|
      if use_condenser_namespace?
        yield api.get_block(i)
      else
        yield block_api.get_block(block_num: i).result, i
      end
    end
  else
    block_number.map do |i|
      if use_condenser_namespace?
        api.get_block(i)
      else
        block_api.get_block(block_num: i).result
      end
    end
  end
end

#inspect ⇒ Object

# File 'lib/radiator/api.rb', line 527

def inspect
  properties = %w(
    chain url backoff_at max_requests ssl_verify_mode ssl_version persist
    recover_transactions_on_error reuse_ssl_sessions pool_size
    use_condenser_namespace
  ).map do |prop|
    if !!(v = instance_variable_get("@#{prop}"))
      "@#{prop}=#{v}" 
    end
  end.compact.join(', ')
  
  "#<#{self.class.name} [#{properties}]>"
end

#method_names ⇒ Object

# File 'lib/radiator/api.rb', line 344

def method_names
  return @method_names if !!@method_names
  return CondenserApi::METHOD_NAMES if api_name == :condenser_api

  @method_names = Radiator::Api.methods(api_name).map do |e|
    e['method'].to_sym
  end
end

#respond_to_missing?(m, include_private = false) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/radiator/api.rb', line 359

def respond_to_missing?(m, include_private = false)
  method_names.nil? ? false : method_names.include?(m.to_sym)
end

#shutdown ⇒ Object

Stops the persistant http connections.

# File 'lib/radiator/api.rb', line 311

def shutdown
  @uri = nil
  @http_id = nil
  @http_memo.each do |k|
    v = @http_memo.delete(k)
    if defined?(v.shutdown)
      debug "Shutting down instance #{k} (#{v})"
      v.shutdown
    end
  end
  @api.shutdown if !!@api && @api != self
  @api = nil
  @block_api.shutdown if !!@block_api && @block_api != self
  @block_api = nil
  
  if @self_logger
    if !!@logger && defined?(@logger.close)
      if defined?(@logger.closed?)
        @logger.close unless @logger.closed?
      end
    end
  end
  
  if @self_hashie_logger
    if !!@hashie_logger && defined?(@hashie_logger.close)
      if defined?(@hashie_logger.closed?)
        @hashie_logger.close unless @hashie_logger.closed?
      end
    end
  end
end

#stopped? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/radiator/api.rb', line 541

def stopped?
  http_active = if @http_memo.nil?
    false
  else
    @http_memo.values.map do |http|
      if defined?(http.active?)
        http.active?
      else
        false
      end
    end.include?(true)
  end
  
  @uri.nil? && @http_id.nil? && !http_active && @api.nil? && @block_api.nil?
end

#use_condenser_namespace? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/radiator/api.rb', line 557

def use_condenser_namespace?
  @use_condenser_namespace
end