diplomat 1.1.0 → 1.2.0

data/lib/diplomat/members.rb

@@ -1,15 +1,13 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul members API endpoint
   class Members < Diplomat::RestClient
-    @access_methods = [ :get ]
+    @access_methods = [:get]
 
     # Get all members
     # @return [OpenStruct] all data associated with the service
     def get
-      ret = @conn.get "/v1/agent/members"
-      return JSON.parse(ret.body)
+      ret = @conn.get '/v1/agent/members'
+      JSON.parse(ret.body)
     end
   end
 end

data/lib/diplomat/node.rb

@@ -1,64 +1,56 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul node API endpoint
   class Node < Diplomat::RestClient
-
     include ApiOptions
 
-    @access_methods = [ :get, :get_all, :register, :deregister ]
+    @access_methods = [:get, :get_all, :register, :deregister]
 
     # Get a node by it's key
     # @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
-
+    def get(key, options = nil)
       url = ["/v1/catalog/node/#{key}"]
       url += check_acl_token
-      url << use_named_parameter('dc', options[:dc]) if options and options[:dc]
+      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.
-      begin
-        ret = @conn.get concat_url url
-      rescue Faraday::ClientError
-        raise Diplomat::PathNotFound
-      end
-      return OpenStruct.new JSON.parse(ret.body)
+      ret = @conn.get concat_url url
+      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 and options[:dc]
-      begin
-        ret = @conn.get concat_url url
-      rescue Faraday::ClientError
-        raise Diplomat::PathNotFound
-      end
-
-      return JSON.parse(ret.body).map { |service| OpenStruct.new service }
+    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
+      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
     # @return [Boolean]
-    def register(definition, path='/v1/catalog/register')
+    def register(definition, path = '/v1/catalog/register')
       register = @conn.put path, JSON.dump(definition)
 
-      return register.status == 200
+      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
     # @return [Boolean]
-    def deregister(definition, path="/v1/catalog/deregister")
+    def deregister(definition, path = '/v1/catalog/deregister')
       deregister = @conn.put path, JSON.dump(definition)
 
-      return deregister.status == 200
+      deregister.status == 200
     end
   end
 end

data/lib/diplomat/nodes.rb

@@ -1,27 +1,25 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # @depreciated
+  # Methods for interacting with the Consul nodes API endpoint
   class Nodes < Diplomat::RestClient
-    @access_methods = [ :get, :get_all ]
+    @access_methods = [:get, :get_all]
 
     # Get all nodes
     # @deprecated Please use Diplomat::Node instead.
     # @return [OpenStruct] all data associated with the nodes in catalog
     def get
-      ret = @conn.get "/v1/catalog/nodes"
-      return JSON.parse(ret.body)
+      ret = @conn.get '/v1/catalog/nodes'
+      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
+      JSON.parse(ret.body).map { |service| OpenStruct.new service }
+    rescue Faraday::ClientError
+      raise Diplomat::PathNotFound
     end
-    
-    def get_all options=nil
-      url = ["/v1/catalog/nodes"]
-      url << use_named_parameter('dc', options[:dc]) if options and options[:dc]
-      begin
-        ret = @conn.get concat_url url
-      rescue Faraday::ClientError
-        raise Diplomat::PathNotFound
-      end
-      return JSON.parse(ret.body).map { |service| OpenStruct.new service }
-    end 
   end
 end

data/lib/diplomat/query.rb

@@ -0,0 +1,124 @@
+module Diplomat
+  # Methods for interacting with the Consul query API endpoint
+  class Query < Diplomat::RestClient
+    include ApiOptions
+
+    @access_methods = [:get, :get_all, :create, :delete, :update, :execute, :explain]
+
+    # Get a prepared query by it's key
+    # @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
+      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
+      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
+
+      parse_body
+    rescue Faraday::ClientError
+      raise Diplomat::QueryAlreadyExists
+    end
+
+    # Delete a prepared query or prepared query template
+    # @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
+
+      ret.status == 200
+    end
+
+    # Update a prepared query or prepared query template
+    # @param key [String] the prepared query ID
+    # @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
+
+      ret.status == 200
+    end
+
+    # Execute a prepared query or prepared query template
+    # @param key [String] the prepared query ID or name
+    # @param options [Hash] prepared query execution options
+    # @option dc [String] :dc Consul datacenter to query
+    # @option near [String] node name to sort the resulting list in ascending order based on the
+    #   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
+      OpenStruct.new JSON.parse(ret.body)
+    rescue Faraday::ClientError
+      raise Diplomat::QueryNotFound
+    end
+    # rubocop:enable PerceivedComplexity, CyclomaticComplexity, AbcSize
+
+    # 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
+      OpenStruct.new JSON.parse(ret.body)
+    rescue Faraday::ClientError
+      raise Diplomat::QueryNotFound
+    end
+  end
+end

data/lib/diplomat/rest_client.rb

@@ -1,14 +1,11 @@
-require 'faraday'
-require 'json'
-
 module Diplomat
