Examples with Deployment org.glassfish.internal.deployment.Deployment used on opensource projects

Example 1 with Deployment

use of org.glassfish.internal.deployment.Deployment in project Payara by payara.

the class MetroContainer method deployWsTxServices.

public void deployWsTxServices(String target) {
    synchronized (lock) {
        if (wstxServicesDeployed.get() || !wstxServicesDeploying.compareAndSet(false, true)) {
            return;
        }
        Deployment deployment = serviceLocator.getService(Deployment.class);
        boolean isRegistered = deployment.isRegistered(WSTX_SERVICES_APP_NAME);
        if (isRegistered) {
            logger.log(WARNING, WSTX_SERVICE_DEPLOYED_EXPLICITLY);
        } else {
            logger.log(INFO, WSTX_SERVICE_LOADING);
            File root = serverContext.getInstallRoot();
            File app = null;
            try {
                app = FileUtils.getManagedFile(WSTX_SERVICES_APP_NAME + ".war", new File(root, METRO_APPS_INSTALL_ROOT));
            } catch (Exception e) {
                logger.log(WARNING, WSTX_SERVICE_UNEXPECTED_EXCEPTION, e);
            }
            if (app == null || !app.exists()) {
                // TODO
                logger.log(WARNING, format(WSTX_SERVICE_CANNOT_DEPLOY, "Required WAR file (" + WSTX_SERVICES_APP_NAME + ".war) is not installed"));
            } else {
                ActionReport report = serviceLocator.getService(ActionReport.class, "plain");
                DeployCommandParameters params = new DeployCommandParameters(app);
                String appName = WSTX_SERVICES_APP_NAME;
                params.name = appName;
                try {
                    File rootScratchDir = env.getApplicationStubPath();
                    File appScratchDir = new File(rootScratchDir, appName);
                    if (isDas() && appScratchDir.createNewFile()) {
                        params.origin = OpsParams.Origin.deploy;
                        if (target != null) {
                            params.target = target;
                        }
                    } else {
                        params.origin = OpsParams.Origin.load;
                        params.target = env.getInstanceName();
                    }
                    ExtendedDeploymentContext dc = deployment.getBuilder(logger, params, report).source(app).build();
                    Properties appProps = dc.getAppProps();
                    appProps.setProperty(OBJECT_TYPE, SYSTEM_ALL);
                    deployment.deploy(dc);
                    if (report.getActionExitCode() != ActionReport.ExitCode.SUCCESS) {
                        logger.log(WARNING, format(WSTX_SERVICE_CANNOT_DEPLOY, report.getMessage()), report.getFailureCause());
                    }
                    logger.log(INFO, WSTX_SERVICE_STARTED);
                } catch (Exception ex) {
                    logger.log(WARNING, format(WSTX_SERVICE_CANNOT_DEPLOY, ex.getLocalizedMessage()), ex);
                }
            }
        }
        wstxServicesDeployed.set(true);
        wstxServicesDeploying.set(false);
    }
}

Example 2 with Deployment

use of org.glassfish.internal.deployment.Deployment in project Payara by payara.

the class ApplicationLifecycle method prepare.

