sequence-sdk 1.0.3 → 1.0.4

data/lib/sequence/balance.rb

@@ -2,32 +2,43 @@ require_relative './client_module'
 require_relative './response_object'
 require_relative './query'
 
-
 module Sequence
   # A summation of contract amounts. Contracts are selected using a filter, and
   # their values are summed using the common values of one or more contract
   # fields.
   class Balance < ResponseObject
-
     # @!attribute [r] amount
-    # Summation of contract amounts.
+    #   Summation of contract amounts.
     # @return [Integer]
     attrib :amount
 
     # @!attribute [r] sum_by
-    # List of parameters along which contract amounts were summed.
+    #   List of parameters along which contract amounts were summed.
     # @return [Hash<String => String>]
     attrib :sum_by
 
     class ClientModule < Sequence::ClientModule
       # Executes a query, returning an enumerable over individual balances.
-      # @param [Hash] opts Options hash
-      # @option opts [String] filter A filter expression.
-      # @option opts [Array<String|Integer>] filter_params A list of values that will be interpolated into the filter expression.
-      # @option opts [Array<String>] sum_by A list of fields along which contract values will be summed.
-      # @option opts [Integer] timestamp A millisecond Unix timestamp. Indicates that the query should be run over the state of the ledger at a given point in time.
+      # @param [Hash] opts
+      #   Options hash
+      # @option opts [String] filter
+      #   A filter expression.
+      # @option opts [Array<String|Integer>] filter_params
+      #   A list of values that will be interpolated into the filter expression.
+      # @option opts [Array<String>] sum_by
+      #   A list of fields along which contract values will be summed.
+      # @option opts [Integer>] page_size
+      #   The number of items to return in the result set.
       # @return [Query]
       def query(opts = {})
+        validate_inclusion_of!(
+          opts,
+          :filter,
+          :filter_params,
+          :sum_by,
+          :page_size,
+          :after,
+        )
         Query.new(client, opts)
       end
     end

data/lib/sequence/client.rb

@@ -1,4 +1,5 @@
 require_relative './account'
+require_relative './action'
 require_relative './asset'
 require_relative './balance'
 require_relative './contract'
@@ -9,26 +10,30 @@ require_relative './transaction'
 
 module Sequence
   class Client
-
-    # @param [Hash] opts Options hash
-    # @option opts [String] url The ledger API URL.
-    # @option opts [String] access_token The ledger access token.
+    # @param [Hash] opts
+    #   Options hash
+    # @option opts [String] ledger
+    #   Ledger name.
+    # @option opts [String] credential
+    #   API credential secret.
     # @return [Query]
     def initialize(opts = {})
-      if !opts.key?(:ledger) || opts[:ledger].empty?
-        raise ArgumentError.new('missing :ledger parameter')
+      if opts[:ledger].nil? || opts[:ledger].empty?
+        raise ArgumentError, ':ledger must be provided'
       end
-      if !opts.key?(:credential) || opts[:credential].empty?
-        raise ArgumentError.new('missing :credential parameter')
+      if opts[:credential].nil? || opts[:credential].empty?
+        raise ArgumentError, ':credential must be provided'
       end
 
       @opts = opts
     end
 
+    # @private
     def opts
       @opts.dup
     end
 
+    # @private
     # @return [Session]
     def session
       @session ||= Session.new(@opts)
@@ -44,6 +49,11 @@ module Sequence
       @assets ||= Asset::ClientModule.new(self)
     end
 
+    # @return [Action::ClientModule]
+    def actions
+      @actions ||= Action::ClientModule.new(self)
+    end
+
     # @return [Balance::ClientModule]
     def balances
       @balances ||= Balance::ClientModule.new(self)
@@ -64,6 +74,7 @@ module Sequence
       @contracts ||= Contract::ClientModule.new(self)
     end
 
+    # @private
     # @return [Stats::ClientModule]
     def stats
       @stats ||= Stats::ClientModule.new(self)
@@ -73,6 +84,5 @@ module Sequence
     def dev_utils
       @dev_utils ||= DevUtils::ClientModule.new(self)
     end
-
   end
 end

data/lib/sequence/client_module.rb

@@ -1,13 +1,15 @@
+require_relative './validations'
+
 module Sequence
   # Base class for ledger client components.
-  # @abstract
+  # @private
   class ClientModule
+    include Sequence::Validations
 
     attr_reader :client
 
     def initialize(client)
       @client = client
     end
-
   end
 end

data/lib/sequence/contract.rb

@@ -6,68 +6,83 @@ module Sequence
   # An entry in the ledger that contains value that can be spent.
   class Contract < ResponseObject
     # @!attribute [r] id
-    # A unique ID.
+    #   A unique ID.
     # @return [String]
     attrib :id
 
     # @!attribute [r] type
