Examples of org.rhq.core.domain.content.InstalledPackageHistory

org.rhq.core.domain.content.InstalledPackageHistory
Audit trail entity for tracking the results of an individual package request made on a resource. Once created, these objects are effectively immutable; if the state of a package request changes a new entity will be created. @author Jason Dobies

            LOG.error("Attempting to complete a request that was not found in the database: " + response.getRequestId());
            return;
        }
        Resource resource = persistedRequest.getResource();


        InstalledPackageHistory initialRequestHistory = persistedRequest.getInstalledPackageHistory().iterator().next();
        PackageVersion packageVersion = initialRequestHistory.getPackageVersion();


        if (response.getStatus() == ContentRequestStatus.SUCCESS) {
            // Read the stream from the agent and store in the package version
            try {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Saving content for response: " + response);
                }


                PackageBits packageBits = initializePackageBits(null);


                // Could use the following, but only on jdk6 as builds
                // @since 1.6
                // void setBinaryStream(int parameterIndex, java.io.InputStream x) throws SQLException;


                Long length = packageVersion.getFileSize();
                if (length == null) {
                    File tmpFile = File.createTempFile("rhq", ".stream");
                    FileOutputStream fos = new FileOutputStream(tmpFile);
                    length = StreamUtil.copy(bitStream, fos, true);


                    bitStream = new FileInputStream(tmpFile);
                }
                Connection conn = null;
                PreparedStatement ps = null;


                try {
                    PackageBits bits = entityManager.find(PackageBits.class, packageBits.getId());
                    String pkgName = "(set packageName)";
                    if ((packageVersion != null) && (packageVersion.getGeneralPackage() != null)) {
                        //update it to whatever package name is if we can get to it.
                        pkgName = packageVersion.getGeneralPackage().getName();
                    }
                    bits = loadPackageBits(bitStream, packageVersion.getId(), pkgName, packageVersion.getVersion(),
                        bits, null);


                    entityManager.merge(bits);
                } finally {


                    if (ps != null) {
                        try {
                            ps.close();
                        } catch (Exception e) {
                            LOG.warn("Failed to close prepared statement for package version [" + packageVersion + "]");
                        }
                    }


                    if (conn != null) {
                        try {
                            conn.close();
                        } catch (Exception e) {
                            LOG.warn("Failed to close connection for package version [" + packageVersion + "]");
                        }
                    }
                }


            } catch (Exception e) {
                LOG.error("Error while reading content from agent stream", e);
                // TODO: don't want to throw exception here? does the tx rollback automatically anyway?
            }
        }


        // Update the persisted request
        persistedRequest.setErrorMessage(response.getErrorMessage());
        persistedRequest.setStatus(response.getStatus());


        // Add a new audit trail entry
        InstalledPackageHistory completedHistory = new InstalledPackageHistory();
        completedHistory.setContentServiceRequest(persistedRequest);
        completedHistory.setResource(resource);
        completedHistory.setTimestamp(System.currentTimeMillis());
        completedHistory.setPackageVersion(packageVersion);


        if (response.getStatus() == ContentRequestStatus.SUCCESS) {
            completedHistory.setStatus(InstalledPackageHistoryStatus.RETRIEVED);
        } else {
            completedHistory.setStatus(InstalledPackageHistoryStatus.FAILED);
            completedHistory.setErrorMessage(response.getErrorMessage());
        }


    }

View Full Code Here

            PackageVersion packageVersion = (PackageVersion) persistedPackageList.get(0);
            ResourcePackageDetails details = ContentManagerHelper.packageVersionToDetails(packageVersion);
            dependencies.add(details);


            // Create an installed package history and attach to the request
            InstalledPackageHistory dependencyPackage = new InstalledPackageHistory();
            dependencyPackage.setContentServiceRequest(persistedRequest);
            dependencyPackage.setPackageVersion(packageVersion);
            dependencyPackage.setResource(resource);
            dependencyPackage.setStatus(InstalledPackageHistoryStatus.BEING_INSTALLED);
            dependencyPackage.setTimestamp(installationDate);


            persistedRequest.addInstalledPackageHistory(dependencyPackage);


            entityManager.persist(dependencyPackage);
        }

