# Vert.x Consul Client

Consul is a tool for discovering and configuring services in your infrastructure.

A Vert.x client allowing applications to interact with a Consul system via blocking and non-blocking HTTP API.

## Using Vert.x Consul Client

To use this project, add the following dependency to the dependencies section of your build descriptor:

- Maven (in your `pom.xml`):

    <dependency>
      <groupId>io.vertx</groupId>
      <artifactId>vertx-consul-client-scala_2.12</artifactId>
      <version>3.5.3.CR1</version>
    </dependency>

- Gradle (in your `build.gradle` file):

    compile 'io.vertx:vertx-consul-client-scala_2.12:3.5.3.CR1'

## Creating a client

Just use factory method:

    var client = ConsulClient.create(vertx)

Also the client can be configured with an options.

    var options = ConsulClientOptions()
      .setHost("consul.example.com")

    var client = ConsulClient.create(vertx, options)

The following configuration is supported by the consul client:

`host`

  Consul host. Defaults to `localhost`

`port`

  Consul HTTP API port. Defaults to `8500`

`timeout`

  Sets the amount of time (in milliseconds) after which if the request does not return any data within the timeout period an failure will be passed to the handler and the request will be closed.

`aclToken`

  The ACL token. When provided, the client will use this token when making requests to the Consul by providing the "?token" query parameter. When not provided, the empty token, which maps to the 'anonymous' ACL policy, is used.

`dc`

  The datacenter name. When provided, the client will use it when making requests to the Consul by providing the "?dc" query parameter. When not provided, the datacenter of the consul agent is queried.

ConsulClient options extends WebClientOptions from `vertx-web-client` module, therefore a lot of settings are available. Please see the documentation.

## Using the API

The client API is represented by `ConsulClient`. The API is very similar to Consul’s HTTP API that described in Consul API docs

### Blocking queries

Certain endpoints support a feature called a "blocking query." A blocking query is used to wait for a potential change using long polling. Any endpoint that supports blocking also provide a unique identifier (index) representing the current state of the requested resource. The following configuration is used to perform blocking queries:

`index`

  value indicating that the client wishes to wait for any changes subsequent to that index.

`wait`

  parameter specifying a maximum duration for the blocking request. This is limited to 10 minutes.

    var opts = BlockingQueryOptions()
      .setIndex(lastIndex)
      .setWait("1m")

A critical note is that the return of a blocking request is no guarantee of a change. It is possible that the timeout was reached or that there was an idempotent write that does not affect the result of the query.

## Key/Value Store

The KV endpoints are used to access Consul’s simple key/value store, useful for storing service configuration or other metadata. The following endpoints are supported:

- To manage updates of individual keys, deletes of individual keys or key prefixes, and fetches of individual keys or key prefixes

- To manage updates or fetches of multiple keys inside a single, atomic transaction

### Get key-value pair from store

