diplomat-blsk 2.0.2

data/lib/diplomat/members.rb

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

data/lib/diplomat/node.rb

@@ -0,0 +1,56 @@
+module Diplomat
+  # Methods for interacting with the Consul node API endpoint
+  class Node < Diplomat::RestClient
+    include ApiOptions
+
+    @access_methods = %i[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)
+      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
+      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
+      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')
+      register = @conn.put path, JSON.dump(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
+    # @return [Boolean]
+    def deregister(definition, path = '/v1/catalog/deregister')
+      deregister = @conn.put path, JSON.dump(definition)
+
+      deregister.status == 200
+    end
+  end
+end

data/lib/diplomat/nodes.rb

@@ -0,0 +1,25 @@
+module Diplomat
+  # @depreciated
+  # Methods for interacting with the Consul nodes API endpoint
+  class Nodes < Diplomat::RestClient
+    @access_methods = %i[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'
+      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
+  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 = %i[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

@@ -0,0 +1,180 @@
+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)
+      start_connection api_connection
+    end
+
+    # Format url parameters into strings correctly
+    # @param name [String] the name of the parameter
+    # @param value [String] the value of the parameter
+    # @return [Array] the resultant parameter string inside an array.
+    def use_named_parameter(name, value)
+      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
+        parts.first + '?' + parts.drop(1).join('&')
+      else
+        parts.first
+      end
+    end
+
+    class << self
+      def access_method?(meth_id)
+        @access_methods.include? meth_id
+      end
+
+      # Allow certain methods to be accessed
+      # without defining "new".
+      # @param meth_id [Symbol] symbol defining method requested
+      # @param *args Arguments list
+      # @return [Boolean]
+      def method_missing(meth_id, *args)
+        if access_method?(meth_id)
+          new.send(meth_id, *args)
+        else
+
+          # See https://bugs.ruby-lang.org/issues/10969
+          begin
+            super
+          rescue NameError => err
+            raise NoMethodError, err
+          end
+        end
+      end
+
+      # Make `respond_to?` aware of method short-cuts.
+      #
+      # @param meth_id [Symbol] the tested method
+      # @oaram with_private if private methods should be tested too
+      def respond_to?(meth_id, with_private = false)
+        access_method?(meth_id) || super
+      end
+
+      # Make `respond_to_missing` aware of method short-cuts. This is needed for
+      # {#method} to work on these, which is helpful for testing purposes.
+      #
+      # @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
+
+    private
+
+    # Build the API Client
+    # @param api_connection [Faraday::Connection,nil] supply mock API Connection
+    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)
+      api_connection || Faraday.new(Diplomat.configuration.url, Diplomat.configuration.options) do |faraday|
+        Diplomat.configuration.middleware.each do |middleware|
+          faraday.use middleware
+        end
+
+        faraday.request  :url_encoded
+        faraday.response :raise_error unless raise_error
+
+        faraday.adapter  Faraday.default_adapter
+      end
+    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)
+    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}: #{@raw.body}"
+    end
+
+    # Return @raw with Value fields decoded
+    def decode_values
+      return @raw if @raw.first.is_a? String
+      @raw.each_with_object([]) do |acc, el|
+        begin
+          acc['Value'] = Base64.decode64(acc['Value'])
+        rescue # rubocop:disable RescueWithoutErrorClass
+          nil
+        end
+        el << acc
+        el
+      end
+    end
+
+    # Get the key/value(s) from the raw output
+    # rubocop:disable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
+    def return_value(nil_values = false, transformation = nil, return_hash = false)
+      @value = decode_values
+      return @value if @value.first.is_a? String
+      if @value.count == 1 && !return_hash
+        @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 && !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?) }
+      end
+    end
+  end
+end

data/lib/diplomat/service.rb

@@ -0,0 +1,118 @@
+module Diplomat
+  # Methods for interacting with the Consul serivce API endpoint.
+  class Service < Diplomat::RestClient
+    include ApiOptions
+
+    @access_methods = %i[get get_all register deregister register_external deregister_external maintenance]
+
+    # Get a service by it's key
+    # @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
+
+      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
+
+      if scope == :all
+        JSON.parse(ret.body).map { |service| OpenStruct.new service }
+      else
+        OpenStruct.new JSON.parse(ret.body).first
+      end
+    end
+    # rubocop:enable PerceivedComplexity, MethodLength, CyclomaticComplexity, AbcSize
+
+    # 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
+
+      OpenStruct.new JSON.parse(ret.body)
+    end
+
+    # Register a service
+    # @param definition [Hash] Hash containing definition of service
+    # @return [Boolean]
+    def register(definition, path = '/v1/agent/service/register')
+      json_definition = JSON.dump(definition)
+      register = @conn.put path, json_definition
+      register.status == 200
+    end
+
+    # De-register a service
+    # @param service_name [String] Service name to de-register
+    # @return [Boolean]
+    def deregister(service_name)
+      deregister = @conn.put "/v1/agent/service/deregister/#{service_name}"
+      deregister.status == 200
+    end
+
+    # Register an external service
+    # @param definition [Hash] Hash containing definition of service
+    # @return [Boolean]
+    def register_external(definition)
+      register(definition, '/v1/catalog/register')
+    end
+
+    # Deregister an external service
+    # @param definition [Hash] Hash containing definition of service
+    # @return [Boolean]
+    def deregister_external(definition)
+      json_definition = JSON.dump(definition)
+      deregister = @conn.put '/v1/catalog/deregister', json_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
+    # @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
+      maintenance.status == 200
+    end
+    # rubocop:enable AbcSize
+  end
+end