vertx-lang-scala-docs_2.12 3.6.2 API - io.vertx.scala.ext.consul.ConsulClient

final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def agentInfo(resultHandler: Handler[AsyncResult[JsonObject]]): ConsulClient

Returns the configuration and member information of the local agent * @param resultHandler will be provided with the configuration and member information of the local agent

returns: reference to this, for fluency

def agentInfoFuture(): Future[JsonObject]

Like agentInfo but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def asInstanceOf[T0]: T0

Definition Classes: Any

def asJava: AnyRef

def catalogDatacenters(resultHandler: Handler[AsyncResult[Buffer[String]]]): ConsulClient

Return all the datacenters that are known by the Consul server * @param resultHandler will be provided with list of datacenters

returns: reference to this, for fluency

def catalogDatacentersFuture(): Future[Buffer[String]]

Like catalogDatacenters but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def catalogNodeServices(node: String, resultHandler: Handler[AsyncResult[ServiceList]]): ConsulClient

Returns the node's registered services * @param node node name

resultHandler: will be provided with list of services
returns: reference to this, for fluency

def catalogNodeServicesFuture(node: String): Future[ServiceList]

Like catalogNodeServices but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def catalogNodeServicesWithOptions(node: String, options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[ServiceList]]): ConsulClient

Returns the node's registered services This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#catalogNodeServices * @param node node name

options: the blocking options see BlockingQueryOptions
resultHandler: will be provided with list of services
returns: reference to this, for fluency

def catalogNodeServicesWithOptionsFuture(node: String, options: BlockingQueryOptions): Future[ServiceList]

Like catalogNodeServicesWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def catalogNodes(resultHandler: Handler[AsyncResult[NodeList]]): ConsulClient

Returns the nodes registered in a datacenter * @param resultHandler will be provided with list of nodes

returns: reference to this, for fluency

def catalogNodesFuture(): Future[NodeList]

Like catalogNodes but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def catalogNodesWithOptions(options: NodeQueryOptions, resultHandler: Handler[AsyncResult[NodeList]]): ConsulClient

Returns the nodes registered in a datacenter * @param options options used to request nodes see NodeQueryOptions

resultHandler: will be provided with list of nodes
returns: reference to this, for fluency

def catalogNodesWithOptionsFuture(options: NodeQueryOptions): Future[NodeList]

Like catalogNodesWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def catalogServiceNodes(service: String, resultHandler: Handler[AsyncResult[ServiceList]]): ConsulClient

Returns the nodes providing a service * @param service name of service

resultHandler: will be provided with list of nodes providing given service
returns: reference to this, for fluency

def catalogServiceNodesFuture(service: String): Future[ServiceList]

Like catalogServiceNodes but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def catalogServiceNodesWithOptions(service: String, options: ServiceQueryOptions, resultHandler: Handler[AsyncResult[ServiceList]]): ConsulClient

Returns the nodes providing a service * @param service name of service

options: options used to request services see ServiceQueryOptions
resultHandler: will be provided with list of nodes providing given service
returns: reference to this, for fluency

def catalogServiceNodesWithOptionsFuture(service: String, options: ServiceQueryOptions): Future[ServiceList]

Like catalogServiceNodesWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def catalogServices(resultHandler: Handler[AsyncResult[ServiceList]]): ConsulClient

Returns the services registered in a datacenter * @param resultHandler will be provided with list of services

returns: reference to this, for fluency

def catalogServicesFuture(): Future[ServiceList]

Like catalogServices but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def catalogServicesWithOptions(options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[ServiceList]]): ConsulClient

Returns the services registered in a datacenter This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#catalogServices * @param options the blocking options see BlockingQueryOptions

resultHandler: will be provided with list of services
returns: reference to this, for fluency

def catalogServicesWithOptionsFuture(options: BlockingQueryOptions): Future[ServiceList]

Like catalogServicesWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @native() @throws( ... )

def cloneAclToken(id: String, idHandler: Handler[AsyncResult[String]]): ConsulClient

Clone Acl token * @param id the ID of token to be cloned

idHandler: will be provided with ID of cloned token
returns: reference to this, for fluency

def cloneAclTokenFuture(id: String): Future[String]

