ratpack - springone2gx 2015

SPRINGONE2GXWASHINGTON, DC

Unless otherwise ind icated, these sl ides are © 2013-2015 Pivotal Sof tware, Inc. and l icensed under a Creat ive Commons Att r ibut ion-NonCommercial l icense: ht tp: / /creat ivecommons.org/ l icenses/by-nc/3.0/

Ratpack Web FrameworkBy Dan Woods

@danveloper

Unless otherwise indicated, these slides are © 2013-2015 Pivotal Software, Inc. and licensed under aCreative Commons Attribution-NonCommercial license: http://creativecommons.org/l icenses/by-nc/3.0/ 2

About Me• Member of the Ratpack Web core team• Author of “Learning Ratpack”, O’Reilly• http://shop.oreilly.com/product/0636920037545.do• Senior Engineer, The Groundwork• https://github.com/danveloper

1st Four Chapters Available Today!

http://shop.oreilly.com/product/0636920037545.do

http://shop.oreilly.com/product/0636920037545.do

https://github.com/danveloper


Ratpack Team on TwitterFollow this crew!

• @ldaley• @varzof• @rus_hart• @beckje01• @marcinerdmann• @zedar185• @Lspacewalker• @johnrengelman


Brief History of Ratpack• Ratpack started out as a Groovy DSL implementation example (2010)• Evolved steadily into a JVM Sinatra clone (2010-2011)• Dumped Sinatra legacy and started focusing on NIO/performance

(2012)• Under steady development in its modern form for 3 full years!

Groovy DSL Implem

entation

JVM Sinatra Clone

Drop “Sinatra”, NIO/Perf

Drops Servlets for Vert.x

Core rewritten in JavaM

oves to org.ratpack packages

Execution Model Introduced

Bootstraping, Config

Registry is introducedM

ove from Vert.x to Netty

Stable, Production Ready – 1.0


Overview of Ratpack• Ratpack is now at version 1.0.0• Production-ready, API-stable• Can safely adopt without fear of breaking API changes• Great option for building microservices• Can also be integrated into legacy apps through its robust test

fixtures


Overview of Ratpack• A high performance web framework• Built on a non-blocking network stack• Provides low-level constructs for working with async APIs• Core is written in Java (requires Java 8)• Integrated support for building Groovy-based applications• Emphasis on developer productivity• As few opinions as possible• Fast, self-contained, light-weight deployables


Simplest Hello World Example• Just a few lines of Groovy code required!


Simplest Hello World Example• Totally Tweetable! https://twitter.com/danveloper/status/

608298173208100864

https://twitter.com/danveloper/status/608298173208100864

https://twitter.com/danveloper/status/608298173208100864


Java Hello World Example• Still, not very much needed at all…


Overview of Ratpack• Support for HTML templates with Groovy and Handlebars


Overview of Ratpack• Great for microservices!• First-class support for language agnostic transport


Overview of Ratpack• Non-blocking HTTP client


Overview of Ratpack• Fault tolerance for building distributed systems


Overview of Ratpack• Support for metric reporting with Dropwizard Metrics


Overview of Ratpack• Comprehensive configuration model


Overview of Ratpack• Support for persistent sessions


Overview of Ratpack• Robust security with Pac4j


Overview of Ratpack• Out of the box SSL support


Performance• Like most frameworks, Ratpack is CPU-bound (the more CPUs, the

better)• Unlike most frameworks, Ratpack efficiently processes on each CPU

https://gist.github.com/danveloper/db888be3519966976368




Execution Model• The execution model in Ratpack is borne from the fact that the JVM

has no inherent support for Continuations• Asynchronous programming is difficult• Async processing introduces non-determinism• Web applications require deterministic processing


Execution Model• Ratpack wants to make Async processing and programming a reliable

and usable model for the JVM• By fitting into the execution model, applications garner confidence

from a deterministic processing flow


TPR/TPC Processing Model• How most JVM web frameworks work

Internet Web App

new Thread().start()BlockingProcessin

g

Process and wait


TPR/TPC Processing Model• In the thread-per-request (or thread-per-connection) model, you are

limited by the amount of threads that you can create• Bringing the data from a request-taking thread and placing it into a

processing thread incurs a context switch• The processing thread is where all your work is done, and is

established until you respond• This is not performant at all, but it is an easy model to program in,

and that’s why people use it


Ratpack Processing Model• How Ratpack works (4 CPU example)

Internet Event Loop

Event LoopEvent LoopEvent Loop

HandlerWaiting for something? (db call, call to remote)

Return thread to request-taking pool while we wait

Respond

One thread per CPU core


Ratpack Processing Model• Only establishes a single thread per CPU core• Processing doesn’t block the thread (if it needs to, then we can

schedule it to the blocking thread pool)• While we wait for async responses to be fulfilled, the thread is able to

