1. Update release note to use jdk1.5.0_06 to take place of jdk1.5.0_04
[mirror_edk2.git] / Tools / Source / FrameworkWizard / src / org / tianocore / frameworkwizard / far / Mainfest.java
1 /** @file
2
3 The file is used to create Far's mainfest file
4
5 Copyright (c) 2006, Intel Corporation
6 All rights reserved. This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15 package org.tianocore.frameworkwizard.far;
16
17 import java.io.File;
18 import java.io.FileInputStream;
19 import java.io.IOException;
20 import java.io.InputStream;
21 import java.util.ArrayList;
22 import java.util.Iterator;
23 import java.util.LinkedHashSet;
24 import java.util.List;
25 import java.util.Set;
26 import java.util.regex.Matcher;
27 import java.util.regex.Pattern;
28
29 import javax.xml.parsers.DocumentBuilder;
30 import javax.xml.parsers.DocumentBuilderFactory;
31 import javax.xml.transform.OutputKeys;
32 import javax.xml.transform.Result;
33 import javax.xml.transform.Source;
34 import javax.xml.transform.Transformer;
35 import javax.xml.transform.TransformerFactory;
36 import javax.xml.transform.dom.DOMSource;
37 import javax.xml.transform.stream.StreamResult;
38
39 import org.apache.xmlbeans.XmlException;
40 import org.tianocore.frameworkwizard.common.Tools;
41 import org.tianocore.frameworkwizard.packaging.PackageIdentification;
42 import org.tianocore.frameworkwizard.platform.PlatformIdentification;
43 import org.tianocore.frameworkwizard.workspace.Workspace;
44 import org.w3c.dom.Document;
45 import org.w3c.dom.Element;
46 import org.w3c.dom.NamedNodeMap;
47 import org.w3c.dom.Node;
48 import org.w3c.dom.NodeList;
49
50 public class Mainfest implements ManifestInterface {
51 // /
52 // / mainfest document
53 // /
54 Document mainfestDoc = null;
55
56 // /
57 // / Mainfest file element name
58 // /
59 final static String mfFileName = "FarMainfest.MF";
60
61 //
62 // Header
63 //
64 final static String farHeader = "FarHeader";
65
66 final static String farHeader_FarName = "FarName";
67
68 final static String farHeader_Abstract = "Abstract";
69
70 final static String farHeader_Description = "Description";
71
72 final static String farHeader_CopyRight = "CopyRight";
73
74 final static String farHeader_License = "Licese";
75
76 final static String farHeader_Specification = "Specification";
77
78 //
79 // Package list
80 //
81 final static String farPackageList = "FarPackageList";
82
83 final static String farPlatformList = "FarPlatformList";
84
85 final static String contents = "Contents";
86
87 final static String userExtensions = "UserExtensions";
88
89 //
90 // Common node name
91 //
92
93 final static String guidValue = "GuidValue";
94
95 final static String version = "Version";
96
97 //
98 // FarPackage node name
99 //
100 final static String farPackageList_FarPackage = "FarPackage";
101
102 final static String farPackage_FarfileName = "FarFileName";
103
104 final static String farPackage_DefaultPath = "DefaultPath";
105
106 final static String farPlatformList_FarPlatform = "FarPlatform";
107
108 final static String farFileName_FarGuid = "FarGuid";
109
110 final static String farFileName_Md5sum = "Md5sum";
111
112 //
113 // mainfest header information.
114 //
115 FarHeader fhInfo = new FarHeader();
116
117 //
118 // FarPackage list
119 //
120 List<FarPackage> fPkgList = new ArrayList<FarPackage>();
121
122 //
123 // FarPlatform list
124 //
125 List<FarPlatformItem> fPlfList = new ArrayList<FarPlatformItem>();
126
127 Set<File> files = new LinkedHashSet<File>();
128
129 //
130 // Mainfest file
131 //
132 File mfFile = null;
133
134 public FarHeader getHeader() {
135 return fhInfo;
136 }
137
138 public Mainfest() throws Exception {
139 DocumentBuilderFactory domfac = DocumentBuilderFactory.newInstance();
140 DocumentBuilder dombuilder = domfac.newDocumentBuilder();
141 Document document = dombuilder.newDocument();
142 this.mainfestDoc = document;
143
144 }
145
146 public Mainfest(InputStream mainfestInputStream) throws Exception {
147 DocumentBuilderFactory domfac = DocumentBuilderFactory.newInstance();
148 try {
149 if (mainfestInputStream != null) {
150 DocumentBuilder dombuilder = domfac.newDocumentBuilder();
151 this.mainfestDoc = dombuilder.parse(mainfestInputStream);
152 parseMainfest();
153 }
154
155 } catch (Exception e) {
156 //
157 // Will change to throw Wizader exception.
158 //
159 throw new Exception(e.getMessage());
160 }
161 }
162
163 public void setFarHeader(FarHeader fHeader) {
164 this.fhInfo = fHeader;
165 }
166
167 public void createManifest(List<PackageIdentification> pkgList, List<PlatformIdentification> plfList,
168 Set<String> fileFilter) throws Exception {
169
170 //
171 // Add Package and it's contents to FarPackageList.
172 //
173 Iterator<PackageIdentification> pkgItem = pkgList.iterator();
174 while (pkgItem.hasNext()) {
175 PackageIdentification pkgId = pkgItem.next();
176
177 //
178 // Add package and it's contents to <FarPackageList>.
179 //
180 addPkgToPkgList(pkgId, fileFilter);
181 }
182
183 //
184 // Add FarPlatform to this.farPlatformList.
185 //
186 Iterator<PlatformIdentification> plfItem = plfList.iterator();
187 while (plfItem.hasNext()) {
188 PlatformIdentification plfId = plfItem.next();
189
190 //
191 // Add platform to Mainifest.
192 //
193 addPlatformIdToFarPlatformItemList(plfId);
194 }
195 }
196
197 public void setManifestFile(File mainfestFile) throws Exception {
198 DocumentBuilderFactory domfac = DocumentBuilderFactory.newInstance();
199 DocumentBuilder dombuilder = domfac.newDocumentBuilder();
200 InputStream is = new FileInputStream(mainfestFile);
201 this.mainfestDoc = dombuilder.parse(is);
202 }
203
204 public void addPkgToPkgList(PackageIdentification packageId, Set<String> fileFilter) throws Exception {
205 files.add(packageId.getSpdFile());
206
207 FarPackage farPackage = new FarPackage();
208 //
209 // Add SPD file to FarPackage
210 //
211 File spdFile = new File(packageId.getPath());
212
213 FarFileItem ffItem = new FarFileItem(spdFile.getName(), FarMd5.md5(spdFile));
214 farPackage.setFarFile(ffItem);
215
216 //
217 // Add package guid value.
218 //
219 farPackage.setGuidValue(packageId.getGuid());
220
221 //
222 // Add package version
223 //
224 farPackage.setVersion(packageId.getVersion());
225
226 //
227 // Add DefaultPat: Package absoulte path - Workspace absolut
228 // path.
229 //
230 String pkgDir = Tools.getFilePathOnly(packageId.getPath());
231 File rootDir = new File(pkgDir);
232 farPackage.setDefaultPath(Tools.getRelativePath(rootDir.getPath(), Workspace.getCurrentWorkspace()));
233
234 //
235 // Get package root dir contains.
236 //
237 Set<File> fileSet = new LinkedHashSet<File>();
238 Set<File> fpdFileSet = new LinkedHashSet<File>();
239
240 //
241 // Get all files and fpd files
242 //
243 recursiveDirectory(fileSet, fpdFileSet, rootDir, fileFilter);
244
245 //
246 // Remove current package's SPD file
247 //
248 fileSet.remove(packageId.getSpdFile());
249
250 files.addAll(fileSet);
251
252 Iterator<File> iter = fileSet.iterator();
253 List<FarFileItem> contents = new ArrayList<FarFileItem>();
254 while (iter.hasNext()) {
255 File normalFile = iter.next();
256 String fileRelativePath = Tools.getRelativePath(normalFile.getPath(), pkgDir);
257 ffItem = new FarFileItem(fileRelativePath, FarMd5.md5(normalFile));
258 contents.add(ffItem);
259 }
260
261 farPackage.setContentList(contents);
262
263 // List<FarPlatformItem> fpfList = new ArrayList<FarPlatformItem>();
264 //
265 // iter = fpdFileSet.iterator();
266 //
267 // while (iter.hasNext()) {
268 // File fpdFile = iter.next();
269 // PlatformIdentification platformId = new PlatformIdentification(wsTool
270 // .getId(fpdFile.getPath(), OpenFile.openFpdFile(fpdFile
271 // .getPath())));
272 // addPlatformIdToFarPlatformItemList(fpfList, platformId);
273 // }
274 // farPackage.setFarPlatformList(fpfList);
275 fPkgList.add(farPackage);
276 }
277
278 private void recursiveDirectory(Set<File> files, Set<File> fpds, File dir, Set<String> fileFilter) {
279 if (isFilter(dir, fileFilter)) {
280 return;
281 }
282 File[] allFilesInDir = dir.listFiles();
283 for (int i = 0; i < allFilesInDir.length; i++) {
284 if (allFilesInDir[i].isFile()) {
285 if (isFilter(allFilesInDir[i], fileFilter)) {
286 continue;
287 }
288 // if (allFilesInDir[i].getPath().toLowerCase().endsWith(".fpd")) {
289 // fpds.add(allFilesInDir[i]);
290 // } else {
291 files.add(allFilesInDir[i]);
292 // }
293 } else {
294 recursiveDirectory(files, fpds, allFilesInDir[i], fileFilter);
295 }
296 }
297 }
298
299 public void addPlatformIdToFarPlatformItemList(PlatformIdentification platformId) throws Exception {
300 files.add(platformId.getFpdFile());
301
302 FarPlatformItem fpfItem = new FarPlatformItem();
303 FarFileItem ffItem;
304 String fpfPath = platformId.getPath();
305 File fpfFile = new File(fpfPath);
306 //
307 // Add farFileName
308 //
309 ffItem = new FarFileItem(Tools.getRelativePath(fpfFile.getPath(), Workspace.getCurrentWorkspace()),
310 FarMd5.md5(fpfFile));
311 fpfItem.setFarFile(ffItem);
312
313 //
314 // Add guid value
315 //
316 fpfItem.setGuidValue(platformId.getGuid());
317
318 //
319 // Add version
320 //
321 fpfItem.setVersion(platformId.getVersion());
322
323 fPlfList.add(fpfItem);
324 }
325
326 /**
327 *
328 * @param
329 * @return Set<PackageIdentification> list of PackageIdentification.
330 */
331 public List<PackageIdentification> getPackageList() throws Exception {
332 //
333 // PackageIdentification set.
334 //
335 List<PackageIdentification> pkgList = new ArrayList<PackageIdentification>();
336 //
337 //
338 //
339 Iterator pkgItem = this.fPkgList.iterator();
340 while (pkgItem.hasNext()) {
341 FarPackage fPkg = (FarPackage) pkgItem.next();
342 //
343 // Get package information from SPD file and create a package
344 // identification.
345 //
346
347 PackageIdentification pkgId = new PackageIdentification(fPkg.getFarFile().getRelativeFilename(),
348 fPkg.getGuidValue(), fPkg.getVersion());
349 pkgId.setPath(Workspace.getCurrentWorkspace() + File.separatorChar + fPkg.getDefaultPath()
350 + File.separatorChar + fPkg.getFarFile().getRelativeFilename());
351 // wsTool.getId(
352 // Workspace.getCurrentWorkspace() + File.separatorChar
353 // + fPkg.getDefaultPath(), OpenFile
354 // .openFpdFile(Workspace.getCurrentWorkspace()
355 // + File.separatorChar
356 // + fPkg.getDefaultPath()
357 // + File.separatorChar
358 // + fPkg.getFarFile().getRelativeFilename()));
359 pkgList.add(pkgId);
360 }
361 return pkgList;
362 }
363
364 /**
365 *
366 */
367 public List<PlatformIdentification> getPlatformList() throws Exception, IOException, XmlException {
368 //
369 // PlatformIdentification set.
370 //
371 List<PlatformIdentification> plfList = new ArrayList<PlatformIdentification>();
372 Iterator plfItem = this.fPlfList.iterator();
373 while (plfItem.hasNext()) {
374 FarPlatformItem fpfItem = (FarPlatformItem) plfItem.next();
375 File file = new File(Workspace.getCurrentWorkspace() + File.separatorChar
376 + fpfItem.getFarFile().getRelativeFilename());
377 //
378 // Set platformIdentificaiton's path as absolutly path (include
379 // workspace and FPD relatively path)
380 //
381 PlatformIdentification plfId = new PlatformIdentification(fpfItem.getFarFile().getRelativeFilename(),
382 fpfItem.getGuidValue(), fpfItem.getVersion(),
383 file.getPath());
384
385 // (PlatformIdentification) wsTool
386 // .getId(file.getParent(), OpenFile.openFpdFile(Workspace
387 // .getCurrentWorkspace()
388 // + File.separatorChar
389 // + fpfItem.getFarFile().getRelativeFilename()));
390 plfList.add(plfId);
391 }
392 return plfList;
393 }
394
395 public List<FarFileItem> getPlatformContents(PlatformIdentification platformId) {
396 List<FarFileItem> result = new ArrayList<FarFileItem>();
397 Iterator<FarPlatformItem> iter = this.fPlfList.iterator();
398
399 while (iter.hasNext()) {
400 FarPlatformItem item = iter.next();
401 if (item.isIdentityPlf(platformId)) {
402 FarFileItem farFileItem = item.getFarFile();
403 farFileItem.setDefaultPath(farFileItem.getRelativeFilename());
404 farFileItem.setRelativeFilename(Tools.getFileNameOnly(farFileItem.getRelativeFilename()));
405 result.add(farFileItem);
406 break;
407 }
408 }
409 return result;
410 }
411
412 public List<FarFileItem> getPackageContents(PackageIdentification packageId) {
413 List<FarFileItem> farFileList = new ArrayList<FarFileItem>();
414 Iterator pkgItem = this.fPkgList.iterator();
415 while (pkgItem.hasNext()) {
416 FarPackage pkg = (FarPackage) pkgItem.next();
417 if (pkg.isIdentityPkg(packageId)) {
418 //
419 // Add spd far file to list.
420 //
421 farFileList.add(pkg.getFarFile());
422 //
423 // Add all files in contents to list.
424 //
425 farFileList.addAll(pkg.getContentList());
426 //
427 // Add all farfiles in <FarPlatformList> to list.
428 //
429 // List<FarPlatformItem> plfList = pkg.getFarPlatformList();
430 // Iterator plfItem = plfList.iterator();
431 // while (plfItem.hasNext()) {
432 // farFileList.add(((FarPlatformItem) plfItem.next())
433 // .getFarFile());
434 // }
435
436 Iterator<FarFileItem> ffIter = farFileList.iterator();
437 while (ffIter.hasNext()) {
438 FarFileItem ffItem = ffIter.next();
439 ffItem.setDefaultPath(pkg.getDefaultPath() + File.separatorChar + ffItem.getRelativeFilename());
440 }
441 break;
442 }
443 }
444
445 return farFileList;
446 }
447
448 /**
449 *
450 * @param pkgId
451 * @return String: return string represent jar file entry;
452 */
453 public String[] getPackgeSpd(PackageIdentification pkgId) {
454 Iterator pkgItem = this.fPkgList.iterator();
455 String[] entryStr = new String[2];
456 while (pkgItem.hasNext()) {
457 FarPackage pkg = (FarPackage) pkgItem.next();
458 if (pkg.isIdentityPkg(pkgId)) {
459 entryStr[0] = pkg.getFarFile().getRelativeFilename();
460 entryStr[1] = pkg.getDefaultPath();
461 return entryStr;
462 }
463 }
464 return null;
465 }
466
467 public List<FarFileItem> getPackageContents() {
468 //
469 // In this farFilelist,all FarFileItem's relativeFileName should be
470 // set as absolutely path.
471 //
472 List<FarFileItem> farFileList = new ArrayList<FarFileItem>();
473 Iterator pkgItem = this.fPkgList.iterator();
474 FarFileItem ffItem = null;
475
476 while (pkgItem.hasNext()) {
477 FarPackage pkg = (FarPackage) pkgItem.next();
478
479 //
480 // Add spd far file to list.
481 //
482 ffItem = pkg.getFarFile();
483 //
484 // Set farFileItem relativeFileName = absolutePath + file Name.
485 //
486 farFileList.add(new FarFileItem(pkg.getDefaultPath() + File.separatorChar + ffItem.getRelativeFilename(),
487 ffItem.getMd5Value()));
488 //
489 // Add all files in contents to list.
490 //
491 Iterator contentsItem = pkg.getContentList().iterator();
492 while (contentsItem.hasNext()) {
493 ffItem = (FarFileItem) contentsItem.next();
494 farFileList.add(new FarFileItem(pkg.getDefaultPath() + File.separator + ffItem.getRelativeFilename(),
495 ffItem.getMd5Value()));
496 }
497 //
498 // Add all farfiles in <FarPlatformList> to list.
499 //
500 List<FarPlatformItem> plfList = pkg.getFarPlatformList();
501 Iterator plfItem = plfList.iterator();
502 while (plfItem.hasNext()) {
503 ffItem = ((FarPlatformItem) plfItem.next()).getFarFile();
504 farFileList.add(new FarFileItem(pkg.getDefaultPath() + File.separator + ffItem.getRelativeFilename(),
505 ffItem.getMd5Value()));
506 }
507 }
508 return farFileList;
509 }
510
511 public String getPackageDefaultPath(PackageIdentification packageId) {
512 Iterator pkgItr = this.fPkgList.iterator();
513 while (pkgItr.hasNext()) {
514 FarPackage farPackage = (FarPackage) pkgItr.next();
515 if (farPackage.isIdentityPkg(packageId)) {
516 return farPackage.getDefaultPath();
517 }
518 }
519 return null;
520 }
521
522 // public void setPackageInstallPath(PackageIdentification packageId, String path) {
523 // Iterator<FarPackage> pkgItr = this.fPkgList.iterator();
524 // while (pkgItr.hasNext()) {
525 // FarPackage farPackage = pkgItr.next();
526 // if (farPackage.isIdentityPkg(packageId)) {
527 // farPackage.setDefaultPath(path);
528 // return ;
529 // }
530 // }
531 // }
532 //
533 // public void setPlatformInstallPath(PlatformIdentification platformId, String path) {
534 // Iterator<FarPlatformItem> plfItr = this.fPlfList.iterator();
535 // while (plfItr.hasNext()) {
536 // FarPlatformItem farPlatform = plfItr.next();
537 // if (farPlatform.i.isIdentity(platformId)) {
538 // farPackage.setDefaultPath(path);
539 // return ;
540 // }
541 // }
542 // }
543
544 public List<FarFileItem> getAllFileItem() {
545 //
546 // The farFileName in this list are all abosulte path.
547 //
548 List<FarFileItem> ffiList = new ArrayList<FarFileItem>();
549 //
550 // Add far files in <FarPackageList> to list.
551 //
552 ffiList = this.getPackageContents();
553
554 //
555 // Add far files in <FarPlatformList> to list
556 //
557 NodeList elementList = this.mainfestDoc.getElementsByTagName(farPlatformList);
558 for (int i = 0; i < elementList.getLength(); i++) {
559 //
560 // Get <farPlatform> node list.
561 //
562 Node item = elementList.item(i);
563 NodeList plfElements = item.getChildNodes();
564 for (int j = 0; j < plfElements.getLength(); j++) {
565 //
566 // Get each <FarPlatform> content.
567 //
568 NodeList plfChildNode = plfElements.item(i).getChildNodes();
569 Node tempNode = null;
570 for (int t = 0; t < plfChildNode.getLength(); t++) {
571 tempNode = plfChildNode.item(t);
572 //
573 // Get child node value and set to platformIdentification.
574 //
575 if (tempNode.getNodeName().equalsIgnoreCase(farPackage_FarfileName)) {
576 NamedNodeMap farAttr = tempNode.getAttributes();
577 //
578 // Change relative path to absolute one
579 //
580 FarFileItem farFile = new FarFileItem(tempNode.getTextContent(),
581 farAttr.getNamedItem(farFileName_Md5sum).getTextContent());
582 ffiList.add(farFile);
583 }
584 }
585 }
586 }
587 return ffiList;
588 }
589
590 public void hibernateToFile() throws Exception {
591 //
592 // create mainfest root node
593 //
594 Element rootNode = this.mainfestDoc.createElement("FrameworkArchiveManifest");
595 this.mainfestDoc.appendChild(rootNode);
596
597 //
598 // create mainfest header node
599 //
600 Element headerNode = this.mainfestDoc.createElement(farHeader);
601 rootNode.appendChild(headerNode);
602 //
603 // Add FarHeader to headerNode.
604 //
605 Element farName = this.mainfestDoc.createElement(farHeader_FarName);
606 farName.setTextContent(this.fhInfo.getFarName());
607 headerNode.appendChild(farName);
608
609 Element gv = this.mainfestDoc.createElement(guidValue);
610 gv.setTextContent(this.fhInfo.getGuidValue());
611 headerNode.appendChild(gv);
612
613 Element ver = this.mainfestDoc.createElement(version);
614 ver.setTextContent(this.fhInfo.getVersion());
615 headerNode.appendChild(ver);
616
617 Element abstra = this.mainfestDoc.createElement(farHeader_Abstract);
618 abstra.setTextContent(this.fhInfo.getAbstractStr());
619 headerNode.appendChild(abstra);
620
621 Element descr = this.mainfestDoc.createElement(farHeader_Description);
622 descr.setTextContent(this.fhInfo.getDescription());
623 headerNode.appendChild(descr);
624
625 Element copyright = this.mainfestDoc.createElement(farHeader_CopyRight);
626 copyright.setTextContent(this.fhInfo.getCopyright());
627 headerNode.appendChild(copyright);
628
629 Element license = this.mainfestDoc.createElement(farHeader_License);
630 license.setTextContent(this.fhInfo.getLicense());
631 headerNode.appendChild(license);
632
633 Element spec = this.mainfestDoc.createElement(farHeader_Specification);
634 spec.setTextContent(this.fhInfo.getSpecification());
635 System.out.println(this.fhInfo.getSpecification());
636 headerNode.appendChild(spec);
637
638 //
639 // create mainfest FarPackageList node
640 //
641 Element pkgListNode = this.mainfestDoc.createElement(farPackageList);
642 rootNode.appendChild(pkgListNode);
643
644 //
645 // Save each item in farPackage list to <FarPackage>.
646 //
647 Iterator pkgItem = this.fPkgList.iterator();
648 while (pkgItem.hasNext()) {
649 pkgToFarPkgNode(pkgListNode, (FarPackage) pkgItem.next());
650
651 }
652
653 //
654 // create mainfest FarPlatformList node
655 //
656 Element plfListNode = this.mainfestDoc.createElement(farPlatformList);
657 rootNode.appendChild(plfListNode);
658
659 //
660 // Save farPakcage list info to <FarPackageList> node
661 //
662 Iterator plfItem = this.fPlfList.iterator();
663 while (plfItem.hasNext()) {
664 FarPlatformItem plfIterator = (FarPlatformItem) plfItem.next();
665 PlfToPlatformNode(plfListNode, plfIterator);
666 }
667
668 //
669 // Write the DOM document to the file
670 //
671 Transformer xformer = TransformerFactory.newInstance().newTransformer();
672 xformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
673 xformer.setOutputProperty(OutputKeys.INDENT, "yes");
674
675 //
676 // Prepare the DOM document for writing
677 //
678 Source source = new DOMSource(this.mainfestDoc);
679 //
680 // Prepare the output file, get the Mainifest file name from <FarHeader>
681 // /<FarName>.
682 //
683 this.mfFile = new File(Workspace.getCurrentWorkspace() + File.separatorChar + mfFileName);
684 //
685 // generate all directory path
686 //
687 Result result = new StreamResult(this.mfFile);
688 xformer.transform(source, result);
689 }
690
691 public void pkgToFarPkgNode(Element parentNode, FarPackage pkgItem) {
692 Element pkgNode = this.mainfestDoc.createElement(farPackageList_FarPackage);
693 //
694 // Add <FarFileName>
695 //
696 ffiToFfNode(pkgNode, pkgItem.getFarFile());
697 //
698 // Add <GuidValue>
699 //
700 setStrItemToNode(pkgNode, pkgItem.getGuidValue(), guidValue);
701 //
702 // Add <Version>
703 //
704 setStrItemToNode(pkgNode, pkgItem.getVersion(), version);
705 //
706 // Add <DefaultPath>
707 //
708 setStrItemToNode(pkgNode, pkgItem.getDefaultPath(), farPackage_DefaultPath);
709
710 //
711 // Add <Contents>
712 //
713 Element contentNode = this.mainfestDoc.createElement(contents);
714 Iterator iterator = pkgItem.getContentList().iterator();
715 while (iterator.hasNext()) {
716 ffiToFfNode(contentNode, (FarFileItem) iterator.next());
717 }
718 pkgNode.appendChild(contentNode);
719 parentNode.appendChild(pkgNode);
720 }
721
722 public void PlfToPlatformNode(Element parentNode, FarPlatformItem fplItem) {
723 Element fplNode = this.mainfestDoc.createElement(farPlatformList_FarPlatform);
724 //
725 // Add <FarFileName>
726 //
727 ffiToFfNode(fplNode, fplItem.getFarFile());
728 //
729 // Add <GuidValue>
730 //
731 setStrItemToNode(fplNode, fplItem.getGuidValue(), guidValue);
732 //
733 // Add <Version>
734 //
735 setStrItemToNode(fplNode, fplItem.getVersion(), version);
736 //
737 // Add to <PlatformList>
738 //
739 parentNode.appendChild(fplNode);
740
741 }
742
743 public void ffiToFfNode(Element parentNode, FarFileItem ffi) {
744 Element farFileName = this.mainfestDoc.createElement(farPackage_FarfileName);
745 farFileName.setTextContent(ffi.getRelativeFilename());
746 System.out.println(farFileName.getTextContent());
747 System.out.println(ffi.getRelativeFilename());
748 farFileName.setAttribute(farFileName_Md5sum, ffi.getMd5Value());
749 parentNode.appendChild(farFileName);
750 }
751
752 public void setStrItemToNode(Element parentNode, String strValue, String strName) {
753 Element node = this.mainfestDoc.createElement(strName);
754 node.setTextContent(strValue);
755 parentNode.appendChild(node);
756 }
757
758 private void parseMainfest() {
759
760 //
761 // Parse header
762 //
763 parseMfHeader();
764 //
765 // parse <farPackageList>
766 //
767 parseHeaderFarPackageList();
768
769 //
770 // parse <farPlatformList>
771 //
772 NodeList ele = this.mainfestDoc.getElementsByTagName(farPlatformList);
773 Node plfNode;
774 if (ele.getLength() > 0) {
775 //
776 // Only have one <FarPlatformList> node under mainfest root node.
777 //
778 plfNode = ele.item(0);
779 parseFarPlatformList(plfNode, this.fPlfList);
780 }
781 }
782
783 private void parseMfHeader() {
784 Node headerNode;
785 NodeList ele = this.mainfestDoc.getElementsByTagName(farHeader);
786 if (ele.getLength() > 0) {
787 //
788 // For mainfest file only have one <FarHeader>
789 //
790 headerNode = ele.item(0);
791 } else {
792 return;
793 }
794 NodeList childList = headerNode.getChildNodes();
795 Node node = null;
796 String nodeName = null;
797 for (int i = 0; i < childList.getLength(); i++) {
798 node = childList.item(i);
799 nodeName = node.getNodeName();
800 if (nodeName.equalsIgnoreCase(farHeader_FarName)) {
801 String nodeValue = node.getTextContent();
802 this.fhInfo.setFarName(nodeValue);
803 } else if (nodeName.equalsIgnoreCase(guidValue)) {
804 this.fhInfo.setGuidValue(node.getTextContent());
805 } else if (nodeName.equalsIgnoreCase(version)) {
806 this.fhInfo.setVersion(node.getTextContent());
807 } else if (nodeName.equalsIgnoreCase(farHeader_Abstract)) {
808 this.fhInfo.setAbstractStr(node.getTextContent());
809 } else if (nodeName.equalsIgnoreCase(farHeader_Description)) {
810 this.fhInfo.setDescription(node.getTextContent());
811 } else if (nodeName.equalsIgnoreCase(farHeader_CopyRight)) {
812 this.fhInfo.setCopyright(node.getTextContent());
813 } else if (nodeName.equalsIgnoreCase(farHeader_License)) {
814 this.fhInfo.setLicense(node.getTextContent());
815 } else if (nodeName.equalsIgnoreCase(farHeader_Specification)) {
816 this.fhInfo.setSpecification(node.getTextContent());
817 }
818 }
819 }
820
821 public void parseHeaderFarPackageList() {
822 Node farPkgNode;
823 NodeList ele = this.mainfestDoc.getElementsByTagName(farPackageList);
824 if (ele.getLength() > 0) {
825 //
826 // For mainfest file only have one <FarHeader>
827 //
828 farPkgNode = ele.item(0);
829 } else {
830 return;
831 }
832 NodeList fpnList = farPkgNode.getChildNodes();
833 for (int i = 0; i < fpnList.getLength(); i++) {
834 if (fpnList.item(i).getNodeType() == Node.TEXT_NODE) {
835 continue;
836 }
837 FarPackage fpItem = new FarPackage();
838 parseFarPackage(fpnList.item(i), fpItem);
839 this.fPkgList.add(fpItem);
840 }
841 }
842
843 public void parseFarPackage(Node farPkgNode, FarPackage fpItem) {
844 NodeList childList = farPkgNode.getChildNodes();
845 Node childNode;
846 String childName;
847 for (int i = 0; i < childList.getLength(); i++) {
848 childNode = childList.item(i);
849 childName = childNode.getNodeName();
850 if (childName.equalsIgnoreCase(farPackage_FarfileName)) {
851 fpItem.setFarFile(parseFarFile(childNode));
852 } else if (childName.equalsIgnoreCase(guidValue)) {
853 fpItem.setGuidValue(childNode.getTextContent());
854 } else if (childName.equalsIgnoreCase(version)) {
855 fpItem.setVersion(childNode.getTextContent());
856 } else if (childName.equalsIgnoreCase(farPackage_DefaultPath)) {
857 fpItem.setDefaultPath(childNode.getTextContent());
858 } else if (childName.equalsIgnoreCase(farPlatformList)) {
859 List<FarPlatformItem> plfList = new ArrayList<FarPlatformItem>();
860 parseFarPlatformList(childNode, plfList);
861 fpItem.setFarPlatformList(plfList);
862 } else if (childName.equalsIgnoreCase(contents)) {
863 List<FarFileItem> ffList = new ArrayList<FarFileItem>();
864 parseContents(childNode, ffList);
865 fpItem.setContentList(ffList);
866 }
867 }
868 }
869
870 /**
871 *
872 * @param fpfListNode
873 * @param plfList
874 */
875 public void parseFarPlatformList(Node fpfListNode, List<FarPlatformItem> plfList) {
876 //
877 // Get <FarPlatform> list.
878 //
879 NodeList child = fpfListNode.getChildNodes();
880 Node farPlfNode;
881 for (int i = 0; i < child.getLength(); i++) {
882 if (child.item(i).getNodeType() == Node.TEXT_NODE) {
883 continue;
884 }
885 farPlfNode = child.item(i);
886 plfList.add(parseFarPlatform(farPlfNode));
887 }
888 }
889
890 /**
891 *
892 * @param fpfNode
893 * @return
894 */
895 public FarPlatformItem parseFarPlatform(Node fpfNode) {
896 //
897 // New FarPlatformItem.
898 //
899 FarPlatformItem fplItem = new FarPlatformItem();
900 //
901 // Get <FarPlatform> elements;
902 //
903 NodeList childList = fpfNode.getChildNodes();
904 Node child;
905 String nodeName;
906 for (int i = 0; i < childList.getLength(); i++) {
907 child = childList.item(i);
908 nodeName = child.getNodeName();
909 if (nodeName.equalsIgnoreCase(farPackage_FarfileName)) {
910 fplItem.setFarFile(parseFarFile(child));
911 } else if (nodeName.equalsIgnoreCase(guidValue)) {
912 fplItem.setGuidValue(child.getTextContent());
913 } else if (nodeName.equalsIgnoreCase(version)) {
914 fplItem.setVersion(child.getTextContent());
915 }
916 }
917
918 return fplItem;
919 }
920
921 public void parseContents(Node contentsNode, List<FarFileItem> ffList) {
922 NodeList contentList = contentsNode.getChildNodes();
923 Node contentNode;
924 for (int i = 0; i < contentList.getLength(); i++) {
925 if (contentList.item(i).getNodeType() == Node.TEXT_NODE) {
926 continue;
927 }
928 contentNode = contentList.item(i);
929 //
930 // Parse each <FarFileName>.
931 //
932 ffList.add(parseFarFile(contentNode));
933 }
934 }
935
936 public FarFileItem parseFarFile(Node farFileNode) {
937 String ffName = farFileNode.getTextContent();
938 NamedNodeMap attr = farFileNode.getAttributes();
939 FarFileItem ffItem = new FarFileItem(ffName, attr.getNamedItem(farFileName_Md5sum).getTextContent());
940 return ffItem;
941 }
942
943 public boolean isFilter(File file, Set<String> fileter) {
944 Iterator<String> iter = fileter.iterator();
945 while (iter.hasNext()) {
946 Pattern pattern = Pattern.compile(iter.next());
947 Matcher matcher = pattern.matcher(file.getName());
948
949 if (matcher.find()) {
950 return true;
951 }
952 }
953 return false;
954 }
955
956 }