+  # Base class for interacting with the Consul RESTful API
   class RestClient
-
     @access_methods = []
 
     # Initialize the fadaray connection
     # @param api_connection [Faraday::Connection,nil] supply mock API Connection
-    def initialize api_connection=nil
+    def initialize(api_connection = nil)
       start_connection api_connection
     end
 
@@ -17,14 +14,14 @@ module Diplomat
     # @param value [String] the value of the parameter
     # @return [Array] the resultant parameter string inside an array.
     def use_named_parameter(name, value)
-      if value then ["#{name}=#{value}"] else [] end
+      value ? ["#{name}=#{value}"] : []
     end
 
     # Assemble a url from an array of parts.
     # @param parts [Array] the url chunks to be assembled
     # @return [String] the resultant url string
-    def concat_url parts
-      if parts.length > 1 then
+    def concat_url(parts)
+      if parts.length > 1
         parts.first + '?' + parts.drop(1).join('&')
       else
         parts.first
@@ -32,8 +29,7 @@ module Diplomat
     end
 
     class << self
-
-      def access_method? meth_id
+      def access_method?(meth_id)
         @access_methods.include? meth_id
       end
 
@@ -78,13 +74,13 @@ module Diplomat
 
     # Build the API Client
     # @param api_connection [Faraday::Connection,nil] supply mock API Connection
-    def start_connection api_connection=nil
+    def start_connection(api_connection = nil)
       @conn = build_connection(api_connection)
       @conn_no_err = build_connection(api_connection, true)
     end
 
-    def build_connection(api_connection, raise_error=false)
-      return api_connection || Faraday.new(Diplomat.configuration.url, Diplomat.configuration.options) do |faraday|
+    def build_connection(api_connection, raise_error = false)
+      api_connection || Faraday.new(Diplomat.configuration.url, Diplomat.configuration.options) do |faraday|
         faraday.adapter  Faraday.default_adapter
         faraday.request  :url_encoded
         faraday.response :raise_error unless raise_error
@@ -95,85 +91,85 @@ module Diplomat
       end
     end
 
-    #Converts k/v data into ruby hash
+    # 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 ?/
+        split_up = item[:key].split('/')
         sub_hash = {}
         temp = nil
         real_size = split_up.size - 1
-        for i in 0..real_size do
-           if i == 0
-              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
+        (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|
-         n = deep_merge(master, h)
-         master = n
+        master = deep_merge(master, h)
       end
       master
     end
+    # rubocop:enable MethodLength, AbcSize
 
     def deep_merge(first, second)
-        merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-        first.merge(second, &merger)
+      merger = proc { |_key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2 }
+      first.merge(second, &merger)
     end
 
     # Parse the body, apply it to the raw attribute
     def parse_body
       return JSON.parse(@raw.body) if @raw.status == 200
-      raise Diplomat::UnknownStatus, "status #{@raw.status}"
+      raise Diplomat::UnknownStatus, "status #{@raw.status}: #{@raw.body}"
     end
 
     # Return @raw with Value fields decoded
     def decode_values
       return @raw if @raw.first.is_a? String
-      @raw.inject([]) do |acc, el|
-        new_el = el.dup
-        new_el["Value"] = (Base64.decode64(el["Value"]) rescue nil)
-        acc << new_el
-        acc
+      @raw.each_with_object([]) do |acc, el|
+        acc['Value'] = Base64.decode64(acc['Value']) rescue nil # rubocop:disable RescueModifier
+        el << acc
+        el
       end
     end
 
     # Get the key/value(s) from the raw output
-    def return_value(nil_values=false, transformation=nil)
+    # rubocop:disable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
+    def return_value(nil_values = false, transformation = nil)
       @value = decode_values
-      if @value.first.is_a? String
-        return @value
-      elsif @value.count == 1
-        @value = @value.first["Value"]
-        @value = transformation.call(@value) if transformation and not @value.nil?
+      return @value if @value.first.is_a? String
+      if @value.count == 1
+        @value = @value.first['Value']
+        @value = transformation.call(@value) if transformation && !@value.nil?
         return @value
       else
         @value = @value.map do |el|
-          el["Value"] = transformation.call(el["Value"]) if transformation and not el["Value"].nil?
-          { :key => el["Key"], :value => el["Value"] } if el["Value"] or nil_values
+          el['Value'] = transformation.call(el['Value']) if transformation && !el['Value'].nil?
+          { key: el['Key'], value: el['Value'] } if el['Value'] || nil_values
         end.compact
       end
     end
+    # rubocop:enable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
 
     # Get the name and payload(s) from the raw output
     def return_payload
       @value = @raw.map do |e|
-        { :name => e["Name"],
-          :payload => (Base64.decode64(e["Payload"]) unless e["Payload"].nil?) }
+        { name: e['Name'],
+          payload: (Base64.decode64(e['Payload']) unless e['Payload'].nil?) }
       end
     end
-
   end
 end