diplomat 2.0.5 → 2.1.0

data/lib/diplomat/nodes.rb

@@ -6,20 +6,17 @@ module Diplomat
 
     # Get all nodes
     # @deprecated Please use Diplomat::Node instead.
+    # @param options [Hash] options parameter hash
     # @return [OpenStruct] all data associated with the nodes in catalog
-    def get
-      ret = @conn.get '/v1/catalog/nodes'
+    def get(options = {})
+      ret = send_get_request(@conn, ['/v1/catalog/nodes'], options)
       JSON.parse(ret.body)
     end
 
-    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
   end
 end

data/lib/diplomat/query.rb

@@ -7,44 +7,28 @@ module Diplomat
     # @param key [String] the prepared query ID
     # @param options [Hash] :dc string for dc specific query
     # @return [OpenStruct] all data associated with the prepared query
-    def get(key, options = nil)
-      url = ["/v1/query/#{key}"]
-      url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-
-      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/query/#{key}"], options, custom_params)
       JSON.parse(ret.body).map { |query| OpenStruct.new query }
-    rescue Faraday::ClientError
-      raise Diplomat::QueryNotFound
     end
 
     # Get all prepared queries
     # @param options [Hash] :dc Consul datacenter to query
     # @return [OpenStruct] the list of all prepared queries
-    def get_all(options = nil)
-      url = ['/v1/query']
-      url += check_acl_token
-      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/query'], options, custom_params)
       JSON.parse(ret.body).map { |query| OpenStruct.new query }
-    rescue Faraday::ClientError
-      raise Diplomat::PathNotFound
     end
 
     # Create a prepared query or prepared query template
     # @param definition [Hash] Hash containing definition of prepared query
     # @param options [Hash] :dc Consul datacenter to query
     # @return [String] the ID of the prepared query created
-    def create(definition, options = nil)
-      url = ['/v1/query']
-      url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-      @raw = @conn.post do |req|
-        req.url concat_url url
-        req.body = JSON.dump(definition)
-      end
-
+    def create(definition, options = {})
+      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
+      @raw = send_post_request(@conn, ['/v1/query'], options, definition, custom_params)
       parse_body
     rescue Faraday::ClientError
       raise Diplomat::QueryAlreadyExists
@@ -54,12 +38,9 @@ module Diplomat
     # @param key [String] the prepared query ID
     # @param options [Hash] :dc Consul datacenter to query
     # @return [Boolean]
-    def delete(key, options = nil)
-      url = ["/v1/query/#{key}"]
-      url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-      ret = @conn.delete concat_url url
-
+    def delete(key, options = {})
+      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
+      ret = send_delete_request(@conn, ["/v1/query/#{key}"], options, custom_params)
       ret.status == 200
     end
 
@@ -68,16 +49,9 @@ module Diplomat
     # @param definition [Hash] Hash containing updated definition of prepared query
     # @param options [Hash] :dc Consul datacenter to query
     # @return [Boolean]
-    def update(key, definition, options = nil)
-      url = ["/v1/query/#{key}"]
-      url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-      json_definition = JSON.dump(definition)
-      ret = @conn.put do |req|
-        req.url concat_url url
-        req.body = json_definition
-      end
-
+    def update(key, definition, options = {})
+      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
+      ret = send_put_request(@conn, ["/v1/query/#{key}"], options, definition, custom_params)
       ret.status == 200
     end
 
@@ -89,34 +63,25 @@ module Diplomat
     #   estimated round trip time from that node
     # @option limit [Integer] to limit the size of the return list to the given number of results
     # @return [OpenStruct] the list of results from the prepared query or prepared query template
-    # rubocop:disable PerceivedComplexity, CyclomaticComplexity, AbcSize
-    def execute(key, options = nil)
-      url = ["/v1/query/#{key}/execute"]
-      url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-      url << use_named_parameter('near', options[:near]) if options && options[:near]
-      url << use_named_parameter('limit', options[:limit]) if options && options[:limit]
-
-      ret = @conn.get concat_url url
+    # rubocop:disable PerceivedComplexity
+    def execute(key, 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]
+      custom_params << use_named_parameter('limit', options[:limit]) if options[:limit]
+      ret = send_get_request(@conn, ["/v1/query/#{key}/execute"], options, custom_params)
       OpenStruct.new JSON.parse(ret.body)
-    rescue Faraday::ClientError
-      raise Diplomat::QueryNotFound
     end
