diplomatic_bag 2.2.2 → 2.2.3

data/lib/diplomat/check.rb

@@ -1,109 +0,0 @@
-module Diplomat
-  # Methods for interacting with the Consul check API endpoint
-  class Check < Diplomat::RestClient
-    @access_methods = %i[checks register_script register_ttl
-                         deregister pass warn fail]
-
-    # Get registered checks
-    # @return [OpenStruct] all data associated with the service
-    def checks(options = {})
-      ret = send_get_request(@conn, ['/v1/agent/checks'], options)
-      JSON.parse(ret.body)
-    end
-
-    # Register a check
-    # @param check_id [String] the unique id of the check
-    # @param name [String] the name
-    # @param notes [String] notes about the check
-    # @param args [String[]] command to be run for check
-    # @param interval [String] frequency (with units) of the check execution
-    # @param options [Hash] options parameter hash
-    # @return [Integer] Status code
-    # rubocop:disable ParameterLists
-    def register_script(check_id, name, notes, args, interval, options = {})
-      unless args.is_a?(Array)
-        raise(Diplomat::DeprecatedArgument, 'Script usage is deprecated, replace by an array of args')
-      end
-
-      definition = JSON.generate(
-        'ID' => check_id,
-        'Name' => name,
-        'Notes' => notes,
-        'Args' => args,
-        'Interval' => interval
-      )
-      ret = send_put_request(@conn, ['/v1/agent/check/register'], options, definition)
-      ret.status == 200
-    end
-    # rubocop:enable ParameterLists
-
-    # Register a TTL check
-    # @param check_id [String] the unique id of the check
-    # @param name [String] the name
-    # @param notes [String] notes about the check
-    # @param ttl [String] time (with units) to mark a check down
-    # @param options [Hash] options parameter hash
-    # @return [Boolean] Success
-    def register_ttl(check_id, name, notes, ttl, options = {})
-      definition = JSON.generate(
-        'ID' => check_id,
-        'Name' => name,
-        'Notes' => notes,
-        'TTL' => ttl
-      )
-      ret = send_put_request(@conn, ['/v1/agent/check/register'], options, definition)
-      ret.status == 200
-    end
-
-    # Deregister a check
-    # @param check_id [String] the unique id of the check
-    # @param options [Hash] options parameter hash
-    # @return [Integer] Status code
-    def deregister(check_id, options = {})
-      ret = send_put_request(@conn, ["/v1/agent/check/deregister/#{check_id}"], options, nil)
-      ret.status == 200
-    end
-
-    # Update a TTL check
-    # @param check_id [String] the unique id of the check
-    # @param status [String] status of the check. Valid values are "passing", "warning", and "critical"
-    # @param output [String] human-readable message will be passed through to the check's Output field
-    # @param options [Hash] options parameter hash
-    # @return [Integer] Status code
-    def update_ttl(check_id, status, output = nil, options = {})
-      definition = JSON.generate(
-        'Status' => status,
-        'Output' => output
-      )
-      ret = send_put_request(@conn, ["/v1/agent/check/update/#{check_id}"], options, definition)
-      ret.status == 200
-    end
-
-    # Pass a check
-    # @param check_id [String] the unique id of the check
-    # @param output [String] human-readable message will be passed through to the check's Output field
-    # @param options [Hash] options parameter hash
-    # @return [Integer] Status code
-    def pass(check_id, output = nil, options = {})
-      update_ttl(check_id, 'passing', output, options)
-    end
-
-    # Warn a check
-    # @param check_id [String] the unique id of the check
-    # @param output [String] human-readable message will be passed through to the check's Output field
-    # @param options [Hash] options parameter hash
-    # @return [Integer] Status code
-    def warn(check_id, output = nil, options = {})
-      update_ttl(check_id, 'warning', output, options)
-    end
-
-    # Fail a check
-    # @param check_id [String] the unique id of the check
-    # @param output [String] human-readable message will be passed through to the check's Output field
-    # @param options [Hash] options parameter hash
-    # @return [Integer] Status code
-    def fail(check_id, output = nil, options = {})
-      update_ttl(check_id, 'critical', output, options)
-    end
-  end
-end

data/lib/diplomat/configuration.rb

