imperium 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 040c01db1f3d464524d6b66f0b0e52f7c8fc3553
-  data.tar.gz: 65991cbb6b16acce1c2b3d408eaa6ae3e6ec67be
+  metadata.gz: 707891835377b95b0bbfad486145b8c3ab3394a6
+  data.tar.gz: b076560dd3acaa8327cc96459db5dcb63fecca03
 SHA512:
-  metadata.gz: 897ac12a4b8a4616dfe37e3175c69a1ffa3d76d6dff7e7ab0c5beb6370fd39fbb02c32a817dde2e6c87a5fa420c6f5202113e1172fd79821be1d00797cfd062e
-  data.tar.gz: 01d52982aab2dbb960229c7cf2b90b85f577054a894de8c58aa478de1cb0477d7b8038ecc7b573ed94070e02b02cb6f15a0083171785d09d929c0df47bd516a5
+  metadata.gz: 509f7e2d9d6b888c3de92acc1a4472bb4df0c8032a060236db73bf169804553525ab94a2e9a3741f092cb0f4b53039eee236ecca2e2a704bfb5e0cfc64001d18
+  data.tar.gz: d0f25997c35f608f545a9470067cc4a8679799fa01683a2a52b0ec483f9ccc9792b60948da83be88cf552351b82826e56891f2c4c3bafb3d38a176caa757b65f

data/bin/console

@@ -10,5 +10,11 @@ require "imperium"
 # require "pry"
 # Pry.start
 
+Imperium.configure do |conf|
+  conf.host = ENV.fetch('IMPERIUM_CONSUL_HOST', 'localhost')
+  conf.port = Integer(ENV.fetch('IMPERIUM_CONSUL_PORT', 8500))
+  conf.ssl = ENV.fetch('IMPERIUM_CONSUL_SSL', 'false') == 'true'
+end
+
 require "irb"
 IRB.start

data/lib/imperium.rb

@@ -1,15 +1,21 @@
 require 'imperium/error'
 
-require 'imperium/configuration'
+require 'imperium/agent'
+require 'imperium/agent_list_checks_response'
+require 'imperium/agent_list_services_response'
+require 'imperium/catalog'
 require 'imperium/client'
-require 'imperium/http_client'
+require 'imperium/configuration'
 require 'imperium/event_fire_response'
 require 'imperium/events'
+require 'imperium/http_client'
 require 'imperium/kv'
 require 'imperium/kv_pair'
 require 'imperium/kv_get_response'
 require 'imperium/kv_put_response'
 require 'imperium/response'
+require 'imperium/service'
+require 'imperium/service_check'
 require 'imperium/version'
 
 module Imperium

data/lib/imperium/agent.rb

@@ -0,0 +1,48 @@
+require 'imperium/client'
+
+module Imperium
+  # A client for the Agent API.
+  class Agent < Client
+    self.path_prefix = 'v1/agent'.freeze
+
+    # Deregister a service with the agent.
+    #
+    # @see https://www.consul.io/api/agent/service.html#deregister-service Consul's Documentation
+    #
+    # @param service_or_id [Service, String] The object or id representing the
+    #   service to be removed from the services registry.
+    def deregister_service(service_or_id)
+      id = (service_or_id.is_a?(Service) ? service_or_id.id : service_or_id)
+      Response.new(@http_client.put(prefix_path("service/deregister/#{id}"), ''))
+    end
+
+    # Retreive a list of all checks registered to the local agent.
+    #
+    # @see https://www.consul.io/api/agent/check.html#list-checks Consul's Documentation
+    # @return [AgentListChecksResponse]
+    def list_checks
+      response = @http_client.get(prefix_path('checks'))
+      AgentListChecksResponse.new(response)
+    end
+
+    # Retreive a list of all services registered to the local agent.
+    #
+    # @see https://www.consul.io/api/agent/service.html#list-services Consul's Documentation
+    # @return [AgentListServicesResponse]
+    def list_services
+      response = @http_client.get(prefix_path('services'))
+      AgentListServicesResponse.new(response)
+    end
+
+    # Register a new service with the agent.
+    #
+    # @see https://www.consul.io/api/agent/service.html#register-service Consul's Documentation
+    #
+    # @param service [Serivce] A {Service} object containing the data to use
+    #   for registration
+    def register_service(service)
+      Response.new(@http_client.put(prefix_path('service/register'), service.registration_data))
+    end
+  end
+end
+

