Curator RPC Proxy / Usage


Thrift File

The first step in using the RPC Proxy is to process the Curator RPC Thrift file into your desired language/environment. The current Curator RPC Thrift File can be found here: Details on using Apache Thrift can be found here:


It's assumed you are already familiar with ZooKeeper and Curator. Also, familiarity with writing Thrift applications is helpful.


Three Thrift Services are included with the Curator RPC:

Service Description
CuratorService The main service for accessing the Curator APIs and recipes
EventService Used to receive out-of-band messages for callbacks, watchers, etc. See Events for details.
DiscoveryService Curator's ServiceDiscovery recipe



Many of the Curator RPC APIs refer to "projections" (e.g. CuratorProjection). A projection is an id that refers to a real object instance inside of the RPC server. The projection is a "handle" or "cookie" that directly refers to that instance.

Thrift Client Equals a Thread

It's important to remember that each thrift client is the equivalent of a system thread. i.e. you cannot have multiple outstanding calls in multiple threads with a given client. For each thread, you should allocate a separate client. A Thrift Client maps directly to a single TCP/IP socket.

Event Loop

You must dedicate a separate thread for getting events via the Curator RPC EventService. Curator will report async results, connection state changes, watcher triggers, etc. via this event loop.

CuratorProjection Expiration

If you don't make an API call using a CuratorProjection within the configured timeout the projection instance will be closed and any open recipes, etc. associated with it will be closed. NOTE: calls to the EventService will cause the CuratorProjection to be "touched". So, as long as your event loop is running your CuratorProjection instance will be kept open.


After setting up Thrift, create a connection to the CuratorService and the EventService. If you plan on using Curator Discovery, create a connection to DiscoveryService. Allocate a CuratorProjection instance and then start a thread watching events for that instance. Here is pseudo code:

CuratorService.Client curatorService = new CuratorService.Client()
EventService.Client eventService = new EventService.Client()

curatorProjection = curatorService.newCuratorProjection(name)

inThread => {
    while isOpen {
        event = eventService.getNextEvent(curatorProjection)
        ... process event ...

... in your application shutdown


Once initialized, use recipes/APIs as needed. Here is an example of using the lock recipe:

optionalLock = client.acquireLock(curatorProjection, "/mylock", 10000)
if optionalLock.lockProjection == null {
    // lock attempt failed. Throw exception, etc.
lockProjection = optionalLock.lockProjection

    // you now own the lock

Here is an example of using the path cache:

cacheProjection = client.startPathChildrenCache(curatorProjection, "/path", true, false, BUILD_INITIAL_CACHE)


data = client.getPathChildrenCacheDataForPath(curatorProjection, cacheProjection, "/path/child")


// in your event loop, you will get events for the cache. e.g.
event = eventService.getNextEvent(curatorProjection)
if event.type == PATH_CHILDREN_CACHE {
    if event.childrenCacheEvent.type == CHILD_UPDATED {
        // node described by has changed
        // event.childrenCacheEvent.cachedPath is the path that was passed to startPathChildrenCache()


// when done with the cache, close it


See API Reference Page for the API reference.