consul.core — consul-clojure 0.7.2

acl-clone clj

(acl-clone conn token-id {:keys [token] :as params})

acl-create clj

(acl-create conn {:keys [name type rules] :as tkn} {:keys [token] :as params})

Create a new ACL token

:type is 'client' or 'management'

acl-destroy clj

(acl-destroy conn token-id {:keys [token] :as params})

acl-info clj

(acl-info conn token-id {:keys [token] :as params})

acl-list clj

(acl-list conn {:keys [token] :as params})

acl-update clj

(acl-update conn
            {:keys [id name type rules] :as tkn}
            {:keys [token] :as params})

agent-checks clj

(agent-checks conn)

(agent-checks conn {:as params})

Returns all the checks that are registered with the local agent as a map with the check names as strings.

agent-deregister-check clj

(agent-deregister-check conn check-id)

(agent-deregister-check conn check-id {:as params})

Deregisters a check with the local agent.

agent-deregister-service clj

(agent-deregister-service conn service-id)

(agent-deregister-service conn service-id {:as params})

Registers a new local service.

agent-fail-check clj

(agent-fail-check conn check-id)

(agent-fail-check conn check-id {:keys [note] :as params})

Marks a local test as critical.

agent-force-leave clj

(agent-force-leave conn node)

(agent-force-leave conn node {:as params})

Forces removal of a node, returns true if the request succeeded.

agent-join clj

(agent-join conn address)

(agent-join conn address {:as params})

Triggers the local agent to join a node. Returns true if successful.

agent-maintenance clj

(agent-maintenance conn enable?)

(agent-maintenance conn enable? {:as params})

Manages node maintenance mode.

Requires a boolean value for enable?. An optional :reason can be provided, returns true if successful.

agent-maintenance-service clj

(agent-maintenance-service conn service-id {:keys [enable reason] :as params})

(agent-maintenance-service conn service-id enable reason)

Registers a new local service.

agent-members clj

(agent-members conn)

(agent-members conn {:as params})

Returns the members as seen by the local serf agent.

agent-pass-check clj

(agent-pass-check conn check-id)

(agent-pass-check conn check-id {:keys [note] :as params})

Marks a local check as passing.

agent-register-check clj

(agent-register-check conn
                      {:keys [name id notes script http interval service-id]
                       :as m})

(agent-register-check conn m {:as params})

Registers a new check with the local agent.

agent-register-service clj

(agent-register-service conn {:keys [id name tags address port check] :as m})

(agent-register-service conn m {:as params})

Registers a new local service.

agent-self clj

(agent-self conn)

(agent-self conn {:as params})

Returns the local node configuration.

agent-services clj

(agent-services conn)

(agent-services conn {:as params})

Returns all services registered with the local agent.

agent-warn-check clj

(agent-warn-check conn check-id)

(agent-warn-check conn check-id {:keys [note] :as params})

Marks a local test as warning.

base64->str clj

(base64->str s)

catalog-datacenters clj

(catalog-datacenters conn)

(catalog-datacenters conn {:as params})

catalog-deregister clj

(catalog-deregister conn entry)

(catalog-deregister conn
                    {:keys [datacenter node checkid serviceid] :as entry}
                    {:as params})

catalog-node clj

(catalog-node conn node)

(catalog-node conn node {:keys [dc] :as params})

catalog-nodes clj

(catalog-nodes conn)

(catalog-nodes conn {:keys [dc] :as params})

catalog-register clj

(catalog-register conn
                  {:keys [datacenter node address service check] :as entry})

(catalog-register conn entry {:as params})

Register a catalog entry. Low level - preferably

catalog-service clj

(catalog-service conn service)

(catalog-service conn service {:keys [tag dc] :as params})

catalog-services clj

(catalog-services conn)

(catalog-services conn {:keys [dc] :as params})

check? clj

(check? {:keys [Name HTTP TTL Script Interval] :as check})

Simple validation outlined in https://www.consul.io/docs/agent/checks.html.

consul clj

(consul conn method endpoint & [{:as request}])

Creates a request and calls consul using the HTTP API.

consul-200 clj

(consul-200 conn method endpoint params)

consul-index clj

(consul-index conn method endpoint params)

consul-pascal-case-substitutions clj

Differences from PascalCase used by Consul.

consul-request clj

(consul-request conn method endpoint & [{:as opts :keys [body]}])

Constructs a Consul HTTP request.

endpoint->path clj

(endpoint->path endpoint)

Converts a vector into the consul endpoint path.

event-fire clj

(event-fire conn name)

(event-fire conn name {:keys [node service tag] :as params})

event-list clj

(event-list conn)

(event-list conn {:keys [name] :as params})

ex-info? clj

(ex-info? x)

headers->index clj

(headers->index m)

Selects the X-Consul-* headers into a map with keywordized names.

health-state clj

(health-state conn state)

(health-state conn state {:as params})

Returns the checks in a given state (any, unknown, passing, warning or critical)

healthy-service? clj

(healthy-service? health-service)

Returns true if every check is passing for each object returned from /v1/health/service/<service>.