data/lib/imperium/agent_list_checks_response.rb

@@ -0,0 +1,24 @@
+require_relative 'response'
+require_relative 'service_check'
+
+module Imperium
+  class AgentListChecksResponse < Response
+    self.default_response_object_class = ServiceCheck
+
+    def checks
+      @checks ||= checks_hash.values
+    end
+
+    def checks_hash
+      @checks_hash ||= (ok? ? coerced_body : {})
+    end
+
+    def [](key)
+      checks_hash[key]
+    end
+
+    def each(&block)
+      checks.each(&block)
+    end
+  end
+end

data/lib/imperium/agent_list_services_response.rb

@@ -0,0 +1,36 @@
+require_relative 'response'
+require_relative 'service'
+
+module Imperium
+  # AgentListServiceResponse is a wrapper for the raw HTTP::Message response
+  #   from the API
+  #
+  # @note This class doesn't really make sense to be instantiated outside of
+  #   {Agent#list_services}
+  #
+  # We've included Enumerable and implemented #each so it can be treated as an
+  # array of {Service} objects.
+  class AgentListServicesResponse < Response
+    self.default_response_object_class = Service
+
+    def each(&block)
+      services.each(&block)
+    end
+
+    # Build an array of {Service} objects from the response
+    #
+    # @return [Array<Service>] This array will be empty when the response is not
+    #   a success
+    def services
+      @services ||= services_hash.values
+    end
+
+    # Build a hash of {Service} object from the response
+    #
+    # The keys are the service's id from the API response.
+    # @return [Hash<String => Service>]
+    def services_hash
+      @services_hash ||= (ok? ? coerced_body : {})
+    end
+  end
+end

data/lib/imperium/api_object.rb

@@ -0,0 +1,83 @@
+require_relative 'refinements/hash_compact'
+module Imperium
+  # Base class for handling data coming from the Consul API
+  class APIObject
+    using HashCompact
+
+    class << self
+      # The mapping of attribute names coming from Consul to names that are more
+      # Ruby friendly
+      # @return [Hash<String => Symbol>]
+      attr_reader :attribute_map
+
+      # The Ruby friendly names from {attribute_map}
+      # @return [Array<Symbol>]
+      attr_reader :ruby_attribute_names
+
+      def attribute_map=(val)
+        @attribute_map = val
+        @ruby_attribute_names = val.values.map(&:to_sym)
+        attr_accessor *@ruby_attribute_names
+      end
+    end
+
+    # Initialize a new object extracting attributes from the supplied hash
+    def initialize(attributes = {})
+      self.class.attribute_map.each do |key, attribute_name|
+        value = attributes[attribute_name] || attributes[key]
+        send("#{attribute_name}=", value) if value
+      end
+    end
+
+    def ==(other)
+      return false unless self.class == other.class
+      ruby_attribute_names.all? { |attr| self.send(attr) == other.send(attr) }
+    end
+
+    def attribute_map
+      self.class.attribute_map
+    end
+
+    # Shortcut method to access the class level attribute
+    # @return [Array<Symbol>]
+    def ruby_attribute_names
+      self.class.ruby_attribute_names
+    end
+
+    # Convert the object and any sub-objects into a hash
+    #
+    # @param consul_names_as_keys [Boolean] Use the Consul object attribute names
+    #   as the keys when true (default) otherwise use the ruby attribute names.
+    def to_h(consul_names_as_keys: true)
+      if consul_names_as_keys
+        attribute_map.each_with_object({}) do |(consul, ruby), h|
+          h[consul] = maybe_hashified_attribute(ruby, true)
+        end.compact
+      else
+        ruby_attribute_names.each_with_object({}) do |attr, h|
+          h[attr] = maybe_hashified_attribute(attr, false)
+        end.compact
+      end
+    end
+
+    private
+
+    def maybe_hashified_attribute(attr_name, consul_names)
+      val = send(attr_name)
+
+      if val.nil?
+        nil
+      elsif val.is_a?(Array)
+        val.map { |elem| elem.respond_to?(:to_h) ? fancy_send_to_h(elem, consul_names) : elem }
+      elsif val.respond_to?(:to_h)
+        fancy_send_to_h(val, consul_names)
+      else
+        val
+      end
+    end
+
+    def fancy_send_to_h(obj, consul_names)
+      (obj.is_a?(APIObject) ? obj.to_h(consul_names_as_keys: consul_names) : obj.to_h)
+    end
+  end
+end

