Server as a Function. In Kotlin. _________________. KotlinConf - - - PowerPoint PPT Presentation

Server as a Function. In Kotlin. _________________.

David Denton & Ivan Sanchez KotlinConf - October 4th 2018

The Oscar Platform

• Top 1000 site globally, delivers ~10s of millions Req/day
• Strategic journal delivery platform for a global

academic publisher

CD build & deploy by Deployed to Monorepo in

Techrospective

Issues:

• Mutable HTTP model
• Boilerplate around application setup is bloated
• Magic around routing proving hard to debug
• Hard to test end-to-end scenarios
• Functional Java vs native Kotlin woes

Action: Let’s try something in pure Kotlin

BarelyMagical

• Hackday project
• ~40 line Kotlin wrapper for Utterlyidle
• Use it as a library
• Simple routing
• Server as a function

See it @ http://bit.ly/BarelyMagical

Server as a Function

• 2013 white paper from Marius Eriksen @ Twitter
• Defined the composing of Services using just 2 types of asynchronous

function:

• Service - Represents a system boundary (symmetric)
• Filter - aka middleware - Models application agnostic concerns and

I/O transforms

• Twitter implementation is Scala-based

Finagle library

• Protocol agnostic == too generic
• Future-based == adds complexity

Server as a Function. In Kotlin. ______ _. Distilled

Concept: Service HttpHandler

“It turns an HTTP Request into an HTTP Response”

HttpHandler: (Request) -> Response

• ie. it’s a function!

val echo: HttpHandler = { req: Request -> Response(OK).body(req.body) } val resp: Response = echo(Request(POST, “/ echo“).body(“hello”))

Concept: Filter

“Provides pre and post processing on an HTTP operation”

Filter: (HttpHandler) -> HttpHandler

• ie. it’s a function!

val twitterFilter = Filter { next: HttpHandler -> { req: Request -> val tweet: Request = req.body(req.bodyString().take(140)) next(tweet) } } val tweet: HttpHandler = twitterFilter.then(echo)

(New) Concept: Router

Router: (Request) -> HttpHandler?

• ie. it’s a function!

“Matches an HttpHandler against a Request”

val routes: HttpHandler = routes( "/echo" bind POST to echo, "/twitter" bind routes( “/tweet” bind POST to tweet ) )

Can compose multiple routers to make an HttpHandler http4k does a depth-first search on the tree, then falls back to 404

Serving HTTP

val echo: HttpHandler = { r: Request -> Response(OK).body(r.body) } val server: Http4kServer = echo.asServer(Undertow(8000)).start()

We can attach an HttpHandler to a running container

Consuming HTTP

HttpHandler: (Request) -> Response

Can reuse the symmetric HttpHandler API:

