Groovy ++ в действии: Gretty / GridGain / REST / Websockets

Теперь давайте добавим еще несколько полезных функций на наш сервер. Мы хотим, чтобы клиенты могли хранить некоторые временные данные на сервере как операция, подобная карте. Самым простым решением является подход REST — операции http GET / PUT / DELETE с ключами, закодированными в URL. Для хранения будем использовать красивый распределенный кеш GridGain.

Полную версию исходного кода, включая тест, можно найти в репозитории github. Здесь мы покажем только важные изменения.

Прежде всего, перед запуском нашего сервера нам нужно подключиться к GridGain

// start GridGain and obtain cache instance
def cache = GridFactory.start("spring-cache.xml").cache('replicated')

Нам также нужно изменить публичный блок нашего сервера и добавить обработчики для операций с нашими картами.

    public: {
        // redirect googlib path to google servers
        get("/googlib/:path") {
....................................................
         }

        get("/api/:key") {
            if(it.key)
                response.json = [result: cache.get(it.key)]
            else
                response.json = [result: cache.keySet()]
        }

        delete("/api/:key") {
            response.json = [result: cache.remove(it.key)]
        }

        put("/api/:key") {
            response.json = [result: cache.put(it.key, request.contentText)]
        }
    },

Обратите внимание, насколько просто и удобно мы создаем ответы в формате JSON.

Gretty utilizes Jackson library — probably the fastest JSON library for Java available today

As we said above test cases are available at github repository but there is one thing, which is important to know. Not every browser is capable to send AJAX requests other than GET & POST, so our story with PUT & DELETE operations can be useless. Fortunately there is common workaround recommended at least by both Microsoft and Google in their APIs — X-HTTP-Method-Override header.

Gretty supports this header both on client and server side as shown in following code snippet for test cases

        // request done as 'POST' method with additional header
        // X-HTTP-Method-Override: DELETE
        // we use methodOveride only in order to make sure that it handled correctly
        doTest([uri: "/$api/1", methodOverride: HttpMethod.DELETE ]) { response ->
            assert Map.fromJson(response.contentText).result == '932'
        }

Interesting to note that we developed our server without opening browser even once (modulo of course checking design of web pages)

But there still something non-perfect in our server. It is synchronious! That means that while we do network round trip to GridGain the server thread is blocked waiting for result to arrive. That does not sound like right utilization of resources. Let us fix it.

Again whole source code can be found at github repository We will only provide important changes.

First of all we will use alternative and more flexible approach to define our new API. Instead of putting everything in to public section of our server we will define separate web context dedicated to our API. In fact public section is just shortcut for default web context.

Secondly, we will use GridGain asynchronious operations like getAsync etc. Asynchronious operations return almost immidiately and instead of operation’s result return subclass of java.util.concurrent.Future called GridFuture. The huge benefit of GridFuture is the fact that it allows adding listeners for operation completion (OMG! why standard JDK future does not)

So we call asynchronious operation, register listener and free resources for handling of other requests (by returning from current handler). When listener invoked we are ready to send response back to the client.

Does not this code look elegant?

    public: {
..............................  
    },

    webContexts: [
       // alternative approach
       // - use of web context instead of default context
       // - use of asynchronous operations
       "/asyncapi" : [
           public: {
               get("/:key") {
                   if(it.key) {
                       cache.getAsync(it.key) << { f ->
                           response.json = [result: f.get()]
                       }
                   }
                   else {
                       cache.getAllAsync() << { f ->
                           response.json = [result: f.get().keySet()]
                       }
                   }
               }

               delete("/:key") {
                   cache.removeAsync(it.key) << { f ->
                       response.json = [result: f.get()]
                   }
               }

               put("/:key") {
                   cache.putAsync(it.key, request.contentText) << { f ->
                       response.json = [result: f.get()]
                   }
               }
           }
       ]
    ]

Well, truly speaking, there is one small but important detail, which we did not explain yet. Obviously GridGain (designed for Java and Scala) does not provide Groovish leftShift API (<< operator). Even more important question is how does server know (except the fact that we responded nothing yet) that response is not completed and some continuation (our listener) plans to do it later.

To understand both issues we need to see how do we integrate GridGain in to our GrettyServer. Magically it is done by static compilation. In the code snippet below we define GrettyGridInClosure which subclass GridInClosure (base class for listener) from GridGain and mix it in with GrettyAsyncFunction trait from Gretty. GrettyAsyncFunction is capable to remember all necessary information of web request handled when it was created and than to reuse this knowledge when executed. At the same time leftShift method has parameter of type GrettyGridInClosure, which let compiler treat closure we provide as new instance of this class. Voila!

/**
 * Utility class to make GridGain callback Gretty asynchronious
 */
abstract class GrettyGridInClosure<T> extends GridInClosure<T> implements GrettyAsyncFunction<T, Object> {
    final void apply(T t) {
        handlerAction(t)
    }
}

/**
 * Convenient << method for GridFuture
 */
static <V> void leftShift(GridFuture<V> self, GrettyGridInClosure<GridFuture<V>> listener) {
    self.listenAsync listener
}

Very good — we have beautiful and covered with tests web server. The last feature we would like to add is to have similar API accessable via websockets. Yes, Gretty does support websockets.

The full code can be found in github repository which I recommend at least to look in order to see how websockets can be tested over in memory communication. Here we only provide snippet important for support of websockets. I hope the code is self-explaining (probably modulo «labeled closure» syntax used to define method onConnect)

   webContexts: [
       // alternative approach
       // - use of web context instead of default context
       // - use of asynchronous operations
       "/asyncapi" : [
           public: {
......................................
               websocket("/") { String msg ->
                   onConnect: {
                       send([msg: "welcome"].toJsonString())
                   }

                   def command = Map.fromJson(msg)
                   switch(command.method) {
                       case 'put':
                           cache.putAsync(command.key, command.value) << { f ->
                               send([result: f.get()].toJsonString())
                           }
                       break

                       case 'get':
                           if(command.key) {
                               cache.getAsync(command.key) << { f ->
                                   sendJson([result: f.get()])
                               }
                           }
                           else {
                               cache.getAllAsync() << { f ->
                                   sendJson([result: f.get().keySet()])
                               }
                           }
                       break

                       case 'delete':
                           cache.removeAsync(command.key) << { f ->
                               sendJson([result: f.get()])
                           }
                       break
                   }
               }
           }
       ]
    ]

Gretty is very young but already powerful project combining together brilliant Netty and capabilities of Groovy++. Maybe one day you will find it useful for your work.

Thank you for reading (hope it was interesting) and till next time.