package finagle
Finagle is an extensible RPC system.
Services are represented by class com.twitter.finagle.Service. Clients make use of com.twitter.finagle.Service objects while servers implement them.
Finagle contains a number of protocol implementations; each of these implement
Client and/or com.twitter.finagle.Server. For example, Finagle's
HTTP implementation, com.twitter.finagle.Http (in package finagle-http
), exposes both.
Thus a simple HTTP server is built like this:
import com.twitter.finagle.{Http, Service} import com.twitter.finagle.http.{Request, Response} import com.twitter.util.{Await, Future} val service = new Service[Request, Response] { def apply(req: Request): Future[Response] = Future.value(Response()) } val server = Http.server.serve(":8080", service) Await.ready(server)
We first define a service to which requests are dispatched. In this case, the service returns immediately with a HTTP 200 OK response, and with no content.
This service is then served via the Http protocol on TCP port 8080. Finally we wait for the server to stop serving.
We can now query our web server:
% curl -D - localhost:8080 HTTP/1.1 200 OK
Building an HTTP client is also simple. (Note that type annotations are added for illustration.)
import com.twitter.finagle.{Http, Service} import com.twitter.finagle.http.{Request, Response} import com.twitter.util.{Future, Return, Throw} val client: Service[Request, Response] = Http.client.newService("localhost:8080") val f: Future[Response] = client(Request()).respond { case Return(rep) => printf("Got HTTP response %s\n", rep) case Throw(exc) => printf("Got error %s\n", exc) }
Http.client.newService("localhost:8080")
constructs a new com.twitter.finagle.Service instance
connected to localhost TCP port 8080. We then issue a HTTP/1.1 GET request to URI "/". The service
returns a com.twitter.util.Future representing the result of the operation. We listen to this
future, printing an appropriate message when the response arrives.
The Finagle homepage contains useful documentation and resources for using Finagle.
- Alphabetic
- By Inheritance
- finagle
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
abstract
class
AbstractNamer extends Namer
Abstract Namer class for Java compatibility.
-
abstract
class
AbstractResolver extends Resolver
An abstract class version of Resolver for java compatibility.
-
sealed
trait
Addr extends AnyRef
An address identifies the location of an object--it is a bound name.
An address identifies the location of an object--it is a bound name. An object may be replicated, and thus bound to multiple physical locations (see com.twitter.finagle.Address).
- See also
The user guide for further details.
-
sealed
trait
Address extends AnyRef
An Address represents the physical location of a single host or endpoint.
An Address represents the physical location of a single host or endpoint. It also includes Addr.Metadata (typically set by Namers and Resolvers) that provides additional configuration to client stacks.
Note that a bound Addr contains a set of Addresses and Addr.Metadata that pertains to the entire set.
- trait Announcement extends Closable
- trait Announcer extends AnyRef
-
class
AnnouncerForumInvalid extends Exception
Indicates that a forum string passed to an com.twitter.finagle.Announcer was invalid according to the forum grammar [1].
Indicates that a forum string passed to an com.twitter.finagle.Announcer was invalid according to the forum grammar [1].
[1] https://twitter.github.io/finagle/guide/Names.html
-
class
AnnouncerNotFoundException extends Exception
Indicates that an com.twitter.finagle.Announcer was not found for the given
scheme
.Indicates that an com.twitter.finagle.Announcer was not found for the given
scheme
.Announcers are discovered via Finagle's com.twitter.finagle.util.LoadService mechanism. These exceptions typically suggest that there are no libraries on the classpath that define an Announcer for the given scheme.
-
class
ApiException extends Exception
A base class for exceptions encountered on account of incorrect API usage.
-
trait
CanStackFrom[-From, To] extends AnyRef
A typeclass for "stackable" items.
A typeclass for "stackable" items. This is used by the StackBuilder to provide a convenient interface for constructing Stacks.
- Annotations
- @implicitNotFound( "${From} is not Stackable to ${To}" )
-
class
CancelledConnectionException extends RequestException with HasLogLevel
A Future is satisfied with this exception when the process of establishing a session is interrupted.
A Future is satisfied with this exception when the process of establishing a session is interrupted. Sessions are not preemptively established in Finagle, rather requests are taxed with session establishment when necessary. For example, this exception can occur if a request is interrupted while waiting for an available session or if an interrupt is propagated from a Finagle server during session establishment.
- See also
The user guide for additional details.
com.twitter.finagle.CancelledRequestException
-
class
CancelledRequestException extends RequestException with HasLogLevel
Indicates that a request was cancelled.
Indicates that a request was cancelled. Cancellation is propagated between a Finagle server and a client intra-process when the server is interrupted by an upstream service. In such cases, the pending Future is interrupted with this exception. The client will cancel its pending request which will by default propagate an interrupt to its downstream, and so on. This is done to conserve resources.
- See also
The user guide for additional details.
-
class
ChannelBufferUsageException extends Exception
Indicates that an error occurred on account of incorrect usage of a org.jboss.netty.buffer.ChannelBuffer.
Indicates that an error occurred on account of incorrect usage of a org.jboss.netty.buffer.ChannelBuffer.
TODO: Probably remove this exception class once we migrate away from Netty usage in public APIs.
-
class
ChannelClosedException extends ChannelException
Indicates that a given channel was closed, for instance if the connection was reset by a peer or a proxy.
-
class
ChannelException extends Exception with SourcedException with HasLogLevel
An exception encountered within the context of a given socket channel.
-
case class
ChannelWriteException(ex: Option[Throwable]) extends ChannelException with WriteException with NoStackTrace with Product with Serializable
Default implementation for WriteException that wraps an underlying exception.
-
trait
Client[Req, Rep] extends AnyRef
RPC clients with
Req
-typed requests andRep
typed replies.RPC clients with
Req
-typed requests andRep
typed replies. RPC destinations are represented by names. Names are bound for each request.Clients are implemented by the various protocol packages in finagle, for example com.twitter.finagle.Http:
object Http extends Client[HttpRequest, HttpResponse] ... val service: Service[HttpRequest, HttpResponse] = Http.newService("google.com:80")
-
trait
ClientConnection extends Closable
Information about a client, passed to a Service factory for each new connection.
-
class
ConnectionFailedException extends ChannelException
Indicates that the client failed to establish a connection.
Indicates that the client failed to establish a connection. Typically this class will be extended to provide additional information relevant to a particular category of connection failure.
-
case class
ConnectionRefusedException(remoteAddr: Option[SocketAddress]) extends ChannelException with Product with Serializable
Indicates that connecting to a given
remoteAddress
was refused. -
case class
Dentry(prefix: Prefix, dst: NameTree[Path]) extends Product with Serializable
Trait Dentry describes a delegation table entry.
Trait Dentry describes a delegation table entry.
prefix
describes the paths that the entry applies to.dst
describes the resulting tree for this prefix on lookup. -
class
DroppedWriteException extends TransportException
Indicates that a com.twitter.finagle.transport.Transport write associated with the request was dropped by the transport (usually to respect backpressure).
-
case class
Dtab(dentries0: IndexedSeq[Dentry]) extends IndexedSeq[Dentry] with Product with Serializable
A Dtab--short for delegation table--comprises a sequence of delegation rules.
A Dtab--short for delegation table--comprises a sequence of delegation rules. Together, these describe how to bind a com.twitter.finagle.Path to a set of com.twitter.finagle.Addr. com.twitter.finagle.naming.DefaultInterpreter implements the default binding stategy.
- See also
The user guide for further details.
- final class DtabBuilder extends Builder[Dentry, Dtab]
-
class
FactoryToService[Req, Rep] extends Service[Req, Rep]
Turns a com.twitter.finagle.ServiceFactory into a com.twitter.finagle.Service which acquires a new service for each request.
-
class
FailedFastException extends RequestException with WriteException with HasLogLevel with FailureFlags[FailedFastException]
Used by com.twitter.finagle.service.FailFastFactory to indicate that a request failed because all hosts in the cluster to which the client is connected have been marked as failed.
Used by com.twitter.finagle.service.FailFastFactory to indicate that a request failed because all hosts in the cluster to which the client is connected have been marked as failed. See com.twitter.finagle.service.FailFastFactory for details on this behavior.
- See also
The user guide for additional details.
-
final
class
Failure extends Exception with NoStackTrace with HasLogLevel with FailureFlags[Failure]
Base exception for all Finagle originated failures.
Base exception for all Finagle originated failures. These are Exceptions, but with additional
sources
andflags
. Sources describe the origins of the failure to aid in debugging and flags mark attributes of the Failure (e.g. Restartable). -
abstract
class
Filter[-ReqIn, +RepOut, +ReqOut, -RepIn] extends (ReqIn, Service[ReqOut, RepIn]) ⇒ Future[RepOut]
A Filter acts as a decorator/transformer of a service.
A Filter acts as a decorator/transformer of a service. It may apply transformations to the input and output of that service:
(* MyService *) [ReqIn -> (ReqOut -> RepIn) -> RepOut]
For example, you may have a service that takes
Strings
and parses them asInts
. If you want to expose this as a Network Service via Thrift, it is nice to isolate the protocol handling from the business rules. Hence you might have a Filter that converts back and forth between Thrift structs. Again, your service deals with plain objects:[ThriftIn -> (String -> Int) -> ThriftOut]
Thus, a
Filter[A, B, C, D]
converts aService[C, D]
to aService[A, B]
. In other words, it converts aService[ReqOut, RepIn]
to aService[ReqIn, RepOut]
.- See also
The user guide for details and examples.
-
class
GlobalRequestTimeoutException extends RequestTimeoutException
Indicates that a request timed out, where "request" comprises a full RPC from the perspective of the application.
Indicates that a request timed out, where "request" comprises a full RPC from the perspective of the application. For instance, multiple retried Finagle-level requests could constitute the single request that this exception pertains to.
-
trait
HasRemoteInfo extends Exception
A trait for exceptions that contain remote information: the downstream address/client id, upstream address/client id (if applicable), and trace id of the request.
A trait for exceptions that contain remote information: the downstream address/client id, upstream address/client id (if applicable), and trace id of the request. RemoteInfo.NotAvailable is used if no remote information has been set.
-
class
InconsistentStateException extends ChannelException
Indicates that some client state was inconsistent with the observed state of some server.
Indicates that some client state was inconsistent with the observed state of some server. For example, the client could receive a channel-connection event from a proxy when there is no outstanding connect request.
-
class
IndividualRequestTimeoutException extends RequestTimeoutException
Indicates that a single Finagle-level request timed out.
Indicates that a single Finagle-level request timed out. In contrast to com.twitter.finagle.RequestTimeoutException, an "individual request" could be a single request-retry performed as a constituent of an application-level RPC.
-
trait
ListeningServer extends Closable with Awaitable[Unit]
Trait ListeningServer represents a bound and listening server.
Trait ListeningServer represents a bound and listening server. Closing a server instance unbinds the port and relinquishes resources that are associated with the server.
-
class
MultipleAnnouncersPerSchemeException extends Exception with NoStackTrace
Indicates that multiple Announcers were discovered for given
scheme
.Indicates that multiple Announcers were discovered for given
scheme
.Announcers are discovered via Finagle's com.twitter.finagle.util.LoadService mechanism. These exceptions typically suggest that there are multiple libraries on the classpath with conflicting scheme definitions.
-
class
MultipleResolversPerSchemeException extends Exception with NoStackTrace
Indicates that multiple Resolvers were discovered for given
scheme
.Indicates that multiple Resolvers were discovered for given
scheme
.Resolvers are discovered via Finagle's com.twitter.finagle.util.LoadService mechanism. These exceptions typically suggest that there are multiple libraries on the classpath with conflicting scheme definitions.
-
sealed
trait
Name extends AnyRef
Names identify network locations.
Names identify network locations. They come in two varieties:
- Bound names are concrete. They represent a changeable list of network endpoints (represented by Addrs).
2. Path names are unbound paths, representing an abstract location which must be resolved by some context, usually the Dtab.
In practice, clients use a com.twitter.finagle.Resolver to resolve a destination name string into a
Name
. This is achieved by passing a destination name into methods such as ClientBuilder.dest or thenewClient
method of the appropriate protocol object (e.g.Http.newClient(/s/org/servicename)
). These APIs useResolver
under the hood to resolve the destination names into theName
representation of the appropriate cluster.As names are bound, a Namer may elect to bind only a Name prefix, leaving an unbound residual name to be processed by a downstream Namer.
- See also
The user guide for further details.
-
sealed
trait
NameTree[+T] extends AnyRef
Name trees represent a composite T-typed name whose interpretation is subject to evaluation rules.
Name trees represent a composite T-typed name whose interpretation is subject to evaluation rules. Typically, a Namer is used to provide evaluation context for these trees.
- com.twitter.finagle.NameTree.Union nodes represent the union of several trees; a destination is reached by load-balancing over the sub-trees.
- Alt nodes represent a fail-over relationship between several trees; the first successful tree is picked as the destination. When the tree-list is empty, Alt-nodes evaluate to Empty.
- A Leaf represents a T-typed leaf node;
- A Neg represents a negative location; no destination exists here.
- Finally, Empty trees represent an empty location: it exists but is uninhabited at this time.
-
abstract
class
Namer extends AnyRef
A namer is a context in which a NameTree is bound.
-
class
NoBrokersAvailableException extends RequestException with SourcedException
Indicates that a request failed because no servers were available.
Indicates that a request failed because no servers were available. The Finagle client's internal load balancer was empty. This typically occurs under one of the following conditions:
- The cluster is actually down. No servers are available. - A service discovery failure. This can be due to a number of causes, such as the client being constructed with an invalid cluster destination name [1] or a failure in the service discovery system (e.g. DNS, ZooKeeper).
A good way to diagnose NoBrokersAvailableExceptions is to reach out to the owners of the service to which the client is attempting to connect and verify that the service is operational. If so, then investigate the service discovery mechanism that the client is using (e.g. the com.twitter.finagle.Resolver that is it configured to use and the system backing it).
[1] https://twitter.github.io/finagle/guide/Names.html
-
class
NotServableException extends RequestException
Indicates that the request was not servable, according to some policy.
Indicates that the request was not servable, according to some policy. See com.twitter.finagle.service.OptionallyServableFilter as an example.
-
class
NotShardableException extends NotServableException
Indicates that the client failed to distribute a given request according to some sharding strategy.
Indicates that the client failed to distribute a given request according to some sharding strategy. See com.twitter.finagle.service.ShardingService for details on this behavior.
-
case class
Path(elems: Buf*) extends Product with Serializable
A Path comprises a sequence of byte buffers naming a hierarchically-addressed object.
A Path comprises a sequence of byte buffers naming a hierarchically-addressed object.
- See also
The user guide for further details.
- trait ProxyAnnouncement extends Announcement with Proxy
-
class
ProxyConnectException extends Exception with NoStackTrace with FailureFlags[ProxyConnectException]
Indicates that either SOCKS or HTTP(S) proxy server rejected client's connect request.
-
class
ReadTimedOutException extends ChannelException
Indicates that a read from a given
remoteAddress
timed out. -
case class
RefusedByRateLimiter() extends ChannelException with Product with Serializable
Indicates that requests were failed by a rate-limiter.
Indicates that requests were failed by a rate-limiter. See com.twitter.finagle.service.RateLimitingFilter for details.
-
class
RequestException extends Exception with NoStackTrace with SourcedException
A base class for request failures.
A base class for request failures. Indicates that some failure occurred before a request could be successfully serviced.
-
class
RequestTimeoutException extends RequestException with TimeoutException
Indicates that a request timed out.
Indicates that a request timed out. See com.twitter.finagle.IndividualRequestTimeoutException and com.twitter.finagle.GlobalRequestTimeoutException for details on the different request granularities that this exception class can pertain to.
-
trait
Resolver extends AnyRef
A resolver binds a name, represented by a string, to a variable address.
A resolver binds a name, represented by a string, to a variable address. Resolvers have an associated scheme which is used for lookup so that names may be resolved in a global context.
These are loaded by Finagle through the service loading mechanism. Thus, in order to implement a new resolver, a class implementing
Resolver
with a 0-arg constructor must be registered in a file namedMETA-INF/services/com.twitter.finagle.Resolver
included in the classpath; see Oracle's ServiceLoader documentation for further details. -
class
ResolverAddressInvalid extends Exception
Indicates that a destination name string passed to a com.twitter.finagle.Resolver was invalid according to the destination name grammar [1].
Indicates that a destination name string passed to a com.twitter.finagle.Resolver was invalid according to the destination name grammar [1].
[1] https://twitter.github.io/finagle/guide/Names.html
-
class
ResolverNotFoundException extends Exception
Indicates that a com.twitter.finagle.Resolver was not found for the given
scheme
.Indicates that a com.twitter.finagle.Resolver was not found for the given
scheme
.Resolvers are discovered via Finagle's com.twitter.finagle.util.LoadService mechanism. These exceptions typically suggest that there are no libraries on the classpath that define a Resolver for the given scheme.
-
trait
Server[Req, Rep] extends AnyRef
Servers implement RPC servers with
Req
-typed requests andRep
-typed responses.Servers implement RPC servers with
Req
-typed requests andRep
-typed responses. Servers dispatch requests to a com.twitter.finagle.Service or com.twitter.finagle.ServiceFactory provided throughserve
.Servers are implemented by the various protocol packages in finagle, for example com.twitter.finagle.Http:
object Http extends Server[HttpRequest, HttpResponse] ... val server = Http.serve(":*", new Service[HttpRequest, HttpResponse] { def apply(req: HttpRequest): Future[HttpResponse] = ... })
Will bind to an ephemeral port (":*") and dispatch request to
server.boundAddress
to the provided com.twitter.finagle.Service instance.The
serve
method has two variants: one for instances ofService
, and another forServiceFactory
. TheServiceFactory
variants are used for protocols in which connection state is significant: a newService
is requested from theServiceFactory
for each new connection, and requests on that connection are dispatched to the supplied service. The service is also closed when the client disconnects or the connection is otherwise terminated. -
abstract
class
Service[-Req, +Rep] extends (Req) ⇒ Future[Rep] with Closable
A
Service
is an asynchronous function from aRequest
to aFuture[Response]
.A
Service
is an asynchronous function from aRequest
to aFuture[Response]
.It is the basic unit of an RPC interface.
- See also
Service.mk for a convenient way to create new instances.
The user guide for details and examples.
-
class
ServiceClosedException extends Exception with ServiceException
Indicates that a request was applied to a com.twitter.finagle.Service that is closed (i.e.
Indicates that a request was applied to a com.twitter.finagle.Service that is closed (i.e. the connection is closed).
-
trait
ServiceException extends Exception with SourcedException
A trait for exceptions related to a com.twitter.finagle.Service.
- abstract class ServiceFactory[-Req, +Rep] extends (ClientConnection) ⇒ Future[Service[Req, Rep]] with Closable
-
abstract
class
ServiceFactoryProxy[-Req, +Rep] extends ServiceFactory[Req, Rep] with Proxy
A ServiceFactory that proxies all calls to another ServiceFactory.
A ServiceFactory that proxies all calls to another ServiceFactory. This can be useful if you want to modify an existing
ServiceFactory
. -
trait
ServiceFactoryWrapper extends AnyRef
A ServiceFactoryWrapper adds behavior to an underlying ServiceFactory.
-
trait
ServiceNamer[Req, Rep] extends Namer
Base-trait for Namers that bind to a local Service.
Base-trait for Namers that bind to a local Service.
Implementers with a 0-argument constructor may be named and auto-loaded with
/$/pkg.cls
syntax.Note that this can't actually be accomplished in a type-safe manner since the naming step obscures the service's type to observers.
-
class
ServiceNotAvailableException extends Exception with ServiceException
Indicates that a request was applied to a com.twitter.finagle.Service that is unavailable.
Indicates that a request was applied to a com.twitter.finagle.Service that is unavailable. This constitutes a fail-stop condition.
-
abstract
class
ServiceProxy[-Req, +Rep] extends Service[Req, Rep] with Proxy
A simple proxy Service that forwards all calls to another Service.
A simple proxy Service that forwards all calls to another Service. This is useful if you want to wrap-but-modify an existing service.
-
class
ServiceTimeoutException extends Exception with WriteException with ServiceException with TimeoutException with NoStackTrace
Indicates that the connection was not established within the timeouts.
Indicates that the connection was not established within the timeouts. This type of exception should generally be safe to retry.
-
class
ShardNotAvailableException extends NotServableException
Indicates that the shard to which a request was assigned was not available.
Indicates that the shard to which a request was assigned was not available. See com.twitter.finagle.service.ShardingService for details on this behavior.
-
abstract
class
SimpleFilter[Req, Rep] extends Filter[Req, Rep, Req, Rep]
A Filter where the request and reply types are the same.
-
trait
SourcedException extends Exception with HasRemoteInfo
A trait for exceptions that have a source.
A trait for exceptions that have a source. The name of the source is specified as a
serviceName
. The "unspecified" value is used if noserviceName
is provided by the implementation. -
case class
SslHandshakeException(ex: Option[Throwable], remoteAddr: Option[SocketAddress]) extends ChannelException with Product with Serializable
Indicates that an error occurred while an SSL handshake was being performed with a server at a given
remoteAddress
. -
case class
SslHostVerificationException(principal: String) extends ChannelException with Product with Serializable
Indicates that the certificate for a given session was invalidated.
-
case class
SslVerificationFailedException(ex: Option[Throwable], remoteAddr: Option[SocketAddress]) extends ChannelException with Product with Serializable
Indicates that an error occurred while
SslClientSessionVerification
was being performed, or the server disconnected from the client in a way that indicates that there was high probability that the server failed to verify the client's certificate. -
sealed
trait
Stack[T] extends AnyRef
Stacks represent stackable elements of type T.
Stacks represent stackable elements of type T. It is assumed that T-typed elements can be stacked in some meaningful way; examples are functions (function composition) Filters (chaining), and ServiceFactories (through transformers). T-typed values are also meant to compose: the stack itself materializes into a T-typed value.
Stacks are persistent, allowing for nondestructive transformations; they are designed to represent 'template' stacks which can be configured in various ways before materializing the stack itself.
Note: Stacks are advanced and sometimes subtle. For expert use only!
-
class
StackBuilder[T] extends AnyRef
StackBuilders are imperative-style builders for Stacks.
StackBuilders are imperative-style builders for Stacks. It maintains a stack onto which new elements can be pushed (defining a new stack).
- See also
stack.nilStack for starting construction of an empty stack for ServiceFactorys.
-
trait
Stackable[T] extends Head
Produce a stack from a
T
-typed element. -
sealed
trait
Status extends AnyRef
Status tells the condition of a networked endpoint.
Status tells the condition of a networked endpoint. They are used to indicate the health of Service, ServiceFactory, and of transport.Transport.
Object Status$ contains the status definitions.
-
class
StreamClosedException extends ChannelException with NoStackTrace
Indicates that a given stream was closed, for instance if the stream was reset by a peer or a proxy.
-
trait
TimeoutException extends Exception with SourcedException with HasLogLevel
Indicates that an operation exceeded some timeout duration before completing.
Indicates that an operation exceeded some timeout duration before completing. Differs from com.twitter.util.TimeoutException in that this trait doesn't extend java.util.concurrent.TimeoutException, provides more context in its error message (e.g. the source and timeout value), and is only used within the confines of Finagle.
-
class
TooManyConcurrentRequestsException extends ApiException
Indicates that the client has issued more concurrent requests than are allowable, where "allowable" is typically determined based on some configurable maximum.
-
class
TooManyWaitersException extends RequestException with HasLogLevel
Used by com.twitter.finagle.pool.WatermarkPool to indicate that a request failed because too many requests are already waiting for a connection to become available from a client's connection pool.
-
class
TransportException extends Exception with SourcedException
A base class for exceptions encountered in the context of a com.twitter.finagle.transport.Transport.
-
case class
UnknownChannelException(ex: Option[Throwable], remoteAddr: Option[SocketAddress]) extends ChannelException with Product with Serializable
A catch-all exception class for uncategorized ChannelExceptions.
-
trait
WriteException extends Exception with SourcedException
Marker trait to indicate there was an exception before writing any of the request.
Marker trait to indicate there was an exception before writing any of the request. These exceptions should generally be retryable.
-
class
WriteTimedOutException extends ChannelException
Indicates that a write to a given
remoteAddress
timed out. -
trait
Group[T] extends AnyRef
A group is a dynamic set of
T
-typed values.A group is a dynamic set of
T
-typed values. It is used to represent dynamic hosts and operations over such lists. Its flexibility is derived from the ability to map, creating derived groups. The map operation ensures that each element is mapped over exactly once, allowing side-effecting operations to rely on this to implement safe semantics.Note: querying groups is nonblocking, which means that derived groups are effectively eventually consistent.
Note:
T
s must be hashable, defininghashCode
andequals
to ensure that maps have exactly-once semantics.Note: Groups are invariant because Scala's Sets are. In the case of sets, this is an implementation artifact, and is unfortunate, but it's better to keep things simpler and consistent.
- Annotations
- @deprecated
- Deprecated
(Since version 6.7.x) Use
com.twitter.finagle.Name
to represent clusters instead
-
case class
LabelledGroup[T](underlying: Group[T], name: String) extends Group[T] with Product with Serializable
A mixin trait to assign a
to the group.name
A mixin trait to assign a
to the group. This is used to assign labels to groups that ascribe meaning to them.name
- Annotations
- @deprecated
- Deprecated
(Since version 6.7.x) Use
com.twitter.finagle.Name
to represent clusters instead
-
trait
MutableGroup[T] extends Group[T]
- Annotations
- @deprecated
- Deprecated
(Since version 6.7.x) Use
com.twitter.finagle.Name
to represent clusters instead
Value Members
-
object
Addr
Note: There is a Java-friendly API for this object: com.twitter.finagle.Addrs.
- object Address
-
object
Addresses
A Java adaptation of the com.twitter.finagle.Address companion object.
-
object
Addrs
A Java adaptation of the com.twitter.finagle.Addr companion object.
- object Announcer
- object CanStackFrom
- object ChannelException extends Serializable
- object ChannelWriteException extends Serializable
- object ClientConnection
- object Dentry extends Serializable
-
object
Dtab extends Serializable
Object Dtab manages 'base' and 'local' Dtabs.
- object FactoryToService
- object FailResolver extends Resolver
- object Failure extends Serializable
-
object
FailureFlags extends Serializable
FailureFlags
may be applied to any Failure/Exception encountered during the handling of a request. - object Filter
-
object
FixedInetResolver
InetResolver that caches all successful DNS lookups indefinitely and does not poll for updates.
InetResolver that caches all successful DNS lookups indefinitely and does not poll for updates.
Clients should only use this in scenarios where host -> IP map changes do not occur.
- object Group
-
object
InetResolver
Resolver for inet scheme.
- object Name
-
object
NameTree
The NameTree object comprises NameTree types as well as binding and evaluation routines.
- object Namer
- object NegResolver extends Resolver
- object NilResolver extends Resolver
-
object
NullServer extends ListeningServer with CloseAwaitably
An empty ListeningServer that can be used as a placeholder.
An empty ListeningServer that can be used as a placeholder. For example:
@volatile var server = NullServer def main() { server = Http.serve(...) } def exit() { server.close() }
- object Path extends Serializable
-
object
Resolver extends BaseResolver
The default Resolver used by Finagle.
-
object
Resolvers
Java APIs for Resolver.
- object Service
- object ServiceFactory
- object ServiceFactoryWrapper
- object SourcedException extends Serializable
-
object
Stack
- See also
stack.nilStack for starting construction of an empty stack for ServiceFactorys.
-
object
StackParams
Stack.Params
forwarder to provide a clean Java API. -
object
Status
Define valid Status! values.
Define valid Status! values. They are, in order from most to least healthy:
- Open
- Busy
- Closed
(An scala.math.Ordering is defined in these terms.)
- object WriteException extends Serializable
- object stack
Deprecated Value Members
-
object
BackupRequestLost extends Exception with NoStackTrace with HasLogLevel
An exception that is raised on requests that are discarded because their corresponding backup requests succeeded first.
An exception that is raised on requests that are discarded because their corresponding backup requests succeeded first. See
com.twitter.finagle.exp.BackupRequestFilter
for details.- Annotations
- @deprecated
- Deprecated
(Since version 2017-11-20) Use Failure flagged Failure.Ignorable