@@ -1,28 +0,0 @@
-module Diplomat
-  # Methods for configuring Diplomat
-  class Configuration
-    attr_reader :middleware
-    attr_accessor :url, :acl_token, :options
-
-    # Override defaults for configuration
-    # @param url [String] consul's connection URL
-    # @param acl_token [String] a connection token used when making requests to consul
-    # @param options [Hash] extra options to configure Faraday::Connection
-    def initialize(url = 'http://localhost:8500', acl_token = nil, options = {})
-      @middleware = []
-      @url = url
-      @acl_token = acl_token
-      @options = options
-    end
-
-    # Define a middleware for Faraday
-    # @param middleware [Class] Faraday Middleware class
-    def middleware=(middleware)
-      if middleware.is_a? Array
-        @middleware = middleware
-        return
-      end
-      @middleware = [middleware]
-    end
-  end
-end

data/lib/diplomat/datacenter.rb

@@ -1,21 +0,0 @@
-module Diplomat
-  # Methods for interacting with the Consul dataceneter API endpoint
-  class Datacenter < Diplomat::RestClient
-    @access_methods = [:get]
-
-    # Get an array of all avaliable datacenters accessible by the local consul agent
-    # @param meta [Hash] output structure containing header information about the request (index)
-    # @param options [Hash] options parameter hash
-    # @return [OpenStruct] all datacenters avaliable to this consul agent
-    def get(meta = nil, options = {})
-      ret = send_get_request(@conn, ['/v1/catalog/datacenters'], options)
-
-      if meta && ret.headers
-        meta[:index] = ret.headers['x-consul-index'] if ret.headers['x-consul-index']
-        meta[:knownleader] = ret.headers['x-consul-knownleader'] if ret.headers['x-consul-knownleader']
-        meta[:lastcontact] = ret.headers['x-consul-lastcontact'] if ret.headers['x-consul-lastcontact']
-      end
-      JSON.parse(ret.body)
-    end
-  end
-end

data/lib/diplomat/error.rb

@@ -1,15 +0,0 @@
-module Diplomat
-  class KeyNotFound < StandardError; end
-  class PathNotFound < StandardError; end
-  class KeyAlreadyExists < StandardError; end
-  class AclNotFound < StandardError; end
-  class AclAlreadyExists < StandardError; end
-  class EventNotFound < StandardError; end
-  class EventAlreadyExists < StandardError; end
-  class QueryNotFound < StandardError; end
-  class QueryAlreadyExists < StandardError; end
-  class UnknownStatus < StandardError; end
-  class IdParameterRequired < StandardError; end
-  class InvalidTransaction < StandardError; end
-  class DeprecatedArgument < StandardError; end
-end

data/lib/diplomat/event.rb

