public string CreateArchive(LanguageConfiguration configuration) { var tgzFilename = string.Format(TgzFilenameFormat, configuration.BuildNumber); this.files.Clear(); this.files.Add(configuration.AnswerFile); this.files.AddRange(configuration.OtherFiles); using (var outStream = File.Create(tgzFilename)) using (var gzoStream = new GZipOutputStream(outStream)) using (var tarArchive = TarArchive.CreateOutputTarArchive(gzoStream)) { tarArchive.RootPath = Path.GetDirectoryName(configuration.AnswerFile); foreach (var file in this.files) { var tarEntry = TarEntry.CreateEntryFromFile(file); tarEntry.Name = Path.GetFileName(file); tarArchive.WriteEntry(tarEntry, true); } } return(tgzFilename); }
public void WriteTarGzipProject(string id, ProjectTarGzipDto projectTarGzipDto, string directory) { if (directory == null) { directory = Application.dataPath + "/Card Set Editor Projects/"; } Stream outStream = File.Create(directory + id + ".cse-project"); Stream gzoStream = new GZipOutputStream(outStream); 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 = directory.Replace('\\', '/'); if (tarArchive.RootPath.EndsWith("/")) { tarArchive.RootPath = tarArchive.RootPath.Remove(tarArchive.RootPath.Length - 1); } foreach (var cardTarGzipDto in projectTarGzipDto.cardTarGzipDtoList) { // Add a Copy of these two guys to our tgz AddDirectoryFilesToTar(tarArchive, cardTarGzipDto.cardJsonFileDireString); AddDirectoryFilesToTar(tarArchive, cardTarGzipDto.cardPNGFileString); // Delete the originals File.Delete(cardTarGzipDto.cardJsonFileDireString); File.Delete(cardTarGzipDto.cardPNGFileString); } tarArchive.Close(); }
/// <summary> /// Pack the archive /// </summary> public static Task PackAsync(Recipe recipe, string directory, Stream stream) { var includePatterns = new List <Glob.Glob>(); // Include the Recipe file includePatterns.Add(new Glob.Glob(Constants.RecipeFileName.ToLower())); // Include all or the source filess foreach (var source in recipe.Source) { includePatterns.Add(new Glob.Glob(source.ToLower())); } using (var gzipStream = new GZipStream(stream, CompressionLevel.Optimal, true)) using (var archive = TarArchive.CreateOutputTarArchive(gzipStream)) { archive.RootPath = directory; // Check every file in the directory foreach (var file in Directory.EnumerateFiles(directory, "*", SearchOption.AllDirectories)) { var relativePath = Path.GetRelativePath(directory, file); bool matchInclude = includePatterns.Any(pattern => pattern.IsMatch(relativePath.ToLower())); if (matchInclude) { Log.Verbose(relativePath); var entry = TarEntry.CreateEntryFromFile(file); archive.WriteEntry(entry, true); } } } return(Task.CompletedTask); }
private static void CompressTar( string directory, string archiveFile, Predicate <FileInfo> filter, FileMode fileMode, Func <Stream, Stream> outputStreamFactory) { Log.Information("Compressing content of {Directory} to {File} ...", directory, Path.GetFileName(archiveFile)); FileSystemTasks.EnsureExistingParentDirectory(archiveFile); var files = GetFiles(directory, filter); using var fileStream = File.Open(archiveFile, fileMode, 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); } }
public static string CreateTarGz(string tgzFilename, string directory, IProgress <string> progress = null) { var guid = Guid.NewGuid(); var tempPath = Path.Combine(Path.GetTempPath(), guid.ToString()); var tarPath = Path.Combine(tempPath, $"{tgzFilename}.tar"); Directory.CreateDirectory(tempPath); using (var outStream = File.Create(tarPath)) using (var gzoStream = new GZipOutputStream(outStream)) using (var tarArchive = TarArchive.CreateOutputTarArchive(gzoStream)) { tarArchive.RootPath = Path.GetDirectoryName(directory); var tarEntry = TarEntry.CreateEntryFromFile(directory); tarEntry.Name = Path.GetFileName(directory); tarArchive.ProgressMessageEvent += (archive, entry, message) => { progress?.Report(message); }; tarArchive.WriteEntry(tarEntry, true); } return(tarPath); }
private void createTARAndTxLog(int partNumber) { FileInfo fioi = new FileInfo(fileLogFileDialog.FileName); String slogId = fioi.Name.Replace(".csv", ""); DateTime dt = new DateTime(); dt = DateTime.Now; String dtString = dt.ToString(); dtString = dtString.Replace("/", "_").Replace(":", "").Replace(" ", ""); tarLogName = "GlacierTARBall_" + slogId + "_Part" + Convert.ToString(partNumber) + "_" + dtString + "_LOG.csv"; tarLog = new StreamWriter(tarLogName); tarLog.WriteLine("Zip FileLoc" + "," + "SHA256 Compressed" + "," + "FileName" + "," + "SHA 256 Decompressed"); archiveName = "GlacierTARBall_" + slogId + "_Part" + Convert.ToString(partNumber) + "_" + dtString + ".tar"; log.Info("Making Tar Log : " + "GlacierTarLog_" + slogId + "_Part" + Convert.ToString(partNumber) + "_" + dtString + ".csv"); log.Info("Tar FileName : " + "GlacierTARBall_" + slogId + "_Part" + Convert.ToString(partNumber) + "_" + dtString + ".tar"); FileStream fs = File.Create(archiveName); TarOutputStream stream = new TarOutputStream((Stream)fs); archive = TarArchive.CreateOutputTarArchive(stream); }
public static void Make_TAR(string What, string Where) { string Out_TAR = Path.GetFileNameWithoutExtension(Where) + ".tar"; string Out_MD5 = Path.GetFileNameWithoutExtension(Where) + ".tar.md5"; Stream fs = new FileStream(Out_MD5, FileMode.Create); StringBuilder sb = new StringBuilder(); MD5 MD5_Hash_Engine = new MD5CryptoServiceProvider(); Console.WriteLine("Creating: " + Out_MD5 + " ....."); TarArchive TA = TarArchive.CreateOutputTarArchive(fs); TarEntry TE = TarEntry.CreateEntryFromFile(What); TE.SetIds(0, 0); TE.SetNames(string.Empty, string.Empty); TE.TarHeader.Mode = 420; TA.WriteEntry(TE, true); TA.Close(); fs.Close(); Stream hash = new FileStream(Out_MD5, FileMode.Open); byte[] TAR_MD5_Hash = MD5_Hash_Engine.ComputeHash(hash); for (int i = 0; i < TAR_MD5_Hash.Length; i++) { sb.Append(TAR_MD5_Hash[i].ToString("X2")); } byte[] Final_Hash = Encoding.ASCII.GetBytes(sb.ToString().ToLower() + Convert.ToChar(0x20).ToString() + Convert.ToChar(0x20).ToString() + Out_TAR + Convert.ToChar("\n").ToString()); Console.WriteLine("MD5 for " + Out_MD5 + " is " + sb.ToString().ToLower()); hash.Write(Final_Hash, 0, Final_Hash.Length); hash.Close(); }
private void CreateTarGZ(string tgzFilename, string sourceDirectory) { try { Stream outStream = File.Create(tgzFilename); Stream gzoStream = new GZipOutputStream(outStream); 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 = sourceDirectory.Replace('\\', '/'); if (tarArchive.RootPath.EndsWith("/")) { tarArchive.RootPath = tarArchive.RootPath.Remove(tarArchive.RootPath.Length - 1); } AddDirectoryFilesToTar(tarArchive, sourceDirectory, true); tarArchive.Close(); } catch (SystemException se) { MessageBox.Show(se.Message); } }
static void FileBackup(string dbPath, string dbName) { var backup = Path.Combine(App.Current.DBDir, "backup"); if (!Directory.Exists(backup)) { Directory.CreateDirectory(backup); } string outputFilename = Path.Combine(backup, dbName + ".tar.gz"); if (File.Exists(outputFilename)) { File.Delete(outputFilename); } // storage backup in old format using (FileStream fs = new FileStream(outputFilename, FileMode.Create, FileAccess.Write, FileShare.None)) { using (Stream gzipStream = new GZipOutputStream(fs)) { using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(gzipStream)) { foreach (string n in new string [] { "", "-wal", "-shm" }) { TarEntry tarEntry = TarEntry.CreateEntryFromFile(Path.Combine(dbPath, dbName + ".cblite" + n)); tarArchive.WriteEntry(tarEntry, true); } AddDirectoryFilesToTar(tarArchive, Path.Combine(dbPath, dbName + " attachments"), true); } } } }
/// <summary> /// Creates a GZipped Tar file from a source directory /// </summary> /// <param name="outputTarFilename">Output .tar.gz file</param> /// <param name="sourceDirectory">Input directory containing files to be added to GZipped tar archive</param> public static void CreateTar(string outputTarFilename, string sourceDirectory) { using (FileStream fs = new FileStream(outputTarFilename, FileMode.Create, FileAccess.Write, FileShare.None)) using (Stream gzipStream = new GZipOutputStream(fs)) using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(gzipStream)) AddDirectoryFilesToTar(tarArchive, sourceDirectory, true); }
public void EmptyTar() { var ms = new MemoryStream(); int recordSize = 0; using (TarArchive tarOut = TarArchive.CreateOutputTarArchive(ms)) { recordSize = tarOut.RecordSize; } Assert.IsTrue(ms.GetBuffer().Length > 0, "Archive size must be > zero"); Assert.Zero(ms.GetBuffer().Length % recordSize, "Archive size must be a multiple of record size"); var ms2 = new MemoryStream(); ms2.Write(ms.GetBuffer(), 0, ms.GetBuffer().Length); ms2.Seek(0, SeekOrigin.Begin); using (TarArchive tarIn = TarArchive.CreateInputTarArchive(ms2, null)) { entryCount = 0; tarIn.ProgressMessageEvent += EntryCounter; tarIn.ListContents(); Assert.AreEqual(0, entryCount, "Expected 0 tar entries"); } }
public string CreateArchive(string solutionPath, string buildId) { if (solutionPath == null) { throw new ArgumentNullException(nameof(solutionPath)); } var tgzFilename = string.Format(TgzFilenameFormat, buildId); try { var files = Directory.GetFiles(solutionPath); using (var outStream = File.Create(tgzFilename)) using (var gzoStream = new GZipOutputStream(outStream)) using (var tarArchive = TarArchive.CreateOutputTarArchive(gzoStream)) { tarArchive.RootPath = Path.GetDirectoryName(solutionPath); foreach (var file in files) { var tarEntry = TarEntry.CreateEntryFromFile(file); tarEntry.Name = Path.GetFileName(file); tarArchive.WriteEntry(tarEntry, true); } } } catch (Exception ex) { throw new CodeNotAchivedException($"Не удалось создать архив для {solutionPath}", ex); } return(tgzFilename); }
private void CreateTarArchive() { log.Trace("TAR (Create): '{0}' -> '{1}'", directory, tarFile); if (File.Exists(tarFile)) { File.Delete(tarFile); } using (var fs = File.Open(tarFile, FileMode.CreateNew, FileAccess.Write, FileShare.None)) { using (var gzipStream = new GZipOutputStream(fs)) { using (var tarArchive = TarArchive.CreateOutputTarArchive(gzipStream)) { tarArchive.RootPath = directory.Replace('\\', '/'); if (tarArchive.RootPath.EndsWith("/")) { tarArchive.RootPath = tarArchive.RootPath.Remove(tarArchive.RootPath.Length - 1); } var tarEntry = TarEntry.CreateEntryFromFile(directory); tarArchive.WriteEntry(tarEntry, true); log.Debug("TAR DIRECTORY {0}", directory); log.Debug("TAR ROOT {0}", tarArchive.RootPath); } } } }
/// <summary> /// 生成 ***.tar.gz 文件 /// </summary> /// <param name="sourceFolderPath">待压缩的源文件夹或文件路径</param> /// <param name="tgzFileDir">生成的文件路径</param> /// <param name="tgzFileName">生成的文件名称,不带扩展名</param> /// <param name="encoding">编码</param> /// <returns></returns> public bool CreateTarGzArchive(string sourceFolderPath, string tgzFileDir, string tgzFileName = "temp", string encoding = "utf-8") { if (!System.IO.Directory.Exists(tgzFileDir)) { System.IO.Directory.CreateDirectory(tgzFileDir); } //string fileName; //if (File.Exists(sourceFolderPath)) // 如果是文件 //{ // fileName = Path.GetFileNameWithoutExtension(sourceFolderPath); //} //else //{ // string tempStr = sourceFolderPath.Replace('\\', '/'); // Regex regex = new Regex("/(.+?)$", RegexOptions.RightToLeft); // fileName = regex.Match(tempStr).Groups[1].Value; //} tgzFileName = Path.Combine(tgzFileDir, tgzFileName + ".tar.gz"); using Stream outTmpStream = new FileStream(tgzFileName, FileMode.OpenOrCreate); //注意此处源文件大小大于4096KB using Stream outStream = new GZipOutputStream(outTmpStream); using TarArchive archive = TarArchive.CreateOutputTarArchive(outStream, TarBuffer.DefaultBlockFactor, Encoding.GetEncoding(encoding)); archive.RootPath = Path.GetDirectoryName(sourceFolderPath); TarEntry entry = TarEntry.CreateEntryFromFile(sourceFolderPath); archive.WriteEntry(entry, true); return(true); }
public static void Create(string sourcePath, string targetPath) { var previousDirectory = Environment.CurrentDirectory; try { using (var outStream = File.Open(targetPath, FileMode.Create)) using (var gzoStream = new GZipOutputStream(outStream)) using (var tarArchive = TarArchive.CreateOutputTarArchive(gzoStream)) { if (Directory.Exists(sourcePath)) // is directory { Environment.CurrentDirectory = sourcePath; tarArchive.AddDirectory(sourcePath); } else { Environment.CurrentDirectory = Path.GetDirectoryName(sourcePath); tarArchive.AddFile(sourcePath); } } } finally { Environment.CurrentDirectory = previousDirectory; } }
/// <summary> /// files to gzip /// </summary> /// <param name="tgzFileName">tgzFileName.</param> /// <param name="files">files.</param> /// <param name="rootPath">rootPath.</param> public static void CreateGZip(string tgzFileName, List <String> files, string rootPath = null) { if (string.IsNullOrEmpty(rootPath)) { rootPath = CUtils.realStreamingAssetsPath; } rootPath = rootPath.Replace('\\', '/'); if (rootPath.EndsWith("/")) { rootPath = rootPath.Remove(rootPath.Length - 1); } if (File.Exists(tgzFileName)) { File.Delete(tgzFileName); } using (Stream outStream = File.Create(tgzFileName)) { using (GZipOutputStream gzoStream = new GZipOutputStream(outStream)) { TarArchive tarArchive = TarArchive.CreateOutputTarArchive(gzoStream); tarArchive.RootPath = rootPath; foreach (string filename in files) { //check folder AddDirectoryFilesToTar(tarArchive, rootPath, filename); } } } }
/// <inheritdoc /> public string Tar() { var dockerfileArchiveName = Regex.Replace(this.image.FullName, "[^a-zA-Z0-9]", "-").ToLowerInvariant(); var dockerfileArchivePath = Path.Combine(Path.GetTempPath(), $"{dockerfileArchiveName}.tar"); var dockerIgnoreFile = new DockerIgnoreFile(this.dockerfileDirectory.FullName, ".dockerignore", this.logger); using (var stream = new FileStream(dockerfileArchivePath, FileMode.Create)) { using (var tarArchive = TarArchive.CreateOutputTarArchive(stream)) { tarArchive.RootPath = OS.NormalizePath(this.dockerfileDirectory.FullName); foreach (var file in GetFiles(this.dockerfileDirectory.FullName)) { var relativePath = file.Substring(tarArchive.RootPath.Length + 1); if (dockerIgnoreFile.Denies(relativePath)) { continue; } var tarEntry = TarEntry.CreateEntryFromFile(file); tarEntry.Name = relativePath; tarArchive.WriteEntry(tarEntry, true); } } } return(dockerfileArchivePath); }
/// <summary> /// 生成 ***.tar 文件 /// </summary> /// <param name="strBasePath">文件基目录(源文件、生成文件所在目录)</param> /// <param name="strSourceFolderName">待压缩的源文件夹名</param> public bool CreatTarArchive(string strBasePath, string strSourceFolderName) { if (string.IsNullOrEmpty(strBasePath) || string.IsNullOrEmpty(strSourceFolderName) || !System.IO.Directory.Exists(strBasePath) || !System.IO.Directory.Exists(Path.Combine(strBasePath, strSourceFolderName))) { return(false); } Environment.CurrentDirectory = strBasePath; //要压缩的文件夹名称 string strSourceFolderAllPath = Path.Combine(strBasePath, strSourceFolderName); string strOupFileAllPath = Path.Combine(strBasePath, strSourceFolderName + ".tar"); //压缩文件名及路径 Stream outStream = new FileStream(strOupFileAllPath, FileMode.OpenOrCreate); TarArchive archive = TarArchive.CreateOutputTarArchive(outStream, TarBuffer.DefaultBlockFactor); TarEntry entry = TarEntry.CreateEntryFromFile(strSourceFolderAllPath); archive.WriteEntry(entry, true); if (archive != null) { archive.Close(); } outStream.Close(); return(true); }
public override void CreateTarFromLocalData(string outputPath) { lock (_pathsPreparedForRemote) { UpdatePathsPreparedForRemote(); if (_pathsPreparedForRemote.Count == 0) { throw new Exception("No data available."); } using (FileStream outputFile = new FileStream(outputPath, FileMode.Create, FileAccess.Write)) { using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(outputFile)) { foreach (string pathPreparedForRemote in _pathsPreparedForRemote) { using (FileStream filePreparedForRemote = File.OpenRead(pathPreparedForRemote)) { TarEntry tarEntry = TarEntry.CreateEntryFromFile(pathPreparedForRemote); tarEntry.Name = "data/" + Path.GetFileName(pathPreparedForRemote); tarArchive.WriteEntry(tarEntry, false); filePreparedForRemote.Close(); } } tarArchive.Close(); } outputFile.Close(); } } }
/// <summary> /// 打包成Tar包 /// </summary> /// <param name="strBasePath">压缩文件夹路径</param> /// <param name="strSourceFolderName">生成tar文件路径</param> /// <param name="sTarName">生成tar文件名称</param> /// <returns></returns> public bool CreatTarArchive(string strBasePath, string strSourceFolderName, string sTarName) { if (!Directory.Exists(strSourceFolderName)) { Directory.CreateDirectory(strSourceFolderName);//不存在生成Tar文件目录就创建 } if (string.IsNullOrEmpty(strBasePath) || string.IsNullOrEmpty(strSourceFolderName) || !Directory.Exists(strBasePath)) { return(false); } if (strBasePath.EndsWith("\\")) { strBasePath = strSourceFolderName.TrimEnd('\\'); } Environment.CurrentDirectory = strBasePath; //要压缩的文件夹名称 string strSourceFolderAllPath = strBasePath; string strOupFileAllPath = strSourceFolderName + "\\" + sTarName + ".tar"; //压缩文件名及路径 Stream outStream = new FileStream(strOupFileAllPath, FileMode.OpenOrCreate); TarArchive archive = TarArchive.CreateOutputTarArchive(outStream, TarBuffer.DefaultBlockFactor); TarEntry entry = TarEntry.CreateEntryFromFile(strSourceFolderAllPath); archive.WriteEntry(entry, true); if (archive != null) { archive.Close(); } outStream.Close(); return(true); }
public void RootPathIsRespected() { using (var extractDirectory = new Utils.TempDir()) using (var tarFileName = new Utils.TempFile()) using (var tempDirectory = new Utils.TempDir()) { tempDirectory.CreateDummyFile(); using (var tarFile = File.Open(tarFileName.Filename, FileMode.Create)) { using (var tarOutputStream = TarArchive.CreateOutputTarArchive(tarFile)) { tarOutputStream.RootPath = tempDirectory.Fullpath; var entry = TarEntry.CreateEntryFromFile(tempDirectory.Fullpath); tarOutputStream.WriteEntry(entry, true); } } using (var file = File.OpenRead(tarFileName.Filename)) { using (var archive = TarArchive.CreateInputTarArchive(file, Encoding.UTF8)) { archive.ExtractContents(extractDirectory.Fullpath); } } var expectationDirectory = new DirectoryInfo(tempDirectory.Fullpath); foreach (var checkFile in expectationDirectory.GetFiles("", SearchOption.AllDirectories)) { var relativePath = checkFile.FullName.Substring(expectationDirectory.FullName.Length + 1); FileAssert.Exists(Path.Combine(extractDirectory.Fullpath, relativePath)); FileAssert.AreEqual(checkFile.FullName, Path.Combine(extractDirectory.Fullpath, relativePath)); } } }
private void CreateTar(string path, int id) // Пакует в архив заказ по имени архива, пути до папки файлов и id { using (var outStream = File.Create(nextID.ToString())) //using (var gzoStream = new GZipOutputStream(outStream)) using (var tarArchive = TarArchive.CreateOutputTarArchive(outStream)) { string s = "nope"; try { tarArchive.RootPath = Path.GetDirectoryName("info.txt"); // Пакуем info var tarEntry = TarEntry.CreateEntryFromFile("info.txt"); tarEntry.Name = Path.GetFileName("info.txt"); tarArchive.WriteEntry(tarEntry, true); s = "+info"; tarArchive.RootPath = Path.GetDirectoryName(@"C:\users\masch01\" + orders[id].name + ".LST"); // Пакуем LST #TODO tarEntry = TarEntry.CreateEntryFromFile(@"C:\users\masch01\" + orders[id].name + ".LST"); tarEntry.Name = Path.GetFileName("PROG.LST"); tarArchive.WriteEntry(tarEntry, true); s = "done"; } catch (Exception e) { MessageBox.Show(e.ToString(), s); } } nextID++; }
internal static void CompressFolder(string inFolder, string outFile, CompressionFormat format, List <Regex> ignoredPathsRegex) { string tarFilePath = outFile + "tmptar"; // Source: https://github.com/icsharpcode/SharpZipLib/wiki/GZip-and-Tar-Samples#-create-a-tgz-targz using (FileStream outputStream = File.Create(tarFilePath)) using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(outputStream)) { // Currently, SharpZipLib only supports '/', and the folder path must not end with it if (inFolder[inFolder.Length - 1] == '\\' || inFolder[inFolder.Length - 1] == '/') { inFolder = inFolder.Substring(0, inFolder.Length - 1).Replace('\\', '/'); } else { inFolder = inFolder.Replace('\\', '/'); } tarArchive.RootPath = inFolder; CreateTarRecursive(tarArchive, new DirectoryInfo(inFolder), "", ignoredPathsRegex); } CompressFile(tarFilePath, outFile, format); File.Delete(tarFilePath); }
private static void CreateTarGz(string tgzFilename, string sourceDirectory) { Stream outStream = null; try { outStream = File.Create(tgzFilename); var gzoStream = new GZipOutputStream(outStream); using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(gzoStream)) { outStream = null; // 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 = sourceDirectory.Replace('\\', '/'); if (tarArchive.RootPath.EndsWith("/")) { tarArchive.RootPath = tarArchive.RootPath.Remove(tarArchive.RootPath.Length - 1); } AddDirectoryFilesToTar(tarArchive, sourceDirectory, true); } } finally { if (outStream != null) { outStream.Dispose(); } } }
public static void CompressFolderLZMA(string inFolder, string outFile) { string tarFilePath = outFile + "tmptar"; // Source: https://github.com/icsharpcode/SharpZipLib/wiki/GZip-and-Tar-Samples#-create-a-tgz-targz using (FileStream outputStream = File.Create(tarFilePath)) using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(outputStream)) { // Currently, SharpZipLib only supports '/', and the folder path must not end with it if (inFolder[inFolder.Length - 1] == '\\' || inFolder[inFolder.Length - 1] == '/') { inFolder = inFolder.Substring(0, inFolder.Length - 1).Replace('\\', '/'); } else { inFolder = inFolder.Replace('\\', '/'); } tarArchive.RootPath = inFolder; CreateTarRecursive(tarArchive, inFolder); } CompressFileLZMA(tarFilePath, outFile); File.Delete(tarFilePath); }
public static void Compress(string directory, string command, string destination) { if (!Directory.Exists(directory)) { return; } var filesDirectory = Path.Combine(directory, command + "-files"); var file = destination + ".oipkg"; if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix) { var args = new StringBuilder(); args.Append("\"" + file + "\" "); Directory .GetFiles(directory, command + ".*") .ToList() .ForEach(x => args.Append("\"" + toRelative(x, directory) + "\" ")); args.Append("\"" + toRelative(filesDirectory, directory) + "\""); run(directory, "tar", "-czf " + args.ToString()); return; } var currentDirectory = Directory.GetCurrentDirectory(); Directory.SetCurrentDirectory(directory); try { var outStream = File.Create(file); var gzoStream = new GZipOutputStream(outStream); var 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 = directory.Replace('\\', '/'); if (tarArchive.RootPath.EndsWith("/")) { tarArchive.RootPath = tarArchive.RootPath.Remove(tarArchive.RootPath.Length - 1); } Directory .GetFiles(directory, command + ".*") .ToList() .ForEach(x => addFile(tarArchive, x)); addDirectory(tarArchive, filesDirectory); tarArchive.Close(); } catch (Exception ex) { Console.WriteLine("error|Exception during processing {0}", ex); throw; } finally { Directory.SetCurrentDirectory(currentDirectory); } }
private static void Compress(string outputFile, string tempPath) { using var stream = new FileStream(outputFile, FileMode.CreateNew); using var zipStream = new GZipOutputStream(stream); using var archive = TarArchive.CreateOutputTarArchive(zipStream); archive.RootPath = tempPath; archive.AddFilesRecursive(tempPath); }
public void CreateTarGzFromDirectory(string sourceDirectory, string targetTarGzFilepath, bool isRecursive) { using (FileStream fs = new FileStream(targetTarGzFilepath, FileMode.Create, FileAccess.Write, FileShare.None)) using (Stream gzipStream = new GZipOutputStream(fs)) using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(gzipStream)) { AddDirectoryFilesToTar(tarArchive, sourceDirectory, isRecursive); } }
static void Zip() { Stream outstream = File.Create(basepath + latest + "\\data.tar.gz"); Stream gzipstream = new GZipOutputStream(outstream); TarArchive tar = TarArchive.CreateOutputTarArchive(gzipstream); AddDirectoryFilesToTar(tar, dstpath); tar.Close(); }
static async Task Main(string[] args) { var client = new DockerClientConfiguration(new Uri("http://host.docker.internal:2375")) .CreateClient(); var sb = new StringBuilder(); sb.AppendLine("FROM mcr.microsoft.com/dotnet/core/runtime:3.0-buster-slim"); sb.AppendLine("COPY . ."); sb.AppendLine("ENTRYPOINT [\"dotnet\", \"Playground.Docker.Hello.dll\"]"); Directory.Delete("contents", true); var contentsDir = Directory.CreateDirectory("contents"); var dockerfilePath = Path.Combine("contents", "Dockerfile"); File.WriteAllText(dockerfilePath, sb.ToString()); File.Copy("Playground.Docker.Hello.dll", Path.Combine("contents", "Playground.Docker.Hello.dll")); File.Copy("Playground.Docker.Hello.runtimeconfig.json", Path.Combine("contents", "Playground.Docker.Hello.runtimeconfig.json")); var filesInDirectory = contentsDir.GetFiles(); var tarArchiveName = @"contents.tar.gz"; using var targetStream = new GZipOutputStream(File.Create(tarArchiveName)); { using var tarArchive = TarArchive.CreateOutputTarArchive(targetStream); { foreach (var fileToBeTarred in filesInDirectory) { var entry = TarEntry.CreateEntryFromFile(fileToBeTarred.FullName); entry.Name = fileToBeTarred.Name; tarArchive.WriteEntry(entry, true); } } } using var contentsStream = File.OpenRead(tarArchiveName); var logStream = await client.Images.BuildImageFromDockerfileAsync(contentsStream, new ImageBuildParameters { Tags = new[] { "playground-hello" } }); var response = await client.Containers.CreateContainerAsync(new CreateContainerParameters { Image = "playground-hello" }); var started = await client.Containers.StartContainerAsync(response.ID, new ContainerStartParameters { }); }