View Full Code Here

        // This should only be called as the result of an exception during the user initiated action. As such,
        // every package history entity represents an in progress state. Add a new entry for each in the failed state.
        long timestamp = System.currentTimeMillis();


        for (InstalledPackageHistory history : persistedRequest.getInstalledPackageHistory()) {
            InstalledPackageHistory failedEntry = new InstalledPackageHistory();
            failedEntry.setContentServiceRequest(persistedRequest);
            failedEntry.setDeploymentConfigurationValues(history.getDeploymentConfigurationValues());
            failedEntry.setErrorMessage(ThrowableUtil.getStackAsString(error));
            failedEntry.setPackageVersion(history.getPackageVersion());
            failedEntry.setResource(resource);
            failedEntry.setStatus(InstalledPackageHistoryStatus.FAILED);
            failedEntry.setTimestamp(timestamp);


            persistedRequest.addInstalledPackageHistory(failedEntry);
        }
    }

View Full Code Here

                        // list will likely be in this state, and we'd need to handle resubmissions differently anyway.
                        switch (packageStatus) {
                        case BEING_DELETED:
                        case BEING_INSTALLED:
                        case BEING_RETRIEVED:
                            InstalledPackageHistory closedHistory = new InstalledPackageHistory();
                            closedHistory.setContentServiceRequest(request);
                            closedHistory.setPackageVersion(history.getPackageVersion());
                            closedHistory.setResource(resource);
                            closedHistory.setStatus(InstalledPackageHistoryStatus.TIMED_OUT);
                            closedHistory.setTimestamp(timestamp);


                            entityManager.persist(closedHistory);
                            break;


                        default:

View Full Code Here

    }


    public InstalledPackageHistory getInstalledPackageHistory(int historyId) {
        Query query = entityManager.createNamedQuery(InstalledPackageHistory.QUERY_FIND_BY_ID);
        query.setParameter("id", historyId);
        InstalledPackageHistory history = (InstalledPackageHistory) query.getSingleResult();
        return history;
    }

View Full Code Here

        this.selectedHistoryId = selectedHistoryId;
    }


    public List<PackageInstallationStep> getInstallationSteps() {
        if (installationSteps == null) {
            InstalledPackageHistory history = getHistory();


            if (history == null) {
                log.error("Trying to load steps for null history");
                return installationSteps;
            }


            ContentUIManagerLocal contentUIManager = LookupUtil.getContentUIManager();
            installationSteps = contentUIManager.getPackageInstallationSteps(history.getId()); 
        }


        return installationSteps;
    }

View Full Code Here

        newlyInstalledPackage.setInstallationDate(discoveredPackage.getInstallationTimestamp());


        entityManager.persist(newlyInstalledPackage);


        // Create an audit trail entry to show how this package was added to the system
        InstalledPackageHistory history = new InstalledPackageHistory();
        history.setDeploymentConfigurationValues(discoveredPackage.getDeploymentTimeConfiguration());
        history.setPackageVersion(packageVersion);
        history.setResource(resource);
        history.setStatus(InstalledPackageHistoryStatus.DISCOVERED);
        history.setTimestamp(timestamp);


        entityManager.persist(history);
    }

View Full Code Here

    @Override
    public void removeInstalledPackages(Resource resource, Set<InstalledPackage> doomedPackages, long timestamp) {


        // first, create history records to audit that the previously discovered package was no longer found
        for (InstalledPackage doomedPackage : doomedPackages) {
            InstalledPackageHistory history = new InstalledPackageHistory();
            history.setPackageVersion(doomedPackage.getPackageVersion());
            history.setResource(resource);
            history.setStatus(InstalledPackageHistoryStatus.MISSING);
            history.setTimestamp(timestamp);
            entityManager.persist(history);
        }


        // let's flush these to not buffer too much
        entityManager.flush();

View Full Code Here

            packageVersionQuery.setParameter("resourceTypeId", resource.getResourceType().getId());


            PackageVersion packageVersion = (PackageVersion) packageVersionQuery.getSingleResult();


            // Create the history entity
            InstalledPackageHistory history = new InstalledPackageHistory();
            history.setContentServiceRequest(persistedRequest);
            history.setDeploymentConfigurationValues(packageDetails.getDeploymentTimeConfiguration());
            history.setPackageVersion(packageVersion);
            history.setResource(resource);
            history.setStatus(InstalledPackageHistoryStatus.BEING_INSTALLED);
            history.setTimestamp(timestamp);


            persistedRequest.addInstalledPackageHistory(history);
        }


        entityManager.persist(persistedRequest);

