Java > Open Source Codes > com > izforge > izpack > compiler > Packager


1 /*
2  * $Id: Packager.java 1708 2007-01-13 18:31:26Z jponge $
3  * IzPack - Copyright 2001-2007 Julien Ponge, All Rights Reserved.
4  *
5  * http://www.izforge.com/izpack/
6  * http://developer.berlios.de/projects/izpack/
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  */
20
21 package com.izforge.izpack.compiler;
22
23 import java.io.File ;
24 import java.io.FileInputStream ;
25 import java.io.IOException ;
26 import java.io.InputStream ;
27 import java.io.ObjectOutputStream ;
28 import java.io.OutputStream ;
29 import java.net.URL ;
30 import java.util.ArrayList ;
31 import java.util.HashMap ;
32 import java.util.HashSet ;
33 import java.util.Iterator ;
34 import java.util.List ;
35 import java.util.Map ;
36 import java.util.Properties ;
37 import java.util.Set ;
38 import java.util.zip.Deflater ;
39 import java.util.zip.ZipException ;
40 import java.util.zip.ZipInputStream ;
41
42 import net.n3.nanoxml.XMLElement;
43
44 // The declarations for ZipOutputStreams will be done
45 // as full qualified to clear at the use point that
46 // we do not use the standard class else the extended
47 // from apache.
48 //import org.apache.tools.zip.ZipOutputStream;
49 //import org.apache.tools.zip.ZipEntry;
50
51 import com.izforge.izpack.CustomData;
52 import com.izforge.izpack.GUIPrefs;
53 import com.izforge.izpack.Info;
54 import com.izforge.izpack.Pack;
55 import com.izforge.izpack.PackFile;
56 import com.izforge.izpack.Panel;
57 import com.izforge.izpack.compressor.PackCompressor;
58 import com.izforge.izpack.compressor.PackCompressorFactory;
59 //import com.izforge.izpack.util.JarOutputStream;
60
61 /**
62  * The packager class. The packager is used by the compiler to put files into an installer, and
63  * create the actual installer files.
64  *
65  * @author Julien Ponge
66  * @author Chadwick McHenry
67  */
68 public class Packager implements IPackager
69 {
70
71     /** Path to the skeleton installer. */
72     public static final String SKELETON_SUBPATH = "lib/installer.jar";
73
74     /** Base file name of all jar files. This has no ".jar" suffix. */
75     private File baseFile = null;
76
77     /** Executable zipped output stream. First to open, last to close.
78      * Attention! This is our own JarOutputStream, not the java standard! */
79     private com.izforge.izpack.util.JarOutputStream primaryJarStream;
80
81     /** Basic installer info. */
82     private Info info = null;
83
84     /** Gui preferences of instatller. */
85     private GUIPrefs guiPrefs = null;
86
87     /** The variables used in the project */
88     private Properties variables = new Properties ();
89
90     /** The ordered panels informations. */
91     private List panelList = new ArrayList ();
92
93     /** The ordered packs informations (as PackInfo objects). */
94     private List packsList = new ArrayList ();
95
96     /** The ordered langpack ISO3 names. */
97     private List langpackNameList = new ArrayList ();
98
99     /** The ordered custom actions informations. */
100     private List customDataList = new ArrayList ();
101
102     /** The langpack URLs keyed by ISO3 name. */
103     private Map installerResourceURLMap = new HashMap ();
104
105     /** Jar file URLs who's contents will be copied into the installer. */
106     private Set includedJarURLs = new HashSet ();
107
108     /** Each pack is created in a separte jar if webDirURL is non-null. */
109     private boolean packJarsSeparate = false;
110
111     /** The listeners. */
112     private PackagerListener listener;
113
114     /** The compression format to be used for pack compression */
115     private PackCompressor compressor;
116     
117     /** Files which are always written into the container file */
118     private HashMap alreadyWrittenFiles = new HashMap ();
119     /** The constructor.
120      * @throws CompilerException*/
121     public Packager() throws CompilerException
122     {
123         this("default");
124     }
125
126     /**
127      * Extended constructor.
128      * @param compr_format Compression format to be used for packs
129      * compression format (if supported)
130      * @throws CompilerException
131      */
132     public Packager(String compr_format) throws CompilerException
133     {
134         this( compr_format, -1);
135     }
136
137     /**
138      * Extended constructor.
139      * @param compr_format Compression format to be used for packs
140      * @param compr_level Compression level to be used with the chosen
141      * compression format (if supported)
142      * @throws CompilerException
143      */
144     public Packager(String compr_format, int compr_level) throws CompilerException
145     {
146         compressor = PackCompressorFactory.get( compr_format);
147         compressor.setCompressionLevel(compr_level);
148     }
149     
150     
151
152     /* (non-Javadoc)
153      * @see com.izforge.izpack.compiler.IPackager#createInstaller(java.io.File)
154      */
155     public void createInstaller(File primaryFile) throws Exception
156     {
157         // preliminary work
158 String baseName = primaryFile.getName();
159         if (baseName.endsWith(".jar"))
160         {
161             baseName = baseName.substring(0, baseName.length() - 4);
162             baseFile = new File (primaryFile.getParentFile(), baseName);
163         }
164         else
165             baseFile = primaryFile;
166
167         info.setInstallerBase(baseFile.getName());
168         packJarsSeparate = (info.getWebDirURL() != null);
169
170         // primary (possibly only) jar. -1 indicates primary
171 primaryJarStream = getJarOutputStream(baseFile.getName() + ".jar");
172
173         sendStart();
174         
175         // write the primary jar. MUST be first so manifest is not overwritten
176 // by
177 // an included jar
178 writeSkeletonInstaller();
179
180         writeInstallerObject("info", info);
181         writeInstallerObject("vars", variables);
182         writeInstallerObject("GUIPrefs", guiPrefs);
183         writeInstallerObject("panelsOrder", panelList);
184         writeInstallerObject("customData", customDataList);
185         writeInstallerObject("langpacks.info", langpackNameList);
186         writeInstallerResources();
187         writeIncludedJars();
188
189         // Pack File Data may be written to separate jars
190 writePacks();
191
192         // Finish up. closeAlways is a hack for pack compressions other than
193 // default. Some of it (e.g. BZip2) closes the slave of it also.
194 // But this should not be because the jar stream should be open
195 // for the next pack. Therefore an own JarOutputStream will be used
196 // which close method will be blocked.
197 primaryJarStream.closeAlways();
198
199         sendStop();
200     }
201
202     /***********************************************************************************************
203      * Listener assistance
204      **********************************************************************************************/
205
206     /* (non-Javadoc)
207      * @see com.izforge.izpack.compiler.IPackager#getPackagerListener()
208      */
209     public PackagerListener getPackagerListener()
210     {
211         return listener;
212     }
213     /* (non-Javadoc)
214      * @see com.izforge.izpack.compiler.IPackager#setPackagerListener(com.izforge.izpack.compiler.PackagerListener)
215      */
216     public void setPackagerListener(PackagerListener listener)
217     {
218         this.listener = listener;
219     }
220
221     /**
222      * Dispatches a message to the listeners.
223      *
224      * @param job The job description.
225      */
226     private void sendMsg(String job)
227     {
228         sendMsg(job, PackagerListener.MSG_INFO);
229     }
230
231     /**
232      * Dispatches a message to the listeners at specified priority.
233      *
234      * @param job The job description.
235      * @param priority The message priority.
236      */
237     private void sendMsg(String job, int priority)
238     {
239         if (listener != null) listener.packagerMsg(job, priority);
240     }
241
242     /** Dispatches a start event to the listeners. */
243     private void sendStart()
244     {
245         if (listener != null) listener.packagerStart();
246     }
247
248     /** Dispatches a stop event to the listeners. */
249     private void sendStop()
250     {
251         if (listener != null) listener.packagerStop();
252     }
253
254     /***********************************************************************************************
255      * Public methods to add data to the Installer being packed
256      **********************************************************************************************/
257
258     /* (non-Javadoc)
259      * @see com.izforge.izpack.compiler.IPackager#setInfo(com.izforge.izpack.Info)
260      */
261     public void setInfo(Info info) throws Exception
262     {
263         sendMsg("Setting the installer information", PackagerListener.MSG_VERBOSE);
264         this.info = info;
265         if( ! getCompressor().useStandardCompression() &&
266                 getCompressor().getDecoderMapperName() != null )
267         {
268             this.info.setPackDecoderClassName(getCompressor().getDecoderMapperName());
269         }
270     }
271
272     /* (non-Javadoc)
273      * @see com.izforge.izpack.compiler.IPackager#setGUIPrefs(com.izforge.izpack.GUIPrefs)
274      */
275     public void setGUIPrefs(GUIPrefs prefs)
276     {
277         sendMsg("Setting the GUI preferences", PackagerListener.MSG_VERBOSE);
278         guiPrefs = prefs;
279     }
280
281     /* (non-Javadoc)
282      * @see com.izforge.izpack.compiler.IPackager#getVariables()
283      */
284     public Properties getVariables()
285     {
286         return variables;
287     }
288
289     /* (non-Javadoc)
290      * @see com.izforge.izpack.compiler.IPackager#addPanelJar(com.izforge.izpack.Panel, java.net.URL)
291      */
292     public void addPanelJar(Panel panel, URL jarURL)
293     {
294         panelList.add(panel); // serialized to keep order/variables correct
295 addJarContent(jarURL); // each included once, no matter how many times
296 // added
297 }
298
299     /* (non-Javadoc)
300      * @see com.izforge.izpack.compiler.IPackager#addCustomJar(com.izforge.izpack.CustomData, java.net.URL)
301      */
302     public void addCustomJar(CustomData ca, URL url)
303     {
304         customDataList.add(ca); // serialized to keep order/variables correct
305 addJarContent(url); // each included once, no matter how many times
306 // added
307 }
308
309     /* (non-Javadoc)
310      * @see com.izforge.izpack.compiler.IPackager#addPack(com.izforge.izpack.compiler.PackInfo)
311      */
312     public void addPack(PackInfo pack)
313     {
314         packsList.add(pack);
315     }
316
317     /* (non-Javadoc)
318      * @see com.izforge.izpack.compiler.IPackager#getPacksList()
319      */
320     public List getPacksList()
321     {
322         return packsList;
323     }
324
325     /* (non-Javadoc)
326      * @see com.izforge.izpack.compiler.IPackager#addLangPack(java.lang.String, java.net.URL, java.net.URL)
327      */
328     public void addLangPack(String iso3, URL xmlURL, URL flagURL)
329     {
330         sendMsg("Adding langpack: " + iso3, PackagerListener.MSG_VERBOSE);
331         // put data & flag as entries in installer, and keep array of iso3's
332 // names
333 langpackNameList.add(iso3);
334         addResource("flag." + iso3, flagURL);
335         installerResourceURLMap.put("langpacks/" + iso3 + ".xml", xmlURL);
336     }
337
338     /* (non-Javadoc)
339      * @see com.izforge.izpack.compiler.IPackager#addResource(java.lang.String, java.net.URL)
340      */
341     public void addResource(String resId, URL url)
342     {
343         sendMsg("Adding resource: " + resId, PackagerListener.MSG_VERBOSE);
344         installerResourceURLMap.put("res/" + resId, url);
345     }
346
347     /* (non-Javadoc)
348      * @see com.izforge.izpack.compiler.IPackager#addNativeLibrary(java.lang.String, java.net.URL)
349      */
350     public void addNativeLibrary(String name, URL url) throws Exception
351     {
352         sendMsg("Adding native library: " + name, PackagerListener.MSG_VERBOSE);
353         installerResourceURLMap.put("native/" + name, url);
354     }
355
356
357     /* (non-Javadoc)
358      * @see com.izforge.izpack.compiler.IPackager#addJarContent(java.net.URL)
359      */
360     public void addJarContent(URL jarURL)
361     {
362         addJarContent(jarURL, null);
363     }
364     /* (non-Javadoc)
365      * @see com.izforge.izpack.compiler.IPackager#addJarContent(java.net.URL, java.util.List)
366      */
367     public void addJarContent(URL jarURL, List files)
368     {
369         Object [] cont = { jarURL, files };
370         sendMsg("Adding content of jar: " + jarURL.getFile(), PackagerListener.MSG_VERBOSE);
371         includedJarURLs.add(cont);
372     }
373
374     /* (non-Javadoc)
375      * @see com.izforge.izpack.compiler.IPackager#addNativeUninstallerLibrary(com.izforge.izpack.CustomData)
376      */
377     public void addNativeUninstallerLibrary(CustomData data)
378     {
379         customDataList.add(data); // serialized to keep order/variables
380 // correct
381
382     }
383
384     /***********************************************************************************************
385      * Private methods used when writing out the installer to jar files.
386      **********************************************************************************************/
387
388     /**
389      * Write skeleton installer to primary jar. It is just an included jar, except that we copy the
390      * META-INF as well.
391      */
392     private void writeSkeletonInstaller() throws IOException
393     {
394         sendMsg("Copying the skeleton installer", PackagerListener.MSG_VERBOSE);
395
396         InputStream is = Packager.class.getResourceAsStream("/" + SKELETON_SUBPATH);
397         if (is == null)
398         {
399             File skeleton = new File (Compiler.IZPACK_HOME, SKELETON_SUBPATH);
400             is = new FileInputStream (skeleton);
401         }
402         ZipInputStream inJarStream = new ZipInputStream (is);
403         copyZip(inJarStream, primaryJarStream);
404     }
405
406     /**
407      * Write an arbitrary object to primary jar.
408      */
409     private void writeInstallerObject(String entryName, Object object) throws IOException
410     {
411         primaryJarStream.putNextEntry(new org.apache.tools.zip.ZipEntry(entryName));
412         ObjectOutputStream out = new ObjectOutputStream (primaryJarStream);
413         out.writeObject(object);
414         out.flush();
415         primaryJarStream.closeEntry();
416     }
417
418     /** Write the data referenced by URL to primary jar. */
419     private void writeInstallerResources() throws IOException
420     {
421         sendMsg("Copying " + installerResourceURLMap.size() + " files into installer");
422
423         Iterator i = installerResourceURLMap.keySet().iterator();
424         while (i.hasNext())
425         {
426             String name = (String ) i.next();
427             InputStream in = ((URL ) installerResourceURLMap.get(name)).openStream();
428             primaryJarStream.putNextEntry(new org.apache.tools.zip.ZipEntry(name));
429             PackagerHelper.copyStream(in, primaryJarStream);
430             primaryJarStream.closeEntry();
431             in.close();
432         }
433     }
434
435     /** Copy included jars to primary jar. */
436     private void writeIncludedJars() throws IOException
437     {
438         sendMsg("Merging " + includedJarURLs.size() + " jars into installer");
439
440         Iterator i = includedJarURLs.iterator();
441         while (i.hasNext())
442         {
443             Object [] current = (Object []) i.next();
444             InputStream is = ((URL ) current[0]).openStream();
445             ZipInputStream inJarStream = new ZipInputStream (is);
446             copyZip(inJarStream, primaryJarStream, (List ) current[1]);
447         }
448     }
449
450     /**
451      * Write Packs to primary jar or each to a separate jar.
452      */
453     private void writePacks() throws Exception
454     {
455         final int num = packsList.size();
456         sendMsg("Writing " + num + " Pack" + (num > 1 ? "s" : "") + " into installer");
457
458         // Map to remember pack number and bytes offsets of back references
459 Map storedFiles = new HashMap ();
460
461         // First write the serialized files and file metadata data for each pack
462 // while counting bytes.
463
464         int packNumber = 0;
465         Iterator packIter = packsList.iterator();
466         while (packIter.hasNext())
467         {
468             PackInfo packInfo = (PackInfo) packIter.next();
469             Pack pack = packInfo.getPack();
470             pack.nbytes = 0;
471
472             // create a pack specific jar if required
473 com.izforge.izpack.util.JarOutputStream packStream = primaryJarStream;
474             if (packJarsSeparate)
475             {
476                 // See installer.Unpacker#getPackAsStream for the counterpart
477 String name = baseFile.getName() + ".pack" + packNumber + ".jar";
478                 packStream = getJarOutputStream(name);
479             }
480             OutputStream comprStream = packStream;
481
482             sendMsg("Writing Pack " + packNumber + ": " + pack.name, PackagerListener.MSG_VERBOSE);
483
484             // Retrieve the correct output stream
485 org.apache.tools.zip.ZipEntry entry =
486                 new org.apache.tools.zip.ZipEntry("packs/pack" + packNumber);
487             if( ! compressor.useStandardCompression())
488             {
489                 entry.setMethod(org.apache.tools.zip.ZipEntry.STORED);
490                 entry.setComment(compressor.getCompressionFormatSymbols()[0]);
491                 // We must set the entry before we get the compressed stream
492 // because some writes initialize data (e.g. bzip2).
493 packStream.putNextEntry(entry);
494                 packStream.flush(); // flush before we start counting
495 comprStream = compressor.getOutputStream(packStream);
496             }
497             else
498             {
499                 int level = compressor.getCompressionLevel();
500                 if( level >= 0 && level < 10 )
501                     packStream.setLevel(level);
502                 packStream.putNextEntry(entry);
503                 packStream.flush(); // flush before we start counting
504 }
505
506             ByteCountingOutputStream dos = new ByteCountingOutputStream(comprStream);
507             ObjectOutputStream objOut = new ObjectOutputStream (dos);
508
509             // We write the actual pack files
510 objOut.writeInt(packInfo.getPackFiles().size());
511
512             Iterator iter = packInfo.getPackFiles().iterator();
513             while (iter.hasNext())
514             {
515                 boolean addFile = !pack.loose;
516                 PackFile pf = (PackFile) iter.next();
517                 File file = packInfo.getFile(pf);
518
519                 // use a back reference if file was in previous pack, and in
520 // same jar
521 long[] info = (long[]) storedFiles.get(file);
522                 if (info != null && !packJarsSeparate)
523                 {
524                     pf.setPreviousPackFileRef((int) info[0], info[1]);
525                     addFile = false;
526                 }
527
528                 objOut.writeObject(pf); // base info
529 objOut.flush(); // make sure it is written
530
531                 if (addFile && !pf.isDirectory())
532                 {
533                     long pos = dos.getByteCount(); // get the position
534
535                     FileInputStream inStream = new FileInputStream (file);
536                     long bytesWritten = PackagerHelper.copyStream(inStream, objOut);
537
538                     if (bytesWritten != pf.length())
539                         throw new IOException ("File size mismatch when reading " + file);
540
541                     inStream.close();
542                     storedFiles.put(file, new long[] { packNumber, pos});
543                 }
544
545                 // even if not written, it counts towards pack size
546 pack.nbytes += pf.length();
547             }
548
549             // Write out information about parsable files
550 objOut.writeInt(packInfo.getParsables().size());
551             iter = packInfo.getParsables().iterator();
552             while (iter.hasNext())
553                 objOut.writeObject(iter.next());
554
555             // Write out information about executable files
556 objOut.writeInt(packInfo.getExecutables().size());
557             iter = packInfo.getExecutables().iterator();
558             while (iter.hasNext())
559                 objOut.writeObject(iter.next());
560
561             // Write out information about updatecheck files
562 objOut.writeInt(packInfo.getUpdateChecks().size());
563             iter = packInfo.getUpdateChecks().iterator();
564             while (iter.hasNext())
565                 objOut.writeObject(iter.next());
566
567             // Cleanup
568 objOut.flush();
569             if( ! compressor.useStandardCompression())
570             {
571                 comprStream.close();
572             }
573
574             packStream.closeEntry();
575
576             // close pack specific jar if required
577 if (packJarsSeparate) packStream.closeAlways();
578
579             packNumber++;
580         }
581
582         // Now that we know sizes, write pack metadata to primary jar.
583 primaryJarStream.putNextEntry(new org.apache.tools.zip.ZipEntry("packs.info"));
584         ObjectOutputStream out = new ObjectOutputStream (primaryJarStream);
585         out.writeInt(packsList.size());
586
587         Iterator i = packsList.iterator();
588         while (i.hasNext())
589         {
590             PackInfo pack = (PackInfo) i.next();
591             out.writeObject(pack.getPack());
592         }
593         out.flush();
594         primaryJarStream.closeEntry();
595     }
596
597     /***********************************************************************************************
598      * Stream utilites for creation of the installer.
599      **********************************************************************************************/
600
601     /** Return a stream for the next jar. */
602     private com.izforge.izpack.util.JarOutputStream getJarOutputStream(String name) throws IOException
603     {
604         File file = new File (baseFile.getParentFile(), name);
605         sendMsg("Building installer jar: " + file.getAbsolutePath());
606
607         com.izforge.izpack.util.JarOutputStream jar =
608             new com.izforge.izpack.util.JarOutputStream(file);
609         jar.setLevel(Deflater.BEST_COMPRESSION);
610         jar.setPreventClose(true); // Needed at using FilterOutputStreams which calls close
611 // of the slave at finalizing.
612
613         return jar;
614     }
615
616     /**
617      * Copies contents of one jar to another.
618      *
619      * <p>
620      * TODO: it would be useful to be able to keep signature information from signed jar files, can
621      * we combine manifests and still have their content signed?
622      *
623      * @see #copyStream(InputStream, OutputStream)
624      */
625     private void copyZip(ZipInputStream zin, org.apache.tools.zip.ZipOutputStream out) throws IOException
626     {
627         copyZip( zin, out, null );
628     }
629
630     /**
631      * Copies specified contents of one jar to another.
632      *
633      * <p>
634      * TODO: it would be useful to be able to keep signature information from signed jar files, can
635      * we combine manifests and still have their content signed?
636      *
637      * @see #copyStream(InputStream, OutputStream)
638      */
639     private void copyZip(ZipInputStream zin, org.apache.tools.zip.ZipOutputStream out,
640             List files)
641     throws IOException
642     {
643         java.util.zip.ZipEntry zentry;
644         if( ! alreadyWrittenFiles.containsKey( out ))
645             alreadyWrittenFiles.put(out, new HashSet ());
646         HashSet currentSet = (HashSet ) alreadyWrittenFiles.get(out);
647         while ((zentry = zin.getNextEntry()) != null)
648         {
649             String currentName = zentry.getName();
650             String testName = currentName.replace('/', '.');
651             testName = testName.replace('\\', '.');
652             if( files != null )
653             {
654                 Iterator i = files.iterator();
655                 boolean founded = false;
656                 while( i.hasNext())
657                 { // Make "includes" self to support regex.
658 String doInclude = (String ) i.next();
659                     if( testName.matches( doInclude ) )
660                     {
661                         founded = true;
662                         break;
663                     }
664                 }
665                 if( ! founded )
666                     continue;
667             }
668             if( currentSet.contains(currentName))
669                 continue;
670             try
671             {
672                 out.putNextEntry(new org.apache.tools.zip.ZipEntry(currentName));
673                 PackagerHelper.copyStream(zin, out);
674                 out.closeEntry();
675                 zin.closeEntry();
676                 currentSet.add(currentName);
677             }
678             catch (ZipException x)
679             {
680                 // This avoids any problem that can occur with duplicate
681 // directories. for instance all META-INF data in jars
682 // unfortunately this do not work with the apache ZipOutputStream...
683 }
684         }
685     }
686     
687     /* (non-Javadoc)
688      * @see com.izforge.izpack.compiler.IPackager#getCompressor()
689      */
690     public PackCompressor getCompressor()
691     {
692         return compressor;
693     }
694
695     public void initPackCompressor(String compr_format, int compr_level) throws CompilerException
696     {
697         compressor = PackCompressorFactory.get( compr_format);
698         compressor.setCompressionLevel(compr_level);
699     }
700
701     public void addConfigurationInformation(XMLElement data)
702     {
703         // TODO Auto-generated method stub
704
705     }
706 }
707

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags