Examples of org.apache.sling.api.request.RequestProgressTracker

org.apache.sling.api.request.RequestProgressTracker
The RequestProgressTracker class provides the functionality to track the progress of request processing. Instances of this class are provided through the {@link org.apache.sling.api.SlingHttpServletRequest#getRequestProgressTracker()}method.
The following functionality is provided:
1. Track the progress of request processing through the {@link #log(String)} and {@link #log(String,Object)} methods.
2. Ability to measure and track processing times of parts of request processing through the {@link #startTimer(String)}, {@link #logTimer(String)} and {@link #logTimer(String,String,Object)}methods.
3. Dumping the recording messages through the {@link #dump(PrintWriter)}method.
4. Return the log messages through the {@link #getMessages()} method.
Tracking Request Processing
As the request being processed, certain steps may be tracked by calling either of the log methods. A tracking entry consists of a time stamp managed by this class and a tracking message noting the actual step being tracked.
Timing Processing Steps
Certain steps during request processing may need to be timed in that the time required for processing should be recorded. Instances of this class maintain a map of named timers. Each timer is started (initialized or reset) by calling the {@link #startTimer(String)} method. This method just records thestarting time of the named timer and adds a tracking entry with the timer name as the message.
To record the number of milliseconds elapsed since a timer has been started, the {@link #logTimer(String)} or {@link #logTimer(String,String,Object)}method may be called. This method logs a tracking entry with a message consisting of the name of the timer and the number of milliseconds elapsed since the timer was last {@link #startTimer(String) started}. The logTimer methods may be called multiple times to record several timed steps.
Calling the {@link #startTimer(String)} method with the name of timer whichalready exists, resets the start time of the named timer to the current system time.
Retrieving Tracking Entries
The {@link #dump(PrintWriter)} method may be used to write the trackingentries to the given PrintWriter to for example log them in a HTML comment. Alternatively the tracking entries may be retrieved as an iterator of messages through the {@link #getMessages()} method. Theformatting of the tracking entries is implementation specific.

     */
    public Servlet resolveServlet(final SlingHttpServletRequest request) {
        final Resource resource = request.getResource();


        // start tracking servlet resolution
        final RequestProgressTracker tracker = request.getRequestProgressTracker();
        final String timerName = "resolveServlet(" + resource + ")";
        tracker.startTimer(timerName);


        final String type = resource.getResourceType();
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("resolveServlet called for resource {}", resource);
        }


        final ResourceResolver scriptResolver = this.getScriptResourceResolver();
        Servlet servlet = null;


        if ( type != null && type.length() > 0 ) {
            servlet = resolveServletInternal(request, null, type, scriptResolver);
        }


        // last resort, use the core bundle default servlet
        if (servlet == null) {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("No specific servlet found, trying default");
            }
            servlet = getDefaultServlet();
        }


        // track servlet resolution termination
        if (servlet == null) {
            tracker.logTimer(timerName, "Servlet resolution failed. See log for details");
        } else {
            tracker.logTimer(timerName, "Using servlet {0}", RequestUtil.getServletName(servlet));
        }


        // log the servlet found
        if (LOGGER.isDebugEnabled()) {
            if (servlet != null) {

View Full Code Here

            LOGGER.error("handleError: Recursive invocation. Not further handling status " + status + "(" + message + ")");
            return;
        }


        // start tracker
        RequestProgressTracker tracker = request.getRequestProgressTracker();
        String timerName = "handleError:status=" + status;
        tracker.startTimer(timerName);


        final ResourceResolver scriptResolver = this.getScriptResourceResolver();
        try {
            // find the error handler component
            Resource resource = getErrorResource(request);


            // find a servlet for the status as the method name
            ResourceCollector locationUtil = new ResourceCollector(String.valueOf(status),
                    ServletResolverConstants.ERROR_HANDLER_PATH, resource,
                    this.executionPaths);
            Servlet servlet = getServletInternal(locationUtil, request, scriptResolver);


            // fall back to default servlet if none
            if (servlet == null) {
                servlet = getDefaultErrorServlet(request, resource, scriptResolver);
            }


            // set the message properties
            request.setAttribute(ERROR_STATUS, new Integer(status));
            request.setAttribute(ERROR_MESSAGE, message);


            // the servlet name for a sendError handling is still stored
            // as the request attribute
            Object servletName = request.getAttribute(SLING_CURRENT_SERVLET_NAME);
            if (servletName instanceof String) {
                request.setAttribute(ERROR_SERVLET_NAME, servletName);
            }


            // log a track entry after resolution before calling the handler
            tracker.logTimer(timerName, "Using handler {0}", RequestUtil.getServletName(servlet));


            handleError(servlet, request, response);


        } finally {
            tracker.logTimer(timerName, "Error handler finished");
        }
    }

View Full Code Here

            LOGGER.error("handleError: Recursive invocation. Not further handling Throwable:", throwable);
            return;
        }


        // start tracker
        RequestProgressTracker tracker = request.getRequestProgressTracker();
        String timerName = "handleError:throwable=" + throwable.getClass().getName();
        tracker.startTimer(timerName);


        final ResourceResolver scriptResolver = this.getScriptResourceResolver();
        try {
            // find the error handler component
            Servlet servlet = null;
            Resource resource = getErrorResource(request);


            Class<?> tClass = throwable.getClass();
            while (servlet == null && tClass != Object.class) {
                // find a servlet for the simple class name as the method name
                ResourceCollector locationUtil = new ResourceCollector(tClass.getSimpleName(),
                        ServletResolverConstants.ERROR_HANDLER_PATH, resource,
                        this.executionPaths);
                servlet = getServletInternal(locationUtil, request, scriptResolver);


                // go to the base class
                tClass = tClass.getSuperclass();
            }


            if (servlet == null) {
                servlet = getDefaultErrorServlet(request, resource, scriptResolver);
            }


            // set the message properties
            request.setAttribute(SlingConstants.ERROR_EXCEPTION, throwable);
            request.setAttribute(SlingConstants.ERROR_EXCEPTION_TYPE, throwable.getClass());
            request.setAttribute(SlingConstants.ERROR_MESSAGE, throwable.getMessage());


            // log a track entry after resolution before calling the handler
            tracker.logTimer(timerName, "Using handler {0}", RequestUtil.getServletName(servlet));


            handleError(servlet, request, response);
        } finally {
            tracker.logTimer(timerName, "Error handler finished");
        }
    }

View Full Code Here

            pw.println("</pre>");
        }


        // dump the request progress tracker
        if (req instanceof SlingHttpServletRequest) {
            final RequestProgressTracker tracker = ((SlingHttpServletRequest) req).getRequestProgressTracker();
            pw.println("<h3>Request Progress:</h3>");
            pw.println("<pre>");
            pw.flush();
            tracker.dump(escapingWriter);
            escapingWriter.flush();
            pw.println("</pre>");
        }


        // conclude the response message

View Full Code Here

         */


        SlingHttpServletRequest cRequest = RequestData.unwrap(request);
        RequestData rd = RequestData.getRequestData(cRequest);
        String absPath = getAbsolutePath(cRequest, path);
        RequestProgressTracker requestProgressTracker = cRequest.getRequestProgressTracker();


        // if the response is not an HttpServletResponse, fail gracefully not
        // doing anything
        if (!(sResponse instanceof HttpServletResponse)) {
            log.error("include: Failed to include {}, response has wrong type",
                absPath);
            return;
        }


        if (resource == null) {
            String timerName = "resolveIncludedResource(" + absPath + ")";
            requestProgressTracker.startTimer(timerName);


            // resolve the absolute path in the resource resolver, using
            // only those parts of the path as if it would be request path
            resource = cRequest.getResourceResolver().resolve(absPath);


            // if the resource could not be resolved, fail gracefully
            if (resource == null) {
                log.error(
                    "include: Could not resolve {} to a resource, not including",
                    absPath);
                return;
            }


            requestProgressTracker.logTimer(timerName,
                    "path={0} resolves to Resource={1}",
                    absPath, resource);
        }


        // ensure request path info and optional merges
        SlingRequestPathInfo info = getMergedRequestPathInfo(cRequest);
        requestProgressTracker.log(
            "Including resource {0} ({1})", resource, info);
        rd.getSlingRequestProcessor().dispatchRequest(request, sResponse, resource,
            info, include);
    }

View Full Code Here

                pw.flush();
                throwable.printStackTrace(escapingWriter);
                escapingWriter.flush();
                pw.println("</pre>");


                final RequestProgressTracker tracker = ((SlingHttpServletRequest) request).getRequestProgressTracker();
                pw.println("<h3>Request Progress:</h3>");
                pw.println("<pre>");
                pw.flush();
                tracker.dump(new PrintWriter(escapingWriter));
                escapingWriter.flush();
                pw.println("</pre>");
            }


            pw.println("<hr /><address>");

View Full Code Here

    // ---------- internal helper


    private void trackFilter(ServletRequest request, Filter filter) {
        RequestData data = RequestData.getRequestData(request);
        if (data != null) {
            RequestProgressTracker tracker = data.getRequestProgressTracker();
            tracker.log("Calling filter: {0}",
                this.filters[this.current].getClass().getName());
        }
    }

View Full Code Here

            FilterChain chain) throws IOException, ServletException {


        chain.doFilter(request, response);


        if (request instanceof SlingHttpServletRequest) {
            final RequestProgressTracker t = ((SlingHttpServletRequest) request).getRequestProgressTracker();
            t.done();


            if (log.isDebugEnabled()) {
                int requestId = 0;
                synchronized (getClass()) {
                    requestId = ++requestCounter;
                }
                final Iterator<String> it = t.getMessages();
                while (it.hasNext()) {
                    log.debug("REQUEST_{} - " + it.next(), requestId);
                }
            }
        }

View Full Code Here

        final SlingBindings bindings = (SlingBindings) pageContext.getRequest().getAttribute(
                SlingBindings.class.getName());
        final SlingScriptHelper scriptHelper = bindings.getSling();
        final ServletResolver servletResolver = scriptHelper.getService(ServletResolver.class);


        final RequestProgressTracker tracker = TagUtil.getRequest(pageContext).getRequestProgressTracker();
        String servletName = null;


        final Servlet servlet;
        if (!ignoreComponentHierarchy) {
            final Resource resource = bindings.getResource();
            servlet = servletResolver.resolveServlet(resource, this.script);


            if (servlet != null) {
                servletName = RequestUtil.getServletName(servlet);
                tracker.log("Including script {0} for path={1}, type={2}: {3}", script, resource.getPath(),
                        resource.getResourceType(), servletName);
            }


        } else {
            final ResourceResolver resolver = bindings.getRequest().getResourceResolver();
            final String scriptPath;
            if (!script.startsWith("/")) {


                // resolve relative script
                String parentPath = ResourceUtil.getParent(scriptHelper.getScript().getScriptResource().getPath());
                // check if parent resides on search path
                for (String sp : resolver.getSearchPath()) {
                    if (parentPath.startsWith(sp)) {
                        parentPath = parentPath.substring(sp.length());
                        break;
                    }
                }
                scriptPath = parentPath + "/" + script;


            } else {


                scriptPath = this.script;
            }
            servlet = servletResolver.resolveServlet(resolver, scriptPath);


            if (servlet != null) {
                servletName = RequestUtil.getServletName(servlet);
                tracker.log("Including script {0} (ignoring component hierarchy): {1}", script, servletName);
            }
        }


        if (servlet == null) {
            throw new JspException("Could not find script " + script);
        }


        try {
            if (flush && !(pageContext.getOut() instanceof BodyContent)) {
                // might throw an IOException of course
                pageContext.getOut().flush();
            }


            // wrap the response to get the correct output order
            SlingHttpServletResponse response = new JspSlingHttpServletResponseWrapper(pageContext);


            tracker.startTimer(servletName);


            servlet.service(pageContext.getRequest(), response);


            tracker.logTimer(servletName);


            return EVAL_PAGE;


        } catch (Exception e) {

View Full Code Here

     * @return
     */
    public String getRequestProgress(SlingHttpServletRequest request) {
        StringWriter stringWriter = new StringWriter();
        if (request != null) {
            RequestProgressTracker tracker = request.getRequestProgressTracker();
            tracker.dump(new PrintWriter(stringWriter, true));
        }
        return stringWriter.toString();
    }

View Full Code Here

0 1

TOP

Related Classes of org.apache.sling.api.request.RequestProgressTracker

com.adobe.acs.commons.errorpagehandler.impl.ErrorPageHandlerImpl

org.apache.sling.engine.impl.debug.RequestProgressTrackerLogFilter

org.apache.sling.engine.impl.DefaultErrorHandler

org.apache.sling.engine.impl.filter.AbstractSlingFilterChain

org.apache.sling.engine.impl.request.SlingRequestDispatcher

org.apache.sling.engine.impl.SlingMainServlet

org.apache.sling.scripting.jsp.taglib.CallTag

org.apache.sling.servlets.resolver.internal.defaults.DefaultErrorHandlerServlet

org.apache.sling.servlets.resolver.internal.SlingServletResolver

org.apache.sling.servlets.resolver.SlingServletResolver

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.