Rest.li is an open source REST framework that uses asynchronous and non-blocking I/O to build scalable REST architectures. It achieves asynchronous behavior through its components R2 (network communication), D2 (dynamic discovery and load balancing), and by not blocking on I/O. Rest.li provides both callback-based and ParSeq-based approaches for building asynchronous Rest.li servers and clients to avoid blocking and improve throughput. ParSeq allows expressing complex asynchronous workflows through tasks and promises.

1. Async servers and clients in
Rest.li
1

2. (Please read the speaker notes)
2

3. What is this Rest.li thing
you speak about?
“Rest.li is an open source REST framework for building robust,
scalable RESTful architectures using type-safe bindings and
asynchronous, non-blocking I/O.”
3

4. The Stack
Rest.li Data and REST API
D2 Dynamic Discovery and load balancing
R2 Network communication
4

5. What do you by mean
by async?
5

6. What do you mean by
async (I/O)?
6
Request 1
Request 2
Blocked on I/O
Time
Sync Async
Free CPU

7. Rest.li is async and non-blocking
under the hood!
7

8. Rest.li
D2
R2
8

9. How is R2 async and
non-blocking?
• Netty based async client
• Jetty based server – configuration change (link) needed to run
the server in async mode
Rest.li
D2
R2
9

10. How is D2 async and
non-blocking?
• All communication with ZooKeeper uses the asynchronous
APIs
• ZooKeeper pushes data to clients in case of updates
Rest.li
D2
R2
10

11. How is Rest.li async
and non-blocking?
• Does not handle I/O
• I/O is taken care of by R2
• R2 is async and non-blocking!
• Uses ParSeq when interacting with and delegating to
application code.
Rest.li
D2
R2
11

12. Async Rest.li Servers
12

13. Async Server
Implementations
• The Rest.li framework is async and non-blocking under the
hood.
• As a result of this, if you do any blocking work in your method
implementation it can negatively impact your application
throughput as threads are held up by your application which
are needed by Rest.li. (if you are using Rest.li in async
mode)
13

14. Async Server
Implementations -
Options
1. Callback based
2. ParSeq based
14

15. Async Server – Callback
@RestMethod.Get
public void get(final Long id, @CallbackParam final Callback<Greeting>
callback) {
String path = "/data/" + id;
_zkClient.getData(path, false, new DataCallback() {
public void processResult(int i, String s, Object o, byte[] b, Stat
st) {
if (b.length == 0) {
callback.onError(new
RestLiServiceException(HttpStatus.S_404_NOT_FOUND));
}
else {
callback.onSuccess(buildGreeting(b));
}
}
}, null);
} 15

16. Async Server –
Callback Signature
@RestMethod.Get
public void get(final Long id, @CallbackParam
final Callback<Greeting> callback)
com.linkedin.common.Callback
16

17. Async Server – Filling
out the callback
_zkClient.getData(path, false, new DataCallback() {
public void processResult(int i, String s, Object o,
byte[] b, Stat st) {
if (b.length == 0) {
callback.onError(new
RestLiServiceException(HttpStatus.S_404_NOT_FOUND));
}
else {
callback.onSuccess(buildGreeting(b));
}
}
}, null); 17

18. Async Server – Callback
@RestMethod.Get
public void get(final Long id, @CallbackParam final Callback<Greeting>
callback) {
String path = "/data/" + id;
_zkClient.getData(path, false, new DataCallback() {
public void processResult(int i, String s, Object o, byte[] b, Stat
st) {
if (b.length == 0) {
callback.onError(new
RestLiServiceException(HttpStatus.S_404_NOT_FOUND));
}
else {
callback.onSuccess(buildGreeting(b));
}
}
}, null);
} 18

19. Async server - ParSeq
19

20. Key ParSeq Concepts
• Promise Fully async Java Future + listener mechanism.
• Task Basic unit of work that is similar to Java Callable.
Task<T>
• Engine runs Tasks.
• Context Used by a Task to run sub-Tasks.
• Composition par and seq
(link)
20

21. Async Server – ParSeq
@RestMethod.Get
public Task<Greeting> get(final Long id) {
final Task<FileData> fileDataTask = buildFileDataTask();
final Task<Greeting> mainTask = Tasks.callable("main", new
Callable<Greeting>() {
@Override
public Greeting call() throws Exception {
FileData fileData = fileDataTask.get();
return buildGreetingFromFileData(id, fileData);
}
});
return Tasks.seq(fileDataTask, mainTask);
}
21

22. Async Server – ParSeq
signature
@RestMethod.Get
public Task<Greeting> get(final Long id)
22

23. Async Server – ParSeq body
final Task<FileData> fileDataTask = buildFileDataTask();
23

24. Async Server – ParSeq body
final Task<Greeting> mainTask = Tasks.callable("main", new
Callable<Greeting>() {
@Override
public Greeting call() throws Exception {
FileData fileData = fileDataTask.get();
return buildGreetingFromFileData(id, fileData);
}
});
24