-    # The type of the contract. Currently, this is always "account".
+    #   The type of the contract. Currently, this is always "account".
     # @return [String]
     attrib :type
 
     # @!attribute [r] transaction_id
-    # The ID of the transaction in which the contract appears.
+    #   The ID of the transaction in which the contract appears.
     # @return [String]
     attrib :transaction_id
 
     # @!attribute [r] asset_id
-    # The ID of the asset held by the contract.
+    #   The ID of the asset held by the contract.
     # @return [String]
     attrib :asset_id
 
     # @!attribute [r] asset_alias
-    # The alias of the asset held by the contract.
+    #   The alias of the asset held by the contract.
     # @return [String]
     attrib :asset_alias
 
     # @!attribute [r] asset_tags
-    # The tags of the asset held by the contract.
+    #   The tags of the asset held by the contract.
     # @return [Hash]
     attrib :asset_tags
 
     # @!attribute [r] amount
-    # The number of units of the asset held by the contract.
+    #   The number of units of the asset held by the contract.
     # @return [Integer]
     attrib :amount
 
     # @!attribute [r] account_id
-    # The ID of the account controlling the contract.
+    #   The ID of the account controlling the contract.
     # @return [String]
     attrib :account_id
 
     # @!attribute [r] account_alias
-    # The alias of the account controlling the contract.
+    #   The alias of the account controlling the contract.
     # @return [String]
     attrib :account_alias
 
     # @!attribute [r] account_tags
-    # The tags of the account controlling the contract.
+    #   The tags of the account controlling the contract.
     # @return [Hash]
     attrib :account_tags
 
     # @!attribute [r] reference_data
-    # User-specified key-value data embedded in the contract.
+    #   User-specified key-value data embedded in the contract.
     # @return [Hash]
     attrib :reference_data
 
     class ClientModule < Sequence::ClientModule
       # Executes a query, returning an enumerable over individual contracts.
-      # @param [Hash] opts Options hash
-      # @option opts [String] filter A filter expression.
-      # @option opts [Array<String|Integer>] filter_params A list of values that will be interpolated into the filter expression.
-      # @option opts [Integer] timestamp A millisecond Unix timestamp. Indicates that the query should be run over the state of the ledger at a given point in time.
+      # @param [Hash] opts
+      #   Options hash
+      # @option opts [String] filter
+      #   A filter expression.
+      # @option opts [Array<String|Integer>] filter_params
+      #   A list of values that will be interpolated into the filter expression.
+      # @option opts [Integer] timestamp
+      #   A millisecond Unix timestamp. Indicates that the query should be run
+      #   over the state of the ledger at a given point in time.
+      # @option opts [Integer>] page_size
+      #   The number of items to return in the result set.
       # @return [Query]
       def query(opts = {})
+        validate_inclusion_of!(
+          opts,
+          :filter,
+          :filter_params,
+          :timestamp,
+          :page_size,
+          :after,
+        )
         Query.new(client, opts)
       end
     end

data/lib/sequence/dev_utils.rb

@@ -8,7 +8,7 @@ module Sequence
     class ClientModule < Sequence::ClientModule
       # Deletes all data in the ledger.
       def reset
-        client.session.request('/reset', client_token: SecureRandom.uuid)
+        client.session.request('/reset')
       end
     end
   end

data/lib/sequence/errors.rb

@@ -34,23 +34,23 @@ module Sequence
   # an error code, a message, and an optional detail field that provides
   # additional context for the error.
   class APIError < BaseError
-    RETRIABLE_STATUS_CODES = [
-      408, # Request Timeout
-      429, # Too Many Requests
-      500, # Internal Server Error
-      502, # Bad Gateway
-      503, # Service Unavailable
-      504, # Gateway Timeout
-      509, # Bandwidth Limit Exceeded
-    ]
-
-    attr_accessor :code, :chain_message, :detail, :data, :temporary, :request_id, :response
+    attr_accessor(
+      :chain_message,
+      :code,
+      :data,
+      :detail,
+      :request_id,
+      :response,
+      :retriable,
+      :temporary,
+    )
 
     def initialize(body, response)
       self.code = body['code']
       self.chain_message = body['message']
       self.detail = body['detail']
-      self.temporary = body['temporary']
+      self.retriable = body['retriable']
+      self.temporary = body['retriable']
 
       self.response = response
       self.request_id = response['Chain-Request-ID'] if response
@@ -59,7 +59,7 @@ module Sequence
     end
 
     def retriable?
-      temporary || (response && RETRIABLE_STATUS_CODES.include?(Integer(response.code)))
+      self.retriable
     end
 
     def self.format_error_message(code, message, detail, request_id)

data/lib/sequence/http_wrapper.rb

@@ -2,14 +2,15 @@ require 'net/http'
 require 'net/https'
 require 'openssl'
 require 'thread'
+require 'securerandom'
 
 module Sequence
