diplomat 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 781ef66fd58770259245d9d3624499232db1cdbe
-  data.tar.gz: cffd83536d1936f5f1189129fbf1d238a1555c8b
+  metadata.gz: 6feb74783d35459eb7f08e895688ffe20ed975b1
+  data.tar.gz: 21a8d4d02987f5d6298414c047fa86758968dd58
 SHA512:
-  metadata.gz: b5b01504b9b8c7f8aac4f08e13837a36018ea7005a198e4d0dfba97568ff65f3417ed8ef33d061f2a2a2ba5adb421ad7ef691018f0e7883a714a798e0a823f1d
-  data.tar.gz: 38034ad0d2add4cbb6368ba65af19c6ee066daa56b39fa8a3f12674d269240527e75765fd4648c17b2ca3b4de556299ed556e55d27475e6e72dc59a30b26e21e
+  metadata.gz: 709cdba5352b6c9f045065e8d335d4ce00d3b0065d0dbba39b83ed1d0ba8ea873088de4dd7b998fd127682dcd40104d5726daf91e9af40a45c13a2837c8240f9
+  data.tar.gz: 0621ad4ca2152759913a2e82f6daf650e2044bb2083f66b028caa73bac19e38f7cefcf044f1e73d79c4edbf1b1a9d1a2e40d0d82b43be58f51d91064d9d50f45

data/features/step_definitions/setup_diplomat.rb

@@ -1,22 +1,24 @@
 require 'diplomat'
-Given /^I am setting up a default diplomat$/ do
+
+Given 'I am setting up a default diplomat' do
 end
 
-Given /^I am setting up a custom diplomat$/ do
-  class StubMiddleware
+Given 'I am setting up a custom diplomat' do
+  class StubMiddleware # :nodoc:
     def initialize(app, options = {})
       @app = app
       @options = options
     end
+
     def call(env)
       @app.call(env)
     end
   end
 
-  expect {
+  expect do
     Diplomat.configure do |config|
-      config.url = "http://localhost:8500"
+      config.url = 'http://localhost:8500'
       config.middleware = StubMiddleware
     end
-  }.to_not raise_error
+  end.to_not raise_error
 end

data/features/step_definitions/test_key_value.rb

@@ -1,7 +1,7 @@
-Then /^I should be able to get and put keys$/ do
+Then 'I should be able to get and put keys' do
   # High-fructose Corn Syrup
   Diplomat.put('drink', 'Irn Bru')
-  expect(Diplomat.get('drink')).to eq("Irn Bru")
+  expect(Diplomat.get('drink')).to eq('Irn Bru')
 
   # Sugar
   Diplomat::Kv.put('cake', 'Sponge')

data/lib/diplomat.rb

@@ -1,7 +1,10 @@
-module Diplomat
+require 'json'
+require 'base64'
+require 'faraday'
 
+# Top level namespace ensures all required libraries are included and initializes the gem configration.
+module Diplomat
   class << self
-
     attr_accessor :root_path
     attr_accessor :lib_path
     attr_accessor :configuration
@@ -20,16 +23,15 @@ module Diplomat
 
   raise 'Diplomat only supports ruby >= 2.0.0' unless RUBY_VERSION.to_f >= 2.0
 
-  self.root_path = File.expand_path "..", __FILE__
-  self.lib_path = File.expand_path "../diplomat", __FILE__
+  self.root_path = File.expand_path '..', __FILE__
+  self.lib_path = File.expand_path '../diplomat', __FILE__
 
-  require_libs "configuration", "rest_client", "api_options", "kv", "datacenter",
-    "service", "members", "node", "nodes", "check", "health", "session", "lock",
-    "error", "event", "acl", "maintenance"
+  require_libs 'configuration', 'rest_client', 'api_options', 'kv', 'datacenter',
+               'service', 'members', 'node', 'nodes', 'check', 'health', 'session', 'lock',
+               'error', 'event', 'acl', 'maintenance', 'query'
   self.configuration ||= Diplomat::Configuration.new
 
   class << self
-
     # Build optional configuration by yielding a block to configure
     # @yield [Diplomat::Configuration]
     def configure
@@ -46,7 +48,15 @@ module Diplomat
     # @param &block block to send to Kv
     # @return [Object]
     def method_missing(name, *args, &block)
-      Diplomat::Kv.new.send(name, *args, &block)
+      Diplomat::Kv.new.send(name, *args, &block) || super
+    end
+
+    # Make `respond_to_missing?` fall back to super
+    #
+    # @param meth_id [Symbol] the tested method
+    # @oaram with_private if private methods should be tested too
+    def respond_to_missing?(meth_id, with_private = false)
+      access_method?(meth_id) || super
     end
   end
 end

data/lib/diplomat/acl.rb