@@ -1,166 +0,0 @@
-module Diplomat
-  # Methods for interacting with the Consul event API endpoint
-  class Event < Diplomat::RestClient
-    @access_methods = %i[fire get_all get]
-
-    # Send an event
-    # @param name [String] the event name
-    # @param value [String] the payload of the event
-    # @param service [String] the target service name
-    # @param node [String] the target node name
-    # @param tag [String] the target tag name, must only be used with service
-    # @param dc [String] the dc to target
-    # @param options [Hash] options parameter hash
-    # @return [nil]
-    # rubocop:disable Metrics/ParameterLists
-    def fire(name, value = nil, service = nil, node = nil, tag = nil, dc = nil, options = {})
-      custom_params = []
-      custom_params << use_named_parameter('service', service) if service
-      custom_params << use_named_parameter('node', node) if node
-      custom_params << use_named_parameter('tag', tag) if tag
-      custom_params << use_named_parameter('dc', dc) if dc
-
-      send_put_request(@conn, ["/v1/event/fire/#{name}"], options, value, custom_params)
-      nil
-    end
-    # rubocop:enable Metrics/ParameterLists
-
-    # Get the list of events matching name
-    # @param name [String] the name of the event (regex)
-    # @param not_found [Symbol] behaviour if there are no events matching name;
-    #   :reject with exception, :return degenerate value, or :wait for a non-empty list
-    # @param found [Symbol] behaviour if there are already events matching name;
-    #   :reject with exception, :return its current value, or :wait for its next value
-    # @return [Array[hash]] The list of { :name, :payload } hashes
-    # @param options [Hash] options parameter hash
-    # @note
-    #   Events are sent via the gossip protocol; there is no guarantee of delivery
-    #   success or order, but the local agent will store up to 256 events that do
-    #   arrive. This method lists those events.
-    #   It has the same semantics as Kv::get, except the value returned is a list
-    #   i.e. the current value is all events up until now, the next value is the
-    #   current list plus the next event to arrive.
-    #   To get a specific event in the sequence, @see #get
-    #   When trying to get a list of events matching a name, there are two possibilities:
-    #   - The list doesn't (yet) exist / is empty
-    #   - The list exists / is non-empty
-    #   The combination of not_found and found behaviour gives maximum possible
-    #   flexibility. For X: reject, R: return, W: wait
-    #   - X X - meaningless; never return a value
-    #   - X R - "normal" non-blocking get operation. Default
-    #   - X W - get the next value only (must have a current value)
-    #   - R X - meaningless; never return a meaningful value
-    #   - R R - "safe" non-blocking, non-throwing get-or-default operation
-    #   - R W - get the next value or a default
-    #   - W X - get the first value only (must not have a current value)
-    #   - W R - get the first or current value; always return something, but
-    #           block only when necessary
-    #   - W W - get the first or next value; wait until there is an update
-    def get_all(name = nil, not_found = :reject, found = :return, options = {})
-      # Event list never returns 404 or blocks, but may return an empty list
-      @raw = send_get_request(@conn, ['/v1/event/list'], options, use_named_parameter('name', name))
-      if JSON.parse(@raw.body).count.zero?
-        case not_found
-        when :reject
-          raise Diplomat::EventNotFound, name
-        when :return
-          return []
-        end
-      else
-        case found
-        when :reject
-          raise Diplomat::EventAlreadyExists, name
-        when :return
-          @raw = parse_body
-          return return_payload
-        end
-      end
-
-      @raw = wait_for_next_event(['/v1/event/list'], options, use_named_parameter('name', name))
-      @raw = parse_body
-      return_payload
-    end
-
-    # Get a specific event in the sequence matching name
-    # @param name [String] the name of the event (regex)
-    # @param token [String|Symbol] the ordinate of the event in the sequence;
-    #   String are tokens returned by previous calls to this function
-    #   Symbols are the special tokens :first, :last, and :next
-    # @param not_found [Symbol] behaviour if there is no matching event;
-    #   :reject with exception, :return degenerate value, or :wait for event
-    # @param found [Symbol] behaviour if there is a matching event;
-    #   :reject with exception, or :return its current value
-    # @return [hash] A hash with keys :value and :token;
-    #   :value is a further hash of the :name and :payload of the event,
-    #   :token is the event's ordinate in the sequence and can be passed to future calls to get the subsequent event
-    # @param options [Hash] options parameter hash
-    # @note
-    #   Whereas the consul API for events returns all past events that match
-    #   name, this method allows retrieval of individual events from that
-    #   sequence. However, because consul's API isn't conducive to this, we can
-    #   offer first, last, next (last + 1) events, or arbitrary events in the
-    #   middle, though these can only be identified relative to the preceding
-    #   event. However, this is ideal for iterating through the sequence of
-    #   events (while being sure that none are missed).
-    # rubocop:disable PerceivedComplexity
-    def get(name = nil, token = :last, not_found = :wait, found = :return, options = {})
-      @raw = send_get_request(@conn, ['/v1/event/list'], options, use_named_parameter('name', name))
-      body = JSON.parse(@raw.body)
-      # TODO: deal with unknown symbols, invalid indices (find_index will return nil)
-      idx = case token
-            when :first then 0
-            when :last then body.length - 1
-            when :next then body.length
-            else body.find_index { |e| e['ID'] == token } + 1
-            end
-      if JSON.parse(@raw.body).count.zero? || idx == body.length
-        case not_found
-        when :reject
-          raise Diplomat::EventNotFound, name
-        when :return
-          event_name = ''
-          event_payload = ''
-          event_token = :last
-        when :wait
-          @raw = wait_for_next_event(['/v1/event/list'], options, use_named_parameter('name', name))
-          @raw = parse_body
-          # If it's possible for two events to arrive at once,
-          # this needs to #find again:
-          event = @raw.last
-          event_name = event['Name']
-          event_payload = Base64.decode64(event['Payload'])
-          event_token = event['ID']
-        end
-      else
-        case found
-        when :reject
-          raise Diplomat::EventAlreadyExits, name
-        when :return
-          event = body[idx]
-          event_name = event['Name']
-          event_payload = event['Payload'].nil? ? nil : Base64.decode64(event['Payload'])
-          event_token = event['ID']
-        end
-      end
-
-      {
-        value: { name: event_name, payload: event_payload },
-        token: event_token
-      }
-    end
-    # rubocop:enable PerceivedComplexity
-
-    private
-
-    def wait_for_next_event(url, options = {}, param = nil)
-      if options.nil?
-        options = { timeout: 86_400 }
-      else
-        options[:timeout] = 86_400
-      end
-      index = @raw.headers['x-consul-index']
-      param += use_named_parameter('index', index)
-      send_get_request(@conn, url, options, param)
-    end
-  end
-end