Consul client can return the value for certain key

    consulClient.getValueFuture("key").onComplete{
      case Success(result) => {
        println(s"retrieved value: ${todo-renderDataObjectMemberSelect}")
        println(s"modify index: ${todo-renderDataObjectMemberSelect}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

…​or it can return all key-value pairs with the given prefix

    consulClient.getValuesFuture("prefix").onComplete{
      case Success(result) => {
        println(s"modify index: ${todo-renderDataObjectMemberSelect}")
        todo-renderDataObjectMemberSelect.foreach(kv => {
          println(s"retrieved value: ${todo-renderDataObjectMemberSelect}")
        })

      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

The returned key-value object contains these fields (see documentation):

`createIndex`

  the internal index value that represents when the entry was created.

`modifyIndex`

  the last index that modified this key

`lockIndex`

  the number of times this key has successfully been acquired in a lock

`key`

  the key

`flags`

  the flags attached to this entry. Clients can choose to use this however makes sense for their application

`value`

  the value

`session`

  the session that owns the lock

The modify index can be used for blocking queries:

    var opts = BlockingQueryOptions()
      .setIndex(modifyIndex)
      .setWait("1m")

    consulClient.getValueWithOptionsFuture("key", opts).onComplete{
      case Success(result) => {
        println(s"retrieved value: ${todo-renderDataObjectMemberSelect}")
        println(s"new modify index: ${todo-renderDataObjectMemberSelect}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

### Put key-value pair to store

    consulClient.putValueFuture("key", "value").onComplete{
      case Success(result) => {
        var opResult = result ? "success" : "fail"
        println(s"result of the operation: ${opResult}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

Put request with options also accepted

    var opts = KeyValueOptions()
      .setFlags(42)
      .setCasIndex(modifyIndex)
      .setAcquireSession("acquireSessionID")
      .setReleaseSession("releaseSessionID")

    consulClient.putValueWithOptionsFuture("key", "value", opts).onComplete{
      case Success(result) => {
        var opResult = result ? "success" : "fail"
        println(s"result of the operation: ${opResult}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

The list of the query options that can be used with a `PUT` request:

`flags`

  This can be used to specify an unsigned value between `0` and `264-1`. Clients can choose to use this however makes sense for their application.

`casIndex`

  This flag is used to turn the PUT into a Check-And-Set operation. This is very useful as a building block for more complex synchronization primitives. If the index is `0`, Consul will only put the key if it does not already exist. If the index is non-zero, the key is only set if the index matches the ModifyIndex of that key.

`acquireSession`

  This flag is used to turn the PUT into a lock acquisition operation. This is useful as it allows leader election to be built on top of Consul. If the lock is not held and the session is valid, this increments the LockIndex and sets the Session value of the key in addition to updating the key contents. A key does not need to exist to be acquired. If the lock is already held by the given session, then the LockIndex is not incremented but the key contents are updated. This lets the current lock holder update the key contents without having to give up the lock and reacquire it.

`releaseSession`

  This flag is used to turn the PUT into a lock release operation. This is useful when paired with `acquireSession` as it allows clients to yield a lock. This will leave the LockIndex unmodified but will clear the associated Session of the key. The key must be held by this session to be unlocked.

### Transactions

When connected to Consul 0.7 and later, client allows to manage updates or fetches of multiple keys inside a single, atomic transaction. KV is the only available operation type, though other types of operations may be added in future versions of Consul to be mixed with key/value operations (see documentation).

    var request = TxnRequest()
      .setOperations(Set(TxnKVOperation()
        .setKey("key1")
        .setValue("value1")
        .setType(TxnKVVerb.SET)
      , TxnKVOperation()
        .setKey("key2")
        .setValue("value2")
        .setType(TxnKVVerb.SET)
      ))

    consulClient.transactionFuture(request).onComplete{
      case Success(result) => {
        println(s"succeeded results: ${todo-renderDataObjectMemberSelect.size}")
        println(s"errors: ${todo-renderDataObjectMemberSelect.size}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

### Delete key-value pair

At last, Consul client allows to delete key-value pair from store:

    consulClient.deleteValueFuture("key").onComplete{
      case Success(result) => {
        println("complete")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

…​or all key-value pairs with corresponding key prefix

    consulClient.deleteValuesFuture("prefix").onComplete{
      case Success(result) => {
        println("complete")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

## Services

One of the main goals of service discovery is to provide a catalog of available services. To that end, the agent provides a simple service definition format to declare the availability of a service and to potentially associate it with a health check.

### Service registering

A service definition must include a `name` and may optionally provide an `id`, `tags`, `address`, `port`, and `checks`.

    var opts = ServiceOptions()
      .setName("serviceName")
      .setId("serviceId")
      .setTags(List("tag1", "tag2"))
      .setCheckOptions(CheckOptions()
        .setTtl("10s")
      )
      .setAddress("10.0.0.1")
      .setPort(8048)

`name`

  the name of service

`id`

  the `id` is set to the `name` if not provided. It is required that all services have a unique ID per node, so if names might conflict then unique IDs should be provided.

`tags`

  list of values that are opaque to Consul but can be used to distinguish between primary or secondary nodes, different versions, or any other service level labels.

`address`

  used to specify a service-specific IP address. By default, the IP address of the agent is used, and this does not need to be provided.

`port`

  used as well to make a service-oriented architecture simpler to configure; this way, the address and port of a service can be discovered.

`checks`

  associated health checks

These options used to register service in catalog:

    consulClient.registerServiceFuture(opts).onComplete{
      case Success(result) => {
        println("Service successfully registered")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

### Service discovery

Consul client allows to obtain actual list of the nodes providing a service

    consulClient.catalogServiceNodesFuture("serviceName").onComplete{
      case Success(result) => {
        println(s"found ${todo-renderDataObjectMemberSelect.size} services")
        println(s"consul state index: ${todo-renderDataObjectMemberSelect}")
        todo-renderDataObjectMemberSelect.foreach(service => {
          println(s"Service node: ${todo-renderDataObjectMemberSelect}")
          println(s"Service address: ${todo-renderDataObjectMemberSelect}")
          println(s"Service port: ${todo-renderDataObjectMemberSelect}")
        })

      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

It is possible to obtain this list with the statuses of the associated health checks. The result can be filtered by check status.

    consulClient.healthServiceNodesFuture("serviceName", passingOnly).onComplete{
      case Success(result) => {
        println(s"found ${todo-renderDataObjectMemberSelect.size} services")
        println(s"consul state index: ${todo-renderDataObjectMemberSelect}")
        todo-renderDataObjectMemberSelect.foreach(entry => {
          println(s"Service node: ${todo-renderDataObjectMemberSelect}")
          println(s"Service address: ${todo-renderDataObjectMemberSelect}")
          println(s"Service port: ${todo-renderDataObjectMemberSelect}")
        })

      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

There are additional parameters for services queries

    var queryOpts = ServiceQueryOptions()
      .setTag("tag1")
      .setNear("_agent")
      .setBlockingOptions(BlockingQueryOptions()
        .setIndex(lastIndex)
      )

`tag`

  by default, all nodes matching the service are returned. The list can be filtered by tag using the `tag` query parameter

`near`

  adding the optional `near` parameter with a node name will sort the node list in ascending order based on the estimated round trip time from that node. Passing `near`=`_agent` will use the agent’s node for the sort.

`blockingOptions`

  the blocking qyery options

Then the request should look like

    consulClient.healthServiceNodesWithOptionsFuture("serviceName", passingOnly, queryOpts).onComplete{
      case Success(result) => {
        println(s"found ${todo-renderDataObjectMemberSelect.size} services")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

### Deregister service

Service can be deregistered by its ID:

    consulClient.deregisterServiceFuture("serviceId").onComplete{
      case Success(result) => {
        println("Service successfully deregistered")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

## Health Checks

One of the primary roles of the agent is management of system-level and application-level health checks. A health check is considered to be application-level if it is associated with a service. If not associated with a service, the check monitors the health of the entire node.

    var opts = CheckOptions()
      .setTcp("localhost:4848")
      .setInterval("1s")

The list of check options that supported by Consul client is:

`id`

  the check ID

`name`

  check name

`script`

  local path to checking script. Also you should set checking interval

`http`

  HTTP address to check. Also you should set checking interval

`ttl`

  Time to Live of check

`tcp`

  TCP address to check. Also you should set checking interval

`interval`

  checking interval in Go’s time format which is sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m". Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h"

`notes`

  the check notes

`serviceId`

  the service ID to associate the registered check with an existing service provided by the agent.

`deregisterAfter`

  deregister timeout. This is optional field, which is a timeout in the same time format as Interval and TTL. If a check is associated with a service and has 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.

`status`

  the check status to specify the initial state of the health check

The `Name` field is mandatory, as is one of `Script`, `HTTP`, `TCP` or `TTL`. `Script`, `TCP` and `HTTP` also require that `Interval` be set. If an `ID` is not provided, it is set to `Name`. You cannot have duplicate ID entries per agent, so it may be necessary to provide an ID.

    consulClient.registerCheckFuture(opts).onComplete{
      case Success(result) => {
        println("check successfully registered")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

## Events

The Consul provides a mechanism to fire a custom user event to an entire datacenter. These events are opaque to Consul, but they can be used to build scripting infrastructure to do automated deploys, restart services, or perform any other orchestration action.

To send user event only its name is required

    consulClient.fireEventFuture("eventName").onComplete{
      case Success(result) => {
        println("Event sent")
        println(s"id: ${todo-renderDataObjectMemberSelect}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

Also additional options can be specified.

`node`

  regular expression to filter recipients by node name

`service`

  regular expression to filter recipients by service

`tag`

  regular expression to filter recipients by tag

`payload`

  an optional body of the event. The body contents are opaque to Consul and become the "payload" of the event

    var opts = EventOptions()
      .setTag("tag")
      .setPayload("message")

    consulClient.fireEventWithOptionsFuture("eventName", opts).onComplete{
      case Success(result) => {
        println("Event sent")
        println(s"id: ${todo-renderDataObjectMemberSelect}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

The Consul Client supports queries for obtain the most recent events known by the agent. Events are broadcast using the gossip protocol, so they have no global ordering nor do they make a promise of delivery. Agents only buffer the most recent entries. The current buffer size is 256, but this value could change in the future.

    consulClient.listEventsFuture().onComplete{
      case Success(result) => {
        println(s"Consul index: ${todo-renderDataObjectMemberSelect}")
        todo-renderDataObjectMemberSelect.foreach(event => {
          println(s"Event id: ${todo-renderDataObjectMemberSelect}")
          println(s"Event name: ${todo-renderDataObjectMemberSelect}")
          println(s"Event payload: ${todo-renderDataObjectMemberSelect}")
        })

      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

The Consul Index can be used to prepare blocking requests:

    var opts = EventListOptions()
      .setName("eventName")
      .setBlockingOptions(BlockingQueryOptions()
        .setIndex(lastIndex)
      )

    consulClient.listEventsWithOptionsFuture(opts).onComplete{
      case Success(result) => {
        println(s"Consul index: ${todo-renderDataObjectMemberSelect}")
        todo-renderDataObjectMemberSelect.foreach(event => {
          println(s"Event id: ${todo-renderDataObjectMemberSelect}")
        })

      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

## Sessions

Consul provides a session mechanism which can be used to build distributed locks. Sessions act as a binding layer between nodes, health checks, and key/value data. When a session is constructed, a node name, a list of health checks, a behavior, a TTL, and a lock-delay may be provided.

    var opts = SessionOptions()
      .setNode("nodeId")
      .setBehavior(SessionBehavior.RELEASE)

`lockDelay`

  can be specified as a duration string using an 's' suffix for seconds. The default is '15s'.

`name`

  can be used to provide a human-readable name for the Session.

`node`

  must refer to a node that is already registered, if specified. By default, the agent’s own node name is used.

`checks`

  is used to provide a list of associated health checks. It is highly recommended that, if you override this list, you include the default `serfHealth`.

`behavior`

  can be set to either `release` or `delete`. This controls the behavior when a session is invalidated. By default, this is `release`, causing any locks that are held to be released. Changing this to `delete` causes any locks that are held to be deleted. `delete` is useful for creating ephemeral key/value entries.

`ttl`

  is a duration string, and like `LockDelay` it can use s as a suffix for seconds. If specified, it must be between 10s and 86400s currently. When provided, the session is invalidated if it is not renewed before the TTL expires.

For full info see Consul Sessions internals

The newly constructed session is provided with a named ID that can be used to identify it. This ID can be used with the KV store to acquire locks: advisory mechanisms for mutual exclusion.

    consulClient.createSessionWithOptionsFuture(opts).onComplete{
      case Success(result) => {
        println("Session successfully created")
        println(s"id: ${result}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

And also to destroy it

    consulClient.destroySessionFuture(sessionId).onComplete{
      case Success(result) => {
        println("Session successfully destroyed")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

Lists sessions belonging to a node

    consulClient.listNodeSessionsFuture("nodeId").onComplete{
      case Success(result) => {
        todo-renderDataObjectMemberSelect.foreach(session => {
          println(s"Session id: ${todo-renderDataObjectMemberSelect}")
          println(s"Session node: ${todo-renderDataObjectMemberSelect}")
          println(s"Session create index: ${todo-renderDataObjectMemberSelect}")
        })

      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

All of the read session endpoints support blocking queries and all consistency modes.

    var blockingOpts = BlockingQueryOptions()
      .setIndex(lastIndex)

    consulClient.listSessionsWithOptionsFuture(blockingOpts).onComplete{
      case Success(result) => {
        println(s"Found ${todo-renderDataObjectMemberSelect.size} sessions")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

## Nodes in datacenter

    consulClient.catalogNodesFuture().onComplete{
      case Success(result) => {
        println(s"found ${todo-renderDataObjectMemberSelect.size} nodes")
        println(s"consul state index ${todo-renderDataObjectMemberSelect}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

This endpoint supports blocking queries and sorting by distance from specified node

    var opts = NodeQueryOptions()
      .setNear("_agent")
      .setBlockingOptions(BlockingQueryOptions()
        .setIndex(lastIndex)
      )

    consulClient.catalogNodesWithOptionsFuture(opts).onComplete{
      case Success(result) => {
        println(s"found ${todo-renderDataObjectMemberSelect.size} nodes")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

## Prepated Queries

This endpoint creates, updates, destroys, and executes prepared queries. Prepared queries allow you to register a complex service query and then execute it later via its ID or name to get a set of healthy nodes that provide a given service. This is particularly useful in combination with Consul’s DNS Interface as it allows for much richer queries than would be possible given the limited entry points exposed by DNS.

There are many parameters to creating a prepared query. For full details please see docs

`dc`

  Specifies the datacenter to query. This will default to the datacenter of the agent being queried. This is specified as part of the URL as a query parameter.

`name`

  Specifies an optional friendly name that can be used to execute a query instead of using its ID.

`session`

  Specifies the ID of an existing session. This provides a way to automatically remove a prepared query when the given session is invalidated. If not given the prepared query must be manually removed when no longer needed.

`token`

  Specifies the ACL token to use each time the query is executed. This allows queries to be executed by clients with lesser or even no ACL Token, so this should be used with care. The token itself can only be seen by clients with a management token. If the Token field is left blank or omitted, the client’s ACL Token will be used to determine if they have access to the service being queried. If the client does not supply an ACL Token, the anonymous token will be used.

`service`

  Specifies the name of the service to query. This is required field.

`failover`

  contains two fields, both of which are optional, and determine what happens if no healthy nodes are available in the local datacenter when the query is executed. It allows the use of nodes in other datacenters with very little configuration.

`nearestN`

  Specifies that the query will be forwarded to up to NearestN other datacenters based on their estimated network round trip time using Network Coordinates from the WAN gossip pool. The median round trip time from the server handling the query to the servers in the remote datacenter is used to determine the priority.

`datacenters`

  Specifies a fixed list of remote datacenters to forward the query to if there are no healthy nodes in the local datacenter. Datacenters are queried in the order given in the list. If this option is combined with NearestN, then the NearestN queries will be performed first, followed by the list given by Datacenters. A given datacenter will only be queried one time during a failover, even if it is selected by both NearestN and is listed in Datacenters.

`onlyPassing`

  Specifies the behavior of the query’s health check filtering. If this is set to false, the results will include nodes with checks in the passing as well as the warning states. If this is set to true, only nodes with checks in the passing state will be returned.

`tags`

  Specifies a list of service tags to filter the query results. For a service to pass the tag filter it must have all of the required tags, and none of the excluded tags (prefixed with !).

`nodeMeta`

  Specifies a list of user-defined key/value pairs that will be used for filtering the query results to nodes with the given metadata values present.

`dnsTtl`

  Specifies the TTL duration when query results are served over DNS. If this is specified, it will take precedence over any Consul agent-specific configuration.

`templateType`

  is the query type, which must be `name_prefix_match`. This means that the template will apply to any query lookup with a name whose prefix matches the Name field of the template. In this example, any query for geo-db will match this query. Query templates are resolved using a longest prefix match, so it’s possible to have high-level templates that are overridden for specific services. Static queries are always resolved first, so they can also override templates.

`templateRegexp`

  is an optional regular expression which is used to extract fields from the entire name, once this template is selected. In this example, the regular expression takes the first item after the "-" as the database name and everything else after as a tag. See the RE2 reference for syntax of this regular expression.

    var def = PreparedQueryDefinition()
      .setName("Query name")
      .setService("service-${match(1)}-${match(2)}")
      .setDcs(List("dc1", "dc42"))
      .setTemplateType("name_prefix_match")
      .setTemplateRegexp("^find_(.+?)_(.+?)$")

If the query is successfully created, its ID will be provided

    consulClient.createPreparedQueryFuture(def).onComplete{
      case Success(result) => {
        var queryId = result
        println(s"Query created: ${queryId}")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

The prepared query can be executed by its id

    consulClient.executePreparedQueryFuture(id).onComplete{
      case Success(result) => {
        var response = result
        println(s"Found ${todo-renderDataObjectMemberSelect.size} nodes")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

or by query string that must match template regexp

    consulClient.executePreparedQueryFuture("find_1_2").onComplete{
      case Success(result) => {
        var response = result
        println(s"Found ${todo-renderDataObjectMemberSelect.size} nodes")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

Finally, `ConsulClient` allows you to modify, get or delete prepared queries

    consulClient.deletePreparedQueryFuture(query).onComplete{
      case Success(result) => {
        println("Query deleted")
      }
      case Failure(cause) => {
        println(s"$cause")
      }
    }

## Watches

Watches are a way of specifying a view of data (e.g. list of nodes, KV pairs, health checks) which is monitored for updates. When an update is detected, an `Handler` with `AsyncResult` is invoked. As an example, you could watch the status of health checks and notify when a check is critical.

    Watch.key("foo/bar", vertx).setHandler((res: io.vertx.scala.ext.consul.WatchResult<io.vertx.scala.ext.consul.KeyValue>) => {
      if (res.succeeded()) {
        println(s"value: ${todo-renderDataObjectMemberSelect}")
      } else {
        res.cause().printStackTrace()
      }
    }).start()