diplomat 2.0.5 → 2.1.0

data/lib/diplomat/health.rb

@@ -8,75 +8,55 @@ module Diplomat
     # @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 = nil)
-      url = ["/v1/health/node/#{n}"]
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
+    def node(n, options = {})
+      custom_params = []
+      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
 
-      # If the request fails, it's probably due to a bad path
-      # so return a PathNotFound error.
-      ret = @conn.get concat_url url
+      ret = send_get_request(@conn, ["/v1/health/node/#{n}"], options, custom_params)
       JSON.parse(ret.body).map { |node| OpenStruct.new node }
-    rescue Faraday::ClientError
-      raise Diplomat::PathNotFound
     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 = nil)
-      url = ["/v1/health/checks/#{s}"]
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
+    def checks(s, options = {})
+      custom_params = []
+      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
 
-      # If the request fails, it's probably due to a bad path
-      # so return a PathNotFound error.
-      ret = @conn.get concat_url url
+      ret = send_get_request(@conn, ["/v1/health/checks/#{s}"], options, custom_params)
       JSON.parse(ret.body).map { |check| OpenStruct.new check }
-    rescue Faraday::ClientError
-      raise Diplomat::PathNotFound
     end
 
     # Get service health
     # @param s [String] the service
-    # @param options [Hash] :dc string for dc specific query
-    # @param options [Hash] :passing boolean to return only checks in passing state
-    # @param options [Hash] :tag string for specific tag
+    # @param options [Hash] options parameter hash
     # @return [OpenStruct] all data associated with the node
-    # rubocop:disable PerceivedComplexity, CyclomaticComplexity, AbcSize
-    def service(s, options = nil)
-      url = ["/v1/health/service/#{s}"]
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-      url << 'passing' if options && options[:passing]
-      url << use_named_parameter('tag', options[:tag]) if options && options[:tag]
-      url << use_named_parameter('near', options[:near]) if options && options[:near]
+    # 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]
 
-      # If the request fails, it's probably due to a bad path
-      # so return a PathNotFound error.
-      ret = @conn.get concat_url url
+      ret = send_get_request(@conn, ["/v1/health/service/#{s}"], options, custom_params)
       JSON.parse(ret.body).map { |service| OpenStruct.new service }
-    rescue Faraday::ClientError
-      raise Diplomat::PathNotFound
     end
-    # rubocop:enable PerceivedComplexity, CyclomaticComplexity, AbcSize
+    # 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
-    # rubocop:disable AbcSize
-    def state(s, options = nil)
-      url = ["/v1/health/state/#{s}"]
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-      url << use_named_parameter('near', options[:near]) if options && options[:near]
+    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]
 
-      # If the request fails, it's probably due to a bad path
-      # so return a PathNotFound error.
-      ret = @conn.get concat_url url
+      ret = send_get_request(@conn, ["/v1/health/state/#{s}"], options, custom_params)
       JSON.parse(ret.body).map { |status| OpenStruct.new status }
-    rescue Faraday::ClientError
-      raise Diplomat::PathNotFound
     end
-    # rubocop:enable AbcSize
 
     # Convenience method to get services in any state
     def any

data/lib/diplomat/kv.rb

@@ -40,24 +40,26 @@ module Diplomat
     #   - 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, CyclomaticComplexity, AbcSize, LineLength
-    def get(key, options = nil, not_found = :reject, found = :return)
-      @key = key
+    # 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
-
-      url = ["/v1/kv/#{@key}"]
-      url += recurse_get(@options)
-      url += check_acl_token
-      url += use_consistency(@options)
-      url += dc(@options)
-      url += keys(@options)
-      url += separator(@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
 
-      # 404s OK using this connection
-      raw = @conn_no_err.get concat_url url
+      raw = send_get_request(@conn_no_err, ["/v1/kv/#{@key}"], options, custom_params)
       if raw.status == 404
         case not_found
         when :reject
@@ -88,15 +90,17 @@ module Diplomat
       end
 
       # Wait for first/next value
-      url += use_named_parameter('index', index)
-      @raw = @conn.get do |req|
-        req.url concat_url url
-        req.options.timeout = 86_400
+      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, MethodLength, CyclomaticComplexity, AbcSize, LineLength
+    # rubocop:enable PerceivedComplexity, LineLength, MethodLength, CyclomaticComplexity
 
     # Associate a value with a key
     # @param key [String] the key
@@ -106,25 +110,19 @@ module Diplomat
     # @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)
-    # rubocop:disable MethodLength, AbcSize
-    def put(key, value, options = nil)
+    def put(key, value, options = {})
       @options = options
-      @raw = @conn.put do |req|
-        url = ["/v1/kv/#{key}"]
-        url += check_acl_token
-        url += use_cas(@options)
-        url += dc(@options)
-        url += acquire(@options)
-        req.url concat_url url
-        req.body = value
-      end
+      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)
       if @raw.body.chomp == 'true'
         @key = key
         @value = value
       end
       @raw.body.chomp == 'true'
     end
-    # rubocop:enable MethodLength, AbcSize
 
     # Delete a value by its key
     # @param key [String] the key
@@ -132,14 +130,13 @@ module Diplomat
     # @option options [String] :dc Target datacenter
     # @option options [Boolean] :recurse If to make recursive get or not
     # @return [OpenStruct]
-    def delete(key, options = nil)
+    def delete(key, options = {})
       @key = key
       @options = options
-      url = ["/v1/kv/#{@key}"]
-      url += recurse_get(@options)
-      url += check_acl_token
-      url += dc(@options)
-      @raw = @conn.delete concat_url url
+      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.
@@ -163,42 +160,37 @@ module Diplomat
     # @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 = nil)
+    def txn(value, options = {})
       # Verify the given value for the transaction
       transaction_verification(value)
       # Will return 409 if transaction was rolled back
-      raw = @conn_no_err.put do |req|
-        url = ['/v1/txn']
-        url += check_acl_token
-        url += dc(options)
-        url += transaction_consistency(options)
-
-        req.url concat_url url
-        req.body = JSON.generate(value)
-      end
+      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 && options[:recurse] ? ['recurse'] : []
+      options[:recurse] ? ['recurse'] : []
     end
 
     def dc(options)
-      options && options[:dc] ? use_named_parameter('dc', options[:dc]) : []
+      options[:dc] ? use_named_parameter('dc', options[:dc]) : []
     end
 
     def acquire(options)
-      options && options[:acquire] ? use_named_parameter('acquire', options[:acquire]) : []
+      options[:acquire] ? use_named_parameter('acquire', options[:acquire]) : []
     end
 
     def keys(options)
-      options && options[:keys] ? ['keys'] : []
+      options[:keys] ? ['keys'] : []
     end
 
     def separator(options)
-      options && options[:separator] ? use_named_parameter('separator', options[:separator]) : []
+      options[:separator] ? use_named_parameter('separator', options[:separator]) : []
     end
 
     def transaction_consistency(options)
@@ -247,11 +239,11 @@ module Diplomat
 
     def transaction_return(raw_return, options)
       decoded_return =
-        options && options[:decode_values] == false ? raw_return : decode_transaction(raw_return)
+        options[:decode_values] == false ? raw_return : decode_transaction(raw_return)
       OpenStruct.new decoded_return
     end
 
-    def decode_transaction(transaction) # rubocop:disable Metrics/MethodLength
+    def decode_transaction(transaction)
       return transaction if transaction['Results'].nil? || transaction['Results'].empty?
 
       transaction.tap do |txn|

data/lib/diplomat/lock.rb

@@ -7,31 +7,26 @@ module Diplomat
     # @param key [String] the key
     # @param session [String] the session, generated from Diplomat::Session.create
     # @param value [String] the value for the key
-    # @param options [Hash] :dc string for dc specific query
+    # @param options [Hash] options parameter hash
     # @return [Boolean] If the lock was acquired
-    # rubocop:disable AbcSize
-    def acquire(key, session, value = nil, options = nil)
-      raw = @conn.put do |req|
-        url = ["/v1/kv/#{key}"]
-        url += use_named_parameter('acquire', session)
-        url += check_acl_token
-        url += use_named_parameter('dc', options[:dc]) if options && options[:dc]
-
-        req.url concat_url url
-        req.body = value unless value.nil?
-      end
+    def acquire(key, session, value = nil, options = {})
+      custom_params = []
+      custom_params << use_named_parameter('acquire', session)
+      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
+      custom_params << use_named_parameter('flags', options[:flags]) if options && options[:flags]
+      data = value unless value.nil?
+      raw = send_put_request(@conn, ["/v1/kv/#{key}"], options, data, custom_params)
       raw.body.chomp == 'true'
     end
-    # rubocop:enable AbcSize
 
     # wait to aquire a lock
     # @param key [String] the key
     # @param session [String] the session, generated from Diplomat::Session.create
     # @param value [String] the value for the key
     # @param check_interval [Integer] number of seconds to wait between retries
-    # @param options [Hash] :dc string for dc specific query
+    # @param options [Hash] options parameter hash
     # @return [Boolean] If the lock was acquired
-    def wait_to_acquire(key, session, value = nil, check_interval = 10, options = nil)
+    def wait_to_acquire(key, session, value = nil, check_interval = 10, options = {})
       acquired = false
       until acquired
         acquired = acquire(key, session, value, options)
@@ -45,16 +40,15 @@ module Diplomat
     # @param session [String] the session, generated from Diplomat::Session.create
     # @param options [Hash] :dc string for dc specific query
     # @return [nil]
