diplomat 1.1.0 → 1.2.0

data/lib/diplomat/health.rb

@@ -1,106 +1,101 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul health API endpoint
   class Health < Diplomat::RestClient
-    @access_methods = [ :node, :checks, :service, :state,
-                        :unknown, :passing, :warning, :critical ]
+    @access_methods = [: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=nil
+    def node(n, options = nil)
       url = ["/v1/health/node/#{n}"]
-      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 JSON.parse(ret.body)
+      ret = @conn.get concat_url url
+      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
+    def checks(s, options = nil)
       url = ["/v1/health/checks/#{s}"]
-      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 JSON.parse(ret.body)
+      ret = @conn.get concat_url url
+      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] :state string for specific service state
+    # @param options [Hash] :passing boolean to return only checks in passing state
     # @param options [Hash] :tag string for specific tag
     # @return [OpenStruct] all data associated with the node
-    def service s, options=nil
+    # rubocop:disable PerceivedComplexity, CyclomaticComplexity, AbcSize
+    def service(s, options = nil)
       url = ["/v1/health/service/#{s}"]
-      url << use_named_parameter('dc', options[:dc]) if options and options[:dc]
-      url << options[:state] if options and options[:state]
-      url << use_named_parameter('tag', options[:tag]) if options and options[:tag]
+      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]
 
       # 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 JSON.parse(ret.body)
+      # so return a PathNotFound error.
+      ret = @conn.get concat_url url
+      JSON.parse(ret.body).map { |service| OpenStruct.new service }
+    rescue Faraday::ClientError
+      raise Diplomat::PathNotFound
     end
+    # rubocop:enable PerceivedComplexity, CyclomaticComplexity, AbcSize
 
     # Get service health
-    # @param s [String] the state ("unknown", "passing", "warning", or "critical")
+    # @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=nil
-       url = ["/v1/health/state/#{s}"]
-       url << use_named_parameter('dc', options[:dc]) if options and 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 JSON.parse(ret.body)
+    # 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]
 
+      # If the request fails, it's probably due to a bad path
+      # so return a PathNotFound error.
+      ret = @conn.get concat_url url
+      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 unknown state
-    def unknown
-      state("unknown")
+    # 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")
+      state('passing')
     end
 
     # Convenience method to get services in warning state
     def warning
-      state("warning")
+      state('warning')
     end
 
     # Convenience method to get services in critical state
     def critical
-      state("critical")
+      state('critical')
     end
   end
 end

data/lib/diplomat/kv.rb

@@ -1,12 +1,9 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul KV API endpoint
   class Kv < Diplomat::RestClient
-
     include ApiOptions
 
-    @access_methods = [ :get, :put, :delete ]
+    @access_methods = [:get, :put, :delete]
     attr_reader :key, :value, :raw
 
     # Get a value by its key, potentially blocking for the first or next value
@@ -18,7 +15,8 @@ module Diplomat
     # @option options [Boolean] :keys Only return key names.
     # @option options [Boolean] :modify_index Only return ModifyIndex 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 [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
@@ -43,7 +41,8 @@ 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
-    def get key, options=nil, not_found=:reject, found=:return
+    # rubocop:disable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize, LineLength
+    def get(key, options = nil, not_found = :reject, found = :return)
       @key = key
       @options = options
 
@@ -55,53 +54,48 @@ module Diplomat
       url += keys(@options)
       url += separator(@options)
 
-      return_nil_values = (@options and @options[:nil_values])
-      transformation = (@options and @options[:transformation] and @options[:transformation].methods.find_index(:call)) ? @options[:transformation] : nil
+      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
       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"]
+        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
-            if @options and @options[:modify_index]
-              return @raw.first['ModifyIndex']
-            end
-            if @options and @options[:decode_values]
-              return decode_values
-            end
-            if @options and @options[:convert_to_hash]
-              return convert_to_hash(return_value(return_nil_values, transformation))
-            end
-            return return_value(return_nil_values, transformation)
-          when :wait
-            index = raw.headers["x-consul-index"]
+        when :reject
+          raise Diplomat::KeyAlreadyExists, key
+        when :return
+          @raw = raw
+          @raw = parse_body
+          return @raw.first['ModifyIndex'] if @options && @options[:modify_index]
+          return decode_values if @options && @options[:decode_values]
+          return convert_to_hash(return_value(return_nil_values, transformation)) 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}"
+        raise Diplomat::UnknownStatus, "status #{raw.status}: #{raw.body}"
       end
 
       # Wait for first/next value
-      url += use_named_parameter("index", index)
+      url += use_named_parameter('index', index)
       @raw = @conn.get do |req|
         req.url concat_url url
-        req.options.timeout = 86400
+        req.options.timeout = 86_400
       end
-      parse_body
+      @raw = parse_body
       return_value(return_nil_values, transformation)
     end
+    # rubocop:enable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize, LineLength
 
     # Associate a value with a key
     # @param key [String] the key
