The document discusses ob1k, a server framework based on asynchronous I/O with Netty and synchronous modules from Jetty 9, designed to enhance performance and provide full control over modular services. It outlines features such as seamless RPC, built-in serialization support, and a variety of asynchronous client options while detailing its architecture and example implementation. Additionally, it touches on the potential learning curve for developers and mentions future enhancements like client-side load balancing and session tracing.

1. ⇨ Yotam Oron (@YotamOron2)
⇨ Asy Ronen (A.K.A Async)
⇨ Eran Harel (@eran_ha)

2. What is OB1K?

3. Asynchronous IO based on Netty

4. Synchronous Modules based on Jetty 9

5. Drop-in replacement for Tomcat apps

6. Kick A$$ Performance :)

8. Self Contained

9. Isolated Services
● Own JVM
● Own JVM settings
● Own configuration
● Own port
● Own logs
● Own log configuration

10. Full control over your module
● JVM options
● Configuration properties
● Logging
● Ports
● Compression
● Threads
● Etc

11. Seamless RPC
● Strongly Typed RPC Client

12. Seamless RPC
● No need to configure anything
○ Except for more advanced cases…

13. Seamless RPC
● RPC complexity is transparent to the client

14. Seamless RPC
● Server implementation only worries about
the business logic

15. Seamless RPC
● Configurable client behavior (e.g. retries)

16. Seamless RPC
● Built-In serialization support
○ MsgPack
○ JSON
○ Compression

17. Free Standard API entry points
● /selftest
● /version
● /help (/)
● /properties
● /ping
● /presence
● /jmx

18. Free Service Monitoring

19. Free ZooKeeper Registration

20. Easier upgrades, easier deployment

21. Same execution path for
Dev / Prod / JUnit

22. Maven Archetype Scaffolding
$ mvn archetype:generate -DarchetypeGroupId=com.outbrain -
DarchetypeArtifactId=outbrain-ob1k-archetype -DarchetypeVersion=1.0.13 -
DinteractiveMode=false -Dversion=trunk -DgroupId=com.outbrain -
Dpackage=com.outbrain.YOUR_PACKAGE_NAME -DartifactId=YOUR_SERVICE_NAME

23. A set of asynchronous modules
● Async memcached client
● Async RPC client
● Async HTTP client
● Async DB query execution
● Async Event Stream support
● Composable Futures infrastructure

25. The main class

26. Jetty Server
public class GruffaloServer {
private static final Logger logger = LoggerFactory.getLogger(GruffaloServer.class);
public static void main(String[] args) {
new GruffaloServer().build().start();
logger.info("******** Gruffalo started ********");
}
public Server build() {
return new JettyServerBuilder().useConfigurationPorts().setContextPath("/Gruffalo");
}
}

27. Netty Server
public static Server buildServer() {
final String contextPath = "/Ob1kTemplate";
Context ctx = new SpringContextBuilder(contextPath).
addInitParam("self-tests", "properties,zookeeper,url,valid-context").
setMainContext("main", "classpath:applicationContext-Ob1kTemplate-all.xml").
addSubContext("ops", "classpath:WEB-INF/spring/ops-services.xml").
addSubContext("service", "classpath:WEB-INF/spring/Ob1kTemplate-service.xml").
build();
ServerBuilder serverBuilder = new ServerBuilder().
setContextPath(contextPath).
setContext(ctx).
addStaticPath("/html").
addStaticPath("/css").
addBaseServices("ops").
addServiceFromContext("service", Ob1kService.class, "/api").
createServiceFromContext("service", Ob1kNamedService.class, "/names").
addEndpoint("handleFirstRequest", "/first/{id}").
addEndpoint("handleSecondRequest", "/second/{name}").
addEndpoint("handleThirdRequest", "/third/{state}/{city}").
addService().useConfigurationPorts();
return serverBuilder.build();
}

28. OB1K Service
public class Ob1kService implements Service {
private static final Logger log = LoggerFactory.getLogger(Ob1kService.class);
private final String greetingMessage;
public Ob1kService(final String greetingMessage) {
this.greetingMessage = greetingMessage;
}
public ComposableFuture<String> echo(final String name) {
return ComposableFutures.fromValue("hello " + name + ". " + greetingMessage);
}
}

29. OB1K client
new ClientBuilder<>(IOb1kService.class).
setProtocol(ContentType.JSON).
setRequestTimeout(requestTimeout).
setRetries(retries).
addEndpoint("http://somehost:8080/Ob1kApp/Ob1kService").
build();

30. ComposableFuture
public interface ComposableFuture<T> extends Future<T> {
<R> ComposableFuture<R> continueWith(FutureResultHandler<T, R> handler);
<R> ComposableFuture<R> continueWith(ResultHandler<T, R> handler);
<R> ComposableFuture<R> continueOnSuccess(FutureSuccessHandler<T, R> handler);
ComposableFuture<T> continueOnError(FutureErrorHandler<T> handler);
ComposableFuture<T> withTimeout(long duration, final TimeUnit unit);
void onResult(Handler<T> handler);
<R> ComposableFuture<R> transform(final Function<? super T, ? extends R> function);
State getState();
Throwable getError();
}

31. ComposableFuture Example
ComposableFuture<Response> f1 = client.httpGet("http://www.google.co.il/search?q=term1");
ComposableFuture<Response> f2 = client.httpGet("http://www.google.co.il/search?q=term2");
ComposableFuture<Response> f3 = client.httpGet("http://www.google.co.il/search?q=term3");
ComposableFuture<List<Response>> combined = all(f1, f2, f3);
ComposableFuture<String> res = combined.continueWith((result) -> {
// prepare combined result.
});
schedule(() -> {
return trySomething().continueOnError((error) -> {
return getFallback();
});
}, 30, TimeUnit.SECONDS);

32. how does it all works ?
● All IO is non blocking and done via Netty
● Basically one thread per core, all working
unless there is nothing to do
● Context switch is minimized
● Transport is always HTTP, payload may vary
● Adjusted Executor for blocking actions(if you
must)

33. What is the catch?
● Blocking code is (almost)forbidden in the
async mode
● Writing asynchronous code has a learning
curve
● Libraries have to be adapted

34. Alternatives
Finagle
Drop Wizard
Vert.x
Play Framework
RESTEasy
Etc

35. Future Features
● Client Side Load Balancing
● Client Side Discovery (ZK based)
● Aggregation
● Scatter-Gather
● Throttling
● Session Tracing (a-la Zipkin)

36. *W
e’rerecruiting;)