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
  • package server
    Definition Classes
    ssl
  • ConstServerEngineFactory
  • JdkServerEngineFactory
  • LegacyKeyServerEngineFactory
  • LegacyServerEngineFactory
  • SslContextServerEngineFactory
  • SslServerConfiguration
  • SslServerEngineFactory
  • SslServerSessionVerifier

package server

Ordering
  1. Alphabetic
Visibility
  1. Public
  2. All

Type Members

  1. class ConstServerEngineFactory extends SslServerEngineFactory

    This engine factory is a bridge for TLSServerEngine param configurations which use a () => Engine interface.

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

  2. class SslContextServerEngineFactory extends SslServerEngineFactory
  3. case class SslServerConfiguration(keyCredentials: KeyCredentials = KeyCredentials.Unspecified, clientAuth: ClientAuth = ClientAuth.Unspecified, trustCredentials: TrustCredentials = TrustCredentials.Unspecified, cipherSuites: CipherSuites = CipherSuites.Unspecified, protocols: Protocols = Protocols.Unspecified, applicationProtocols: ApplicationProtocols = ApplicationProtocols.Unspecified) extends Product with Serializable

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

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

    keyCredentials

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

    clientAuth

    Determines whether mutual authentication is desired or required by this server engine.

    trustCredentials

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

    cipherSuites

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

    protocols

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

    applicationProtocols

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

  4. abstract class SslServerEngineFactory extends AnyRef

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

  5. abstract class SslServerSessionVerifier extends AnyRef

    SslServerSessionVerifier represents an opportunity for a user or system to perform additional server-side verification checks against a configuration or session.

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

Value Members

  1. object JdkServerEngineFactory extends SslServerEngineFactory

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

  2. object SslServerEngineFactory
  3. object SslServerSessionVerifier

Deprecated Value Members

  1. object LegacyKeyServerEngineFactory extends SslServerEngineFactory

    This engine factory is intended to act as a temporary bridge for those currently using non-PKCS#8 PEM-encoded keys, such as PKCS#1 keys.

    This engine factory is intended to act as a temporary bridge for those currently using non-PKCS#8 PEM-encoded keys, such as PKCS#1 keys. Once the private key file has been converted into PKCS#8 PEM-encoded format, JdkServerEngineFactory or Netty4ServerEngineFactory should be used instead.

    Annotations
    @deprecated
    Deprecated

    (Since version 2017-02-10) Use Netty4ServerEngineFactory instead

    Note

    This engine factory uses PEMEncodedKeyManager which shells out to OpenSSL in order to convert the key into a usable format.

  2. object LegacyServerEngineFactory extends SslServerEngineFactory

    This engine factory is intended to act as a temporary bridge for those currently using JSSE or OpenSSL (Finagle-Native) through the Ssl class.

    This engine factory is intended to act as a temporary bridge for those currently using JSSE or OpenSSL (Finagle-Native) through the Ssl class. From there, if using JSSE, then JdkServerEngineFactory or Netty4ServerEngineFactory should be the next step. If using OpenSSL, then Netty4ServerEngineFactory should be the next step, as it will be the supported path forward for using native engines with Finagle.

    Annotations
    @deprecated
    Deprecated

    (Since version 2017-02-07) Use Netty4ServerEngineFactory instead

Ungrouped