Like cloneAclToken but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def close(): Unit

Close the client and release its resources

def coordinateDatacenters(resultHandler: Handler[AsyncResult[Buffer[DcCoordinates]]]): ConsulClient

Returns the WAN network coordinates for all Consul servers, organized by DCs * @param resultHandler will be provided with network coordinates for all Consul servers

returns: reference to this, for fluency

def coordinateDatacentersFuture(): Future[Buffer[DcCoordinates]]

Like coordinateDatacenters but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def coordinateNodes(resultHandler: Handler[AsyncResult[CoordinateList]]): ConsulClient

Returns the LAN network coordinates for all nodes in a given DC * @param resultHandler will be provided with network coordinates of nodes in datacenter

returns: reference to this, for fluency

def coordinateNodesFuture(): Future[CoordinateList]

Like coordinateNodes but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def coordinateNodesWithOptions(options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[CoordinateList]]): ConsulClient

Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#coordinateNodes * @param options the blocking options see BlockingQueryOptions

resultHandler: will be provided with network coordinates of nodes in datacenter
returns: reference to this, for fluency

def coordinateNodesWithOptionsFuture(options: BlockingQueryOptions): Future[CoordinateList]

Like coordinateNodesWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def createAclToken(token: AclToken, idHandler: Handler[AsyncResult[String]]): ConsulClient

Create new Acl token * @param token properties of the token see AclToken

idHandler: will be provided with ID of created token
returns: reference to this, for fluency

def createAclTokenFuture(token: AclToken): Future[String]

Like createAclToken but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def createPreparedQuery(definition: PreparedQueryDefinition, resultHandler: Handler[AsyncResult[String]]): ConsulClient

definition: definition of the prepare query see PreparedQueryDefinition
resultHandler: will be provided with id of created prepare query
returns: reference to this, for fluency

def createPreparedQueryFuture(definition: PreparedQueryDefinition): Future[String]

Like createPreparedQuery but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def createSession(idHandler: Handler[AsyncResult[String]]): ConsulClient

Initialize a new session * @param idHandler will be provided with ID of new session

returns: reference to this, for fluency

def createSessionFuture(): Future[String]

Like createSession but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def createSessionWithOptions(options: SessionOptions, idHandler: Handler[AsyncResult[String]]): ConsulClient

Initialize a new session * @param options options used to create session see SessionOptions

idHandler: will be provided with ID of new session
returns: reference to this, for fluency

def createSessionWithOptionsFuture(options: SessionOptions): Future[String]

