RestletTutorialExamples

Examples of how to construct Restlet applications mentioned in Restlet Tutorials
For example groovy scripts, see http://svn.codehaus.org/groovy-contrib/groovyrestlet/trunk/src/test/groovy/org/lpny/groovyrestlet/examples/tutorials/

Example of Part02

Example about creating a Restlet Client instance.

You can use shortcut client constructor as shown in `#1`; also you can use the generic restlet constructor to create client instance.

you can use `restlet(ofClass:[class name])` to create any instance of derived type of Restlet. In this case, you need to specify attribute `consArgs` which are an array of constructing parameters.

Create client

//#1 using shortcut
builder.client(protocol.HTTP)

//#2 generic restlet constructor
builder.restlet(ofClass:"org.restlet.Client", consArgs:[protocol.HTTP] as Object[])

Example of Part03

At current moment, server construction does not support `restlet` way

Nesting here indicates a parent-child relationship.

The child of a server component becoming the target property of the Server.

Create a server

builder.server(protocol:protocol.HTTP,port:8182){
    restlet(handle:{req, resp->
        resp.setEntity("Hello World", mediaType.TEXT_PLAIN)
    })
}.start()
//or you can define restlet first
def restlet = builder.restlet(handle:{req, resp->
    resp.setEntity("Hello World", mediaType.TEXT_PLAIN)
})
builder.server(protocol:protocol.HTTP,port:8182, target:restlet).start()

Example of Part05

Restlet example

//using component shortcut constructor
def component = builder.component{
    current.servers.add(protocol.HTTP, 8182)

    restlet(uri:"/trace", handle: {req, resp->
        println "To process request: ${req}"
        def message = """Resource URI: ${req.resourceRef}
Root URI : ${req.rootRef}
Routed part : ${req.resourceRef.baseRef}
Remaining part: ${req.resourceRef.remainingPart}
"""
        resp.setEntity(message, mediaType.TEXT_PLAIN)
    })
}

Example of Part06

Serving static files

def ROOT_URI = "file:."
builder.component{
    current.servers.add(protocol.HTTP, 8182)
    current.clients.add(protocol.FILE)
    application(uri:"") {
        directory(root:ROOT_URI)
    }
}.start()

Example of Part09

Using current to reference to the current instance.

By default any nested component will be automatically attached to its parent component according to their parent-child relationship. Here Guard is automatically attached to its parent (Application here) as its root. Adding attribute autoAttach:false can disable this feature.

Guard

builder.component{
    current.servers.add(protocol.HTTP, 8182)
    application(uri:"") {
        guard(scheme:challengeScheme.HTTP_BASIC, realm:"Tutorial").secrets.put("scott","tiger".toCharArray())
        def dir = directory(autoAttach:false, root:"")
        current.root.next=dir
    }
}.start()

Example of Part10

In Restlet, an attaching operation (on Router.attach) returns an instance of Route. It might be needed to do some post processing on a route. Attribute postAttach which refers a closure is used to support this.

Redirector example

builder.component{
    current.servers.add(protocol.HTTP, 8182)
    application(uri:""){
        def router = router{
            def target = "http://www.google.com/search?q= {keywords}"
            redirector(uri:"/search",targetTemplate:target,
                 mode:redirectorMode.MODE_CLIENT_TEMPORARY,
                 postAttach:{route->
                         route.extractQuery("keywords","kwd",true)
                })
       }
   }
}.start()

Example of Part11

You can implement the handle method of a Restlet using a groovy closure.

Router

builder.component{
    current.servers.add(protocol.HTTP, 8182)

    application(uri:""){
        router{
            def guard = guard(uri:"/docs", scheme:challengeScheme.HTTP_BASIC, realm:"Restlet Tutorials")
            guard.secrets.put("scott", "tiger".toCharArray())
            guard.next = directory(root:"", autoAttach:false)
            restlet(uri:"/users/ {user}", handle:{req,resp->
               resp.setEntity("Account of user \"${req.attributes.get('user')}\"",mediaType.TEXT_PLAIN)
            })

            restlet(uri:"/users/{user}/orders", handle:{req, resp->
                resp.setEntity("Orders or user \"${req.attributes.get('user')}\"",mediaType.TEXT_PLAIN)
            })
            restlet(uri:"/users/{user}/orders/{order}", handle:{req, resp->
               def attrs = req.attributes
               def message = "Order \"${attrs.get('order')}\" for User \"${attrs.get('user')}\""
               resp.setEntity(message, mediaType.TEXT_PLAIN)
            })
       }
    }
}.start()

Example of Part12

Same as handle closure of a Restlet, you can implement a simple Restlet Resource using groovy closures. Following attributes are supported:

init: init method
represent: for represent() and represent(Variant) methods HTTP GET
store: for storeRepresentation() method HTTP PUT
remove: for remoteRepresentation() method HTTP DELETE
accept: for acceptRepresentation() method HTTP POST
head: for handleHead() method

options: for handleOptions method

Specify `self` parameter in the last of parameter list. This special `self` instance indicates the resource instance.

Resources

builder.component{
    current.servers.add(protocol.HTTP, 8182)

    application(uri:""){
        router{
            resource("/users/{user}",
                     init:{ctx, req, resp, self->
                          self.getVariants().add(new Variant(mediaType.TEXT_PLAIN))
                     },
                     represent:{variant, self->
                           return new StringRepresentation( "Account of user \"$ {self.request.attributes.get('user')}".toString(),
                                                           mediaType.TEXT_PLAIN);
                     })
            resource("/users/{user}/orders", ofClass:OrdersResource)
        }

}.start()

Labels