public static void testBumpSubBuilders() throws Exception {
File tmp = new File("tmp-ws");
if (tmp.exists()) IO.deleteWithException(tmp);
tmp.mkdir();
assertTrue(tmp.isDirectory());
try {
IO.copy(new File("test/ws"), tmp);
Workspace ws = Workspace.getWorkspace(tmp);
Project project = ws.getProject("bump-sub");
project.setTrace(true);
assertNull(project.getProperty("Bundle-Version"));
project.bump("=+0");
assertNull(project.getProperty("Bundle-Version"));
for (Builder b : project.getSubBuilders()) {
assertEquals(new Version(1, 1, 0), new Version(b.getVersion()));
}
} finally {
IO.deleteWithException(tmp);
}
}
public static void testBump() throws Exception {
File tmp = new File("tmp-ws");
if (tmp.exists()) IO.deleteWithException(tmp);
tmp.mkdir();
assertTrue(tmp.isDirectory());
try {
IO.copy(new File("test/ws"), tmp);
Workspace ws = Workspace.getWorkspace(tmp);
Project project = ws.getProject("p1");
int size = project.getProperties().size();
Version old = new Version(project.getProperty("Bundle-Version"));
System.err.println("Old version " + old);
project.bump("=+0");
Version newv = new Version(project.getProperty("Bundle-Version"));
System.err.println("New version " + newv);
assertEquals(old.getMajor(), newv.getMajor());
assertEquals(old.getMinor() + 1, newv.getMinor());
assertEquals(0, newv.getMicro());
assertEquals(size, project.getProperties().size());
assertEquals("sometime", newv.getQualifier());
} finally {
IO.deleteWithException(tmp);
}
}
public static void testBumpIncludeFile() throws Exception {
File tmp = new File("tmp-ws");
if (tmp.exists()) IO.deleteWithException(tmp);
tmp.mkdir();
assertTrue(tmp.isDirectory());
try {
IO.copy(new File("test/ws"), tmp);
Workspace ws = Workspace.getWorkspace(tmp);
Project project = ws.getProject("bump-included");
project.setTrace(true);
Version old = new Version(project.getProperty("Bundle-Version"));
assertEquals(new Version(1, 0, 0), old);
project.bump("=+0");
Processor processor = new Processor();
processor.setProperties(project.getFile("include.txt"));
Version newv = new Version(processor.getProperty("Bundle-Version"));
System.err.println("New version " + newv);
assertEquals(1, newv.getMajor());
assertEquals(1, newv.getMinor());
assertEquals(0, newv.getMicro());
} finally {
IO.deleteWithException(tmp);
}
}
private static void checkPackageInfoFiles(
Project project, String packageName, boolean expectPackageInfo, boolean expectPackageInfoJava)
throws Exception {
File pkgInfo = IO.getFile(project.getSrc(), packageName + "/packageinfo");
File pkgInfoJava = IO.getFile(project.getSrc(), packageName + "/package-info.java");
assertEquals(expectPackageInfo, pkgInfo.exists());
assertEquals(expectPackageInfoJava, pkgInfoJava.exists());
}
/**
* System command. Execute a command and insert the result.
*
* @param args
* @param help
* @param patterns
* @param low
* @param high
*/
public String system_internal(boolean allowFail, String args[]) throws Exception {
verifyCommand(
args,
"${"
+ (allowFail ? "system-allow-fail" : "system")
+ ";<command>[;<in>]}, execute a system command",
null,
2,
3);
String command = args[1];
String input = null;
if (args.length > 2) {
input = args[2];
}
Process process = Runtime.getRuntime().exec(command, null, domain.getBase());
if (input != null) {
process.getOutputStream().write(input.getBytes("UTF-8"));
}
process.getOutputStream().close();
String s = IO.collect(process.getInputStream(), "UTF-8");
int exitValue = process.waitFor();
if (exitValue != 0) return exitValue + "";
if (!allowFail && (exitValue != 0)) {
domain.error("System command " + command + " failed with " + exitValue);
}
return s.trim();
}
/**
* Get the contents of a file.
*
* @param in
* @return
* @throws IOException
*/
public String _cat(String args[]) throws IOException {
verifyCommand(args, "${cat;<in>}, get the content of a file", null, 2, 2);
File f = domain.getFile(args[1]);
if (f.isFile()) {
return IO.collect(f);
} else if (f.isDirectory()) {
return Arrays.toString(f.list());
} else {
try {
URL url = new URL(args[1]);
return IO.collect(url, "UTF-8");
} catch (MalformedURLException mfue) {
// Ignore here
}
return null;
}
}
public void deleteCommand(String name) throws Exception {
CommandData cmd = getCommand(name);
if (cmd == null) throw new IllegalArgumentException("No such command " + name);
platform.deleteCommand(cmd);
File tobedel = new File(commandDir, name);
IO.deleteWithException(tobedel);
}
public void init() throws IOException {
URL s = getClass().getClassLoader().getResource(SERVICE_JAR_FILE);
if (s == null)
if (underTest) return;
else throw new Error("No " + SERVICE_JAR_FILE + " resource in jar");
service.getParentFile().mkdirs();
IO.copy(s, service);
}
public ArtifactData get(byte[] sha) throws Exception {
String name = Hex.toHexString(sha);
File data = IO.getFile(repoDir, name + ".json");
reporter.trace("artifact data file %s", data);
if (data.isFile()) { // Bin + metadata
ArtifactData artifact = codec.dec().from(data).get(ArtifactData.class);
artifact.file = IO.getFile(repoDir, name).getAbsolutePath();
return artifact;
}
File bin = IO.getFile(repoDir, name);
if (bin.exists()) { // Only bin
ArtifactData artifact = new ArtifactData();
artifact.file = bin.getAbsolutePath();
artifact.sha = sha;
return artifact;
}
return null;
}
public void update(UpdateMemo memo) throws Exception {
ArtifactData target = put(memo.best.urls.iterator().next());
memo.current.version = new Version(memo.best.version);
target.sync();
memo.current.sha = target.sha;
// memo.current.dependencies = target.dependencies;
// memo.current.dependencies.add((new File(repoDir,
// Hex.toHexString(target.sha))).getCanonicalPath());
// memo.current.runbundles = target.runbundles;
// memo.current.description = target.description;
memo.current.time = target.time;
if (memo.current instanceof ServiceData) {
Service service = getService((ServiceData) memo.current);
service.remove();
createService((ServiceData) memo.current);
IO.delete(new File(IO.getFile(serviceDir, memo.current.name), "data"));
storeData(new File(IO.getFile(serviceDir, memo.current.name), "data"), memo.current);
} else {
platform.deleteCommand(memo.current);
createCommand(memo.current, false);
IO.delete(IO.getFile(commandDir, memo.current.name));
storeData(IO.getFile(commandDir, memo.current.name), memo.current);
}
}
private String listSupportFiles(List<File> toDelete) throws Exception {
Formatter f = new Formatter();
try {
if (toDelete == null) {
toDelete = new ArrayList<File>();
}
int precount = toDelete.size();
File confFile = IO.getFile(platform.getConfigFile()).getCanonicalFile();
if (confFile.exists()) {
f.format(" * %s \t0 Config file%n", confFile);
toDelete.add(confFile);
}
String result = (toDelete.size() > precount) ? f.toString() : null;
return result;
} finally {
f.close();
}
}
/**
* Constructor
*
* @throws IOException
*/
public JustAnotherPackageManager(Reporter reporter, Platform platform, File homeDir, File binDir)
throws IOException {
this.platform = platform;
this.reporter = reporter;
this.homeDir = homeDir;
if (!homeDir.exists() && !homeDir.mkdirs())
throw new IllegalArgumentException("Could not create directory " + homeDir);
repoDir = IO.getFile(homeDir, "repo");
if (!repoDir.exists() && !repoDir.mkdirs())
throw new IllegalArgumentException("Could not create directory " + repoDir);
commandDir = new File(homeDir, COMMANDS);
serviceDir = new File(homeDir, SERVICE);
commandDir.mkdir();
serviceDir.mkdir();
service = new File(repoDir, SERVICE_JAR_FILE);
if (!service.isFile()) init();
this.binDir = binDir;
if (!binDir.exists() && !binDir.mkdirs())
throw new IllegalArgumentException("Could not create bin directory " + binDir);
}
public static void testSetPackageVersion() throws Exception {
File tmp = new File("tmp-ws");
if (tmp.exists()) IO.deleteWithException(tmp);
tmp.mkdir();
assertTrue(tmp.isDirectory());
try {
IO.copy(new File("test/ws"), tmp);
Workspace ws = Workspace.getWorkspace(tmp);
Project project = ws.getProject("p5");
project.setTrace(true);
Version newVersion = new Version(2, 0, 0);
// Package with no package info
project.setPackageInfo("pkg1", newVersion);
Version version = project.getPackageInfo("pkg1");
assertEquals(newVersion, version);
checkPackageInfoFiles(project, "pkg1", true, false);
// Package with package-info.java containing @Version("1.0.0")
project.setPackageInfo("pkg2", newVersion);
version = project.getPackageInfo("pkg2");
assertEquals(newVersion, version);
checkPackageInfoFiles(project, "pkg2", false, true);
// Package with package-info.java containing @aQute.bnd.annotations.Version("1.0.0")
project.setPackageInfo("pkg3", newVersion);
version = project.getPackageInfo("pkg3");
assertEquals(newVersion, version);
checkPackageInfoFiles(project, "pkg3", false, true);
// Package with package-info.java containing @aQute.bnd.annotations.Version(value="1.0.0")
project.setPackageInfo("pkg4", newVersion);
version = project.getPackageInfo("pkg4");
assertEquals(newVersion, version);
checkPackageInfoFiles(project, "pkg4", false, true);
// Package with package-info.java containing version + packageinfo
project.setPackageInfo("pkg5", newVersion);
version = project.getPackageInfo("pkg5");
assertEquals(newVersion, version);
checkPackageInfoFiles(project, "pkg5", true, true);
// Package with package-info.java NOT containing version + packageinfo
project.setPackageInfo("pkg6", newVersion);
version = project.getPackageInfo("pkg6");
assertEquals(newVersion, version);
checkPackageInfoFiles(project, "pkg6", true, true);
// Package with package-info.java NOT containing version
project.setPackageInfo("pkg7", newVersion);
version = project.getPackageInfo("pkg7");
assertEquals(newVersion, version);
checkPackageInfoFiles(project, "pkg7", true, true);
newVersion = new Version(2, 2, 0);
// Update packageinfo file
project.setPackageInfo("pkg1", newVersion);
version = project.getPackageInfo("pkg1");
assertEquals(newVersion, version);
checkPackageInfoFiles(project, "pkg1", true, false);
} finally {
IO.deleteWithException(tmp);
}
}
public void deinit(Appendable out, boolean force) throws Exception {
Settings settings = new Settings(platform.getConfigFile());
if (!force) {
Justif justify = new Justif(80, 40);
StringBuilder sb = new StringBuilder();
Formatter f = new Formatter(sb);
try {
String list = listFiles(platform.getGlobal());
if (list != null) {
f.format("In global default environment:%n");
f.format(list);
}
list = listFiles(platform.getLocal());
if (list != null) {
f.format("In local default environment:%n");
f.format(list);
}
if (settings.containsKey(JPM_CACHE_GLOBAL)) {
list = listFiles(IO.getFile(settings.get(JPM_CACHE_GLOBAL)));
if (list != null) {
f.format("In global configured environment:%n");
f.format(list);
}
}
if (settings.containsKey(JPM_CACHE_LOCAL)) {
list = listFiles(IO.getFile(settings.get(JPM_CACHE_LOCAL)));
if (list != null) {
f.format("In local configured environment:%n");
f.format(list);
}
}
list = listSupportFiles();
if (list != null) {
f.format("jpm support files:%n");
f.format(list);
}
f.format("%n%n");
f.format(
"All files listed above will be deleted if deinit is run with the force flag set"
+ " (\"jpm deinit -f\" or \"jpm deinit --force\"%n%n");
f.flush();
justify.wrap(sb);
out.append(sb.toString());
} finally {
f.close();
}
} else { // i.e. if(force)
int count = 0;
File[] caches = {platform.getGlobal(), platform.getLocal(), null, null};
if (settings.containsKey(JPM_CACHE_LOCAL)) {
caches[2] = IO.getFile(settings.get(JPM_CACHE_LOCAL));
}
if (settings.containsKey(JPM_CACHE_GLOBAL)) {
caches[3] = IO.getFile(settings.get(JPM_CACHE_GLOBAL));
}
ArrayList<File> toDelete = new ArrayList<File>();
for (File cache : caches) {
if (cache == null || !cache.exists()) {
continue;
}
listFiles(cache, toDelete);
if (toDelete.size() > count) {
count = toDelete.size();
if (!cache.canWrite()) {
reporter.error(PERMISSION_ERROR + " (" + cache + ")");
return;
}
toDelete.add(cache);
}
}
listSupportFiles(toDelete);
for (File f : toDelete) {
if (f.exists() && !f.canWrite()) {
reporter.error(PERMISSION_ERROR + " (" + f + ")");
}
}
if (reporter.getErrors().size() > 0) {
return;
}
for (File f : toDelete) {
if (f.exists()) {
IO.deleteWithException(f);
}
}
}
}