private int verifyVersionEx() {
String min = getMinVersion();
String max = getMaxVersion();
int retval = OK;
// No min and max, version always ok.
if (min == null && max == null) return (OK);
if (!pathIsValid()) return (BAD_REAL_PATH);
// No get the version ...
// We cannot look to the version of this vm because we should
// test the given JDK VM.
String[] params = {
pathSelectionPanel.getPath() + File.separator + "bin" + File.separator + "java", "-version"
};
String[] output = new String[2];
FileExecutor fe = new FileExecutor();
fe.executeCommand(params, output);
// "My" VM writes the version on stderr :-(
String vs = (output[0].length() > 0) ? output[0] : output[1];
if (min != null) {
if (!compareVersions(vs, min, true, 4, 4, "__NO_NOT_IDENTIFIER_")) retval = BAD_VERSION;
}
if (max != null)
if (!compareVersions(vs, max, false, 4, 4, "__NO_NOT_IDENTIFIER_")) retval = BAD_VERSION;
if (retval == OK
&& badRegEntries != null
&& badRegEntries.size() > 0) { // Test for bad registry entry.
if (badRegEntries.contains(getDetectedVersion())) retval = BAD_REG_PATH;
}
return (retval);
}
// check if sudo password is correct (so sudo can be used in all other scripts, even without
// password, lasts for 5 minutes)
private void doSudoCmd() {
String pass = passwordField.getText();
File file = null;
try {
// write file in /tmp
file = new File("/tmp/cmd_sudo.sh"); // ""c:/temp/run.bat""
FileOutputStream fos = new FileOutputStream(file);
fos.write("echo $password | sudo -S ls\nexit $?".getBytes()); // "echo $password > pipo.txt"
fos.close();
// execute
HashMap vars = new HashMap();
vars.put("password", pass);
List oses = new ArrayList();
oses.add(
new OsConstraint(
"unix", null, null,
null)); // "windows",System.getProperty("os.name"),System.getProperty("os.version"),System.getProperty("os.arch")));
ArrayList plist = new ArrayList();
ParsableFile pf = new ParsableFile(file.getAbsolutePath(), null, null, oses);
plist.add(pf);
ScriptParser sp = new ScriptParser(plist, new VariableSubstitutor(vars));
sp.parseFiles();
ArrayList elist = new ArrayList();
ExecutableFile ef =
new ExecutableFile(
file.getAbsolutePath(),
ExecutableFile.POSTINSTALL,
ExecutableFile.ABORT,
oses,
false);
elist.add(ef);
FileExecutor fe = new FileExecutor(elist);
int retval = fe.executeFiles(ExecutableFile.POSTINSTALL, this);
if (retval == 0) {
idata.setVariable("password", pass);
isValid = true;
}
// else is already showing dialog
// {
// JOptionPane.showMessageDialog(this, "Cannot execute 'sudo' cmd, check your password",
// "Error", JOptionPane.ERROR_MESSAGE);
// }
} catch (Exception e) {
// JOptionPane.showMessageDialog(this, "Cannot execute 'sudo' cmd, check your password",
// "Error", JOptionPane.ERROR_MESSAGE);
e.printStackTrace();
isValid = false;
}
try {
if (file != null && file.exists())
file.delete(); // you don't want the file with password tobe arround, in case of error
} catch (Exception e) {
// ignore
}
}
/**
* Executes this ShellScript with the given Params.<br>
* NOTE: the params cannot be contain whitespaces.<br>
* This (su -c <br>"cp from to"</br>) would not work:<br>
* because the underlaying java.runtime.exec("command") does not handle balanced or unbalanced (")
* correctly.<br>
* else just whitespace separate tokens.<br>
* This means for the sample. runtime.exec() would ever execute such as: su "-c" "\"cp" "fromFile"
* "toFile\""<br>
* But this his hidden in Sun's native code ;-(<br>
* This was the reason to write this class to have a Workaround :-)
*
* @param itsParams
* @return the output from stdout of the execution.
*/
public String exec(String itsParams) {
FileExecutor.getExecOutput(
new String[] {UnixHelper.getCustomCommand("chmod"), "+x", itsLocation});
if (itsParams != null) {
return FileExecutor.getExecOutput(new String[] {itsLocation, itsParams});
} else {
return FileExecutor.getExecOutput(new String[] {itsLocation});
}
}
/**
* Internal helper method.
*
* @param executor The executor, only used when using external compiler.
* @param output The output from the compiler ([0] = stdout, [1] = stderr)
* @return The result of the compilation.
*/
private int runCompiler(FileExecutor executor, String[] output, List<String> cmdline) {
if (cmdline.get(0).equals(ECLIPSE_COMPILER_NAME)) {
return runEclipseCompiler(output, cmdline);
}
return executor.executeCommand(cmdline.toArray(new String[cmdline.size()]), output);
}
/** The run method. */
public void run() {
try {
// We get the list of uninstaller listeners
List[] listeners = getListenerLists();
// We get the list of the files to delete
ArrayList executables = getExecutablesList();
FileExecutor executor = new FileExecutor(executables);
executor.executeFiles(ExecutableFile.UNINSTALL, this.handler);
ArrayList files = getFilesList();
int size = files.size();
// Custem action listener stuff --- beforeDeletion ----
informListeners(listeners[0], UninstallerListener.BEFORE_DELETION, files, handler);
handler.startAction("destroy", size);
// We destroy the files
for (int i = 0; i < size; i++) {
File file = (File) files.get(i);
// Custem action listener stuff --- beforeDelete ----
informListeners(listeners[1], UninstallerListener.BEFORE_DELETE, file, handler);
file.delete();
// Custem action listener stuff --- afterDelete ----
informListeners(listeners[1], UninstallerListener.AFTER_DELETE, file, handler);
handler.progress(i, file.getAbsolutePath());
}
// Custem action listener stuff --- afterDeletion ----
informListeners(listeners[0], UninstallerListener.AFTER_DELETION, files, handler);
// We make a complementary cleanup
handler.progress(size, "[ cleanups ]");
cleanup(new File(installPath));
handler.stopAction();
} catch (Exception err) {
handler.stopAction();
err.printStackTrace();
handler.emitError("exception caught", err.toString());
}
}
/** The run method. */
public void run() {
instances.add(this);
try {
listener.startUnpack();
String currentOs = System.getProperty("os.name").toLowerCase();
//
// Initialisations
FileOutputStream out = null;
ArrayList parsables = new ArrayList();
ArrayList executables = new ArrayList();
List packs = idata.selectedPacks;
int npacks = packs.size();
udata = UninstallData.getInstance();
// Specific to the web installers
if (idata.kind.equalsIgnoreCase("web") || idata.kind.equalsIgnoreCase("web-kunststoff")) {
InputStream kin = getClass().getResourceAsStream("/res/WebInstallers.url");
BufferedReader kreader = new BufferedReader(new InputStreamReader(kin));
jarLocation = kreader.readLine();
}
// We unpack the selected packs
for (int i = 0; i < npacks; i++) {
// We get the pack stream
int n = idata.allPacks.indexOf(packs.get(i));
ObjectInputStream objIn = new ObjectInputStream(getPackAsStream(n));
// We unpack the files
int nfiles = objIn.readInt();
listener.changeUnpack(0, nfiles, ((Pack) packs.get(i)).name);
for (int j = 0; j < nfiles; j++) {
// We read the header
PackFile pf = (PackFile) objIn.readObject();
if (null == pf.os || matchOS(currentOs, pf.os.toLowerCase())) {
// We translate & build the path
String path = translatePath(pf.targetPath);
File pathFile = new File(path);
String fname = pathFile.getName();
int z = fname.length();
File dest = pathFile.getParentFile();
if (!dest.exists()) dest.mkdirs();
// We add the path to the log,
udata.addFile(path);
listener.progressUnpack(j, path);
// if this file exists and shouldnot override skip this file
if (((pf.override == false) && (pathFile.exists()))) {
objIn.skip(pf.length);
continue;
}
// We copy the file
out = new FileOutputStream(path);
byte[] buffer = new byte[5120];
long bytesCopied = 0;
while (bytesCopied < pf.length) {
int maxBytes =
(pf.length - bytesCopied < buffer.length
? (int) (pf.length - bytesCopied)
: buffer.length);
int bytesInBuffer = objIn.read(buffer, 0, maxBytes);
if (bytesInBuffer == -1) throw new IOException("Unexpected end of stream");
out.write(buffer, 0, bytesInBuffer);
bytesCopied += bytesInBuffer;
}
// Cleanings
out.close();
// Empty dirs restoring
String _n = pathFile.getName();
if (_n.startsWith("izpack-keepme") && _n.endsWith(".tmp")) pathFile.delete();
} else objIn.skip(pf.length);
}
// Load information about parsable files
int numParsables = objIn.readInt();
int k;
for (k = 0; k < numParsables; k++) {
ParsableFile pf = (ParsableFile) objIn.readObject();
pf.path = translatePath(pf.path);
parsables.add(pf);
}
// Load information about executable files
int numExecutables = objIn.readInt();
for (k = 0; k < numExecutables; k++) {
ExecutableFile ef = (ExecutableFile) objIn.readObject();
ef.path = translatePath(ef.path);
if (null != ef.argList && !ef.argList.isEmpty()) {
String arg = null;
for (int j = 0; j < ef.argList.size(); j++) {
arg = (String) ef.argList.get(j);
arg = translatePath(arg);
ef.argList.set(j, arg);
}
}
executables.add(ef);
if (ef.executionStage == ExecutableFile.UNINSTALL) {
udata.addExecutable(ef);
}
}
objIn.close();
}
// We use the scripts parser
ScriptParser parser = new ScriptParser(parsables, vs);
parser.parseFiles();
// We use the file executor
FileExecutor executor = new FileExecutor(executables);
if (executor.executeFiles(ExecutableFile.POSTINSTALL) != 0)
javax.swing.JOptionPane.showMessageDialog(
null,
"The installation was not completed.",
"Installation warning",
javax.swing.JOptionPane.WARNING_MESSAGE);
// We put the uninstaller
putUninstaller();
// The end :-)
listener.stopUnpack();
} catch (Exception err) {
listener.stopUnpack();
listener.errorUnpack(err.toString());
}
instances.remove(instances.indexOf(this));
}
/**
* Check whether the given compiler works.
*
* <p>This performs two steps:
*
* <ol>
* <li>check whether we can successfully call "compiler -help"
* <li>check whether we can successfully call "compiler -help arguments" (not all compilers
* return an error here)
* </ol>
*
* On failure, the method CompileHandler#errorCompile is called with a descriptive error
* message.
*
* @param compiler the compiler to use
* @param arguments additional arguments to pass to the compiler
* @return false on error
*/
public CompileResult checkCompiler(String compiler, ArrayList arguments) {
int retval = 0;
FileExecutor executor = new FileExecutor();
String[] output = new String[2];
Debug.trace("checking whether \"" + compiler + " -help\" works");
{
String[] args = {compiler, "-help"};
retval = executor.executeCommand(args, output);
if (retval != 0) {
CompileResult result =
new CompileResult(
this.langpack.getString("CompilePanel.error.compilernotfound"),
args,
output[0],
output[1]);
this.listener.handleCompileError(result);
if (!result.isContinue()) return result;
}
}
Debug.trace("checking whether \"" + compiler + " -help +arguments\" works");
// used to collect the arguments for executing the compiler
LinkedList args = new LinkedList(arguments);
// add -help argument to prevent the compiler from doing anything
args.add(0, "-help");
// add compiler in front of arguments
args.add(0, compiler);
// construct classpath argument for compiler
// - collect all classpaths
StringBuffer classpath_sb = new StringBuffer();
Iterator cp_it = this.classpath.iterator();
while (cp_it.hasNext()) {
String cp = (String) cp_it.next();
if (classpath_sb.length() > 0) classpath_sb.append(File.pathSeparatorChar);
classpath_sb.append(new File(cp).getAbsolutePath());
}
String classpath_str = classpath_sb.toString();
// - add classpath argument to command line
if (classpath_str.length() > 0) {
args.add("-classpath");
args.add(classpath_str);
}
String[] args_arr = (String[]) args.toArray(output);
retval = executor.executeCommand(args_arr, output);
if (retval != 0) {
CompileResult result =
new CompileResult(
this.langpack.getString("CompilePanel.error.invalidarguments"),
args_arr,
output[0],
output[1]);
this.listener.handleCompileError(result);
if (!result.isContinue()) return result;
}
return new CompileResult();
}
public CompileResult perform(String compiler, ArrayList arguments) {
Debug.trace("starting job " + this.name);
// we have some maximum command line length - need to count
int cmdline_len = 0;
// used to collect the arguments for executing the compiler
LinkedList args = new LinkedList(arguments);
{
Iterator arg_it = args.iterator();
while (arg_it.hasNext()) cmdline_len += ((String) arg_it.next()).length() + 1;
}
// add compiler in front of arguments
args.add(0, compiler);
cmdline_len += compiler.length() + 1;
// construct classpath argument for compiler
// - collect all classpaths
StringBuffer classpath_sb = new StringBuffer();
Iterator cp_it = this.classpath.iterator();
while (cp_it.hasNext()) {
String cp = (String) cp_it.next();
if (classpath_sb.length() > 0) classpath_sb.append(File.pathSeparatorChar);
classpath_sb.append(new File(cp).getAbsolutePath());
}
String classpath_str = classpath_sb.toString();
// - add classpath argument to command line
if (classpath_str.length() > 0) {
args.add("-classpath");
cmdline_len = cmdline_len + 11;
args.add(classpath_str);
cmdline_len += classpath_str.length() + 1;
}
// remember how many arguments we have which don't change for the
// job
int common_args_no = args.size();
// remember how long the common command line is
int common_args_len = cmdline_len;
// used for execution
FileExecutor executor = new FileExecutor();
String output[] = new String[2];
// used for displaying the progress bar
String jobfiles = "";
int fileno = 0;
int last_fileno = 0;
// now iterate over all files of this job
Iterator file_it = this.files.iterator();
while (file_it.hasNext()) {
File f = (File) file_it.next();
String fpath = f.getAbsolutePath();
Debug.trace("processing " + fpath);
// we add the file _first_ to the arguments to have a better
// chance to get something done if the command line is almost
// MAX_CMDLINE_SIZE or even above
fileno++;
jobfiles += f.getName() + " ";
args.add(fpath);
cmdline_len += fpath.length();
// start compilation if maximum command line length reached
if (cmdline_len >= MAX_CMDLINE_SIZE) {
Debug.trace("compiling " + jobfiles);
// display useful progress bar (avoid showing 100% while
// still
// compiling a lot)
this.listener.progress(last_fileno, jobfiles);
last_fileno = fileno;
String[] full_cmdline = (String[]) args.toArray(output);
int retval = executor.executeCommand(full_cmdline, output);
// update progress bar: compilation of fileno files done
this.listener.progress(fileno, jobfiles);
if (retval != 0) {
CompileResult result =
new CompileResult(
this.langpack.getString("CompilePanel.error"),
full_cmdline,
output[0],
output[1]);
this.listener.handleCompileError(result);
if (!result.isContinue()) return result;
} else {
// verify that all files have been compiled successfully
// I found that sometimes, no error code is returned
// although
// compilation failed.
Iterator arg_it = args.listIterator(common_args_no);
while (arg_it.hasNext()) {
File java_file = new File((String) arg_it.next());
String basename = java_file.getName();
int dotpos = basename.lastIndexOf('.');
basename = basename.substring(0, dotpos) + ".class";
File class_file = new File(java_file.getParentFile(), basename);
if (!class_file.exists()) {
CompileResult result =
new CompileResult(
this.langpack.getString("CompilePanel.error.noclassfile")
+ java_file.getAbsolutePath(),
full_cmdline,
output[0],
output[1]);
this.listener.handleCompileError(result);
if (!result.isContinue()) return result;
// don't continue any further
break;
}
}
}
// clean command line: remove files we just compiled
for (int i = args.size() - 1; i >= common_args_no; i--) {
args.removeLast();
}
cmdline_len = common_args_len;
jobfiles = "";
}
}
if (cmdline_len > common_args_len) {
this.listener.progress(last_fileno, jobfiles);
String[] full_cmdline = (String[]) args.toArray(output);
int retval = executor.executeCommand(full_cmdline, output);
this.listener.progress(fileno, jobfiles);
if (retval != 0) {
CompileResult result =
new CompileResult(
this.langpack.getString("CompilePanel.error"),
full_cmdline,
output[0],
output[1]);
this.listener.handleCompileError(result);
if (!result.isContinue()) return result;
}
}
Debug.trace("job " + this.name + " done (" + fileno + " files compiled)");
return new CompileResult();
}
/* (non-Javadoc)
* @see com.izforge.izpack.installer.IUnpacker#run()
*/
public void run() {
addToInstances();
try {
//
// Initialisations
FileOutputStream out = null;
ArrayList<ParsableFile> parsables = new ArrayList<ParsableFile>();
ArrayList<ExecutableFile> executables = new ArrayList<ExecutableFile>();
ArrayList<UpdateCheck> updatechecks = new ArrayList<UpdateCheck>();
List packs = idata.selectedPacks;
int npacks = packs.size();
handler.startAction("Unpacking", npacks);
udata = UninstallData.getInstance();
// Custom action listener stuff --- load listeners ----
List[] customActions = getCustomActions();
// Custom action listener stuff --- beforePacks ----
informListeners(customActions, InstallerListener.BEFORE_PACKS, idata, npacks, handler);
packs = idata.selectedPacks;
npacks = packs.size();
// We unpack the selected packs
for (int i = 0; i < npacks; i++) {
// We get the pack stream
// int n = idata.allPacks.indexOf(packs.get(i));
Pack p = (Pack) packs.get(i);
// evaluate condition
if (p.hasCondition()) {
if (rules != null) {
if (!rules.isConditionTrue(p.getCondition())) {
// skip pack, condition is not fullfilled.
continue;
}
} else {
// TODO: skip pack, because condition can not be checked
}
}
// Custom action listener stuff --- beforePack ----
informListeners(
customActions, InstallerListener.BEFORE_PACK, packs.get(i), npacks, handler);
ObjectInputStream objIn = new ObjectInputStream(getPackAsStream(p.id, p.uninstall));
// We unpack the files
int nfiles = objIn.readInt();
// We get the internationalized name of the pack
final Pack pack = ((Pack) packs.get(i));
String stepname = pack.name; // the message to be passed to the
// installpanel
if (langpack != null && !(pack.id == null || "".equals(pack.id))) {
final String name = langpack.getString(pack.id);
if (name != null && !"".equals(name)) {
stepname = name;
}
}
handler.nextStep(stepname, i + 1, nfiles);
for (int j = 0; j < nfiles; j++) {
// We read the header
PackFile pf = (PackFile) objIn.readObject();
// TODO: reaction if condition can not be checked
if (pf.hasCondition() && (rules != null)) {
if (!rules.isConditionTrue(pf.getCondition())) {
if (!pf.isBackReference()) {
// skip, condition is not fulfilled
objIn.skip(pf.length());
}
continue;
}
}
if (OsConstraint.oneMatchesCurrentSystem(pf.osConstraints())) {
// We translate & build the path
String path = IoHelper.translatePath(pf.getTargetPath(), vs);
File pathFile = new File(path);
File dest = pathFile;
if (!pf.isDirectory()) {
dest = pathFile.getParentFile();
}
if (!dest.exists()) {
// If there are custom actions which would be called
// at
// creating a directory, create it recursively.
List fileListeners = customActions[customActions.length - 1];
if (fileListeners != null && fileListeners.size() > 0) {
mkDirsWithEnhancement(dest, pf, customActions);
} else
// Create it in on step.
{
if (!dest.mkdirs()) {
handler.emitError(
"Error creating directories",
"Could not create directory\n" + dest.getPath());
handler.stopAction();
this.result = false;
return;
}
}
}
if (pf.isDirectory()) {
continue;
}
// Custom action listener stuff --- beforeFile ----
informListeners(customActions, InstallerListener.BEFORE_FILE, pathFile, pf, null);
// We add the path to the log,
udata.addFile(path, pack.uninstall);
handler.progress(j, path);
// if this file exists and should not be overwritten,
// check
// what to do
if ((pathFile.exists()) && (pf.override() != PackFile.OVERRIDE_TRUE)) {
boolean overwritefile = false;
// don't overwrite file if the user said so
if (pf.override() != PackFile.OVERRIDE_FALSE) {
if (pf.override() == PackFile.OVERRIDE_TRUE) {
overwritefile = true;
} else if (pf.override() == PackFile.OVERRIDE_UPDATE) {
// check mtime of involved files
// (this is not 100% perfect, because the
// already existing file might
// still be modified but the new installed
// is just a bit newer; we would
// need the creation time of the existing
// file or record with which mtime
// it was installed...)
overwritefile = (pathFile.lastModified() < pf.lastModified());
} else {
int def_choice = -1;
if (pf.override() == PackFile.OVERRIDE_ASK_FALSE) {
def_choice = AbstractUIHandler.ANSWER_NO;
}
if (pf.override() == PackFile.OVERRIDE_ASK_TRUE) {
def_choice = AbstractUIHandler.ANSWER_YES;
}
int answer =
handler.askQuestion(
idata.langpack.getString("InstallPanel.overwrite.title")
+ " - "
+ pathFile.getName(),
idata.langpack.getString("InstallPanel.overwrite.question")
+ pathFile.getAbsolutePath(),
AbstractUIHandler.CHOICES_YES_NO,
def_choice);
overwritefile = (answer == AbstractUIHandler.ANSWER_YES);
}
}
if (!overwritefile) {
if (!pf.isBackReference() && !((Pack) packs.get(i)).loose) {
objIn.skip(pf.length());
}
continue;
}
}
// We copy the file
InputStream pis = objIn;
if (pf.isBackReference()) {
InputStream is = getPackAsStream(pf.previousPackId, pack.uninstall);
pis = new ObjectInputStream(is);
// must wrap for blockdata use by objectstream
// (otherwise strange result)
// skip on underlaying stream (for some reason not
// possible on ObjectStream)
is.skip(pf.offsetInPreviousPack - 4);
// but the stream header is now already read (== 4
// bytes)
} else if (((Pack) packs.get(i)).loose) {
/* Old way of doing the job by using the (absolute) sourcepath.
* Since this is very likely to fail and does not confirm to the documentation,
* prefer using relative path's
pis = new FileInputStream(pf.sourcePath);
*/
File resolvedFile = new File(getAbsolutInstallSource(), pf.getRelativeSourcePath());
if (!resolvedFile.exists()) {
// try alternative destination - the current working directory
// user.dir is likely (depends on launcher type) the current directory of the
// executable or jar-file...
final File userDir = new File(System.getProperty("user.dir"));
resolvedFile = new File(userDir, pf.getRelativeSourcePath());
}
if (resolvedFile.exists()) {
pis = new FileInputStream(resolvedFile);
// may have a different length & last modified than we had at compiletime, therefore
// we have to build a new PackFile for the copy process...
pf =
new PackFile(
resolvedFile.getParentFile(),
resolvedFile,
pf.getTargetPath(),
pf.osConstraints(),
pf.override(),
pf.getAdditionals());
} else {
// file not found
// issue a warning (logging api pending)
// since this file was loosely bundled, we continue with the installation.
System.out.println(
"Could not find loosely bundled file: " + pf.getRelativeSourcePath());
out.close();
continue;
}
}
if (pf.isPack200Jar()) {
int key = objIn.readInt();
InputStream pack200Input =
Unpacker.class.getResourceAsStream("/packs/pack200-" + key);
Pack200.Unpacker unpacker = getPack200Unpacker();
java.util.jar.JarOutputStream jarOut =
new java.util.jar.JarOutputStream(new FileOutputStream(pathFile));
unpacker.unpack(pack200Input, jarOut);
jarOut.close();
} else {
out = new FileOutputStream(pathFile);
byte[] buffer = new byte[5120];
long bytesCopied = 0;
while (bytesCopied < pf.length()) {
if (performInterrupted()) { // Interrupt was initiated; perform it.
out.close();
if (pis != objIn) {
pis.close();
}
return;
}
int maxBytes = (int) Math.min(pf.length() - bytesCopied, buffer.length);
int bytesInBuffer = pis.read(buffer, 0, maxBytes);
if (bytesInBuffer == -1) {
throw new IOException("Unexpected end of stream (installer corrupted?)");
}
out.write(buffer, 0, bytesInBuffer);
bytesCopied += bytesInBuffer;
}
out.close();
}
if (pis != objIn) {
pis.close();
}
// Set file modification time if specified
if (pf.lastModified() >= 0) {
pathFile.setLastModified(pf.lastModified());
}
// Custom action listener stuff --- afterFile ----
informListeners(customActions, InstallerListener.AFTER_FILE, pathFile, pf, null);
} else {
if (!pf.isBackReference()) {
objIn.skip(pf.length());
}
}
}
// Load information about parsable files
int numParsables = objIn.readInt();
for (int k = 0; k < numParsables; k++) {
ParsableFile pf = (ParsableFile) objIn.readObject();
if (pf.hasCondition() && (rules != null)) {
if (!rules.isConditionTrue(pf.getCondition())) {
// skip, condition is not fulfilled
continue;
}
}
pf.path = IoHelper.translatePath(pf.path, vs);
parsables.add(pf);
}
// Load information about executable files
int numExecutables = objIn.readInt();
for (int k = 0; k < numExecutables; k++) {
ExecutableFile ef = (ExecutableFile) objIn.readObject();
if (ef.hasCondition() && (rules != null)) {
if (!rules.isConditionTrue(ef.getCondition())) {
// skip, condition is false
continue;
}
}
ef.path = IoHelper.translatePath(ef.path, vs);
if (null != ef.argList && !ef.argList.isEmpty()) {
String arg = null;
for (int j = 0; j < ef.argList.size(); j++) {
arg = ef.argList.get(j);
arg = IoHelper.translatePath(arg, vs);
ef.argList.set(j, arg);
}
}
executables.add(ef);
if (ef.executionStage == ExecutableFile.UNINSTALL) {
udata.addExecutable(ef);
}
}
// Custom action listener stuff --- uninstall data ----
handleAdditionalUninstallData(udata, customActions);
// Load information about updatechecks
int numUpdateChecks = objIn.readInt();
for (int k = 0; k < numUpdateChecks; k++) {
UpdateCheck uc = (UpdateCheck) objIn.readObject();
updatechecks.add(uc);
}
objIn.close();
if (performInterrupted()) { // Interrupt was initiated; perform it.
return;
}
// Custom action listener stuff --- afterPack ----
informListeners(customActions, InstallerListener.AFTER_PACK, packs.get(i), i, handler);
}
// We use the scripts parser
ScriptParser parser = new ScriptParser(parsables, vs);
parser.parseFiles();
if (performInterrupted()) { // Interrupt was initiated; perform it.
return;
}
// We use the file executor
FileExecutor executor = new FileExecutor(executables);
if (executor.executeFiles(ExecutableFile.POSTINSTALL, handler) != 0) {
handler.emitError("File execution failed", "The installation was not completed");
this.result = false;
}
if (performInterrupted()) { // Interrupt was initiated; perform it.
return;
}
// We put the uninstaller (it's not yet complete...)
putUninstaller();
// update checks _after_ uninstaller was put, so we don't delete it
performUpdateChecks(updatechecks);
if (performInterrupted()) { // Interrupt was initiated; perform it.
return;
}
// Custom action listener stuff --- afterPacks ----
informListeners(customActions, InstallerListener.AFTER_PACKS, idata, handler, null);
if (performInterrupted()) { // Interrupt was initiated; perform it.
return;
}
// write installation information
writeInstallationInformation();
// The end :-)
handler.stopAction();
} catch (Exception err) {
// TODO: finer grained error handling with useful error messages
handler.stopAction();
if ("Installation cancelled".equals(err.getMessage())) {
handler.emitNotification("Installation cancelled");
} else {
handler.emitError("An error occured", err.getMessage());
err.printStackTrace();
}
this.result = false;
Housekeeper.getInstance().shutDown(4);
} finally {
removeFromInstances();
}
}
