/** * Performs common initialization for template engines. * * Implementations must override this method to do their own template engine specific initialization. * To use the convenience of this class, implementations must invoke this class's implementation before * performing their own initialization. * * @param application reference to the Pippo {@link Application} that can be used to retrieve settings * and other settings for the initialization */ @Override public void init(Application application) { languages = application.getLanguages(); messages = application.getMessages(); router = application.getRouter(); pippoSettings = application.getPippoSettings(); fileExtension = pippoSettings.getString(PippoConstants.SETTING_TEMPLATE_EXTENSION, getDefaultFileExtension()); templatePathPrefix = pippoSettings.getString(PippoConstants.SETTING_TEMPLATE_PATH_PREFIX, TemplateEngine.DEFAULT_PATH_PREFIX); }
@Override public void init(Application application) { application.registerContentTypeEngine(CsvEngine.class); }
@Override public void init(Application application) { application.registerTemplateEngine(GroovyTemplateEngine.class); }
public void init() { log.debug("Initializing application '{}'", application); application.init(); router = application.getRouter(); errorHandler = application.getErrorHandler(); notFoundRouteHandler = application.getNotFoundRouteHandler(); routeContextFactory = getRouteContextFactory(); routeContextFactory.init(application); log.debug("RouteContext factory is '{}'", routeContextFactory.getClass().getName()); }
public Response(HttpServletResponse httpServletResponse, Application application) { this.httpServletResponse = httpServletResponse; this.contentTypeEngines = application.getContentTypeEngines(); this.templateEngine = application.getTemplateEngine(); this.httpServletResponse.setCharacterEncoding(StandardCharsets.UTF_8.toString()); this.contextPath = application.getRouter().getContextPath(); this.applicationPath = StringUtils.removeEnd(application.getRouter().getApplicationPath(), "/"); this.mimeTypes = application.getMimeTypes(); this.status = 0; }
@Override protected void setup() { String basePath = Strings.nullToEmpty(getSettings().getString(RestServlet.SETTING_URL, null)).trim(); serve(basePath + "/*").with(RestServlet.class); final PippoSettings pippoSettings = getPippoSettings(getSettings()); final Application application = new Application(pippoSettings); // must set context path before starting application application.getRouter().setContextPath(getSettings().getContextPath()); // must set application path before starting application String contextPath = application.getRouter().getContextPath(); String applicationPath = StringUtils.addEnd(contextPath, "/") + StringUtils.removeStart(basePath, "/"); application.getRouter().setApplicationPath(applicationPath); // start the application which sets up all initializers application.init(); bind(Application.class).toInstance(application); bind(Router.class).toInstance(application.getRouter()); bind(Messages.class).toInstance(application.getMessages()); bind(Languages.class).toInstance(application.getLanguages()); bind(MimeTypes.class).toInstance(application.getMimeTypes()); bind(ErrorHandler.class).toInstance(application.getErrorHandler()); bind(TemplateEngine.class).toInstance(application.getTemplateEngine()); bind(HttpCacheToolkit.class).toInstance(application.getHttpCacheToolkit()); bind(ContentTypeEngines.class).toInstance(application.getContentTypeEngines()); bind(RestService.class); }
@Override public PippoSettings getSettings() { return application.getPippoSettings(); }
@Override public void init(Application application) { metricRegistry = (MetricRegistry) application.getLocals().get("metricRegistry"); if (metricRegistry == null) { metricRegistry = new MetricRegistry(); PippoSettings pippoSettings = application.getPippoSettings(); String applicationName = pippoSettings.getString(PippoConstants.SETTING_APPLICATION_NAME, "Pippo"); application.getRoutePreDispatchListeners().add(metricsDispatchListener); application.getRoutePostDispatchListeners().add(metricsDispatchListener); application.addRouteTransformer(transformer);
/** * Get the template bindings for the error response. * * @param routeContext * @return bindings map */ protected Map<String, Object> prepareTemplateBindings(int statusCode, RouteContext routeContext) { Map<String, Object> locals = new LinkedHashMap<>(); locals.put("applicationName", application.getApplicationName()); locals.put("applicationVersion", application.getApplicationVersion()); locals.put("runtimeMode", application.getPippoSettings().getRuntimeMode().toString()); if (application.getPippoSettings().isDev()) { locals.put("routes", application.getRouter().getRoutes()); } return locals; }
if (application.getPippoSettings().isProd()) { routeContext.getResponse().commit(); } else { content.append('\n'); List<Route> routes = application.getRouter().getRoutes(); for (Route route : routes) { content.append('\t').append(route.getRequestMethod()).append(' ').append(route.getUriPattern());
@Override public Messages getMessages() { return application.getMessages(); }
private void initializeApplication() { // hook-up the Metrics dispatch listener MetricsDispatchListener metricsDispatchListener = new MetricsDispatchListener(metricRegistry); application.getRoutePreDispatchListeners().add(metricsDispatchListener); application.getRoutePostDispatchListeners().add(metricsDispatchListener); // set the RedirectException handler application.getErrorHandler().setExceptionHandler(RedirectException.class, (exception, ctx) -> { RedirectException redirectException = (RedirectException) exception; if (!Strings.isNullOrEmpty(redirectException.getSessionUrlAttribute())) { String requestUri = ctx.getRequest().getApplicationUriWithQuery(); ctx.setSession(redirectException.getSessionUrlAttribute(), requestUri); } ctx.redirect(redirectException.getPath()); }); // set the StatusCodeException handler application.getErrorHandler().setExceptionHandler(StatusCodeException.class, (exception, ctx) -> { StatusCodeException statusCodeException = (StatusCodeException) exception; ctx.setLocal("message", statusCodeException.getMessage()); application.getErrorHandler().handle(statusCodeException.getStatusCode(), ctx); }); }
/** * Helper method that calls {@code getRouter().addRouteTransformer(transformer)}. * * @param transformer */ public void addRouteTransformer(RouteTransformer transformer) { getRouter().addRouteTransformer(transformer); }
.set("contextPath", router.getContextPath()) .set("appPath", router.getApplicationPath())) .extension(new I18nExtension(application.getMessages())) .extension(new FormatTimeExtension()) .extension(new PrettyTimeExtension()) .extension(new WebjarsAtExtension(router)) .extension(new PublicAtExtension(router)) .extension(new RouteExtension(application.getRouter()));
@Override public void init(ServletConfig servletConfig) { if (System.getProperty("pippo.hideLogo") == null) { log.info(PippoUtils.getPippoLogo()); } // check for runtime mode in filter init parameter String mode = servletConfig.getInitParameter(MODE_PARAM); if (!StringUtils.isNullOrEmpty(mode)) { System.setProperty(PippoConstants.SYSTEM_PROPERTY_PIPPO_MODE, mode); } if (application == null) { createApplication(servletConfig); log.debug("Created application '{}'", application); } ServletContext servletContext = servletConfig.getServletContext(); // save the servlet context object in application application.setServletContext(servletContext); // set the application as an attribute of the servlet container if (servletContext.getAttribute(WebServer.PIPPO_APPLICATION) == null) { servletContext.setAttribute(WebServer.PIPPO_APPLICATION, application); } String contextPath = StringUtils.addStart(servletContext.getContextPath(), "/"); application.getRouter().setContextPath(contextPath); log.debug("Serving application on context path '{}'", contextPath); log.debug("Initializing Route Dispatcher"); routeDispatcher = new RouteDispatcher(application); routeDispatcher.init(); String runtimeMode = application.getRuntimeMode().toString().toUpperCase(); log.info("Pippo started ({})", runtimeMode); }
public Request(HttpServletRequest servletRequest, Application application) { this.httpServletRequest = servletRequest; this.contentTypeEngines = application.getContentTypeEngines(); applicationPath = application.getRouter().getApplicationPath(); // fill (query&post) parameters if any initParameters(); // empty path parameters for now (see internalSetPathParameters method) pathParameters = Collections.unmodifiableMap(new HashMap<String, ParameterValue>()); // init all parameters initAllParameters(); }
} else { ContentTypeEngine engine = application.getContentTypeEngine(contentType); if (engine == null) { log.warn("No registered content type engine for '{}'", contentType); log.error("Unexpected error generating '{}' as '{}'", Error.class.getName(), contentType, e); routeContext.status(HttpConstants.StatusCode.INTERNAL_ERROR); routeContext.send(application.getMessages().get("pippo.statusCode500", routeContext));
protected WebSocketRouter.WebSocketMatch findWebSocketRoute(String requestUri) { String applicationPath = getApplication().getRouter().getContextPath(); String path = applicationPath.isEmpty() ? requestUri : requestUri.substring(applicationPath.length()); if (StringUtils.isNullOrEmpty(path)) { path = "/"; } return getApplication().getWebSocketRouter().match(path); }
public final void init() { // add initializers initializers.addAll(ServiceLocator.locateAll(Initializer.class)); // call each initializer for (Initializer initializer : initializers) { log.debug("Initializing '{}'", initializer.getClass().getName()); try { initializer.init(this); } catch (Exception e) { log.error("Failed to initialize '{}'", initializer.getClass().getName(), e); } } // add transformers List<RouteTransformer> transformers = ServiceLocator.locateAll(RouteTransformer.class); for (RouteTransformer transformer : transformers) { getRouter().addRouteTransformer(transformer); } onInit(); // compile routes getRouter().compileRoutes(); }
@Override public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws IOException, ServletException { HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest; HttpServletResponse httpServletResponse = (HttpServletResponse) servletResponse; // set the application path from the servlet request since we don't know it at initialization String applicationPath = application.getRouter().getContextPath() + httpServletRequest.getServletPath(); application.getRouter().setApplicationPath(applicationPath); // create Request, Response objects RequestResponseFactory requestResponseFactory = application.getRequestResponseFactory(); RequestResponse requestResponse = requestResponseFactory.createRequestResponse(httpServletRequest, httpServletResponse); Request request = requestResponse.getRequest(); Response response = requestResponse.getResponse(); // create a URI to automatically decode the path URI uri = URI.create(httpServletRequest.getRequestURL().toString()); String requestUri = uri.getPath(); String requestPath = request.getPath(); log.trace("The relative path for '{}' is '{}'", requestUri, requestPath); log.debug("Request {} '{}'", request.getMethod(), requestPath); // dispatch route(s) routeDispatcher.dispatch(request, response); }