Java tutorial
/* * Jopr Management Platform * Copyright (C) 2005-2008 Red Hat, Inc. * All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License, version 2, as * published by the Free Software Foundation, and/or the GNU Lesser * General Public License, version 2.1, also as published by the Free * Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License and the GNU Lesser General Public License * for more details. * * You should have received a copy of the GNU General Public License * and the GNU Lesser General Public License along with this program; * if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ package org.rhq.core.pluginapi.content; import java.io.BufferedInputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Arrays; import java.util.Comparator; import java.util.Properties; import java.util.Set; import java.util.Stack; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.rhq.core.domain.content.PackageDetails; import org.rhq.core.domain.content.transfer.ResourcePackageDetails; import org.rhq.core.pluginapi.util.FileUtils; import org.rhq.core.util.MessageDigestGenerator; import org.rhq.core.util.ZipUtil; import org.rhq.core.util.file.FileUtil; /** * Delegate class used for manipulating artifacts in a JON plugin. * * @author Greg Hinkle * @author Jason Dobies * @author Stefan Negrea */ public class FileContentDelegate { private static final String RHQ_SHA_256 = "RHQ-Sha256"; private static final String SHA256_FILE = "application.sha256"; private final Log log = LogFactory.getLog(FileContentDelegate.class); private final String fileEnding; private final File directory; /** * Default constructor. */ public FileContentDelegate() { this.fileEnding = null; this.directory = null; } public FileContentDelegate(File directory, String fileEnding) { this.directory = directory; this.fileEnding = fileEnding; } public String getFileEnding() { return fileEnding; } public File getDirectory() { return directory; } /** * Creates a new package described by the specified details. The destination of the content in the provided input * stream will be determined by the package name. * * @param details describes the package being created * @param content content to be written for the package. NOTE this Stream will be closed by this method. * @param unzip if <code>true</code>, the content stream will be treated like a ZIP file and be unzipped as * it is written, using the package name as the base directory; if <code>false</code> the * @param createBackup If <code>true</code>, the original file will be backed up to file.bak */ public void createContent(PackageDetails details, File content, boolean unzip) { File destination = getPath(details); try { if (unzip) { ZipUtil.unzipFile(content, destination); } else { FileUtil.copyFile(content, destination); } details.setFileName(destination.getPath()); } catch (IOException e) { throw new RuntimeException("Error creating artifact from details: " + destination, e); } } /** * Returns a stream from which the content of the specified package can be read. * * @param details package being loaded * * @return buffered input stream containing the contents of the package; will not be <code>null</code>, an * exception is thrown if the content cannot be loaded */ public InputStream getContent(PackageDetails details) { File contentFile = getPath(details); try { return new BufferedInputStream(new FileInputStream(contentFile)); } catch (FileNotFoundException e) { throw new RuntimeException("Package content not found for package " + contentFile, e); } } /** * Deletes the underlying file for the specified package. * * @param details package to delete */ public void deleteContent(PackageDetails details) { File contentFile = getPath(details); if (!contentFile.exists()) return; try { FileUtils.purge(contentFile, true); } catch (IOException e) { throw new RuntimeException( "Failed to delete underlying file [" + contentFile + "] for " + details + ".", e); } } /** * This is a stub implementation, you need to implement a * discovery for artifacts of your particular content type. * * @return */ public Set<ResourcePackageDetails> discoverDeployedPackages() { throw new UnsupportedOperationException("This method is not implemented!"); } /** * Retrieves SHA256 for the deployment. If this is an exploded deployment * and SHA256 is missing from the data directory then compute the SHA256 * and save in the data directory. * * @param deployment deployment location * @param resourceId resource id * @param dataDirectory data directory * @return SHA256 of the package */ public String retrieveDeploymentSHA(File deployment, File resourceDataDirectory) { String sha = null; if (deployment.isDirectory()) { File propertiesFile = new File(resourceDataDirectory, SHA256_FILE); if (propertiesFile.exists()) { FileInputStream propertiesInputStream = null; try { propertiesInputStream = new FileInputStream(propertiesFile); Properties prop = new Properties(); prop.load(propertiesInputStream); sha = prop.getProperty(RHQ_SHA_256); } catch (IOException e) { throw new RuntimeException("Error retrieving artifact's SHA256.", e); } finally { if (propertiesInputStream != null) { try { propertiesInputStream.close(); } catch (IOException e) { log.error("Failed to close input stream.", e); } } } } if (sha == null) { sha = this.saveDeploymentSHA(deployment, resourceDataDirectory); } } else { sha = this.computeSHAForArchivedContent(deployment); } return sha; } /** * Save the SHA256 for a deployment with knowledge of the original archived content. * If the deployment is archived, do not save anything. Just return the SHA256 * of the content. * * @param originalArchive * @param deployment * @param resourceId * @param dataDirectory * @return */ public String saveDeploymentSHA(File originalArchive, File deployment, File resourceDataDirectory) { String sha = null; if (deployment.isDirectory()) { sha = this.computeSHAForArchivedContent(originalArchive); this.saveDeploymentSHA(sha, resourceDataDirectory); } else { sha = this.computeSHAForArchivedContent(deployment); } return sha; } /** * Save the SHA256 for a deployment without knowing its original archived content. * If the deployment is archived, do not save anything. Just return the SHA256 * of the content. * * @param deployment deployment * @param resourceId resource id * @param dataDirectory data directory * @return the saved SHA256 */ public String saveDeploymentSHA(File deployment, File resourceDataDirectory) { String sha = null; if (deployment.isDirectory()) { sha = this.computeSHAForExplodedContent(deployment); this.saveDeploymentSHA(sha, resourceDataDirectory); } else { sha = this.computeSHAForArchivedContent(deployment); } return sha; } /** * Persist the SHA256 value in data directory in a properties file. * File name format is "[Uuid of Resource].sha" * * @param sha SHA256 of the content * @param resourceId resource Uuid * @param dataDirectory data directory */ private void saveDeploymentSHA(String sha, File resourceDataDirectory) { Properties prop = new Properties(); prop.setProperty(RHQ_SHA_256, sha); File propertiesFile = new File(resourceDataDirectory, SHA256_FILE); FileOutputStream propertiesOutputStream = null; try { propertiesOutputStream = new FileOutputStream(propertiesFile); prop.store(propertiesOutputStream, null); } catch (FileNotFoundException e) { throw new RuntimeException("Error saving artifact's SHA256.", e); } catch (IOException e) { throw new RuntimeException("Error saving artifact's SHA256.", e); } finally { if (propertiesOutputStream != null) { try { propertiesOutputStream.close(); } catch (IOException e) { throw new RuntimeException("Error saving artifact's SHA256.", e); } } } } /** * Computes SHA256 for an archived content. * * @param contentFile content archive * @return SHA256 of the archive */ private String computeSHAForArchivedContent(File contentFile) { if (!contentFile.isDirectory()) { try { MessageDigestGenerator messageDigest = new MessageDigestGenerator(MessageDigestGenerator.SHA_256); return messageDigest.calcDigestString(contentFile); } catch (Exception ex) { log.error("Not able to compute SHA256 for " + contentFile.getPath() + " ."); } } return null; } /** * Computes SHA256 for exploded content as the aggregate SHA256 * of all the files in the deployment * * @param deploymentDirectory deployment directory * @return SHA256 of the content */ private String computeSHAForExplodedContent(File deploymentDirectory) { try { if (deploymentDirectory.isDirectory()) { MessageDigestGenerator messageDigest = new MessageDigestGenerator(MessageDigestGenerator.SHA_256); Stack<File> unvisitedFolders = new Stack<File>(); unvisitedFolders.add(deploymentDirectory); while (!unvisitedFolders.empty()) { File[] files = unvisitedFolders.pop().listFiles(); Arrays.sort(files, new Comparator<File>() { public int compare(File f1, File f2) { try { return f1.getCanonicalPath().compareTo(f2.getCanonicalPath()); } catch (IOException e) { //do nothing if the sort fails at this point } return 0; } }); for (File file : files) { if (file.isDirectory()) { unvisitedFolders.add(file); } else { FileInputStream inputStream = null; try { inputStream = new FileInputStream(file); messageDigest.add(inputStream); } finally { if (inputStream != null) { inputStream.close(); } } } } } return messageDigest.getDigestString(); } } catch (IOException e) { throw new RuntimeException("Error creating artifact for contentFile: " + deploymentDirectory, e); } return null; } /** * JBNADM-2022 - It still needs to be determined if it is the responsibility of the plugin container or the * plugin to be concerned with path information in the package name. For now, it's the plugin's * responsibility. We strip out the path information to keep control of where the JARs are * deployed to. Note: when we add support for more package types, we'll need to refactor this * out on a package type basis. * @param details package details * @return destination path */ private File getPath(PackageDetails details) { String fileName = details.getKey().getName(); int lastPathStart = fileName.lastIndexOf(File.separatorChar); if (lastPathStart > -1) { fileName = fileName.substring(lastPathStart + 1); } if (this.fileEnding != null && !fileName.endsWith(this.fileEnding)) { fileName = fileName + this.fileEnding; } return new File(this.directory, fileName); } }