Examples with UiExtensionType org.apache.nifi.web.UiExtensionType used on opensource projects

Example 1 with UiExtensionType

use of org.apache.nifi.web.UiExtensionType in project nifi by apache.

the class JettyServer method loadWars.

private Handler loadWars(final Set<Bundle> bundles) {
    // load WARs
    final Map<File, Bundle> warToBundleLookup = findWars(bundles);
    // locate each war being deployed
    File webUiWar = null;
    File webApiWar = null;
    File webErrorWar = null;
    File webDocsWar = null;
    File webContentViewerWar = null;
    List<File> otherWars = new ArrayList<>();
    for (File war : warToBundleLookup.keySet()) {
        if (war.getName().toLowerCase().startsWith("nifi-web-api")) {
            webApiWar = war;
        } else if (war.getName().toLowerCase().startsWith("nifi-web-error")) {
            webErrorWar = war;
        } else if (war.getName().toLowerCase().startsWith("nifi-web-docs")) {
            webDocsWar = war;
        } else if (war.getName().toLowerCase().startsWith("nifi-web-content-viewer")) {
            webContentViewerWar = war;
        } else if (war.getName().toLowerCase().startsWith("nifi-web")) {
            webUiWar = war;
        } else {
            otherWars.add(war);
        }
    }
    // ensure the required wars were found
    if (webUiWar == null) {
        throw new RuntimeException("Unable to load nifi-web WAR");
    } else if (webApiWar == null) {
        throw new RuntimeException("Unable to load nifi-web-api WAR");
    } else if (webDocsWar == null) {
        throw new RuntimeException("Unable to load nifi-web-docs WAR");
    } else if (webErrorWar == null) {
        throw new RuntimeException("Unable to load nifi-web-error WAR");
    } else if (webContentViewerWar == null) {
        throw new RuntimeException("Unable to load nifi-web-content-viewer WAR");
    }
    // handlers for each war and init params for the web api
    final HandlerCollection handlers = new HandlerCollection();
    final Map<String, String> mimeMappings = new HashMap<>();
    final ClassLoader frameworkClassLoader = getClass().getClassLoader();
    final ClassLoader jettyClassLoader = frameworkClassLoader.getParent();
    // deploy the other wars
    if (CollectionUtils.isNotEmpty(otherWars)) {
        // hold onto to the web contexts for all ui extensions
        componentUiExtensionWebContexts = new ArrayList<>();
        contentViewerWebContexts = new ArrayList<>();
        // ui extension organized by component type
        final Map<String, List<UiExtension>> componentUiExtensionsByType = new HashMap<>();
        for (File war : otherWars) {
            // identify all known extension types in the war
            final Map<UiExtensionType, List<String>> uiExtensionInWar = new HashMap<>();
            identifyUiExtensionsForComponents(uiExtensionInWar, war);
            // only include wars that are for custom processor ui's
            if (!uiExtensionInWar.isEmpty()) {
                // get the context path
                String warName = StringUtils.substringBeforeLast(war.getName(), ".");
                String warContextPath = String.format("/%s", warName);
                // get the classloader for this war
                ClassLoader narClassLoaderForWar = warToBundleLookup.get(war).getClassLoader();
                // this should never be null
                if (narClassLoaderForWar == null) {
                    narClassLoaderForWar = jettyClassLoader;
                }
                // create the extension web app context
                WebAppContext extensionUiContext = loadWar(war, warContextPath, narClassLoaderForWar);
                // create the ui extensions
                for (final Map.Entry<UiExtensionType, List<String>> entry : uiExtensionInWar.entrySet()) {
                    final UiExtensionType extensionType = entry.getKey();
                    final List<String> types = entry.getValue();
                    if (UiExtensionType.ContentViewer.equals(extensionType)) {
                        // consider each content type identified
                        for (final String contentType : types) {
                            // map the content type to the context path
                            mimeMappings.put(contentType, warContextPath);
                        }
                        // this ui extension provides a content viewer
                        contentViewerWebContexts.add(extensionUiContext);
                    } else {
                        // consider each component type identified
                        for (final String componentTypeCoordinates : types) {
                            logger.info(String.format("Loading UI extension [%s, %s] for %s", extensionType, warContextPath, componentTypeCoordinates));
                            // record the extension definition
                            final UiExtension uiExtension = new UiExtension(extensionType, warContextPath);
                            // create if this is the first extension for this component type
                            List<UiExtension> componentUiExtensionsForType = componentUiExtensionsByType.get(componentTypeCoordinates);
                            if (componentUiExtensionsForType == null) {
                                componentUiExtensionsForType = new ArrayList<>();
                                componentUiExtensionsByType.put(componentTypeCoordinates, componentUiExtensionsForType);
                            }
                            // see if there is already a ui extension of this same time
                            if (containsUiExtensionType(componentUiExtensionsForType, extensionType)) {
                                throw new IllegalStateException(String.format("Encountered duplicate UI for %s", componentTypeCoordinates));
                            }
                            // record this extension
                            componentUiExtensionsForType.add(uiExtension);
                        }
                        // this ui extension provides a component custom ui
                        componentUiExtensionWebContexts.add(extensionUiContext);
                    }
                }
                // include custom ui web context in the handlers
                handlers.addHandler(extensionUiContext);
            }
        }
        // record all ui extensions to give to the web api
        componentUiExtensions = new UiExtensionMapping(componentUiExtensionsByType);
    } else {
        componentUiExtensions = new UiExtensionMapping(Collections.EMPTY_MAP);
    }
    // load the web ui app
    final WebAppContext webUiContext = loadWar(webUiWar, "/nifi", frameworkClassLoader);
    webUiContext.getInitParams().put("oidc-supported", String.valueOf(props.isOidcEnabled()));
    webUiContext.getInitParams().put("knox-supported", String.valueOf(props.isKnoxSsoEnabled()));
    handlers.addHandler(webUiContext);
    // load the web api app
    webApiContext = loadWar(webApiWar, "/nifi-api", frameworkClassLoader);
    handlers.addHandler(webApiContext);
    // load the content viewer app
    webContentViewerContext = loadWar(webContentViewerWar, "/nifi-content-viewer", frameworkClassLoader);
    webContentViewerContext.getInitParams().putAll(mimeMappings);
    handlers.addHandler(webContentViewerContext);
    // create a web app for the docs
    final String docsContextPath = "/nifi-docs";
    // load the documentation war
    webDocsContext = loadWar(webDocsWar, docsContextPath, frameworkClassLoader);
    // overlay the actual documentation
    final ContextHandlerCollection documentationHandlers = new ContextHandlerCollection();
    documentationHandlers.addHandler(createDocsWebApp(docsContextPath));
    documentationHandlers.addHandler(webDocsContext);
    handlers.addHandler(documentationHandlers);
    // load the web error app
    final WebAppContext webErrorContext = loadWar(webErrorWar, "/", frameworkClassLoader);
    webErrorContext.getInitParams().put("whitelistedContextPaths", props.getWhitelistedContextPaths());
    handlers.addHandler(webErrorContext);
    // deploy the web apps
    return gzip(handlers);
}