modules/common/ant-bundle/src/test/java/org/rhq/bundle/ant/AntLauncherTest.java
| 25 -
modules/core/util/src/main/java/org/rhq/core/util/file/FileUtil.java
| 72 ++++
modules/core/util/src/main/java/org/rhq/core/util/updater/Deployer.java
| 135 +++++++-
modules/core/util/src/test/java/org/rhq/core/util/file/FileUtilTest.java
| 98 +++++-
modules/core/util/src/test/java/org/rhq/core/util/updater/DeployerTest.java
| 49 +--
modules/core/util/src/test/java/org/rhq/core/util/updater/SimpleDeployerTest.java
| 77 ++++-
modules/plugins/ant-bundle/src/test/java/org/rhq/plugins/ant/AntBundlePluginComponentTest.java
| 152 +++++++++-
modules/plugins/ant-bundle/src/test/resources/test-bundle-manage-root-dir.xml
| 16 +
8 files changed, 540 insertions(+), 84 deletions(-)
New commits:
commit 9eebf13c055908a1afd357ff4e507052190fb890
Author: John Mazzitelli <mazz(a)redhat.com>
Date: Thu Feb 2 08:45:39 2012 -0500
[BZ 784124] forgot to fix this test
Due to the conflict here, I also pulled in BZ 751027 (commit
d1e85ac2ef91f4578861f139bbc248603fea782e)
This BZ was simply to make sure the test only runs on RH flavors, not just any old
Linux.
Conflicts:
modules/common/ant-bundle/src/test/java/org/rhq/bundle/ant/AntLauncherTest.java
diff --git
a/modules/common/ant-bundle/src/test/java/org/rhq/bundle/ant/AntLauncherTest.java
b/modules/common/ant-bundle/src/test/java/org/rhq/bundle/ant/AntLauncherTest.java
index 1df24d6..bd2d35d 100644
--- a/modules/common/ant-bundle/src/test/java/org/rhq/bundle/ant/AntLauncherTest.java
+++ b/modules/common/ant-bundle/src/test/java/org/rhq/bundle/ant/AntLauncherTest.java
@@ -59,6 +59,7 @@ import org.rhq.core.util.updater.FileHashcodeMap;
public class AntLauncherTest {
private static final File DEPLOY_DIR = new
File("target/test-ant-bundle").getAbsoluteFile();
private static final String ANT_BASEDIR = "target/test-classes";
+ private static final File REDHAT_RELEASE_FILE = new
File("/etc/redhat-release");
private int deploymentId;
@@ -107,12 +108,13 @@ public class AntLauncherTest {
public void testInstall() throws Exception {
- if (skipNonLinux("testInstall")) return;
+ if (skipNonRHLinux("testInstall"))
+ return;
// We want to test a fresh install, so make sure the deploy dir doesn't
pre-exist.
FileUtil.purge(DEPLOY_DIR, true);
- // but we do want to add an unrelated file to see that it remains untouched - the
install just "goes around" it
+ // but we do want to add an unrelated file to see that it goes away - since we
have manageRootDir=true
File unrelatedFile = writeFile("unrelated content", DEPLOY_DIR,
"unrelated-file.txt");
AntLauncher ant = new AntLauncher();
@@ -156,16 +158,16 @@ public class AntLauncherTest {
assert new File(DEPLOY_DIR, "subdir/test.properties").exists() :
"missing file";
assert new File(DEPLOY_DIR, "archived-bundle-file.txt").exists() :
"missing archived bundle file";
assert new File(DEPLOY_DIR,
"archived-subdir/archived-file-in-subdir.properties").exists() : "missing
subdir archive file";
- assert unrelatedFile.exists() : "unrelated file was removed during the
install";
+ assert !unrelatedFile.exists() : "unrelated file was not removed during the
install";
assert readPropsFile(new File(DEPLOY_DIR,
"subdir/test.properties")).getProperty("junk.listener.port").equals(
"10000");
assert readPropsFile(new File(DEPLOY_DIR,
"archived-subdir/archived-file-in-subdir.properties")).getProperty(
"templatized.variable").equals("10000");
}
- private boolean skipNonLinux(String meth) {
- if (!System.getProperty("os.name").equals("Linux")) {
- System.out.println("Skipping " + meth + "() as this only works
on Linux");
+ private boolean skipNonRHLinux(String meth) {
+ if (!System.getProperty("os.name").equals("Linux") ||
!REDHAT_RELEASE_FILE.exists()) {
+ System.out.println("Skipping " + meth + "() as this only works
on Red Hat Linux flavors");
return true;
}
return false;
@@ -174,10 +176,10 @@ public class AntLauncherTest {
@Test(dependsOnMethods = "testInstall")
public void testUpgrade() throws Exception {
- if (skipNonLinux("testUpgrade")) return;
+ if (skipNonRHLinux("testUpgrade"))
+ return;
- // We want to test an upgrade, so do *not* wipe out the deploy dir - our test
method @dependsOnMethods testInstall
- // but we do want to add an unrelated file to see that it gets deleted as part of
the upgrade
+ // add an unrelated file to see that it gets deleted as part of the upgrade
File unrelatedFile = writeFile("unrelated content", DEPLOY_DIR,
"unrelated-file.txt");
AntLauncher ant = new AntLauncher();
@@ -230,14 +232,15 @@ public class AntLauncherTest {
public void testUpgradeNoManageRootDir() throws Exception {
- if (skipNonLinux("testInstall")) return;
+ if (skipNonRHLinux("testInstall"))
+ return;
// We want to test an upgrade, so do *not* wipe out the deploy dir - let's
re-invoke testInstall
// to get us to an initial state of the v1 bundle installed
testInstall();
// we still want the unrelated file - we want to see that manageRootDir=false
works (unrelated files should not be deleted)
- File unrelatedFile = new File(DEPLOY_DIR, "unrelated-file.txt");
+ File unrelatedFile = writeFile("unrelated content", DEPLOY_DIR,
"unrelated-file.txt");
assert unrelatedFile.exists() : "our initial install test method should have
prepared an unmanaged file";
AntLauncher ant = new AntLauncher();
commit 43ba87eadc086fe9da031584620168f1f04d9ec1
Author: John Mazzitelli <mazz(a)redhat.com>
Date: Thu Jan 26 17:19:43 2012 -0500
[BZ 784124] fix the issue where, on initial deployment of a bundle, we didn't
clean out any files that happen to be in the deployment dir.
we need to remove them, they are in the way. we do back them up so they can be
manually retrieved if the user screwed up.
diff --git a/modules/core/util/src/main/java/org/rhq/core/util/file/FileUtil.java
b/modules/core/util/src/main/java/org/rhq/core/util/file/FileUtil.java
index c4ac737..9135279 100644
--- a/modules/core/util/src/main/java/org/rhq/core/util/file/FileUtil.java
+++ b/modules/core/util/src/main/java/org/rhq/core/util/file/FileUtil.java
@@ -33,6 +33,7 @@ import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
+import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
@@ -102,6 +103,77 @@ public class FileUtil {
StreamUtil.copy(is, os);
}
+ public static void copyDirectory(File inDir, File outDir) throws IOException {
+ if (inDir.exists()) {
+ if (!inDir.isDirectory()) {
+ throw new IOException("Source directory [" + inDir + "] is
not a directory");
+ }
+ } else {
+ throw new FileNotFoundException("Source directory [" + inDir +
"] does not exist");
+ }
+
+ if (!outDir.mkdirs()) {
+ throw new IOException("Destination directory [" + outDir + "]
failed to be created");
+ }
+
+ if (!canWrite(outDir)) {
+ throw new IOException("Cannot write to destination directory [" +
outDir + "]");
+ }
+
+ // TODO do we care to restore the last mod time on the destination dir?
+ //outDir.setLastModified(inDir.lastModified());
+
+ File[] files = inDir.listFiles();
+ if (files == null) {
+ throw new IOException("Failed to get the list of files in source
directory [" + inDir + "]");
+ }
+ for (File file : files) {
+ File copiedFile = new File(outDir, file.getName());
+ if (file.isDirectory()) {
+ copyDirectory(file, copiedFile);
+ } else {
+ copyFile(file, copiedFile);
+ }
+ }
+
+ files = null; // help GC
+ return;
+ }
+
+ /**
+ * Obtains the list of all files in the given directory and, recursively, all its
subdirectories.
+ * Note that the returns list is only regular files - directory names are NOT in the
list. Also,
+ * the names in the list are relative to the given directory.
+ * @param directory the directory whose files are to be returned
+ * @return list of files in the directory, not sorted in any particular order
+ * @throws IOException if directory does not exist or is not a directory
+ */
+ public static List<File> getDirectoryFiles(File directory) throws IOException
{
+ ArrayList<File> files = new ArrayList<File>();
+ if (!directory.isDirectory()) {
+ throw new IOException("[" + directory + "] is not an existing
directory");
+ }
+ getDirectoryFilesRecursive(directory, files, null);
+ return files;
+ }
+
+ private static void getDirectoryFilesRecursive(File directory, List<File>
files, String relativeTo)
+ throws IOException {
+ File[] children = directory.listFiles();
+ if (children == null) {
+ throw new IOException("Cannot obtain files from directory [" +
directory + "]");
+ }
+ for (File child : children) {
+ if (child.isDirectory()) {
+ getDirectoryFilesRecursive(child, files, ((relativeTo == null) ?
"" : relativeTo) + child.getName()
+ + File.separatorChar);
+ } else {
+ files.add(new File(relativeTo, child.getName()));
+ }
+ }
+ return;
+ }
+
/**
* Copy a stream, using a buffer.
* @deprecated use {@link StreamUtil} for more methods like this - those are unit
tested and used more
diff --git a/modules/core/util/src/main/java/org/rhq/core/util/updater/Deployer.java
b/modules/core/util/src/main/java/org/rhq/core/util/updater/Deployer.java
index 652bcda..40ce727 100644
--- a/modules/core/util/src/main/java/org/rhq/core/util/updater/Deployer.java
+++ b/modules/core/util/src/main/java/org/rhq/core/util/updater/Deployer.java
@@ -28,6 +28,8 @@ import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
+import java.io.FilenameFilter;
+import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
@@ -301,9 +303,9 @@ public class Deployer {
return;
}
- debug("Estimated disk usage for this deployment is [",
usage.getDiskUsage(), "] bytes (file count=[", usage
- .getFileCount(), "]). The maximum disk space currently usable is
estimated to be [", usage
- .getMaxDiskUsable(), "] bytes.");
+ debug("Estimated disk usage for this deployment is [",
usage.getDiskUsage(), "] bytes (file count=[",
+ usage.getFileCount(), "]). The maximum disk space currently usable is
estimated to be [",
+ usage.getMaxDiskUsable(), "] bytes.");
if (usage.getDiskUsage() > usage.getMaxDiskUsable()) {
throw new Exception(
@@ -316,6 +318,31 @@ public class Deployer {
}
private FileHashcodeMap performInitialDeployment(DeployDifferences diff, boolean
dryRun) throws Exception {
+ // If we are to fully manage the deployment dir, then we need to delete
everything we find here.
+ // Any old files do not belong here - only our bundle files should live here
now.
+ if (this.deploymentData.isManageRootDir()) {
+ File destDir = this.deploymentData.getDestinationDir();
+ log.info(buildLogMessage("Will be managing the deploy dir[",
destDir,
+ "]; backing up and purging any obsolete content existing in
there"));
+ if (destDir.isDirectory()) {
+ int deploymentId =
this.deploymentData.getDeploymentProps().getDeploymentId();
+ backupFiles(diff, deploymentId, destDir, dryRun, null, true);
+ if (!dryRun) {
+ // we want to purge everything that is originally in here, but we
backed up the files in here
+ // so make sure we don't delete our metadata directory, which is
where the backed up files are
+ File[] doomedFiles = destDir.listFiles(new FilenameFilter() {
+ @Override
+ public boolean accept(File dir, String name) {
+ return !DeploymentsMetadata.METADATA_DIR.equals(name);
+ }
+ });
+ for (File doomedFile : doomedFiles) {
+ FileUtil.purge(doomedFile, true);
+ }
+ }
+ }
+ }
+
FileHashcodeMap newFileHashcodeMap = extractZipAndRawFiles(new HashMap<String,
String>(0), diff, dryRun);
// this is an initial deployment, so we know every file is new - tell our diff
about them all
@@ -340,8 +367,8 @@ public class Deployer {
// * if a current file is backed up
FileHashcodeMap original =
this.deploymentsMetadata.getCurrentDeploymentFileHashcodes();
- ChangesFileHashcodeMap current =
original.rescan(this.deploymentData.getDestinationDir(), this.deploymentData
- .getIgnoreRegex(), this.deploymentData.isManageRootDir());
+ ChangesFileHashcodeMap current =
original.rescan(this.deploymentData.getDestinationDir(),
+ this.deploymentData.getIgnoreRegex(),
this.deploymentData.isManageRootDir());
FileHashcodeMap newFiles = getNewDeploymentFileHashcodeMap();
if (current.getUnknownContent() != null) {
@@ -457,7 +484,8 @@ public class Deployer {
int backupDeploymentId = props.getDeploymentId();
debug("Backing up files as part of update deployment. dryRun=",
dryRun);
for (String fileToBackupPath : currentFilesToBackup) {
- backupFile(diff, backupDeploymentId, fileToBackupPath, dryRun);
+ boolean toBeDeleted = currentFilesToDelete.remove(fileToBackupPath);
+ backupFile(diff, backupDeploymentId, fileToBackupPath, dryRun,
toBeDeleted);
}
}
@@ -503,8 +531,8 @@ public class Deployer {
return newFileHashCodeMap;
}
- private void backupFile(DeployDifferences diff, int deploymentId, final String
fileToBackupPath, boolean dryRun)
- throws Exception {
+ private void backupFile(DeployDifferences diff, int deploymentId, final String
fileToBackupPath, boolean dryRun,
+ boolean removeFileToBackup) throws Exception {
File bakFile;
@@ -536,8 +564,8 @@ public class Deployer {
String destDirDriveLetter =
FileUtil.stripDriveLetter(destDirAbsPathBuilder);
if (destDirDriveLetter == null || driveLetter.equals(destDirDriveLetter))
{
bakFile = new File(backupDir, fileToBackupPath);
- fileToBackup = new File(this.deploymentData.getDestinationDir(),
fileToBackupPathNoDriveLetter
- .toString());
+ fileToBackup = new File(this.deploymentData.getDestinationDir(),
+ fileToBackupPathNoDriveLetter.toString());
} else {
throw new Exception("Cannot backup relative path [" +
fileToBackupPath
+ "] whose drive letter is different than the destination
directory ["
@@ -549,20 +577,77 @@ public class Deployer {
}
}
+ boolean deleted = false; // will be true if we were told to delete the file and
we actually did delete it
+
if (!dryRun) {
bakFile.getParentFile().mkdirs();
- FileUtil.copyFile(fileToBackup, bakFile);
+ // try to do a rename first if we are to remove the file, since this is more
likely
+ // much faster and more efficient.
+ // if it fails (perhaps because we are crossing file systems), try a true
copy
+ if (removeFileToBackup) {
+ boolean movedSuccessfully = fileToBackup.renameTo(bakFile);
+ if (movedSuccessfully) {
+ deleted = true;
+ } else {
+ FileUtil.copyFile(fileToBackup, bakFile);
+ deleted = fileToBackup.delete();
+ if (deleted == false) {
+ // TODO: what should we do? is it a major failure if we can't
remove files here?
+ debug("Failed to delete file [", fileToBackup, "]
but it is backed up");
+ if (diff != null) {
+ diff.addError(fileToBackupPath, "File [" +
fileToBackup.getAbsolutePath()
+ + "] did not delete");
+ }
+ }
+ }
+ } else {
+ FileUtil.copyFile(fileToBackup, bakFile);
+ }
+ } else {
+ deleted = removeFileToBackup; // this is a dry run, pretend we deleted it if
we were asked to
}
debug("Backed up file [", fileToBackup, "] to [", bakFile,
"]. dryRun=", dryRun);
+ if (deleted) {
+ debug("Deleted file [", fileToBackup, "] after backing it up.
dryRun=", dryRun);
+ }
if (diff != null) {
diff.addBackedUpFile(fileToBackupPath, bakFile.getAbsolutePath());
+ if (deleted) {
+ diff.addDeletedFile(fileToBackupPath);
+ }
}
return;
}
+ private void backupFiles(DeployDifferences diff, int deploymentId, File dirToBackup,
boolean dryRun,
+ String relativeTo, boolean removeSourceFiles) throws Exception {
+ File[] files = dirToBackup.listFiles();
+ if (files == null) {
+ throw new IOException("Failed to get the list of files in source
directory [" + dirToBackup + "]");
+ }
+ if (files.length > 0) {
+ this.deploymentsMetadata.getMetadataDirectory().mkdirs(); // make sure we
create this, might not be there yet
+ for (File file : files) {
+ if (file.isDirectory()) {
+ if (file.getName().equals(DeploymentsMetadata.METADATA_DIR)) {
+ continue; // skip the RHQ metadata directory, its where we are
putting our backups!
+ }
+ backupFiles(diff, deploymentId, file, dryRun,
+ ((relativeTo == null) ? "" : relativeTo) +
file.getName() + File.separatorChar,
+ removeSourceFiles);
+ } else {
+ backupFile(diff, deploymentId, ((relativeTo == null) ? "" :
relativeTo) + file.getName(), dryRun,
+ removeSourceFiles);
+ }
+ }
+
+ files = null; // help GC
+ }
+ }
+
private FileHashcodeMap extractZipAndRawFiles(Map<String, String>
currentFilesToLeaveAlone, DeployDifferences diff,
boolean dryRun) throws Exception {
@@ -615,8 +700,8 @@ public class Deployer {
ZipUtil.walkZipFile(zipFile, visitor);
// we have to compress the file again - our new compressed file will
have the new realized files in them
if (!dryRun) {
- createZipFile(compressedFile,
this.deploymentData.getDestinationDir(), visitor
- .getFileHashcodeMap());
+ createZipFile(compressedFile,
this.deploymentData.getDestinationDir(),
+ visitor.getFileHashcodeMap());
}
}
@@ -1040,16 +1125,20 @@ public class Deployer {
private void debug(Object... objs) {
if (log.isDebugEnabled()) {
- String bundleName =
this.deploymentData.getDeploymentProps().getBundleName();
- String bundleVersion =
this.deploymentData.getDeploymentProps().getBundleVersion();
- int deploymentId =
this.deploymentData.getDeploymentProps().getDeploymentId();
- StringBuilder str = new StringBuilder();
- str.append("Bundle [").append(bundleName).append("
v").append(bundleVersion).append(']');
- str.append("; Deployment [").append(deploymentId).append("]:
");
- for (Object o : objs) {
- str.append(o);
- }
- log.debug(str.toString());
+ log.debug(buildLogMessage(objs));
+ }
+ }
+
+ private String buildLogMessage(Object... objs) {
+ String bundleName = this.deploymentData.getDeploymentProps().getBundleName();
+ String bundleVersion =
this.deploymentData.getDeploymentProps().getBundleVersion();
+ int deploymentId = this.deploymentData.getDeploymentProps().getDeploymentId();
+ StringBuilder str = new StringBuilder();
+ str.append("Bundle [").append(bundleName).append("
v").append(bundleVersion).append(']');
+ str.append("; Deployment [").append(deploymentId).append("]:
");
+ for (Object o : objs) {
+ str.append(o);
}
+ return str.toString();
}
}
diff --git a/modules/core/util/src/test/java/org/rhq/core/util/file/FileUtilTest.java
b/modules/core/util/src/test/java/org/rhq/core/util/file/FileUtilTest.java
index 31659bd..bb7ad34 100644
--- a/modules/core/util/src/test/java/org/rhq/core/util/file/FileUtilTest.java
+++ b/modules/core/util/src/test/java/org/rhq/core/util/file/FileUtilTest.java
@@ -22,21 +22,92 @@
*/
package org.rhq.core.util.file;
+import static java.util.Arrays.asList;
+import static org.apache.commons.io.FileUtils.deleteDirectory;
+import static org.apache.commons.io.FileUtils.toFile;
+import static org.apache.commons.io.FileUtils.touch;
+import static org.rhq.test.AssertUtils.assertCollectionEqualsNoOrder;
+
+import java.io.ByteArrayInputStream;
import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
import org.testng.annotations.Test;
-import static java.util.Arrays.asList;
-import static org.apache.commons.io.FileUtils.deleteDirectory;
-import static org.apache.commons.io.FileUtils.toFile;
-import static org.apache.commons.io.FileUtils.touch;
-import static org.rhq.test.AssertUtils.assertCollectionEqualsNoOrder;
+import org.rhq.core.util.stream.StreamUtil;
@Test
public class FileUtilTest {
+ public void testCopyDirectory() throws Exception {
+ try {
+ FileUtil.copyDirectory(new File("this.does.not.exist"), new
File("dummy"));
+ assert false : "the source directory did not exist, this should have
failed because of that";
+ } catch (Exception ok) {
+ }
+
+ // create a source directory and a destination directory. Make sure we start off
+ // with a non-existent destination directory - we want the copyDirectory to
create it for us.
+ File outDir = FileUtil.createTempDirectory("fileUtilTestCopyDir",
".dest", null);
+ assert outDir.delete() : "failed to start out with a non-existent dest
directory";
+ assert !outDir.exists() : "dest directory should not exist"; // yes, I
am paranoid
+
+ File inDir = FileUtil.createTempDirectory("fileUtilTestCopyDir",
".src", null);
+ try {
+ // create some test files in our source directory
+ String testFilename0 = "file0.txt";
+ String testFilename1 = "subdir" + File.separatorChar +
"subfile1.txt";
+ String testFilename2 = "subdir" + File.separatorChar +
"subfile2.txt";
+
+ File testFile = new File(inDir, testFilename0);
+ StreamUtil.copy(new ByteArrayInputStream("0".getBytes()), new
FileOutputStream(testFile));
+ assert "0".equals(new String(StreamUtil.slurp(new
FileInputStream(testFile)))); // sanity check, make sure its there
+
+ testFile = new File(inDir, testFilename1);
+ testFile.getParentFile().mkdirs();
+ StreamUtil.copy(new ByteArrayInputStream("1".getBytes()), new
FileOutputStream(testFile));
+ assert "1".equals(new String(StreamUtil.slurp(new
FileInputStream(testFile)))); // sanity check, make sure its there
+ testFile = new File(inDir, testFilename2);
+ testFile.getParentFile().mkdirs();
+ StreamUtil.copy(new ByteArrayInputStream("2".getBytes()), new
FileOutputStream(testFile));
+ assert "2".equals(new String(StreamUtil.slurp(new
FileInputStream(testFile)))); // sanity check, make sure its there
+
+ // copy our source directory and confirm the copies are correct
+ FileUtil.copyDirectory(inDir, outDir);
+
+ testFile = new File(outDir, testFilename0);
+ assert testFile.exists() : "file did not get created: " +
testFile;
+ assert "0".equals(new String(StreamUtil.slurp(new
FileInputStream(testFile))));
+ testFile = new File(outDir, testFilename1);
+ assert testFile.exists() : "file did not get created: " +
testFile;
+ assert "1".equals(new String(StreamUtil.slurp(new
FileInputStream(testFile))));
+ testFile = new File(outDir, testFilename2);
+ assert testFile.exists() : "file did not get created: " +
testFile;
+ assert "2".equals(new String(StreamUtil.slurp(new
FileInputStream(testFile))));
+
+ // let's test getDirectoryFiles while we are here
+ List<File> outFiles = FileUtil.getDirectoryFiles(outDir);
+ assert outFiles != null : outFiles;
+ assert outFiles.size() == 3 : outFiles;
+ assert outFiles.contains(new File(testFilename0)) : outFiles;
+ assert outFiles.contains(new File(testFilename1)) : outFiles;
+ assert outFiles.contains(new File(testFilename2)) : outFiles;
+ } finally {
+ // clean up our test
+ try {
+ FileUtil.purge(inDir, true);
+ } catch (Exception ignore) {
+ }
+ try {
+ FileUtil.purge(outDir, true);
+ } catch (Exception ignore) {
+ }
+ }
+ }
+
public void testStripDriveLetter() {
StringBuilder str;
@@ -142,8 +213,7 @@ public class FileUtilTest {
}
});
- assertCollectionEqualsNoOrder(expectedFiles, actualFiles,
- "Expected to visit all files in directory");
+ assertCollectionEqualsNoOrder(expectedFiles, actualFiles, "Expected to visit
all files in directory");
}
@Test
@@ -176,8 +246,7 @@ public class FileUtilTest {
}
});
- assertCollectionEqualsNoOrder(expectedFiles, actualFiles,
- "Expected to visit files in sub directories");
+ assertCollectionEqualsNoOrder(expectedFiles, actualFiles, "Expected to visit
files in sub directories");
}
@Test
@@ -210,8 +279,7 @@ public class FileUtilTest {
}
});
- assertCollectionEqualsNoOrder(expectedFiles, actualFiles,
- "Expected to visit files in nested sub directories");
+ assertCollectionEqualsNoOrder(expectedFiles, actualFiles, "Expected to visit
files in nested sub directories");
}
public void testGetPattern() {
@@ -222,8 +290,8 @@ public class FileUtilTest {
assert regex.matcher("/basedir/test1.txt").matches();
assert !regex.matcher("/basedir/test2.txt").matches();
- regex =
assertPatternsRegex("(/basedir/easy\\.txt)|(/basedir/test\\.txt)",
- new PathFilter("/basedir/easy.txt", null), new
PathFilter("/basedir/test.txt", null));
+ regex =
assertPatternsRegex("(/basedir/easy\\.txt)|(/basedir/test\\.txt)", new
PathFilter("/basedir/easy.txt",
+ null), new PathFilter("/basedir/test.txt", null));
assert regex.matcher("/basedir/easy.txt").matches();
assert regex.matcher("/basedir/test.txt").matches();
@@ -244,8 +312,8 @@ public class FileUtilTest {
assert !regex.matcher("/basedir/subdir/foo.txt").matches();
assert !regex.matcher("/basedir/foo.txt.swp").matches();
- regex =
assertPatternsRegex("(/var/lib/([^/]*\\.war))|(/var/lib/([^/]*\\.ear))",
- new PathFilter("/var/lib", "*.war"), new
PathFilter("/var/lib", "*.ear"));
+ regex =
assertPatternsRegex("(/var/lib/([^/]*\\.war))|(/var/lib/([^/]*\\.ear))", new
PathFilter("/var/lib",
+ "*.war"), new PathFilter("/var/lib",
"*.ear"));
assert regex.matcher("/var/lib/myapp.war").matches();
assert regex.matcher("/var/lib/myapp.ear").matches();
diff --git a/modules/core/util/src/test/java/org/rhq/core/util/updater/DeployerTest.java
b/modules/core/util/src/test/java/org/rhq/core/util/updater/DeployerTest.java
index 69d6d53..a69931a 100644
--- a/modules/core/util/src/test/java/org/rhq/core/util/updater/DeployerTest.java
+++ b/modules/core/util/src/test/java/org/rhq/core/util/updater/DeployerTest.java
@@ -230,12 +230,13 @@ public class DeployerTest {
final String file999 = "dir1" + fileSeparator + "file999";
try {
- if (ignore) {
- // create a file that will be retained because we will be ignoring it
- File ignoreDir = FileUtil.createTempDirectory("ignoreme",
".dir", tmpDir);
- fileToIgnore = new File(ignoreDir, "some-log.log");
- StreamUtil.copy(new ByteArrayInputStream("boo".getBytes()), new
FileOutputStream(fileToIgnore));
- }
+ // this is a file that will be removed because our initial deployment is
managing the root deploy dir
+ // later we will recreate it to see that we ignore it during the upgrade.
+ // note that during the initial deployment, we will still back it up.
+ File ignoreDir = FileUtil.createTempDirectory("ignoreme",
".dir", tmpDir);
+ fileToIgnore = new File(ignoreDir, "some-log.log");
+ StreamUtil.copy(new ByteArrayInputStream("boo".getBytes()), new
FileOutputStream(fileToIgnore));
+ String fileToIgnorePath = ignoreDir.getName() + "/" +
fileToIgnore.getName(); // yes, use /, even if we are on windows
File testZipFile1 = new
File("target/test-classes/updater-test1.zip");
File testZipFile2 = new
File("target/test-classes/updater-test2.zip");
@@ -267,15 +268,25 @@ public class DeployerTest {
deployer.deploy(diff);
- if (ignore) {
- assert "boo".equals(new String(StreamUtil.slurp(new
FileInputStream(fileToIgnore))));
- assert diff.getIgnoredFiles().size() == 0 : "this was an initial
deploy - nothing to ignore (ignore is only for updates)";
- }
+ // our initial deploy should have deleted this because we are managing the
root dir
+ assert !fileToIgnore.exists() : "should have removed this file since we
are managing the root dir";
+ assert !fileToIgnore.getParentFile().exists() : "should have removed
this file since we are managing the root dir";
+ assert diff.getIgnoredFiles().size() == 0 : "this was an initial deploy
- nothing to ignore (ignore is only for updates)";
assert diff.getAddedFiles().size() == 6 : diff;
- assert diff.getDeletedFiles().size() == 0 : diff;
+ assert diff.getDeletedFiles().size() == 1 : diff;
+ assert diff.getDeletedFiles().contains(fileToIgnorePath) : "should have
deleted this unknown file" + diff;
assert diff.getChangedFiles().size() == 0 : diff;
assert diff.getRealizedFiles().size() == 0 : "No fileA to realize in
this deployment: " + diff;
- assert diff.getBackedUpFiles().size() == 0 : "No fileA to realize in
this deployment: " + diff;
+ assert diff.getBackedUpFiles().size() == 1 : diff;
+ assert diff.getBackedUpFiles().get(fileToIgnorePath) != null : "should
have backed up this file" + diff;
+
+ if (ignore) {
+ // let's create this again to make sure we really do ignore it
+ ignoreDir = FileUtil.createTempDirectory("ignoreme",
".dir", tmpDir);
+ fileToIgnore = new File(ignoreDir, "some-log.log");
+ StreamUtil.copy(new ByteArrayInputStream("boo".getBytes()), new
FileOutputStream(fileToIgnore));
+ fileToIgnorePath = ignoreDir.getName() + "/" +
fileToIgnore.getName(); // yes, use /, even if we are on windows
+ }
StreamUtil.copy(new ByteArrayInputStream("X".getBytes()), new
FileOutputStream(new File(tmpDir, file1)));
StreamUtil.copy(new ByteArrayInputStream("X".getBytes()), new
FileOutputStream(updaterAabsolute));
@@ -295,7 +306,7 @@ public class DeployerTest {
templateEngine, ignoreRegex, true, null);
deployer = new Deployer(dd);
diff = new DeployDifferences();
- deployer.deploy(diff);
+ deployer.deploy(diff); // this is an upgrade
if (ignore) {
assert "boo".equals(new String(StreamUtil.slurp(new
FileInputStream(fileToIgnore))));
@@ -396,11 +407,11 @@ public class DeployerTest {
assert diff.getChangedFiles().contains(fileB) : diff;
assert diff.getBackedUpFiles().size() == 4 : diff;
assert
diff.getBackedUpFiles().containsKey(diff.convertPath(updaterAabsolute.getAbsolutePath()))
: diff;
- assert
diff.getBackedUpFiles().get(diff.convertPath(updaterAabsolute.getAbsolutePath())).equals(
- diff.convertPath(updaterAabsoluteBackupTo2)) : diff;
+ assert
diff.getBackedUpFiles().get(diff.convertPath(updaterAabsolute.getAbsolutePath()))
+ .equals(diff.convertPath(updaterAabsoluteBackupTo2)) : diff;
assert
diff.getBackedUpFiles().containsKey(diff.convertPath(updaterBabsolute.getAbsolutePath()))
: diff;
- assert
diff.getBackedUpFiles().get(diff.convertPath(updaterBabsolute.getAbsolutePath())).equals(
- diff.convertPath(updaterBabsoluteBackupTo2)) : diff;
+ assert
diff.getBackedUpFiles().get(diff.convertPath(updaterBabsolute.getAbsolutePath()))
+ .equals(diff.convertPath(updaterBabsoluteBackupTo2)) : diff;
assert diff.getBackedUpFiles().containsKey(fileB) : diff;
assert
diff.getBackedUpFiles().get(fileB).equals(diff.convertPath(fileBbackupTo2.getAbsolutePath()))
: diff;
assert diff.getBackedUpFiles().containsKey(file999) : diff;
@@ -442,8 +453,8 @@ public class DeployerTest {
assert
diff.getChangedFiles().contains(diff.convertPath(updaterBabsolute.getAbsolutePath())) :
diff;
assert diff.getBackedUpFiles().size() == 1 : diff;
assert
diff.getBackedUpFiles().containsKey(diff.convertPath(updaterBabsolute.getAbsolutePath()))
: diff;
- assert
diff.getBackedUpFiles().get(diff.convertPath(updaterBabsolute.getAbsolutePath())).equals(
- diff.convertPath(updaterBabsoluteBackupTo3)) : diff;
+ assert
diff.getBackedUpFiles().get(diff.convertPath(updaterBabsolute.getAbsolutePath()))
+ .equals(diff.convertPath(updaterBabsoluteBackupTo3)) : diff;
if (realize) {
assert diff.getRealizedFiles().size() == 1 : diff;
assert diff.getRealizedFiles().containsKey(fileA) : diff;
diff --git
a/modules/core/util/src/test/java/org/rhq/core/util/updater/SimpleDeployerTest.java
b/modules/core/util/src/test/java/org/rhq/core/util/updater/SimpleDeployerTest.java
index f875576..2736f16 100644
--- a/modules/core/util/src/test/java/org/rhq/core/util/updater/SimpleDeployerTest.java
+++ b/modules/core/util/src/test/java/org/rhq/core/util/updater/SimpleDeployerTest.java
@@ -205,7 +205,15 @@ public class SimpleDeployerTest {
baseNoNewWithCurrentDifferentThanOriginal(true);
}
- public void testWithSubdirectories() throws Exception {
+ public void testWithSubdirectoriesManageRootDir() throws Exception {
+ testWithSubdirectories(true);
+ }
+
+ public void testWithSubdirectoriesNoManageRootDir() throws Exception {
+ testWithSubdirectories(false);
+ }
+
+ private void testWithSubdirectories(boolean manageRootDir) throws Exception {
// this test is different than all the rest, start with clean tmp/dest dirs with
no beforeMethod buildup
FileUtil.purge(this.tmpDir, false);
FileUtil.purge(this.deployDir, false);
@@ -227,14 +235,40 @@ public class SimpleDeployerTest {
this.originalZipFiles.add(originalZipFile);
this.originalDeployProps = new DeploymentProperties(1, "simple",
"1.0", "original test deployment");
DeploymentData dd = new DeploymentData(originalDeployProps, originalZipFiles,
null, tmpDir, deployDir, null,
- null, null, null, true, null);
+ null, null, null, manageRootDir, null);
+ this.diff = new DeployDifferences();
Deployer deployer = new Deployer(dd);
- this.originalFileHashcodeMap = deployer.deploy(null);
+ this.originalFileHashcodeMap = deployer.deploy(this.diff);
assert new File(this.deployDir, origFileName1).exists();
assert new File(this.deployDir, origFileName2).exists();
- assert unrelated1.exists() : "the deployment removed unrelated file1";
- assert unrelated2.getParentFile().isDirectory() : "the deployment removed an
unrelated dir";
- assert unrelated2.exists() : "the deployment removed unrelated file2";
+ if (manageRootDir) {
+ assert !unrelated1.exists() : "the deployment should have removed
unrelated file1";
+ assert !unrelated2.getParentFile().isDirectory() : "the deployment
should have removed an unrelated dir";
+ assert !unrelated2.exists() : "the deployment should have removed
unrelated file2";
+
+ assert this.diff.getBackedUpFiles().size() == 2 : this.diff;
+ assert new
File(this.diff.getBackedUpFiles().get(unrelatedFileName1)).exists() : this.diff;
+ assert new
File(this.diff.getBackedUpFiles().get(unrelatedFileName2)).exists() : this.diff;
+ assert this.diff.getDeletedFiles().size() == 2 : this.diff;
+ assert this.diff.getDeletedFiles().contains(unrelatedFileName1) : this.diff;
+ assert this.diff.getDeletedFiles().contains(unrelatedFileName2) : this.diff;
+ } else {
+ assert this.diff.getBackedUpFiles().size() == 0 : this.diff;
+ assert this.diff.getDeletedFiles().size() == 0 : this.diff;
+ assert unrelated1.exists() : "the deployment removed unrelated
file1";
+ assert unrelated2.getParentFile().isDirectory() : "the deployment
removed an unrelated dir";
+ assert unrelated2.exists() : "the deployment removed unrelated
file2";
+ }
+
+ assert this.diff.getAddedFiles().size() == 2 : this.diff;
+ assert this.diff.getAddedFiles().contains(origFileName1) : this.diff;
+ assert this.diff.getAddedFiles().contains(origFileName2) : this.diff;
+ assert this.diff.getChangedFiles().isEmpty() : this.diff;
+ assert this.diff.getIgnoredFiles().isEmpty() : this.diff;
+ assert this.diff.getRealizedFiles().isEmpty() : this.diff;
+ assert this.diff.getRestoredFiles().isEmpty() : this.diff;
+ assert !this.diff.wasCleaned() : this.diff;
+ assert this.diff.getErrors().isEmpty() : this.diff;
// deploy new content
this.newDeployProps = new DeploymentProperties(2, "simple",
"2.0", "new test deployment");
@@ -246,19 +280,36 @@ public class SimpleDeployerTest {
new String[] { newFileName1, newFileName2 });
HashSet<File> newZipFiles = new HashSet<File>(1);
newZipFiles.add(newZipFile);
- dd = new DeploymentData(newDeployProps, newZipFiles, null, tmpDir, deployDir,
null, null, null, null, true,
- null);
+ dd = new DeploymentData(newDeployProps, newZipFiles, null, tmpDir, deployDir,
null, null, null, null,
+ manageRootDir, null);
deployer = new Deployer(dd);
FileHashcodeMap newFileHashcodeMap = deployer.deploy(this.diff);
+ assert newFileHashcodeMap != null;
assert new File(this.deployDir, newFileName1).exists();
assert new File(this.deployDir, newFileName2).exists();
assert !new File(this.deployDir, origFileName1).exists();
assert !new File(this.deployDir, origFileName2).exists();
- assert !unrelated1.exists() : "the deployment did not remove unrelated
file1";
- assert !unrelated2.exists() : "the deployment did not remove unrelated
file1";
- assert this.diff.getBackedUpFiles().size() == 2 : this.diff;
- assert new File(this.diff.getBackedUpFiles().get(unrelatedFileName1)).exists() :
this.diff;
- assert new File(this.diff.getBackedUpFiles().get(unrelatedFileName2)).exists() :
this.diff;
+ if (manageRootDir) {
+ assert !unrelated1.exists() : "the deployment did not remove unrelated
file1";
+ assert !unrelated2.exists() : "the deployment did not remove unrelated
file1";
+ } else {
+ assert unrelated1.exists() : "the deployment removed unrelated file1 but
we aren't managing the root dir";
+ assert unrelated2.exists() : "the deployment removed unrelated file1 but
we aren't managing the root dir";
+ }
+
+ assert this.diff.getAddedFiles().size() == 2 : this.diff;
+ assert this.diff.getAddedFiles().contains(newFileName1) : this.diff;
+ assert this.diff.getAddedFiles().contains(newFileName2) : this.diff;
+ assert this.diff.getDeletedFiles().size() == 2 : this.diff;
+ assert this.diff.getDeletedFiles().contains(origFileName1) : this.diff;
+ assert this.diff.getDeletedFiles().contains(origFileName2) : this.diff;
+ assert this.diff.getChangedFiles().isEmpty() : this.diff;
+ assert this.diff.getBackedUpFiles().isEmpty() : this.diff;
+ assert this.diff.getIgnoredFiles().isEmpty() : this.diff;
+ assert this.diff.getRealizedFiles().isEmpty() : this.diff;
+ assert this.diff.getRestoredFiles().isEmpty() : this.diff;
+ assert !this.diff.wasCleaned() : this.diff;
+ assert this.diff.getErrors().isEmpty() : this.diff;
}
private void baseX_X_X(boolean dryRun) throws Exception {
diff --git
a/modules/plugins/ant-bundle/src/test/java/org/rhq/plugins/ant/AntBundlePluginComponentTest.java
b/modules/plugins/ant-bundle/src/test/java/org/rhq/plugins/ant/AntBundlePluginComponentTest.java
index a772ef0..d712401 100644
---
a/modules/plugins/ant-bundle/src/test/java/org/rhq/plugins/ant/AntBundlePluginComponentTest.java
+++
b/modules/plugins/ant-bundle/src/test/java/org/rhq/plugins/ant/AntBundlePluginComponentTest.java
@@ -231,11 +231,17 @@ public class AntBundlePluginComponentTest {
upgrade(true);
}
+ @Test(enabled = true)
+ public void testAntBundleInitialInstall() throws Exception {
+ doAntBundleInitialInstall(true);
+ }
+
/**
* Test deployment of an RHQ bundle recipe with archive file and raw file
+ * @param startClean if true, the destination directory will be non-existent and thus
clean
+ * if false, this will put some junk files in the dest directory
*/
- @Test(enabled = true)
- public void testAntBundleInitialInstall() throws Exception {
+ private void doAntBundleInitialInstall(boolean startClean) throws Exception {
ResourceType resourceType = new ResourceType("testSimpleBundle2Type",
"plugin", ResourceCategory.SERVER, null);
BundleType bundleType = new BundleType("testSimpleBundle2BType",
resourceType);
Repo repo = new Repo("test-bundle-two");
@@ -273,6 +279,25 @@ public class AntBundlePluginComponentTest {
props.store(outputStream, "test.properties comment");
outputStream.close();
+ // if we are not to start clean, create some junk files that will need to be
backed up and moved away
+ if (startClean == false) {
+ this.destDir.mkdirs();
+ File junk1 = new File(this.destDir, "junk1.properties");
+ Properties junkProps = new Properties();
+ junkProps.setProperty("junk1", "wot gorilla?");
+ FileOutputStream os = new FileOutputStream(junk1);
+ junkProps.store(os, "junk1.properties comment");
+ os.close();
+
+ File junk2 = new File(this.destDir, "junksubdir" +
File.separatorChar + "junk2.properties");
+ junk2.getParentFile().mkdirs();
+ junkProps = new Properties();
+ junkProps.setProperty("junk2", "more junk");
+ os = new FileOutputStream(junk2);
+ junkProps.store(os, "junk2.properties comment");
+ os.close();
+ }
+
BundleDeployRequest request = new BundleDeployRequest();
request.setBundleFilesLocation(this.bundleFilesDir);
request.setResourceDeployment(new BundleResourceDeployment(deployment, null));
@@ -501,8 +526,129 @@ public class AntBundlePluginComponentTest {
assert "2".equals(props.getProperty("external2")) :
"bundle purge removed our unmanaged file 2";
}
+ /**
+ * Test deployment of an RHQ bundle recipe where the deploy directory is to be fully
managed.
+ * This is the typical use-case and the default behavior.
+ */
+ @Test(enabled = true)
+ public void testAntBundleManageRootDir() throws Exception {
+ ResourceType resourceType = new ResourceType("testManageRootDirBundle",
"plugin", ResourceCategory.SERVER, null);
+ BundleType bundleType = new BundleType("testManageRootDirBundle",
resourceType);
+ Repo repo = new Repo("testManageRootDirBundle");
+ PackageType packageType = new PackageType("testManageRootDirBundle",
resourceType);
+ Bundle bundle = new Bundle("testManageRootDirBundle", bundleType, repo,
packageType);
+ BundleVersion bundleVersion = new
BundleVersion("testManageRootDirBundle", "1.0", bundle,
+ getRecipeFromFile("test-bundle-manage-root-dir.xml"));
+ BundleDestination destination = new BundleDestination(bundle,
"testManageRootDirBundle", new ResourceGroup(
+ "testManageRootDirBundle"), DEST_BASE_DIR_NAME,
this.destDir.getAbsolutePath());
+ Configuration config = new Configuration();
+
+ BundleDeployment deployment = new BundleDeployment();
+ deployment.setName("test bundle deployment name");
+ deployment.setBundleVersion(bundleVersion);
+ deployment.setConfiguration(config);
+ deployment.setDestination(destination);
+
+ // create bundle test files
+ File file0 = new File(this.bundleFilesDir, "zero.properties");
+ Properties props = new Properties();
+ props.setProperty("zero", "0");
+ FileOutputStream outputStream = new FileOutputStream(file0);
+ props.store(outputStream, "zero file");
+ outputStream.close();
+
+ File file1 = new File(this.bundleFilesDir, "one.properties");
+ props.clear();
+ props.setProperty("one", "1");
+ outputStream = new FileOutputStream(file1);
+ props.store(outputStream, "one file");
+ outputStream.close();
+
+ File file2 = new File(this.bundleFilesDir, "two.properties");
+ props.clear();
+ props.setProperty("two", "2");
+ outputStream = new FileOutputStream(file2);
+ props.store(outputStream, "two file");
+ outputStream.close();
+
+ // create some external test files that don't belong to the bundle but are in
the dest dir (which is to be managed by the bundle)
+ this.destDir.mkdirs();
+ File external1 = new File(this.destDir, "external1.properties");
+ props.clear();
+ props.setProperty("external1", "1");
+ outputStream = new FileOutputStream(external1);
+ props.store(outputStream, "external1 file");
+ outputStream.close();
+
+ File external2 = new File(this.destDir,
"extdir/external2.properties");
+ external2.getParentFile().mkdirs();
+ props.clear();
+ props.setProperty("external2", "2");
+ outputStream = new FileOutputStream(external2);
+ props.store(outputStream, "external2 file");
+ outputStream.close();
+
+ // deploy the bundle
+ BundleDeployRequest request = new BundleDeployRequest();
+ request.setBundleFilesLocation(this.bundleFilesDir);
+ request.setResourceDeployment(new BundleResourceDeployment(deployment, null));
+ request.setBundleManagerProvider(new MockBundleManagerProvider());
+ request.setAbsoluteDestinationDirectory(this.destDir);
+
+ BundleDeployResult results = plugin.deployBundle(request);
+
+ assertResultsSuccess(results);
+
+ // test that files were deployed in the proper place
+ props.clear();
+ loadProperties(props, new FileInputStream(new File(this.destDir,
"zero.properties")));
+ assert "0".equals(props.getProperty("zero")) : "did not
deploy bundle correctly 0";
+ loadProperties(props, new FileInputStream(new File(this.destDir,
"subdir1/one.properties")));
+ assert "1".equals(props.getProperty("one")) : "did not
deploy bundle correctly 1";
+ loadProperties(props, new FileInputStream(new File(this.destDir,
"subdir2/two.properties")));
+ assert "2".equals(props.getProperty("two")) : "did not
deploy bundle correctly 2";
+
+ DeploymentsMetadata metadata = new DeploymentsMetadata(this.destDir);
+ assert metadata.isManaged() == true : "missing metadata directory";
+ assert metadata.getCurrentDeploymentProperties().getManageRootDir() == true :
"should be managing root dir";
+
+ // make sure our external files/directories were removed because
+ // they aren't part of the bundle and we are fully managing the dest dir
+ props.clear();
+ try {
+ loadProperties(props, new FileInputStream(new File(this.destDir,
"external1.properties")));
+ assert false : "bundle deployment did not remove our managed file
1";
+ } catch (Exception ok) {
+ }
+ try {
+ loadProperties(props, new FileInputStream(new File(this.destDir,
"extdir/external2.properties")));
+ assert false : "bundle deployment did not remove our managed file
2";
+ } catch (Exception ok) {
+ }
+
+ // now purge the bundle - this should purge everything in the deploy dir because
we are fully managing it
+ BundlePurgeRequest purgeRequest = new BundlePurgeRequest();
+ purgeRequest.setLiveResourceDeployment(new BundleResourceDeployment(deployment,
null));
+ purgeRequest.setBundleManagerProvider(new MockBundleManagerProvider());
+ purgeRequest.setAbsoluteDestinationDirectory(this.destDir);
+
+ BundlePurgeResult purgeResults = plugin.purgeBundle(purgeRequest);
+ assertResultsSuccess(purgeResults);
+
+ // make sure our bundle files have been completely purged; the metadata directory
should have been purged too
+ assert new File(this.destDir, "zero.properties").exists() == false;
+ assert new File(this.destDir, "subdir1/one.properties").exists() ==
false;
+ assert new File(this.destDir, "subdir2/two.properties").exists() ==
false;
+ assert new File(this.destDir, "subdir1").exists() == false;
+ assert new File(this.destDir, "subdir2").exists() == false;
+ assert this.destDir.exists() == false : "deploy dir should not exist, we
were told to fully manage it";
+
+ metadata = new DeploymentsMetadata(this.destDir);
+ assert metadata.getMetadataDirectory().exists() == false : "metadata
directory should not exist";
+ }
+
private void upgrade(boolean clean) throws Exception {
- testAntBundleInitialInstall(); // install a bundle first
+ doAntBundleInitialInstall(clean); // install a bundle first
cleanPluginDirs(); // clean everything but the dest dir - we want to upgrade the
destination
prepareBeforeTestMethod(); // prepare for our new test
diff --git a/modules/plugins/ant-bundle/src/test/resources/test-bundle-manage-root-dir.xml
b/modules/plugins/ant-bundle/src/test/resources/test-bundle-manage-root-dir.xml
new file mode 100644
index 0000000..9b77dd8
--- /dev/null
+++ b/modules/plugins/ant-bundle/src/test/resources/test-bundle-manage-root-dir.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+
+<project name="simple-build" default="main"
+ xmlns:rhq="antlib:org.rhq.bundle">
+
+ <rhq:bundle name="testManageRootDirBundle" version="1.0">
+ <rhq:deployment-unit name="simulated-war"
manageRootDir="true">
+ <rhq:file name="zero.properties"
destinationFile="zero.properties"/>
+ <rhq:file name="one.properties"
destinationFile="subdir1/one.properties"/>
+ <rhq:file name="two.properties"
destinationFile="subdir2/two.properties"/>
+ </rhq:deployment-unit>
+ </rhq:bundle>
+
+ <target name="main"/>
+
+</project>
\ No newline at end of file