val client: HttpHandler = ApacheClient() val response: Response = client( Request(GET, "https://www.http4k.org/search") .query("term", “http4k is cool") )

Extreme Testability

Testing http4k apps is trivial because:

• the building blocks are just functions
• messages are immutable data classes!

val echo: HttpHandler = { r: Request -> Response(OK).body(r.body) } class EchoTest { @Test fun `handler echoes input`() { val input: Request = Request(POST, "/echo").body("hello") val expected: Response = Response(OK).body("hello") assertThat(echo(input), equalTo(expected)) } }

Extreme Testability

Testing http4k apps is trivial because:

• the building blocks are just functions
• messages are immutable data classes!

val echo: HttpHandler = SetHostFrom(Uri.of("http://myserver:80")) .then(ApacheClient()) class EchoTest { @Test fun `handler echoes input`() { val input: Request = Request(POST, "/echo").body("hello") val expected: Response = Response(OK).body("hello") assertThat(echo(input), equalTo(expected)) } }

Typesafe HTTP Contracts

• How do we enforce our incoming HTTP contract?
• Locations: Path/Query/Header/Body/Form
• Optionality - required or optional?
• Marshalling + Typesafety
• What about creating outbound messages?

val miner: HttpHandler = routes( "/mine/{btc}" bind POST to { r: Request -> val newTotal: Int = r.path("btc")!!.toInt() + 1 Response(OK).body("""{"value":$newTotal}""") } )

Concept: Lens

“A Lens targets a specific part of a complex object to either GET or SET a value”

• ie. it’s a function - or more precisely 2 functions!

Extract: (HttpMessage) -> X Inject: (X, HttpMessage) -> HttpMessage

• these functions exist on the lens object as overloaded

invoke() functions

Lens example

• Revisiting the earlier example…

val miner: HttpHandler = routes( "/mine/{btc}" bind POST to { r: Request -> val newTotal: Int = r.path("btc")!!.toInt() + 1 Response(OK).body("""{"value":$newTotal}""") } ) data class BTC(val value: Int) {

• perator fun plus(that: BTC) = BTC(value + that.value)
• verride fun toString() = value.toString()

}

• Let’s introduce a domain type to wrap our primitive

val btcPath: PathLens<BTC> = Path.int().map(::BTC).of("btc") val btcBody: BiDiBodyLens<BTC> = Body.auto<BTC>().toLens()

• … and create lenses to do automatic marshalling:

Lens application

• http4k provides Lenses targeting all parts of the HttpMessage
• Via a CatchLensFailure filter, contract violations automatically

produce a BadRequest (400)

• Auto-marshalling JSON support for Jackson, GSON and Moshi

val btcPath: PathLens<BTC> = Path.int().map(::BTC).of("btc") val btcBody: BiDiBodyLens<BTC> = Body.auto<BTC>().toLens() val miner: HttpHandler = CatchLensFailure.then( routes( "/mine/{btc}" bind POST to { r: Request -> val newTotal: BTC = btcPath(r) + BTC(1) btcBody(newTotal, Response(OK)) } ) )

Server as a Function. In Kotlin. _______________. Dogfood Edition

Business Abstraction Remote Client Launcher

Load Environment Configuration Embedded Server Launch

Application Stack

Logging Metrics Remote Clients

Application

Business Abstraction Business Abstraction

The Layer Cake

Route Route Route Route

Standardised Server & Clients

fun serverStack(systemName: String, app: HttpHandler): HttpHandler = logTransactionFilter(“IN”, systemName) .then(recordMetricsFilter(systemName)) .then(handleErrorsFilter()) .then(app) fun clientStack(systemName: String): HttpHandler = logTransactionFilter(“OUT”, systemName) .then(recordMetricsFilter(systemName)) .then(handleErrorsFilter()) .then(ApacheClient())

Filter.then(that: Filter) -> Filter

By utilising the ability to “stack” Filters, we can build reusable units of behaviour

Fake Your Dependencies!

Fake HTTP Service State

• Leverage Body lenses
• Simple state-based behaviour
• Run in memory or as server
• Easy to simulate failures

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 HttpHandlers

Consumer Driven Contracts

Abstract Test Contract Success scenarios Business Abstraction Fake Dependency Test Fake System (HttpHandler) State Failure scenarios Real Dependency Test Environment Configuration Remote Client (HttpHandler)

Performance

• Best performing Kotlin library
• http4k + Apache server
• Standard JVM tuning

Full implementation @ http://bit.ly/techempower

What did we gain?

• Pure Kotlin Services
• No Magic == easy debugging
• Boilerplate reduction
• In-Memory == super quick build
• End-to-End testing is easy

D E M O T I M E

… all this in 70 lines of Kotlin!

http://bit.ly/http4kbox https://http4kbox.http4k.org Auth: http4kbox:http4kbox

CORE

Server as a Function. In Kotlin. _________________. Without the Server.

serverless4k

AWS API Gateway AWS Lambda

• Http4k Apps can run as Lambdas by implementing a

single interface

• Applying Proguard shrinks binary size to 100’s of Kb
• Dependencies can have a significant effect on cold

start time**

** http://bit.ly/coldstartwar

native4k

• GraalVM is a universal VM
• Can compile JVM apps into native binaries
• Small size + quick startup
• BUT: No simple reflection = hard for many libs
• http4k apps with Apache-backend work out of the box!
• Simple Graal http4k app = 6mb
• With Docker (Alpine), 9mb

CORE

ecosystem

HamKrest

http4k nanoservices

“5 useful mini-apps which all fit in a tweet!”

{ ws: Websocket -> while (true) { ws.send(WsMessage( Instant.now().toString()) ) Thread.sleep(1000) } }.asServer(Jetty()).start() ProxyHost(Https) .then(JavaHttpClient()) .withChaosControls(Latency() .appliedWhen(Always)) .asServer(SunHttp()) .start() static(Directory() .asServer(SunHttp()) .start() ProxyHost(Https) .then(RecordTo(Disk("store"))) .then(JavaHttpClient()) .asServer(SunHttp()) .start() JavaHttpClient().let { client -> Disk("store").requests() .forEach { println(it) client(it) } }

http://bit.ly/http4knanoservices

Thanks! __________?

quickstart: start.http4k.org web: www.http4k.org slack: #http @ kotlinlang @http4k @daviddenton david@http4k.org @s4nchez ivan@http4k.org