public void Tar_Japanese_Name(int length)
{
using (var mstm = new MemoryStream())
{
var enc = new ArchiveEncoding()
{
Default = Encoding.UTF8
};
var twopt = new TarWriterOptions(CompressionType.None, true);
twopt.ArchiveEncoding = enc;
var fname = new string((char)0x3042, length);
using (var tw = new TarWriter(mstm, twopt))
using (var input = new MemoryStream(new byte[32]))
{
tw.Write(fname, input, null);
}
using (var inputMemory = new MemoryStream(mstm.ToArray()))
{
var tropt = new ReaderOptions()
{
ArchiveEncoding = enc
};
using (var tr = TarReader.Open(inputMemory, tropt))
{
while (tr.MoveToNextEntry())
{
Assert.Equal(fname, tr.Entry.Key);
}
}
}
}
}
private void SaveCompressedFile(string sourceFilePath, string compressedFilePath)
{
using var sourceFileStream = _fileStream.CreateFileStream(sourceFilePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
using var targetCompressedFileStream = _file.OpenWrite(compressedFilePath);
var tarWriterOptions = new TarWriterOptions(CompressionType.LZip, true);
using var targetWriter = _tarWriter.CreateTarWriter(targetCompressedFileStream, tarWriterOptions);
targetWriter.Write(Path.GetFileName(sourceFilePath), sourceFileStream);
}
/// <summary>
/// Compress (TAR/BZip2) an unencrypted FAES File.
/// </summary>
/// <param name="unencryptedFile">Unencrypted FAES File</param>
/// <returns>Path of the unencrypted, TAR/BZip2 compressed file</returns>
public string CompressFAESFile(FAES_File unencryptedFile)
{
FileAES_IntUtilities.CreateEncryptionFilePath(unencryptedFile, "TAR", out string tempRawPath, out _, out string tempOutputPath);
TarWriterOptions wo = new TarWriterOptions(CompressionType.BZip2, true);
using (Stream stream = File.OpenWrite(tempOutputPath))
using (var writer = new TarWriter(stream, wo))
{
writer.WriteAll(tempRawPath, "*", SearchOption.AllDirectories);
}
return(tempOutputPath);
}
public void Tar_Read_One_At_A_Time()
{
var archiveEncoding = new ArchiveEncoding {
Default = Encoding.UTF8,
};
var tarWriterOptions = new TarWriterOptions(CompressionType.None, true)
{
ArchiveEncoding = archiveEncoding,
};
var testBytes = Encoding.UTF8.GetBytes("This is a test.");
using (var memoryStream = new MemoryStream())
{
using (var tarWriter = new TarWriter(memoryStream, tarWriterOptions))
using (var testFileStream = new MemoryStream(testBytes))
{
tarWriter.Write("test1.txt", testFileStream);
testFileStream.Position = 0;
tarWriter.Write("test2.txt", testFileStream);
}
memoryStream.Position = 0;
var numberOfEntries = 0;
using (var archiveFactory = TarArchive.Open(memoryStream))
{
foreach (var entry in archiveFactory.Entries)
{
++numberOfEntries;
using (var tarEntryStream = entry.OpenEntryStream())
using (var testFileStream = new MemoryStream())
{
tarEntryStream.CopyTo(testFileStream);
Assert.Equal(testBytes.Length, testFileStream.Length);
}
}
}
Assert.Equal(2, numberOfEntries);
}
}
public void Tar_Create_New()
{
string scratchPath = Path.Combine(SCRATCH_FILES_PATH, "Tar.tar");
string unmodified = Path.Combine(TEST_ARCHIVES_PATH, "Tar.noEmptyDirs.tar");
// var aropt = new Ar
using (var archive = TarArchive.Create())
{
archive.AddAllFromDirectory(ORIGINAL_FILES_PATH);
var twopt = new TarWriterOptions(CompressionType.None, true);
twopt.ArchiveEncoding = new ArchiveEncoding()
{
Default = Encoding.GetEncoding(866)
};
archive.SaveTo(scratchPath, twopt);
}
CompareArchivesByPath(unmodified, scratchPath);
}
/// <summary>
/// Constructs a new lzip instance.
/// </summary>
/// <param name="stream">The stream to read or write depending on access mode</param>
/// <param name="mode">The archive access mode</param>
/// <param name="options">The options passed on the commandline</param>
public FileArchiveLzip(Stream stream, ArchiveMode mode, IDictionary <string, string> options)
{
m_stream = stream;
m_mode = mode;
if (mode == ArchiveMode.Write)
{
var compression = new TarWriterOptions(CompressionType.LZip, true);
//var compression = new TarWriterOptions(CompressionType.None, true);
// TODO: can the compression level be set?
string cplevel;
int tmplevel;
if (options.TryGetValue(COMPRESSION_LEVEL_OPTION, out cplevel) && int.TryParse(cplevel, out tmplevel))
{
// TODO: set compression level to tmplevel
}
m_writer = WriterFactory.Open(m_stream, ArchiveType.Tar, compression);
// TODO: set m_flushBufferSize for the size of endheader?
}
}
public TarWriter CreateTarWriter(Stream destination, TarWriterOptions options)
{
return(new TarWriter(destination, options));
}
///// <summary>
///// OnDir = (int sumCount,int curCount,string fileName)=>{ };
///// </summary>
//public Action<int, int, string> OnDir;
/// <summary>
/// Supported Reader Formats: Zip, GZip, Tar
/// </summary>
public void PackByWriter()
{
fileCount = 0;
sumEntityCount = 0;
ArchiveType archiveType;
WriterOptions writerOptions;
switch (Path.GetExtension(outputPath)?.ToLower())
{
case ".gz":
archiveType = ArchiveType.GZip;
writerOptions = new GZipWriterOptions();
break;
case ".tar":
archiveType = ArchiveType.Tar;
writerOptions = new TarWriterOptions(CompressionType.None, true);
break;
case ".zip":
archiveType = ArchiveType.Zip;
writerOptions = new WriterOptions(CompressionType.Deflate); //CompressionType.BZip2 CompressionType.None CompressionType.LZMA CompressionType.PPMd
break;
default: throw new InvalidOperationException("Cannot Support file format. Supported Formats: .zip, .gz, .tar ");
}
//writerOptions.ArchiveEncoding.Default = System.Text.Encoding.UTF8;
//readOptions.ArchiveEncoding.Default = System.Text.Encoding.Default;
writerOptions.ArchiveEncoding.Default = System.Text.Encoding.GetEncoding("GB2312");
if (File.Exists(inputPath))
{
//压缩单个文件
sumEntityCount = 1;
#region (x.x.2)压缩
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
using (var fileStream = File.OpenWrite(outputPath))
using (var writer = WriterFactory.Open(fileStream, archiveType, writerOptions))
{
var directoryLength = inputPath.Length;
var relativePath = Path.GetFileName(inputPath);
writer.Write(relativePath, inputPath);
OnFile?.Invoke(1, 1, relativePath);
OnProgress?.Invoke(1.0f, 1, 1);
}
#endregion
}
else
{
//压缩文件夹
#region (x.x.1)获取文件（夹）总个数
var enumerable = Directory.EnumerateFiles(inputPath, "*", SearchOption.AllDirectories);
sumEntityCount = enumerable.Count();
#endregion
#region (x.x.2)压缩
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
using (var fileStream = File.OpenWrite(outputPath))
using (var writer = WriterFactory.Open(fileStream, archiveType, writerOptions))
{
int importedEntityCount = 0;
int step = Math.Min((int)(sumEntityCount * progressStep), stepMaxEntityCount);
int nextStep = step;
var directoryLength = inputPath.Length;
foreach (var file in enumerable)
{
var relativePath = file.Substring(directoryLength);
writer.Write(relativePath, file);
importedEntityCount++;
//if (entry.IsDirectory)
//{
// dirCount++;
// OnDir?.Invoke(sumEntityCount, importedEntityCount, relativePath);
//}
//else
{
fileCount++;
OnFile?.Invoke(sumEntityCount, importedEntityCount, relativePath);
}
if (importedEntityCount >= nextStep)
{
nextStep = Math.Min(sumEntityCount, nextStep + step);
OnProgress?.Invoke(1.0f * importedEntityCount / sumEntityCount, sumEntityCount, importedEntityCount);
}
}
}
#endregion
}
}