@Override
public ApplicationDeployment prepare(Collection<? extends Sniffer> sniffers, final ExtendedDeploymentContext context) {
    StructuredDeploymentTracing tracing = StructuredDeploymentTracing.load(context);
    DeploymentSpan eventSpan = tracing.startSpan(DeploymentTracing.AppStage.PROCESS_EVENTS, Deployment.DEPLOYMENT_START.type());
    events.send(new Event<>(Deployment.DEPLOYMENT_START, context), false);
    eventSpan.close();
    currentDeploymentContext.get().push(context);
    final ActionReport report = context.getActionReport();
    final DeployCommandParameters commandParams = context.getCommandParameters(DeployCommandParameters.class);
    final String appName = commandParams.name();
    ApplicationInfo appInfo;
    Optional<ApplicationState> appState = hotDeployService.getApplicationState(context);
    final ClassLoader currentCL = Thread.currentThread().getContextClassLoader();
    ProgressTracker tracker = new ProgressTracker() {

        @Override
        public void actOn(Logger logger) {
            // loaded but may not be started. Issue 18263
            for (EngineRef module : get("loaded", EngineRef.class)) {
                try {
                    module.stop(context);
                } catch (Exception e) {
                // ignore
                }
            }
            try {
                PreDestroy.class.cast(context).preDestroy();
            } catch (Exception e) {
            // ignore
            }
            for (EngineRef module : get("loaded", EngineRef.class)) {
                try {
                    module.unload(context);
                } catch (Exception e) {
                // ignore
                }
            }
            try {
                ApplicationInfo appInfo = appRegistry.get(appName);
                if (appInfo != null) {
                    // send the event to close necessary resources
                    events.send(new Event<>(Deployment.APPLICATION_DISABLED, appInfo));
                }
            } catch (Exception e) {
            // ignore
            }
            for (EngineRef module : get("prepared", EngineRef.class)) {
                try {
                    module.clean(context);
                } catch (Exception e) {
                // ignore
                }
            }
            if (!commandParams.keepfailedstubs) {
                try {
                    context.clean();
                } catch (Exception e) {
                // ignore
                }
            }
            appRegistry.remove(appName);
        }
    };
    try (DeploymentSpan topSpan = tracing.startSpan(DeploymentTracing.AppStage.PREPARE);
        SpanSequence span = tracing.startSequence(DeploymentTracing.AppStage.PREPARE, "ArchiveMetadata")) {
        if (commandParams.origin == OpsParams.Origin.deploy && appRegistry.get(appName) != null && !commandParams.hotDeploy) {
            report.setMessage(localStrings.getLocalString("appnamenotunique", "Application name {0} is already in use. Please pick a different name.", appName));
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            return null;
        }
        // defined virtual servers minus __asadmin on that target
        if (commandParams.virtualservers == null) {
            commandParams.virtualservers = DeploymentUtils.getVirtualServers(commandParams.target, env, domain);
        }
        if (commandParams.enabled == null) {
            commandParams.enabled = Boolean.TRUE;
        }
        if (commandParams.altdd != null) {
            context.getSource().addArchiveMetaData(DeploymentProperties.ALT_DD, commandParams.altdd);
        }
        if (commandParams.runtimealtdd != null) {
            context.getSource().addArchiveMetaData(DeploymentProperties.RUNTIME_ALT_DD, commandParams.runtimealtdd);
        }
        context.addTransientAppMetaData(ExtendedDeploymentContext.TRACKER, tracker);
        context.setPhase(DeploymentContextImpl.Phase.PREPARE);
        span.start("ArchiveHandler");
        ArchiveHandler handler = context.getArchiveHandler();
        if (handler == null) {
            handler = getArchiveHandler(context.getSource(), commandParams.type);
            context.setArchiveHandler(handler);
        }
        if (handler == null) {
            report.setMessage(localStrings.getLocalString("unknownarchivetype", "Archive type of {0} was not recognized", context.getSourceDir()));
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            return null;
        }
        span.start(DeploymentTracing.AppStage.CLASS_SCANNING);
        if (handler.requiresAnnotationScanning(context.getSource())) {
            getDeployableTypes(context);
        }
        span.finish();
        // is that some container do not support to be restarted.
        if (sniffers != null && logger.isLoggable(Level.FINE)) {
            for (Sniffer sniffer : sniffers) {
                logger.log(FINE, "Before Sorting{0}", sniffer.getModuleType());
            }
        }
        span.start(DeploymentTracing.AppStage.PREPARE, "Sniffer");
        sniffers = getSniffers(handler, sniffers, context);
        final Collection<? extends Sniffer> selectedSniffers = sniffers;
        appState.ifPresent(s -> s.setSniffers(selectedSniffers));
        span.start(DeploymentTracing.AppStage.PREPARE, "ClassLoaderHierarchy");
        ClassLoaderHierarchy clh = habitat.getService(ClassLoaderHierarchy.class);
        span.start(DeploymentTracing.AppStage.PREPARE, "ClassLoader");
        context.createDeploymentClassLoader(clh, handler);
        events.send(new Event<>(Deployment.AFTER_DEPLOYMENT_CLASSLOADER_CREATION, context), false);
        Thread.currentThread().setContextClassLoader(context.getClassLoader());
        span.start(DeploymentTracing.AppStage.PREPARE, "Container");
        final List<EngineInfo> sortedEngineInfos;
        if (appState.map(ApplicationState::getEngineInfos).isPresent()) {
            sortedEngineInfos = appState.get().getEngineInfos();
            loadDeployers(sortedEngineInfos.stream().collect(toMap(EngineInfo::getDeployer, Function.identity())), context);
        } else {
            sortedEngineInfos = setupContainerInfos(handler, sniffers, context);
            appState.ifPresent(s -> s.setEngineInfos(sortedEngineInfos));
        }
        // a bit more is happening here, but I cannot quite describe it yet
        span.start(DeploymentTracing.AppStage.CREATE_CLASSLOADER);
        if (sortedEngineInfos.isEmpty()) {
            throw new DeploymentException(localStrings.getLocalString("unknowncontainertype", "There is no installed container capable of handling this application {0}", context.getSource().getName()));
        }
        if (logger.isLoggable(Level.FINE)) {
            for (EngineInfo info : sortedEngineInfos) {
                logger.log(FINE, "After Sorting {0}", info.getSniffer().getModuleType());
            }
        }
        // create a temporary application info to hold metadata
        // so the metadata could be accessed at classloader
        // construction time through ApplicationInfo
        ApplicationInfo tempAppInfo = new ApplicationInfo(events, context.getSource(), appName);
        for (Object m : context.getModuleMetadata()) {
            tempAppInfo.addMetaData(m);
        }
        tempAppInfo.setIsJavaEEApp(sortedEngineInfos);
        // set the flag on the archive to indicate whether it's
        // a JavaEE archive or not
        context.getSource().setExtraData(Boolean.class, tempAppInfo.isJavaEEApp());
        appRegistry.add(appName, tempAppInfo);
        try {
            notifyLifecycleInterceptorsBefore(ExtendedDeploymentContext.Phase.PREPARE, context);
        } catch (Throwable interceptorException) {
            report.failure(logger, "Exception while invoking the lifecycle interceptor", null);
            report.setFailureCause(interceptorException);
            logger.log(SEVERE, KernelLoggerInfo.lifecycleException, interceptorException);
            tracker.actOn(logger);
            return null;
        }
        events.send(new Event<>(Deployment.DEPLOYMENT_BEFORE_CLASSLOADER_CREATION, context), false);
        context.createApplicationClassLoader(clh, handler);
        tempAppInfo.setAppClassLoader(context.getFinalClassLoader());
        events.send(new Event<>(Deployment.AFTER_APPLICATION_CLASSLOADER_CREATION, context), false);
        // this is a first time deployment as opposed as load following an unload event,
        // we need to create the application info
        // todo : we should come up with a general Composite API solution
        final ModuleInfo moduleInfo;
        try (SpanSequence innerSpan = span.start(DeploymentTracing.AppStage.PREPARE, "Module")) {
            if (appState.map(ApplicationState::getModuleInfo).isPresent()) {
                moduleInfo = appState.get().getModuleInfo();
                moduleInfo.reset();
            } else {
                moduleInfo = prepareModule(sortedEngineInfos, appName, context, tracker);
                appState.ifPresent(s -> s.setModuleInfo(moduleInfo));
            }
            // Now that the prepare phase is done, any artifacts
            // should be available.  Go ahead and create the
            // downloadable client JAR.  We want to do this now, or
            // at least before the load and start phases, because
            // (for example) the app client deployer start phase
            // needs to find all generated files when it runs.
            final ClientJarWriter cjw = new ClientJarWriter(context);
            cjw.run();
        } catch (Throwable prepareException) {
            report.failure(logger, "Exception while preparing the app", null);
            report.setFailureCause(prepareException);
            logger.log(SEVERE, KernelLoggerInfo.lifecycleException, prepareException);
            tracker.actOn(logger);
            return null;
        }
        span.start(DeploymentTracing.AppStage.PROCESS_EVENTS, Deployment.APPLICATION_PREPARED.type());
        // is not a composite module.
        if (appState.map(ApplicationState::getApplicationInfo).isPresent()) {
            appInfo = appState.get().getApplicationInfo();
            appInfo.reset(context.getSource());
            for (Object metadata : context.getModuleMetadata()) {
                moduleInfo.addMetaData(metadata);
                appInfo.addMetaData(metadata);
            }
        } else if ((appInfo = context.getModuleMetaData(ApplicationInfo.class)) == null) {
            ApplicationInfo applicationInfo = new ApplicationInfo(events, context.getSource(), appName);
            appInfo = applicationInfo;
            appInfo.addModule(moduleInfo);
            appState.ifPresent(s -> s.setApplicationInfo(applicationInfo));
            for (Object metadata : context.getModuleMetadata()) {
                moduleInfo.addMetaData(metadata);
                appInfo.addMetaData(metadata);
            }
        } else {
            for (EngineRef ref : moduleInfo.getEngineRefs()) {
                appInfo.add(ref);
            }
        }
        // remove the temp application info from the registry
        // first, then register the real one
        appRegistry.remove(appName);
        appInfo.setIsJavaEEApp(sortedEngineInfos);
        appRegistry.add(appName, appInfo);
        notifyLifecycleInterceptorsAfter(ExtendedDeploymentContext.Phase.PREPARE, context);
        // send the APPLICATION_PREPARED event
        // set the phase and thread context classloader properly
        // before sending the event
        context.setPhase(DeploymentContextImpl.Phase.PREPARED);
        Thread.currentThread().setContextClassLoader(context.getClassLoader());
        appInfo.setAppClassLoader(context.getClassLoader());
        appState.ifPresent(s -> s.setApplicationClassLoader(context.getClassLoader()));
        events.send(new Event<>(Deployment.APPLICATION_PREPARED, context), false);
        if (loadOnCurrentInstance(context)) {
            appInfo.setLibraries(commandParams.libraries());
            try (SpanSequence innerSpan = span.start(DeploymentTracing.AppStage.LOAD)) {
                notifyLifecycleInterceptorsBefore(ExtendedDeploymentContext.Phase.LOAD, context);
                appInfo.load(context, tracker);
                notifyLifecycleInterceptorsAfter(ExtendedDeploymentContext.Phase.LOAD, context);
            } catch (Throwable loadException) {
                logger.log(SEVERE, KernelLoggerInfo.lifecycleException, loadException);
                report.failure(logger, "Exception while loading the app", null);
                report.setFailureCause(loadException);
                tracker.actOn(logger);
                return null;
            }
        }
    } catch (DeploymentException de) {
        report.failure(logger, de.getMessage());
        tracker.actOn(logger);
        return null;
    } catch (Exception e) {
        report.failure(logger, localStrings.getLocalString("error.deploying.app", "Exception while deploying the app [{0}]", appName), null);
        report.setFailureCause(e);
        logger.log(SEVERE, KernelLoggerInfo.lifecycleException, e);
        tracker.actOn(logger);
        return null;
    } finally {
        Thread.currentThread().setContextClassLoader(currentCL);
        if (report.getActionExitCode() != ActionReport.ExitCode.SUCCESS) {
            context.postDeployClean(false);
            events.send(new Event<>(Deployment.DEPLOYMENT_FAILURE, context));
        }
    }
    ApplicationDeployment depl = new ApplicationDeployment(appInfo, context);
    appRegistry.addTransient(depl);
    return depl;
}

