consul-ruby-client 0.0.2

data/lib/consul/client/base.rb

@@ -0,0 +1,132 @@
+require 'json'
+require 'logger'
+require 'rest-client'
+require_relative '../util/utils'
+
+module Consul
+  module Client
+
+    # Public API Base.
+    module Base
+
+      # Public: Creates an API Endpoint
+      #
+      # data_center - The data center to utilize, defaults to bootstrap 'dc1' datat center
+      # api_host    - The host the Consul Agent is running on. Default: 127.0.0.1
+      # api_port    - The port the Consul Agent is listening on. Default: 8500
+      # version     - The version of the api to use.
+      # logger      - Logging mechanism.  Must conform to Ruby Logger interface
+      #
+      def initialize(data_center = 'dc1', api_host = '127.0.0.1', api_port = '8500', version = 'v1', logger = Logger.new(STDOUT))
+        @dc = data_center
+        @host = api_host
+        @port = api_port
+        @logger = logger
+        @version = version
+      end
+
+      # Public: Test if this Consul Client is reachable.
+      def is_reachable
+        _get(base_url, nil, false) == 'Consul Agent'
+      end
+
+      protected
+
+      # Protected: Generic get request.  Wraps error handling and url validation.
+      #
+      # url       - url endpoint to hit.
+      # params    - Hash of key to value parameters
+      # json_only - Flag that annotates we should only be expecting json back.  Default true, most consul endpoints return JSON.
+      #
+      # Returns:
+      # Throws:
+      #     ArgumentError: the url is not valid.
+      #     IOError: Unable to reach Consul Agent.
+      def _get(url, params = nil, json_only = true)
+        # Validation
+        validate_url(url)
+
+        opts = {}
+        opts[:params] = params unless params.nil?
+        opts[:accept] = :json if json_only
+        begin
+          return RestClient.get url, opts
+        rescue Exception => e
+          # Unable to communicate with consul agent.
+          logger.warn(e.message)
+          raise IOError.new "Unable to complete get request: #{e}"
+        end
+      end
+
+      # Protected: Generic put request.  Wraps error and translates Rest response to success or failure.
+      #
+      # url    - The url endpoint for the put request.
+      # value  - The value to put at the url endpoint.
+      #
+      # Returns: true on success or false on failure and the body of the return message.
+      # Throws:
+      #     ArgumentError: the url is not valid.
+      #     IOError: Unable to reach Consul Agent.
+      def _put(url, value, params = nil)
+        # Validation
+        validate_url(url)
+
+        p = {}
+        p[:params] = params unless params.nil?
+        begin
+          if Consul::Utils.valid_json?(value)
+            resp = RestClient.put(url, value, :content_type => :json) {|response, req, res| response }
+          else
+            resp = RestClient.put(url, value) {|response, req, res| response }
+          end
+          success = (resp.code == 200 or resp.code == 201)
+          logger.warn("Unable to send #{value} to endpoint #{url} returned code: #{resp.code}") unless success
+          return success, resp.body
+        rescue Exception => e
+          logger.error('RestClient.put Error: Unable to reach consul agent')
+          raise IOError.new "Unable to complete put request: #{e}"
+        end
+      end
+
+      def data_center
+        @data_center ||= 'dc1'
+      end
+
+      def host
+        @host ||= '127.0.0.1'
+      end
+
+      def port
+        @port ||= '8500'
+      end
+
+      def version
+        @version ||= 'v1'
+      end
+
+      def logger
+        @logger ||= Logger.new(STDOUT)
+      end
+
+      def https
+        @https = false
+      end
+
+      def base_versioned_url
+        "#{base_url}/#{version}"
+      end
+
+      private
+
+      def base_url
+        "#{(https ? 'https': 'http')}://#{host}:#{port}"
+      end
+
+      # Private: Validates the url
+      def validate_url(url)
+        raise ArgumentError.new 'URL cannot be blank' if url.to_s == ''
+      end
+
+    end
+  end
+end

data/lib/consul/client/catalog.rb