Like createSessionWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def deletePreparedQuery(id: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Deletes an existing prepared query * @param id the id of the query to delete

resultHandler: will be called when complete
returns: reference to this, for fluency

def deletePreparedQueryFuture(id: String): Future[Unit]

Like deletePreparedQuery but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def deleteValue(key: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Remove the key/value pair that corresponding to the specified key * @param key the key

resultHandler: will be called on complete
returns: reference to this, for fluency

def deleteValueFuture(key: String): Future[Unit]

Like deleteValue but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def deleteValues(keyPrefix: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Removes all the key/value pair that corresponding to the specified key prefix * @param keyPrefix the prefix

resultHandler: will be called on complete
returns: reference to this, for fluency

def deleteValuesFuture(keyPrefix: String): Future[Unit]

Like deleteValues but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def deregisterCheck(checkId: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Remove a check from the local agent.

Remove a check from the local agent. The agent will take care of deregistering the check from the Catalog. * @param checkId the ID of check

resultHandler: will be called when complete
returns: reference to this, for fluency

def deregisterCheckFuture(checkId: String): Future[Unit]

Like deregisterCheck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def deregisterService(id: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Remove a service from the local agent.

Remove a service from the local agent. The agent will take care of deregistering the service with the Catalog. If there is an associated check, that is also deregistered. * @param id the ID of service

resultHandler: will be called when complete
returns: reference to this, for fluency

def deregisterServiceFuture(id: String): Future[Unit]

Like deregisterService but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def destroyAclToken(id: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Destroy Acl token * @param id the ID of token

resultHandler: will be called on complete
returns: reference to this, for fluency

def destroyAclTokenFuture(id: String): Future[Unit]

Like destroyAclToken but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def destroySession(id: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Destroys the given session * @param id the ID of session

resultHandler: will be called when complete
returns: reference to this, for fluency

def destroySessionFuture(id: String): Future[Unit]

Like destroySession but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def executePreparedQuery(query: String, resultHandler: Handler[AsyncResult[PreparedQueryExecuteResponse]]): ConsulClient

Executes an existing prepared query.

Executes an existing prepared query. * @param query the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.

resultHandler: will be provided with response
returns: reference to this, for fluency

def executePreparedQueryFuture(query: String): Future[PreparedQueryExecuteResponse]

Like executePreparedQuery but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def executePreparedQueryWithOptions(query: String, options: PreparedQueryExecuteOptions, resultHandler: Handler[AsyncResult[PreparedQueryExecuteResponse]]): ConsulClient

Executes an existing prepared query.

Executes an existing prepared query. * @param query the ID of the query to execute. This can also be the name of an existing prepared query, or a name that matches a prefix name for a prepared query template.

options: the options used to execute prepared query see PreparedQueryExecuteOptions
resultHandler: will be provided with response
returns: reference to this, for fluency

def executePreparedQueryWithOptionsFuture(query: String, options: PreparedQueryExecuteOptions): Future[PreparedQueryExecuteResponse]

Like executePreparedQueryWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def failCheck(checkId: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Set status of the check to "critical".

Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset. * @param checkId the ID of check

resultHandler: will be called when complete
returns: reference to this, for fluency

def failCheckFuture(checkId: String): Future[Unit]

Like failCheck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def failCheckWithNote(checkId: String, note: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Set status of the check to "critical".

Set status of the check to "critical". Used with a check that is of the TTL type. The TTL clock will be reset. * @param checkId the ID of check

note: specifies a human-readable message. This will be passed through to the check's Output field.
resultHandler: will be called when complete
returns: reference to this, for fluency

def failCheckWithNoteFuture(checkId: String, note: String): Future[Unit]

Like failCheckWithNote but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

def fireEvent(name: String, resultHandler: Handler[AsyncResult[Event]]): ConsulClient

Fires a new user event * @param name name of event

resultHandler: will be provided with properties of event
returns: reference to this, for fluency

def fireEventFuture(name: String): Future[Event]

Like fireEvent but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def fireEventWithOptions(name: String, options: EventOptions, resultHandler: Handler[AsyncResult[Event]]): ConsulClient

Fires a new user event * @param name name of event

options: options used to create event see EventOptions
resultHandler: will be provided with properties of event
returns: reference to this, for fluency

def fireEventWithOptionsFuture(name: String, options: EventOptions): Future[Event]

Like fireEventWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getAllPreparedQueries(resultHandler: Handler[AsyncResult[Buffer[PreparedQueryDefinition]]]): ConsulClient

Returns a list of all prepared queries.

Returns a list of all prepared queries. * @param resultHandler will be provided with list of definitions of the all prepare queries

returns: reference to this, for fluency

def getAllPreparedQueriesFuture(): Future[Buffer[PreparedQueryDefinition]]

Like getAllPreparedQueries but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native()

def getKeys(keyPrefix: String, resultHandler: Handler[AsyncResult[Buffer[String]]]): ConsulClient

Returns the list of keys that corresponding to the specified key prefix.

Returns the list of keys that corresponding to the specified key prefix. * @param keyPrefix the prefix

resultHandler: will be provided with keys list
returns: reference to this, for fluency

def getKeysFuture(keyPrefix: String): Future[Buffer[String]]

Like getKeys but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getKeysWithOptions(keyPrefix: String, options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[Buffer[String]]]): ConsulClient

Returns the list of keys that corresponding to the specified key prefix.

Returns the list of keys that corresponding to the specified key prefix. * @param keyPrefix the prefix

options: the blocking options see BlockingQueryOptions
resultHandler: will be provided with keys list
returns: reference to this, for fluency

def getKeysWithOptionsFuture(keyPrefix: String, options: BlockingQueryOptions): Future[Buffer[String]]

Like getKeysWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getPreparedQuery(id: String, resultHandler: Handler[AsyncResult[PreparedQueryDefinition]]): ConsulClient

Returns an existing prepared query * @param id the id of the query to read

resultHandler: will be provided with definition of the prepare query
returns: reference to this, for fluency

def getPreparedQueryFuture(id: String): Future[PreparedQueryDefinition]

Like getPreparedQuery but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getValue(key: String, resultHandler: Handler[AsyncResult[KeyValue]]): ConsulClient

Returns key/value pair that corresponding to the specified key.

Returns key/value pair that corresponding to the specified key. An empty KeyValue object will be returned if no such key is found. * @param key the key

resultHandler: will be provided with key/value pair
returns: reference to this, for fluency

def getValueFuture(key: String): Future[KeyValue]

Like getValue but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getValueWithOptions(key: String, options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[KeyValue]]): ConsulClient

Returns key/value pair that corresponding to the specified key.

Returns key/value pair that corresponding to the specified key. An empty KeyValue object will be returned if no such key is found. This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#getValue * @param key the key

options: the blocking options see BlockingQueryOptions
resultHandler: will be provided with key/value pair
returns: reference to this, for fluency

def getValueWithOptionsFuture(key: String, options: BlockingQueryOptions): Future[KeyValue]

Like getValueWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getValues(keyPrefix: String, resultHandler: Handler[AsyncResult[KeyValueList]]): ConsulClient

Returns the list of key/value pairs that corresponding to the specified key prefix.

Returns the list of key/value pairs that corresponding to the specified key prefix. An empty KeyValueList object will be returned if no such key prefix is found. * @param keyPrefix the prefix

resultHandler: will be provided with list of key/value pairs
returns: reference to this, for fluency

def getValuesFuture(keyPrefix: String): Future[KeyValueList]

Like getValues but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def getValuesWithOptions(keyPrefix: String, options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[KeyValueList]]): ConsulClient

Returns the list of key/value pairs that corresponding to the specified key prefix.

Returns the list of key/value pairs that corresponding to the specified key prefix. An empty KeyValueList object will be returned if no such key prefix is found. This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#getValues * @param keyPrefix the prefix

options: the blocking options see BlockingQueryOptions
resultHandler: will be provided with list of key/value pairs
returns: reference to this, for fluency

def getValuesWithOptionsFuture(keyPrefix: String, options: BlockingQueryOptions): Future[KeyValueList]

Like getValuesWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

def healthChecks(service: String, resultHandler: Handler[AsyncResult[CheckList]]): ConsulClient

Returns the checks associated with the service * @param service the service name

resultHandler: will be provided with list of checks
returns: reference to this, for fluency

def healthChecksFuture(service: String): Future[CheckList]

Like healthChecks but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def healthChecksWithOptions(service: String, options: CheckQueryOptions, resultHandler: Handler[AsyncResult[CheckList]]): ConsulClient

Returns the checks associated with the service * @param service the service name

options: options used to request checks see CheckQueryOptions
resultHandler: will be provided with list of checks
returns: reference to this, for fluency

def healthChecksWithOptionsFuture(service: String, options: CheckQueryOptions): Future[CheckList]

Like healthChecksWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def healthServiceNodes(service: String, passing: Boolean, resultHandler: Handler[AsyncResult[ServiceEntryList]]): ConsulClient

Returns the nodes providing the service.

Returns the nodes providing the service. This endpoint is very similar to the io.vertx.scala.ext.consul.ConsulClient#catalogServiceNodes endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks. * @param service the service name

passing: if true, filter results to only nodes with all checks in the passing state
resultHandler: will be provided with list of services
returns: reference to this, for fluency

def healthServiceNodesFuture(service: String, passing: Boolean): Future[ServiceEntryList]

Like healthServiceNodes but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def healthServiceNodesWithOptions(service: String, passing: Boolean, options: ServiceQueryOptions, resultHandler: Handler[AsyncResult[ServiceEntryList]]): ConsulClient

Returns the nodes providing the service.

Returns the nodes providing the service. This endpoint is very similar to the io.vertx.scala.ext.consul.ConsulClient#catalogServiceNodesWithOptions endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks. * @param service the service name

passing: if true, filter results to only nodes with all checks in the passing state
options: options used to request services see ServiceQueryOptions
resultHandler: will be provided with list of services
returns: reference to this, for fluency

def healthServiceNodesWithOptionsFuture(service: String, passing: Boolean, options: ServiceQueryOptions): Future[ServiceEntryList]

Like healthServiceNodesWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def healthState(healthState: HealthState, resultHandler: Handler[AsyncResult[CheckList]]): ConsulClient

Returns the checks in the specified status * @param healthState the health state

resultHandler: will be provided with list of checks
returns: reference to this, for fluency

def healthStateFuture(healthState: HealthState): Future[CheckList]

Like healthState but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def healthStateWithOptions(healthState: HealthState, options: CheckQueryOptions, resultHandler: Handler[AsyncResult[CheckList]]): ConsulClient

Returns the checks in the specified status * @param healthState the health state

options: options used to request checks see CheckQueryOptions
resultHandler: will be provided with list of checks
returns: reference to this, for fluency

def healthStateWithOptionsFuture(healthState: HealthState, options: CheckQueryOptions): Future[CheckList]

Like healthStateWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def infoAclToken(id: String, tokenHandler: Handler[AsyncResult[AclToken]]): ConsulClient

Get info of Acl token * @param id the ID of token

tokenHandler: will be provided with token
returns: reference to this, for fluency

def infoAclTokenFuture(id: String): Future[AclToken]

Like infoAclToken but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def infoSession(id: String, resultHandler: Handler[AsyncResult[Session]]): ConsulClient

Returns the requested session information * @param id the ID of requested session

resultHandler: will be provided with info of requested session
returns: reference to this, for fluency

def infoSessionFuture(id: String): Future[Session]

Like infoSession but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def infoSessionWithOptions(id: String, options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[Session]]): ConsulClient

Returns the requested session information This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#infoSession * @param id the ID of requested session

options: the blocking options see BlockingQueryOptions
resultHandler: will be provided with info of requested session
returns: reference to this, for fluency

def infoSessionWithOptionsFuture(id: String, options: BlockingQueryOptions): Future[Session]

Like infoSessionWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def leaderStatus(resultHandler: Handler[AsyncResult[String]]): ConsulClient

Get the Raft leader for the datacenter in which the agent is running.

Get the Raft leader for the datacenter in which the agent is running. It returns an address in format "10.1.10.12:8300" * @param resultHandler will be provided with address of cluster leader

returns: reference to this, for fluency

def leaderStatusFuture(): Future[String]

Like leaderStatus but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def listAclTokens(resultHandler: Handler[AsyncResult[Buffer[AclToken]]]): ConsulClient

Get list of Acl token * @param resultHandler will be provided with list of tokens

returns: reference to this, for fluency

def listAclTokensFuture(): Future[Buffer[AclToken]]

Like listAclTokens but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def listEvents(resultHandler: Handler[AsyncResult[EventList]]): ConsulClient

Returns the most recent events known by the agent * @param resultHandler will be provided with list of events

returns: reference to this, for fluency

def listEventsFuture(): Future[EventList]

Like listEvents but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def listEventsWithOptions(options: EventListOptions, resultHandler: Handler[AsyncResult[EventList]]): ConsulClient

Returns the most recent events known by the agent.

Returns the most recent events known by the agent. This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#listEvents. However, the semantics of this endpoint are slightly different. Most blocking queries provide a monotonic index and block until a newer index is available. This can be supported as a consequence of the total ordering of the consensus protocol. With gossip, there is no ordering, and instead X-Consul-Index maps to the newest event that matches the query.

In practice, this means the index is only useful when used against a single agent and has no meaning globally. Because Consul defines the index as being opaque, clients should not be expecting a natural ordering either. * @param options the blocking options see EventListOptions

resultHandler: will be provided with list of events
returns: reference to this, for fluency

def listEventsWithOptionsFuture(options: EventListOptions): Future[EventList]

Like listEventsWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def listNodeSessions(nodeId: String, resultHandler: Handler[AsyncResult[SessionList]]): ConsulClient

Returns the active sessions for a given node * @param nodeId the ID of node

resultHandler: will be provided with list of sessions
returns: reference to this, for fluency

def listNodeSessionsFuture(nodeId: String): Future[SessionList]

Like listNodeSessions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def listNodeSessionsWithOptions(nodeId: String, options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[SessionList]]): ConsulClient

Returns the active sessions for a given node This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#listNodeSessions * @param nodeId the ID of node

options: the blocking options see BlockingQueryOptions
resultHandler: will be provided with list of sessions
returns: reference to this, for fluency

def listNodeSessionsWithOptionsFuture(nodeId: String, options: BlockingQueryOptions): Future[SessionList]

Like listNodeSessionsWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def listSessions(resultHandler: Handler[AsyncResult[SessionList]]): ConsulClient

Returns the active sessions * @param resultHandler will be provided with list of sessions

returns: reference to this, for fluency

def listSessionsFuture(): Future[SessionList]

Like listSessions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def listSessionsWithOptions(options: BlockingQueryOptions, resultHandler: Handler[AsyncResult[SessionList]]): ConsulClient

Returns the active sessions This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#listSessions * @param options the blocking options see BlockingQueryOptions

resultHandler: will be provided with list of sessions
returns: reference to this, for fluency

def listSessionsWithOptionsFuture(options: BlockingQueryOptions): Future[SessionList]

Like listSessionsWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def localChecks(resultHandler: Handler[AsyncResult[Buffer[Check]]]): ConsulClient

Return all the checks that are registered with the local agent.

Return all the checks that are registered with the local agent. * @param resultHandler will be provided with list of checks

returns: reference to this, for fluency

def localChecksFuture(): Future[Buffer[Check]]

Like localChecks but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def localServices(resultHandler: Handler[AsyncResult[Buffer[Service]]]): ConsulClient

Returns list of services registered with the local agent.

Returns list of services registered with the local agent. * @param resultHandler will be provided with list of services

returns: reference to this, for fluency

def localServicesFuture(): Future[Buffer[Service]]

Like localServices but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def maintenanceService(maintenanceOptions: MaintenanceOptions, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Places a given service into "maintenance mode" * @param maintenanceOptions the maintenance options see MaintenanceOptions

resultHandler: will be called when complete
returns: reference to this, for fluency

def maintenanceServiceFuture(maintenanceOptions: MaintenanceOptions): Future[Unit]

Like maintenanceService but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

def passCheck(checkId: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Set status of the check to "passing".

Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset. * @param checkId the ID of check

resultHandler: will be called when complete
returns: reference to this, for fluency

def passCheckFuture(checkId: String): Future[Unit]

Like passCheck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def passCheckWithNote(checkId: String, note: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Set status of the check to "passing".

Set status of the check to "passing". Used with a check that is of the TTL type. The TTL clock will be reset. * @param checkId the ID of check

note: specifies a human-readable message. This will be passed through to the check's Output field.
resultHandler: will be called when complete
returns: reference to this, for fluency

def passCheckWithNoteFuture(checkId: String, note: String): Future[Unit]

Like passCheckWithNote but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def peersStatus(resultHandler: Handler[AsyncResult[Buffer[String]]]): ConsulClient

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

Retrieves the Raft peers for the datacenter in which the the agent is running. It returns a list of addresses "10.1.10.12:8300", "10.1.10.13:8300" * @param resultHandler will be provided with list of peers

returns: reference to this, for fluency

def peersStatusFuture(): Future[Buffer[String]]

Like peersStatus but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def putValue(key: String, value: String, resultHandler: Handler[AsyncResult[Boolean]]): ConsulClient

Adds specified key/value pair * @param key the key

value: the value
resultHandler: will be provided with success of operation
returns: reference to this, for fluency

def putValueFuture(key: String, value: String): Future[Boolean]

Like putValue but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def putValueWithOptions(key: String, value: String, options: KeyValueOptions, resultHandler: Handler[AsyncResult[Boolean]]): ConsulClient

key: the key
value: the value
options: options used to push pair see KeyValueOptions
resultHandler: will be provided with success of operation
returns: reference to this, for fluency

def putValueWithOptionsFuture(key: String, value: String, options: KeyValueOptions): Future[Boolean]

Like putValueWithOptions but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def registerCheck(checkOptions: CheckOptions, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Add a new check to the local agent.

Add a new check to the local agent. The agent is responsible for managing the status of the check and keeping the Catalog in sync. * @param checkOptions options used to register new check see CheckOptions

resultHandler: will be called when complete
returns: reference to this, for fluency

def registerCheckFuture(checkOptions: CheckOptions): Future[Unit]

Like registerCheck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def registerService(serviceOptions: ServiceOptions, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Adds a new service, with an optional health check, to the local agent.

Adds a new service, with an optional health check, to the local agent. * @param serviceOptions the options of new service see ServiceOptions

resultHandler: will be called when complete
returns: reference to this, for fluency

def registerServiceFuture(serviceOptions: ServiceOptions): Future[Unit]

Like registerService but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def renewSession(id: String, resultHandler: Handler[AsyncResult[Session]]): ConsulClient

Renews the given session.

Renews the given session. This is used with sessions that have a TTL, and it extends the expiration by the TTL * @param id the ID of session that should be renewed

resultHandler: will be provided with info of renewed session
returns: reference to this, for fluency

def renewSessionFuture(id: String): Future[Session]

Like renewSession but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def toString(): String

Definition Classes: AnyRef → Any

def transaction(request: TxnRequest, resultHandler: Handler[AsyncResult[TxnResponse]]): ConsulClient

Manages multiple operations inside a single, atomic transaction.

Manages multiple operations inside a single, atomic transaction. * @param request transaction request see TxnRequest

resultHandler: will be provided with result of transaction
returns: reference to this, for fluency

def transactionFuture(request: TxnRequest): Future[TxnResponse]

Like transaction but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def updateAclToken(token: AclToken, idHandler: Handler[AsyncResult[String]]): ConsulClient

Update Acl token * @param token properties of the token to be updated see AclToken

idHandler: will be provided with ID of updated
returns: reference to this, for fluency

def updateAclTokenFuture(token: AclToken): Future[String]

Like updateAclToken but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def updateCheck(checkId: String, status: CheckStatus, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Set status of the check to given status.

Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset. * @param checkId the ID of check

status: new status of check
resultHandler: will be called when complete
returns: reference to this, for fluency

def updateCheckFuture(checkId: String, status: CheckStatus): Future[Unit]

Like updateCheck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def updateCheckWithNote(checkId: String, status: CheckStatus, note: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Set status of the check to given status.

Set status of the check to given status. Used with a check that is of the TTL type. The TTL clock will be reset. * @param checkId the ID of check

status: new status of check
note: specifies a human-readable message. This will be passed through to the check's Output field.
resultHandler: will be called when complete
returns: reference to this, for fluency

def updateCheckWithNoteFuture(checkId: String, status: CheckStatus, note: String): Future[Unit]

Like updateCheckWithNote but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def updatePreparedQuery(definition: PreparedQueryDefinition, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

definition: definition of the prepare query see PreparedQueryDefinition
resultHandler: will be called when complete
returns: reference to this, for fluency

def updatePreparedQueryFuture(definition: PreparedQueryDefinition): Future[Unit]

Like updatePreparedQuery but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @native() @throws( ... )

def warnCheck(checkId: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Set status of the check to "warning".

Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset. * @param checkId the ID of check

resultHandler: will be called when complete
returns: reference to this, for fluency

def warnCheckFuture(checkId: String): Future[Unit]

Like warnCheck but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

def warnCheckWithNote(checkId: String, note: String, resultHandler: Handler[AsyncResult[Unit]]): ConsulClient

Set status of the check to "warning".

Set status of the check to "warning". Used with a check that is of the TTL type. The TTL clock will be reset. * @param checkId the ID of check

note: specifies a human-readable message. This will be passed through to the check's Output field.
resultHandler: will be called when complete
returns: reference to this, for fluency

def warnCheckWithNoteFuture(checkId: String, note: String): Future[Unit]

Like warnCheckWithNote but returns a scala.concurrent.Future instead of taking an AsyncResultHandler.

Packages

ConsulClient

Companion object ConsulClient

class ConsulClient extends AnyRef

Instance Constructors

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped