org.restlet.security.Verifier Java Examples

/**
 * Overridden method from super class.  
 */
@Override
public int verify(Request request, Response response) {
	
	ChallengeResponse cr = request.getChallengeResponse();
	
	if (cr == null){
		logger.info("Missing credentials in request from a client with IP " 
									+ request.getClientInfo().getAddress() + ".");
		return Verifier.RESULT_MISSING;
	}
	
	String objectId = cr.getIdentifier();
	String password = new String(cr.getSecret());
	
	if (communicationManager.isConnected(objectId)){
		// if the client is already connected, just verify the password
		if (!communicationManager.verifyPassword(objectId, password)){
			logger.info("Invalid credentials in request from a client with IP " 
					+ request.getClientInfo().getAddress() + ".");
			return Verifier.RESULT_INVALID;
		}
	} else {
		// if not, establish a connection
		StatusMessage statusMessage = communicationManager.establishConnection(objectId, password); 
		if (statusMessage.isError()){
			logger.info("Invalid credentials in request from a client with IP " 
										+ request.getClientInfo().getAddress() + ".");
			return Verifier.RESULT_INVALID;
		}
	}
	
	logger.info("Valid credentials received from a client with IP " + request.getClientInfo().getAddress() + ".");
	return Verifier.RESULT_VALID;
}
 

@Inject
public RestComponent(@Hello Application helloApp, @Car Application carApp, Verifier authTokenVerifier) {
    getClients().add(Protocol.HTTPS);
    Server secureServer = getServers().add(Protocol.HTTPS, 8043);
    Series<Parameter> parameters = secureServer.getContext().getParameters();
    parameters.add("sslContextFactory", "org.restlet.engine.ssl.DefaultSslContextFactory");
    parameters.add("keyStorePath", System.getProperty("javax.net.ssl.keyStorePath"));
    getDefaultHost().attach("/api/hello", secure(helloApp, authTokenVerifier, "ame"));
    getDefaultHost().attach("/api/cars", secure(carApp, authTokenVerifier, "ame"));
    replaceConverter(JacksonConverter.class, new JacksonCustomConverter());
}
 

private Restlet secure(Application app, Verifier verifier, String realm) {
    ChallengeAuthenticator guard = new ChallengeAuthenticator(getContext().createChildContext(),
            ChallengeScheme.HTTP_OAUTH_BEARER, realm);
    guard.setVerifier(verifier);
    guard.setNext(app);
    return guard;
}
 

@Override
public Restlet createInboundRoot()
{
    Context context = getContext();
    Engine.getInstance().getRegisteredConverters().add( new PolygeneConverter( objectFactory ) );

    if( polygeneApplication.mode() == Application.Mode.development )
    {
        setDebugging( true );
    }
    router = new Router( context );

    addRoutes( router );
    router.attach( basePath, newPolygeneRestlet( EntryPointResource.class, EntryPoint.class ) );

    Verifier verifier = createVerifier();
    Enroler enroler = createEnroler();
    if( verifier == null && enroler == null )
    {
        return createInterceptors(new Filter()
            {
            } );
    }
    else
    {
        ChallengeAuthenticator guard = new ChallengeAuthenticator( context, ChallengeScheme.HTTP_BASIC, getName() + " Realm" );

        if( verifier != null )
        {
            guard.setVerifier( verifier );
        }

        if( enroler != null )
        {
            guard.setEnroler( enroler );
        }
        return createInterceptors( guard );
    }
}
 

@Override
protected void configure() {
    bind(Verifier.class).to(AuthTokenVerifier.class);
}
 

protected Verifier createVerifier()
{
    return null;
}