@@ -1,94 +1,92 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul ACL API endpoint
   class Acl < Diplomat::RestClient
-
     include ApiOptions
 
-    @access_methods = [ :list, :info, :create, :destroy, :update ]
+    @access_methods = [:list, :info, :create, :destroy, :update]
     attr_reader :id, :type, :acl
 
     # Get Acl info by ID
     # @param id [String] ID of the Acl to get
     # @return [Hash]
-    def info id, options=nil, not_found=:reject, found=:return
+    # rubocop:disable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
+    def info(id, options = nil, not_found = :reject, found = :return)
       @id = id
       @options = options
-
-      url = ["/v1/acl/info/#{@id}"]
-      url += check_acl_token
-      url += use_consistency(@options)
+      url = ["/v1/acl/info/#{id}"]
+      url << check_acl_token
+      url << use_consistency(options)
 
       raw = @conn_no_err.get concat_url url
-      if raw.status == 200 and raw.body != "null"
+      if raw.status == 200 && raw.body != 'null'
         case found
-          when :reject
-            raise Diplomat::AclAlreadyExists, @id
-          when :return
-            @raw = raw
-            return parse_body
+        when :reject
+          raise Diplomat::AclAlreadyExists, id
+        when :return
+          @raw = raw
+          return parse_body
         end
-      elsif raw.status == 200 and raw.body == "null"
+      elsif raw.status == 200 && raw.body == 'null'
         case not_found
-          when :reject
-            raise Diplomat::AclNotFound, @id
-          when :return
-            return nil
+        when :reject
+          raise Diplomat::AclNotFound, id
+        when :return
+          return nil
         end
       else
-        raise Diplomat::UnknownStatus, "status #{raw.status}"
+        raise Diplomat::UnknownStatus, "status #{raw.status}: #{raw.body}"
       end
     end
+    # rubocop:enable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
 
     # List all Acls
     # @return [List] list of [Hash] of Acls
     def list
-      url = ["/v1/acl/list"]
+      url = ['/v1/acl/list']
       url += check_acl_token
       @raw = @conn_no_err.get concat_url url
-      return parse_body
+      parse_body
     end
 
     # Update an Acl definition, create if not present
     # @param value [Hash] Acl definition, ID field is mandatory
     # @return [Hash] The result Acl
-    def update value
+    def update(value)
       raise Diplomat::IdParameterRequired unless value['ID']
 
       @raw = @conn.put do |req|
-        url = ["/v1/acl/update"]
+        url = ['/v1/acl/update']
         url += check_acl_token
         url += use_cas(@options)
         req.url concat_url url
         req.body = value.to_json
       end
-      return parse_body
+      parse_body
     end
 
     # Create an Acl definition
     # @param value [Hash] Acl definition, ID field is mandatory
     # @return [Hash] The result Acl
-    def create value
+    def create(value)
       @raw = @conn.put do |req|
-        url = ["/v1/acl/create"]
+        url = ['/v1/acl/create']
         url += check_acl_token
         url += use_cas(@options)
         req.url concat_url url
         req.body = value.to_json
       end
-      return parse_body
+      parse_body
     end
 
     # Destroy an ACl token by its id
     # @param ID [String] the Acl ID
     # @return [Bool]
-    def destroy id
+    def destroy(id)
       @id = id
       url = ["/v1/acl/destroy/#{@id}"]
-      url += check_acl_token
+      url << check_acl_token
       @raw = @conn.put concat_url url
-      return @raw.body == "true"
+      @raw.body == 'true'
     end
   end
 end

data/lib/diplomat/api_options.rb

@@ -1,15 +1,16 @@
 module Diplomat
+  # Helper methods for interacting with the Consul RESTful API
   module ApiOptions
     def check_acl_token
-      use_named_parameter("token", Diplomat.configuration.acl_token)
+      use_named_parameter('token', Diplomat.configuration.acl_token)
     end
 
     def use_cas(options)
-      if options then use_named_parameter("cas", options[:cas]) else [] end
+      options ? use_named_parameter('cas', options[:cas]) : []
     end
 
     def use_consistency(options)
-      if options && options[:consistency] then ["#{options[:consistency]}"] else [] end
+      options && options[:consistency] ? [options[:consistency].to_s] : []
     end
   end
 end

data/lib/diplomat/check.rb

@@ -1,17 +1,14 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul check API endpoint
   class Check < Diplomat::RestClient
-
-    @access_methods = [ :checks, :register_script, :register_ttl,
-                        :deregister, :pass, :warn, :fail ]
+    @access_methods = [:checks, :register_script, :register_ttl,
+                       :deregister, :pass, :warn, :fail]
 
     # Get registered checks
     # @return [OpenStruct] all data associated with the service
     def checks
-      ret = @conn.get "/v1/agent/checks"
-      return JSON.parse(ret.body)
+      ret = @conn.get '/v1/agent/checks'
+      JSON.parse(ret.body)
     end
 
     # Register a check