data/lib/imperium/catalog.rb

@@ -0,0 +1,29 @@
+require_relative 'client'
+
+module Imperium
+  # A client for the Catalog API.
+  class Catalog < Client
+    self.path_prefix = 'v1/catalog'.freeze
+
+    # List services in the global catalog
+    #
+    # @return [Response]
+    def list_services
+      response = @http_client.get(prefix_path('services'))
+      Response.new(response)
+    end
+
+    # List the known nodes for the given service in the global catalog
+    #
+    # Returns a {Response} object that coerces the returned data into {Service}
+    # objects
+    #
+    # @param [String] :service
+    # @return [Array<Service>]
+    def list_nodes_for_service(service)
+      response = @http_client.get(prefix_path("service/#{service}"))
+      Response.new(response, response_object_class: Service)
+    end
+  end
+end
+require_relative 'catalog/service'

data/lib/imperium/catalog/service.rb

@@ -0,0 +1,76 @@
+require_relative '../api_object'
+
+module Imperium
+  class Catalog
+    # Service is a container for data being received from and sent to the
+    # catalog APIs.
+    #
+    # @see https://www.consul.io/api/catalog.html#list-nodes-for-service The Consul Catalog Documentation
+    #
+    # @!attribute [rw] id
+    #   @return [String]
+    # @!attribute [rw] node
+    #   @return [String]
+    # @!attribute [rw] address
+    #   @return [String]
+    # @!attribute [rw] datacenter
+    #   @return [String]
+    # @!attribute [rw] tagged_addresses
+    #   @return [Hash<String => String>]
+    # @!attribute [rw] node_meta
+    #   @return [Hash<String => String>]
+    # @!attribute [rw] service_id
+    #   @return [String]
+    # @!attribute [rw] service_name
+    #   @return [String]
+    # @!attribute [rw] service_address
+    #   @return [String]
+    # @!attribute [rw] service_tags
+    #   @return [Array<String>]
+    # @!attribute [rw] service_port
+    #   @return [String]
+    # @!attribute [rw] service_enable_tag_override
+    #   @return [Boolean]
+    # @!attribute [rw] create_index
+    #   @return [Integer]
+    # @!attribute [rw] modify_index
+    #   @return [Integer]
+    class Service < APIObject
+      self.attribute_map = {
+	'ID' => :id,
+	'Node' => :node,
+	'Address' => :address,
+	'Datacenter' => :datacenter,
+	'TaggedAddresses' => :tagged_addresses,
+	'NodeMeta' => :node_meta,
+	'ServiceID' => :service_id,
+	'ServiceName' => :service_name,
+	'ServiceAddress' => :service_address,
+	'ServiceTags' => :service_tags,
+	'ServicePort' => :service_port,
+	'ServiceEnableTagOverride' => :service_enable_tag_override,
+	'CreateIndex' => :create_index,
+	'ModifyIndex' => :modify_index,
+      }
+
+      def initialize(*args)
+        @tagged_addresses = {}
+        @node_meta = {}
+        @service_tags = []
+        super
+      end
+
+      def tagged_addresses=(val)
+        @tagged_addresses = (val.nil? ? {} : val)
+      end
+
+      def node_meta=(val)
+        @node_meta = (val.nil? ? {} : val)
+      end
+
+      def service_tags=(val)
+        @service_tags = (val.nil? ? [] : val)
+      end
+    end
+  end
+end

data/lib/imperium/http_client.rb

@@ -31,7 +31,11 @@ module Imperium
       wrapping_exceptions do
         url = config.url.join(path)
         url.query_values = query
-        @driver.put(url, body: value)
+        if value.is_a?(String)
+          @driver.put(url, body: value)
+        else
+          @driver.put(url, body: JSON.generate(value))
+        end
       end
     end
 

data/lib/imperium/kv_pair.rb