-    # rubocop:enable PerceivedComplexity, CyclomaticComplexity, AbcSize
+    # rubocop:enable PerceivedComplexity
 
     # Get the fully rendered query template
     # @param key [String] the prepared query ID or name
     # @param options [Hash] :dc Consul datacenter to query
     # @return [OpenStruct] the list of results from the prepared query or prepared query template
-    def explain(key, options = nil)
-      url = ["/v1/query/#{key}/explain"]
-      url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-
-      ret = @conn.get concat_url url
+    def explain(key, options = {})
+      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
+      ret = send_get_request(@conn, ["/v1/query/#{key}/explain"], options, custom_params)
       OpenStruct.new JSON.parse(ret.body)
-    rescue Faraday::ClientError
-      raise Diplomat::QueryNotFound
     end
   end
 end

data/lib/diplomat/rest_client.rb

@@ -1,3 +1,5 @@
+require 'deep_merge'
+
 module Diplomat
   # Base class for interacting with the Consul RESTful API
   class RestClient
@@ -30,6 +32,7 @@ module Diplomat
     # @param parts [Array] the url chunks to be assembled
     # @return [String] the resultant url string
     def concat_url(parts)
+      parts.reject!(&:empty?)
       if parts.length > 1
         parts.first + '?' + parts.drop(1).join('&')
       else
@@ -102,42 +105,10 @@ module Diplomat
     end
 
     # Converts k/v data into ruby hash
-    # rubocop:disable MethodLength, AbcSize
     def convert_to_hash(data)
-      collection = []
-      master     = {}
-      data.each do |item|
-        split_up = item[:key].split('/')
-        sub_hash = {}
-        temp = nil
-        real_size = split_up.size - 1
-        (0..real_size).each do |i|
-          if i.zero?
-            temp = {}
-            sub_hash[split_up[i]] = temp
-            next
-          end
-          if i == real_size
-            temp[split_up[i]] = item[:value]
-          else
-            new_h = {}
-            temp[split_up[i]] = new_h
-            temp = new_h
-          end
-        end
-        collection << sub_hash
-      end
-
-      collection.each do |h|
-        master = deep_merge(master, h)
-      end
-      master
-    end
-    # rubocop:enable MethodLength, AbcSize
-
-    def deep_merge(first, second)
-      merger = proc { |_key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2 }
-      first.merge(second, &merger)
+      data.map do |item|
+        item[:key].split('/').reverse.reduce(item[:value]) { |h, v| { v => h } }
+      end.reduce(:deep_merge)
     end
 
     # Parse the body, apply it to the raw attribute
@@ -163,7 +134,7 @@ module Diplomat
     end
 
     # Get the key/value(s) from the raw output
-    # rubocop:disable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
+    # rubocop:disable PerceivedComplexity
     def return_value(nil_values = false, transformation = nil, return_hash = false)
       @value = decode_values
       return @value if @value.first.is_a? String
@@ -179,7 +150,7 @@ module Diplomat
         end.compact
       end
     end
-    # rubocop:enable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
+    # rubocop:enable PerceivedComplexity
 
     # Get the name and payload(s) from the raw output
     def return_payload
@@ -189,22 +160,88 @@ module Diplomat
       end
     end
 
-    def check_acl_token
-      use_named_parameter('token', configuration.acl_token)
-    end
-
     def use_cas(options)
       options ? use_named_parameter('cas', options[:cas]) : []
     end
 
     def use_consistency(options)