@@ -22,23 +19,15 @@ module Diplomat
     # @param interval [String] frequency (with units) of the check execution
     # @param ttl [String] time (with units) to mark a check down
     # @return [Integer] Status code
-    def register_script check_id, name, notes, script, interval
-      json = JSON.generate(
-      {
-        "ID" => check_id,
-        "Name" => name,
-        "Notes" => notes,
-        "Script" => script,
-        "Interval" => interval
-      }
-      )
-
+    #
+    def register_script(check_id, name, notes, script, interval)
       ret = @conn.put do |req|
-        req.url "/v1/agent/check/register"
-        req.body = json
+        req.url '/v1/agent/check/register'
+        req.body = JSON.generate(
+          'ID' => check_id, 'Name' => name, 'Notes' => notes, 'Script' => script, 'Interval' => interval
+        )
       end
-
-      return ret.status == 200
+      ret.status == 200
     end
 
     # Register a TTL check
@@ -47,53 +36,46 @@ module Diplomat
     # @param notes [String] notes about the check
     # @param ttl [String] time (with units) to mark a check down
     # @return [Boolean] Success
-    def register_ttl check_id, name, notes, ttl
-      json = JSON.generate({
-        "ID"    => check_id,
-        "Name"  => name,
-        "Notes" => notes,
-        "TTL"   => ttl,
-      })
-
+    def register_ttl(check_id, name, notes, ttl)
       ret = @conn.put do |req|
-        req.url "/v1/agent/check/register"
-        req.body = json
+        req.url '/v1/agent/check/register'
+        req.body = JSON.generate(
+          'ID' => check_id, 'Name' => name, 'Notes' => notes, 'TTL' => ttl
+        )
       end
-
-      return ret.status == 200
+      ret.status == 200
     end
 
     # Deregister a check
     # @param check_id [String] the unique id of the check
     # @return [Integer] Status code
-    def deregister check_id
+    def deregister(check_id)
       ret = @conn.get "/v1/agent/check/deregister/#{check_id}"
-      return ret.status == 200
+      ret.status == 200
     end
 
     # Pass a check
     # @param check_id [String] the unique id of the check
     # @return [Integer] Status code
-    def pass check_id
+    def pass(check_id)
       ret = @conn.get "/v1/agent/check/pass/#{check_id}"
-      return ret.status == 200
+      ret.status == 200
     end
 
     # Warn a check
     # @param check_id [String] the unique id of the check
     # @return [Integer] Status code
-    def warn check_id
+    def warn(check_id)
       ret = @conn.get "/v1/agent/check/warn/#{check_id}"
-      return ret.status == 200
+      ret.status == 200
     end
 
     # Warn a check
     # @param check_id [String] the unique id of the check
     # @return [Integer] Status code
-    def fail check_id
+    def fail(check_id)
       ret = @conn.get "/v1/agent/check/fail/#{check_id}"
-      return ret.status == 200
+      ret.status == 200
     end
-
   end
 end

data/lib/diplomat/configuration.rb

@@ -1,4 +1,5 @@
 module Diplomat
+  # Methods for configuring Diplomat
   class Configuration
     attr_accessor :middleware
     attr_accessor :url, :acl_token, :options
@@ -7,7 +8,7 @@ module Diplomat
     # @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 = {})
+    def initialize(url = 'http://localhost:8500', acl_token = nil, options = {})
       @middleware = []
       @url = url
       @acl_token = acl_token
@@ -20,7 +21,5 @@ module Diplomat
       return @middleware = middleware if middleware.is_a? Array
       @middleware = [middleware]
     end
-
   end
 end
-

data/lib/diplomat/datacenter.rb

@@ -1,27 +1,22 @@
-require 'base64'
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul dataceneter API endpoint
   class Datacenter < Diplomat::RestClient
-
-    @access_methods = [ :get ]
+    @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)
     # @return [OpenStruct] all datacenters avaliable to this consul agent
-    def get meta=nil
-
-      url = ["/v1/catalog/datacenters"]
+    def get(meta = nil)
+      url = ['/v1/catalog/datacenters']
 
       ret = @conn.get concat_url url
 
-      if meta and ret.headers
-        meta[:index] = ret.headers["x-consul-index"]
-        meta[:knownleader] = ret.headers["x-consul-knownleader"]
-        meta[:lastcontact] = ret.headers["x-consul-lastcontact"]
+      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']
       end
-      return JSON.parse(ret.body)
+      JSON.parse(ret.body)
     end
-
   end
-end
+end

data/lib/diplomat/error.rb

@@ -6,6 +6,8 @@ module Diplomat
   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
 end

data/lib/diplomat/event.rb