data/lib/diplomat/health.rb

@@ -1,81 +0,0 @@
-module Diplomat
-  # Methods for interacting with the Consul health API endpoint
-  class Health < Diplomat::RestClient
-    @access_methods = %i[node checks service state
-                         any passing warning critical]
-
-    # Get node health
-    # @param n [String] the node
-    # @param options [Hash] :dc string for dc specific query
-    # @return [OpenStruct] all data associated with the node
-    def node(n, options = {})
-      custom_params = []
-      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
-
-      ret = send_get_request(@conn, ["/v1/health/node/#{n}"], options, custom_params)
-      JSON.parse(ret.body).map { |node| OpenStruct.new node }
-    end
-
-    # Get service checks
-    # @param s [String] the service
-    # @param options [Hash] :dc string for dc specific query
-    # @return [OpenStruct] all data associated with the node
-    def checks(s, options = {})
-      custom_params = []
-      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
-
-      ret = send_get_request(@conn, ["/v1/health/checks/#{s}"], options, custom_params)
-      JSON.parse(ret.body).map { |check| OpenStruct.new check }
-    end
-
-    # Get service health
-    # @param s [String] the service
-    # @param options [Hash] options parameter hash
-    # @return [OpenStruct] all data associated with the node
-    # rubocop:disable PerceivedComplexity
-    def service(s, options = {})
-      custom_params = []
-      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
-      custom_params << ['passing'] if options[:passing]
-      custom_params << use_named_parameter('tag', options[:tag]) if options[:tag]
-      custom_params << use_named_parameter('near', options[:near]) if options[:near]
-
-      ret = send_get_request(@conn, ["/v1/health/service/#{s}"], options, custom_params)
-      JSON.parse(ret.body).map { |service| OpenStruct.new service }
-    end
-    # rubocop:enable PerceivedComplexity
-
-    # Get service health
-    # @param s [String] the state ("any", "passing", "warning", or "critical")
-    # @param options [Hash] :dc string for dc specific query
-    # @return [OpenStruct] all data associated with the node
-    def state(s, options = {})
-      custom_params = []
-      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
-      custom_params << use_named_parameter('near', options[:near]) if options[:near]
-
-      ret = send_get_request(@conn, ["/v1/health/state/#{s}"], options, custom_params)
-      JSON.parse(ret.body).map { |status| OpenStruct.new status }
-    end
-
-    # Convenience method to get services in any state
-    def any
-      state('any')
-    end
-
-    # Convenience method to get services in passing state
-    def passing
-      state('passing')
-    end
-
-    # Convenience method to get services in warning state
-    def warning
-      state('warning')
-    end
-
-    # Convenience method to get services in critical state
-    def critical
-      state('critical')
-    end
-  end
-end

data/lib/diplomat/kv.rb