process other requests• When we get the async response, processing continues on the same

thread• No context switching in computation handlers, async processing

responds when its work is done


Problems with Async Programming• Callbacks are obnoxious to work with• No good way to detect when waiting for async responses• Represents a temporal disconnect from the processing flow• Most async web frameworks start a timer when a request comes in,

and if you don’t respond by the time that’s over, then it assumes you’re not going to


Problems with Async Programming

Callback HELL


Problems with Async ProgrammingWith Ratpack Promises, you get guaranteed execution order without the need scoped callbacks.

<1> - definitely happens 1st

<2> - definitely happens 2nd

<3> - definitely happens 3rd

<4> - definitely happens 4th

<5> - definitely happens 5th


Problems with Async Programming

In other async web frameworks:The clock is ticking for you to get that response out before the framework shuts you down


Execution Model• The overall execution is a parallel to the construct of a

continuation• Each of the calls to a Promise represent a frame in the execution• Each of the Promise types represents a new processing stream in the

execution• While async processing is taking place (ie. Promise is not fulfilled), the

execution is suspended• When the execution is suspended, the processing thread is given back

to the event loop to continue processing requests• When an async call returns, the execution is resumed


Execution Model• Most importantly, we know that when we hit the marker on a

processing stream that the stream is done computing• The processing streams are supervised by Ratpack to know that a

request is still processing• If your code doesn’t respond to a request, we don’t need to wait until

the request times out to inform the client• If all the streams are done computing but no response has been sent,

we are aware of that and can send an appropriate error back (no response sent) to the client


Execution Model• Ratpack’s execution model gives you much higher confidence in

working with async programming• The Promise type makes async programming easier• Deterministic async processing gives added benefits for concurrency• You have better confidence when programming to async APIs with

Ratpack• Fun fact: any API can be made asynchronous in Ratpack


Blocking Done Right• To make use of most 3rd party Java libraries, blocking will need to take

place at some point• A prime example here is using JDBC• Since you can’t block on the request-taking thread, you will need to

do blocking on a separate thread• Any non-trivial application will need to do blocking at some point…• Ratpack provides easy fixtures for Promise types to be scheduled for

computation or blocking


Blocking Done Right


Dependency Injection• Ratpack is not tied to any particular dependency injection framework• DI is an abstract concept in Ratpack, components are registered via a

Registry• Ratpack apps can be built entirely without any DI• Framework modularity is accomplished via Guice• 1st class support for Guice and Spring Boot


Registry• There are multiple registries in Ratpack• Provide components at different layers of the framework

Server Registry

User Registry

Context Registry

Request Registry


Registry• Components can be bound to the user registry at start time


Registry• Registries can be built and cascaded at request time, and according to

request attributes


Registry• Registries can be backed by Guice…


Registry• … or by Spring Boot…


Registry• … or both …


Dependency Injection• In Groovy, dependency injection can be accomplished by simply

specifying the type as a closure argument


Dependency Injection• Taking a completely unopinionated approach to dependency injection

allows implementations to be flexible• Can support nearly every component-providing backend• Gives you the ability to leverage the best parts of all available

ecosystems• New Ratpack apps can readily fit into legacy infrastructures that do

have opinions about this stuff


Build System Support• Ratpack is just a set of libraries, so any Java build system can build

your project• Advanced integration with Gradle is provided through the ratpack-

gradle plugin• Using Gradle is the easiest way to get started• Gradle plugin provides version-proper dependency resolution, so you

don’t need to update versions as you upgrade your project


Build System Support• Just a set of libraries…


Build System Support• Advanced integration with Gradle…


Build System Support• Ratpack apps can be easily packaged for deployment with Gradle• Multiple options: fat jar, tarball, zip file• Gradle plugin applies the application plugin, so distributions and

dependencies can easily be built and shipped with os start scripts• Fat JAR building is accomplished via the ShadowJar plugin


Developer Productivity• Development time hot reloading is provided via Gradle’s “continuous

build” mode• Standalone Ratpack Groovy scripts are able to be reloaded when the

development serverConfig option is true


The Handler Chain• Denotes the edge of your application• Requests flow through the chain until reaching a handler than can

provide a response• Two types of handlers: request flow and terminal• Request Flow handlers manage the direction the request takes

through the chain• Terminal handlers process a request and respond to it


The Handler Chain• Request flow handler


The Handler Chain• Terminal handler


The Handler Chain• Chain API provides semantic methods to bind a handler to an HTTP

verb and optionally a path• get(..), post(..), put(..), patch(..), delete(..) methods will bind

accordingly• Can also bind a handler that will be called for every incoming request

with the all(..) and path(..) chain methods


Live Coding Demo Time


Questions?


Join the Community

http://slack-signup.ratpack.io/



ratpack - springone2gx 2015

Technology