com.izforge.izpack.util

Class SelfModifier

java.lang.Object

com.izforge.izpack.util.SelfModifier

public class SelfModifier
extends Object

Allows an application to modify the jar file from which it came, including outright deletion. The jar file of an app is usually locked when java is run so this is normally not possible.

Create a SelfModifier with a target method, then invoke the SelfModifier with arguments to be passed to the target method. The jar file containing the target method's class (obtained by reflection) will be extracted to a temporary directory, and a new java process will be spawned to invoke the target method. The original jar file may now be modified.

If the constructor or invoke() methods fail, it is generally because secondary java processes could not be started.

Requirements

• The target method, and all it's required classes must be in a jar file.
• The Self Modifier, and its inner classes must also be in the jar file.

There are three system processes (or "phases") involved, the first invoked by the user, the second and third by the SelfModifier.

Phase 1:

1. Program is launched, SelfModifier is created, invoke(String[]) is called
2. A temporary directory (or "sandbox") is created in the default temp directory, and the jar file contents ar extracted into it
3. Phase 2 is spawned using the sandbox as it's classpath, SelfModifier as the main class, the arguments to "invoke(String[])" as the main arguments, and the SelfModifier system properties set.
4. Immediately exit so the system unlocks the jar file

Phase 2:

1. Initializes from system properties.
2. Spawn phase 3 exactly as phase 2 except the self.modifier.phase system properties set to 3.
3. Wait for phase 3 to die
4. Delete the temporary sandbox

Phase 3:

1. Initializes from system properties.
2. Redirect std err stream to the log
3. Invoke the target method with arguments we were given
4. The target method is expected to call exit(), or to not start any looping threads (e.g. AWT thread). In other words, the target is the new "main" method.

SelfModifier system properties used to pass information between processes.

Constant	System property	description
BASE_KEY	self.mod.jar	base path to log file and sandbox dir
JAR_KEY	self.mod.class	path to original jar file
CLASS_KEY	self.mod.method	class of target method
METHOD_KEY	self.mod.phase	name of method to be invoked in sandbox
PHASE_KEY	self.mod.base	phase of operation to run

Version:

1.0

Author:

Chadwick McHenry

Constructor Summary

Constructors

Constructor and Description
SelfModifier(Method method) Creates a SelfModifier which will invoke the target method in a separate process from which it may modify it's own jar file.

Method Summary

Modifier and Type	Method and Description
static File	findJarFile(Class<?> clazz) Retrieve the jar file the specified class was loaded from.
void	invoke(String[] args) Invoke the target method in a separate process from which it may modify it's own jar file.
static void	main(String[] args)
static void	test(String[] args)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

SelfModifier

public SelfModifier(Method method)
             throws IOException

Creates a SelfModifier which will invoke the target method in a separate process from which it may modify it's own jar file.

The target method must be public, static, and take a single array of strings as its only parameter. The class which declares the method must also be public. Reflection is used to ensure this.

Parameters:

method - a public, static method that accepts a String array as it's only parameter. Any return value is ignored.

Throws:

NullPointerException - if method is null

IllegalArgumentException - if method is not public, static, and take a String array as it's only argument, or of it's declaring class is not public.

IllegalStateException - if process was not invoked from a jar file, or an IOException occurred while accessing it

IOException - if java is unable to be executed as a separate process

SecurityException - if access to the method, or creation of a child process is denied

Method Detail

test

public static void test(String[] args)

main

public static void main(String[] args)

invoke

public void invoke(String[] args)
            throws IOException

Invoke the target method in a separate process from which it may modify it's own jar file. This method does not normally return. After spawning the secondary process, the current process must die before the jar file is unlocked, therefore calling this method is akin to calling System.exit(int).

The contents of the current jar file are extracted copied to a 'sandbox' directory from which the method is invoked. The path to the original jar file is placed in the system property JAR_KEY.

Parameters:

args - arguments to pass to the target method. May be empty or null to indicate no arguments.

Throws:

IOException - for lots of things

IllegalStateException - if method's class was not loaded from a jar

findJarFile

public static File findJarFile(Class<?> clazz)

Retrieve the jar file the specified class was loaded from.

Returns:

null if file was not loaded from a jar file

Throws:

SecurityException - if access to is denied by SecurityManager