common/securis.git

package net.curisit.securis; 
 
import java.net.URI; 
import java.util.Properties; 
 
import javax.inject.Inject; 
import javax.inject.Named; 
import javax.ws.rs.core.MediaType; 
import javax.ws.rs.core.Response; 
import javax.ws.rs.ext.ExceptionMapper; 
import javax.ws.rs.ext.Provider; 
 
import net.curisit.securis.ioc.RequestsModule; 
import net.curisit.securis.ioc.SecurisModule; 
 
import org.eclipse.jetty.server.Handler; 
import org.eclipse.jetty.server.Server; 
import org.eclipse.jetty.server.handler.ContextHandlerCollection; 
import org.eclipse.jetty.server.handler.ResourceHandler; 
import org.eclipse.jetty.servlet.FilterHolder; 
import org.eclipse.jetty.servlet.ServletContextHandler; 
import org.eclipse.jetty.servlet.ServletHolder; 
import org.eclipse.jetty.util.resource.Resource; 
import org.jboss.resteasy.plugins.guice.GuiceResteasyBootstrapServletContextListener; 
import org.jboss.resteasy.plugins.server.servlet.HttpServletDispatcher; 
import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 
 
import com.google.inject.Guice; 
import com.google.inject.Injector; 
import com.google.inject.Key; 
import com.google.inject.name.Names; 
import com.google.inject.persist.PersistFilter; 
import com.google.inject.persist.jpa.JpaPersistModule; 
 
public class MainApp { 
 
    private static final Logger log = LoggerFactory.getLogger(MainApp.class); 
 
    private static Server server; 
    private static Injector injector = null; 
 
    @Inject 
    @Named("base-uri") 
    private URI uri; 
 
    public static void main(String[] args) throws Exception { 
        log.info("SeCuris init..."); 
 
        SecurisModule securisModule = new SecurisModule(); 
        JpaPersistModule jpaPersistModule = new JpaPersistModule("localdb"); 
        Properties props = new Properties(); 
        props.put("javax.persistence.jdbc.password", securisModule.getPassword()); 
        props.put("javax.persistence.jdbc.url", securisModule.getUrl(securisModule.getAppDir())); 
        log.info("BD Url: {} {}", securisModule.getUrl(securisModule.getAppDir()), securisModule.getPassword()); 
        jpaPersistModule.properties(props); 
 
        injector = Guice.createInjector(securisModule, new RequestsModule(), jpaPersistModule); 
        // injector.getInstance(JpaInitializer.class); 
 
        startServer(injector.getInstance(Key.get(URI.class, Names.named("base-uri")))); 
        while (true) { 
            Thread.currentThread().sleep(100); 
        } 
    } 
 
    private static void startServer(URI uri) throws Exception { 
        System.out.println("Starting jetty..."); 
 
        server = new Server(9997); 
        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS); 
        context.setContextPath("/"); 
        context.addEventListener(injector.getInstance(GuiceResteasyBootstrapServletContextListener.class)); 
 
        context.setInitParameter("resteasy.role.based.security", "true"); 
        context.setInitParameter("resteasy.providers", DefaultExceptionHandler.class.getName()); 
        context.addFilter(new FilterHolder(injector.getInstance(AuthFilter.class)), "/*", null); 
        context.addFilter(new FilterHolder(injector.getInstance(PersistFilter.class)), "/*", null); 
        ServletHolder sh = new ServletHolder(HttpServletDispatcher.class); 
        sh.setName("resteasy"); 
        context.addServlet(sh, "/*"); 
 
        ResourceHandler staticResources = new ResourceHandler(); 
        staticResources.setBaseResource(Resource.newResource(MainApp.class.getResource("/static").toURI())); 
        staticResources.setWelcomeFiles(new String[] 
            { "/main.html" }); 
        context.setHandler(staticResources); 
 
        // ErrorPageErrorHandler errorHandler = new ErrorPageErrorHandler(); 
        // context.setErrorHandler(errorHandler); 
        // errorHandler.addErrorPage(HttpResponseCodes.SC_FORBIDDEN, "/login"); 
        // errorHandler.addErrorPage(HttpResponseCodes.SC_NOT_FOUND, "/"); 
        // errorHandler.addErrorPage(javax.ws.rs.NotFoundException.class, "/"); 
        // errorHandler.addErrorPage(javax.ws.rs.ForbiddenException.class, "/"); 
        // errorHandler.addErrorPage(javax.ws.rs.ForbiddenException.class.getCanonicalName(), "/"); 
        // errorHandler.addErrorPage(ErrorPageErrorHandler.GLOBAL_ERROR_PAGE, "/"); 
        context.setWelcomeFiles(new String[] 
            { "/index" }); 
        log.info("Error Handlers: " + context.getErrorHandler()); 
        ContextHandlerCollection contexts = new ContextHandlerCollection(); 
 
        contexts.setHandlers(new Handler[] 
            { staticResources, context }); 
        // server.setHandler(contexts); 
 
        server.setHandler(context); 
        server.start(); 
        server.join(); 
        log.info("Started server in: http://127.0.0.1:9997/"); 
    } 
 
    @Provider 
    public static class DefaultExceptionHandler implements ExceptionMapper<Exception> { 
 
        public DefaultExceptionHandler() { 
            log.info("Creating DefaultExceptionHandler "); 
        } 
 
        @Override 
        public Response toResponse(Exception e) { 
            // log.info("Creating DefaultExceptionHandler "); 
            e.printStackTrace(); 
            // For simplicity I am preparing error xml by hand. 
            // Ideally we should create an ErrorResponse class to hold the error info. 
            StringBuilder response = new StringBuilder("<response>"); 
            response.append("<status>ERROR</status>"); 
            response.append("<message>" + e.getMessage() + "</message>"); 
            response.append("</response>"); 
            return Response.serverError().entity(response.toString()).type(MediaType.APPLICATION_XML).build(); 
        } 
    } 
 
}