/// <summary> /// Read data direct from drive to file /// </summary> /// <param name="driveLetter"></param> /// <param name="fileName"></param> /// <param name="eCompType"></param> /// <returns></returns> public bool ReadDrive(string driveLetter, string fileName, EnumCompressionType eCompType, bool bUseMBR) { IsCancelling = false; var dtStart = DateTime.Now; // // Map to physical drive // var physicalDrive = _diskAccess.GetPhysicalPathForLogicalPath(driveLetter); if (string.IsNullOrEmpty(physicalDrive)) { LogMsg(Resources.Disk_WriteDrive_Error__Couldn_t_map_partition_to_physical_drive); _diskAccess.UnlockDrive(); return(false); } // // Lock logical drive // var success = _diskAccess.LockDrive(driveLetter); if (!success) { LogMsg(Resources.Disk_WriteDrive_Failed_to_lock_drive); return(false); } // // Get drive size // var driveSize = _diskAccess.GetDriveSize(physicalDrive); if (driveSize <= 0) { LogMsg(Resources.Disk_WriteDrive_Failed_to_get_device_size); _diskAccess.UnlockDrive(); return(false); } var readSize = driveSize; // // Open the physical drive // var physicalHandle = _diskAccess.Open(physicalDrive); if (physicalHandle == null) { LogMsg(Resources.Disk_WriteDrive_Failed_to_open_physical_drive); _diskAccess.UnlockDrive(); return(false); } // // Start doing the read // var buffer = new byte[Globals.MaxBufferSize]; var offset = 0L; using (var basefs = (Stream) new FileStream(fileName, FileMode.Create, FileAccess.Write)) { Stream fs; switch (eCompType) { case EnumCompressionType.Zip: var zfs = new ZipOutputStream(basefs); // Default to middle of the range compression zfs.SetLevel(Globals.CompressionLevel); var fi = new FileInfo(fileName); var entryName = fi.Name; entryName = entryName.ToLower().Replace(".zip", ""); entryName = ZipEntry.CleanName(entryName); var zipEntry = new ZipEntry(entryName) { DateTime = fi.LastWriteTime }; zfs.IsStreamOwner = true; // Todo: Consider whether size needs setting for older utils ? zfs.PutNextEntry(zipEntry); fs = zfs; break; case EnumCompressionType.Gzip: var gzis = new GZipOutputStream(basefs); gzis.SetLevel(Globals.CompressionLevel); gzis.IsStreamOwner = true; fs = gzis; break; case EnumCompressionType.Targzip: var gzos = new GZipOutputStream(basefs); gzos.SetLevel(Globals.CompressionLevel); gzos.IsStreamOwner = true; var tos = new TarOutputStream(gzos); fs = tos; break; case EnumCompressionType.XZ: var xzs = new XZOutputStream(basefs); fs = xzs; break; default: // No compression - direct to file stream fs = basefs; break; } while (offset < readSize && !IsCancelling) { // NOTE: If we provide a buffer that extends past the end of the physical device ReadFile() doesn't // seem to do a partial read. Deal with this by reading the remaining bytes at the end of the // drive if necessary var readMaxLength = (int) ((((ulong)readSize - (ulong)offset) < (ulong)buffer.Length) ? ((ulong)readSize - (ulong)offset) : (ulong)buffer.Length); int readBytes; if (_diskAccess.Read(buffer, readMaxLength, out readBytes) < 0) { LogMsg(Resources.Disk_ReadDrive_Error_reading_data_from_drive__ + Marshal.GetHRForLastWin32Error()); goto readfail1; } if (readBytes == 0) { LogMsg(Resources.Disk_ReadDrive_Error_reading_data_from_drive___past_EOF_); goto readfail1; } // Check MBR if (bUseMBR && offset == 0) { var truncatedSize = ParseMBRForSize(buffer); if (truncatedSize > driveSize) { LogMsg(Resources.Disk_ReadDrive_Problem_with_filesystem__It_reports_it_is_larger_than_the_disk_); goto readfail1; } if (truncatedSize == 0) { LogMsg(Resources.Disk_ReadDrive_No_valid_partitions_on_drive); goto readfail1; } readSize = truncatedSize; } if (offset == 0) { switch (eCompType) { case EnumCompressionType.Targzip: var fi = new FileInfo(fileName); var entryName = fi.Name; entryName = entryName.ToLower().Replace(".tar.gz", ""); entryName = entryName.ToLower().Replace(".tgz", ""); var tarEntry = TarEntry.CreateTarEntry(entryName); tarEntry.Size = readSize; tarEntry.ModTime = DateTime.SpecifyKind(fi.LastWriteTime, DateTimeKind.Utc); ((TarOutputStream)fs).PutNextEntry(tarEntry); break; } } fs.Write(buffer, 0, readBytes); offset += (uint)readBytes; var percentDone = (int)(100 * offset / readSize); var tsElapsed = DateTime.Now.Subtract(dtStart); var bytesPerSec = offset / tsElapsed.TotalSeconds; Progress(percentDone); LogMsg(Resources.Disk_ReadDrive_Read + @": " + (offset / Globals.MbModifier) + @" / " + (readSize / Globals.MbModifier) + @" MB " + @"(" + Resources.Disk_ReadDrive_Physical + @": " + (driveSize / Globals.MbModifier) + " MB); " + string.Format("{0:F}", (bytesPerSec / Globals.MbModifier)) + @" MB/s; " + Resources.Disk_Elapsed_time + ": " + tsElapsed.ToString(@"hh\:mm\:ss")); } if (fs is ZipOutputStream) { ((ZipOutputStream)fs).CloseEntry(); ((ZipOutputStream)fs).Close(); } else if (fs is TarOutputStream) { ((TarOutputStream)fs).CloseEntry(); fs.Close(); } else if (fs is GZipOutputStream) { fs.Close(); } else if (fs is XZOutputStream) { fs.Close(); } } readfail1: _diskAccess.Close(); _diskAccess.UnlockDrive(); var tstotalTime = DateTime.Now.Subtract(dtStart); if (IsCancelling) { LogMsg(Resources.Disk_WriteDrive_Cancelled); } else { LogMsg(Resources.Disk_ReadDrive_All_Done_Read + @" " + offset + @" " + Resources.Disk_WriteDrive_bytes + @". " + Resources.Disk_Elapsed_time + @": " + tstotalTime.ToString(@"hh\:mm\:ss")); } Progress(0); return(true); }
/// <summary> /// 将文件打包进TAR中 /// </summary> /// <param name="TarFile"></param> /// <param name="files"></param> public void AddFilesToTar(string TarFile, params string[] files) { FileStream fs = new FileStream(TarFile, FileMode.OpenOrCreate, FileAccess.ReadWrite); TarOutputStream taroutputstream = new TarOutputStream(fs); try { TarArchive tar = TarArchive.CreateOutputTarArchive(taroutputstream); tar.RootPath = TarFile; tar.SetKeepOldFiles(true); TarHeader.EncodingName = "gb2312"; Console.WriteLine("目标文件:" + TarFile); foreach (string f in files) { TarEntry tarEntry = TarEntry.CreateEntryFromFile(f); if (tarEntry.IsDirectory) { tar.WriteEntry(tarEntry, false); } else { FileStream ins = ins = System.IO.File.OpenRead(f); string tempfile = f.Substring(3, f.Length - 3); //tarEntry.Name = tempfile; tarEntry.Size = ins.Length; //taroutputstream.PutNextEntry(tarEntry); tar.WriteEntry(tarEntry, false); Console.Write("打包:" + System.IO.Path.GetFileName(f) + " "); long packedsize = 0; while (true) { byte[] buffer = new byte[1024 * 1024]; int bl = ins.Read(buffer, 0, buffer.Length); if (bl > 0) { taroutputstream.Write(buffer, 0, bl); packedsize += bl; float per = (float)packedsize / ins.Length * 100; Console.Write("\b\b\b\b{0,4:G}", per.ToString("###") + "%"); } else { Console.WriteLine("\b\b\b\b{0,4:G}", "100%"); break; } } ins.Close(); } taroutputstream.CloseEntry(); } tar.Close(); } catch (Exception ex) { throw ex; } finally { taroutputstream.Close(); } }
public async Task VerifyIncludeBaseDirectory_Async(bool includeBaseDirectory) { using TempDirectory source = new TempDirectory(); using TempDirectory destination = new TempDirectory(); UnixFileMode baseDirectoryMode = TestPermission1; SetUnixFileMode(source.Path, baseDirectoryMode); string fileName1 = "file1.txt"; string filePath1 = Path.Join(source.Path, fileName1); File.Create(filePath1).Dispose(); UnixFileMode filename1Mode = TestPermission2; SetUnixFileMode(filePath1, filename1Mode); string subDirectoryName = "dir/"; // The trailing separator is preserved in the TarEntry.Name string subDirectoryPath = Path.Join(source.Path, subDirectoryName); Directory.CreateDirectory(subDirectoryPath); UnixFileMode subDirectoryMode = TestPermission3; SetUnixFileMode(subDirectoryPath, subDirectoryMode); string fileName2 = "file2.txt"; string filePath2 = Path.Join(subDirectoryPath, fileName2); File.Create(filePath2).Dispose(); UnixFileMode filename2Mode = TestPermission4; SetUnixFileMode(filePath2, filename2Mode); string destinationArchiveFileName = Path.Join(destination.Path, "output.tar"); TarFile.CreateFromDirectory(source.Path, destinationArchiveFileName, includeBaseDirectory); List <TarEntry> entries = new List <TarEntry>(); FileStreamOptions readOptions = new() { Access = FileAccess.Read, Mode = FileMode.Open, Options = FileOptions.Asynchronous, }; await using (FileStream fileStream = File.Open(destinationArchiveFileName, readOptions)) { await using (TarReader reader = new TarReader(fileStream)) { TarEntry entry; while ((entry = await reader.GetNextEntryAsync()) != null) { entries.Add(entry); } } } int expectedCount = 3 + (includeBaseDirectory ? 1 : 0); Assert.Equal(expectedCount, entries.Count); string prefix = includeBaseDirectory ? Path.GetFileName(source.Path) + '/' : string.Empty; if (includeBaseDirectory) { TarEntry baseEntry = entries.FirstOrDefault(x => x.EntryType == TarEntryType.Directory && x.Name == prefix); Assert.NotNull(baseEntry); AssertEntryModeFromFileSystemEquals(baseEntry, baseDirectoryMode); } TarEntry entry1 = entries.FirstOrDefault(x => x.EntryType == TarEntryType.RegularFile && x.Name == prefix + fileName1); Assert.NotNull(entry1); AssertEntryModeFromFileSystemEquals(entry1, filename1Mode); TarEntry directory = entries.FirstOrDefault(x => x.EntryType == TarEntryType.Directory && x.Name == prefix + subDirectoryName); Assert.NotNull(directory); AssertEntryModeFromFileSystemEquals(directory, subDirectoryMode); string actualFileName2 = subDirectoryName + fileName2; // Notice the trailing separator in subDirectoryName TarEntry entry2 = entries.FirstOrDefault(x => x.EntryType == TarEntryType.RegularFile && x.Name == prefix + actualFileName2); Assert.NotNull(entry2); AssertEntryModeFromFileSystemEquals(entry2, filename2Mode); }
public void InvalidVersionName() { TarEntry e = TarEntry.CreateTarEntry("test"); e.TarHeader.Version = null; }
private static async Task TarFolderCore(FileSystemStorageFolder Folder, TarOutputStream OutputStream, string BaseFolderName, ByteReadChangedEventHandler ByteReadHandler = null) { List <FileSystemStorageItemBase> ItemList = await Folder.GetChildItemsAsync(true, true).ConfigureAwait(false); if (ItemList.Count == 0) { if (!string.IsNullOrEmpty(BaseFolderName)) { TarEntry NewEntry = TarEntry.CreateTarEntry($"{BaseFolderName}/"); OutputStream.PutNextEntry(NewEntry); OutputStream.CloseEntry(); } } else { ulong CurrentPosition = 0; foreach (FileSystemStorageItemBase Item in ItemList) { switch (Item) { case FileSystemStorageFolder InnerFolder: { ulong InnerFolderSize = 0; await TarFolderCore(InnerFolder, OutputStream, $"{BaseFolderName}/{InnerFolder.Name}", ByteReadHandler : (ByteRead) => { InnerFolderSize = ByteRead; ByteReadHandler?.Invoke(CurrentPosition + ByteRead); }).ConfigureAwait(false); ByteReadHandler?.Invoke(CurrentPosition += InnerFolderSize); break; } case FileSystemStorageFile InnerFile: { using (FileStream FileStream = await InnerFile.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { TarEntry NewEntry = TarEntry.CreateTarEntry($"{BaseFolderName}/{InnerFile.Name}"); NewEntry.ModTime = DateTime.Now; NewEntry.Size = FileStream.Length; OutputStream.PutNextEntry(NewEntry); await FileStream.CopyToAsync(OutputStream, ProgressHandler : (s, e) => { ByteReadHandler?.Invoke(CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * InnerFile.SizeRaw)); }).ConfigureAwait(false); } OutputStream.CloseEntry(); ByteReadHandler?.Invoke(CurrentPosition += InnerFile.SizeRaw); break; } } } } }
public void InvalidSize() { TarEntry e = TarEntry.CreateTarEntry("test"); e.Size = -6; }
public void InvalidMagic() { TarEntry e = TarEntry.CreateTarEntry("test"); e.TarHeader.Magic = null; }
private void AddDirectoryFilesToTar(TarArchive tarArchive, string sourceDirectory) { TarEntry tarEntry = TarEntry.CreateEntryFromFile(sourceDirectory); tarArchive.WriteEntry(tarEntry, false); }
private async void btnBuild_Click(object sender, EventArgs e) { if (_baseRegistryClient == null || string.IsNullOrWhiteSpace(comboBaseRepository.Text) || lstTags.SelectedIndex < 0 ) { MessageBox.Show("something is not prepared"); return; } List <string> dockerFileLines = new List <string>(); dockerFileLines.Add($"FROM {comboBaseRepository.Text}:{lstTags.SelectedItem.ToString()}"); dockerFileLines.Add(@"RUN apt-get update && apt-get install libcurl4-openssl-dev libv8-3.14-dev -y &&\"); dockerFileLines.Add(" mkdir -p /var/lib/shiny-server/bookmarks/shiny"); dockerFileLines.Add("COPY *.R /srv/shiny-server/"); if (lstPackages.Items.Count > 0) { List <string> packageList = new List <string>(); foreach (var item in lstPackages.Items) { packageList.Add($"'{item.ToString()}'"); } string packages = string.Join(",", packageList); dockerFileLines.Add($"RUN R -e \"install.packages(c({packages}))\""); } dockerFileLines.Add("RUN chmod -R 755 /srv/shiny-server/"); dockerFileLines.Add("EXPOSE 3838"); dockerFileLines.Add("CMD [\"/usr/bin/shiny-server.sh\"]"); File.WriteAllLines(Path.Combine(lblApplicationFolder.Text, "dockerfile"), dockerFileLines); Directory.SetCurrentDirectory(lblApplicationFolder.Text); // The contents of the application have to be put in a tar file DirectoryInfo directoryOfFilesToBeTarred = new DirectoryInfo(lblApplicationFolder.Text); FileInfo[] filesInDirectory = directoryOfFilesToBeTarred.GetFiles(); String tarArchiveName = Path.Combine(lblApplicationFolder.Text, "mytararchive.tar"); using (TarArchive tarArchive = TarArchive.CreateOutputTarArchive(File.Create(tarArchiveName), TarBuffer.DefaultBlockFactor)) { foreach (FileInfo fileToBeTarred in filesInDirectory) { TarEntry entry = TarEntry.CreateEntryFromFile(fileToBeTarred.FullName); tarArchive.WriteEntry(entry, true); } } string dockerfile = Path.Combine(lblApplicationFolder.Text, "dockerfile").Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar); try { using (Stream result = await _localEngineClient.Images.BuildImageFromDockerfileAsync( new FileStream(tarArchiveName, FileMode.Open), new ImageBuildParameters { Tags = new List <string> { $"{comboTargetRegistry.Text}/{txtTargetTag.Text}" } })) { using (FileStream writer = new FileStream(Path.Combine(lblApplicationFolder.Text, "output.file").Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar), FileMode.Create)) { int bytesread = 0; do { byte[] buffer = new byte[1000]; bytesread = result.Read(buffer, 0, 1000); writer.Write(buffer, 0, bytesread); writer.Flush(); }while (bytesread > 0); } } } catch (Exception ex) { Console.WriteLine($"Exception with message {ex.Message}"); } File.Delete(tarArchiveName); }
private void ParseStream() { _entries = new Dictionary <string, TarEntry>(); _stream.Seek(0, SeekOrigin.Begin); while (true) { byte[] header = new byte[512]; if (_stream.Read(header, 0, 512) != 512) { throw new FileFormatException("Stream contains incomplete Tape Archive entry header."); } // Is this a null entry? If so, we've reached the supposed end of the // stream. On real tape archives using the TAR format, there may be // data after the null entry, but it is ignored. In addition, there // should be two null entries to signify the end of the archive, // but 7-Zip handles just fine with only one null entry. if (header.All(x => (x == 0))) { return; } // Is this a ustar file? if (!Magic.SequenceEqual(header.Skip(257).Take(5))) { throw new FileFormatException("Tape Archive entry is not a valid ustar entry."); } // Get file name and file size. Trim null characters while doing so. char[] arrfileName = Encoding.ASCII.GetChars(header, 0, 100); if (arrfileName[0] == 0) { throw new FileFormatException("Invalid file name."); } string strFileName = new String(arrfileName.TakeWhile(x => x != 0).ToArray()); char[] arrfileSize = Encoding.ASCII.GetChars(header, 124, 12); string strFileSize = new String(arrfileSize.TakeWhile(x => x != 0).ToArray()); // Before adding the entry to the list, ensure the stream contains that many bytes. // Interpret the file size as unsigned to ensure it's not read as a signed number. // TODO: Are numbers interpreted as signed /at all/? ulong fileSize = Convert.ToUInt64(strFileSize, 8); TarEntry entry = new TarEntry(_stream.Position, (long)fileSize); // Round file size up to multiple of 512 // Hacker's Delight 2nd Ed., pg. 59 ulong paddedFileLength = (fileSize + 511UL) & ~511UL; // Skip over file try { _stream.Seek((long)paddedFileLength, SeekOrigin.Current); } catch (IOException ex) { throw new FileFormatException("File length extends past end of stream.", ex); } // Add the entry if (_entries.ContainsKey(strFileName)) { throw new FileFormatException("Encountered a file with an already encountered file path."); } _entries.Add(strFileName, entry); } }
partial void VerifyPlatformSpecificMetadata(string filePath, TarEntry entry);
private static async void InstallUpdate(UpdateDialog updateDialog, string updateFile) { // Extract Update updateDialog.MainText.Text = "Extracting Update..."; updateDialog.ProgressBar.Value = 0; if (OperatingSystem.IsLinux()) { using (Stream inStream = File.OpenRead(updateFile)) using (Stream gzipStream = new GZipInputStream(inStream)) using (TarInputStream tarStream = new TarInputStream(gzipStream, Encoding.ASCII)) { updateDialog.ProgressBar.MaxValue = inStream.Length; await Task.Run(() => { TarEntry tarEntry; while ((tarEntry = tarStream.GetNextEntry()) != null) { if (tarEntry.IsDirectory) { continue; } string outPath = Path.Combine(UpdateDir, tarEntry.Name); Directory.CreateDirectory(Path.GetDirectoryName(outPath)); using (FileStream outStream = File.OpenWrite(outPath)) { tarStream.CopyEntryContents(outStream); } File.SetLastWriteTime(outPath, DateTime.SpecifyKind(tarEntry.ModTime, DateTimeKind.Utc)); TarEntry entry = tarEntry; Application.Invoke(delegate { updateDialog.ProgressBar.Value += entry.Size; }); } }); updateDialog.ProgressBar.Value = inStream.Length; } } else { using (Stream inStream = File.OpenRead(updateFile)) using (ZipFile zipFile = new ZipFile(inStream)) { updateDialog.ProgressBar.MaxValue = zipFile.Count; await Task.Run(() => { foreach (ZipEntry zipEntry in zipFile) { if (zipEntry.IsDirectory) { continue; } string outPath = Path.Combine(UpdateDir, zipEntry.Name); Directory.CreateDirectory(Path.GetDirectoryName(outPath)); using (Stream zipStream = zipFile.GetInputStream(zipEntry)) using (FileStream outStream = File.OpenWrite(outPath)) { zipStream.CopyTo(outStream); } File.SetLastWriteTime(outPath, DateTime.SpecifyKind(zipEntry.DateTime, DateTimeKind.Utc)); Application.Invoke(delegate { updateDialog.ProgressBar.Value++; }); } }); } } // Delete downloaded zip File.Delete(updateFile); List <string> allFiles = EnumerateFilesToDelete().ToList(); updateDialog.MainText.Text = "Renaming Old Files..."; updateDialog.ProgressBar.Value = 0; updateDialog.ProgressBar.MaxValue = allFiles.Count; // Replace old files await Task.Run(() => { foreach (string file in allFiles) { try { File.Move(file, file + ".ryuold"); Application.Invoke(delegate { updateDialog.ProgressBar.Value++; }); } catch { Logger.Warning?.Print(LogClass.Application, "Updater was unable to rename file: " + file); } } Application.Invoke(delegate { updateDialog.MainText.Text = "Adding New Files..."; updateDialog.ProgressBar.Value = 0; updateDialog.ProgressBar.MaxValue = Directory.GetFiles(UpdatePublishDir, "*", SearchOption.AllDirectories).Length; }); MoveAllFilesOver(UpdatePublishDir, HomeDir, updateDialog); }); Directory.Delete(UpdateDir, true); SetUnixPermissions(); updateDialog.MainText.Text = "Update Complete!"; updateDialog.SecondaryText.Text = "Do you want to restart Ryujinx now?"; updateDialog.Modal = true; updateDialog.ProgressBar.Hide(); updateDialog.YesButton.Show(); updateDialog.NoButton.Show(); }
public static long WriteFileOrDirectoryToStream(Stream stream, string targetPath, bool closeStreamWhenComplete = true) { long bytesSent = 0; TarArchive tar = TarArchive.CreateOutputTarArchive(stream); tar.IsStreamOwner = closeStreamWhenComplete; string[] fileList = null; string rootPath = null; // handle globs, directories, and individual files. if (targetPath.Contains("*") || targetPath.Contains("?")) { // we're handling a glob rootPath = Path.GetDirectoryName(targetPath); fileList = GlobFunctions.Glob(targetPath); } else if (File.GetAttributes(targetPath).HasFlag(FileAttributes.Directory)) { // handling a directory rootPath = targetPath; fileList = Directory.GetFileSystemEntries(targetPath, "*", SearchOption.AllDirectories); } else { // handling a single file rootPath = Path.GetDirectoryName(targetPath); fileList = new string[] { targetPath }; } foreach (var entry in fileList) { var tarEntry = TarEntry.CreateEntryFromFile(entry); // Work around for icsharpcode/SharpZipLib issues #334, #337, #338 // This manually rebuilds the tar header entry name var newEntryName = entry; // remove the root path, if present and not an empty string, from the entry path if (!string.IsNullOrEmpty(rootPath) && newEntryName.StartsWith(rootPath, StringComparison.OrdinalIgnoreCase)) { newEntryName = newEntryName.Substring(rootPath.Length + 1); } // in the event this was a unc path name (started with \\), // remove leading '\' entries. while (newEntryName.StartsWith(@"\", StringComparison.Ordinal)) { newEntryName = newEntryName.Substring(1); } // switch all back slashes to forwrd slashes newEntryName = newEntryName.Replace(Path.DirectorySeparatorChar, '/'); // if this is a directory, it should have a trailing slash. if (File.GetAttributes(entry).HasFlag(FileAttributes.Directory)) { newEntryName += '/'; } // rewrite the header block name tarEntry.TarHeader.Name = newEntryName; // end work around for icsharpcode/SharpZipLib. tar.WriteEntry(tarEntry, false); // if it's a file, count it's size if (!File.GetAttributes(entry).HasFlag(FileAttributes.Directory)) { bytesSent += (new FileInfo(entry)).Length; } } // close the archive tar.Close(); // return our byte count return(bytesSent); }
/// <summary> /// Returns available modules from the supplied tar.gz file. /// </summary> private static List <CkanModule> UpdateRegistryFromTarGz(string path, out SortedDictionary <string, int> downloadCounts) { log.DebugFormat("Starting registry update from tar.gz file: \"{0}\".", path); downloadCounts = null; List <CkanModule> modules = new List <CkanModule>(); // Open the gzip'ed file. using (Stream inputStream = File.OpenRead(path)) { // Create a gzip stream. using (GZipInputStream gzipStream = new GZipInputStream(inputStream)) { // Create a handle for the tar stream. using (TarInputStream tarStream = new TarInputStream(gzipStream)) { // Walk the archive, looking for .ckan files. const string filter = @"\.ckan$"; while (true) { TarEntry entry = tarStream.GetNextEntry(); // Check for EOF. if (entry == null) { break; } string filename = entry.Name; if (filename.EndsWith("download_counts.json")) { downloadCounts = JsonConvert.DeserializeObject <SortedDictionary <string, int> >( tarStreamString(tarStream, entry) ); continue; } else if (!Regex.IsMatch(filename, filter)) { // Skip things we don't want. log.DebugFormat("Skipping archive entry {0}", filename); continue; } log.DebugFormat("Reading CKAN data from {0}", filename); // Read each file into a buffer. string metadata_json = tarStreamString(tarStream, entry); CkanModule module = ProcessRegistryMetadataFromJSON(metadata_json, filename); if (module != null) { modules.Add(module); } } } } } return(modules); }
void EntryCounter(TarArchive archive, TarEntry entry, string message) { entryCount++; }
private string PackFiles(List <CompilationTask> taskList) { byte[] package; using (var memoryStream = new MemoryStream()) { using (var archive = TarArchive.CreateOutputTarArchive(memoryStream)) { List <string> addedEntries = new List <string>(); // Package precompiled header if used foreach (CompilationTask task in taskList) { if (task.PrecompiledHeader.Length > 0) { TarEntry entry = TarEntry.CreateEntryFromFile(task.PrecompiledHeader); entry.Name = Path.GetFileName(task.PrecompiledHeader); archive.WriteEntry(entry, false); break; } } foreach (CompilationTask task in taskList) { // Package sourcefiles // not needed since this file is already in the task.Includes // TODO: should it be like this? { TarEntry entry = TarEntry.CreateEntryFromFile(task.FilePath); entry.Name = Path.GetFileName(task.FilePath); archive.WriteEntry(entry, false); } // Package includes string projectPath = task.ProjectPath; string dstLibIncludePath = "includes"; string dstProjectIncludePath = ""; foreach (string include in task.Includes) { string dstFilePath = null; if (include.StartsWith(projectPath)) { string relative = include.Replace(projectPath, "").TrimStart('\\', '/'); dstFilePath = Path.Combine(dstProjectIncludePath, relative); } else { for (int i = 0; i < task.IncludeDirs.Count; ++i) { string srcIncludePath = task.IncludeDirs[i]; if (include.StartsWith(srcIncludePath)) { string relative = include.Replace(srcIncludePath, "").TrimStart('\\', '/'); dstFilePath = Path.Combine(dstLibIncludePath + i.ToString(), relative); break; } } } AddFileToTar(archive, include, dstFilePath, addedEntries); } } // Package build batch TextWriter batch = new StreamWriter("golembuild.bat", false); // CD to the directory the batch file is in batch.WriteLine("cd %~DP0"); // Create output folder batch.WriteLine("mkdir output"); int numberOfIncludeDirs = 0; List <CompilerArg> compilerArgs = new List <CompilerArg>(); foreach (CompilationTask task in taskList) { bool found = false; foreach (CompilerArg compilerArg in compilerArgs) { if (compilerArg.compiler == task.Compiler && compilerArg.args == task.CompilerArgs) { compilerArg.files.Add(Path.GetFileName(task.FilePath)); found = true; break; } } if (found) { continue; } numberOfIncludeDirs = Math.Max(numberOfIncludeDirs, task.IncludeDirs.Count); CompilerArg newCompilerArg = new CompilerArg(); newCompilerArg.compiler = task.Compiler; newCompilerArg.args = task.CompilerArgs; newCompilerArg.files.Add(Path.GetFileName(task.FilePath)); compilerArgs.Add(newCompilerArg); } // Add compilation commands, once per CompilerArg foreach (CompilerArg compilerArg in compilerArgs) { for (int i = 0; i < numberOfIncludeDirs; ++i) { compilerArg.args += " /I\"includes" + i.ToString() + "\" /FS"; } compilerArg.args += " /Fo\"output/\""; compilerArg.args += " /Fd\"output/" + Path.GetFileNameWithoutExtension(compilerArg.files[0]) + ".pdb\""; compilerArg.args += " /MP" + TaskCapacity; batch.Write("\"../" + Path.GetFileName(compilerArg.compiler) + "\" " + compilerArg.args); foreach (string file in compilerArg.files) { batch.Write(" " + file); } batch.WriteLine(); } // Zip output folder batch.WriteLine("powershell.exe -nologo -noprofile -command \"& { Add-Type -A 'System.IO.Compression.FileSystem'; [IO.Compression.ZipFile]::CreateFromDirectory('output', 'output.zip'); }\""); // stop the service batch.WriteLine("\"../mspdbsrv.exe\" -stop"); batch.WriteLine("exit 0");//assume no error batch.Close(); TarEntry batchEntry = TarEntry.CreateEntryFromFile("golembuild.bat"); batchEntry.Name = "golembuild.bat"; archive.WriteEntry(batchEntry, false); } package = memoryStream.ToArray(); string hash = GolemCache.RegisterTasksPackage(package); FileStream debug = new FileStream(hash + ".tar", FileMode.Create); debug.Write(package, 0, package.Length); debug.Close(); return(hash); } }
public void InvalidModTime() { TarEntry e = TarEntry.CreateTarEntry("test"); e.ModTime = DateTime.MinValue; }
private string PackFilesPreProcessed(List <CompilationTask> taskList) { byte[] package; using (var memoryStream = new MemoryStream()) { using (var archive = new TarOutputStream(memoryStream)) { List <string> addedEntries = new List <string>(); //precompiled headers are not used in preprocessed build // Package build batch TextWriter batch = new StreamWriter("golembuild.bat", false); // CD to the directory the batch file is in batch.WriteLine("cd %~DP0"); // Create output folder batch.WriteLine("mkdir output"); List <CompilerArg> compilerArgs = new List <CompilerArg>(); foreach (CompilationTask task in taskList) { bool found = false; string args = task.CompilerArgs; foreach (CompilerArg compilerArg in compilerArgs) { bool includesMatch = task.IncludeDirs.Count == compilerArg.includeDirs.Count; if (includesMatch) { for (int i = 0; i < task.IncludeDirs.Count; ++i) { if (!compilerArg.includeDirs[i].Equals(task.IncludeDirs[i])) { includesMatch = false; break; } } } if (compilerArg.compiler == task.Compiler && compilerArg.args == args && includesMatch) { compilerArg.files.Add(task.FilePath); found = true; break; } } if (found) { continue; } CompilerArg newCompilerArg = new CompilerArg(); newCompilerArg.compiler = task.Compiler; newCompilerArg.args = args; newCompilerArg.files.Add(task.FilePath); foreach (string e in task.IncludeDirs) { newCompilerArg.includeDirs.Add(e); } compilerArgs.Add(newCompilerArg); } string tempFolder = "iGolemBuild" + Peer.NodeId; Directory.CreateDirectory(tempFolder); //foreach compilation task, preprocess the cpp file into a temporary folder foreach (CompilerArg compilerArg in compilerArgs) { //preprocess file, grab output, write the file as file to compile on external machine Process proc = new Process(); string args = compilerArg.args; //add includes foreach (string inc in compilerArg.includeDirs) { args += " /I\"" + inc + "\" "; } //add preprocessing flag args += "/P /Fi" + tempFolder + "\\ "; args += "/MP" + TaskCapacity; //add source files foreach (string srcFile in compilerArg.files) { args += " " + srcFile; } proc.StartInfo.Arguments = args; proc.StartInfo.FileName = compilerArg.compiler; proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden; proc.StartInfo.UseShellExecute = false; proc.StartInfo.RedirectStandardInput = false; proc.StartInfo.RedirectStandardOutput = true; proc.StartInfo.RedirectStandardError = true; proc.StartInfo.CreateNoWindow = true; proc.Start(); System.Text.StringBuilder outputStr = new System.Text.StringBuilder(); proc.OutputDataReceived += (sender, e) => { if (e.Data != null) { string output = e.Data; Logger.LogMessage(output); } }; proc.ErrorDataReceived += (sender, e) => { if (e.Data != null) { outputStr.AppendLine(e.Data); } }; proc.BeginOutputReadLine(); proc.BeginErrorReadLine(); proc.WaitForExit(); Logger.LogMessage(outputStr.ToString()); if (proc.ExitCode == 0) { //now read back the files and add them to tar foreach (string srcFile in compilerArg.files) { //TODO: this might be inside a folder string precompiledFile = tempFolder + "\\" + Path.GetFileNameWithoutExtension(srcFile) + ".i"; TarEntry entry = TarEntry.CreateEntryFromFile(precompiledFile); entry.Name = Path.GetFileName(srcFile); archive.PutNextEntry(entry); using (Stream inputStream = File.OpenRead(precompiledFile)) { writeStreamToTar(archive, inputStream); archive.CloseEntry(); } } } else { Logger.LogError($"Preprocessing of file package failed"); } } Directory.Delete(tempFolder, true); // Add compilation commands, once per CompilerArg foreach (CompilerArg compilerArg in compilerArgs) { //remove precompiled header args /Yu /Fp Match match = Regex.Match(compilerArg.args, "/Yu\".+?\""); if (match.Success) { compilerArg.args = compilerArg.args.Remove(match.Index, match.Length); } match = Regex.Match(compilerArg.args, "/Fp\".+?\""); if (match.Success) { compilerArg.args = compilerArg.args.Remove(match.Index, match.Length); } compilerArg.args += " /FS"; compilerArg.args += " /Fo\"output/\""; compilerArg.args += " /Fd\"output/" + Path.GetFileNameWithoutExtension(compilerArg.files[0]) + ".pdb\""; compilerArg.args += " /MP" + TaskCapacity; batch.Write("\"../" + Path.GetFileName(compilerArg.compiler) + "\" " + compilerArg.args); foreach (string file in compilerArg.files) { batch.Write(" " + Path.GetFileName(file)); } batch.WriteLine(); } // Zip output folder batch.WriteLine("powershell.exe -nologo -noprofile -command \"& { Add-Type -A 'System.IO.Compression.FileSystem'; [IO.Compression.ZipFile]::CreateFromDirectory('output', 'output.zip'); }\""); // stop the service batch.WriteLine("\"../mspdbsrv.exe\" -stop"); batch.WriteLine("exit 0");//assume no error batch.Close(); TarEntry batchEntry = TarEntry.CreateEntryFromFile("golembuild.bat"); batchEntry.Name = "golembuild.bat"; using (Stream inputStream = File.OpenRead("golembuild.bat")) { batchEntry.Size = inputStream.Length; archive.PutNextEntry(batchEntry); writeStreamToTar(archive, inputStream); archive.CloseEntry(); } } package = memoryStream.ToArray(); string hash = GolemCache.RegisterTasksPackage(package); FileStream debug = new FileStream(hash + ".tar", FileMode.Create); debug.Write(package, 0, package.Length); debug.Close(); return(hash); } }
public void InvalidName() { TarEntry e = TarEntry.CreateTarEntry("test"); e.Name = null; }
public override TaskStatus Run() { Info("Creating tgz archive..."); bool success = true; var files = SelectFiles(); if (files.Length > 0) { var tgzPath = Path.Combine(Workflow.WorkflowTempFolder, TgzFileName); try { using (var gz = new GZipOutputStream(File.Create(tgzPath))) using (var tar = new TarOutputStream(gz)) { foreach (FileInf file in files) { using (Stream inputStream = File.OpenRead(file.Path)) { string tarName = file.FileName; long fileSize = inputStream.Length; // Create a tar entry named as appropriate. You can set the name to anything, // but avoid names starting with drive or UNC. var entry = TarEntry.CreateTarEntry(tarName); // Must set size, otherwise TarOutputStream will fail when output exceeds. entry.Size = fileSize; // Add the entry to the tar stream, before writing the data. tar.PutNextEntry(entry); var localBuffer = new byte[32 * 1024]; while (true) { var numRead = inputStream.Read(localBuffer, 0, localBuffer.Length); if (numRead <= 0) { break; } tar.Write(localBuffer, 0, numRead); } } tar.CloseEntry(); } // Finish/Close arent needed strictly as the using statement does this automatically tar.Close(); // Finish is important to ensure trailing information for a Zip file is appended. Without this // the created file would be invalid. gz.Finish(); // Close is important to wrap things up and unlock the file. gz.Close(); InfoFormat("Tgz {0} created.", tgzPath); Files.Add(new FileInf(tgzPath, Id)); } } catch (ThreadAbortException) { throw; } catch (Exception e) { ErrorFormat("An error occured while creating the Tar {0}", e, tgzPath); success = false; } } var status = Status.Success; if (!success) { status = Status.Error; } Info("Task finished."); return(new TaskStatus(status, false)); }
public void InvalidLinkName() { TarEntry e = TarEntry.CreateTarEntry("test"); e.TarHeader.LinkName = null; }
public static async Task UpdateRyujinx(UpdateDialog updateDialog, string downloadUrl) { // Empty update dir, although it shouldn't ever have anything inside it if (Directory.Exists(UpdateDir)) { Directory.Delete(UpdateDir, true); } Directory.CreateDirectory(UpdateDir); string updateFile = Path.Combine(UpdateDir, "update.bin"); // Download the update .zip updateDialog.MainText.Text = "Downloading Update..."; updateDialog.ProgressBar.Value = 0; updateDialog.ProgressBar.MaxValue = 100; using (WebClient client = new WebClient()) { client.DownloadProgressChanged += (_, args) => { updateDialog.ProgressBar.Value = args.ProgressPercentage; }; await client.DownloadFileTaskAsync(downloadUrl, updateFile); } // Extract Update updateDialog.MainText.Text = "Extracting Update..."; updateDialog.ProgressBar.Value = 0; if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { using (Stream inStream = File.OpenRead(updateFile)) using (Stream gzipStream = new GZipInputStream(inStream)) using (TarInputStream tarStream = new TarInputStream(gzipStream, Encoding.ASCII)) { updateDialog.ProgressBar.MaxValue = inStream.Length; await Task.Run(() => { TarEntry tarEntry; while ((tarEntry = tarStream.GetNextEntry()) != null) { if (tarEntry.IsDirectory) { continue; } string outPath = Path.Combine(UpdateDir, tarEntry.Name); Directory.CreateDirectory(Path.GetDirectoryName(outPath)); using (FileStream outStream = File.OpenWrite(outPath)) { tarStream.CopyEntryContents(outStream); } File.SetLastWriteTime(outPath, DateTime.SpecifyKind(tarEntry.ModTime, DateTimeKind.Utc)); TarEntry entry = tarEntry; Application.Invoke(delegate { updateDialog.ProgressBar.Value += entry.Size; }); } }); updateDialog.ProgressBar.Value = inStream.Length; } } else { using (Stream inStream = File.OpenRead(updateFile)) using (ZipFile zipFile = new ZipFile(inStream)) { updateDialog.ProgressBar.MaxValue = zipFile.Count; await Task.Run(() => { foreach (ZipEntry zipEntry in zipFile) { if (zipEntry.IsDirectory) { continue; } string outPath = Path.Combine(UpdateDir, zipEntry.Name); Directory.CreateDirectory(Path.GetDirectoryName(outPath)); using (Stream zipStream = zipFile.GetInputStream(zipEntry)) using (FileStream outStream = File.OpenWrite(outPath)) { zipStream.CopyTo(outStream); } File.SetLastWriteTime(outPath, DateTime.SpecifyKind(zipEntry.DateTime, DateTimeKind.Utc)); Application.Invoke(delegate { updateDialog.ProgressBar.Value++; }); } }); } } // Delete downloaded zip File.Delete(updateFile); string[] allFiles = Directory.GetFiles(HomeDir, "*", SearchOption.AllDirectories); updateDialog.MainText.Text = "Renaming Old Files..."; updateDialog.ProgressBar.Value = 0; updateDialog.ProgressBar.MaxValue = allFiles.Length; // Replace old files await Task.Run(() => { foreach (string file in allFiles) { if (!Path.GetExtension(file).Equals(".log")) { try { File.Move(file, file + ".ryuold"); Application.Invoke(delegate { updateDialog.ProgressBar.Value++; }); } catch { Logger.Warning?.Print(LogClass.Application, "Updater wasn't able to rename file: " + file); } } } Application.Invoke(delegate { updateDialog.MainText.Text = "Adding New Files..."; updateDialog.ProgressBar.Value = 0; updateDialog.ProgressBar.MaxValue = Directory.GetFiles(UpdatePublishDir, "*", SearchOption.AllDirectories).Length; }); MoveAllFilesOver(UpdatePublishDir, HomeDir, updateDialog); }); Directory.Delete(UpdateDir, true); updateDialog.MainText.Text = "Update Complete!"; updateDialog.SecondaryText.Text = "Do you want to restart Ryujinx now?"; updateDialog.Modal = true; updateDialog.ProgressBar.Hide(); updateDialog.YesButton.Show(); updateDialog.NoButton.Show(); }
private static async Task CreateTarAsync(IEnumerable <FileSystemStorageItemBase> SourceItemGroup, string NewZipPath, ProgressChangedEventHandler ProgressHandler = null) { if (await FileSystemStorageItemBase.CreateAsync(NewZipPath, StorageItemTypes.File, CreateOption.GenerateUniqueName).ConfigureAwait(false) is FileSystemStorageFile NewFile) { ulong TotalSize = 0; ulong CurrentPosition = 0; foreach (FileSystemStorageItemBase StorageItem in SourceItemGroup) { switch (StorageItem) { case FileSystemStorageFile File: { TotalSize += File.SizeRaw; break; } case FileSystemStorageFolder Folder: { TotalSize += await Folder.GetFolderSizeAsync().ConfigureAwait(false); break; } } } if (TotalSize > 0) { using (FileStream NewFileStream = await NewFile.GetFileStreamFromFileAsync(AccessMode.Exclusive).ConfigureAwait(false)) using (TarOutputStream OutputTarStream = new TarOutputStream(NewFileStream, EncodingSetting)) { OutputTarStream.IsStreamOwner = false; foreach (FileSystemStorageItemBase StorageItem in SourceItemGroup) { switch (StorageItem) { case FileSystemStorageFile File: { using (FileStream FileStream = await File.GetFileStreamFromFileAsync(AccessMode.Read).ConfigureAwait(false)) { TarEntry NewEntry = TarEntry.CreateTarEntry(File.Name); NewEntry.ModTime = DateTime.Now; NewEntry.Size = FileStream.Length; OutputTarStream.PutNextEntry(NewEntry); await FileStream.CopyToAsync(OutputTarStream, ProgressHandler : (s, e) => { ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + Convert.ToUInt64(e.ProgressPercentage / 100d * File.SizeRaw)) * 100d / TotalSize), null)); }).ConfigureAwait(false); } OutputTarStream.CloseEntry(); CurrentPosition += File.SizeRaw; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); break; } case FileSystemStorageFolder Folder: { ulong InnerFolderSize = 0; await TarFolderCore(Folder, OutputTarStream, Folder.Name, (ByteRead) => { InnerFolderSize = ByteRead; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32((CurrentPosition + ByteRead) * 100d / TotalSize), null)); }).ConfigureAwait(false); CurrentPosition += InnerFolderSize; ProgressHandler?.Invoke(null, new ProgressChangedEventArgs(Convert.ToInt32(CurrentPosition * 100d / TotalSize), null)); break; } } } await OutputTarStream.FlushAsync().ConfigureAwait(false); } } } else { throw new UnauthorizedAccessException(); } }
/// <summary> /// Appends the Files of a map to an existing Archive /// </summary> /// <param name="map">the map that contains files which need to be added to an archive</param> /// <param name="wrappedName">the name of the taret wrapper-file</param> public override void AppendFiles(FileMap map, string wrappedName) { bool existing = false; if (File.Exists(wrappedName)) { File.Move(wrappedName, $"{wrappedName}.lock"); existing = true; } using (TarStreamHelper helper = new TarStreamHelper(true, useGz, wrappedName)) { foreach (FileMapEntry entry in map) { TarEntry ent = TarEntry.CreateEntryFromFile(entry.LocationInFileSystem); ent.Name = entry.ArchiveFileName; helper.OutputStream.PutNextEntry(ent); using (Stream fs = entry.Open()) { fs.CopyTo(helper.OutputStream); } helper.OutputStream.CloseEntry(); } if (existing) { try { using (var exhelper = new TarStreamHelper(false, useGz, $"{wrappedName}.lock")) { UnTarFiles(".", exhelper, true, e => { if (!map.Contains(e.ArchiveFileName)) { TarEntry ent = TarEntry.CreateTarEntry(e.ArchiveFileName); helper.OutputStream.PutNextEntry(ent); return(helper.OutputStream); } return(null); }, (input, output) => { try { input.CopyTo(output); } finally { helper.OutputStream.CloseEntry(); } }, true); } } finally { File.Delete($"{wrappedName}.lock"); } } } }
/// <summary> /// 打包多个文件进TAR /// </summary> /// <param name="TarFile"></param> /// <param name="files"></param> public void SerFilesToTar(Stream TarStream, string rootPath, params string[] files) { TarOutputStream taroutputstream = new TarOutputStream(TarStream); try { TarHeader.EncodingName = "gb2312"; foreach (string f in files) { string tempfile = string.IsNullOrEmpty(rootPath) || !f.ToLower().StartsWith(rootPath.ToLower()) ? f.Substring(3, f.Length - 3) : f.Substring(rootPath.Length).Trim('\\'); TarHeader th = new TarHeader(); TarEntry tarEntry = TarEntry.CreateEntryFromFile(f); tarEntry.Name = tempfile; if (tarEntry.IsDirectory) { taroutputstream.PutNextEntry(tarEntry); } else { FileStream ins = new FileStream(f, FileMode.Open, FileAccess.Read); tarEntry.Size = ins.Length; taroutputstream.PutNextEntry(tarEntry); //tar.WriteEntry(tarEntry, true); Console.Write("打包:" + System.IO.Path.GetFileName(f) + " "); long packedsize = 0; while (true) { if (packedsize >= tarEntry.Size) { break; } byte[] buffer = new byte[1024 * 1024]; int bl = ins.Read(buffer, 0, buffer.Length); if (bl > 0) { taroutputstream.Write(buffer, 0, bl); packedsize += bl; float per = (float)packedsize / ins.Length * 100; Console.Write("\b\b\b\b{0,4:G}", per.ToString("###") + "%"); } else { Console.WriteLine("\b\b\b\b{0,4:G}", "100%"); break; } } ins.Close(); } taroutputstream.CloseEntry(); } } catch (Exception ex) { throw ex; } finally { taroutputstream.Close(); } }
private static IFolder findOrCreateFolder(string folderName, IFolder searchInFolder, TarEntry tarEntry) { foreach (IFolder folder in searchInFolder.Folders) { if ((folder as ItemInDatabase).Name == folderName) { return(folder); } } FolderInDatabase newFolder = new FolderInDatabase(searchInFolder); // newFolder.Description = tarEntry.Comment; newFolder.CreationTime = tarEntry.ModTime; newFolder.Name = folderName; newFolder.Attributes = FileAttributes.Directory; // na sztywno searchInFolder.AddToFolders(newFolder); return(newFolder); }
/// <summary> /// Updates the supplied registry from the supplied zip file. /// This will *clear* the registry of available modules first. /// This does not *save* the registry. For that, you probably want Repo.Update /// </summary> internal static void UpdateRegistryFromTarGz(string path, Registry registry) { log.DebugFormat("Starting registry update from tar.gz file: \"{0}\".", path); // Open the gzip'ed file. using (Stream inputStream = File.OpenRead(path)) { // Create a gzip stream. using (GZipInputStream gzipStream = new GZipInputStream(inputStream)) { // Create a handle for the tar stream. using (TarInputStream tarStream = new TarInputStream(gzipStream)) { // Walk the archive, looking for .ckan files. const string filter = @"\.ckan$"; while (true) { TarEntry entry = tarStream.GetNextEntry(); // Check for EOF. if (entry == null) { break; } string filename = entry.Name; // Skip things we don't want. if (!Regex.IsMatch(filename, filter)) { log.DebugFormat("Skipping archive entry {0}", filename); continue; } log.DebugFormat("Reading CKAN data from {0}", filename); // Read each file into a buffer. int buffer_size; try { buffer_size = Convert.ToInt32(entry.Size); } catch (OverflowException) { log.ErrorFormat("Error processing {0}: Metadata size too large.", entry.Name); continue; } byte[] buffer = new byte[buffer_size]; tarStream.Read(buffer, 0, buffer_size); // Convert the buffer data to a string. string metadata_json = Encoding.ASCII.GetString(buffer); ProcessRegistryMetadataFromJSON(metadata_json, registry, filename); } } } } }
public void TrailerContainsNulls() { const int TestBlockFactor = 3; for (int iteration = 0; iteration < TestBlockFactor * 2; ++iteration) { MemoryStream ms = new MemoryStream(); using (TarOutputStream tarOut = new TarOutputStream(ms, TestBlockFactor)) { TarEntry entry = TarEntry.CreateTarEntry("TestEntry"); if (iteration > 0) { entry.Size = (TarBuffer.BlockSize * (iteration - 1)) + 9; } tarOut.PutNextEntry(entry); byte[] buffer = new byte[TarBuffer.BlockSize]; Random r = new Random(); r.NextBytes(buffer); if (iteration > 0) { for (int i = 0; i < iteration - 1; ++i) { tarOut.Write(buffer, 0, buffer.Length); } // Last block is a partial one for (int i = 1; i < 10; ++i) { tarOut.WriteByte((byte)i); } } } byte[] tarData = ms.ToArray(); Assert.IsNotNull(tarData, "Data written is null"); // Blocks = Header + Data Blocks + Zero block + Record trailer int usedBlocks = 1 + iteration + 1; int totalBlocks = usedBlocks + (TestBlockFactor - 1); totalBlocks /= TestBlockFactor; totalBlocks *= TestBlockFactor; Assert.AreEqual(TarBuffer.BlockSize * totalBlocks, tarData.Length, string.Format("Tar file should be {0} blocks in length", totalBlocks)); if (usedBlocks < totalBlocks) { // Start at first byte after header. int byteIndex = TarBuffer.BlockSize * (iteration + 1); while (byteIndex < tarData.Length) { int blockNumber = byteIndex / TarBuffer.BlockSize; int offset = blockNumber % TarBuffer.BlockSize; Assert.AreEqual(0, tarData[byteIndex], string.Format("Trailing block data should be null iteration {0} block {1} offset {2} index {3}", iteration, blockNumber, offset, byteIndex)); byteIndex += 1; } } } }
/// <summary> /// This is the "real" main. The class main() instantiates a tar object /// for the application and then calls this method. Process the arguments /// and perform the requested operation. /// </summary> public void InstanceMain(string[] argv) { TarArchive archive = null; int argIdx = this.ProcessArguments(argv); if (this.archiveName != null && !this.archiveName.Equals("-")) { if (operation == Operation.Create) { string dirName = Path.GetDirectoryName(archiveName); if ((dirName.Length > 0) && !Directory.Exists(dirName)) { Console.Error.WriteLine("Directory for archive doesnt exist"); return; } } else { if (File.Exists(this.archiveName) == false) { Console.Error.WriteLine("File does not exist " + this.archiveName); return; } } } if (operation == Operation.Create) // WRITING { Stream outStream = Console.OpenStandardOutput(); if (this.archiveName != null && !this.archiveName.Equals("-")) { outStream = File.Create(archiveName); } if (outStream != null) { switch (this.compression) { case Compression.Compress: outStream = new DeflaterOutputStream(outStream); break; case Compression.Gzip: outStream = new GZipOutputStream(outStream); break; case Compression.Bzip2: outStream = new BZip2OutputStream(outStream, 9); break; } archive = TarArchive.CreateOutputTarArchive(outStream, this.blockingFactor); } } else // EXTRACTING OR LISTING { Stream inStream = Console.OpenStandardInput(); if (this.archiveName != null && !this.archiveName.Equals("-")) { inStream = File.OpenRead(archiveName); } if (inStream != null) { switch (this.compression) { case Compression.Compress: inStream = new InflaterInputStream(inStream); break; case Compression.Gzip: inStream = new GZipInputStream(inStream); break; case Compression.Bzip2: inStream = new BZip2InputStream(inStream); break; } archive = TarArchive.CreateInputTarArchive(inStream, this.blockingFactor); } } if (archive != null) // SET ARCHIVE OPTIONS { archive.SetKeepOldFiles(this.keepOldFiles); archive.AsciiTranslate = this.asciiTranslate; archive.SetUserInfo(this.userId, this.userName, this.groupId, this.groupName); } if (archive == null) { Console.Error.WriteLine("no processing due to errors"); } else if (operation == Operation.Create) // WRITING { if (verbose) { archive.ProgressMessageEvent += ShowTarProgressMessage; } for (; argIdx < argv.Length; ++argIdx) { string[] fileNames = GetFilesForSpec(argv[argIdx]); if (fileNames.Length > 0) { foreach (string name in fileNames) { TarEntry entry = TarEntry.CreateEntryFromFile(name); archive.WriteEntry(entry, true); } } else { Console.Error.Write("No files for " + argv[argIdx]); } } } else if (operation == Operation.List) // LISTING { archive.ProgressMessageEvent += ShowTarProgressMessage; archive.ListContents(); } else // EXTRACTING { string userDir = Environment.CurrentDirectory; if (verbose) { archive.ProgressMessageEvent += ShowTarProgressMessage; } if (userDir != null) { archive.ExtractContents(userDir); } } if (archive != null) // CLOSE ARCHIVE { archive.Close(); } }
public static void CreateArchive(IProgressMonitor mon, string folder, string targetFile) { string tf = Path.GetFileNameWithoutExtension(targetFile); if (tf.EndsWith(".tar")) { tf = Path.GetFileNameWithoutExtension(tf); } if (File.Exists(targetFile)) { File.Delete(targetFile); } using (Stream os = File.Create(targetFile)) { Stream outStream = os; // Create the zip file switch (GetArchiveExtension(targetFile)) { case ".tar.gz": outStream = new GZipOutputStream(outStream); goto case ".tar"; case ".tar.bz2": outStream = new BZip2OutputStream(outStream, 9); goto case ".tar"; case ".tar": TarArchive archive = TarArchive.CreateOutputTarArchive(outStream); archive.SetAsciiTranslation(false); archive.RootPath = folder; archive.ProgressMessageEvent += delegate(TarArchive ac, TarEntry e, string message) { if (message != null) { mon.Log.WriteLine(message); } }; foreach (FilePath f in GetFilesRec(new DirectoryInfo(folder))) { TarEntry entry = TarEntry.CreateEntryFromFile(f); entry.Name = f.ToRelative(folder); if (!Platform.IsWindows) { UnixFileInfo fi = new UnixFileInfo(f); entry.TarHeader.Mode = (int)fi.Protection; } else { entry.Name = entry.Name.Replace('\\', '/'); FilePermissions p = FilePermissions.S_IFREG | FilePermissions.S_IROTH | FilePermissions.S_IRGRP | FilePermissions.S_IRUSR; if (!new FileInfo(f).IsReadOnly) { p |= FilePermissions.S_IWUSR; } entry.TarHeader.Mode = (int)p; } archive.WriteEntry(entry, false); } // HACK: GNU tar expects to find a double zero record at the end of the archive. TarArchive only emits one. // This hack generates the second zero block. FieldInfo tarOutField = typeof(TarArchive).GetField("tarOut", BindingFlags.Instance | BindingFlags.NonPublic); if (tarOutField != null) { TarOutputStream tarOut = (TarOutputStream)tarOutField.GetValue(archive); tarOut.Finish(); } archive.CloseArchive(); break; case ".zip": ZipOutputStream zs = new ZipOutputStream(outStream); zs.SetLevel(5); byte[] buffer = new byte [8092]; foreach (FilePath f in GetFilesRec(new DirectoryInfo(folder))) { string name = f.ToRelative(folder); if (Platform.IsWindows) { name = name.Replace('\\', '/'); } ZipEntry infoEntry = new ZipEntry(name); zs.PutNextEntry(infoEntry); using (Stream s = File.OpenRead(f)) { int nr; while ((nr = s.Read(buffer, 0, buffer.Length)) > 0) { zs.Write(buffer, 0, nr); } } } zs.Finish(); zs.Close(); break; default: mon.Log.WriteLine("Unsupported file format: " + Path.GetFileName(targetFile)); return; } } }