1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.codehaus.plexus.archiver;
18
19 import javax.annotation.Nonnull;
20 import javax.inject.Inject;
21 import javax.inject.Provider;
22
23 import java.io.Closeable;
24 import java.io.File;
25 import java.io.IOException;
26 import java.lang.reflect.UndeclaredThrowableException;
27 import java.nio.charset.Charset;
28 import java.nio.file.Files;
29 import java.nio.file.attribute.FileTime;
30 import java.util.ArrayList;
31 import java.util.Comparator;
32 import java.util.Date;
33 import java.util.HashMap;
34 import java.util.HashSet;
35 import java.util.Iterator;
36 import java.util.List;
37 import java.util.Map;
38 import java.util.NoSuchElementException;
39 import java.util.Set;
40
41 import org.codehaus.plexus.archiver.manager.ArchiverManager;
42 import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
43 import org.codehaus.plexus.archiver.manager.ServiceLoaderArchiverManager;
44 import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributeUtils;
45 import org.codehaus.plexus.components.io.attributes.PlexusIoResourceAttributes;
46 import org.codehaus.plexus.components.io.attributes.SimpleResourceAttributes;
47 import org.codehaus.plexus.components.io.functions.ResourceAttributeSupplier;
48 import org.codehaus.plexus.components.io.resources.AbstractPlexusIoResourceCollection;
49 import org.codehaus.plexus.components.io.resources.EncodingSupported;
50 import org.codehaus.plexus.components.io.resources.PlexusIoArchivedResourceCollection;
51 import org.codehaus.plexus.components.io.resources.PlexusIoFileResourceCollection;
52 import org.codehaus.plexus.components.io.resources.PlexusIoResource;
53 import org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection;
54 import org.codehaus.plexus.components.io.resources.proxy.PlexusIoProxyResourceCollection;
55 import org.slf4j.Logger;
56 import org.slf4j.LoggerFactory;
57
58 import static org.codehaus.plexus.archiver.util.DefaultArchivedFileSet.archivedFileSet;
59 import static org.codehaus.plexus.archiver.util.DefaultFileSet.fileSet;
60
61 public abstract class AbstractArchiver implements Archiver, FinalizerEnabled {
62
63 private final Logger logger = LoggerFactory.getLogger(getClass());
64
65 protected Logger getLogger() {
66 return logger;
67 }
68
69 private File destFile;
70
71
72
73
74
75
76
77
78
79
80 private final List<Object> resources = new ArrayList<>();
81
82 private boolean includeEmptyDirs = true;
83
84 private int forcedFileMode = -1;
85
86 private int forcedDirectoryMode = -1;
87
88 private int defaultFileMode = -1;
89
90 private int defaultDirectoryMode = -1;
91
92 private int umask = -1;
93
94 private boolean forced = true;
95
96 private List<ArchiveFinalizer> finalizers;
97
98 private File dotFileDirectory;
99
100 private String duplicateBehavior = Archiver.DUPLICATES_SKIP;
101
102
103 private final boolean replacePathSlashesToJavaPaths = File.separatorChar == '/';
104
105 private final List<Closeable> closeables = new ArrayList<>();
106
107
108
109
110
111
112 private boolean useJvmChmod = true;
113
114 private FileTime lastModifiedTime;
115
116
117
118
119 private Comparator<String> filenameComparator;
120
121
122
123
124 private int overrideUid = -1;
125
126
127
128
129 private String overrideUserName;
130
131
132
133
134 private int overrideGid = -1;
135
136
137
138
139 private String overrideGroupName;
140
141
142
143
144
145 @Inject
146 private Provider<ArchiverManager> archiverManagerProvider;
147
148
149
150
151
152 private ArchiverManager serviceLoaderArchiverManager;
153
154 private static class AddedResourceCollection {
155
156 private final PlexusIoResourceCollection resources;
157
158 private final int forcedFileMode;
159
160 private final int forcedDirectoryMode;
161
162 public AddedResourceCollection(PlexusIoResourceCollection resources, int forcedFileMode, int forcedDirMode) {
163 this.resources = resources;
164 this.forcedFileMode = forcedFileMode;
165 this.forcedDirectoryMode = forcedDirMode;
166 }
167
168 private int maybeOverridden(int suggestedMode, boolean isDir) {
169 if (isDir) {
170 return forcedDirectoryMode >= 0 ? forcedDirectoryMode : suggestedMode;
171 } else {
172 return forcedFileMode >= 0 ? forcedFileMode : suggestedMode;
173 }
174 }
175 }
176
177
178
179
180 private boolean ignorePermissions = false;
181
182 @Override
183 public String getDuplicateBehavior() {
184 return duplicateBehavior;
185 }
186
187 @Override
188 public void setDuplicateBehavior(final String duplicate) {
189 if (!Archiver.DUPLICATES_VALID_BEHAVIORS.contains(duplicate)) {
190 throw new IllegalArgumentException("Invalid duplicate-file behavior: '" + duplicate
191 + "'. Please specify one of: " + Archiver.DUPLICATES_VALID_BEHAVIORS);
192 }
193
194 duplicateBehavior = duplicate;
195 }
196
197 @Override
198 public final void setFileMode(final int mode) {
199 if (mode >= 0) {
200 forcedFileMode = (mode & UnixStat.PERM_MASK) | UnixStat.FILE_FLAG;
201 } else {
202 forcedFileMode = -1;
203 }
204 }
205
206 @Override
207 public final void setDefaultFileMode(final int mode) {
208 defaultFileMode = (mode & UnixStat.PERM_MASK) | UnixStat.FILE_FLAG;
209 }
210
211 @Override
212 public final int getOverrideFileMode() {
213 return forcedFileMode;
214 }
215
216 @Override
217 public final int getFileMode() {
218 if (forcedFileMode < 0) {
219 if (defaultFileMode < 0) {
220 return DEFAULT_FILE_MODE;
221 }
222
223 return defaultFileMode;
224 }
225
226 return forcedFileMode;
227 }
228
229 @Override
230 public final int getDefaultFileMode() {
231 return defaultFileMode;
232 }
233
234
235
236
237 @Deprecated
238 public final int getRawDefaultFileMode() {
239 return getDefaultFileMode();
240 }
241
242 @Override
243 public final void setDirectoryMode(final int mode) {
244 if (mode >= 0) {
245 forcedDirectoryMode = (mode & UnixStat.PERM_MASK) | UnixStat.DIR_FLAG;
246 } else {
247 forcedDirectoryMode = -1;
248 }
249 }
250
251 @Override
252 public final void setDefaultDirectoryMode(final int mode) {
253 defaultDirectoryMode = (mode & UnixStat.PERM_MASK) | UnixStat.DIR_FLAG;
254 }
255
256 @Override
257 public final int getOverrideDirectoryMode() {
258 return forcedDirectoryMode;
259 }
260
261 @Override
262 public final int getDirectoryMode() {
263 if (forcedDirectoryMode < 0) {
264 if (defaultDirectoryMode < 0) {
265 return DEFAULT_DIR_MODE;
266 }
267
268 return defaultDirectoryMode;
269 }
270
271 return forcedDirectoryMode;
272 }
273
274 @Override
275 public final int getDefaultDirectoryMode() {
276 if (defaultDirectoryMode < 0) {
277 return DEFAULT_DIR_MODE;
278 } else {
279 return defaultDirectoryMode;
280 }
281 }
282
283 @Override
284 public boolean getIncludeEmptyDirs() {
285 return includeEmptyDirs;
286 }
287
288 @Override
289 public void setIncludeEmptyDirs(final boolean includeEmptyDirs) {
290 this.includeEmptyDirs = includeEmptyDirs;
291 }
292
293 @Override
294 @Deprecated
295 public void addDirectory(@Nonnull final File directory) throws ArchiverException {
296 addFileSet(fileSet(directory).prefixed("").includeExclude(null, null).includeEmptyDirs(includeEmptyDirs));
297 }
298
299 @Override
300 @Deprecated
301 public void addDirectory(@Nonnull final File directory, final String prefix) throws ArchiverException {
302 addFileSet(
303 fileSet(directory).prefixed(prefix).includeExclude(null, null).includeEmptyDirs(includeEmptyDirs));
304 }
305
306 @Override
307 @Deprecated
308 public void addDirectory(@Nonnull final File directory, final String[] includes, final String[] excludes)
309 throws ArchiverException {
310 addFileSet(fileSet(directory)
311 .prefixed("")
312 .includeExclude(includes, excludes)
313 .includeEmptyDirs(includeEmptyDirs));
314 }
315
316 @Override
317 @Deprecated
318 public void addDirectory(
319 @Nonnull final File directory, final String prefix, final String[] includes, final String[] excludes)
320 throws ArchiverException {
321 addFileSet(fileSet(directory)
322 .prefixed(prefix)
323 .includeExclude(includes, excludes)
324 .includeEmptyDirs(includeEmptyDirs));
325 }
326
327 @Override
328 public void addFileSet(@Nonnull final FileSet fileSet) throws ArchiverException {
329 final File directory = fileSet.getDirectory();
330 if (directory == null) {
331 throw new ArchiverException("The file sets base directory is null.");
332 }
333
334 if (!directory.isDirectory()) {
335 throw new ArchiverException(directory.getAbsolutePath() + " isn't a directory.");
336 }
337
338
339
340 final PlexusIoFileResourceCollection collection = new PlexusIoFileResourceCollection();
341 collection.setFollowingSymLinks(fileSet.isFollowingSymLinks());
342
343 collection.setIncludes(fileSet.getIncludes());
344 collection.setExcludes(fileSet.getExcludes());
345 collection.setBaseDir(directory);
346 collection.setFileSelectors(fileSet.getFileSelectors());
347 collection.setIncludingEmptyDirectories(fileSet.isIncludingEmptyDirectories());
348 collection.setPrefix(fileSet.getPrefix());
349 collection.setCaseSensitive(fileSet.isCaseSensitive());
350 collection.setUsingDefaultExcludes(fileSet.isUsingDefaultExcludes());
351 collection.setStreamTransformer(fileSet.getStreamTransformer());
352 collection.setFileMappers(fileSet.getFileMappers());
353 collection.setFilenameComparator(getFilenameComparator());
354
355 if (getOverrideDirectoryMode() > -1
356 || getOverrideFileMode() > -1
357 || getOverrideUid() > -1
358 || getOverrideGid() > -1
359 || getOverrideUserName() != null
360 || getOverrideGroupName() != null) {
361 collection.setOverrideAttributes(
362 getOverrideUid(),
363 getOverrideUserName(),
364 getOverrideGid(),
365 getOverrideGroupName(),
366 getOverrideFileMode(),
367 getOverrideDirectoryMode());
368 }
369
370 if (getDefaultDirectoryMode() > -1 || getDefaultFileMode() > -1) {
371 collection.setDefaultAttributes(-1, null, -1, null, getDefaultFileMode(), getDefaultDirectoryMode());
372 }
373
374 addResources(collection);
375 }
376
377 @Override
378 public void addFile(@Nonnull final File inputFile, @Nonnull final String destFileName) throws ArchiverException {
379 int permissions;
380 if (forcedFileMode > 0) {
381 permissions = forcedFileMode;
382 } else {
383 permissions = PlexusIoResourceAttributes.UNKNOWN_OCTAL_MODE;
384 try {
385 permissions = PlexusIoResourceAttributeUtils.getFileAttributes(inputFile)
386 .getOctalMode();
387 } catch (IOException ioe) {
388
389 }
390 }
391
392 addFile(inputFile, destFileName, permissions);
393 }
394
395 @Override
396 public void addSymlink(String symlinkName, String symlinkDestination) throws ArchiverException {
397 final int fileMode = getOverrideFileMode();
398
399 addSymlink(symlinkName, fileMode, symlinkDestination);
400 }
401
402 @Override
403 public void addSymlink(String symlinkName, int permissions, String symlinkDestination) throws ArchiverException {
404 doAddResource(
405 ArchiveEntry.createSymlinkEntry(symlinkName, permissions, symlinkDestination, getDirectoryMode()));
406 }
407
408 private ArchiveEntry updateArchiveEntryAttributes(ArchiveEntry entry) {
409 if (getOverrideUid() > -1
410 || getOverrideGid() > -1
411 || getOverrideUserName() != null
412 || getOverrideGroupName() != null) {
413 entry.setResourceAttributes(new SimpleResourceAttributes(
414 getOverrideUid(),
415 getOverrideUserName(),
416 getOverrideGid(),
417 getOverrideGroupName(),
418 entry.getMode()));
419 }
420 return entry;
421 }
422
423 protected ArchiveEntry asArchiveEntry(
424 @Nonnull final PlexusIoResource resource,
425 final String destFileName,
426 int permissions,
427 PlexusIoResourceCollection collection)
428 throws ArchiverException {
429 if (!resource.isExisting()) {
430 throw new ArchiverException(resource.getName() + " not found.");
431 }
432
433 if (umask > 0 && permissions != PlexusIoResourceAttributes.UNKNOWN_OCTAL_MODE) {
434 permissions &= ~umask;
435 }
436
437 ArchiveEntry entry;
438 if (resource.isFile()) {
439 entry = ArchiveEntry.createFileEntry(destFileName, resource, permissions, collection, getDirectoryMode());
440 } else {
441 entry = ArchiveEntry.createDirectoryEntry(destFileName, resource, permissions, getDirectoryMode());
442 }
443
444 return updateArchiveEntryAttributes(entry);
445 }
446
447 private ArchiveEntry asArchiveEntry(final AddedResourceCollection collection, final PlexusIoResource resource)
448 throws ArchiverException {
449 final String destFileName = collection.resources.getName(resource);
450
451 int fromResource = PlexusIoResourceAttributes.UNKNOWN_OCTAL_MODE;
452 if (resource instanceof ResourceAttributeSupplier) {
453 final PlexusIoResourceAttributes attrs = ((ResourceAttributeSupplier) resource).getAttributes();
454
455 if (attrs != null) {
456 fromResource = attrs.getOctalMode();
457 }
458 }
459
460 return asArchiveEntry(
461 resource,
462 destFileName,
463 collection.maybeOverridden(fromResource, resource.isDirectory()),
464 collection.resources);
465 }
466
467 @Override
468 public void addResource(final PlexusIoResource resource, final String destFileName, final int permissions)
469 throws ArchiverException {
470 doAddResource(asArchiveEntry(resource, destFileName, permissions, null));
471 }
472
473 @Override
474 public void addFile(@Nonnull final File inputFile, @Nonnull String destFileName, int permissions)
475 throws ArchiverException {
476 if (!inputFile.isFile() || !inputFile.exists()) {
477 throw new ArchiverException(inputFile.getAbsolutePath() + " isn't a file.");
478 }
479
480 if (replacePathSlashesToJavaPaths) {
481 destFileName = destFileName.replace('\\', '/');
482 }
483
484 if (permissions < 0) {
485 permissions = getOverrideFileMode();
486 }
487
488 if (umask > 0 && permissions != PlexusIoResourceAttributes.UNKNOWN_OCTAL_MODE) {
489 permissions &= ~umask;
490 }
491
492 try {
493
494 ArchiveEntry entry = ArchiveEntry.createFileEntry(destFileName, inputFile, permissions, getDirectoryMode());
495 doAddResource(updateArchiveEntryAttributes(entry));
496 } catch (final IOException e) {
497 throw new ArchiverException("Failed to determine inclusion status for: " + inputFile, e);
498 }
499 }
500
501 @Nonnull
502 @Override
503 public ResourceIterator getResources() throws ArchiverException {
504 return new ResourceIterator() {
505
506 private final Iterator<Object> addedResourceIter = resources.iterator();
507
508 private AddedResourceCollection currentResourceCollection;
509
510 private Iterator ioResourceIter;
511
512 private ArchiveEntry nextEntry;
513
514 private final Set<String> seenEntries = new HashSet<>();
515
516 @Override
517 public boolean hasNext() {
518 do {
519 if (nextEntry == null) {
520 if (ioResourceIter == null) {
521 if (addedResourceIter.hasNext()) {
522 final Object o = addedResourceIter.next();
523 if (o instanceof ArchiveEntry) {
524 nextEntry = (ArchiveEntry) o;
525 } else if (o instanceof AddedResourceCollection) {
526 currentResourceCollection = (AddedResourceCollection) o;
527
528 try {
529 ioResourceIter = currentResourceCollection.resources.getResources();
530 } catch (final IOException e) {
531 throw new ArchiverException(e.getMessage(), e);
532 }
533 } else {
534 return throwIllegalResourceType(o);
535 }
536 } else {
537 nextEntry = null;
538 }
539 } else {
540 if (ioResourceIter.hasNext()) {
541 final PlexusIoResource resource = (PlexusIoResource) ioResourceIter.next();
542 nextEntry = asArchiveEntry(currentResourceCollection, resource);
543 } else {
544
545
546
547
548
549 addCloseable(ioResourceIter);
550 ioResourceIter = null;
551 }
552 }
553 }
554
555 if (nextEntry != null && seenEntries.contains(normalizedForDuplicateCheck(nextEntry))) {
556 final String path = nextEntry.getName();
557
558 if (Archiver.DUPLICATES_PRESERVE.equals(duplicateBehavior)
559 || Archiver.DUPLICATES_SKIP.equals(duplicateBehavior)) {
560 if (nextEntry.getType() == ArchiveEntry.FILE) {
561 getLogger().debug(path + " already added, skipping");
562 }
563
564 nextEntry = null;
565 } else if (Archiver.DUPLICATES_FAIL.equals(duplicateBehavior)) {
566 throw new ArchiverException("Duplicate file " + path + " was found and the duplicate "
567 + "attribute is 'fail'.");
568 } else {
569
570 getLogger().debug("duplicate file " + path + " found, adding.");
571 }
572 }
573 } while (nextEntry == null && !(ioResourceIter == null && !addedResourceIter.hasNext()));
574
575 return nextEntry != null;
576 }
577
578 private boolean throwIllegalResourceType(Object o) {
579 throw new IllegalStateException(
580 "An invalid resource of type: " + o.getClass().getName() + " was added to archiver: "
581 + getClass().getName());
582 }
583
584 @Override
585 public ArchiveEntry next() {
586 if (!hasNext()) {
587 throw new NoSuchElementException();
588 }
589
590 final ArchiveEntry next = nextEntry;
591 nextEntry = null;
592
593 seenEntries.add(normalizedForDuplicateCheck(next));
594
595 return next;
596 }
597
598 @Override
599 public void remove() {
600 throw new UnsupportedOperationException("Does not support iterator");
601 }
602
603 private String normalizedForDuplicateCheck(ArchiveEntry entry) {
604 return entry.getName().replace('\\', '/');
605 }
606 };
607 }
608
609 private static void closeIfCloseable(Object resource) throws IOException {
610 if (resource == null) {
611 return;
612 }
613 if (resource instanceof Closeable) {
614 ((Closeable) resource).close();
615 }
616 }
617
618 private static void closeQuietlyIfCloseable(Object resource) {
619 try {
620 closeIfCloseable(resource);
621 } catch (IOException e) {
622 throw new RuntimeException(e);
623 }
624 }
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643 @Override
644 @Deprecated
645 public Map<String, ArchiveEntry> getFiles() {
646 try {
647 final Map<String, ArchiveEntry> map = new HashMap<>();
648 for (final ResourceIterator iter = getResources(); iter.hasNext(); ) {
649 final ArchiveEntry entry = iter.next();
650 if (includeEmptyDirs || entry.getType() == ArchiveEntry.FILE) {
651 map.put(entry.getName(), entry);
652 }
653 }
654 return map;
655 } catch (final ArchiverException e) {
656 throw new UndeclaredThrowableException(e);
657 }
658 }
659
660 @Override
661 public File getDestFile() {
662 return destFile;
663 }
664
665 @Override
666 public void setDestFile(final File destFile) {
667 this.destFile = destFile;
668
669 if (destFile != null && destFile.getParentFile() != null) {
670 destFile.getParentFile().mkdirs();
671 }
672 }
673
674 private ArchiverManager getArchiverManager() {
675 if (archiverManagerProvider != null) {
676 return archiverManagerProvider.get();
677 }
678 if (serviceLoaderArchiverManager == null) {
679 serviceLoaderArchiverManager = new ServiceLoaderArchiverManager();
680 }
681 return serviceLoaderArchiverManager;
682 }
683
684 protected PlexusIoResourceCollection asResourceCollection(final ArchivedFileSet fileSet, Charset charset)
685 throws ArchiverException {
686 final File archiveFile = fileSet.getArchive();
687
688 final PlexusIoResourceCollection resources;
689 try {
690 resources = getArchiverManager().getResourceCollection(archiveFile);
691 } catch (final NoSuchArchiverException e) {
692 throw new ArchiverException(
693 "Error adding archived file-set. PlexusIoResourceCollection not found for: " + archiveFile, e);
694 }
695
696 if (resources instanceof EncodingSupported) {
697 ((EncodingSupported) resources).setEncoding(charset);
698 }
699
700 if (resources instanceof PlexusIoArchivedResourceCollection) {
701 ((PlexusIoArchivedResourceCollection) resources).setFile(fileSet.getArchive());
702 } else {
703 throw new ArchiverException("Expected " + PlexusIoArchivedResourceCollection.class.getName() + ", got "
704 + resources.getClass().getName());
705 }
706
707 if (resources instanceof AbstractPlexusIoResourceCollection) {
708 ((AbstractPlexusIoResourceCollection) resources).setStreamTransformer(fileSet.getStreamTransformer());
709 }
710 final PlexusIoProxyResourceCollection proxy = new PlexusIoProxyResourceCollection(resources);
711
712 proxy.setExcludes(fileSet.getExcludes());
713 proxy.setIncludes(fileSet.getIncludes());
714 proxy.setIncludingEmptyDirectories(fileSet.isIncludingEmptyDirectories());
715 proxy.setCaseSensitive(fileSet.isCaseSensitive());
716 proxy.setPrefix(fileSet.getPrefix());
717 proxy.setUsingDefaultExcludes(fileSet.isUsingDefaultExcludes());
718 proxy.setFileSelectors(fileSet.getFileSelectors());
719 proxy.setStreamTransformer(fileSet.getStreamTransformer());
720 proxy.setFileMappers(fileSet.getFileMappers());
721
722 if (getOverrideDirectoryMode() > -1 || getOverrideFileMode() > -1) {
723 proxy.setOverrideAttributes(-1, null, -1, null, getOverrideFileMode(), getOverrideDirectoryMode());
724 }
725
726 if (getDefaultDirectoryMode() > -1 || getDefaultFileMode() > -1) {
727 proxy.setDefaultAttributes(-1, null, -1, null, getDefaultFileMode(), getDefaultDirectoryMode());
728 }
729
730 return proxy;
731 }
732
733
734
735
736 @Override
737 public void addResources(final PlexusIoResourceCollection collection) throws ArchiverException {
738 doAddResource(new AddedResourceCollection(collection, forcedFileMode, forcedDirectoryMode));
739 }
740
741 private void doAddResource(Object item) {
742 resources.add(item);
743 }
744
745 @Override
746 public void addArchivedFileSet(final ArchivedFileSet fileSet) throws ArchiverException {
747 final PlexusIoResourceCollection resourceCollection = asResourceCollection(fileSet, null);
748 addResources(resourceCollection);
749 }
750
751 @Override
752 public void addArchivedFileSet(final ArchivedFileSet fileSet, Charset charset) throws ArchiverException {
753 final PlexusIoResourceCollection resourceCollection = asResourceCollection(fileSet, charset);
754 addResources(resourceCollection);
755 }
756
757
758
759
760 @Override
761 @Deprecated
762 public void addArchivedFileSet(
763 @Nonnull final File archiveFile, final String prefix, final String[] includes, final String[] excludes)
764 throws ArchiverException {
765 addArchivedFileSet(archivedFileSet(archiveFile)
766 .prefixed(prefix)
767 .includeExclude(includes, excludes)
768 .includeEmptyDirs(includeEmptyDirs));
769 }
770
771
772
773
774 @Override
775 @Deprecated
776 public void addArchivedFileSet(@Nonnull final File archiveFile, final String prefix) throws ArchiverException {
777 addArchivedFileSet(archivedFileSet(archiveFile).prefixed(prefix).includeEmptyDirs(includeEmptyDirs));
778 }
779
780
781
782
783 @Override
784 @Deprecated
785 public void addArchivedFileSet(@Nonnull final File archiveFile, final String[] includes, final String[] excludes)
786 throws ArchiverException {
787 addArchivedFileSet(
788 archivedFileSet(archiveFile).includeExclude(includes, excludes).includeEmptyDirs(includeEmptyDirs));
789 }
790
791
792
793
794 @Override
795 @Deprecated
796 public void addArchivedFileSet(@Nonnull final File archiveFile) throws ArchiverException {
797 addArchivedFileSet(archivedFileSet(archiveFile).includeEmptyDirs(includeEmptyDirs));
798 }
799
800 @Override
801 public boolean isForced() {
802 return forced;
803 }
804
805 @Override
806 public void setForced(final boolean forced) {
807 this.forced = forced;
808 }
809
810 @Override
811 public void addArchiveFinalizer(final ArchiveFinalizer finalizer) {
812 if (finalizers == null) {
813 finalizers = new ArrayList<>();
814 }
815
816 finalizers.add(finalizer);
817 }
818
819 @Override
820 public void setArchiveFinalizers(final List<ArchiveFinalizer> archiveFinalizers) {
821 finalizers = archiveFinalizers;
822 }
823
824 @Override
825 public void setDotFileDirectory(final File dotFileDirectory) {
826 this.dotFileDirectory = dotFileDirectory;
827 }
828
829 protected boolean isUptodate() throws ArchiverException {
830 final File zipFile = getDestFile();
831 if (!zipFile.exists()) {
832 getLogger().debug("isUp2date: false (Destination " + zipFile.getPath() + " not found.)");
833 return false;
834 }
835 final long destTimestamp = getFileLastModifiedTime(zipFile);
836
837 final Iterator<Object> it = resources.iterator();
838 if (!it.hasNext()) {
839 getLogger().debug("isUp2date: false (No input files.)");
840 return false;
841 }
842
843 while (it.hasNext()) {
844 final Object o = it.next();
845 final long l;
846 if (o instanceof ArchiveEntry) {
847 l = ((ArchiveEntry) o).getResource().getLastModified();
848 } else if (o instanceof AddedResourceCollection) {
849 try {
850 l = ((AddedResourceCollection) o).resources.getLastModified();
851 } catch (final IOException e) {
852 throw new ArchiverException(e.getMessage(), e);
853 }
854 } else {
855 throw new IllegalStateException(
856 "Invalid object type: " + o.getClass().getName());
857 }
858 if (l == PlexusIoResource.UNKNOWN_MODIFICATION_DATE) {
859
860 getLogger().debug("isUp2date: false (Resource with unknown modification date found.)");
861 return false;
862 }
863 if (l > destTimestamp) {
864 getLogger().debug("isUp2date: false (Resource with newer modification date found.)");
865 return false;
866 }
867 }
868
869 getLogger().debug("isUp2date: true");
870 return true;
871 }
872
873
874
875
876
877
878
879
880 private long getFileLastModifiedTime(File file) throws ArchiverException {
881 try {
882 return Files.getLastModifiedTime(file.toPath()).toMillis();
883 } catch (IOException e) {
884 throw new ArchiverException(e.getMessage(), e);
885 }
886 }
887
888 protected boolean checkForced() throws ArchiverException {
889 if (!isForced() && isSupportingForced() && isUptodate()) {
890 getLogger().debug("Archive " + getDestFile() + " is uptodate.");
891 return false;
892 }
893 return true;
894 }
895
896 @Override
897 public boolean isSupportingForced() {
898 return false;
899 }
900
901 protected void runArchiveFinalizers() throws ArchiverException {
902 if (finalizers != null) {
903 for (final ArchiveFinalizer finalizer : finalizers) {
904 finalizer.finalizeArchiveCreation(this);
905 }
906 }
907 }
908
909 @Override
910 public final void createArchive() throws ArchiverException, IOException {
911 validate();
912 try {
913 try {
914 if (dotFileDirectory != null) {
915 addArchiveFinalizer(new DotDirectiveArchiveFinalizer(dotFileDirectory));
916 }
917
918 runArchiveFinalizers();
919
920 execute();
921 } finally {
922 close();
923 }
924 } catch (final IOException e) {
925 String msg = "Problem creating " + getArchiveType() + ": " + e.getMessage();
926
927 final StringBuffer revertBuffer = new StringBuffer();
928 if (!revert(revertBuffer)) {
929 msg += revertBuffer.toString();
930 }
931
932 throw new ArchiverException(msg, e);
933 } finally {
934 cleanUp();
935 }
936
937 postCreateArchive();
938 }
939
940 protected boolean hasVirtualFiles() {
941 if (finalizers != null) {
942 for (final ArchiveFinalizer finalizer : finalizers) {
943 final List virtualFiles = finalizer.getVirtualFiles();
944
945 if ((virtualFiles != null) && !virtualFiles.isEmpty()) {
946 return true;
947 }
948 }
949 }
950 return false;
951 }
952
953 protected boolean revert(final StringBuffer messageBuffer) {
954 return true;
955 }
956
957 protected void validate() throws ArchiverException, IOException {}
958
959
960
961
962
963
964
965
966
967
968
969 protected void postCreateArchive() throws ArchiverException, IOException {}
970
971 protected abstract String getArchiveType();
972
973 private void addCloseable(Object maybeCloseable) {
974 if (maybeCloseable instanceof Closeable) {
975 closeables.add((Closeable) maybeCloseable);
976 }
977 }
978
979 private void closeIterators() {
980 for (Closeable closeable : closeables) {
981 closeQuietlyIfCloseable(closeable);
982 }
983 }
984
985 protected abstract void close() throws IOException;
986
987 protected void cleanUp() throws IOException {
988 closeIterators();
989
990 for (Object resource : resources) {
991 if (resource instanceof PlexusIoProxyResourceCollection) {
992 resource = ((PlexusIoProxyResourceCollection) resource).getSrc();
993 }
994
995 closeIfCloseable(resource);
996 }
997 resources.clear();
998 }
999
1000 protected abstract void execute() throws ArchiverException, IOException;
1001
1002
1003
1004
1005 @Override
1006 @Deprecated
1007 public boolean isUseJvmChmod() {
1008 return useJvmChmod;
1009 }
1010
1011
1012
1013
1014 @Override
1015 @Deprecated
1016 public void setUseJvmChmod(final boolean useJvmChmod) {
1017 this.useJvmChmod = useJvmChmod;
1018 }
1019
1020
1021
1022
1023 @Override
1024 public boolean isIgnorePermissions() {
1025 return ignorePermissions;
1026 }
1027
1028
1029
1030
1031 @Override
1032 public void setIgnorePermissions(final boolean ignorePermissions) {
1033 this.ignorePermissions = ignorePermissions;
1034 }
1035
1036
1037
1038
1039 @Override
1040 @Deprecated
1041 public void setLastModifiedDate(Date lastModifiedDate) {
1042 this.lastModifiedTime = lastModifiedDate != null ? FileTime.fromMillis(lastModifiedDate.getTime()) : null;
1043 }
1044
1045
1046
1047
1048 @Override
1049 @Deprecated
1050 public Date getLastModifiedDate() {
1051 return lastModifiedTime != null ? new Date(lastModifiedTime.toMillis()) : null;
1052 }
1053
1054 @Override
1055 public void setLastModifiedTime(FileTime lastModifiedTime) {
1056 this.lastModifiedTime = lastModifiedTime;
1057 }
1058
1059 @Override
1060 public FileTime getLastModifiedTime() {
1061 return lastModifiedTime;
1062 }
1063
1064 @Override
1065 public void setFilenameComparator(Comparator<String> filenameComparator) {
1066 this.filenameComparator = filenameComparator;
1067 }
1068
1069 public Comparator<String> getFilenameComparator() {
1070 return filenameComparator;
1071 }
1072
1073 @Override
1074 public void setOverrideUid(int uid) {
1075 overrideUid = uid;
1076 }
1077
1078 @Override
1079 public void setOverrideUserName(String userName) {
1080 overrideUserName = userName;
1081 }
1082
1083 @Override
1084 public int getOverrideUid() {
1085 return overrideUid;
1086 }
1087
1088 @Override
1089 public String getOverrideUserName() {
1090 return overrideUserName;
1091 }
1092
1093 @Override
1094 public void setOverrideGid(int gid) {
1095 overrideGid = gid;
1096 }
1097
1098 @Override
1099 public void setOverrideGroupName(String groupName) {
1100 overrideGroupName = groupName;
1101 }
1102
1103 @Override
1104 public int getOverrideGid() {
1105 return overrideGid;
1106 }
1107
1108 @Override
1109 public String getOverrideGroupName() {
1110 return overrideGroupName;
1111 }
1112
1113 @Override
1114 public void setUmask(int umask) {
1115 this.umask = umask;
1116 }
1117
1118 @Override
1119 public int getUmask() {
1120 return umask;
1121 }
1122
1123
1124
1125
1126 @Override
1127 @Deprecated
1128 public void configureReproducible(Date lastModifiedDate) {
1129 configureReproducibleBuild(FileTime.fromMillis(lastModifiedDate.getTime()));
1130 }
1131
1132 @Override
1133 public void configureReproducibleBuild(FileTime lastModifiedTime) {
1134
1135 setLastModifiedTime(normalizeLastModifiedTime(lastModifiedTime));
1136
1137
1138 setFilenameComparator(String::compareTo);
1139
1140
1141 setOverrideUid(0);
1142 setOverrideUserName("root");
1143 setOverrideGid(0);
1144 setOverrideGroupName("root");
1145
1146
1147 setUmask(0_022);
1148 }
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162 protected FileTime normalizeLastModifiedTime(FileTime lastModifiedTime) {
1163 return lastModifiedTime;
1164 }
1165 }