@@ -110,7 +104,8 @@ module Diplomat
     # @option options [Integer] :cas The modify index
     # @option options [String] :dc Target datacenter
     # @return [Bool] Success or failure of the write (can fail in c-a-s mode)
-    def put key, value, options=nil
+    # rubocop:disable MethodLength, AbcSize
+    def put(key, value, options = nil)
       @options = options
       @raw = @conn.put do |req|
         url = ["/v1/kv/#{key}"]
@@ -120,12 +115,11 @@ module Diplomat
         req.url concat_url url
         req.body = value
       end
-      if @raw.body == "true"
-        @key   = key
-        @value = value
-      end
-      @raw.body == "true"
+      @key = key if @raw.body == 'true'
+      @value = value if @raw.body == 'true'
+      @raw.body == 'true'
     end
+    # rubocop:enable MethodLength, AbcSize
 
     # Delete a value by its key
     # @param key [String] the key
@@ -133,7 +127,7 @@ 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 = nil)
       @key = key
       @options = options
       url = ["/v1/kv/#{@key}"]
@@ -146,19 +140,19 @@ module Diplomat
     private
 
     def recurse_get(options)
-      if options && options[:recurse] == true then ['recurse'] else [] end
+      options && options[:recurse] ? ['recurse'] : []
     end
 
     def dc(options)
-      if options && options[:dc] then use_named_parameter("dc", options[:dc]) else [] end
+      options && options[:dc] ? use_named_parameter('dc', options[:dc]) : []
     end
 
     def keys(options)
-      if options && options[:keys] == true then ['keys'] else [] end
+      options && options[:keys] ? ['keys'] : []
     end
 
     def separator(options)
-      if options && options[:separator] then use_named_parameter("separator", options[:separator]) else [] end
+      options && options[:separator] ? use_named_parameter('separator', options[:separator]) : []
     end
   end
 end

data/lib/diplomat/lock.rb

@@ -1,22 +1,22 @@
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul lock API endpoint
   class Lock < Diplomat::RestClient
-
     include ApiOptions
 
-    @access_methods = [ :acquire, :wait_to_acquire, :release ]
+    @access_methods = [:acquire, :wait_to_acquire, :release]
 
     # Acquire 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 options [Hash] :dc string for dc specific query
     # @return [Boolean] If the lock was acquired
-    def acquire key, session, value=nil
+    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?
@@ -29,30 +29,32 @@ module Diplomat
     # @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
     # @return [Boolean] If the lock was acquired
-    def wait_to_acquire key, session, value=nil, check_interval=10
+    def wait_to_acquire(key, session, value = nil, check_interval = 10, options = nil)
       acquired = false
-      while !acquired
-        acquired = self.acquire key, session, value
-        sleep(check_interval) if !acquired
+      until acquired
+        acquired = acquire(key, session, value, options)
+        sleep(check_interval) unless acquired
         return true if acquired
       end
     end
 
-
     # Release a lock
     # @param key [String] the key
     # @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
+    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
-      return raw.body
+      raw.body
     end
   end
 end

data/lib/diplomat/maintenance.rb

@@ -1,23 +1,21 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # Methods to interact with the Consul maintenance API endpoint
   class Maintenance < Diplomat::RestClient
-    @access_methods = [ :enabled, :enable]
+    @access_methods = [:enabled, :enable]
 
     # Get the maintenance state of a host
     # @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 = nil)
       health = Diplomat::Health.new(@conn)
-      result = health.node(n, options).
-        select { |check| check['CheckID'] == '_node_maintenance' }
+      result = health.node(n, options)
+                     .select { |check| check['CheckID'] == '_node_maintenance' }
 
-      if result.size > 0
-        { :enabled => true, :reason => result.first['Notes'] }
+      if result.empty?
+        { enabled: false, reason: nil }
       else
-        { :enabled => false, :reason => nil }
+        { enabled: true, reason: result.first['Notes'] }
       end
     end
 
@@ -27,21 +25,20 @@ 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
-    def enable enable=true, reason=nil, options=nil
+    # rubocop:disable AbcSize
+    def enable(enable = true, reason = nil, options = nil)
       raw = @conn.put do |req|
-        url = ["/v1/agent/maintenance"]
+        url = ['/v1/agent/maintenance']
         url << use_named_parameter('enable', enable.to_s)
-        url << use_named_parameter('reason', reason) unless reason.nil?
-        url << use_named_parameter('dc', options[:dc]) if options and options[:dc]
+        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
 
-      if raw.status == 200
-        @raw = raw
-        return true
-      else
-        raise Diplomat::UnknownStatus, "status #{raw.status}"
-      end
+      return_status = raw.status == 200
+      raise Diplomat::UnknownStatus, "status #{raw.status}: #{raw.body}" unless return_status
+      return_status
     end
+    # rubocop:enable AbcSize
   end
 end