vertx-lang-scala-docs_2.12 3.5.3 API - io.vertx.scala.ext.consul.ConsulService

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]]): ConsulService

Returns the configuration and member information of the local agent

resultHandler: will be provided with the configuration and member information of the local agent
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

def agentInfoFuture(): Future[JsonObject]

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

Definition Classes: ConsulService → ConsulClient

final def asInstanceOf[T0]: T0

Definition Classes: Any

def asJava: AnyRef

Definition Classes: ConsulClient

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

Return all the datacenters that are known by the Consul server

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the node's registered services

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the node's registered services This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#catalogNodeServicesFuture

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the nodes registered in a datacenter

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

Definition Classes: ConsulService → ConsulClient

def catalogNodesFuture(): Future[NodeList]

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

Definition Classes: ConsulService → ConsulClient

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

Returns the nodes registered in a datacenter

options: options used to request nodessee NodeQueryOptions
resultHandler: will be provided with list of nodes
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the nodes providing a service

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the nodes providing a service

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the services registered in a datacenter

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

Definition Classes: ConsulService → ConsulClient

def catalogServicesFuture(): Future[ServiceList]

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

Definition Classes: ConsulService → ConsulClient

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

Returns the services registered in a datacenter This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#catalogServicesFuture

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

def clone(): AnyRef

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

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

Clone Acl token

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

def close(): Unit

Close the client and release its resources

Definition Classes: ConsulService → ConsulClient

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

Returns the WAN network coordinates for all Consul servers, organized by DCs

resultHandler: will be provided with network coordinates for all Consul servers
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the LAN network coordinates for all nodes in a given DC

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

Definition Classes: ConsulService → ConsulClient

def coordinateNodesFuture(): Future[CoordinateList]

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

Definition Classes: ConsulService → ConsulClient

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

Returns the LAN network coordinates for all nodes in a given DC This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#coordinateNodesFuture

options: the blocking optionssee BlockingQueryOptions
resultHandler: will be provided with network coordinates of nodes in datacenter
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Create new Acl token

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Initialize a new session

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

Definition Classes: ConsulService → ConsulClient

def createSessionFuture(): Future[String]

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

Definition Classes: ConsulService → ConsulClient

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

Initialize a new session

options: options used to create sessionsee SessionOptions
idHandler: will be provided with ID of new session
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Deletes an existing prepared query

id: the id of the query to delete
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Remove the key/value pair that corresponding to the specified key

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Removes all the key/value pair that corresponding to the specified key prefix

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

checkId: the ID of check
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

id: the ID of service
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Destroy Acl token

id: the ID of token
resultHandler: will be called on complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Destroys the given session

id: the ID of session
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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]]): ConsulService

Executes an existing prepared query.

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Executes an existing prepared query.

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 querysee PreparedQueryExecuteOptions
resultHandler: will be provided with response
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

checkId: the ID of check
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

checkId: the ID of check
note: a human-readable message with the status of the check
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

def finalize(): Unit

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

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

Fires a new user event

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Fires a new user event

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns a list of all prepared queries.

resultHandler: will be provided with list of definitions of the all prepare queries
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

final def getClass(): Class[_]

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

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

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns an existing prepared query

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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#getValueFuture

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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#getValuesFuture

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

def hashCode(): Int

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

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

Returns the checks associated with the service

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the checks associated with the service

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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#catalogServiceNodesFuture endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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#catalogServiceNodesWithOptionsFuture endpoint; however, this endpoint automatically returns the status of the associated health check as well as any system level health checks.

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

def healthState(checkStatus: CheckStatus, resultHandler: Handler[AsyncResult[CheckList]]): ConsulService

Returns the checks in the specified status

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

Definition Classes: ConsulService → ConsulClient

def healthStateFuture(checkStatus: CheckStatus): Future[CheckList]

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

Definition Classes: ConsulService → ConsulClient

def healthStateWithOptions(checkStatus: CheckStatus, options: CheckQueryOptions, resultHandler: Handler[AsyncResult[CheckList]]): ConsulService

Returns the checks in the specified status

checkStatus: the check status
options: options used to request checkssee CheckQueryOptions
resultHandler: will be provided with list of checks
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

def healthStateWithOptionsFuture(checkStatus: CheckStatus, options: CheckQueryOptions): Future[CheckList]

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

Definition Classes: ConsulService → ConsulClient

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

Get info of Acl token

id: the ID of token
tokenHandler: will be provided with token
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the requested session information

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the requested session information This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#infoSessionFuture

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

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

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"

resultHandler: will be provided with address of cluster leader
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

def leaderStatusFuture(): Future[String]

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

Definition Classes: ConsulService → ConsulClient

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

Get list of Acl token

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the most recent events known by the agent

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

Definition Classes: ConsulService → ConsulClient

def listEventsFuture(): Future[EventList]

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

Definition Classes: ConsulService → ConsulClient

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

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#listEventsFuture. 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.

options: the blocking optionssee EventListOptions
resultHandler: will be provided with list of events
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the active sessions for a given node

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the active sessions for a given node This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#listNodeSessionsFuture

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns the active sessions

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

Definition Classes: ConsulService → ConsulClient

def listSessionsFuture(): Future[SessionList]

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

Definition Classes: ConsulService → ConsulClient

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

Returns the active sessions This is blocking query unlike io.vertx.scala.ext.consul.ConsulClient#listSessionsFuture

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Returns list of services registered with the local agent.

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Places a given service into "maintenance mode"

maintenanceOptions: the maintenance optionssee MaintenanceOptions
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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]]): ConsulService

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.

checkId: the ID of check
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

checkId: the ID of check
note: a human-readable message with the status of the check
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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"

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Adds specified key/value pair

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

checkOptions: options used to register new checksee CheckOptions
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

serviceOptions: the options of new servicesee ServiceOptions
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

id: the ID of session that should be renewed
resultHandler: will be provided with info of renewed session
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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]]): ConsulService

Manages multiple operations inside a single, atomic transaction.

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

Update Acl token

token: properties of the token to be updatedsee AclToken
idHandler: will be provided with ID of updated
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

checkId: the ID of check
status: new status of check
note: a human-readable message with the status of the check
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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]]): ConsulService

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.

checkId: the ID of check
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

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

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.

checkId: the ID of check
note: a human-readable message with the status of the check
resultHandler: will be called when complete
returns: reference to this, for fluency

Definition Classes: ConsulService → ConsulClient

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

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

Definition Classes: ConsulService → ConsulClient

Packages

ConsulService

Companion object ConsulService

class ConsulService extends ConsulClient

Instance Constructors

Value Members

Inherited from ConsulClient

Inherited from AnyRef

Inherited from Any

Ungrouped