-    def release(key, session, options = nil)
-      raw = @conn.put do |req|
-        url = ["/v1/kv/#{key}"]
-        url += use_named_parameter('release', session)
-        url += check_acl_token
-        url += use_named_parameter('dc', options[:dc]) if options && options[:dc]
-
-        req.url concat_url url
-      end
+    # rubocop:disable AbcSize
+    def release(key, session, options = {})
+      custom_params = []
+      custom_params << use_named_parameter('release', session)
+      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
+      custom_params << use_named_parameter('flags', options[:flags]) if options && options[:flags]
+      raw = send_put_request(@conn, ["/v1/kv/#{key}"], options, nil, custom_params)
       raw.body
     end
+    # rubocop:enable AbcSize
   end
 end

data/lib/diplomat/maintenance.rb

@@ -7,7 +7,7 @@ module Diplomat
     # @param n [String] the node
     # @param options [Hash] :dc string for dc specific query
     # @return [Hash] { :enabled => true, :reason => 'foo' }
-    def enabled(n, options = nil)
+    def enabled(n, options = {})
       health = Diplomat::Health.new(@conn)
       result = health.node(n, options)
                      .select { |check| check['CheckID'] == '_node_maintenance' }
@@ -25,21 +25,17 @@ module Diplomat
     # @param reason [String] the reason for enabling maintenance mode
     # @param options [Hash] :dc string for dc specific query
     # @return true if call is successful
-    # rubocop:disable AbcSize
-    def enable(enable = true, reason = nil, options = nil)
-      raw = @conn.put do |req|
-        url = ['/v1/agent/maintenance']
-        url << use_named_parameter('enable', enable.to_s)
-        url << use_named_parameter('reason', reason) if reason
-        url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-        req.url concat_url url
-      end
+    def enable(enable = true, reason = nil, options = {})
+      custom_params = []
+      custom_params << use_named_parameter('enable', enable.to_s)
+      custom_params << use_named_parameter('reason', reason) if reason
+      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
+      raw = send_put_request(@conn, ['/v1/agent/maintenance'], options, nil, custom_params)
 
       return_status = raw.status == 200
       raise Diplomat::UnknownStatus, "status #{raw.status}: #{raw.body}" unless return_status
 
       return_status
     end
-    # rubocop:enable AbcSize
   end
 end

data/lib/diplomat/members.rb

@@ -4,9 +4,10 @@ module Diplomat
     @access_methods = [:get]
 
     # Get all members
+    # @param options [Hash] options parameter hash
     # @return [OpenStruct] all data associated with the service
-    def get
-      ret = @conn.get '/v1/agent/members'
+    def get(options = {})
+      ret = send_get_request(@conn, ['/v1/agent/members'], options)
       JSON.parse(ret.body)
     end
   end

data/lib/diplomat/node.rb

@@ -7,47 +7,36 @@ module Diplomat
     # @param key [String] the key
     # @param options [Hash] :dc string for dc specific query
     # @return [OpenStruct] all data associated with the node
-    def get(key, options = nil)
-      url = ["/v1/catalog/node/#{key}"]
-      url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-
-      # If the request fails, it's probably due to a bad path
-      # so return a PathNotFound error.
-      ret = @conn.get concat_url url
+    def get(key, options = {})
+      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
+      ret = send_get_request(@conn, ["/v1/catalog/node/#{key}"], options, custom_params)
       OpenStruct.new JSON.parse(ret.body)
-    rescue Faraday::ClientError
-      raise Diplomat::PathNotFound
     end
 
     # Get all the nodes
     # @param options [Hash] :dc string for dc specific query
     # @return [OpenStruct] the list of all nodes
-    def get_all(options = nil)
-      url = ['/v1/catalog/nodes']
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-
-      ret = @conn.get concat_url url
+    def get_all(options = {})
+      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
+      ret = send_get_request(@conn, ['/v1/catalog/nodes'], options, custom_params)
       JSON.parse(ret.body).map { |service| OpenStruct.new service }
-    rescue Faraday::ClientError
-      raise Diplomat::PathNotFound
     end
 
     # Register a node
     # @param definition [Hash] Hash containing definition of a node to register
+    # @param options [Hash] options parameter hash
     # @return [Boolean]
-    def register(definition, path = '/v1/catalog/register')
-      register = @conn.put path, JSON.dump(definition)
-
+    def register(definition, options = {})
+      register = send_put_request(@conn, ['/v1/catalog/register'], options, definition)
       register.status == 200
     end
 
     # De-register a node (and all associated services and checks)
     # @param definition [Hash] Hash containing definition of a node to de-register
+    # @param options [Hash] options parameter hash
     # @return [Boolean]
-    def deregister(definition, path = '/v1/catalog/deregister')
-      deregister = @conn.put path, JSON.dump(definition)
-
+    def deregister(definition, options = {})
+      deregister = send_put_request(@conn, ['/v1/catalog/deregister'], options, definition)
       deregister.status == 200
     end
   end