+  # @private
   class HttpWrapper
-
     # Parameters to the retry exponential backoff function.
-    MAX_RETRIES = 10
     RETRY_BASE_DELAY_MS = 40
-    RETRY_MAX_DELAY_MS = 4000
+    RETRY_MAX_DELAY_MS = 20_000
+    RETRY_TIMEOUT_SECS = 120 # 2 minutes
 
     NETWORK_ERRORS = [
       InvalidRequestIDError,
@@ -22,46 +23,76 @@ module Sequence
       Errno::ETIMEDOUT,
       Errno::EHOSTUNREACH,
       Errno::ECONNREFUSED,
-    ]
+    ].freeze
 
     attr_accessor :dis_macaroon
 
-    def initialize(host, macaroon, opts={})
+    def initialize(host, macaroon, opts = {})
       @mutex = Mutex.new
       @host = URI(host)
       @macaroon = macaroon
       @dis_macaroon = nil
       @opts = opts
-      @http = setup_http
+      @connection = setup_connection
     end
 
-    def post(url, body)
+    def post(id, url, body)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       attempts = 0
+      idempotency_key = SecureRandom.uuid
       begin
         attempts += 1
         # If this is a retry and not the first attempt, sleep before making the
         # retry request.
         sleep(backoff_delay(attempts)) if attempts > 1
 
+        attempt_id = "#{id}/#{attempts}"
         @mutex.synchronize do
           req = Net::HTTP::Post.new(url)
           req.body = JSON.dump(body)
           req['Accept'] = 'application/json'
           req['Content-Type'] = 'application/json'
+          req['Id'] = attempt_id
+          req['Idempotency-Key'] = idempotency_key
           req['User-Agent'] = 'chain-sdk-ruby/' + Sequence::VERSION
-          if @macaroon != nil && @dis_macaroon != nil
+          if !@macaroon.nil? && !@dis_macaroon.nil?
             req['Macaroon'] = @macaroon
             req['Discharge-Macaroon'] = @dis_macaroon
           end
-          return @http.request(req)
+          unless @connection.started?
+            @connection.start
+          end
+          response = @connection.request(req)
+
+          if block_given?
+            yield response
+          end
+
+          # We must parse any APIErrors here so that
+          # the retry logic can handle them.
+          status = Integer(response.code)
+          parsed_body = nil
+          if status != 204 # No Content
+            begin
+              parsed_body = JSON.parse(response.body)
+            rescue JSON::JSONError
+              raise JSONError.new(attempt_id, response)
+            end
+          end
+          if status / 100 != 2
+            klass = status == 401 ? UnauthorizedError : APIError
+            raise klass.new(parsed_body, response)
+          end
+
+          { parsed_body: parsed_body, response: response }
         end
       rescue *NETWORK_ERRORS => e
-        raise e if attempts > MAX_RETRIES
+        raise e if elapsed_secs(start_time) > RETRY_TIMEOUT_SECS
         retry
       rescue APIError => e
-        raise e if attempts > MAX_RETRIES
-        retry if e.retriable?
-        raise e
+        raise e unless e.retriable?
+        raise e if elapsed_secs(start_time) > RETRY_TIMEOUT_SECS
+        retry
       end
     end
 
@@ -69,14 +100,18 @@ module Sequence
 
     MILLIS_TO_SEC = 0.001
 
+    def elapsed_secs(start_time)
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+    end
+
     def backoff_delay(attempt)
-      max = RETRY_BASE_DELAY_MS * 2**(attempt-1)
+      max = RETRY_BASE_DELAY_MS * 2**(attempt - 1)
       max = [max, RETRY_MAX_DELAY_MS].min
       millis = rand(max) + 1
       millis * MILLIS_TO_SEC
     end
 
-    def setup_http
+    def setup_connection
       args = [@host.hostname, @host.port]
 
       # Proxy configuration
@@ -87,25 +122,24 @@ module Sequence
         end
       end
 
-      http = Net::HTTP.new(*args)
-      http.set_debug_output($stdout) if ENV['DEBUG']
+      connection = Net::HTTP.new(*args)
+      connection.set_debug_output($stdout) if ENV['DEBUG']
 
       # TLS configuration
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      connection.use_ssl = true
+      connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
       [:ca_file, :cert, :key].each do |k|
         next unless @opts.key?(:ssl_params) && @opts[:ssl_params].key?(k)
-        http.send("#{k}=", @opts[:ssl_params][k])
+        connection.send("#{k}=", @opts[:ssl_params][k])
       end
 
       # Timeout configuration
       [:open_timeout, :read_timeout, :ssl_timeout].each do |k|
         next unless @opts.key?(k)
-        http.send "#{k}=", @opts[k]
+        connection.send "#{k}=", @opts[k]
       end
 
-      return http
+      connection
     end
-
   end
 end