Examples with Artifacts org.glassfish.deployment.common.Artifacts used on opensource projects

Example 1 with Artifacts

use of org.glassfish.deployment.common.Artifacts in project Payara by payara.

the class AppClientDeployer method addArtifactsToGeneratedFiles.

private void addArtifactsToGeneratedFiles(final AppClientDeployerHelper helper, final DeploymentContext dc) throws IOException {
    final Artifacts generatedFileInfo = DeploymentUtils.generatedArtifacts(dc);
    generatedFileInfo.addArtifacts(helper.earLevelDownloads());
    generatedFileInfo.addArtifacts(helper.clientLevelDownloads());
}

Example 2 with Artifacts

use of org.glassfish.deployment.common.Artifacts in project Payara by payara.

the class NestedAppClientDeployerHelper method processDependencies.

/**
 * Creates downloadable artifacts for any JARs or directory contents on
 * which this nested app client might depend and adds them to the
 * collection of downloadable artifacts for this EAR.
 *
 * @throws IOException
 */
private void processDependencies() throws IOException {
    /*
         * Currently, for directory-deployed apps, we generate JAR files for
         * the submodules.  This is primarily for Java Web Start support, but
         * we also download those generated JARs as part of the "deploy --retrieve" or
         * "get-client-stubs" operations.
         *
         */
    signedJARManager = new ApplicationSignedJARManager(JWSAdapterManager.signingAlias(dc()), jarSigner, habitat, dc(), this, earURI, earDirUserURI(dc()));
    /*
         * Init the class path for the facade so it refers to the developer's app client,
         * relative to where the facade will be.
         */
    URI appClientURI = URI.create(Util.getURIName(appClientUserURI(dc())));
    classPathForFacade.append(appClientURI);
    /*
         * Because the group facade contains generated stubs (if any), add the
         * relative path to the group facade to the facade's Class-Path so those
         * stubs will be accessible via the class path at runtime.
         */
    final URI groupFacadeURIRelativeToFacade = facadeUserURI(dc()).relativize(relativeURIToGroupFacade());
    classPathForFacade.append(" ").append(groupFacadeURIRelativeToFacade.toASCIIString());
    /*
         * For a nested app client, the required downloads include the
         * developer's original app client JAR, the generated facade JAR,
         * the generated EAR-level facade, and
         * the transitive closure of all JARs in the app client's Class-Path
         * and the JARs in the EAR's library-directory.
         *
         * If the user has selected compatibility with v2 behavior, then also
         * consider EJB submodules and JARs at the top level of the EAR.
         */
    clientLevelDownloads.add(new Artifacts.FullAndPartURIs(facadeServerURI(dc()), facadeUserURI(dc())));
    /*
         * dependencyURIsProcessed records URIs, relative to the original JAR as it will
         * reside in the user's download directory, that have already been
         * processed.  This allows us to avoid processing the same JAR or dir more
         * than once if more than one JAR depends on it.
         *
         * Note that all dependencies expressed in the client's manifest must
         * resolve within the EAR, not within the client. So those
         * dependent JARs (or directory contents) will be "EAR-level" not client-level.
         */
    Set<URI> dependencyURIsProcessed = new HashSet<URI>();
    URI appClientURIWithinEAR = URI.create(appClientDesc().getModuleDescriptor().getArchiveUri());
    final Artifact appClientJARArtifact = newArtifact(appClientURIWithinEAR);
    /*
         * Processing the client artifact will recursively process any artifacts
         * on which it depends plus the transitive closure thereof.
         */
    appClientJARArtifact.processArtifact(dependencyURIsProcessed, clientLevelDownloads(), earLevelDownloads());
    /*
         * Now incorporate the library JARs and, if v2 compatibility is chosen,
         * EJB JARs and top level JARs.
         */
    addLibraryJARs(classPathForFacade, PUScanTargetsForFacade, dependencyURIsProcessed);
    if (DeploymentUtils.useV2Compatibility(dc()) && !appClientDesc().getApplication().isVirtual()) {
        addEJBJARs(classPathForFacade, dependencyURIsProcessed);
        addTopLevelJARs(classPathForFacade, PUScanTargetsForFacade, dependencyURIsProcessed);
    }
}

