Example usage for org.apache.wicket.application IClassResolver resolveClass

List of usage examples for org.apache.wicket.application IClassResolver resolveClass

Introduction

In this page you can find the example usage for org.apache.wicket.application IClassResolver resolveClass.

Prototype

Class<?> resolveClass(final String classname) throws ClassNotFoundException;

Source Link

Document

Resolves a class by name (which may or may not involve loading it; thus the name class *resolver* not *loader*).

Usage

From source file:org.hippoecm.frontend.Main.java

License:Apache License

@Override
protected void init() {
    super.init();

    addRequestCycleListeners();/*from   ww  w.  j  av  a  2  s . c o  m*/

    registerSessionListeners();

    getPageSettings().setVersionPagesByDefault(false);
    //        getPageSettings().setAutomaticMultiWindowSupport(false);

    //        getSessionSettings().setPageMapEvictionStrategy(new LeastRecentlyAccessedEvictionStrategy(1));

    getApplicationSettings().setPageExpiredErrorPage(PageExpiredErrorPage.class);
    try {
        String cfgParam = getConfigurationParameter(MAXUPLOAD_PARAM, null);
        if (cfgParam != null && cfgParam.trim().length() > 0) {
            getApplicationSettings().setDefaultMaximumUploadSize(Bytes.valueOf(cfgParam));
        }
    } catch (StringValueConversionException ex) {
        log.warn("Unable to parse number as specified by " + MAXUPLOAD_PARAM, ex);
    }
    final IClassResolver originalResolver = getApplicationSettings().getClassResolver();
    getApplicationSettings().setClassResolver(new IClassResolver() {

        @Override
        public Class resolveClass(String name) throws ClassNotFoundException {
            if (Session.exists()) {
                UserSession session = UserSession.get();
                ClassLoader loader = session.getClassLoader();
                if (loader != null) {
                    return session.getClassLoader().loadClass(name);
                }
            }
            return originalResolver.resolveClass(name);
        }

        @Override
        public Iterator<URL> getResources(String name) {
            List<URL> resources = new LinkedList<>();
            for (Iterator<URL> iter = originalResolver.getResources(name); iter.hasNext();) {
                resources.add(iter.next());
            }
            if (Session.exists()) {
                UserSession session = UserSession.get();
                ClassLoader loader = session.getClassLoader();
                if (loader != null) {
                    try {
                        for (Enumeration<URL> resourceEnum = session.getClassLoader()
                                .getResources(name); resourceEnum.hasMoreElements();) {
                            resources.add(resourceEnum.nextElement());
                        }
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            return resources.iterator();
        }

        @Override
        public ClassLoader getClassLoader() {
            return Main.class.getClassLoader();
        }
    });

    final IResourceSettings resourceSettings = getResourceSettings();

    // replace current loaders with own list, starting with component-specific
    List<IStringResourceLoader> loaders = resourceSettings.getStringResourceLoaders();
    loaders.add(new ClassFromKeyStringResourceLoader());
    loaders.add(new IStringResourceLoader() {

        @Override
        public String loadStringResource(final Class<?> clazz, final String key, final Locale locale,
                final String style, final String variation) {
            return null;
        }

        @Override
        public String loadStringResource(final Component component, String key, final Locale locale,
                final String style, final String variation) {
            if (key.contains(",")) {
                key = key.substring(0, key.lastIndexOf(','));
                return resourceSettings.getLocalizer().getStringIgnoreSettings(key, component, null, locale,
                        style, variation);
            }
            return null;
        }
    });

    if (RuntimeConfigurationType.DEVELOPMENT.equals(getConfigurationType())) {
        resourceSettings.setCachingStrategy(new NoOpResourceCachingStrategy());
    } else {
        resourceSettings.setCachingStrategy(
                new FilenameWithVersionResourceCachingStrategy(new LastModifiedResourceVersion()));
    }

    mount(new MountMapper("binaries", new IMountedRequestMapper() {

        @Override
        public IRequestHandler mapRequest(final Request request, final MountParameters mountParams) {
            String path = Strings.join("/", request.getUrl().getSegments());
            try {
                javax.jcr.Session subSession = UserSession.get().getJcrSession();
                Node node = ((HippoWorkspace) subSession.getWorkspace()).getHierarchyResolver()
                        .getNode(subSession.getRootNode(), path);
                // YUCK: no exception!
                if (node == null) {
                    log.info("no binary found at " + path);
                } else {
                    if (node.isNodeType(HippoNodeType.NT_DOCUMENT)) {
                        node = (Node) JcrHelper.getPrimaryItem(node);
                    }
                    return new JcrResourceRequestHandler(node);
                }
            } catch (PathNotFoundException e) {
                log.info("binary not found " + e.getMessage());
            } catch (javax.jcr.LoginException ex) {
                log.warn(ex.getMessage());
            } catch (RepositoryException ex) {
                log.error(ex.getMessage());
            }
            return null;
        }

        @Override
        public int getCompatibilityScore(final Request request) {
            return 1;
        }

        @Override
        public Mount mapHandler(final IRequestHandler requestHandler) {
            return null;
        }
    }));

    String applicationName = getPluginApplicationName();

    if (PLUGIN_APPLICATION_VALUE_CMS.equals(applicationName)) {

        // the following is only applicable and needed for the CMS application, not the Console

        /*
         * HST SAML kind of authentication handler needed for Template Composer integration
         *
         */
        cmsContextService = (CmsInternalCmsContextService) HippoServiceRegistry
                .getService(CmsContextService.class);
        if (cmsContextService == null) {
            cmsContextServiceImpl = new CmsContextServiceImpl();
            cmsContextService = cmsContextServiceImpl;
            HippoServiceRegistry.registerService(cmsContextServiceImpl,
                    new Class[] { CmsContextService.class, CmsInternalCmsContextService.class });
        }
        mount(new MountMapper("auth", new IMountedRequestMapper() {

            @Override
            public IRequestHandler mapRequest(final Request request, final MountParameters mountParams) {

                IRequestHandler requestTarget = new RenderPageRequestHandler(
                        new PageProvider(getHomePage(), null), RedirectPolicy.AUTO_REDIRECT);

                IRequestParameters requestParameters = request.getRequestParameters();
                final List<StringValue> cmsCSIDParams = requestParameters.getParameterValues("cmsCSID");
                final List<StringValue> destinationPathParams = requestParameters
                        .getParameterValues("destinationPath");
                final String destinationPath = destinationPathParams != null && !destinationPathParams.isEmpty()
                        ? destinationPathParams.get(0).toString()
                        : null;

                PluginUserSession userSession = (PluginUserSession) Session.get();
                final UserCredentials userCredentials = userSession.getUserCredentials();

                HttpSession httpSession = ((ServletWebRequest) request).getContainerRequest().getSession();
                final CmsSessionContext cmsSessionContext = CmsSessionContext.getContext(httpSession);

                if (destinationPath != null && destinationPath.startsWith("/")
                        && (cmsSessionContext != null || userCredentials != null)) {

                    requestTarget = new IRequestHandler() {

                        @Override
                        public void respond(IRequestCycle requestCycle) {
                            String destinationUrl = RequestUtils.getFarthestUrlPrefix(request)
                                    + destinationPath;
                            WebResponse response = (WebResponse) RequestCycle.get().getResponse();
                            String cmsCSID = cmsCSIDParams == null ? null
                                    : cmsCSIDParams.get(0) == null ? null : cmsCSIDParams.get(0).toString();
                            if (!cmsContextService.getId().equals(cmsCSID)) {
                                // redirect to destinationURL and include marker that it is a retry. This way
                                // the destination can choose to not redirect for SSO handshake again if it still does not
                                // have a key
                                if (destinationUrl.contains("?")) {
                                    response.sendRedirect(destinationUrl + "&retry");
                                } else {
                                    response.sendRedirect(destinationUrl + "?retry");
                                }
                                return;
                            }
                            String cmsSessionContextId = cmsSessionContext != null ? cmsSessionContext.getId()
                                    : null;
                            if (cmsSessionContextId == null) {
                                CmsSessionContext newCmsSessionContext = cmsContextService.create(httpSession);
                                CmsSessionUtil.populateCmsSessionContext(cmsContextService,
                                        newCmsSessionContext, userSession);
                                cmsSessionContextId = newCmsSessionContext.getId();

                            }
                            if (destinationUrl.contains("?")) {
                                response.sendRedirect(destinationUrl + "&cmsCSID=" + cmsContextService.getId()
                                        + "&cmsSCID=" + cmsSessionContextId);
                            } else {
                                response.sendRedirect(destinationUrl + "?cmsCSID=" + cmsContextService.getId()
                                        + "&cmsSCID=" + cmsSessionContextId);
                            }
                        }

                        @Override
                        public void detach(IRequestCycle requestCycle) {
                            //Nothing to detach.
                        }
                    };
                }
                return requestTarget;
            }

            @Override
            public int getCompatibilityScore(final Request request) {
                return 0;
            }

            @Override
            public Mount mapHandler(final IRequestHandler requestHandler) {
                return null;
            }
        }));
    }

    // caching resource stream locator implementation that allows the class argument to be null.
    final IResourceStreamLocator resourceStreamLocator = resourceSettings.getResourceStreamLocator();
    resourceSettings.setResourceStreamLocator(new IResourceStreamLocator() {
        @Override
        public IResourceStream locate(Class<?> clazz, final String path) {
            if (clazz == null) {
                clazz = CACHING_RESOURCE_STREAM_LOCATOR_CLASS;
            }
            return resourceStreamLocator.locate(clazz, path);
        }

        @Override
        public IResourceStream locate(Class<?> clazz, final String path, final String style,
                final String variation, final Locale locale, final String extension, final boolean strict) {
            if (clazz == null) {
                clazz = CACHING_RESOURCE_STREAM_LOCATOR_CLASS;
            }
            return resourceStreamLocator.locate(clazz, path, style, variation, locale, extension, strict);
        }

        @Override
        public IResourceNameIterator newResourceNameIterator(final String path, final Locale locale,
                final String style, final String variation, final String extension, final boolean strict) {
            return resourceStreamLocator.newResourceNameIterator(path, locale, style, variation, extension,
                    strict);
        }
    });

    if (RuntimeConfigurationType.DEVELOPMENT.equals(getConfigurationType())) {
        // disable cache
        resourceSettings.getLocalizer().setEnableCache(false);

        final long timeout = NumberUtils.toLong(
                getConfigurationParameter(DEVELOPMENT_REQUEST_TIMEOUT_PARAM, null),
                DEFAULT_DEVELOPMENT_REQUEST_TIMEOUT_MS);

        if (timeout > 0L) {
            log.info("Setting wicket request timeout to {} ms.", timeout);
            getRequestCycleSettings().setTimeout(Duration.milliseconds(timeout));
        }

        // render comments with component class names
        getDebugSettings().setOutputMarkupContainerClassName(true);

        // do not render Wicket-specific markup since it can break CSS
        getMarkupSettings().setStripWicketTags(true);
    } else {
        // don't serialize pages for performance
        setPageManagerProvider(new DefaultPageManagerProvider(this) {

            @Override
            protected IPageStore newPageStore(final IDataStore dataStore) {
                return new AmnesicPageStore();
            }
        });

        // don't throw on missing resource
        resourceSettings.setThrowExceptionOnMissingResource(false);

        // don't show exception page
        getExceptionSettings().setUnexpectedExceptionDisplay(IExceptionSettings.SHOW_NO_EXCEPTION_PAGE);

        final long timeout = NumberUtils
                .toLong(getConfigurationParameter(DEPLOYMENT_REQUEST_TIMEOUT_PARAM, null));

        if (timeout > 0L) {
            log.info("Setting wicket request timeout to {} ms.", timeout);
            getRequestCycleSettings().setTimeout(Duration.milliseconds(timeout));
        }
    }

    String outputWicketpaths = obtainOutputWicketPathsParameter();

    if (outputWicketpaths != null && "true".equalsIgnoreCase(outputWicketpaths)) {
        getDebugSettings().setOutputComponentPath(true);
    }

    final IContextProvider<AjaxRequestTarget, Page> ajaxRequestTargetProvider = getAjaxRequestTargetProvider();
    setAjaxRequestTargetProvider(context -> new PluginRequestTarget(ajaxRequestTargetProvider.get(context)));

    setPageRendererProvider(new IPageRendererProvider() {

        @Override
        public PageRenderer get(final RenderPageRequestHandler context) {
            return new WebPageRenderer(context) {

                @Override
                protected BufferedWebResponse renderPage(final Url targetUrl, final RequestCycle requestCycle) {
                    IRequestHandler scheduled = requestCycle.getRequestHandlerScheduledAfterCurrent();
                    if (scheduled == null) {
                        IRequestablePage page = getPage();
                        if (page instanceof Home) {
                            Home home = (Home) page;
                            home.processEvents();
                            home.render(null);
                        }
                    }
                    return super.renderPage(targetUrl, requestCycle);
                }
            };
        }
    });

    // don't allow public access to any package resource (empty whitelist) by default
    resourceSettings.setPackageResourceGuard(new WhitelistedClassesResourceGuard());

    if (log.isInfoEnabled()) {
        log.info("Hippo CMS application " + applicationName + " has started");
    }
}

From source file:org.ops4j.pax.wicket.internal.DelegatingClassResolver.java

License:Apache License

public Class<?> resolveClass(final String classname) throws ClassNotFoundException {
    synchronized (resolvers) {
        LOGGER.trace("Try to resolve {} from {} resolvers", classname, resolvers.size());
        for (IClassResolver resolver : resolvers) {
            try {
                Class<?> candidate = resolver.resolveClass(classname);
                if (candidate != null) {
                    return candidate;
                }/*from  ww  w.j a  v a2s  .  co  m*/
            } catch (ClassNotFoundException e) {
                LOGGER.trace("ClassResolver {} could not find class: {}", resolver, classname);
            } catch (RuntimeException e) {
                LOGGER.warn("ClassResolver {} threw an unexpected exception.", resolver, e);
            }
        }
    }
    throw new ClassNotFoundException(String.format("Class [%s] can't be resolved.", classname));
}

From source file:org.ops4j.pax.wicket.it.classResolver.ClassResolverByPidTest.java

License:Apache License

private void validateThatClassResolverIsExposedToAbcAndDef() throws Throwable {
    ServiceReference[] references = bundleContext.getServiceReferences(IClassResolver.class.getName(),
            "(" + APPLICATION_NAME + "=abc)");
    assertNotNull(references);//from   w ww . j a  va  2  s  .  co  m
    assertEquals(references.length, 1);
    ServiceReference reference = references[0];
    String[] applicationNames = (String[]) reference.getProperty(APPLICATION_NAME);
    assertEquals(2, applicationNames.length);
    assertEquals(applicationNames[0], "abc");
    assertEquals(applicationNames[1], "def");

    // Verify that this is the simple libraries class resolver
    IClassResolver classResolver = (IClassResolver) bundleContext.getService(reference);
    String className = "org.ops4j.pax.wicket.it.classResolver.simpleLibraries.internal.PrivateClass";
    Class clazz = classResolver.resolveClass(className);
    assertNotNull(clazz);
    assertEquals(clazz.getName(), className);

    bundleContext.ungetService(reference);
}