Share
Embed
Futuristic Functions and how to Fake them
A journey story about how we re-engineered a set of high-traffic services at a major Academic Publisher to use Finagle - the Server as a Function framework from Twitter.
I'll cover the concepts behind Finagle, then how we extended the application of those concepts to develop Fintrospect.io, a typesafe routing library that sits atop it. Finally, we'll see how the combination of the 2 technologies reinvented how we implemented microservice testing strategies, and allowed the applications to be fully Continuously Deployed.
Presented at the London Scala User Group.
David Denton
October 23, 2017
Transcript
33 slides
-
Futuristic Functions & How to Fake Them David Denton fintrospect.io
Scala meet up / 23rd October 2017 -
Domain: Academic Publishing •Backbone app delivering metadata search services and
asset XML for branded academic research content: •Serves 20-30 million requests per day CD build & deploy by Deployed to Monorepo in -
Migration == Opportunity! Issues we’d like to address: • Separation
of route logic hard to debug • No typesafety around routing - validation boilerplate! • Loads and loads and loads of dependencies. • Hard to test end-to-end scenarios. • Network failure cases hard to simulate. • Swagger support not integrated. -
• 2013 Whitepaper from Marius Eriksen @ Twitter Server as
a Function • Defined 2 major concepts: • Service represents System Boundaries • Filter used to apply I/O transformation and stateful effects • Protocol agnostic RPC system • In production @ Twitter • Scala + Netty • Fault tolerant by design • Basis for LinkerD ServiceMesh -
Concept: Service “It turns an Request into an (eventual) Response”
Service: Request => Future[Response] ie. it’s a function! val service: Service[Request, Response] = Service.mk { r => val response = Response(Status.Ok) response.content = r.content Future(response) } -
Concept: Filter “Provides pre and post processing on a remote
operation” Filter[ReqIn, RespIn, ReqOut, RespOut] = (ReqIn, Service[ReqOut, RespOut]) => Future[RespIn] ie. it’s a function! val addType: Filter[Request, Response, Request, Response] = Filter.mk { (req, next) => next(req).map(resp => { resp.headerMap("Content-type") = "application/json" resp }) } Filters compose with other Filters/Services using andThen() -
Testing Services This is trivially easy, because Services are just
functions! val echoPath = Service.mk[Request, Response] { req => val response = Response(Status.Ok) response.contentString = req.uri Future(response) } class EchoPathTest extends FunSpec with Matchers { it("echoes path”) { Await.result(echoPath(Request("hello"))).contentString shouldBe "/hello" } } -
Functions on a network! val service: Service[Request, Response] = Service.mk
{ req: Request => Future(Response(Ok)) } val server: ListeningServer = Http.serve(":80", service) We can mount a Service into a running Finagle Server -
HTTP Clients “It turns an Request into an (eventual) Response”
val client: Service[Request, Response] = Http.newService(”www.google.com:80”) val response: Future[Response] = client( Request(GET, "/search?query=hello") ) Service: Request => Future[Response] ie. it’s a Service! -
Fault tolerance through composition Resilience features are built into the
Protocols: Load balancing, Retrying, Dead-node detection (circuits) val backOff = Stream(fromSeconds(1), fromSeconds(3), fromSeconds(5)) val shouldRetry: PartialFunction[(Request, Try[Response]), Boolean] = { case (_, Return(rep)) => rep.status.code != 200 } val resilientHttpClient = RetryFilter(backOff)(shouldRetry) .andThen( Http.newService("localhost:8000,localhost:8001")) Below example provides LB & custom retrying logic with backoff: -
• Typesafe routing • Reduce validation boilerplate • Auto-documenting (Swagger)
• Fault tolerance • Lightweight dependencies Wish list Mk2 -
fintrospect.io “Fintrospect is a routing library which allows the API
user to serve and consume typesafe HTTP contracts.” So what is it? -
RouteSpec Service (Client) RouteClient bind() ServerRoute Service (Server) bind() Concept:
RouteSpec Module ServerRoute ServerRoute ServerRoute Service Module ServerRoute ServerRoute ServerRoute Module ServerRoute ServerRoute ServerRoute <exports> • RouteSpec defines contract: • Path/Queries/Headers/Body • Content types • Responses RouteSpec("a post endpoint") .consuming(APPLICATION_ATOM_XML) .producing(APPLICATION_JSON) .taking(Query.required.int("qName")) .taking(Header.optional.boolean("name")) .body( Body.json("the body of the message", obj("anObject" -> obj("notAStringField" -> number(123))) ) ) .at(Post) / "echo" / Path.string("message") -
Concept: ServerRoute “Binds the RouteSpec to a typesafe Http Endpoint”
val route: ServerRoute[Request, Response] = RouteSpec().at(Post) / Path.int("code") bindTo { code: Int => Service.mk { req: Request => Future(Response(Status(code))) } } • Path variables are passed to a function which builds the Service -
Concept: Module val renderer = Swagger2dot0Json(ApiInfo("my great api", "v1")) val
module: Module = RouteModule(Root / "context", renderer) .withRoute(serverRoute1) .withRoute(serverRoute2) val svc: Service[Request, Response] = module.toService • Models a set of Routes • Provides auto-validation and Documentation • If no matching service found, falls back to a 404 “Matches a Request to a bound Service” -
Typesafe HTTP Contracts • How do we enforce our incoming
HTTP contract? • Locations:Query/Header/Body/Form • Optionality - required or optional? • Marshalling + Typesafety • What about creating outbound messages? RouteSpec().at(Post) / "mine" bindTo { Service.mk { r: Request => val newBtc: Int = r.params("btc").toInt + 1 val response = Response(Ok) response.contentString = s”""{"balance":$newBtc}""" Future(response) } } -
Concept: Lens “A Lens targets a specific part of a
complex object to either GET or SET a value” Extract (or <—-): (Message) => X Inject (or —->): (X) => (Message) => Message ie. it’s a function - or more precisely 2 functions! -
Lens example 1/2 val btc = Query.required.int("btc") RouteSpec().taking(btc).at(Post) bindTo Service.mk
{ r: Request => val newBtc: Int = (btc <-- r) + 1 val response = Response(Ok) response.contentString = s”""{"balance":$newBtc}""" Future(response) } } • Use lens extraction to provide a typed value. • Violations result in an HTTP 400 (Bad Request). -
Lens example 2/2 • We can also “map()” the lens
into domain types: case class BTC(value: Int) { def +(that: BTC) = BTC(value + that.value) override def toString() = value.toString } val btcSpec = ParameterSpec.int().map(BTC, (i: BTC) => i.value) val btc = Query.required(btcSpec, "btc") RouteSpec().taking(btc).at(Post) bindTo Service.mk { r: Request => val newBtc = (btc <-- r) + BTC(1) val response = Response(Ok) response.contentString = s”""{"balance":$newBtc}""" Future(response) } -
Typesafe responses • Typesafe builders for creating Responses • Encode
native API JSON objects import io.fintrospect.formats.Jackson.JsonFormat._ import io.fintrospect.formats.Jackson.ResponseBuilder._ val jsonResponse: Response = Ok(obj("balance" -> number(234))) case class Wallet(balance: Int) val encodedResponse: Response = NotFound(encode(Wallet(234))) • Or leverage auto-marshalling to convert Scala objects… import io.fintrospect.formats.Jackson.bodySpec val body: Body[Wallet] = Body.of(bodySpec[Wallet]()) val wallet: Wallet = body <-- encodedResponse … then extract the response using a lens -
Concept: RouteClient “Binds the RouteSpec to a typesafe Http Client”
val client = Http.newService("localhost:80") val code = Path.int("code") val routeClient: RouteClient = RouteSpec().at(Post) / code bindToClient client val r: Future[Response] = routeClient(code --> 404) • Use lense “injection” to pass type safe bindings to client -
Business Abstraction Remote Client Launcher Load Environment Configuration Embedded Server
Launch Application Stack Logging Metrics Remote Clients Application/Module(s) Business Abstraction Business Abstraction The Layer Cake Route Route Route Route -
Standardised Server & Clients def serverStack(host: String, app: Service[Request, Response]):
Service[Request, Response] = logTransactionFilter(“IN”, host) .andThen(recordMetricsFilter(server)) .andThen(handleErrorsFilter()) .andThen(app) def clientStack(host: String): Service[Request, Response] = logTransactionFilter(“OUT”, systemName) .andThen(recordMetricsFilter(host)) .andThen(handleErrorsFilter()) .andThen(Http.newService(s"$host:80")) Filter.andThen(that: Filter) => Filter By utilising the ability to “stack” Filters, we can build reusable units of behaviour -
Fake Dependencies! Fake HTTP Dependency State • Define RouteSpecs for
remote services, then mount them into a Fake Service • Leverage Body lenses & Response Builders • Simple state-based behaviour • Run in memory or as server • Easy to simulate failures -
Consumer Driven Contracts Abstract Test Contract Success scenarios Business Abstraction
Fake Dependency Test Fake System (Service) State Failure scenarios Real Dependency Test Environment Configuration Remote Client (Service) -
Test Environment Configuration Application Testing • We can simply inject
apps into each other in order to build an offline environment • Using fakes, we can inject failure to test particular scenarios • All internal and external applications and clients are Services -
Advantages of the new stack •Reduced vaildation/error boilerplate •No Magic
== easy debugging •Compiler validated Auto-documentation •In-Memory testing == quicker build •CDC testing models allow for full CD •Light dependencies == small artefacts •Finagle services runs in 50-100Meg Heap + very performant!