Example 3 with Artifacts

use of org.glassfish.deployment.common.Artifacts in project Payara by payara.

the class AppClientDeployer method addArtifactsToDownloads.

private void addArtifactsToDownloads(final AppClientDeployerHelper helper, final DeploymentContext dc) throws IOException {
    final Artifacts downloadInfo = DeploymentUtils.downloadableArtifacts(dc);
    downloadInfo.addArtifacts(helper.earLevelDownloads());
    downloadInfo.addArtifacts(helper.clientLevelDownloads());
}

Example 4 with Artifacts

use of org.glassfish.deployment.common.Artifacts in project Payara by payara.

the class UndeployCommand method execute.

@Override
public void execute(AdminCommandContext context) {
    // for each matched version
    for (String appName : matchedVersions) {
        if (target == null) {
            target = deployment.getDefaultTarget(appName, origin, _classicstyle);
        }
        ApplicationInfo info = deployment.get(appName);
        Application application = apps.getModule(Application.class, appName);
        if (application == null) {
            report.setMessage(localStrings.getLocalString("application.notreg", "Application {0} not registered", appName));
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            return;
        }
        deployment.validateUndeploymentTarget(target, appName);
        if (!DeploymentUtils.isDomainTarget(target)) {
            ApplicationRef ref = domain.getApplicationRefInTarget(appName, target);
            if (ref == null) {
                report.setMessage(localStrings.getLocalString("ref.not.referenced.target", "Application {0} is not referenced by target {1}", appName, target));
                report.setActionExitCode(ActionReport.ExitCode.FAILURE);
                return;
            }
        }
        ReadableArchive source = null;
        if (info == null) {
            // disabled application or application failed to be
            // loaded for some reason
            URI uri = null;
            try {
                uri = new URI(application.getLocation());
            } catch (URISyntaxException e) {
                logger.severe("Cannot determine original location for application : " + e.getMessage());
            }
            if (uri != null) {
                File location = new File(uri);
                if (location.exists()) {
                    try {
                        source = archiveFactory.openArchive(location);
                    } catch (IOException e) {
                        logger.log(Level.INFO, e.getMessage(), e);
                    }
                } else {
                    logger.warning("Originally deployed application at " + location + " not found");
                }
            }
        } else {
            source = info.getSource();
        }
        if (source == null) {
            logger.fine("Cannot get source archive for undeployment");
            // server is in a consistent state after restart
            try {
                deployment.unregisterAppFromDomainXML(appName, target);
            } catch (TransactionFailure e) {
                logger.warning("Module " + appName + " not found in configuration");
            }
            // also remove application from runtime registry
            if (info != null) {
                appRegistry.remove(appName);
            }
            return;
        }
        File sourceFile = new File(source.getURI());
        if (!source.exists()) {
            logger.log(Level.WARNING, "Cannot find application bits at " + sourceFile.getPath() + ". Please restart server to ensure server is in a consistent state before redeploy the application.");
            // server is in a consistent state after restart
            try {
                deployment.unregisterAppFromDomainXML(appName, target);
            } catch (TransactionFailure e) {
                logger.warning("Module " + appName + " not found in configuration");
            }
            // also remove application from runtime registry
            if (info != null) {
                appRegistry.remove(appName);
            }
            return;
        }
        // now start the normal undeploying
        this.name = appName;
        this._type = application.archiveType();
        ExtendedDeploymentContext deploymentContext = null;
        try {
            deploymentContext = deployment.getBuilder(logger, this, report).source(source).build();
        } catch (IOException e) {
            logger.log(Level.SEVERE, "Cannot create context for undeployment ", e);
            report.setMessage(localStrings.getLocalString("undeploy.contextcreation.failed", "Cannot create context for undeployment : {0} ", e.getMessage()));
            report.setActionExitCode(ActionReport.ExitCode.FAILURE);
            return;
        }
        final InterceptorNotifier notifier = new InterceptorNotifier(habitat, deploymentContext);
        final DeployCommandSupplementalInfo suppInfo = new DeployCommandSupplementalInfo();
        suppInfo.setDeploymentContext(deploymentContext);
        report.setResultType(DeployCommandSupplementalInfo.class, suppInfo);
        final Properties appProps = deploymentContext.getAppProps();
        appProps.putAll(application.getDeployProperties());
        if (properties != null) {
            appProps.putAll(properties);
        }
        deploymentContext.setModulePropsMap(application.getModulePropertiesMap());
        events.send(new Event<DeploymentContext>(Deployment.UNDEPLOYMENT_VALIDATION, deploymentContext), false);
        if (report.getActionExitCode() == ActionReport.ExitCode.FAILURE) {
            // status as failure, return
            return;
        }
        // disable the application first for non-DAS target
        if (env.isDas() && !DeploymentUtils.isDASTarget(target)) {
            ActionReport subReport = report.addSubActionsReport();
            CommandRunner.CommandInvocation inv = commandRunner.getCommandInvocation("disable", subReport, context.getSubject());
            try {
                final ParameterMapExtractor extractor = new ParameterMapExtractor(this);
                final ParameterMap parameters = extractor.extract(Collections.EMPTY_LIST);
                parameters.set("DEFAULT", appName);
                parameters.add(DeploymentProperties.IS_UNDEPLOY, Boolean.TRUE.toString());
                inv.parameters(parameters).execute();
                if (subReport.getActionExitCode().equals(ActionReport.ExitCode.FAILURE)) {
                    // if disable application failed
                    // we should just return
                    report.setMessage(localStrings.getLocalString("disable.command.failed", "{0} disabled failed", appName));
                    return;
                }
                if (DeploymentUtils.isDomainTarget(target)) {
                    List<String> targets = domain.getAllReferencedTargetsForApplication(appName);
                    // replicate command to all referenced targets
                    parameters.remove("isUndeploy");
                    notifier.ensureBeforeReported(ExtendedDeploymentContext.Phase.REPLICATION);
                    ClusterOperationUtil.replicateCommand("undeploy", FailurePolicy.Error, FailurePolicy.Warn, FailurePolicy.Ignore, targets, context, parameters, habitat);
                }
            } catch (Exception e) {
                report.failure(logger, e.getMessage());
                return;
            }
        }
        /*
             * Extract the generated artifacts from the application's properties
             * and record them in the DC.  This will be useful, for example,
             * during Deployer.clean.
             */
        final Artifacts generatedArtifacts = DeploymentUtils.generatedArtifacts(application);
        generatedArtifacts.record(deploymentContext);
        if (info != null) {
            deployment.undeploy(appName, deploymentContext);
        }
        // check if it's directory deployment
        boolean isDirectoryDeployed = Boolean.valueOf(application.getDirectoryDeployed());
        // and warning case
        if (!report.getActionExitCode().equals(ActionReport.ExitCode.FAILURE)) {
            // so far I am doing this after the unload, maybe this should be moved before...
            try {
                // remove the "application" element
                deployment.unregisterAppFromDomainXML(appName, target);
            } catch (TransactionFailure e) {
                logger.warning("Module " + appName + " not found in configuration");
            }
            // remove context from generated
            deploymentContext.clean();
            // free file descriptors
            try {
                Class clazz = Class.forName("sun.net.www.protocol.jar.JarFileFactory", true, URL.class.getClassLoader());
                Field[] fields = clazz.getDeclaredFields();
                for (Field field : fields) {
                    if ("fileCache".equals(field.getName())) {
                        field.setAccessible(true);
                        HashMap<String, JarFile> files = (HashMap<String, JarFile>) field.get(null);
                        Set<JarFile> jars = new HashSet<>();
                        jars.addAll(files.values());
                        for (JarFile file : jars) {
                            file.close();
                        }
                    }
                }
            } catch (ClassNotFoundException | IllegalAccessException | SecurityException | IllegalArgumentException ex) {
                logger.log(Level.SEVERE, null, ex);
            } catch (IOException ex) {
                logger.log(Level.SEVERE, null, ex);
            }
            // perform full GC after cleaning to ensure full clean up
            System.gc();
            // if directory deployment then do not remove the directory
            if ((!keepreposdir) && !isDirectoryDeployed && source.exists()) {
                /*
                     * Delete the repository directory as an archive so
                     * any special handling (such as stale file handling)
                     * known to the archive can run.
                     */
                source.delete();
            }
        }
    // else a message should have been provided.
    }
}