@@ -0,0 +1,99 @@
+require_relative 'base'
+require_relative '../model/node'
+
+# Consul Catalog End Point.
+module Consul
+  module Client
+    class Catalog
+      include Consul::Client::Base
+
+      # Public: Returns a list of all the nodes on this client
+      #
+      # dc - Data Center to look for services in, defaults to the agents data center
+      #
+      def nodes(dc = nil)
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        JSON.parse(_get build_url('nodes'), params).map {|n| Consul::Model::Node.new.extend(Consul::Model::Node::Representer).from_hash(n)}
+      end
+
+      # Public: Returns a list of services that are within the supplied or agent data center
+      #
+      # dc - Data Center to look for services in, defaults to the agents data center
+      #
+      # Example:
+      #   Consul::Client::Catalog.new('dc1').services =>
+      #   {
+      #     "consul": [],
+      #     "redis": [],
+      #     "postgresql": [
+      #       "master",
+      #       "slave"
+      #     ]
+      #   }
+      #
+      # Returns: List of services ids.
+      def services(dc = nil)
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        JSON.parse(_get build_url('services'), params)
+      end
+
+      # Public: Returns all the nodes within a data center that have the service specified.
+      #
+      # dc  - Data center, default: agent current data center
+      # tag - Tag, filter for tags
+      #
+      # Example:
+      #   ConsulCatalog.new('dc1').service('my_service_id') =>
+      #     [ConsulNode<@service_id=my_service_id ...>,
+      #      ConsulNode<@service_id=my_service_id ...>,
+      #     ...]
+      #
+      # Returns: List of nodes that have this service.
+      def service(id, dc = nil, tag = nil)
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        params.add[:tag] = tag unless tag.nil?
+        JSON.parse(_get build_url("service/#{id}"), params).map {|n| Consul::Model::Node.new.extend(Consul::Model::Node::Representer).from_hash(n)}
+      end
+
+      # Public: Returns all the nodes within a data center that have the service specified.
+      #
+      # dc  - Data center, default: agent current data center
+      # tag - Tag, filter for tags
+      #
+      # Example:
+      #   ConsulCatalog.new('dc1').node('my_node') =>
+      #     ConsulNode<@service_id=my_service_id ...>
+      #
+      # Returns: Returns the node by the argument name.
+      def node(name, dc = nil)
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        resp = JSON.parse(_get build_url("node/#{name}"), params)
+        n = Consul::Model::Node.new.extend(Consul::Model::Node::Representer).from_hash(resp['Node'])
+        unless resp[:Services].nil?
+          n.services = resp['Services'].keys.map{|k| Consul::Model::Service.new.extend(Consul::Model::Service::Representer).from_hash(resp[:Services][k])}
+        end
+        n
+      end
+
+      def data_centers
+        _get build_url('datacenters'), params = nil, json_only = false
+      end
+
+      private
+
+      # Public: Builds the base url
+      #
+      # Example:
+      #
+      # Returns: The base
+      def build_url(suffix)
+        "#{base_versioned_url}/catalog/#{suffix}"
+      end
+
+    end
+  end
+end

data/lib/consul/client/key_value.rb

