KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > izforge > izpack > uninstaller > Destroyer


1 /*
2  * IzPack - Copyright 2001-2007 Julien Ponge, All Rights Reserved.
3  *
4  * http://www.izforge.com/izpack/
5  * http://developer.berlios.de/projects/izpack/
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  */
19
20 package com.izforge.izpack.uninstaller;
21
22 import java.io.BufferedReader JavaDoc;
23 import java.io.File JavaDoc;
24 import java.io.InputStream JavaDoc;
25 import java.io.InputStreamReader JavaDoc;
26 import java.io.ObjectInputStream JavaDoc;
27 import java.io.PrintWriter JavaDoc;
28 import java.io.StringWriter JavaDoc;
29 import java.util.ArrayList JavaDoc;
30 import java.util.Collections JavaDoc;
31 import java.util.Iterator JavaDoc;
32 import java.util.List JavaDoc;
33 import java.util.TreeSet JavaDoc;
34
35 import com.izforge.izpack.ExecutableFile;
36 import com.izforge.izpack.event.UninstallerListener;
37 import com.izforge.izpack.installer.UninstallData;
38 import com.izforge.izpack.util.AbstractUIProgressHandler;
39 import com.izforge.izpack.util.Debug;
40 import com.izforge.izpack.util.FileExecutor;
41 import com.izforge.izpack.util.OsVersion;
42 import com.izforge.izpack.util.os.unix.ShellScript;
43
44
45 /**
46  * The files destroyer class.
47  *
48  * @author Julien Ponge
49  */
50 public class Destroyer extends Thread JavaDoc
51 {
52
53     /** True if the destroyer must force the recursive deletion. */
54     private boolean forceDestroy;
55
56     /** The installation path. */
57     private String JavaDoc installPath;
58
59     /** the destroyer listener. */
60     private AbstractUIProgressHandler handler;
61
62     /**
63      * The constructor.
64      *
65      * @param installPath The installation path.
66      * @param forceDestroy Shall we force the recursive deletion.
67      * @param handler The destroyer listener.
68      */
69     public Destroyer(String JavaDoc installPath, boolean forceDestroy, AbstractUIProgressHandler handler)
70     {
71         super("IzPack - Destroyer");
72
73         this.installPath = installPath;
74         this.forceDestroy = forceDestroy;
75         this.handler = handler;
76     }
77
78     /** The run method. */
79     public void run()
80     {
81         try
82         {
83             // We get the list of uninstaller listeners
84 List JavaDoc[] listeners = getListenerLists();
85             // We get the list of the files to delete
86 ArrayList JavaDoc executables = getExecutablesList();
87
88             FileExecutor executor = new FileExecutor(executables);
89             executor.executeFiles(ExecutableFile.UNINSTALL, this.handler);
90
91             ArrayList JavaDoc files = getFilesList();
92             int size = files.size();
93
94             // Custem action listener stuff --- beforeDeletion ----
95 informListeners(listeners[0], UninstallerListener.BEFORE_DELETION, files, handler);
96
97             handler.startAction("destroy", size);
98
99             // We destroy the files
100 for (int i = 0; i < size; i++)
101             {
102                 File JavaDoc file = (File JavaDoc) files.get(i);
103                 // Custem action listener stuff --- beforeDelete ----
104 informListeners(listeners[1], UninstallerListener.BEFORE_DELETE, file, handler);
105
106                 file.delete();
107
108                 // Custem action listener stuff --- afterDelete ----
109 informListeners(listeners[1], UninstallerListener.AFTER_DELETE, file, handler);
110
111                 handler.progress(i, file.getAbsolutePath());
112             }
113
114             // Custem action listener stuff --- afterDeletion ----
115 informListeners(listeners[0], UninstallerListener.AFTER_DELETION, files, handler);
116             
117             if( OsVersion.IS_UNIX )
118             {
119               execRootScript(getRootScript());
120             }
121             // We make a complementary cleanup
122 handler.progress(size, "[ cleanups ]");
123             cleanup(new File JavaDoc(installPath));
124
125             handler.stopAction();
126         }
127         catch (Exception JavaDoc err)
128         {
129             handler.stopAction();
130             err.printStackTrace();
131            
132             StackTraceElement JavaDoc str[] = err.getStackTrace();
133             for(int idx = 0; idx < str.length;idx++)
134             {
135                  
136             }
137             
138             StringWriter JavaDoc trace = new StringWriter JavaDoc();
139             //err.printStackTrace(new PrintStream);
140 err.printStackTrace(new PrintWriter JavaDoc(trace));
141                         
142             handler.emitError("exception caught", err.toString() + "\n" + trace.toString() );
143         }
144     }
145
146     /**
147      * Asks the JVM for the uninstaller deletion.
148      *
149      * @exception Exception Description of the Exception
150      */
151     // private void askUninstallerRemoval() throws Exception
152 // {
153 // // Initialisations
154 // InputStream in = Destroyer.class.getResourceAsStream("/jarlocation.log");
155 // InputStreamReader inReader = new InputStreamReader(in);
156 // BufferedReader reader = new BufferedReader(inReader);
157 //
158 // // We delete
159 // File jar = new File(reader.readLine());
160 // File path = new File(reader.readLine());
161 // File inst = new File(installPath);
162 // jar.deleteOnExit();
163 // path.deleteOnExit();
164 // inst.deleteOnExit();
165 // }
166 /**
167      * Returns an ArrayList of the files to delete.
168      *
169      * @return The files list.
170      * @exception Exception Description of the Exception
171      */
172     private ArrayList JavaDoc getFilesList() throws Exception JavaDoc
173     {
174         // Initialisations
175 TreeSet JavaDoc files = new TreeSet JavaDoc(Collections.reverseOrder());
176         InputStream JavaDoc in = Destroyer.class.getResourceAsStream("/install.log");
177         InputStreamReader JavaDoc inReader = new InputStreamReader JavaDoc(in);
178         BufferedReader JavaDoc reader = new BufferedReader JavaDoc(inReader);
179
180         // We skip the first line (the installation path)
181 reader.readLine();
182
183         // We read it
184 String JavaDoc read = reader.readLine();
185         while (read != null)
186         {
187             files.add(new File JavaDoc(read));
188             read = reader.readLine();
189         }
190
191         // We return it
192 return new ArrayList JavaDoc(files);
193     }
194
195     /**
196      * Gets the List of all Executables
197      * @return The ArrayList of the Executables
198      * @throws Exception
199      */
200     private ArrayList JavaDoc getExecutablesList() throws Exception JavaDoc
201     {
202         ArrayList JavaDoc executables = new ArrayList JavaDoc();
203         ObjectInputStream JavaDoc in = new ObjectInputStream JavaDoc(Destroyer.class
204                 .getResourceAsStream("/executables"));
205         int num = in.readInt();
206         for (int i = 0; i < num; i++)
207         {
208             ExecutableFile file = (ExecutableFile) in.readObject();
209             executables.add(file);
210         }
211         return executables;
212     }
213
214     /**
215      * Gets the root files.
216      *
217      * @return The files which should remove by root for another user
218      * @throws Exception
219      */
220     private String JavaDoc getRootScript() throws Exception JavaDoc
221     {
222         String JavaDoc result = new String JavaDoc();
223         ObjectInputStream JavaDoc in = new ObjectInputStream JavaDoc(Destroyer.class.getResourceAsStream("/"
224                 + UninstallData.ROOTSCRIPT));
225         
226         result = in.readUTF();
227
228         
229         return result;
230     }
231
232     /**
233      * Removes the given files as root for the given Users
234      *
235      * @param aRootScript The Script to exec as uninstall time by root.
236      */
237     private void execRootScript(String JavaDoc aRootScript)
238     {
239         if(!"".equals(aRootScript))
240         {
241             Debug.log("Will Execute: " + aRootScript.toString());
242
243             try
244             {
245                 String JavaDoc result = ShellScript.execAndDelete(new StringBuffer JavaDoc( aRootScript ), File.createTempFile(
246                         this.getClass().getName(),
247                         Long.toString(System.currentTimeMillis()) + ".sh").toString());
248                 Debug.log("Result: " + result);
249             }
250             catch (Exception JavaDoc ex)
251             {
252                 Debug.log("Exeption during su remove: " + ex.getMessage());
253             }
254         }
255     }
256
257     /**
258      * Makes some reccursive cleanups.
259      *
260      * @param file The file to wipe.
261      * @exception Exception Description of the Exception
262      */
263     private void cleanup(File JavaDoc file) throws Exception JavaDoc
264     {
265         if (file.isDirectory())
266         {
267             File JavaDoc[] files = file.listFiles();
268             int size = files.length;
269             for (int i = 0; i < size; i++)
270                 cleanup(files[i]);
271             file.delete();
272         }
273         else if (forceDestroy) file.delete();
274
275     }
276
277     // CUSTOM ACTION STUFF -------------- start -----------------
278
279     /**
280      * Load the defined uninstall listener objects.
281      *
282      * @return a list with the defined uninstall listeners
283      * @throws Exception
284      */
285     private List JavaDoc[] getListenerLists() throws Exception JavaDoc
286     {
287         ArrayList JavaDoc[] uninstaller = new ArrayList JavaDoc[] { new ArrayList JavaDoc(), new ArrayList JavaDoc()};
288         // Load listeners if exist
289 InputStream JavaDoc in;
290         ObjectInputStream JavaDoc objIn;
291         in = Destroyer.class.getResourceAsStream("/uninstallerListeners");
292         if (in != null)
293         {
294             objIn = new ObjectInputStream JavaDoc(in);
295             List JavaDoc listeners = (List JavaDoc) objIn.readObject();
296             objIn.close();
297             Iterator JavaDoc iter = listeners.iterator();
298             while (iter != null && iter.hasNext())
299             {
300                 Class JavaDoc clazz = Class.forName(((String JavaDoc) iter.next()));
301                 UninstallerListener ul = (UninstallerListener) clazz.newInstance();
302                 if (ul.isFileListener()) uninstaller[1].add(ul);
303                 uninstaller[0].add(ul);
304             }
305         }
306         return uninstaller;
307     }
308
309     /**
310      * Informs all listeners.
311      *
312      * @param listeners list with the listener objects
313      * @param action identifier which callback should be called
314      * @param param parameter for the call
315      * @param handler the current progress handler
316      */
317
318     private void informListeners(List JavaDoc listeners, int action, Object JavaDoc param,
319             AbstractUIProgressHandler handler)
320     {
321         // Iterate the action list.
322 Iterator JavaDoc iter = listeners.iterator();
323         UninstallerListener il = null;
324         while (iter.hasNext())
325         {
326             try
327             {
328                 il = (UninstallerListener) iter.next();
329                 switch (action)
330                 {
331                 case UninstallerListener.BEFORE_DELETION:
332                     il.beforeDeletion((List JavaDoc) param, handler);
333                     break;
334                 case UninstallerListener.AFTER_DELETION:
335                     il.afterDeletion((List JavaDoc) param, handler);
336                     break;
337                 case UninstallerListener.BEFORE_DELETE:
338                     il.beforeDelete((File JavaDoc) param, handler);
339                     break;
340                 case UninstallerListener.AFTER_DELETE:
341                     il.afterDelete((File JavaDoc) param, handler);
342                     break;
343                 }
344             }
345             catch (Throwable JavaDoc e)
346             { // Catch it to prevent for a block of uninstallation.
347 handler.emitError("Skipping custom action because exception caught during "
348                         + il.getClass().getName(), e.toString());
349             }
350         }
351     }
352
353     // CUSTOM ACTION STUFF -------------- end -----------------
354
355 }
356
Popular Tags