Example 3 with Deployment

use of org.glassfish.internal.deployment.Deployment in project Payara by payara.

the class VirtualServer method addContext.

/**
 * Registers the given <tt>Context</tt> with this <tt>VirtualServer</tt> at the given context root.
 *
 * <p>
 * If this <tt>VirtualServer</tt> has already been started, the given <tt>context</tt> will be started as well.
 *
 * @throws org.glassfish.embeddable.GlassFishException
 */
@Override
public void addContext(Context context, String contextRoot) throws ConfigException, GlassFishException {
    _logger.fine(VS_ADDED_CONTEXT);
    if (!(context instanceof ContextFacade)) {
        // embedded context should always be created via ContextFacade
        return;
    }
    if (!contextRoot.startsWith("/")) {
        contextRoot = "/" + contextRoot;
    }
    ExtendedDeploymentContext deploymentContext = null;
    try {
        if (factory == null) {
            factory = services.getService(ArchiveFactory.class);
        }
        ContextFacade facade = (ContextFacade) context;
        File docRoot = facade.getDocRoot();
        ClassLoader classLoader = facade.getClassLoader();
        ReadableArchive archive = factory.openArchive(docRoot);
        if (report == null) {
            report = new PlainTextActionReporter();
        }
        ServerEnvironment env = services.getService(ServerEnvironment.class);
        DeployCommandParameters params = new DeployCommandParameters();
        params.contextroot = contextRoot;
        params.enabled = Boolean.FALSE;
        params.origin = OpsParams.Origin.deploy;
        params.virtualservers = getName();
        params.target = "server";
        ExtendedDeploymentContext initialContext = new DeploymentContextImpl(report, archive, params, env);
        if (deployment == null) {
            deployment = services.getService(Deployment.class);
        }
        ArchiveHandler archiveHandler = deployment.getArchiveHandler(archive);
        if (archiveHandler == null) {
            throw new RuntimeException("Cannot find archive handler for source archive");
        }
        params.name = archiveHandler.getDefaultApplicationName(archive, initialContext);
        Applications apps = domain.getApplications();
        ApplicationInfo appInfo = deployment.get(params.name);
        ApplicationRef appRef = domain.getApplicationRefInServer(params.target, params.name);
        if (appInfo != null && appRef != null) {
            if (appRef.getVirtualServers().contains(getName())) {
                throw new ConfigException("Context with name " + params.name + " is already registered on virtual server " + getName());
            } else {
                String virtualServers = appRef.getVirtualServers();
                virtualServers = virtualServers + "," + getName();
                params.virtualservers = virtualServers;
                params.force = Boolean.TRUE;
                if (_logger.isLoggable(Level.FINE)) {
                    _logger.log(Level.FINE, "Virtual server " + getName() + " added to context " + params.name);
                }
                return;
            }
        }
        deploymentContext = deployment.getBuilder(_logger, params, report).source(archive).archiveHandler(archiveHandler).build(initialContext);
        Properties properties = new Properties();
        deploymentContext.getAppProps().putAll(properties);
        if (classLoader != null) {
            ClassLoader parentCL = classLoaderHierarchy.createApplicationParentCL(classLoader, deploymentContext);
            ClassLoader cl = archiveHandler.getClassLoader(parentCL, deploymentContext);
            deploymentContext.setClassLoader(cl);
        }
        ApplicationConfigInfo savedAppConfig = new ApplicationConfigInfo(apps.getModule(com.sun.enterprise.config.serverbeans.Application.class, params.name));
        Properties appProps = deploymentContext.getAppProps();
        String appLocation = DeploymentUtils.relativizeWithinDomainIfPossible(deploymentContext.getSource().getURI());
        appProps.setProperty(ServerTags.LOCATION, appLocation);
        appProps.setProperty(ServerTags.OBJECT_TYPE, "user");
        appProps.setProperty(ServerTags.CONTEXT_ROOT, contextRoot);
        savedAppConfig.store(appProps);
        Transaction t = deployment.prepareAppConfigChanges(deploymentContext);
        appInfo = deployment.deploy(deploymentContext);
        if (appInfo != null) {
            facade.setAppName(appInfo.getName());
            if (_logger.isLoggable(Level.FINE)) {
                _logger.log(Level.FINE, LogFacade.VS_ADDED_CONTEXT, new Object[] { getName(), appInfo.getName() });
            }
            deployment.registerAppInDomainXML(appInfo, deploymentContext, t);
        } else {
            if (report.getActionExitCode().equals(ActionReport.ExitCode.FAILURE)) {
                throw new ConfigException(report.getMessage());
            }
        }
        // Update web.xml with programmatically added servlets, filters, and listeners
        File file = null;
        boolean delete = true;
        com.sun.enterprise.config.serverbeans.Application appBean = apps.getApplication(params.name);
        if (appBean != null) {
            file = new File(deploymentContext.getSource().getURI().getPath(), "/WEB-INF/web.xml");
            if (file.exists()) {
                delete = false;
            }
            updateWebXml(facade, file);
        } else {
            _logger.log(Level.SEVERE, LogFacade.APP_NOT_FOUND);
        }
        ReadableArchive source = appInfo.getSource();
        UndeployCommandParameters undeployParams = new UndeployCommandParameters(params.name);
        undeployParams.origin = UndeployCommandParameters.Origin.undeploy;
        undeployParams.target = "server";
        ExtendedDeploymentContext undeploymentContext = deployment.getBuilder(_logger, undeployParams, report).source(source).build();
        deployment.undeploy(params.name, undeploymentContext);
        params.origin = DeployCommandParameters.Origin.load;
        params.enabled = Boolean.TRUE;
        archive = factory.openArchive(docRoot);
        deploymentContext = deployment.getBuilder(_logger, params, report).source(archive).build();
        if (classLoader != null) {
            ClassLoader parentCL = classLoaderHierarchy.createApplicationParentCL(classLoader, deploymentContext);
            archiveHandler = deployment.getArchiveHandler(archive);
            ClassLoader cl = archiveHandler.getClassLoader(parentCL, deploymentContext);
            deploymentContext.setClassLoader(cl);
        }
        deployment.deploy(deploymentContext);
        // Enable the app using the modified web.xml
        // We can't use Deployment.enable since it doesn't take DeploymentContext with custom class loader
        deployment.updateAppEnabledAttributeInDomainXML(params.name, params.target, true);
        if (_logger.isLoggable(Level.FINE)) {
            _logger.log(Level.FINE, LogFacade.VS_ENABLED_CONTEXT, new Object[] { getName(), params.name() });
        }
        if (delete) {
            if (file != null) {
                if (file.exists() && !file.delete()) {
                    String path = file.toString();
                    _logger.log(Level.WARNING, LogFacade.UNABLE_TO_DELETE, path);
                }
            }
        }
        if (contextRoot.equals("/")) {
            contextRoot = "";
        }
        WebModule wm = (WebModule) findChild(contextRoot);
        if (wm != null) {
            facade.setUnwrappedContext(wm);
            wm.setEmbedded(true);
            if (config != null) {
                wm.setDefaultWebXml(config.getDefaultWebXml());
            }
        } else {
            throw new ConfigException("Deployed app not found " + contextRoot);
        }
        if (deploymentContext != null) {
            deploymentContext.postDeployClean(true);
        }
    } catch (Exception ex) {
        if (deployment != null && deploymentContext != null) {
            deploymentContext.clean();
        }
        throw new GlassFishException(ex);
    }
}