kv clj

kv-del clj

(kv-del conn k)

(kv-del conn k {:as params :keys [recurse?] :or {recurse? false}})

Deletes a key k from consul.

Parameters:

:dc - Optional data center in which to retrieve k, defaults agent's data center. :recurse? - If true, then consul it will delete all keys with the given prefix. Defaults to false. :cas - Uses a CAS index when deleting. Index must be non-zero and must match the ModifyIndex of the key to delete successfully

kv-get clj

(kv-get conn k)

(kv-get
  conn
  k
  {:keys [dc wait index raw? string?] :or {raw? false string? true} :as params})

Retrieves key k from consul given the following optional parameters.

Parameters:

:dc - Optional data center in which to retrieve k, defaults agent's data center. :wait - Used in conjunction with :index to get using a blocking query. e.g. 10s, 1m, etc. :index - The current Consul index, suitable for making subsequent calls to wait for changes since this query was last run.

:raw? - If true and used with a non-recursive GET, the response is just the raw value of the key, without any encoding. :string? - Converts the value returned for k into a string. Defaults to true.

kv-keys clj

(kv-keys conn prefix)

(kv-keys conn prefix {:keys [dc wait index separator] :as params})

Retrieves a set of keys using prefix.

Parameters:

:dc - Optional data center in which to retrieve k, defaults agent's data center. :wait - Used in conjunction with :index to get using a blocking query. e.g. 10s, 1m, etc. :index - The current Consul index, suitable for making subsequent calls to wait for changes since this query was last run.

:separator - List keys up to separator.

kv-map-convert clj

(kv-map-convert response convert?)

kv-put clj

(kv-put conn k v)

(kv-put conn k v {:keys [dc flags cas acquire release] :as params})

Sets key k with value v.

Parameters:

:dc - Optional data center in which to retrieve k, defaults agent's data center.

:flags - This can be used to specify an unsigned value between 0 and 2^(64-1). Stored against the key for client app use. :cas - Uses a CAS index when updating. If the index is 0, puts only if the key does not exist. If index is non-zero, index must match the ModifyIndex of that key. :acquire - Session ID. Updates using lock acquisition. A key does not need to exist to be acquired :release - Session ID. Yields a lock acquired with :acquire.

kv-recurse clj

(kv-recurse conn prefix)

(kv-recurse conn
            prefix
            {:as params :keys [string? map?] :or {string? true map? true}})

Retrieves key k from consul given the following optional parameters.

Parameters:

:dc - Optional data center in which to retrieve k, defaults agent's data center. :wait - Used in conjunction with :index to get using a blocking query. e.g. 10s, 1m, etc. :index - The current Consul index, suitable for making subsequent calls to wait for changes since this query was last run.

:string? - Converts the value returned for k into a string. Defaults to true.

leader clj

(leader conn)

Returns the current Raft leader.

local-conn clj

map->check clj

(map->check check)

Creates a check from a map. Returns a map with excessive capitalization conforming to consul's expectations.

Requires :script, :http or :ttl to be set.

Map keys:

:name - required :id - If not provided, is set to :name. However, duplicate :id values are not allowed. :notes - Free text. :script - Path of the script Consul should invoke as part of the check. :http - URL of the HTTP check. :interval - Required if :script or :http is set. :service-id - Associates the check with an existing service.

map->consulcase clj

(map->consulcase m)

mapify-response clj

(mapify-response prefix kvs)

Converts a list of kv's into a map, stripping off a given prefix

node-health clj

(node-health conn node)

(node-health conn node {:keys [dc] :as params})

Returns the health info of a node

parse-response clj

(parse-response response)

passing? clj

(passing? check)

Returns true if check is passing

peers clj

(peers conn)

Returns the Raft peers for the datacenter in which the agent is running.

service-health clj

(service-health conn service)

(service-health conn
                service
                {:keys [dc tag passing?] :or {passing? false} :as params})

Returns the nodes and health info of a service.

service-health-checks clj

(service-health-checks conn service)

(service-health-checks conn service {:as params})

Returns the checks of a service

session-create clj

(session-create conn)

(session-create conn
                {:keys [lock-delay node name checks behavior ttl] :as session})

(session-create conn session {:keys [dc] :as params})

Create a new consul session

session-destroy clj

(session-destroy conn session)

(session-destroy conn session {:keys [dc] :as params})

session-info clj

(session-info conn session)

(session-info conn session {:keys [dc] :as params})

session-list clj

(session-list conn)

(session-list conn {:keys [dc] :as params})

session-node clj

(session-node conn node)

(session-node conn node {:keys [dc] :as params})

session-renew clj

(session-renew conn session)

(session-renew conn session {:keys [dc] :as params})

Renews a session. NOTE the TTL on the response and use that as a basic on when to renew next time since consul may return a higher TTL, requesting that you renew less often (high server load)

shallow-nameify-keys clj

(shallow-nameify-keys m)

Returns a map with the root keys converted to strings using name.

str->base64 clj

(str->base64 s)

success? clj

(success? {:keys [status] :as resp})