@@ -1,11 +1,9 @@
-require 'faraday'
-
 module Diplomat
+  # Methods for interacting with the Consul event API endpoint
   class Event < Diplomat::RestClient
-  
     include ApiOptions
-  
-    @access_methods = [ :fire, :get_all, :get ]
+
+    @access_methods = [:fire, :get_all, :get]
 
     # Send an event
     # @param name [String] the event name
@@ -14,15 +12,14 @@ module Diplomat
     # @param node [String] the target node name
     # @param tag [String] the target tag name, must only be used with service
     # @return [nil]
-    def fire name, value=nil, service=nil, node=nil, tag=nil
-      url = [ "/v1/event/fire/#{name}" ]
+    def fire(name, value = nil, service = nil, node = nil, tag = nil)
+      url = ["/v1/event/fire/#{name}"]
       url += check_acl_token
-      url += use_named_parameter("service", service)
-      url += use_named_parameter("node", node)
-      url += use_named_parameter("tag", tag) if service
-      url = concat_url url
+      url += use_named_parameter('service', service) if service
+      url += use_named_parameter('node', node) if node
+      url += use_named_parameter('tag', tag) if tag
 
-      @conn.put(url, value)
+      @conn.put concat_url(url), value
       nil
     end
 
@@ -56,31 +53,32 @@ 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_all name=nil, not_found=:reject, found=:return
-      url = ["/v1/event/list"]
+    # rubocop:disable MethodLength, AbcSize
+    def get_all(name = nil, not_found = :reject, found = :return)
+      url = ['/v1/event/list']
       url += check_acl_token
-      url += use_named_parameter("name", name)
+      url += use_named_parameter('name', name)
       url = concat_url url
 
       # Event list never returns 404 or blocks, but may return an empty list
       @raw = @conn.get url
-      if JSON.parse(@raw.body).count == 0
+      if JSON.parse(@raw.body).count.zero?
         case not_found
-          when :reject
-            raise Diplomat::EventNotFound, name
-          when :return
-            return []
+        when :reject
+          raise Diplomat::EventNotFound, name
+        when :return
+          return []
         end
       else
         case found
-          when :reject
-            raise Diplomat::EventAlreadyExists, name
-          when :return
-            # Always set the response to 200 so we always return
-            # the response body.
-            @raw.status = 200
-            @raw = parse_body
-            return return_payload
+        when :reject
+          raise Diplomat::EventAlreadyExists, name
+        when :return
+          # Always set the response to 200 so we always return
+          # the response body.
+          @raw.status = 200
+          @raw = parse_body
+          return return_payload
         end
       end
 
@@ -88,6 +86,7 @@ module Diplomat
       @raw = parse_body
       return_payload
     end
+    # rubocop:enable MethodLength, AbcSize
 
     # Get a specific event in the sequence matching name
     # @param name [String] the name of the event (regex)
@@ -109,67 +108,66 @@ module Diplomat
     #   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).
-    def get name=nil, token=:last, not_found=:wait, found=:return
-      url = ["/v1/event/list"]
+    # rubocop:disable MethodLength, CyclomaticComplexity, AbcSize
+    def get(name = nil, token = :last, not_found = :wait, found = :return)
+      url = ['/v1/event/list']
       url += check_acl_token
-      url += use_named_parameter("name", name)
-      url = concat_url url
-      @raw = @conn.get url
+      url += use_named_parameter('name', name)
+      @raw = @conn.get concat_url url
       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
+            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 idx == body.length then
+      if 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(url)
-            @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"]
+        when :reject
+          raise Diplomat::EventNotFound, name
+        when :return
+          event_name = ''
+          event_payload = ''
+          event_token = :last
+        when :wait
+          @raw = wait_for_next_event(url)
+          @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 = Base64.decode64(event["Payload"])
-            event_token = event["ID"]
+        when :reject
+          raise Diplomat::EventAlreadyExits, name
+        when :return
+          event = body[idx]
+          event_name = event['Name']
+          event_payload = Base64.decode64(event['Payload'])
+          event_token = event['ID']
         end
       end
 
       {
-        :value => { :name => event_name, :payload => event_payload },
-        :token => event_token
+        value: { name: event_name, payload: event_payload },
+        token: event_token
       }
     end
-
+    # rubocop:enable MethodLength, CyclomaticComplexity, AbcSize
 
     private
 
-    def wait_for_next_event url
-      index = @raw.headers["x-consul-index"]
-      url = [url, use_named_parameter("index", index)].join("&")
-      return @conn.get do |req|
+    def wait_for_next_event(url)
+      index = @raw.headers['x-consul-index']
+      url = [url, use_named_parameter('index', index)].join('&')
+      @conn.get do |req|
         req.url concat_url url
-        req.options.timeout = 86400
+        req.options.timeout = 86_400
       end
     end
-
   end
 end