-      options && options[:consistency] ? [options[:consistency].to_s] : []
+      options[:consistency] ? [options[:consistency].to_s] : []
+    end
+
+    # rubocop:disable PerceivedComplexity
+    # TODO: Migrate all custom params in options
+    def parse_options(options)
+      headers = nil
+      query_params = []
+      url_prefix = nil
+      consistency = []
+
+      # Parse options used as header
+      headers = { 'X-Consul-Token': configuration.acl_token } if configuration.acl_token
+      headers = { 'X-Consul-Token': options[:token] } if options[:token]
+
+      # Parse options used as query params
+      consistency = 'stale' if options[:stale]
+      consistency = 'leader' if options[:leader]
+      consistency = 'consistent' if options[:consistent]
+      query_params << consistency
+
+      # Parse url host
+      url_prefix = options[:http_addr] if options[:http_addr]
+      { query_params: query_params, headers: headers, url_prefix: url_prefix }
+    end
+    # rubocop:enable PerceivedComplexity
+
+    def send_get_request(connection, url, options, custom_params = nil)
+      rest_options = parse_options(options)
+      url += rest_options[:query_params]
+      url += custom_params unless custom_params.nil?
+      begin
+        connection.get do |req|
+          req.url rest_options[:url_prefix] ? rest_options[:url_prefix] + concat_url(url) : concat_url(url)
+          rest_options[:headers].map { |k, v| req.headers[k.to_sym] = v } unless rest_options[:headers].nil?
+          req.options.timeout = options[:timeout] if options[:timeout]
+        end
+      rescue Faraday::ClientError => e
+        raise Diplomat::PathNotFound, e
+      end
+    end
+
+    def send_put_request(connection, url, options, data, custom_params = nil)
+      rest_options = parse_options(options)
+      url += rest_options[:query_params]
+      url += custom_params unless custom_params.nil?
+      connection.put do |req|
+        req.url rest_options[:url_prefix] ? rest_options[:url_prefix] + concat_url(url) : concat_url(url)
+        rest_options[:headers].map { |k, v| req.headers[k.to_sym] = v } unless rest_options[:headers].nil?
+        req.body = JSON.dump(data) unless data.nil?
+      end
+    end
+
+    def send_post_request(connection, url, options, data, custom_params = nil)
+      rest_options = parse_options(options)
+      url += rest_options[:query_params]
+      url += custom_params unless custom_params.nil?
+      connection.post do |req|
+        req.url rest_options[:url_prefix] ? rest_options[:url_prefix] + concat_url(url) : concat_url(url)
+        rest_options[:headers].map { |k, v| req.headers[k.to_sym] = v } unless rest_options[:headers].nil?
+        req.body = JSON.dump(data) unless data.nil?
+      end
+    end
+
+    def send_delete_request(connection, url, options, custom_params = nil)
+      rest_options = parse_options(options)
+      url += rest_options[:query_params]
+      url += custom_params unless custom_params.nil?
+      connection.delete do |req|
+        req.url rest_options[:url_prefix] ? rest_options[:url_prefix] + concat_url(url) : concat_url(url)
+        rest_options[:headers].map { |k, v| req.headers[k.to_sym] = v } unless rest_options[:headers].nil?
+      end
     end
 
     # Mapping for valid key/value store transaction verbs and required parameters
     #
     # @return [Hash] valid key/store transaction verbs and required parameters
-    # rubocop:disable MethodLength
     def valid_transaction_verbs
       {
         'set' => %w[Key Value],
@@ -220,7 +257,6 @@ module Diplomat
         'delete-cas' => %w[Key Index]
       }
     end
-    # rubocop:enable MethodLength
 
     # Key/value store transactions that require that a value be set
     #

data/lib/diplomat/service.rb

@@ -1,5 +1,5 @@
 module Diplomat
-  # Methods for interacting with the Consul serivce API endpoint.
+  # Methods for interacting with the Consul service API endpoint.
   class Service < Diplomat::RestClient
     @access_methods = %i[get get_all register deregister register_external deregister_external maintenance]
 
@@ -7,33 +7,21 @@ module Diplomat
     # @param key [String] the key
     # @param scope [Symbol] :first or :all results
     # @param options [Hash] options parameter hash
-    # @option wait [Integer] :wait string for wait time
-    # @option index [String] :index for index of last query
-    # @option dc [String] :dc data center to make request for
-    # @option tag [String] :tag service tag to get
     # @param meta [Hash] output structure containing header information about the request (index)
     # @return [OpenStruct] all data associated with the service
-    # rubocop:disable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
-    def get(key, scope = :first, options = nil, meta = nil)
-      url = ["/v1/catalog/service/#{key}"]
-      url += check_acl_token
-      url << use_named_parameter('wait', options[:wait]) if options && options[:wait]
-      url << use_named_parameter('index', options[:index]) if options && options[:index]
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-      url << use_named_parameter('tag', options[:tag]) if options && options[:tag]
-
-      # If the request fails, it's probably due to a bad path
-      # so return a PathNotFound error.
-      begin
-        ret = @conn.get concat_url url
-      rescue Faraday::ClientError => e
-        raise Diplomat::PathNotFound, e
-      end
+    # rubocop:disable PerceivedComplexity
+    def get(key, scope = :first, options = {}, meta = nil)
+      custom_params = []
+      custom_params << use_named_parameter('wait', options[:wait]) if options[:wait]
+      custom_params << use_named_parameter('index', options[:index]) if options[:index]
+      custom_params << use_named_parameter('dc', options[:dc]) if options[:dc]
+      custom_params << use_named_parameter('tag', options[:tag]) if options[:tag]
 