@@ -1,3 +1,4 @@
+require_relative 'api_object'
 require 'base64'
 
 module Imperium
@@ -24,8 +25,8 @@ module Imperium
   # @!attribute [rw] modify_index
   #   @return [Integer] The internal index value representing when the entry
   #     was last updated.
-  class KVPair
-    ATTRIBUTE_MAP = {
+  class KVPair < APIObject
+    self.attribute_map = {
       'LockIndex' => :lock_index,
       'Session' => :session,
       'Key' => :key,
@@ -34,27 +35,6 @@ module Imperium
       'CreateIndex' => :create_index,
       'ModifyIndex' => :modify_index,
     }.freeze
-    private_constant :ATTRIBUTE_MAP
-
-    ATTRIBUTE_NAMES = ATTRIBUTE_MAP.values
-    private_constant :ATTRIBUTE_NAMES
-
-    attr_accessor *ATTRIBUTE_NAMES
-
-    # Initialize a {KVPair}
-    #
-    # @param attributes [Hash] The attributes for this object as parsed from the
-    #   API response.
-    def initialize(attributes = {})
-      ATTRIBUTE_MAP.each do |key, attribute_name|
-        send("#{attribute_name}=", attributes[key]) if attributes[key]
-      end
-    end
-
-    def ==(other)
-      return false unless self.class === other
-      ATTRIBUTE_NAMES.all? { |attr| self.send(attr) == other.send(attr )}
-    end
 
     # Capture and base64 decode a value from the api.
     #

data/lib/imperium/refinements/hash_compact.rb

@@ -0,0 +1,11 @@
+module Imperium
+  module HashCompact
+    refine Hash do
+      unless Hash.instance_methods(false).include?(:compact)
+        def compact
+          reject { |_, v| v.nil? }
+        end
+      end
+    end
+  end
+end

data/lib/imperium/response.rb

@@ -8,6 +8,26 @@ module Imperium
   # It exposes, through a convenient API, headers common to all interactions
   # with the Consul HTTP API
   class Response < SimpleDelegator
+    include Enumerable
+
+    class << self
+      attr_accessor :default_response_object_class
+    end
+
+    # Construct a new response
+    #
+    # @param response [HTTP::Message] The response as returned from the http client
+    # @param response_object_class [APIObject] The class to coerce values into,
+    #   if left the default (:none) no coersion will be attempted.
+    def initialize(response, response_object_class: :none)
+      super(response)
+      @klass = if response_object_class == :none
+                 self.class.default_response_object_class
+               else
+                 response_object_class
+               end
+    end
+
     # Indicates if the contacted server has a known leader.
     #
     # @return [TrueClass] When the response indicates there is a known leader
@@ -41,6 +61,25 @@ module Imperium
       headers.key?('X-Consul-Translate-Addresses')
     end
 
+    # Iterate over the values contained in the structure returned from {#coerced_body}
+    def each(&block)
+      coerced_body.each(&block)
+    end
+
+    # Parse the response JSON and initialize objects using the class passed to the constructor.
+    #
+    # @return [Array<Hash, APIObject>, Hash<String => APIObject>]
+    def coerced_body
+      return parsed_body if @klass == :none || @klass.nil?
+      @coerced_body ||= if parsed_body.is_a?(Array)
+                          parsed_body.map { |attrs| @klass.new(attrs) }
+                        else
+                          parsed_body.each_with_object({}) { |(k, attrs), h|
+                            h[k] = @klass.new(attrs)
+                          }
+                        end
+    end
+
     private
 
     def parsed_body

data/lib/imperium/service.rb

@@ -0,0 +1,87 @@
+module Imperium
+  # Service is a container for data being received from and sent to the agent
+  # services APIs.
+  #
+  # @see https://www.consul.io/api/agent/service.html Agent Services API documentation
+  #
+  # @!attribute [rw] id
+  #   @return [String] The service's id, when creating a new service this will
+  #     be automatically assigned if not supplied, must be unique.
+  # @!attribute [rw] name
+  #   @return [String] The service's name in the consul UI, required for
+  #     creation, not required to be unique.
+  # @!attribute [rw] tags
+  #   @return [Arary<String>] List of tags to be used for the service, can be
+  #     used after creation for filtering in the API.
+  # @!attribute [rw] address
+  #   @return [String] The network address to find the service at for DNS
+  #     requests, defaults to the running agent's IP if left blank.
+  # @!attribute [rw] port
+  #   @return [Integer] The port the service is bound to for network services.
+  # @!attribute [rw] checks
+  #   @return [Array<ServiceCheck>] Specifies a list of checks to use for monitoring
+  #     the service's health.
+  # @!attribute [rw] enable_tag_override
+  #   @return [Boolean] Specifies to disable the anti-entropy feature for this
+  #     service's tags. If EnableTagOverride is set to true then external agents
+  #     can update this service in the catalog and modify the tags.
+  # @!attribute [r] create_index
+  #   @return [Integer]
+  # @!attribute [r] modify_index
+  #   @return [Integer]
+  class Service < APIObject
+    self.attribute_map = {
+      'ID' => :id,
+      'Name' => :name,
+      'Tags' => :tags,
+      'Address' => :address,
+      'Port' => :port,
+      'Check' => :check,
+      'Checks' => :checks,
+      'EnableTagOverride' => :enable_tag_override,
+      'CreateIndex' => :create_index,
+      'ModifyIndex' => :modify_index
+    }
+
+    def initialize(*args)
+      # So we can << onto these w/o having to nil check everywhere first
+      @tags ||= []
+      @checks ||= []
+      super
+    end
+
+    def add_check(val)
+      @checks <<  maybe_convert_service_check(val) unless val.nil?
+    end
+    alias check= add_check
+
+
+    def checks=(val)
+      @checks = (val || []).map { |obj| maybe_convert_service_check(obj) }
+    end
+
+    def tags=(val)
+      @tags = (val.nil? ? [] : val)
+    end
+
+    # Generate a hash containing the data necessary for registering this service.
+    #
+    # If both Check and Checks are present in the object they're coalesced into
+    # a single Checks key.
+    #
+    # @return [Hash<String => String,Integer,Hash<String => String>,Array<Hash<String => String>>]
+    def registration_data
+      to_h.tap do |h|
+        h.delete('CreateIndex')
+        h.delete('ModifyIndex')
+        h.delete('Checks') if checks.empty?
+      end
+    end
+
+    private
+
+    def maybe_convert_service_check(attrs_or_check)
+      attrs_or_check.is_a?(Hash) ? ServiceCheck.new(attrs_or_check) : attrs_or_check
+    end
+  end
+end

data/lib/imperium/service_check.rb

@@ -0,0 +1,100 @@
+require_relative 'api_object'
+module Imperium
+  # ServiceCheck is a container for data being received from and sent to the
+  # agent services and checks apis.
+  #
+  # @see https://www.consul.io/api/agent/check.html Agent Checks API documentation
+  #
+  # @!attribute [rw] id
+  #   @return [String] The service's id, when creating a new check this will
+  #     be automatically assigned if not supplied, must be unique.
+  # @!attribute [rw] name
+  #   @return [String] The check's name in the consul UI, required for
+  #     creation, not required to be unique.
+  # @!attribute [rw] script
+  #   @return [String] Specifies a script or path to a script to run on Interval
+  #     to update the status of the check. If specifying a path, this path must
+  #     exist on disk and be readable by the Consul agent.
+  # @!attribute [rw] docker_container_id
+  #   @return [String] Specifies that the check is a Docker check, and Consul
+  #     will evaluate the script every Interval in the given container using the
+  #     specified Shell. Note that Shell is currently only supported for Docker checks.
+  # @!attribute [rw] shell
+  #   @return [String] The shell to use for docker checks, only applies when
+  #     docker_container_id is specified
+  # @!attribute [rw] interval
+  #   @return [String] Specifies the frequency at which to run this check. This
+  #     is required for HTTP and TCP checks.
+  # @!attribute [rw] timeout
+  #   @return [String]
+  # @!attribute [rw] ttl
+  #   @return [String] Specifies this is a TTL check, and the TTL endpoint must
+  #     be used periodically to update the state of the check.
+  # @!attribute [rw] http
+  #   @return [String] Specifies an HTTP check to perform a GET request against
+  #     the value of HTTP (expected to be a URL) every Interval. If the response
+  #     is any 2xx code, the check is passing. If the response is 429 Too Many
+  #     Requests, the check is warning. Otherwise, the check is critical. HTTP
+  #     checks also support SSL. By default, a valid SSL certificate is
+  #     expected. Certificate verification can be controlled using the
+  #     TLSSkipVerify.
+  # @!attribute [rw] headers
+  #   @return [Hash<String => String>] Specifies a set of headers that should be
+  #     set for HTTP checks. Each header can have multiple values.
+  # @!attribute [rw] method
+  #   @return [String] Specifies a different HTTP method to be used for an HTTP
+  #     check. When no value is specified, GET is used.
+  # @!attribute [rw] tcp
+  #   @return [String] Specifies a TCP to connect against the value of TCP
+  #     (expected to be an IP or hostname plus port combination) every Interval.
+  #     If the connection attempt is successful, the check is passing. If the
+  #     connection attempt is unsuccessful, the check is critical. In the case
+  #     of a hostname that resolves to both IPv4 and IPv6 addresses, an attempt
+  #     will be made to both addresses, and the first successful connection
+  #     attempt will result in a successful check.
+  # @!attribute [rw] status
+  #   @return [String] Specifies the initial status of the health check.
+  # @!attribute [rw] notes
+  #   @return [String] Specifies arbitrary information for humans. This is not
+  #     used by Consul internally.
+  # @!attribute [rw] tls_skip_verify
+  #   @return [String] Specifies if the certificate for an HTTPS check should
+  #     not be verified.
+  # @!attribute [rw] deregister_critical_service_after
+  #   @return [String] Specifies that checks associated with a service should
+  #     deregister after this time. This is specified as a time duration with
+  #     suffix like "10m". If a check is in the critical state for more than
+  #     this configured value, then its associated service (and all of its
+  #     associated checks) will automatically be deregistered. The minimum
+  #     timeout is 1 minute, and the process that reaps critical services runs
+  #     every 30 seconds, so it may take slightly longer than the configured
+  #     timeout to trigger the deregistration. This should generally be
+  #     configured with a timeout that's much, much longer than any expected
+  #     recoverable outage for the given service.
+  # @!attribute [rw] service_id
+  #   @return [String] Specifies the ID of a service to associate the
+  #     registered check with an existing service provided by the agent. Does
+  #     not need to be set when registering the check at the same time as
+  #     registering a service
+  class ServiceCheck < APIObject
+    self.attribute_map = {
+      'ID' => :id,
+      'Name' => :name,
+      'Script' => :script,
+      'DockerContainerID' => :docker_container_id,
+      'Shell' => :shell,
+      'Interval' => :interval,
+      'Timeout' => :timeout,
+      'TTL' => :ttl,
+      'HTTP' => :http,
+      'Header' => :headers,
+      'Method' => :method,
+      'TCP' => :tcp,
+      'Status' => :status,
+      'Notes' => :notes,
+      'TLSSkipVerify' => :tls_skip_verify,
+      'DeregisterCriticalServiceAfter' => :deregister_critical_service_after,
+      'ServiceID' => :service_id,
+    }
+  end
+end

data/lib/imperium/version.rb

@@ -1,3 +1,3 @@
 module Imperium
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: imperium
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Tyler Pickett
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-26 00:00:00.000000000 Z
+date: 2017-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -157,6 +157,12 @@ files:
 - docker-compose.yml
 - imperium.gemspec
 - lib/imperium.rb
+- lib/imperium/agent.rb
+- lib/imperium/agent_list_checks_response.rb
+- lib/imperium/agent_list_services_response.rb
+- lib/imperium/api_object.rb
+- lib/imperium/catalog.rb
+- lib/imperium/catalog/service.rb
 - lib/imperium/client.rb
 - lib/imperium/configuration.rb
 - lib/imperium/error.rb
@@ -167,7 +173,10 @@ files:
 - lib/imperium/kv_get_response.rb
 - lib/imperium/kv_pair.rb
 - lib/imperium/kv_put_response.rb
+- lib/imperium/refinements/hash_compact.rb
 - lib/imperium/response.rb
+- lib/imperium/service.rb
+- lib/imperium/service_check.rb
 - lib/imperium/testing.rb
 - lib/imperium/version.rb
 homepage: https://github.com/instructure/imperium