| /* |
| * Copyright (C) 2012 Google Inc. |
| * and other copyright owners as documented in the project's IP log. |
| * |
| * This program and the accompanying materials are made available |
| * under the terms of the Eclipse Distribution License v1.0 which |
| * accompanies this distribution, is reproduced below, and is |
| * available at http://www.eclipse.org/org/documents/edl-v10.php |
| * |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or |
| * without modification, are permitted provided that the following |
| * conditions are met: |
| * |
| * - Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * - Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following |
| * disclaimer in the documentation and/or other materials provided |
| * with the distribution. |
| * |
| * - Neither the name of the Eclipse Foundation, Inc. nor the |
| * names of its contributors may be used to endorse or promote |
| * products derived from this software without specific prior |
| * written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND |
| * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, |
| * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, |
| * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| package org.eclipse.jgit.pgm; |
| |
| import static org.eclipse.jgit.lib.Constants.CHARSET; |
| import static org.junit.Assert.assertArrayEquals; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.fail; |
| import static org.junit.Assume.assumeNoException; |
| |
| import java.io.BufferedInputStream; |
| import java.io.BufferedReader; |
| import java.io.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.InputStreamReader; |
| import java.io.OutputStream; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| import java.util.concurrent.Callable; |
| import java.util.concurrent.ExecutorService; |
| import java.util.concurrent.Executors; |
| import java.util.concurrent.Future; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipInputStream; |
| |
| import org.eclipse.jgit.api.Git; |
| import org.eclipse.jgit.dircache.DirCache; |
| import org.eclipse.jgit.lib.CLIRepositoryTestCase; |
| import org.eclipse.jgit.lib.FileMode; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| public class ArchiveTest extends CLIRepositoryTestCase { |
| private Git git; |
| private String emptyTree; |
| |
| @Override |
| @Before |
| public void setUp() throws Exception { |
| super.setUp(); |
| git = new Git(db); |
| git.commit().setMessage("initial commit").call(); |
| emptyTree = db.resolve("HEAD^{tree}").abbreviate(12).name(); |
| } |
| |
| @Test |
| public void testEmptyArchive() throws Exception { |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=zip " + emptyTree, db).outBytes(); |
| assertArrayEquals(new String[0], listZipEntries(result)); |
| } |
| |
| @Test |
| public void testEmptyTar() throws Exception { |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=tar " + emptyTree, db).outBytes(); |
| assertArrayEquals(new String[0], listTarEntries(result)); |
| } |
| |
| @Test |
| public void testUnrecognizedFormat() throws Exception { |
| String[] expect = new String[] { |
| "fatal: Unknown archive format 'nonsense'", "" }; |
| String[] actual = executeUnchecked( |
| "git archive --format=nonsense " + emptyTree); |
| assertArrayEquals(expect, actual); |
| } |
| |
| @Test |
| public void testArchiveWithFiles() throws Exception { |
| writeTrashFile("a", "a file with content!"); |
| writeTrashFile("c", ""); // empty file |
| writeTrashFile("unrelated", "another file, just for kicks"); |
| git.add().addFilepattern("a").call(); |
| git.add().addFilepattern("c").call(); |
| git.commit().setMessage("populate toplevel").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=zip HEAD", db).outBytes(); |
| assertArrayEquals(new String[] { "a", "c" }, |
| listZipEntries(result)); |
| } |
| |
| private void commitGreeting() throws Exception { |
| writeTrashFile("greeting", "hello, world!"); |
| git.add().addFilepattern("greeting").call(); |
| git.commit().setMessage("a commit with a file").call(); |
| } |
| |
| @Test |
| public void testDefaultFormatIsTar() throws Exception { |
| commitGreeting(); |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive HEAD", db).outBytes(); |
| assertArrayEquals(new String[] { "greeting" }, |
| listTarEntries(result)); |
| } |
| |
| private static String shellQuote(String s) { |
| return "'" + s.replace("'", "'\\''") + "'"; |
| } |
| |
| @Test |
| public void testFormatOverridesFilename() throws Exception { |
| File archive = new File(db.getWorkTree(), "format-overrides-name.tar"); |
| String path = archive.getAbsolutePath(); |
| |
| commitGreeting(); |
| assertArrayEquals(new String[] { "" }, |
| execute("git archive " + |
| "--format=zip " + |
| shellQuote("--output=" + path) + " " + |
| "HEAD")); |
| assertContainsEntryWithMode(path, "", "greeting"); |
| assertIsZip(archive); |
| } |
| |
| @Test |
| public void testUnrecognizedExtensionMeansTar() throws Exception { |
| File archive = new File(db.getWorkTree(), "example.txt"); |
| String path = archive.getAbsolutePath(); |
| |
| commitGreeting(); |
| assertArrayEquals(new String[] { "" }, |
| execute("git archive " + |
| shellQuote("--output=" + path) + " " + |
| "HEAD")); |
| assertTarContainsEntry(path, "", "greeting"); |
| assertIsTar(archive); |
| } |
| |
| @Test |
| public void testNoExtensionMeansTar() throws Exception { |
| File archive = new File(db.getWorkTree(), "example"); |
| String path = archive.getAbsolutePath(); |
| |
| commitGreeting(); |
| assertArrayEquals(new String[] { "" }, |
| execute("git archive " + |
| shellQuote("--output=" + path) + " " + |
| "HEAD")); |
| assertIsTar(archive); |
| } |
| |
| @Test |
| public void testExtensionMatchIsAnchored() throws Exception { |
| File archive = new File(db.getWorkTree(), "two-extensions.zip.bak"); |
| String path = archive.getAbsolutePath(); |
| |
| commitGreeting(); |
| assertArrayEquals(new String[] { "" }, |
| execute("git archive " + |
| shellQuote("--output=" + path) + " " + |
| "HEAD")); |
| assertIsTar(archive); |
| } |
| |
| @Test |
| public void testZipExtension() throws Exception { |
| File archiveWithDot = new File(db.getWorkTree(), "greeting.zip"); |
| File archiveNoDot = new File(db.getWorkTree(), "greetingzip"); |
| |
| commitGreeting(); |
| execute("git archive " + |
| shellQuote("--output=" + archiveWithDot.getAbsolutePath()) + " " + |
| "HEAD"); |
| execute("git archive " + |
| shellQuote("--output=" + archiveNoDot.getAbsolutePath()) + " " + |
| "HEAD"); |
| assertIsZip(archiveWithDot); |
| assertIsTar(archiveNoDot); |
| } |
| |
| @Test |
| public void testTarExtension() throws Exception { |
| File archive = new File(db.getWorkTree(), "tarball.tar"); |
| String path = archive.getAbsolutePath(); |
| |
| commitGreeting(); |
| assertArrayEquals(new String[] { "" }, |
| execute("git archive " + |
| shellQuote("--output=" + path) + " " + |
| "HEAD")); |
| assertIsTar(archive); |
| } |
| |
| @Test |
| public void testTgzExtensions() throws Exception { |
| commitGreeting(); |
| |
| for (String ext : Arrays.asList("tar.gz", "tgz")) { |
| File archiveWithDot = new File(db.getWorkTree(), "tarball." + ext); |
| File archiveNoDot = new File(db.getWorkTree(), "tarball" + ext); |
| |
| execute("git archive " + |
| shellQuote("--output=" + archiveWithDot.getAbsolutePath()) + " " + |
| "HEAD"); |
| execute("git archive " + |
| shellQuote("--output=" + archiveNoDot.getAbsolutePath()) + " " + |
| "HEAD"); |
| assertIsGzip(archiveWithDot); |
| assertIsTar(archiveNoDot); |
| } |
| } |
| |
| @Test |
| public void testTbz2Extension() throws Exception { |
| commitGreeting(); |
| |
| for (String ext : Arrays.asList("tar.bz2", "tbz", "tbz2")) { |
| File archiveWithDot = new File(db.getWorkTree(), "tarball." + ext); |
| File archiveNoDot = new File(db.getWorkTree(), "tarball" + ext); |
| |
| execute("git archive " + |
| shellQuote("--output=" + archiveWithDot.getAbsolutePath()) + " " + |
| "HEAD"); |
| execute("git archive " + |
| shellQuote("--output=" + archiveNoDot.getAbsolutePath()) + " " + |
| "HEAD"); |
| assertIsBzip2(archiveWithDot); |
| assertIsTar(archiveNoDot); |
| } |
| } |
| |
| @Test |
| public void testTxzExtension() throws Exception { |
| commitGreeting(); |
| |
| for (String ext : Arrays.asList("tar.xz", "txz")) { |
| File archiveWithDot = new File(db.getWorkTree(), "tarball." + ext); |
| File archiveNoDot = new File(db.getWorkTree(), "tarball" + ext); |
| |
| execute("git archive " + |
| shellQuote("--output=" + archiveWithDot.getAbsolutePath()) + " " + |
| "HEAD"); |
| execute("git archive " + |
| shellQuote("--output=" + archiveNoDot.getAbsolutePath()) + " " + |
| "HEAD"); |
| assertIsXz(archiveWithDot); |
| assertIsTar(archiveNoDot); |
| } |
| } |
| |
| @Test |
| public void testArchiveWithSubdir() throws Exception { |
| writeTrashFile("a", "a file with content!"); |
| writeTrashFile("b.c", "before subdir in git sort order"); |
| writeTrashFile("b0c", "after subdir in git sort order"); |
| writeTrashFile("c", ""); |
| git.add().addFilepattern("a").call(); |
| git.add().addFilepattern("b.c").call(); |
| git.add().addFilepattern("b0c").call(); |
| git.add().addFilepattern("c").call(); |
| git.commit().setMessage("populate toplevel").call(); |
| writeTrashFile("b/b", "file in subdirectory"); |
| writeTrashFile("b/a", "another file in subdirectory"); |
| git.add().addFilepattern("b").call(); |
| git.commit().setMessage("add subdir").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=zip master", db).outBytes(); |
| String[] expect = { "a", "b.c", "b0c", "b/", "b/a", "b/b", "c" }; |
| String[] actual = listZipEntries(result); |
| |
| Arrays.sort(expect); |
| Arrays.sort(actual); |
| assertArrayEquals(expect, actual); |
| } |
| |
| @Test |
| public void testTarWithSubdir() throws Exception { |
| writeTrashFile("a", "a file with content!"); |
| writeTrashFile("b.c", "before subdir in git sort order"); |
| writeTrashFile("b0c", "after subdir in git sort order"); |
| writeTrashFile("c", ""); |
| git.add().addFilepattern("a").call(); |
| git.add().addFilepattern("b.c").call(); |
| git.add().addFilepattern("b0c").call(); |
| git.add().addFilepattern("c").call(); |
| git.commit().setMessage("populate toplevel").call(); |
| writeTrashFile("b/b", "file in subdirectory"); |
| writeTrashFile("b/a", "another file in subdirectory"); |
| git.add().addFilepattern("b").call(); |
| git.commit().setMessage("add subdir").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=tar master", db).outBytes(); |
| String[] expect = { "a", "b.c", "b0c", "b/", "b/a", "b/b", "c" }; |
| String[] actual = listTarEntries(result); |
| |
| Arrays.sort(expect); |
| Arrays.sort(actual); |
| assertArrayEquals(expect, actual); |
| } |
| |
| private void commitBazAndFooSlashBar() throws Exception { |
| writeTrashFile("baz", "a file"); |
| writeTrashFile("foo/bar", "another file"); |
| git.add().addFilepattern("baz").call(); |
| git.add().addFilepattern("foo").call(); |
| git.commit().setMessage("sample commit").call(); |
| } |
| |
| @Test |
| public void testArchivePrefixOption() throws Exception { |
| commitBazAndFooSlashBar(); |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --prefix=x/ --format=zip master", db).outBytes(); |
| String[] expect = { "x/", "x/baz", "x/foo/", "x/foo/bar" }; |
| String[] actual = listZipEntries(result); |
| |
| Arrays.sort(expect); |
| Arrays.sort(actual); |
| assertArrayEquals(expect, actual); |
| } |
| |
| @Test |
| public void testTarPrefixOption() throws Exception { |
| commitBazAndFooSlashBar(); |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --prefix=x/ --format=tar master", db).outBytes(); |
| String[] expect = { "x/", "x/baz", "x/foo/", "x/foo/bar" }; |
| String[] actual = listTarEntries(result); |
| |
| Arrays.sort(expect); |
| Arrays.sort(actual); |
| assertArrayEquals(expect, actual); |
| } |
| |
| private void commitFoo() throws Exception { |
| writeTrashFile("foo", "a file"); |
| git.add().addFilepattern("foo").call(); |
| git.commit().setMessage("boring commit").call(); |
| } |
| |
| @Test |
| public void testPrefixDoesNotNormalizeDoubleSlash() throws Exception { |
| commitFoo(); |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --prefix=x// --format=zip master", db).outBytes(); |
| String[] expect = { "x/", "x//foo" }; |
| assertArrayEquals(expect, listZipEntries(result)); |
| } |
| |
| @Test |
| public void testPrefixDoesNotNormalizeDoubleSlashInTar() throws Exception { |
| commitFoo(); |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --prefix=x// --format=tar master", db).outBytes(); |
| String[] expect = { "x/", "x//foo" }; |
| assertArrayEquals(expect, listTarEntries(result)); |
| } |
| |
| /** |
| * The prefix passed to "git archive" need not end with '/'. |
| * In practice it is not very common to have a nonempty prefix |
| * that does not name a directory (and hence end with /), but |
| * since git has historically supported other prefixes, we do, |
| * too. |
| * |
| * @throws Exception |
| */ |
| @Test |
| public void testPrefixWithoutTrailingSlash() throws Exception { |
| commitBazAndFooSlashBar(); |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --prefix=my- --format=zip master", db).outBytes(); |
| String[] expect = { "my-baz", "my-foo/", "my-foo/bar" }; |
| String[] actual = listZipEntries(result); |
| |
| Arrays.sort(expect); |
| Arrays.sort(actual); |
| assertArrayEquals(expect, actual); |
| } |
| |
| @Test |
| public void testTarPrefixWithoutTrailingSlash() throws Exception { |
| commitBazAndFooSlashBar(); |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --prefix=my- --format=tar master", db).outBytes(); |
| String[] expect = { "my-baz", "my-foo/", "my-foo/bar" }; |
| String[] actual = listTarEntries(result); |
| |
| Arrays.sort(expect); |
| Arrays.sort(actual); |
| assertArrayEquals(expect, actual); |
| } |
| |
| @Test |
| public void testArchiveIncludesSubmoduleDirectory() throws Exception { |
| writeTrashFile("a", "a file with content!"); |
| writeTrashFile("c", "after submodule"); |
| git.add().addFilepattern("a").call(); |
| git.add().addFilepattern("c").call(); |
| git.commit().setMessage("initial commit").call(); |
| git.submoduleAdd().setURI("./.").setPath("b").call().close(); |
| git.commit().setMessage("add submodule").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=zip master", db).outBytes(); |
| String[] expect = { ".gitmodules", "a", "b/", "c" }; |
| String[] actual = listZipEntries(result); |
| |
| Arrays.sort(expect); |
| Arrays.sort(actual); |
| assertArrayEquals(expect, actual); |
| } |
| |
| @Test |
| public void testTarIncludesSubmoduleDirectory() throws Exception { |
| writeTrashFile("a", "a file with content!"); |
| writeTrashFile("c", "after submodule"); |
| git.add().addFilepattern("a").call(); |
| git.add().addFilepattern("c").call(); |
| git.commit().setMessage("initial commit").call(); |
| git.submoduleAdd().setURI("./.").setPath("b").call().close(); |
| git.commit().setMessage("add submodule").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=tar master", db).outBytes(); |
| String[] expect = { ".gitmodules", "a", "b/", "c" }; |
| String[] actual = listTarEntries(result); |
| |
| Arrays.sort(expect); |
| Arrays.sort(actual); |
| assertArrayEquals(expect, actual); |
| } |
| |
| @Test |
| public void testArchivePreservesMode() throws Exception { |
| writeTrashFile("plain", "a file with content"); |
| writeTrashFile("executable", "an executable file"); |
| writeTrashFile("symlink", "plain"); |
| writeTrashFile("dir/content", "clutter in a subdir"); |
| git.add().addFilepattern("plain").call(); |
| git.add().addFilepattern("executable").call(); |
| git.add().addFilepattern("symlink").call(); |
| git.add().addFilepattern("dir").call(); |
| |
| DirCache cache = db.lockDirCache(); |
| cache.getEntry("executable").setFileMode(FileMode.EXECUTABLE_FILE); |
| cache.getEntry("symlink").setFileMode(FileMode.SYMLINK); |
| cache.write(); |
| cache.commit(); |
| cache.unlock(); |
| |
| git.commit().setMessage("three files with different modes").call(); |
| |
| byte[] zipData = CLIGitCommand.executeRaw( |
| "git archive --format=zip master", db).outBytes(); |
| writeRaw("zip-with-modes.zip", zipData); |
| assertContainsEntryWithMode("zip-with-modes.zip", "-rw-", "plain"); |
| assertContainsEntryWithMode("zip-with-modes.zip", "-rwx", "executable"); |
| assertContainsEntryWithMode("zip-with-modes.zip", "l", "symlink"); |
| assertContainsEntryWithMode("zip-with-modes.zip", "-rw-", "dir/"); |
| } |
| |
| @Test |
| public void testTarPreservesMode() throws Exception { |
| writeTrashFile("plain", "a file with content"); |
| writeTrashFile("executable", "an executable file"); |
| writeTrashFile("symlink", "plain"); |
| writeTrashFile("dir/content", "clutter in a subdir"); |
| git.add().addFilepattern("plain").call(); |
| git.add().addFilepattern("executable").call(); |
| git.add().addFilepattern("symlink").call(); |
| git.add().addFilepattern("dir").call(); |
| |
| DirCache cache = db.lockDirCache(); |
| cache.getEntry("executable").setFileMode(FileMode.EXECUTABLE_FILE); |
| cache.getEntry("symlink").setFileMode(FileMode.SYMLINK); |
| cache.write(); |
| cache.commit(); |
| cache.unlock(); |
| |
| git.commit().setMessage("three files with different modes").call(); |
| |
| byte[] archive = CLIGitCommand.executeRaw( |
| "git archive --format=tar master", db).outBytes(); |
| writeRaw("with-modes.tar", archive); |
| assertTarContainsEntry("with-modes.tar", "-rw-r--r--", "plain"); |
| assertTarContainsEntry("with-modes.tar", "-rwxr-xr-x", "executable"); |
| assertTarContainsEntry("with-modes.tar", "l", "symlink -> plain"); |
| assertTarContainsEntry("with-modes.tar", "drwxr-xr-x", "dir/"); |
| } |
| |
| @Test |
| public void testArchiveWithLongFilename() throws Exception { |
| StringBuilder filename = new StringBuilder(); |
| List<String> l = new ArrayList<>(); |
| for (int i = 0; i < 20; i++) { |
| filename.append("1234567890/"); |
| l.add(filename.toString()); |
| } |
| filename.append("1234567890"); |
| l.add(filename.toString()); |
| writeTrashFile(filename.toString(), "file with long path"); |
| git.add().addFilepattern("1234567890").call(); |
| git.commit().setMessage("file with long name").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=zip HEAD", db).outBytes(); |
| assertArrayEquals(l.toArray(new String[l.size()]), |
| listZipEntries(result)); |
| } |
| |
| @Test |
| public void testTarWithLongFilename() throws Exception { |
| StringBuilder filename = new StringBuilder(); |
| List<String> l = new ArrayList<>(); |
| for (int i = 0; i < 20; i++) { |
| filename.append("1234567890/"); |
| l.add(filename.toString()); |
| } |
| filename.append("1234567890"); |
| l.add(filename.toString()); |
| writeTrashFile(filename.toString(), "file with long path"); |
| git.add().addFilepattern("1234567890").call(); |
| git.commit().setMessage("file with long name").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=tar HEAD", db).outBytes(); |
| assertArrayEquals(l.toArray(new String[l.size()]), |
| listTarEntries(result)); |
| } |
| |
| @Test |
| public void testArchivePreservesContent() throws Exception { |
| String payload = "“The quick brown fox jumps over the lazy dog!”"; |
| writeTrashFile("xyzzy", payload); |
| git.add().addFilepattern("xyzzy").call(); |
| git.commit().setMessage("add file with content").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=zip HEAD", db).outBytes(); |
| assertArrayEquals(new String[] { payload }, |
| zipEntryContent(result, "xyzzy")); |
| } |
| |
| @Test |
| public void testTarPreservesContent() throws Exception { |
| String payload = "“The quick brown fox jumps over the lazy dog!”"; |
| writeTrashFile("xyzzy", payload); |
| git.add().addFilepattern("xyzzy").call(); |
| git.commit().setMessage("add file with content").call(); |
| |
| byte[] result = CLIGitCommand.executeRaw( |
| "git archive --format=tar HEAD", db).outBytes(); |
| assertArrayEquals(new String[] { payload }, |
| tarEntryContent(result, "xyzzy")); |
| } |
| |
| private Process spawnAssumingCommandPresent(String... cmdline) { |
| File cwd = db.getWorkTree(); |
| ProcessBuilder procBuilder = new ProcessBuilder(cmdline) |
| .directory(cwd) |
| .redirectErrorStream(true); |
| Process proc = null; |
| try { |
| proc = procBuilder.start(); |
| } catch (IOException e) { |
| // On machines without `cmdline[0]`, let the test pass. |
| assumeNoException(e); |
| } |
| |
| return proc; |
| } |
| |
| private BufferedReader readFromProcess(Process proc) throws Exception { |
| return new BufferedReader( |
| new InputStreamReader(proc.getInputStream(), CHARSET)); |
| } |
| |
| private void grepForEntry(String name, String mode, String... cmdline) |
| throws Exception { |
| Process proc = spawnAssumingCommandPresent(cmdline); |
| proc.getOutputStream().close(); |
| BufferedReader reader = readFromProcess(proc); |
| try { |
| String line; |
| while ((line = reader.readLine()) != null) |
| if (line.startsWith(mode) && line.endsWith(name)) |
| // found it! |
| return; |
| fail("expected entry " + name + " with mode " + mode + " but found none"); |
| } finally { |
| proc.getOutputStream().close(); |
| proc.destroy(); |
| } |
| } |
| |
| private void assertMagic(long offset, byte[] magicBytes, File file) throws Exception { |
| try (BufferedInputStream in = new BufferedInputStream( |
| new FileInputStream(file))) { |
| if (offset > 0) { |
| long skipped = in.skip(offset); |
| assertEquals(offset, skipped); |
| } |
| |
| byte[] actual = new byte[magicBytes.length]; |
| in.read(actual); |
| assertArrayEquals(magicBytes, actual); |
| } |
| } |
| |
| private void assertMagic(byte[] magicBytes, File file) throws Exception { |
| assertMagic(0, magicBytes, file); |
| } |
| |
| private void assertIsTar(File file) throws Exception { |
| assertMagic(257, new byte[] { 'u', 's', 't', 'a', 'r', 0 }, file); |
| } |
| |
| private void assertIsZip(File file) throws Exception { |
| assertMagic(new byte[] { 'P', 'K', 3, 4 }, file); |
| } |
| |
| private void assertIsGzip(File file) throws Exception { |
| assertMagic(new byte[] { 037, (byte) 0213 }, file); |
| } |
| |
| private void assertIsBzip2(File file) throws Exception { |
| assertMagic(new byte[] { 'B', 'Z', 'h' }, file); |
| } |
| |
| private void assertIsXz(File file) throws Exception { |
| assertMagic(new byte[] { (byte) 0xfd, '7', 'z', 'X', 'Z', 0 }, file); |
| } |
| |
| private void assertContainsEntryWithMode(String zipFilename, String mode, String name) |
| throws Exception { |
| grepForEntry(name, mode, "zipinfo", zipFilename); |
| } |
| |
| private void assertTarContainsEntry(String tarfile, String mode, String name) |
| throws Exception { |
| grepForEntry(name, mode, "tar", "tvf", tarfile); |
| } |
| |
| private void writeRaw(String filename, byte[] data) |
| throws IOException { |
| File path = new File(db.getWorkTree(), filename); |
| try (OutputStream out = new FileOutputStream(path)) { |
| out.write(data); |
| } |
| } |
| |
| private static String[] listZipEntries(byte[] zipData) throws IOException { |
| List<String> l = new ArrayList<>(); |
| try (ZipInputStream in = new ZipInputStream( |
| new ByteArrayInputStream(zipData))) { |
| ZipEntry e; |
| while ((e = in.getNextEntry()) != null) |
| l.add(e.getName()); |
| } |
| return l.toArray(new String[l.size()]); |
| } |
| |
| private static Future<Object> writeAsync(OutputStream stream, byte[] data) { |
| ExecutorService executor = Executors.newSingleThreadExecutor(); |
| |
| return executor.submit(new Callable<Object>() { |
| @Override |
| public Object call() throws IOException { |
| try { |
| stream.write(data); |
| return null; |
| } finally { |
| stream.close(); |
| } |
| } |
| }); |
| } |
| |
| private String[] listTarEntries(byte[] tarData) throws Exception { |
| List<String> l = new ArrayList<>(); |
| Process proc = spawnAssumingCommandPresent("tar", "tf", "-"); |
| try (BufferedReader reader = readFromProcess(proc)) { |
| OutputStream out = proc.getOutputStream(); |
| |
| // Dump tarball to tar stdin in background |
| Future<?> writing = writeAsync(out, tarData); |
| |
| try { |
| String line; |
| while ((line = reader.readLine()) != null) |
| l.add(line); |
| |
| return l.toArray(new String[l.size()]); |
| } finally { |
| writing.get(); |
| proc.destroy(); |
| } |
| } |
| } |
| |
| private static String[] zipEntryContent(byte[] zipData, String path) |
| throws IOException { |
| ZipInputStream in = new ZipInputStream( |
| new ByteArrayInputStream(zipData)); |
| ZipEntry e; |
| while ((e = in.getNextEntry()) != null) { |
| if (!e.getName().equals(path)) |
| continue; |
| |
| // found! |
| List<String> l = new ArrayList<>(); |
| BufferedReader reader = new BufferedReader( |
| new InputStreamReader(in, CHARSET)); |
| String line; |
| while ((line = reader.readLine()) != null) |
| l.add(line); |
| return l.toArray(new String[l.size()]); |
| } |
| |
| // not found |
| return null; |
| } |
| |
| private String[] tarEntryContent(byte[] tarData, String path) |
| throws Exception { |
| List<String> l = new ArrayList<>(); |
| Process proc = spawnAssumingCommandPresent("tar", "Oxf", "-", path); |
| try (BufferedReader reader = readFromProcess(proc)) { |
| OutputStream out = proc.getOutputStream(); |
| Future<?> writing = writeAsync(out, tarData); |
| |
| try { |
| String line; |
| while ((line = reader.readLine()) != null) |
| l.add(line); |
| |
| return l.toArray(new String[l.size()]); |
| } finally { |
| writing.get(); |
| proc.destroy(); |
| } |
| } |
| } |
| } |