+      ret = send_get_request(@conn, ["/v1/catalog/service/#{key}"], options, custom_params)
       if meta && ret.headers
-        meta[:index] = ret.headers['x-consul-index']
-        meta[:knownleader] = ret.headers['x-consul-knownleader']
-        meta[:lastcontact] = ret.headers['x-consul-lastcontact']
+        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
 
       if scope == :all
@@ -42,77 +30,67 @@ module Diplomat
         OpenStruct.new JSON.parse(ret.body).first
       end
     end
-    # rubocop:enable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
+    # rubocop:enable PerceivedComplexity
 
     # Get all the services
     # @param options [Hash] :dc Consul datacenter to query
     # @return [OpenStruct] the list of all services
-    def get_all(options = nil)
-      url = ['/v1/catalog/services']
-      url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options && options[:dc]
-      begin
-        ret = @conn.get concat_url url
-      rescue Faraday::ClientError
-        raise Diplomat::PathNotFound
-      end
-
+    def get_all(options = {})
+      custom_params = options[:dc] ? use_named_parameter('dc', options[:dc]) : nil
+      ret = send_get_request(@conn, ['/v1/catalog/services'], options, custom_params)
       OpenStruct.new JSON.parse(ret.body)
     end
 
     # Register a service
     # @param definition [Hash] Hash containing definition of service
+    # @param options [Hash] options parameter hash
     # @return [Boolean]
-    def register(definition, path = '/v1/agent/service/register')
-      url = [path]
-      url += check_acl_token
-      json_definition = JSON.dump(definition)
-      register = @conn.put concat_url(url), json_definition
+    def register(definition, options = {})
+      url = options[:path] || ['/v1/agent/service/register']
+      register = send_put_request(@conn, url, options, definition)
       register.status == 200
     end
 
     # De-register a service
     # @param service_name [String] Service name to de-register
+    # @param options [Hash] options parameter hash
     # @return [Boolean]
-    def deregister(service_name)
-      url = ["/v1/agent/service/deregister/#{service_name}"]
-      url += check_acl_token
-      deregister = @conn.put concat_url(url)
+    def deregister(service_name, options = {})
+      deregister = send_put_request(@conn, ["/v1/agent/service/deregister/#{service_name}"], options, nil)
       deregister.status == 200
     end
 
     # Register an external service
     # @param definition [Hash] Hash containing definition of service
+    # @param options [Hash] options parameter hash
     # @return [Boolean]
-    def register_external(definition)
-      register(definition, '/v1/catalog/register')
+    def register_external(definition, options = {})
+      register = send_put_request(@conn, ['/v1/catalog/register'], options, definition)
+      register.status == 200
     end
 
     # Deregister an external service
     # @param definition [Hash] Hash containing definition of service
+    # @param options [Hash] options parameter hash
     # @return [Boolean]
-    def deregister_external(definition)
-      json_definition = JSON.dump(definition)
-      deregister = @conn.put '/v1/catalog/deregister', json_definition
+    def deregister_external(definition, options = {})
+      deregister = send_put_request(@conn, ['/v1/catalog/deregister'], options, definition)
       deregister.status == 200
     end
 
     # Enable or disable maintenance for a service
-    # @param [Hash] opts the options for enabling or disabling maintenance for a service
+    # @param service_id [String] id of the service
+    # @param options [Hash] opts the options for enabling or disabling maintenance for a service
     # @options opts [Boolean] :enable (true) whether to enable or disable maintenance
     # @options opts [String] :reason reason for the service maintenance
     # @raise [Diplomat::PathNotFound] if the request fails
     # @return [Boolean] if the request was successful or not
     def maintenance(service_id, options = { enable: true })
-      url = ["/v1/agent/service/maintenance/#{service_id}"]
-      url += check_acl_token
-      url << ["enable=#{options[:enable]}"]
-      url << ["reason=#{options[:reason].split(' ').join('+')}"] if options && options[:reason]
-      begin
-        maintenance = @conn.put concat_url(url)
-      rescue Faraday::ClientError
-        raise Diplomat::PathNotFound
-      end
+      custom_params = []
+      custom_params << ["enable=#{options[:enable]}"]
+      custom_params << ["reason=#{options[:reason].split(' ').join('+')}"] if options[:reason]
+      maintenance = send_put_request(@conn, ["/v1/agent/service/maintenance/#{service_id}"],
+                                     options, nil, custom_params)
       maintenance.status == 200
     end
   end