@@ -1,263 +0,0 @@
-module Diplomat
-  # Methods for interacting with the Consul KV API endpoint
-  class Kv < Diplomat::RestClient
-    @access_methods = %i[get put delete txn]
-    attr_reader :key, :value, :raw
-
-    # Get a value by its key, potentially blocking for the first or next value
-    # @param key [String] the key
-    # @param options [Hash] the query params
-    # @option options [Boolean] :recurse If to make recursive get or not
-    # @option options [String] :consistency The read consistency type
-    # @option options [String] :dc Target datacenter
-    # @option options [Boolean] :keys Only return key names.
-    # @option options [Boolean] :modify_index Only return ModifyIndex value.
-    # @option options [Boolean] :session Only return Session value.
-    # @option options [Boolean] :decode_values Return consul response with decoded values.
-    # @option options [String] :separator List only up to a given separator.
-    #   Only applies when combined with :keys option.
-    # @option options [Boolean] :nil_values If to return keys/dirs with nil values
-    # @option options [Boolean] :convert_to_hash Take the data returned from consul and build a hash
-    # @option options [Callable] :transformation funnction to invoke on keys values
-    # @param not_found [Symbol] behaviour if the key doesn't exist;
-    #   :reject with exception, :return degenerate value, or :wait for it to appear
-    # @param found [Symbol] behaviour if the key does exist;
-    #   :reject with exception, :return its current value, or :wait for its next value
-    # @return [String] The base64-decoded value associated with the key
-    # @note
-    #   When trying to access a key, there are two possibilites:
-    #   - The key doesn't (yet) exist
-    #   - The key exists. This may be its first value, there is no way to tell
-    #   The combination of not_found and found behaviour gives maximum possible
-    #   flexibility. For X: reject, R: return, W: wait
-    #   - X X - meaningless; never return a value
-    #   - X R - "normal" non-blocking get operation. Default
-    #   - X W - get the next value only (must have a current value)
-    #   - R X - meaningless; never return a meaningful value
-    #   - R R - "safe" non-blocking, non-throwing get-or-default operation
-    #   - R W - get the next value or a default
-    #   - W X - get the first value only (must not have a current value)
-    #   - W R - get the first or current value; always return something, but
-    #           block only when necessary
-    #   - W W - get the first or next value; wait until there is an update
-    # rubocop:disable PerceivedComplexity, MethodLength, LineLength, CyclomaticComplexity
-    def get(key, options = {}, not_found = :reject, found = :return)
-      key_subst = if key.start_with? '/'
-                    key[1..-1]
-                  else
-                    key.freeze
-                  end
-      @key = key_subst
-      @options = options
-      custom_params = []
-      custom_params << recurse_get(@options)
-      custom_params << use_consistency(options)
-      custom_params << dc(@options)
-      custom_params << keys(@options)
-      custom_params << separator(@options)
-
-      return_nil_values = @options && @options[:nil_values]
-      transformation = @options && @options[:transformation] && @options[:transformation].methods.find_index(:call) ? @options[:transformation] : nil
-
-      raw = send_get_request(@conn_no_err, ["/v1/kv/#{@key}"], options, custom_params)
-      if raw.status == 404
-        case not_found
-        when :reject
-          raise Diplomat::KeyNotFound, key
-        when :return
-          return @value = ''
-        when :wait
-          index = raw.headers['x-consul-index']
-        end
-      elsif raw.status == 200
-        case found
-        when :reject
-          raise Diplomat::KeyAlreadyExists, key
-        when :return
-          @raw = raw
-          @raw = parse_body
-          return @raw.first['ModifyIndex'] if @options && @options[:modify_index]
-          return @raw.first['Session'] if @options && @options[:session]
-          return decode_values if @options && @options[:decode_values]
-          return convert_to_hash(return_value(return_nil_values, transformation, true)) if @options && @options[:convert_to_hash]
-
-          return return_value(return_nil_values, transformation)
-        when :wait
-          index = raw.headers['x-consul-index']
-        end
-      else
-        raise Diplomat::UnknownStatus, "status #{raw.status}: #{raw.body}"
-      end
-
-      # Wait for first/next value
-      custom_params << use_named_parameter('index', index)
-      if options.nil?
-        options = { timeout: 86_400 }
-      else
-        options[:timeout] = 86_400
-      end
-      @raw = send_get_request(@conn, ["/v1/kv/#{@key}"], options, custom_params)
-      @raw = parse_body
-      return_value(return_nil_values, transformation)
-    end
-    # rubocop:enable PerceivedComplexity, LineLength, MethodLength, CyclomaticComplexity
-
-    # Associate a value with a key
-    # @param key [String] the key
-    # @param value [String] the value
-    # @param options [Hash] the query params
-    # @option options [Integer] :cas The modify index
-    # @option options [String] :dc Target datacenter
-    # @option options [String] :acquire Session to attach to key
-    # @return [Bool] Success or failure of the write (can fail in c-a-s mode)
-    def put(key, value, options = {})
-      @options = options
-      custom_params = []
-      custom_params << use_cas(@options)
-      custom_params << dc(@options)
-      custom_params << acquire(@options)
-      @raw = send_put_request(@conn, ["/v1/kv/#{key}"], options, value, custom_params,
-                              'application/x-www-form-urlencoded')
-      if @raw.body.chomp == 'true'
-        @key = key
-        @value = value
-      end
-      @raw.body.chomp == 'true'
-    end
-
-    # Delete a value by its key
-    # @param key [String] the key
-    # @param options [Hash] the query params
-    # @option options [String] :dc Target datacenter
-    # @option options [Boolean] :recurse If to make recursive get or not
-    # @return [OpenStruct]
-    def delete(key, options = {})
-      @key = key
-      @options = options
-      custom_params = []
-      custom_params << recurse_get(@options)
-      custom_params << dc(@options)
-      @raw = send_delete_request(@conn, ["/v1/kv/#{@key}"], options, custom_params)
-    end
-
-    # Perform a key/value store transaction.
-    #
-    # @since 1.3.0
-    # @see https://www.consul.io/docs/agent/http/kv.html#txn Transaction key/value store API documentation
-    # @example Valid key/value store transaction format
-    #   [
-    #     {
-    #       'KV' => {
-    #         'Verb' => 'get',
-    #         'Key' => 'hello/world'
-    #       }
-    #     }
-    #   ]
-    # @raise [Diplomat::InvalidTransaction] if transaction format is invalid
-    # @param value [Array] an array of transaction hashes
-    # @param [Hash] options transaction params
-    # @option options [Boolean] :decode_values of any GET requests, default: true
-    # @option options [String] :dc Target datacenter
-    # @option options [String] :consistency the accepted staleness level of the transaction.
-    #   Can be 'stale' or 'consistent'
-    # @return [OpenStruct] result of the transaction
-    def txn(value, options = {})
-      # Verify the given value for the transaction
-      transaction_verification(value)
-      # Will return 409 if transaction was rolled back
-      custom_params = []
-      custom_params << dc(options)
-      custom_params << transaction_consistency(options)
-      raw = send_put_request(@conn_no_err, ['/v1/txn'], options, value, custom_params)
-      transaction_return JSON.parse(raw.body), options
-    end
-
-    private
-
-    def recurse_get(options)
-      options[:recurse] ? ['recurse'] : []
-    end
-
-    def dc(options)
-      options[:dc] ? use_named_parameter('dc', options[:dc]) : []
-    end
-
-    def acquire(options)
-      options[:acquire] ? use_named_parameter('acquire', options[:acquire]) : []
-    end
-
-    def keys(options)
-      options[:keys] ? ['keys'] : []
-    end
-
-    def separator(options)
-      options[:separator] ? use_named_parameter('separator', options[:separator]) : []
-    end
-
-    def transaction_consistency(options)
-      return [] unless options
-
-      if options[:consistency] && options[:consistency] == 'stale'
-        ['stale']
-      elsif options[:consistency] && options[:consistency] == 'consistent'
-        ['consistent']
-      else
-        []
-      end
-    end
-
-    def transaction_verification(transaction)
-      raise Diplomat::InvalidTransaction unless transaction.is_a?(Array)
-
-      transaction.each do |req|
-        raise Diplomat::InvalidTransaction unless transaction_type_verification(req)
-        raise Diplomat::InvalidTransaction unless transaction_verb_verification(req['KV'])
-      end
-      # Encode all value transacations if all checks pass
-      encode_transaction(transaction)
-    end
-
-    def transaction_type_verification(txn)
-      txn.is_a?(Hash) && txn.keys == %w[KV]
-    end
-
-    def transaction_verb_verification(txn)
-      transaction_verb = txn['Verb']
-      raise Diplomat::InvalidTransaction unless valid_transaction_verbs.include? transaction_verb
-
-      test_requirements = valid_transaction_verbs[transaction_verb] - txn.keys
-      test_requirements.empty?
-    end
-
-    def encode_transaction(transaction)
-      transaction.each do |txn|
-        next unless valid_value_transactions.include? txn['KV']['Verb']
-
-        value = txn['KV']['Value']
-        txn['KV']['Value'] = Base64.encode64(value).chomp
-      end
-    end
-
-    def transaction_return(raw_return, options)
-      decoded_return =
-        options[:decode_values] == false ? raw_return : decode_transaction(raw_return)
-      OpenStruct.new decoded_return
-    end
-
-    def decode_transaction(transaction)
-      return transaction if transaction['Results'].nil? || transaction['Results'].empty?
-
-      transaction.tap do |txn|
-        txn['Results'].each do |resp|
-          next unless resp['KV']['Value']
-
-          begin
-            resp['KV']['Value'] = Base64.decode64(resp['KV']['Value'])
-          rescue StandardError
-            nil
-          end
-        end
-      end
-    end
-  end
-end