25. Async Server –
assembling the Tasks
return Tasks.seq(fileDataTask, mainTask);
25
fileDataTask mainTask

26. Async Server – ParSeq
@RestMethod.Get
public Task<Greeting> get(final Long id) {
final Task<FileData> fileDataTask = buildFileDataTask();
final Task<Greeting> mainTask = Tasks.callable("main", new
Callable<Greeting>() {
@Override
public Greeting call() throws Exception {
FileData fileData = fileDataTask.get();
return buildGreetingFromFileData(id, fileData);
}
});
return Tasks.seq(fileDataTask, mainTask);
}
26

27. Async Server – ParSeq
• Can use this approach to build complex call graphs and
return the final Task. (more on this later).
• Can use ParSeq tracing
• No callback hell!
27

28. Async Rest.li Clients
28

29. Async Rest.li requests
• RestClient is async and non-blocking under the hood – it
uses ParSeq and Netty.
• Applications can still block the thread if they block on the
results of the Rest.li call!
Response response =
_restClient.sendRequest(BUILDER.get().id(1L).build()).get();
Fortune fortune = response.getEntity();
Blocking on the result of a Future
29

30. Async Rest.li requests
Two Options:
1. Callback based API
2. Use a ParSeqRestClient – This is a wrapper around a
RestClient that returns ParSeq Tasks and Promises.
30

31. Async Rest.li requests
– Callbacks
Callback<Response<Greeting>> cb = new Callback() {
void onSuccess(Response<Greeting> response) {
// do something with the returned Greeting
}
void onError(Throwable e) {
// whoops
}
}
Request<Greeting> getRequest = BUILDERS.get().id(1L).build();
_restClient.sendRequest(getRequest, new RequestContext(), cb);
31

32. Async Rest.li requests – defining
a Callback
Callback<Response<Greeting>> callback = new
Callback() {
void onSuccess(Response<Greeting> response) {
// do something with the returned Greeting
}
void onError(Throwable e) {
// whoops
}
}
32

33. Async Rest.li requests – sending
the request
Request<Greeting> getRequest =
BUILDERS.get().id(1L).build();
_restClient.sendRequest(getRequest,
new RequestContext(),
callback);
33

34. Async Rest.li requests – using
ParSeq
• Callback based API is good for simple use cases (one or two
requests and you are done.)
• But it is hard to express more complicated call flows using the
Callback API
Callback ParSeq
34

35. Async Rest.li requests – using
ParSeq
a1 a2 a3
b1 b2
c1
35

36. Async Rest.li requests – using
ParSeq
Task<Response<?>> a1ResponseTask =
_parseqRestClient.createTask(a1Request);
Task<Response<?>> a2ResponseTask =
_parseqRestClient.createTask(a2Request);
Task<Response<?>> a3ResponseTask =
_parseqRestClient.createTask(a3Request); a1 a2 a3
b1 b2
c1
36

37. Async Rest.li requests – using
ParSeq
Task<Response<?>> b1ResponseTask = Tasks.callable("", new
Callable<Task<Response<?>>() {
@Override
public Task<Response<?>> call() throws Exception {
Response<?> a1Response = a1ResponseTask.get();
// Similarly, access the results from a2 and a3 as well
// use this to build request b1Request
return _parseqRestClient.createTask(b1Request)
}
});
Task<Response<?>> b2ResponseTask =
_parseqRestClient.createTask(b2Request);
a1 a2 a3
b1 b2
c1
37

38. Async Rest.li requests – using
ParSeq
Task<Response<?>> c1ResponseTask = Tasks.callable("", new
Callable<Task<Response<?>>() {
@Override
public Task<Response<?>> call() throws Exception {
Response<?> b1Response =
b1ResponseTask.get();
Response<?> b2Response =
b2ResponseTask.get();
// use b1Response and b2Response for
// c1Request
return _parseqRestClient.createTask(c1Request)
}
});
a1 a2 a3
b1 b2
c1
38

39. Async Rest.li requests – using
ParSeq
_engine.run(
Tasks.seq(
Tasks.par(a1ResponseTask, a2ResponseTask, a3ResponseTask),
Tasks.par(b1ResponseTask, b2ResponseTask),
c1ResponseTask));
a1 a2 a3
b1 b2
c1
39

40. Conclusion
• Rest.li is async and non-blocking under the hood
• You can use Callbacks and ParSeq Tasks and Promises to
write async Rest.li clients and servers
40

41. Links and references
• Rest.li user guide https://github.com/linkedin/rest.li/wiki/Rest.li-
User-Guide
• Asynchronous servers and clients in Rest.li
https://github.com/linkedin/rest.li/wiki/Asynchronous-Servers-and-
Clients-in-Rest.li
• ParSeq https://github.com/linkedin/parseq
41

42. Me.
https://www.linkedin.com/in/parikhkaran
https://github.com/karanparikh
http://karanparikh.com/
42

43. Thanks!
43