public static void ExtractTGZ(String gzArchiveName, String destFolder)
{
var flag = gzArchiveName.Split(Path.DirectorySeparatorChar).Last().Split('.').First() + ".bin";
if (File.Exists(Path.Combine(destFolder, flag)))
{
return;
}
Console.WriteLine($"Extracting.");
var task = Task.Run(() =>
{
using (var inStream = File.OpenRead(gzArchiveName))
{
using (var gzipStream = new GZipInputStream(inStream))
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
tarArchive.ExtractContents(destFolder);
}
}
});
while (!task.IsCompleted)
{
Thread.Sleep(200);
Console.Write(".");
}
File.Create(Path.Combine(destFolder, flag));
Console.WriteLine("");
Console.WriteLine("Extracting is completed.");
}
/// <summary>Downloads the and extract.</summary>
/// <param name="uri"> URI of the resource.</param>
/// <param name="packageName"> Name of the package.</param>
/// <param name="version"> The version.</param>
/// <param name="specDirectory">Pathname of the specifier directory.</param>
/// <returns>True if it succeeds, false if it fails.</returns>
private static bool DownloadAndExtract(
Uri uri,
string packageName,
string version,
string specDirectory)
{
try
{
// build our extraction directory name
string directory = Path.Combine(specDirectory, $"{packageName}-{version}");
// make sure our destination directory exists
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
using (Stream fileStream = _httpClient.GetStreamAsync(uri).Result)
using (Stream gzipStream = new GZipInputStream(fileStream))
using (TarArchive tar = TarArchive.CreateInputTarArchive(gzipStream))
{
// extract
tar.ExtractContents(directory);
}
return(true);
}
catch (Exception ex)
{
Console.WriteLine($"DownloadPublishedPackage <<< failed to download package: {packageName}-{version}: {ex.Message}");
throw;
}
}
internal static List <string> UncompressTgz(string archiveName, string destinationFolder)
{
List <string> extractedFiles = new List <string>();
try
{
Stream inStream = File.OpenRead(archiveName);
Stream gzipStream = new GZipInputStream(inStream);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ProgressMessageEvent += (archive, entry, message) => {
extractedFiles.Add(entry.Name);
};
tarArchive.ExtractContents(destinationFolder);
tarArchive.ListContents();
tarArchive.Close();
gzipStream.Close();
inStream.Close();
}
catch (Exception e)
{
Console.WriteLine("UnTar error: " + e.Message);
}
return(extractedFiles);
}
public void TestMigration()
{
string dir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(dir);
var assembly = Assembly.GetExecutingAssembly();
using (Stream fs = assembly.GetManifestResourceStream("longomatch.tar.gz")) {
using (Stream gzipStream = new GZipInputStream(fs)) {
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream)) {
tarArchive.ExtractContents(dir);
}
}
}
CouchbaseStorageLongoMatch storage = new CouchbaseStorageLongoMatch(dir, "longomatch");
Assert.AreEqual(2, storage.RetrieveAll <Team> ().Count());
Assert.AreEqual(1, storage.RetrieveAll <Dashboard> ().Count());
Assert.AreEqual(1, storage.RetrieveAll <LMProject> ().Count());
Team team = storage.RetrieveAll <Team> ().First();
Assert.DoesNotThrow(team.Load);
Dashboard dashboard = storage.RetrieveAll <Dashboard> ().First();
Assert.DoesNotThrow(dashboard.Load);
LMProject project = storage.RetrieveAll <LMProject> ().First();
Assert.DoesNotThrow(project.Load);
}
void ExtractTar(Stream tarSteam)
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(tarSteam, TarBuffer.DefaultBlockFactor))
{
tarArchive.ExtractContents(LogOutputDirectory);
}
}
/// <summary>
/// Extracts contents of GZipped Tar file to specified directory
/// </summary>
/// <param name="filename">Input .tar.gz file</param>
/// <param name="directory">Output directory</param>
public static void ExtractTarGz(string filename, string directory)
{
using (Stream inStream = File.OpenRead(filename))
using (Stream gzipStream = new GZipInputStream(inStream))
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
tarArchive.ExtractContents(directory);
}
/// <summary>
/// Attempts to untar a tar archive and to copy its content into a folder.
/// If it succeeds, the resulting images are added to the files to be added into the generation.
/// </summary>
/// <param name="path">Path of the tar archive to be checked.</param>
private void CheckTarArchive(string path)
{
try
{
using (FileStream stream = new FileStream(path, FileMode.Open))
{
using (TarArchive tarFile = TarArchive.CreateInputTarArchive(stream))
{
int pathIndex = Data.Files.IndexOf(path);
string tarPath = GenerateArchivePath(path);
tarFile.ExtractContents(tarPath);
List <string> newFiles = new List <string>();
ParseExtractedElements(newFiles, new DirectoryInfo(tarPath));
InsertArchiveFiles(pathIndex, newFiles);
}
}
}
catch
{
tarErrors.Add(path);
Data.Files.Remove(path);
}
}
private static void PreallocDBFiles(string installDir)
{
try
{
Logger.Debug("Stopping DB...");
StopService(StationService.MONGO_SERVICE_NAME);
Logger.Debug("DB is stopped");
string journalDir = Path.Combine(installDir, @"MongoDB\Data\DB\journal");
if (Directory.Exists(journalDir))
{
string[] preallocFiles = Directory.GetFiles(journalDir, "prealloc.*");
if (preallocFiles != null && preallocFiles.Length > 0)
{
return;
}
}
Logger.Debug("Extracting prealloc DB files...");
string preallocZip = Path.Combine(installDir, @"MongoDB\Data\DB\mongoPrealloc.tar.gz");
GZipInputStream gzipIn = new GZipInputStream(File.OpenRead(preallocZip));
using (TarArchive tar = TarArchive.CreateInputTarArchive(gzipIn))
{
tar.ExtractContents(Path.Combine(installDir, @"MongoDB\Data\DB"));
}
Logger.Info("Extract prealloc DB files successfully");
}
catch (Exception e)
{
Logger.Warn("Error during extracting prealloc DB files", e);
}
}
/// <summary>Downloads the and extract.</summary>
/// <param name="uri"> URI of the resource.</param>
/// <param name="packageName"> Name of the package.</param>
/// <param name="version"> The version.</param>
/// <param name="specDirectory">Pathname of the specifier directory.</param>
/// <returns>True if it succeeds, false if it fails.</returns>
private static bool DownloadAndExtract(
Uri uri,
string packageName,
string version,
string specDirectory)
{
Stream fileStream = null;
Stream gzipStream = null;
TarArchive tar = null;
try
{
// build our extraction directory name
string directory = Path.Combine(specDirectory, $"{packageName}-{version}");
// make sure our destination directory exists
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
// start our download as a stream
fileStream = _httpClient.GetStreamAsync(uri).Result;
// extract to the npm directory
gzipStream = new GZipInputStream(fileStream);
// grab the tar archive
tar = TarArchive.CreateInputTarArchive(gzipStream);
// extract
tar.ExtractContents(directory);
return(true);
}
catch (Exception ex)
{
Console.WriteLine($"DownloadPublishedPackage <<< failed to download package: {packageName}-{version}: {ex.Message}");
throw;
}
finally
{
// clean up
if (tar != null)
{
tar.Close();
}
if (gzipStream != null)
{
gzipStream.Close();
}
if (fileStream != null)
{
fileStream.Close();
}
}
}
private async Task <string> DownloadRelease(List <Asset> assets, bool isWindows, string version)
{
Variants variants = new Variants();
string artifactFileName = variants.GetArtifactFileName(variant);
Asset targetAsset = assets.Where(a => a.Browser_download_url.EndsWith(artifactFileName, StringComparison.OrdinalIgnoreCase) && artifactFileName.Length > 0).FirstOrDefault();
if (targetAsset == null)
{
logger.Error("Failed to find asset to download!");
return(null);
}
var url = targetAsset.Browser_download_url;
var data = await client.GetBytes(SetDownloadHeaders(new WebRequest()
{
Url = url, EmulateBrowser = true, Type = RequestType.GET
}));
while (data.IsRedirect)
{
data = await client.GetBytes(new WebRequest()
{
Url = data.RedirectingTo, EmulateBrowser = true, Type = RequestType.GET
});
}
var tempDir = Path.Combine(Path.GetTempPath(), "JackettUpdate-" + version + "-" + DateTime.Now.Ticks);
if (Directory.Exists(tempDir))
{
Directory.Delete(tempDir, true);
}
Directory.CreateDirectory(tempDir);
if (isWindows)
{
var zipPath = Path.Combine(tempDir, "Update.zip");
File.WriteAllBytes(zipPath, data.Content);
var fastZip = new FastZip();
fastZip.ExtractZip(zipPath, tempDir, null);
}
else
{
var gzPath = Path.Combine(tempDir, "Update.tar.gz");
File.WriteAllBytes(gzPath, data.Content);
Stream inStream = File.OpenRead(gzPath);
Stream gzipStream = new GZipInputStream(inStream);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(tempDir);
tarArchive.Close();
gzipStream.Close();
inStream.Close();
}
return(tempDir);
}
public static void Untar(string tarball, string path)
{
using (FileStream inStream = File.OpenRead(tarball))
using (TarArchive tar = TarArchive.CreateInputTarArchive(inStream))
{
tar.ExtractContents(path);
}
}
string ExtractTar(Stream tarSteam)
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(tarSteam, TarBuffer.DefaultBlockFactor))
{
tarArchive.ExtractContents(Environment.ExpandEnvironmentVariables("%TEMP%"));
}
return(File.ReadAllText(Path.Combine(Environment.ExpandEnvironmentVariables("%TEMP%"), "warewolf-server.log")));
}
private static void ExtractToDirectory(string file, string targetDir)
{
using (Stream inStream = File.OpenRead(file))
using (Stream gzipStream = new GZipInputStream(inStream)) {
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(targetDir);
}
}
/// <summary>
/// tar文件解压
/// </summary>
/// <param name="zipPath">压缩文件路径***.tar</param>
/// <param name="goalDir">解压到的目录</param>
/// <param name="encoding">编码</param>
/// <returns></returns>
public bool UnzipTar(string zipPath, string goalDir, string encoding = "utf-8")
{
using Stream inStream = File.OpenRead(zipPath);
using TarArchive tarArchive = TarArchive.CreateInputTarArchive(inStream, Encoding.GetEncoding(encoding));
tarArchive.ExtractContents(goalDir);
return(true);
}
public void InitNewModel(Engine engine)
{
using (Stream fileStream = File.OpenRead(_options.NewModelFile))
using (Stream gzipStream = new GZipInputStream(fileStream))
using (TarArchive archive = TarArchive.CreateInputTarArchive(gzipStream))
{
archive.ExtractContents(engine.ConfigDirectory);
}
}
public void ExtractTar(String tarFileName, String destFolder)
{
Stream inStream = File.OpenRead(tarFileName);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(inStream);
tarArchive.ExtractContents(destFolder);
tarArchive.Close();
inStream.Close();
}
public static void UnTarGZ(FileInfo file)
{
using (Stream stream = File.OpenRead(file.FullName))
using (GZipInputStream gzipStream = new GZipInputStream(stream))
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
{
tarArchive.ExtractContents("/tmp/targztest");
}
}
public static void UnTarGZ(MemoryStream stream)
{
using (GZipInputStream gzipStream = new GZipInputStream(stream))
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
{
gzipStream.IsStreamOwner = false;
tarArchive.ExtractContents("/tmp/targztest");
}
}
public static void Extract(String name)
{
TarArchive ta = TarArchive.CreateInputTarArchive(new
FileStream(@name, FileMode.Open, FileAccess.Read));
ta.ProgressMessageEvent += MyNotifier;
ta.ExtractContents(@".");
ta.Close();
}
private static void ExtractTGZ(string gzArchiveName, string destFolder)
{
using (Stream inStream = File.OpenRead(gzArchiveName))
using (Stream bzip2Stream = new BZip2InputStream(inStream))
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(bzip2Stream))
{
tarArchive.ExtractContents(destFolder);
}
}
public static void DecompressZip(FileInfo fileToDecompress)
{
using (Stream targetStream = new GZipInputStream(File.OpenRead(fileToDecompress.FullName)))
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(targetStream, TarBuffer.DefaultBlockFactor))
{
tarArchive.ExtractContents(@"C:\");
}
}
}
/// <summary>
/// Unpack the archive
/// </summary>
public static Task ExtractAsync(Stream source, string targetDirectory)
{
using (var gzipStream = new GZipStream(source, CompressionMode.Decompress))
using (TarArchive archive = TarArchive.CreateInputTarArchive(gzipStream))
{
archive.ExtractContents(targetDirectory);
}
return(Task.CompletedTask);
}
/// <summary>
/// Unpacks the different upgrade packages contained inside the downloaded file.
///
/// Each upgrade of Stoffi is to be packaged inside a file called N.tar.bz2 (where N
/// is the version number) file containing the following:
/// 1) All files that should be copied to the program folder
/// 2) Optional: "Settings Migrator.dll", this will be used later to migrate the settings in SettingsManager
///
/// The method will call Propare() on each version as they are decompressed and unpacked, this will copy the files to a
/// folder called "Queue". From here the content will be copied to the program folder at Finish().
/// </summary>
public static void Unpack()
{
string folder = downloadFilename + "_tmp/packages/";
U.L(LogLevel.Debug, "UPGRADE", "Unpack versions");
DirectoryInfo folderInfo = new DirectoryInfo(baseFolder + "/" + upgradeFolder + folder);
FileInfo[] files = folderInfo.GetFiles("*.tar.bz2", SearchOption.AllDirectories);
List <int> versions = new List <int>();
if (!Directory.Exists(baseFolder + "/" + upgradeFolder + "Queue"))
{
Directory.CreateDirectory(baseFolder + "/" + upgradeFolder + "Queue");
}
// check each file inside the folder and add the version number to our list
foreach (FileInfo file in files)
{
U.L(LogLevel.Debug, "UPGRADE", "Version file @ " + file.FullName);
versions.Add(Convert.ToInt32(file.Name.Substring(0, file.Name.Length - 8)));
}
versions.Sort();
foreach (int version in versions)
{
DispatchProgressChanged(0, new ProgressState(U.T("UpgradeProcessing"), true));
U.L(LogLevel.Debug, "UPGRADE", "Processing version " + version.ToString());
String bz2File = baseFolder + "/" + upgradeFolder + folder + SettingsManager.Channel + "/" + SettingsManager.Architecture + "/" + version.ToString() + ".tar.bz2";
String tarFile = baseFolder + "/" + upgradeFolder + folder + SettingsManager.Channel + "/" + SettingsManager.Architecture + "/" + version.ToString() + ".tar";
String tmpFold = baseFolder + "/" + upgradeFolder + folder + SettingsManager.Channel + "/" + SettingsManager.Architecture + "/" + version.ToString() + "_tmp/";
U.L(LogLevel.Debug, "UPGRADE", "Decompressing");
BZip2.Decompress(File.OpenRead(bz2File), File.Create(tarFile), true);
Stream inStream = File.OpenRead(tarFile);
TarArchive archive = TarArchive.CreateInputTarArchive(inStream, TarBuffer.DefaultBlockFactor);
Directory.CreateDirectory(tmpFold);
archive.ExtractContents(tmpFold);
archive.Close();
inStream.Close();
if (File.Exists(Path.Combine(tmpFold, "Settings Migrator.dll")))
{
File.Move(Path.Combine(tmpFold, "Settings Migrator.dll"), Path.Combine(tmpFold, String.Format("Migrator.{0}.dll", version.ToString())));
}
U.L(LogLevel.Debug, "UPGRADE", "Prepare version " + version.ToString());
Prepare(tmpFold, baseFolder + "/" + upgradeFolder + "Queue/");
pendingUpgradeVersion = version;
}
DispatchUpgraded();
U.L(LogLevel.Debug, "UPGRADE", "Upgrade completed");
}
/// <summary>
/// https://github.com/icsharpcode/SharpZipLib
/// </summary>
/// <param name="tarFile"></param>
/// <param name="outDir"></param>
/// <returns></returns>
static void Extract(string tarFile, string outDir)
{
using (Stream inStream = File.OpenRead(tarFile))
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(inStream))
{
tarArchive.ExtractContents(outDir);
tarArchive.Close();
}
inStream.Close();
}
}
public static void Restore(string archive, string password, string directory, string pattern = "*")
{
using (Stream stream = File.OpenRead(archive))
{
using (CryptoStream cryptoStream = Cipher.Decrypt(stream, password))
using (BZip2InputStream bzip2 = new BZip2InputStream(cryptoStream))
using (TarArchive tar = TarArchive.CreateInputTarArchive(bzip2))
{
tar.ExtractContents(directory);
}
}
}
private void UnPackJRE(string name, string path)
{
Stream inStream = File.OpenRead(Path.GetTempPath() + name);
Stream gzipStream = new GZipInputStream(inStream);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(path);
tarArchive.Close();
gzipStream.Close();
inStream.Close();
}
protected void Deneme(object o, EventArgs args)
{
string zipPath = ((FileChooserButton)o).Filename;
extractPath = ((FileChooserButton)o).Filename;
//((FileChooserButton)o).CurrentFolderUri.Substring(7);
try
{
if (zipPath.EndsWith(".zip"))
{
//Stream inStream = File.OpenRead(zipPath);
//Stream zipStream = new ZipInputStream(inStream);
//extractPath = extractPath.Replace(".zip", "");
FastZip fastZip = new FastZip();
extractPath = extractPath.Replace(".zip", "");
fastZip.ExtractZip(zipPath, "/home/gurko32/ZipDenemeleri/WTF", null);
SetPageComplete(GetNthPage(CurrentPage), true);
}
else if (zipPath.EndsWith(".tar.gz"))
{
Stream inStream = File.OpenRead(zipPath);
Stream gzipStream = new GZipInputStream(inStream);
extractPath = extractPath.Replace(".tar.gz", "");
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(extractPath);
tarArchive.Close();
inStream.Close();
SetPageComplete(GetNthPage(CurrentPage), true);
}
else
{
Console.WriteLine("Unsupported File Type");
SetPageComplete(GetNthPage(CurrentPage), false);
}
}
catch (Exception ex)
{
Console.WriteLine("HATA VAR " + ex);
}
}
private void ExtractGZipSample(string gzipFileName, string targetDir)
{
using (Stream inStream = File.OpenRead(gzipFileName))
{
using (var gzipStream = new GZipInputStream(inStream))
{
using (TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream))
{
tarArchive.ExtractContents(targetDir);
}
}
}
}
private void ExtractTGZ(String gzArchiveName, String destFolder)
{
Stream inStream = File.OpenRead(gzArchiveName);
Stream gzipStream = new GZipInputStream(inStream);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(destFolder);
tarArchive.Close();
gzipStream.Close();
inStream.Close();
}
public static void Unpack(string gzArchiveName, string destFolder)
{
Stream inStream = File.OpenRead(gzArchiveName);
Stream gzipStream = new GZipInputStream(inStream);
TarArchive tarArchive = TarArchive.CreateInputTarArchive(gzipStream);
tarArchive.ExtractContents(destFolder);
tarArchive.Close();
gzipStream.Close();
inStream.Close();
}
