Packages

  • package root
    Definition Classes
    root
  • package com
    Definition Classes
    root
  • package twitter

    Start with com.twitter.finagle.

    Definition Classes
    com
  • package finagle

    Finagle is an extensible RPC system.

    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.

    Definition Classes
    twitter
  • package ssl
    Definition Classes
    finagle
  • package client
    Definition Classes
    ssl
  • ConstClientEngineFactory
  • JdkClientEngineFactory
  • SslClientConfiguration
  • SslClientEngineFactory
  • SslClientSessionVerifier
  • SslContextClientEngineFactory
  • UnknownSocketAddress
  • package server
    Definition Classes
    ssl

package client

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. class ConstClientEngineFactory extends SslClientEngineFactory

    This engine factory is a bridge for TLSClientEngine param configurations which use a SocketAddress => Engine interface.

    This engine factory is a bridge for TLSClientEngine param configurations which use a SocketAddress => Engine interface. It should only be used for legacy purposes.

  2. case class SslClientConfiguration(hostname: Option[String] = None, keyCredentials: KeyCredentials = KeyCredentials.Unspecified, trustCredentials: TrustCredentials = TrustCredentials.Unspecified, cipherSuites: CipherSuites = CipherSuites.Unspecified, protocols: Protocols = Protocols.Unspecified, applicationProtocols: ApplicationProtocols = ApplicationProtocols.Unspecified) extends Product with Serializable

    SslClientConfiguration represents the collection of parameters that an engine factory should use to configure a TLS client Engine.

    SslClientConfiguration represents the collection of parameters that an engine factory should use to configure a TLS client Engine.

    hostname

    If specified, this value should match one of the names specified in the server's X.509 certificate.

    keyCredentials

    The credentials used by the client engine to verify itself to a remote peer.

    trustCredentials

    The credentials used by the client to validate a remote peer's credentials.

    cipherSuites

    The cipher suites which should be used by a particular client engine.

    protocols

    The protocols which should be enabled for use with a particular client engine.

    applicationProtocols

    The ALPN or NPN protocols which should be supported by a particular client engine.

  3. abstract class SslClientEngineFactory extends AnyRef

    Instances of this class provide a method to create Finagle Engines for use with TLS.

  4. abstract class SslClientSessionVerifier extends AnyRef

    SslClientSessionVerifier represents an opportunity for a user or system to perform additional client-side verification checks against an address, configuration, or session.

    SslClientSessionVerifier represents an opportunity for a user or system to perform additional client-side verification checks against an address, configuration, or session. The apply method of the verifier is called when an SSLSession has been established.

  5. class SslContextClientEngineFactory extends SslClientEngineFactory

    This class provides an ability to use an initialized supplied javax.net.ssl.SSLContext as the basis for creating Engines.

Value Members

  1. object JdkClientEngineFactory extends SslClientEngineFactory

    This engine factory is a default JVM-based implementation, intended to provide coverage for a wide array of configurations.

  2. object SslClientEngineFactory
  3. object SslClientSessionVerifier
  4. object UnknownSocketAddress extends SocketAddress with Product with Serializable

    This class represents a Finagle Address that doesn't have or contain a corresponding java.net.SocketAddress

Ungrouped