Example 4 with Deployment

use of org.glassfish.internal.deployment.Deployment in project Payara by payara.

the class MEJBNamingObjectProxy method deployMEJB.

private void deployMEJB() throws IOException {
    _logger.info("Loading MEJB app on JNDI look up");
    ServerContext serverContext = habitat.getService(ServerContext.class);
    File mejbArchive = new File(serverContext.getInstallRoot(), "lib/install/applications/mejb.jar");
    DeployCommandParameters deployParams = new DeployCommandParameters(mejbArchive);
    String targetName = habitat.<Server>getService(Server.class, ServerEnvironment.DEFAULT_INSTANCE_NAME).getName();
    deployParams.target = targetName;
    deployParams.name = "mejb";
    ActionReport report = habitat.getService(ActionReport.class, "plain");
    Deployment deployment = habitat.getService(Deployment.class);
    ExtendedDeploymentContext dc = deployment.getBuilder(_logger, deployParams, report).source(mejbArchive).build();
    deployment.deploy(dc);
    if (report.getActionExitCode() != ActionReport.ExitCode.SUCCESS) {
        throw new RuntimeException("Failed to deploy MEJB app: " + report.getFailureCause());
    }
}

Example 5 with Deployment

use of org.glassfish.internal.deployment.Deployment in project Payara by payara.

