internal TarWritableArchiveEntry(TarArchive archive, Stream stream, CompressionType compressionType, string path, long size, DateTime? lastModified, bool closeStream)
: base(archive, null, compressionType)
{
this.stream = stream;
this.path = path;
this.size = size;
this.lastModified = lastModified;
this.closeStream = closeStream;
}
internal TarWritableArchiveEntry(int index, TarArchive archive, Stream stream, CompressionType compressionType,
string path, long size, DateTime? lastModified)
: base(index, archive, null, compressionType)
{
this.Stream = stream;
this.path = path;
this.size = size;
this.lastModified = lastModified;
}
public void DockerfileArchiveTar()
{
// Given
var expected = new List <string> {
"Dockerfile", "setup", "setup/setup.sh"
};
var actual = new List <string>();
var dockerFileArchive = new DockerfileArchive("./Assets");
using (var tarOut = new FileInfo(dockerFileArchive.Tar()).OpenRead())
{
using (var tarIn = TarArchive.CreateInputTarArchive(tarOut))
{
tarIn.ProgressMessageEvent += (archive, entry, message) => actual.Add(entry.Name);
tarIn.ListContents();
}
}
Assert.Equal(expected, actual);
}
private static void AddDirectoryFilesToTar(TarArchive tarArchive, string rootDirectory, string filePath)
{
filePath = filePath.Replace("\\", "/");
string absFilePath = filePath.Replace(rootDirectory, "").Remove(0, 1);
// Debug.Log(absFilePath);
string[] parentDirInfos = absFilePath.Split('/');
string parentDir = "";
string sp = "/";
for (int i = 0; i < parentDirInfos.Length - 1; i++)
{
parentDir += sp + parentDirInfos[i];
TarEntry tarEntryDic = TarEntry.CreateEntryFromFile(rootDirectory + parentDir);
tarArchive.WriteEntry(tarEntryDic, false);
// Debug.Log(rootDirectory + parentDir);
}
TarEntry tarEntry = TarEntry.CreateEntryFromFile(filePath);
tarArchive.WriteEntry(tarEntry, true);
}
public static void Run(string[] args)
{
if (!File.Exists("cifar-10-binary.tar.gz"))
{
Console.WriteLine("Please download the binary version of the CIFAR-10 dataset from https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz");
return;
}
Console.WriteLine("reading cifar-10-binary.tar.gz");
using (var sr = File.OpenRead("cifar-10-binary.tar.gz"))
using (var gz = new GZipStream(sr, CompressionMode.Decompress))
using (var tar = TarArchive.CreateInputTarArchive(gz))
{
Console.WriteLine("extracting tar file");
tar.ExtractContents(".");
}
Console.WriteLine("reading test_batch.bin");
var bytes = File.ReadAllBytes("cifar-10-batches-bin\\test_batch.bin");
Console.WriteLine("writing cifar-test.tsv");
File.WriteAllLines("cifar-test.tsv", BytesToString(bytes));
Console.WriteLine("done");
}
public static bool TryOpen(FileInfo fileInfo, ReaderOptions options, ArchiveTypeMask archiveTypes, out IArchive archive)
{
fileInfo.CheckNotNull("fileInfo");
options = options ?? new ReaderOptions {
LeaveStreamOpen = false
};
using (var stream = fileInfo.OpenRead())
{
if (archiveTypes.HasFlag(ArchiveTypeMask.Zip) && ZipArchive.IsZipFile(stream, null))
{
archive = ZipArchive.Open(fileInfo, options);
}
stream.Seek(0, SeekOrigin.Begin);
if (archiveTypes.HasFlag(ArchiveTypeMask.SevenZip) && SevenZipArchive.IsSevenZipFile(stream))
{
archive = SevenZipArchive.Open(fileInfo, options);
}
stream.Seek(0, SeekOrigin.Begin);
if (archiveTypes.HasFlag(ArchiveTypeMask.GZip) && GZipArchive.IsGZipFile(stream))
{
archive = GZipArchive.Open(fileInfo, options);
return(true);
}
stream.Seek(0, SeekOrigin.Begin);
if (archiveTypes.HasFlag(ArchiveTypeMask.Rar) && RarArchive.IsRarFile(stream, options))
{
archive = RarArchive.Open(fileInfo, options);
return(true);
}
stream.Seek(0, SeekOrigin.Begin);
if (archiveTypes.HasFlag(ArchiveTypeMask.Tar) && TarArchive.IsTarFile(stream))
{
archive = TarArchive.Open(fileInfo, options);
return(true);
}
}
archive = null;
return(false);
}
private IArchive GetArchiveReader(CompressionType romFileCompressionType, string sourceFile)
{
switch (romFileCompressionType)
{
case CompressionType.Sevenzip:
return(SevenZipArchive.Open(sourceFile));
case CompressionType.Gzip:
return(GZipArchive.Open(sourceFile));
case CompressionType.Rar:
return(RarArchive.Open(sourceFile));
case CompressionType.Tar:
return(TarArchive.Open(sourceFile));
case CompressionType.Zip:
return(ZipArchive.Open(sourceFile));
}
return(null);
}
private static void AddDirectoryFilesToTar(TarArchive tarArchive, string sourceDirectory, bool recurse)
{
TarEntry tarEntry = TarEntry.CreateEntryFromFile(sourceDirectory);
tarArchive.WriteEntry(tarEntry, false);
string[] filenames = Directory.GetFiles(sourceDirectory);
foreach (string filename in filenames)
{
tarEntry = TarEntry.CreateEntryFromFile(filename);
tarArchive.WriteEntry(tarEntry, true);
}
if (recurse)
{
string[] directories = Directory.GetDirectories(sourceDirectory);
foreach (string directory in directories)
{
AddDirectoryFilesToTar(tarArchive, directory, recurse);
}
}
}
/// <summary>
/// Creates a compressed file from this directory.
/// </summary>
/// <param name="destination">Path of the target zip file to generate.</param>
public static void Compress(this DirectoryInfo source, CompressionFormat format, FileInfo destination, bool overwrite = false)
{
if (destination == null)
{
throw new ArgumentNullException(nameof(destination));
}
if (destination.Exists() && !overwrite)
{
throw new Exception("Destination file already exists: " + destination.FullName);
}
IWritableArchive archive;
var type = CompressionType.Deflate;
switch (format)
{
case CompressionFormat.Zip:
archive = ZipArchive.Create();
break;
case CompressionFormat.Gzip:
archive = GZipArchive.Create();
break;
case CompressionFormat.Tar:
archive = TarArchive.Create();
type = CompressionType.None;
break;
default: throw new NotSupportedException();
}
using (archive)
{
archive.AddAllFromDirectory(source.FullName);
archive.SaveTo(destination.FullName, type);
}
}
public string Tar()
{
using (var dockerfileArchiveStream = File.Create(this.DockerfileArchiveFile.FullName))
{
using (var dockerfileArchive = TarArchive.CreateOutputTarArchive(dockerfileArchiveStream))
{
dockerfileArchive.RootPath = this.BaseDirectory.FullName;
void Tar(string baseDirectory)
{
baseDirectory = baseDirectory.Replace('\\', '/');
void WriteEntry(string entry)
{
entry = entry.Replace('\\', '/');
var tarEntry = TarEntry.CreateEntryFromFile(entry);
tarEntry.Name = entry.Replace(dockerfileArchive.RootPath, string.Empty).TrimStart(TrimLeadingChars);
tarEntry.ModTime = DisableModTime;
dockerfileArchive.WriteEntry(tarEntry, File.Exists(entry));
}
if (!dockerfileArchive.RootPath.Equals(baseDirectory))
{
WriteEntry(baseDirectory);
}
Directory.GetFiles(baseDirectory).ToList().ForEach(WriteEntry);
Directory.GetDirectories(baseDirectory).ToList().ForEach(Tar);
}
Tar(this.BaseDirectory.FullName);
}
}
return(this.DockerfileArchiveFile.FullName);
}
public async Task <GetImagesFromArchiveResult> GetImagesFromTarFileAsync(StorageFile file)
{
CompositeDisposable disposables = new CompositeDisposable();
var stream = await file.OpenStreamForReadAsync()
.AddTo(disposables);
var zipArchive = TarArchive.Open(stream)
.AddTo(disposables);
var supportedEntries = zipArchive.Entries
.OrderBy(x => x.Key)
.Where(x => SupportedFileTypesHelper.IsSupportedImageFileExtension(x.Key))
.Select(x => (IImageSource) new ArchiveEntryImageSource(x, file, _recyclableMemoryStreamManager))
.ToArray();
return new GetImagesFromArchiveResult()
{
ItemsCount = (uint)supportedEntries.Length,
Disposer = disposables,
Images = supportedEntries,
};
}
public static string CreateTar(string directoryToCompress, string destPath, string tarFile)
{
string destDrive = destPath.Substring(0, destPath.IndexOf(@"\") + 1);
Directory.SetCurrentDirectory(destDrive);
string tarFilePath = Path.Combine(destPath, tarFile);
using (Stream fs = new FileStream(tarFilePath, FileMode.OpenOrCreate))
{
using (TarArchive ta = TarArchive.CreateOutputTarArchive(fs))
{
string[] files = Directory.GetFiles(directoryToCompress);
foreach (string file in files)
{
string entry = file.Substring(file.IndexOf(@"\") + 1);
TarEntry te = TarEntry.CreateEntryFromFile(entry);
ta.WriteEntry(te, false);
}
}
}
return(tarFilePath);
}
/// <summary>
/// Compresses a file using the .tgz format.
/// </summary>
/// <param name="sourceDir">The directory to compress.</param>
/// <param name="fileName">The name of the archive to be created.</param>
public static void ZipFile(string sourceDir, string fileName)
{
using (Stream outStream = File.Create(fileName))
{
using (Stream gzoStream = new GZipOutputStream(outStream))
{
using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(gzoStream))
{
// Note that the RootPath is currently case sensitive and must be forward slashes e.g. "c:/temp"
// and must not end with a slash, otherwise cuts off first char of filename
// This is scheduled for fix in next release
tarArchive.RootPath = sourceDir.Replace('\\', '/');
if (tarArchive.RootPath.EndsWith("/"))
{
tarArchive.RootPath = tarArchive.RootPath.Remove(tarArchive.RootPath.Length - 1);
}
AddDirectoryFilesToTar(tarArchive, sourceDir, true);
}
}
}
}
public void Update()
{
if (!File.Exists(ArchivePath))
{
throw new Exception("Archive doesn't exist");
}
var tmp = System.IO.Directory.CreateDirectory(Path.Combine(Path.GetDirectoryName(ArchivePath), "tmp"));
using (var fs = File.OpenRead(ArchivePath))
{
using (var decompresed = new GZipInputStream(fs))
{
using (var tararchive = TarArchive.CreateInputTarArchive(decompresed, Encoding.UTF8))
{
tararchive.ExtractContents(tmp.FullName);
}
}
}
File.Create(Path.Combine(tmp.FullName, "foo.c")).Close();
File.Create(Path.Combine(tmp.FullName, "bar.c")).Close();
File.Delete(ArchivePath); //Was possible error
var prepared = GetPreparedFiles(tmp.FullName);
using (var fs = new FileStream(ArchivePath, FileMode.Create))
{
using (var compres = new GZipOutputStream(fs))
{
using (var archive = TarArchive.CreateOutputTarArchive(compres))
{
archive.RootPath = tmp.FullName;
foreach (var p in prepared) //Was error
{
archive.WriteEntry(TarEntry.CreateEntryFromFile(p), true);
}
}
}
}
System.IO.Directory.Delete(tmp.FullName, true); //Was error, recursive
}
public string InstallTheme(GLib.File file)
{
if (!file.Exists)
{
return(null);
}
if (!DockServices.Paths.UserDataFolder.Exists)
{
DockServices.Paths.UserDataFolder.MakeDirectory(null);
}
GLib.File themeDir = DockServices.Paths.UserDataFolder.GetChild("themes");
if (!themeDir.Exists)
{
themeDir.MakeDirectory(null);
}
Log <ThemeService> .Info("Trying to install theme: {0}", file.Path);
try {
List <string> oldThemes = DockThemes.ToList();
TarArchive ar = TarArchive.CreateInputTarArchive(new System.IO.FileStream(file.Path, System.IO.FileMode.Open));
ar.ExtractContents(themeDir.Path);
List <string> newThemes = DockThemes.ToList();
newThemes.RemoveAll(f => oldThemes.Contains(f));
if (newThemes.Count == 1)
{
return(newThemes [0]);
}
return(null);
} catch (Exception e) {
Log <ThemeService> .Error("Error trying to unpack '{0}': {1}", file.Path, e.Message);
Log <ThemeService> .Debug(e.StackTrace);
return(null);
}
}
public void EmptyTar()
{
MemoryStream ms = new MemoryStream();
TarArchive tarOut = TarArchive.CreateOutputTarArchive(ms);
tarOut.CloseArchive();
Assert.IsTrue(ms.GetBuffer().Length > 0, "Archive size must be > zero");
Assert.AreEqual(ms.GetBuffer().Length % tarOut.RecordSize, 0, "Archive size must be a multiple of record size");
MemoryStream ms2 = new MemoryStream();
ms2.Write(ms.GetBuffer(), 0, ms.GetBuffer().Length);
ms2.Seek(0, SeekOrigin.Begin);
TarArchive tarIn = TarArchive.CreateInputTarArchive(ms2);
entryCount = 0;
tarIn.ProgressMessageEvent += new ProgressMessageHandler(EntryCounter);
tarIn.ListContents();
Assert.AreEqual(0, entryCount, "Expected 0 tar entries");
}
private static void CompressTar(string directory, string archiveFile, Predicate <FileInfo> filter, Func <Stream, Stream> outputStreamFactory)
{
FileSystemTasks.EnsureExistingParentDirectory(archiveFile);
var files = GetFiles(directory, filter);
using (var fileStream = File.Open(archiveFile, FileMode.CreateNew, FileAccess.ReadWrite))
using (var outputStream = outputStreamFactory(fileStream))
using (var tarArchive = TarArchive.CreateOutputTarArchive(outputStream))
{
foreach (var file in files)
{
var entry = TarEntry.CreateEntryFromFile(file);
var relativePath = PathConstruction.GetRelativePath(directory, file);
entry.Name = PathConstruction.NormalizePath(relativePath, separator: '/');
tarArchive.WriteEntry(entry, recurse: false);
}
}
Logger.Info($"Compressed content of '{directory}' to '{Path.GetFileName(archiveFile)}'.");
}
/// <summary>
/// Opens an Archive for random access
/// </summary>
/// <param name="stream"></param>
/// <param name="readerOptions"></param>
/// <returns></returns>
public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
{
stream.CheckNotNull("stream");
if (!stream.CanRead || !stream.CanSeek)
{
throw new ArgumentException("Stream should be readable and seekable");
}
readerOptions = readerOptions ?? new ReaderOptions();
if (ZipArchive.IsZipFile(stream, null))
{
stream.Seek(0, SeekOrigin.Begin);
return(ZipArchive.Open(stream, readerOptions));
}
stream.Seek(0, SeekOrigin.Begin);
if (SevenZipArchive.IsSevenZipFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return(SevenZipArchive.Open(stream, readerOptions));
}
stream.Seek(0, SeekOrigin.Begin);
if (GZipArchive.IsGZipFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return(GZipArchive.Open(stream, readerOptions));
}
stream.Seek(0, SeekOrigin.Begin);
if (RarArchive.IsRarFile(stream, readerOptions))
{
stream.Seek(0, SeekOrigin.Begin);
return(RarArchive.Open(stream, readerOptions));
}
stream.Seek(0, SeekOrigin.Begin);
if (TarArchive.IsTarFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return(TarArchive.Open(stream, readerOptions));
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
}
/// <summary>
/// Constructor with a FileInfo object to an existing file.
/// </summary>
/// <param name="fileInfo"></param>
/// <param name="options"></param>
public static IArchive Open(FileInfo fileInfo, ReaderOptions options = null)
{
fileInfo.CheckNotNull("fileInfo");
options = options ?? new ReaderOptions();
using (var stream = fileInfo.OpenRead())
{
if (ZipArchive.IsZipFile(stream, null))
{
stream.Dispose();
return(ZipArchive.Open(fileInfo, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (SevenZipArchive.IsSevenZipFile(stream))
{
stream.Dispose();
return(SevenZipArchive.Open(fileInfo, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (GZipArchive.IsGZipFile(stream))
{
stream.Dispose();
return(GZipArchive.Open(fileInfo, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (RarArchive.IsRarFile(stream, options))
{
stream.Dispose();
return(RarArchive.Open(fileInfo, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (TarArchive.IsTarFile(stream))
{
stream.Dispose();
return(TarArchive.Open(fileInfo, options));
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
}
}
public static string Create(string packageFolder, string outputFolder)
{
JObject manifest = PublicationManifest.LoadManifest(packageFolder);
string packageName = manifest["name"] + "-" + manifest["version"] + ".tgz";
Directory.CreateDirectory(outputFolder);
string outputFile = Path.Combine(outputFolder, packageName);
Stream outStream = File.Create(outputFile);
Stream gzoStream = new GZipOutputStream(outStream);
TarArchive tarArchive = TarArchive.CreateOutputTarArchive(gzoStream);
AddDirectoryFilesToTar(tarArchive, packageFolder, true, "packages/");
tarArchive.Close();
gzoStream.Close();
outStream.Close();
return(outputFile);
}
public void CompressFolderContentToArchiveFile(FileInfo targetFileName, DirectoryInfo sourceFileFolder)
{
Stream outStream = File.Create(targetFileName.FullName);
var tarOutputStream = new TarOutputStream(outStream);
var tarArchive = TarArchive.CreateOutputTarArchive(tarOutputStream);
// TODO: check difference between writing and not writing this
// Optionally, write an entry for the directory itself.
//TarEntry tarEntry = TarEntry.CreateEntryFromFile(sourceFileFolder);
//tarOutputStream.PutNextEntry(tarEntry);
var filenames = System.IO.Directory.GetFiles(sourceFileFolder.FullName, "*.*", SearchOption.AllDirectories);
// Remove source file path from filename and add each file to the TAR acrchive
foreach (var filename in filenames)
{
using (Stream inputStream = File.OpenRead(filename))
{
var tarName = filename.Replace(sourceFileFolder.FullName, "");
var fileSize = inputStream.Length;
var entry = TarEntry.CreateTarEntry(tarName);
entry.Size = fileSize;
tarOutputStream.PutNextEntry(entry);
var localBuffer = new byte[32 * 1024];
while (true)
{
var numRead = inputStream.Read(localBuffer, 0, localBuffer.Length);
if (numRead <= 0)
{
break;
}
tarOutputStream.Write(localBuffer, 0, numRead);
}
}
tarOutputStream.CloseEntry();
}
tarOutputStream.Close();
}
/// <summary>
/// Opens an Archive for random access
/// </summary>
/// <param name="stream"></param>
/// <param name="options"></param>
/// <returns></returns>
public static IArchive Open(Stream stream, Options options = Options.KeepStreamsOpen)
{
stream.CheckNotNull("stream");
if (!stream.CanRead || !stream.CanSeek)
{
throw new ArgumentException("Stream should be readable and seekable");
}
if (ZipArchive.IsZipFile(stream, null))
{
stream.Seek(0, SeekOrigin.Begin);
return(ZipArchive.Open(stream, options, null));
}
stream.Seek(0, SeekOrigin.Begin);
if (RarArchive.IsRarFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return(RarArchive.Open(stream, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (TarArchive.IsTarFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return(TarArchive.Open(stream, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (SevenZipArchive.IsSevenZipFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return(SevenZipArchive.Open(stream, options));
}
stream.Seek(0, SeekOrigin.Begin);
if (GZipArchive.IsGZipFile(stream))
{
stream.Seek(0, SeekOrigin.Begin);
return(GZipArchive.Open(stream, options));
}
throw new InvalidOperationException("Cannot determine compressed stream type.");
}
public string ExtractTarFile(string tarFileName)
{
using (Stream inStream = File.OpenRead(tarFileName))
{
using (var tarArchive = TarArchive.CreateInputTarArchive(inStream))
{
tarArchive.ExtractContents(_tempPath);
}
}
foreach (var directory in Directory.GetDirectories(_tempPath))
{
var files = Directory.GetFiles(directory);
if (files != null && files.Any(f => f.EndsWith(".mmdb")))
{
return(files.First(f => f.EndsWith(".mmdb")));
}
}
return(null);
}
private string CreatePackage(PackageType packageType, Archive archive, ArchiveMetadata metadata, string outputDirectory)
{
string packageDirectory = CreatePackageDirectory(archive, outputDirectory);
string packageFilePath = Path.Combine(packageDirectory, archive.GetInformationPackageFileName());
Stream outStream = File.Create(packageFilePath);
TarArchive tarArchive = TarArchive.CreateOutputTarArchive(new TarOutputStream(outStream));
string packageRootDirectory = archive.Uuid.GetValue() + Path.DirectorySeparatorChar;
CreateEntry(packageRootDirectory, false, new DirectoryInfo("none"), tarArchive, string.Empty, string.Empty);
AddFilesInDirectory(
archive, archive.WorkingDirectory.Root().DirectoryInfo(), packageType, tarArchive, packageRootDirectory
);
if (archive.WorkingDirectory.HasExternalContentDirectory())
{
Log.Debug($"Archive has external content directory, including files from {archive.WorkingDirectory.Content()}");
string contentDirectory = packageRootDirectory +
ArkadeConstants.DirectoryNameContent +
Path.DirectorySeparatorChar;
AddFilesInDirectory(
archive, archive.WorkingDirectory.Content().DirectoryInfo(), null, tarArchive, contentDirectory
);
}
tarArchive.Close();
new InfoXmlCreator().CreateAndSaveFile(metadata, packageFilePath);
HasRun = true;
return(packageFilePath);
}
public void EndBlockHandling()
{
int dummySize = 70145;
long outCount, inCount;
using (var ms = new MemoryStream())
{
using (var tarOut = TarArchive.CreateOutputTarArchive(ms))
using (var dummyFile = Utils.GetDummyFile(dummySize))
{
tarOut.IsStreamOwner = false;
tarOut.WriteEntry(TarEntry.CreateEntryFromFile(dummyFile.Filename), false);
}
outCount = ms.Position;
ms.Seek(0, SeekOrigin.Begin);
using (var tarIn = TarArchive.CreateInputTarArchive(ms, null))
using (var tempDir = new Utils.TempDir())
{
tarIn.IsStreamOwner = false;
tarIn.ExtractContents(tempDir.Fullpath);
foreach (var file in Directory.GetFiles(tempDir.Fullpath, "*", SearchOption.AllDirectories))
{
Console.WriteLine($"Extracted \"{file}\"");
}
}
inCount = ms.Position;
Console.WriteLine($"Output count: {outCount}");
Console.WriteLine($"Input count: {inCount}");
Assert.AreEqual(inCount, outCount, "Bytes read and bytes written should be equal");
}
}
public static IArchive Open(Stream stream, Options options)
{
Utility.CheckNotNull(stream, "stream");
if (!(stream.CanRead && stream.CanSeek))
{
throw new ArgumentException("Stream should be readable and seekable");
}
if (ZipArchive.IsZipFile(stream, null))
{
stream.Seek(0L, SeekOrigin.Begin);
return(ZipArchive.Open(stream, options, null));
}
stream.Seek(0L, SeekOrigin.Begin);
if (TarArchive.IsTarFile(stream))
{
stream.Seek(0L, SeekOrigin.Begin);
return(TarArchive.Open(stream, options));
}
stream.Seek(0L, SeekOrigin.Begin);
if (SevenZipArchive.IsSevenZipFile(stream))
{
stream.Seek(0L, SeekOrigin.Begin);
return(SevenZipArchive.Open(stream, options));
}
stream.Seek(0L, SeekOrigin.Begin);
if (GZipArchive.IsGZipFile(stream))
{
stream.Seek(0L, SeekOrigin.Begin);
return(GZipArchive.Open(stream, options));
}
stream.Seek(0L, SeekOrigin.Begin);
if (!RarArchive.IsRarFile(stream, Options.LookForHeader | Options.KeepStreamsOpen))
{
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip");
}
stream.Seek(0L, SeekOrigin.Begin);
return(RarArchive.Open(stream, options, null));
}
/// <summary>
/// create a tar file
/// </summary>
/// <param name="ADirectory"></param>
/// <param name="ATarFileName"></param>
public static void PackTar(String ADirectory, String ATarFileName)
{
TarArchive archive;
FileStream outStream;
TarEntry entry;
if (ATarFileName.Length == 0)
{
ATarFileName = Path.GetFullPath(ADirectory + "/../" + Path.GetFileName(ADirectory) + ".tar");
}
TLogging.Log("Create tar archive " + ATarFileName, TLoggingType.ToConsole);
System.IO.File.Delete(ATarFileName);
outStream = System.IO.File.OpenWrite(ATarFileName);
archive = TarArchive.CreateOutputTarArchive(outStream, TarBuffer.DefaultBlockFactor);
archive.SetUserInfo(-1, "petra", -1, "petra");
archive.RootPath = Path.GetFullPath(ADirectory).Replace("\\", "/");
// just adding the whole directory does not work as expected, it adds an empty directory without a name
string[] directories = System.IO.Directory.GetDirectories(ADirectory);
foreach (string dir in directories)
{
entry = TarEntry.CreateEntryFromFile(dir);
archive.WriteEntry(entry, true);
}
string[] files = System.IO.Directory.GetFiles(ADirectory);
foreach (string filename in files)
{
entry = TarEntry.CreateEntryFromFile(filename);
archive.WriteEntry(entry, false);
}
archive.Close();
}
/// <summary>
/// Opens an Archive for random access
/// </summary>
/// <param name="stream"></param>
/// <param name="readerOptions"></param>
/// <returns></returns>
public static IArchive Open(Stream stream, ReaderOptions readerOptions = null)
{
stream.CheckNotNull(nameof(stream));
if (!stream.CanRead || !stream.CanSeek)
{
throw new ArgumentException("Stream should be readable and seekable");
}
if (readerOptions == null)
{
readerOptions = new ReaderOptions();
}
ArchiveType?type;
IsArchive(stream, out type); //test and reset stream position
if (type != null)
{
switch (type.Value)
{
case ArchiveType.Zip:
return(ZipArchive.Open(stream, readerOptions));
case ArchiveType.SevenZip:
return(SevenZipArchive.Open(stream, readerOptions));
case ArchiveType.GZip:
return(GZipArchive.Open(stream, readerOptions));
case ArchiveType.Rar:
return(RarArchive.Open(stream, readerOptions));
case ArchiveType.Tar:
return(TarArchive.Open(stream, readerOptions));
}
}
throw new InvalidOperationException("Cannot determine compressed stream type. Supported Archive Formats: Zip, GZip, Tar, Rar, 7Zip, LZip");
}
public void ExtractingCorruptTarShouldntLeakFiles()
{
using var memoryStream = new MemoryStream();
//Create a tar.gz in the output stream
using (var gzipStream = new GZipOutputStream(memoryStream))
{
gzipStream.IsStreamOwner = false;
using (var tarOut = TarArchive.CreateOutputTarArchive(gzipStream))
using (var dummyFile = Utils.GetDummyFile(size: 32000))
{
tarOut.IsStreamOwner = false;
tarOut.WriteEntry(TarEntry.CreateEntryFromFile(dummyFile), recurse: false);
}
}
// corrupt archive - make sure the file still has more than one block
memoryStream.SetLength(16000);
memoryStream.Seek(0, SeekOrigin.Begin);
// try to extract
using (var gzipStream = new GZipInputStream(memoryStream))
{
gzipStream.IsStreamOwner = false;
using var tempDir = Utils.GetTempDir();
using (var tarIn = TarArchive.CreateInputTarArchive(gzipStream, nameEncoding: null))
{
tarIn.IsStreamOwner = false;
Assert.Throws <SharpZipBaseException>(() => tarIn.ExtractContents(tempDir));
}
// Try to remove the output directory to check if any file handles are still being held
Assert.DoesNotThrow(() => tempDir.Delete());
Assert.That(tempDir.Exists, Is.False, "Temporary folder should have been removed");
}
}
/// <summary>
/// Attempt to extract a file as an archive
/// </summary>
/// <param name="outDir">Output directory for archive extraction</param>
/// <returns>True if the extraction was a success, false otherwise</returns>
public override bool CopyAll(string outDir)
{
bool encounteredErrors = true;
try
{
// Create the temp directory
Directory.CreateDirectory(outDir);
// Extract all files to the temp directory
TarArchive ta = TarArchive.Open(this.Filename);
foreach (TarArchiveEntry entry in ta.Entries)
{
entry.WriteToDirectory(outDir, new ExtractionOptions {
PreserveFileTime = true, ExtractFullPath = true, Overwrite = true
});
}
encounteredErrors = false;
ta.Dispose();
}
catch (EndOfStreamException ex)
{
// Catch this but don't count it as an error because SharpCompress is unsafe
logger.Verbose(ex);
}
catch (InvalidOperationException ex)
{
logger.Warning(ex);
encounteredErrors = true;
}
catch (Exception ex)
{
logger.Error(ex);
encounteredErrors = true;
}
return(encounteredErrors);
}
/// <summary>
/// 文件解压
/// </summary>
/// <param name="zipPath">压缩文件路径</param>
/// <param name="goalFolder">解压到的目录</param>
/// <returns></returns>
public static void UnzipTgz(string zipPath, string goalFolder)
{
Stream inStream = null;
Stream gzipStream = null;
TarArchive tarArchive = null;
try
{
using (inStream = File.OpenRead(zipPath))
{
using (gzipStream = new GZipInputStream(inStream))
{
tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(goalFolder);
tarArchive.Close();
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (null != tarArchive)
{
tarArchive.Close();
}
if (null != gzipStream)
{
gzipStream.Close();
}
if (null != inStream)
{
inStream.Close();
}
}
}
public void ExtractTGZ(String gzArchiveName, String destFolder)
{
try
{
Console.WriteLine("Extracting Files...........");
Stream inStream = File.OpenRead(gzArchiveName);
Stream gzipStream = new GZipInputStream(inStream);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(destFolder);
tarArchive.Close();
gzipStream.Close();
inStream.Close();
Logging.Log("Extracting Files");
}
catch (Exception ex)
{
Logging.LogEr("Extraction Error", ex.ToString());
throw;
}
}
internal TarArchiveEntry(int index, TarArchive archive, TarFilePart part, CompressionType compressionType)
: base(part, compressionType)
{
this.Index = index;
this.archive = archive;
}
internal TarArchiveEntry(TarArchive archive, TarFilePart part, CompressionType compressionType)
: base(part, compressionType)
{
Archive = archive;
}