@@ -0,0 +1,142 @@
+require 'base64'
+require_relative 'base'
+require_relative '../model/key_value'
+
+module Consul
+  module Client
+    class KeyValue
+      include Consul::Client::Base
+
+      # Public: Creates an API Endpoint
+      #
+      # data_center - The data center to utilize, defaults to bootstrap 'dc1' datat center
+      # api_host    - The host the Consul Agent is running on. Default: 127.0.0.1
+      # api_port    - The port the Consul Agent is listening on. Default: 8500
+      # version     - The version of the api to use.
+      # logger      - Logging mechanism.  Must conform to Ruby Logger interface
+      #
+      def initialize(name_space = '', data_center = 'dc1', api_host = '127.0.0.1', api_port = '8500', version = 'v1', logger = Logger.new(STDOUT))
+        name_space = sanitize(name_space)
+        name_space = "#{name_space}/" unless name_space.nil? or name_space.empty?
+        @namespace = sanitize(name_space)
+        @dc = data_center
+        @host = api_host
+        @port = api_port
+        @logger = logger
+        @version = version
+      end
+
+      def name_space
+        @namespace ||= ''
+      end
+
+      # Public: Gets the value associated with a given key.
+      #
+      # Reference: https://www.consul.io/docs/agent/http/kv.html
+      #
+      # key       - Key to get value for, if recurse = true the key is treated by a prefix
+      # recurse   - Flag to signify treating the key as a prefix
+      # index     - Can be used to establish blocking queries by setting
+      # only_keys - Flag to return only keys
+      # separator - list only up to a given separator
+      #
+      # Returns: An array of Consul::Model::KeyValue objects, if only
+      def get(key,
+              recurse = false,
+              index = false,
+              only_keys = false,
+              separator = nil)
+        key = sanitize(key)
+        params = {}
+        params[:recurse] = nil if recurse
+        params[:index] = nil if index
+        params[:keys] = nil if only_keys
+        params[:separator] = separator unless separator.nil?
+        # begin
+        #   resp = RestClient.get key_url(key), {:params => params}
+        # rescue
+        #   # TODO need to pass more information back to the client.
+        #   logger.warn("Unable to get value for #{key}")
+        #   nil
+        # end
+        begin
+          resp = _get key_url(key), params
+        rescue Exception => e
+          logger.warn("Unable to get value for #{key} due to: #{e}")
+          return nil
+        end
+        return nil if resp.code == 404
+        json = JSON.parse(_get key_url(key), params)
+        return json if only_keys
+        json.map { |kv|
+          kv = Consul::Model::KeyValue.new.extend(Consul::Model::KeyValue::Representer).from_hash(kv)
+          kv.value = Base64.decode64(kv.value)
+          kv
+        }
+      end
+
+      # Public: Put the Key Value pair in consul.
+      #
+      # Low level put key value implementation.
+      #
+      # Reference: https://www.consul.io/docs/agent/http/kv.html
+      #
+      # key     - Key
+      # value   - Value to assign for Key
+      # flags   - Client specified value [0, 2e64-1]
+      # cas     - Check and Set operation
+      # acquire - Session id to acquire the lock with a valid session.
+      # release - Session id to release the lock with a valid session.
+      #
+      # Returns: True on success, False on failure
+      # Throws: IOError: Unable to contact Consul Agent.
+      def put(key,
+              value,
+              flags = nil,
+              cas = nil,
+              acquire_session = nil,
+              release_session = nil)
+        key = sanitize(key)
+        params = {}
+        params[:flags] = flags unless flags.nil?
+        params[:cas] = cas unless cas.nil?
+        params[:acquire] = acquire_session unless acquire_session.nil?
+        params[:release_session] = release_session unless release_session.nil?
+        begin
+          value = JSON.generate(value)
+        rescue JSON::GeneratorError
+          @logger.debug("Using non-JSON value for key #{key}")
+        end
+        _put build_url(key), value, {:params => params}
+      end
+
+      # Public: Delete the Key Value pair in consul.
+      #
+      # key     - Key
+      # recurse - Delete all keys as the 'key' is a prefix for
+      # cas     - Check and Set
+      def delete(key, recurse = false, cas = nil)
+        key = sanitize(key)
+        params = {}
+        params[:recurse] = nil if recurse
+        params[:cas] = cas unless cas.nil?
+        RestClient.delete build_url(key), {:params => params}
+      end
+
+      def build_url(suffix)
+        "#{base_versioned_url}/kv/#{suffix}"
+      end
+
+      private
+
+      def sanitize(key)
+        key.gsub(/^\//,'').gsub(/\/$/,'')
+      end
+
+      def key_url(key)
+        build_url("#{name_space}#{key}")
+      end
+
+    end
+  end
+end

data/lib/consul/client/session.rb

@@ -0,0 +1,135 @@
+require_relative 'base'
+require_relative '../model/session'
+require_relative '../util/utils'
+
+module Consul
+  module Client
+    # Consul Session Client
+    class Session
+      include Consul::Client::Base
+
+      # Public: Creates an instance of Consul::Model::Session with as many preset
+      # defaults as possible.
+      #
+      # name        - The name of the session.
+      # lock_delay  - Allowance window for leaders to Valid values between '0s' and '60s'
+      # node        - The name of the node, defaults to the node the agent is running on
+      # checks      - Health Checks to associate to this session
+      # behaviour   - 'release' or 'destroy' Behaviour when session is invalidated.
+      # ttl         - When provided  Must be between '10s' and '3600s'
+      #
+      # Returns: Consul::Model::Session instance.
+      def self.for_name(name,
+          lock_delay = '15s',
+          node = nil,
+          checks = ['serfHealth'],
+          behaviour = 'release',
+          ttl = nil)
+        raise ArgumentError.new "Illegal Name: #{name}" if name.nil?
+        session = Consul::Model::Session.new(name: name)
+        session[:lock_delay] = lock_delay unless lock_delay.nil?
+        session[:node] = node unless node.nil?
+        checks = [] if checks.nil?
+        checks += 'serfHealth' unless checks.include? 'serfHealth'
+        session[:checks] = checks
+        behaviour = 'release' if behaviour.nil? or behaviour != 'release' or behaviour != 'destroy'
+        session[:behaviour] = behaviour
+        session[:ttl] = ttl unless ttl.nil?
+        session
+      end
+
+      # Public: Creates a new Consul Session.
+      #
+      # session - Session to create.
+      # dc      - Consul data center
+      #
+      # Returns The Session ID a
+      def create(session, dc = nil)
+        raise TypeError, 'Session must be of type Consul::Model::Session' unless session.kind_of? Consul::Model::Session
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        success, body = _put(build_url('create'), session.extend(Consul::Model::Session::Representer).to_json, params)
+        return Consul::Model::Session.new.extend(Consul::Model::Service::Representer).from_json(body) if success
+        logger.warn("Unable to create session with #{session}")
+        nil
+      end
+
+      # Public: Destroys a given session
+      def destroy(session, dc = nil)
+        return false if session.nil?
+        session = extract_session_id(session)
+        params = nil
+        params = {:dc => dc} unless dc.nil?
+        success, _ = _put build_url("destroy/#{session}"), '', params
+        success
+      end
+
+      # Public: Return the session info for a given session name.
+      #ccs
+      def info(session, dc = nil)
+        return nil if session.nil?
+        session = extract_session_id(session)
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        resp = _get build_url("info/#{session}"), params
+        JSON.parse(resp).map{|session_hash| session(session_hash)} unless resp.nil?
+      end
+
+      # Lists sessions belonging to a node
+      def node(session, dc = nil)
+        return nil if session.nil?
+        session = extract_session_id(session)
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        resp = _get build_url("node/#{session}"), params
+        JSON.parse(resp).map{|session_hash| session(session_hash)} unless resp.nil?
+      end
+
+      # Lists all active sessions
+      def list(dc = nil)
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        resp = _get build_url('list'), params
+        JSON.parse(resp).map{|session_hash| session(session_hash)} unless resp.nil?
+      end
+
+      # Renews a TTL-based session
+      def renew(session, dc = nil)
+        return nil if session.nil?
+        session = extract_session_id(session)
+        params = {}
+        params[:dc] = dc unless dc.nil?
+        success, _ = _put build_url("renew/#{session.name}"), session.to_json
+        success
+      end
+
+      private
+
+      # Private: Extracts the Session
+      def extract_session_id(session)
+        raise TypeError, 'Session cannot be null' if session.nil?
+        session = session.id if session.kind_of? Consul::Model::Session
+        session = session.to_str if session.respond_to?(:to_str)
+        session
+      end
+
+      def session(obj)
+        if Consul::Utils.valid_json?(obj)
+          Consul::Model::Session.new.extend(Consul::Model::Session::Representer).from_json(obj)
+        elsif obj.is_a?(Hash)
+          Consul::Model::Session.new.extend(Consul::Model::Session::Representer).from_hash(obj)
+        end
+      end
+
+      # Private: Create the url for a session endpoint.
+      #
+      # suffix - Suffix of the url endpoint
+      #
+      # Return: The URL for a reachable endpoint
+      def build_url(suffix)
+        "#{base_versioned_url}/session/#{suffix}"
+      end
+
+    end
+  end
+end