the class RestMonitoringLoader method loadApplication.

/**
 * Loads the application
 */
private void loadApplication() {
    ApplicationRegistry appRegistry = habitat.getService(ApplicationRegistry.class);
    ApplicationInfo appInfo = appRegistry.get(applicationName);
    if (appInfo != null && appInfo.isLoaded()) {
        LOGGER.log(Level.FINE, "Rest Monitoring Application already loaded.");
        return;
    }
    Application config = null;
    if (dynamicStart) {
        config = restMonitoringAdapter.getSystemApplicationConfig(contextRoot);
    } else {
        config = restMonitoringAdapter.getSystemApplicationConfig();
    }
    if (config == null) {
        throw new IllegalStateException("The Rest Monitoring application has no system app entry!");
    }
    // Load the Rest Monitoring Application
    String instanceName = serverEnv.getInstanceName();
    ApplicationRef ref = domain.getApplicationRefInServer(instanceName, applicationName);
    Deployment lifecycle = habitat.getService(Deployment.class);
    for (Deployment.ApplicationDeployment depl : habitat.getService(ApplicationLoaderService.class).processApplication(config, ref)) {
        lifecycle.initialize(depl.appInfo, depl.appInfo.getSniffers(), depl.context);
    }
    // Mark as registered
    restMonitoringAdapter.setAppRegistered(true);
    LOGGER.log(Level.FINE, "Rest Monitoring Application Loaded.");
}