View Full Code Here

            packageVersionQuery.setParameter("resourceTypeId", resourceTypeId);


            PackageVersion packageVersion = (PackageVersion) packageVersionQuery.getSingleResult();


            // Create the history entity
            InstalledPackageHistory history = new InstalledPackageHistory();
            history.setContentServiceRequest(persistedRequest);
            history.setPackageVersion(packageVersion);
            history.setResource(resource);
            history.setTimestamp(timestamp);


            // Link the deployment configuration values that were saved for the initial history entity for this
            // package with this entity as well. This will let us show the user the configuration values on the
            // last entry in the audit trail (i.e. for a failed package, the configuration values will be accessible).
            Query deploymentConfigurationQuery = entityManager
                .createNamedQuery(InstalledPackageHistory.QUERY_FIND_CONFIG_BY_PACKAGE_VERSION_AND_REQ);
            deploymentConfigurationQuery.setParameter("packageVersion", packageVersion);
            deploymentConfigurationQuery.setParameter("contentServiceRequest", persistedRequest);
            deploymentConfigurationQuery.setMaxResults(1);


            Configuration deploymentConfiguration = null;
            List deploymentConfigurationResults = deploymentConfigurationQuery.getResultList();
            if (deploymentConfigurationResults.size() > 0) {
                deploymentConfiguration = (Configuration) deploymentConfigurationResults.get(0);
                deploymentConfiguration = deploymentConfiguration.deepCopy(false);
            }


            history.setDeploymentConfigurationValues(deploymentConfiguration);


            // If the package indicated installation steps, link them to the resulting history entry
            List<DeployPackageStep> transferObjectSteps = singleResponse.getDeploymentSteps();
            if (transferObjectSteps != null) {
                List<PackageInstallationStep> installationSteps = translateInstallationSteps(transferObjectSteps,
                    history);
                history.setInstallationSteps(installationSteps);
            }


            if (singleResponse.getResult() == ContentResponseResult.SUCCESS) {
                history.setStatus(InstalledPackageHistoryStatus.INSTALLED);
            } else {
                history.setStatus(InstalledPackageHistoryStatus.FAILED);
                history.setErrorMessage(singleResponse.getErrorMessage());
            }


            entityManager.persist(history);
            persistedRequest.addInstalledPackageHistory(history);


            // We're closing out the package request for this package version, so remove it from the cache of entries
            // that need to be closed
            inProgressEntries.remove(packageVersion);
        }


        // For any entries that were not closed, add closing entries
        for (InstalledPackageHistory unclosed : inProgressEntries.values()) {
            PackageVersion packageVersion = unclosed.getPackageVersion();


            // Create the history entity
            InstalledPackageHistory history = new InstalledPackageHistory();
            history.setContentServiceRequest(persistedRequest);
            history.setPackageVersion(packageVersion);
            history.setResource(resource);
            history.setTimestamp(timestamp);


            // One option is to create a new status that indicates unknown. For now, just give them the same result
            // as the overall request result
            if (response.getOverallRequestResult() == ContentResponseResult.SUCCESS) {
                history.setStatus(InstalledPackageHistoryStatus.INSTALLED);
            } else {
                history.setStatus(InstalledPackageHistoryStatus.FAILED);
                history.setErrorMessage(response.getOverallRequestErrorMessage());
            }


            entityManager.persist(history);
            persistedRequest.addInstalledPackageHistory(history);
        }

View Full Code Here

0 1 2

TOP

Related Classes of org.rhq.core.domain.content.InstalledPackageHistory

org.rhq.enterprise.gui.content.ShowInstalledPackageHistoryUIBean

org.rhq.enterprise.server.content.ContentManagerBean

org.rhq.enterprise.server.content.ContentUIManagerBean

org.rhq.enterprise.server.content.test.ContentManagerBeanTest

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.