View Javadoc
1   /**
2    *
3    * Copyright 2004 The Apache Software Foundation
4    *
5    * Licensed under the Apache License, Version 2.0 (the "License");
6    * you may not use this file except in compliance with the License.
7    * You may obtain a copy of the License at
8    *
9    * http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
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       * A list of the following objects:
73       * <ul>
74       * <li>Instances of {@link ArchiveEntry}, which are passed back by {@link #getResources()} without modifications
75       * .</li>
76       * <li>Instances of {@link PlexusIoResourceCollection}, which are converted into an {@link Iterator} over instances
77       * of {@link ArchiveEntry} by {@link #getResources()}.
78       * </ul>
79       */
80      private final List<Object> resources = new ArrayList<>();
81  
82      private boolean includeEmptyDirs = true;
83  
84      private int forcedFileMode = -1; // Will always be used
85  
86      private int forcedDirectoryMode = -1; // Will always be used
87  
88      private int defaultFileMode = -1; // Optionally used if a value is needed
89  
90      private int defaultDirectoryMode = -1; // Optionally used if a value is needed
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     // On lunix-like systems, we replace windows backslashes with forward slashes
103     private final boolean replacePathSlashesToJavaPaths = File.separatorChar == '/';
104 
105     private final List<Closeable> closeables = new ArrayList<>();
106 
107     /**
108      * since 2.2 is on by default
109      *
110      * @since 1.1
111      */
112     private boolean useJvmChmod = true;
113 
114     private FileTime lastModifiedTime;
115 
116     /**
117      * @since 4.2.0
118      */
119     private Comparator<String> filenameComparator;
120 
121     /**
122      * @since 4.2.0
123      */
124     private int overrideUid = -1;
125 
126     /**
127      * @since 4.2.0
128      */
129     private String overrideUserName;
130 
131     /**
132      * @since 4.2.0
133      */
134     private int overrideGid = -1;
135 
136     /**
137      * @since 4.2.0
138      */
139     private String overrideGroupName;
140 
141     /**
142      * Injected: Allows us to pull the ArchiverManager instance out of the container without causing a chicken-and-egg
143      * instantiation/composition problem.
144      */
145     @Inject
146     private Provider<ArchiverManager> archiverManagerProvider;
147 
148     /**
149      * Used instead of {@link #archiverManagerProvider} when this archiver was not created by a JSR-330 container,
150      * for example through {@link ServiceLoaderArchiverManager} or its constructor.
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      * @since 1.1
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      * @deprecated Use {@link Archiver#getDefaultFileMode()}.
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         // The PlexusIoFileResourceCollection contains platform-specific File.separatorChar which
339         // is an interesting cause of grief, see PLXCOMP-192
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                 // ignore
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             // do a null check here, to avoid creating a file stream if there are no filters...
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                                 // this will leak handles in the IO iterator if the iterator is not fully consumed.
545                                 // alternately we'd have to make this method return a Closeable iterator back
546                                 // to the client and ditch the whole issue onto the client.
547                                 // this does not really make any sense either, might equally well change the
548                                 // api into something that is not broken by design.
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                             // duplicate equal to add, so we continue
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      * Returns a map of the files that have been added to the archive.
628      * <p>
629      * Note: The entry names in the map use platform-specific path separators
630      * (e.g., backslashes on Windows, forward slashes on Unix). For ZIP archivers,
631      * the actual archive entries will use forward slashes as required by the ZIP
632      * specification, but this map returns names as they were added.
633      * </p>
634      * <p>
635      * For ZIP-based archivers (ZipArchiver, JarArchiver, etc.), use the overridden
636      * implementation which normalizes paths to forward slashes to match the actual
637      * ZIP entry names.
638      * </p>
639      *
640      * @return A map where keys are entry names and values are the corresponding ArchiveEntry objects.
641      * @deprecated Use {@link #getResources()} instead.
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      * Adds a resource collection to the archive.
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      * @since 1.0-alpha-7
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      * @since 1.0-alpha-7
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      * @since 1.0-alpha-7
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      * @since 1.0-alpha-7
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; // File doesn't yet exist
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; // No timestamp to compare
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                 // Don't know what to do. Safe thing is to assume not up2date.
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      * Returns the last modified time in milliseconds of a file.
875      * It avoids the bug where milliseconds precision is lost on File#lastModified (JDK-8177809) on JDK8 and Linux.
876      * @param file The file where the last modified time will be returned for.
877      * @return The last modified time in milliseconds of the file.
878      * @throws ArchiverException In the case of an IOException, for example when the file does not exists.
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      * This method is called after the archive creation
961      * completes successfully (no exceptions are thrown).
962      *
963      * Subclasses may override this method in order to
964      * augment or validate the archive after it is
965      * created.
966      *
967      * @since 3.6
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      * @since 1.1
1004      */
1005     @Override
1006     @Deprecated
1007     public boolean isUseJvmChmod() {
1008         return useJvmChmod;
1009     }
1010 
1011     /**
1012      * @since 1.1
1013      */
1014     @Override
1015     @Deprecated
1016     public void setUseJvmChmod(final boolean useJvmChmod) {
1017         this.useJvmChmod = useJvmChmod;
1018     }
1019 
1020     /**
1021      * @since 1.1
1022      */
1023     @Override
1024     public boolean isIgnorePermissions() {
1025         return ignorePermissions;
1026     }
1027 
1028     /**
1029      * @since 1.1
1030      */
1031     @Override
1032     public void setIgnorePermissions(final boolean ignorePermissions) {
1033         this.ignorePermissions = ignorePermissions;
1034     }
1035 
1036     /**
1037      * @deprecated Use {@link #setLastModifiedTime(FileTime)} instead.
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      * @deprecated Use {@link #getLastModifiedTime()} instead.
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      * @deprecated Use {@link #configureReproducibleBuild(FileTime)} instead.
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         // 1. force last modified date
1135         setLastModifiedTime(normalizeLastModifiedTime(lastModifiedTime));
1136 
1137         // 2. sort filenames in each directory when scanning filesystem
1138         setFilenameComparator(String::compareTo);
1139 
1140         // 3. ignore uid/gid from filesystem (for tar)
1141         setOverrideUid(0);
1142         setOverrideUserName("root"); // is it possible to avoid this, like "tar --numeric-owner"?
1143         setOverrideGid(0);
1144         setOverrideGroupName("root");
1145 
1146         // 4. set umask to 022 to avoid environment umask value particularly on group write
1147         setUmask(0_022);
1148     }
1149 
1150     /**
1151      * Normalize last modified time value to get reproducible archive entries, based on
1152      * archive binary format.
1153      *
1154      * <p>tar uses UTC timestamp, but zip uses local time then requires
1155      * tweaks to make the value reproducible whatever the current timezone is.
1156      *
1157      * @param lastModifiedTime The last modification time
1158      * @return The normalized last modification time
1159      *
1160      * @see #configureReproducibleBuild(FileTime)
1161      */
1162     protected FileTime normalizeLastModifiedTime(FileTime lastModifiedTime) {
1163         return lastModifiedTime;
1164     }
1165 }