Class ArchiveCommand

  • All Implemented Interfaces:
    java.util.concurrent.Callable<java.io.OutputStream>

    public class ArchiveCommand
    extends GitCommand<java.io.OutputStream>
    Create an archive of files from a named tree.

    Examples (git is a Git instance):

    Create a tarball from HEAD:

     ArchiveCommand.registerFormat("tar", new TarFormat());
     try {
            git.archive().setTree(db.resolve("HEAD")).setOutputStream(out).call();
     } finally {
            ArchiveCommand.unregisterFormat("tar");
     }
     

    Create a ZIP file from master:

     ArchiveCommand.registerFormat("zip", new ZipFormat());
     try {
            git.archive().
                    .setTree(db.resolve("master"))
                    .setFormat("zip")
                    .setOutputStream(out)
                    .call();
     } finally {
            ArchiveCommand.unregisterFormat("zip");
     }
     
    Since:
    3.1
    See Also:
    Git documentation about archive
    • Field Detail

      • formats

        private static final java.util.concurrent.ConcurrentMap<java.lang.String,​ArchiveCommand.FormatEntry> formats
        Available archival formats (corresponding to values for the --format= option)
      • out

        private java.io.OutputStream out
      • prefix

        private java.lang.String prefix
      • format

        private java.lang.String format
      • formatOptions

        private java.util.Map<java.lang.String,​java.lang.Object> formatOptions
      • paths

        private java.util.List<java.lang.String> paths
      • suffix

        private java.lang.String suffix
        Filename suffix, for automatically choosing a format.
    • Constructor Detail

      • ArchiveCommand

        public ArchiveCommand​(Repository repo)
        Constructor for ArchiveCommand
        Parameters:
        repo - the Repository
    • Method Detail

      • replace

        private static <K,​V> boolean replace​(java.util.concurrent.ConcurrentMap<K,​V> map,
                                                   K key,
                                                   V oldValue,
                                                   V newValue)
        Replaces the entry for a key only if currently mapped to a given value.
        Parameters:
        map - a map
        key - key with which the specified value is associated
        oldValue - expected value for the key (null if should be absent).
        newValue - value to be associated with the key (null to remove).
        Returns:
        true if the value was replaced
      • registerFormat

        public static void registerFormat​(java.lang.String name,
                                          ArchiveCommand.Format<?> fmt)
        Adds support for an additional archival format. To avoid unnecessary dependencies, ArchiveCommand does not have support for any formats built in; use this function to add them.

        OSGi plugins providing formats should call this function at bundle activation time.

        It is okay to register the same archive format with the same name multiple times, but don't forget to unregister it that same number of times, too.

        Registering multiple formats with different names and the same or overlapping suffixes results in undefined behavior. TODO: check that suffixes don't overlap.

        Parameters:
        name - name of a format (e.g., "tar" or "zip").
        fmt - archiver for that format
        Throws:
        JGitInternalException - A different archival format with that name was already registered.
      • unregisterFormat

        public static void unregisterFormat​(java.lang.String name)
        Marks support for an archival format as no longer needed so its Format can be garbage collected if no one else is using it either.

        In other words, this decrements the reference count for an archival format. If the reference count becomes zero, removes support for that format.

        Parameters:
        name - name of format (e.g., "tar" or "zip").
        Throws:
        JGitInternalException - No such archival format was registered.
      • writeArchive

        private <T extends java.io.Closeable> java.io.OutputStream writeArchive​(ArchiveCommand.Format<T> fmt)
      • call

        public java.io.OutputStream call()
                                  throws GitAPIException

        Execute the command

        Specified by:
        call in interface java.util.concurrent.Callable<java.io.OutputStream>
        Specified by:
        call in class GitCommand<java.io.OutputStream>
        Throws:
        GitAPIException
      • setTree

        public ArchiveCommand setTree​(ObjectId tree)
        Set the tag, commit, or tree object to produce an archive for
        Parameters:
        tree - the tag, commit, or tree object to produce an archive for
        Returns:
        this
      • setPrefix

        public ArchiveCommand setPrefix​(java.lang.String prefix)
        Set string prefixed to filenames in archive
        Parameters:
        prefix - string prefixed to filenames in archive (e.g., "master/"). null means to not use any leading prefix.
        Returns:
        this
        Since:
        3.3
      • setFilename

        public ArchiveCommand setFilename​(java.lang.String filename)
        Set the intended filename for the produced archive. Currently the only effect is to determine the default archive format when none is specified with setFormat(String).
        Parameters:
        filename - intended filename for the archive
        Returns:
        this
      • setOutputStream

        public ArchiveCommand setOutputStream​(java.io.OutputStream out)
        Set output stream
        Parameters:
        out - the stream to which to write the archive
        Returns:
        this
      • setFormat

        public ArchiveCommand setFormat​(java.lang.String fmt)
        Set archive format
        Parameters:
        fmt - archive format (e.g., "tar" or "zip"). null means to choose automatically based on the archive filename.
        Returns:
        this
      • setFormatOptions

        public ArchiveCommand setFormatOptions​(java.util.Map<java.lang.String,​java.lang.Object> options)
        Set archive format options
        Parameters:
        options - archive format options (e.g., level=9 for zip compression).
        Returns:
        this
        Since:
        4.0
      • setPaths

        public ArchiveCommand setPaths​(java.lang.String... paths)
        Set an optional parameter path. without an optional path parameter, all files and subdirectories of the current working directory are included in the archive. If one or more paths are specified, only these are included.
        Parameters:
        paths - file names (e.g file1.c) or directory names (e.g. dir to add dir/file1 and dir/file2) can also be given to add all files in the directory, recursively. Fileglobs (e.g. *.c) are not yet supported.
        Returns:
        this
        Since:
        3.4