public static void CreateDemoRequiredFiles()
{
BackupFiles objBackupFiles;
BackupFile objBackupFile;
FilesToBackup objFilesToBackup;
FileToBackUp objFileToBackup;
SingleFileToBackUp objSingleFileToBackup;
//Procedure for reading file from tape; Backup files must have a Size, NewFileName, FilePath and StartTapeLocation to be restored
objBackupFiles = new BackupFiles();
objBackupFile = new BackupFile { StartTapeLocation = 0, EndTapeLocation = 84673, FilePath = Directory.GetCurrentDirectory() + "\\", FileName = "Test1.txt", Size = 5549095658 };
objBackupFiles.Add(objBackupFile);
objBackupFile = new BackupFile { StartTapeLocation = 84673, EndTapeLocation = 84990, FilePath = Directory.GetCurrentDirectory() + "\\", FileName = "Test2.txt", Size = 20764304 };
objBackupFiles.Add(objBackupFile);
objBackupFiles.SaveToXMLFile(Directory.GetCurrentDirectory() + "\\", "BackedUpFilesExample.xml");
//Backup files must have a FilePath and FileName in order to be written to the tape; StartTapeLocation is required when writing a single file,
//otherwise the app assigns locations as it's backing up multiple files
objFilesToBackup = new FilesToBackup();
objFileToBackup = new FileToBackUp { FilePath = Directory.GetCurrentDirectory() + "\\", FileName = "Test1.txt" };
objFilesToBackup.Add(objFileToBackup);
objFileToBackup = new FileToBackUp { FilePath = Directory.GetCurrentDirectory() + "\\", FileName = "Test2.txt" };
objFilesToBackup.Add(objFileToBackup);
objFilesToBackup.SaveToXMLFile(Directory.GetCurrentDirectory() + "\\", "FilesToBackupExample.xml");
objSingleFileToBackup = new SingleFileToBackUp { StartTapeLocation = 84673, FilePath = Directory.GetCurrentDirectory() + "\\", FileName = "Test2.txt" };
objSingleFileToBackup.Serialize(Directory.GetCurrentDirectory() + "\\FileToBackupExample.xml");
}
/// <summary>
/// Gets the <see cref="BackupFile" /> information for the specified game id, file name and install path
/// </summary>
/// <param name="gameId">Game Id</param>
/// <param name="fileName">File Name</param>
/// <param name="installPath">File Install Path</param>
/// <returns></returns>
public BackupFile GetGameFileBackup(string gameId, string fileName, string installPath)
{
return(BackupFiles.FirstOrDefault(backupFile =>
backupFile.CategoryId.Equals(gameId, StringComparison.OrdinalIgnoreCase) &&
backupFile.FileName.ToLower().Contains(fileName.ToLower()) &&
backupFile.InstallPath.ToLower().Contains(installPath.ToLower())));
}
/// <summary>
/// 初始读取文件并备份
/// </summary>
public void DefaultBackupFile(string path)
{
//读取本地文件夹中的所有文件列表
List <string> files = FileTool.GetAllFile(path);
if (ListTool.HasElements(files))
{
foreach (var file in files)
{
try
{
string lastwritetime = DateTimeConvert.StandardString(File.GetLastWriteTime(file));
using (var db = new Muse())
{
BackupFiles backfile = db.Get <BackupFiles>(x => x.FullPath == file && x.LastWriteTime == lastwritetime, null);
if (backfile == null)
{
AddToBackupFiles(file);
}
}
}
catch (Exception e) { }
}
}
}
static async Task Main(string[] args)
{
HttpClient client = new HttpClient();
client.BaseAddress = new Uri("http://*****:*****@"C:\backup\From";
IBackup backup = new Full(files);
while (true)
{
Console.Clear();
string temp = Console.ReadLine();
if (temp == "backup")
{
backup.Backup();
}
}
}
private void revertToolStripMenuItem_Click(object sender, EventArgs e)
{
var data = PatchData.Create(BuildSettings.Instance);
data.GameFolder = BuildSettings.Instance.GameFolders.FirstOrDefault();
data.Init();
if (BuildSettings.Instance.AutoClose)
{
var isDedicatedServer = data.IsDedicatedServer;
var exe = isDedicatedServer ? "7DaysToDieServer" : "7DaysToDie";
Helper.KillProcessByName(exe);
}
var p = new ReaderParameters();
p.InMemory = true;
var ass = AssemblyDefinition.ReadAssembly(data.GameDllLocation, p);
var module = ass.MainModule;
BackupFiles.GetVersionInfo(module);
data.BackupFolder = data.BackupFolder + (data.IsDedicatedServer ? "Dedi/" : "SP/") + BuildSettings.MajorVersion + "." + BuildSettings.MinorVersion + "b" + BuildSettings.BuildNumber + "/";
data.BackupDllLocataion = data.BackupFolder + PatchData.AssemblyFilename;
if (File.Exists(data.BackupDllLocataion))
{
File.Copy(data.BackupDllLocataion, data.GameDllLocation, true);
OnLog($"Dll reverted {data.BackupDllLocataion}", LogType.Info);
}
else
{
OnLog("Could not revert DLL", LogType.Info);
}
}
/// <summary>
/// Updates the collection of backup files at index if it's exists, otherwise adds a new one.
/// </summary>
/// <param name="index"></param>
/// <param name="backupFile"></param>
public void UpdateBackupFile(int index, BackupFile backupFile)
{
if (BackupFiles[index] == null)
{
BackupFiles.Add(backupFile);
return;
}
BackupFiles[index] = backupFile;
}
private void BtRestoreToNew_Click(object sender, EventArgs e)
{
if (DgvFiles.CurrentRow != null && DgvFiles.CurrentRow.Index >= 0)
{
BackupFiles file = Files[DgvFiles.CurrentRow.Index];
SaveFileDialog sfd = new SaveFileDialog();
sfd.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop); //设置默认目录
sfd.FileName = Path.GetFileName(file.FullPath); //设置默认文件名
sfd.Filter = "还原文件|*" + Path.GetExtension(file.FullPath); //设置默认文件类型
if (sfd.ShowDialog() == DialogResult.OK)
{
string from = file.BackupFullPath;
string to = sfd.FileName;
File.Copy(from, to, true);
}
}
}
/// <summary>
/// Create/store a backup of the specified file, and then downloads it locally to a known path
/// </summary>
/// <param name="modItem"></param>
/// <param name="fileName"></param>
/// <param name="installFilePath"></param>
public void CreateBackupFile(ModItem modItem, string fileName, string installFilePath)
{
var fileBackupFolder = GetGameBackupFolder(modItem);
_ = Directory.CreateDirectory(fileBackupFolder);
var backupFile = new BackupFile
{
CategoryId = modItem.GameId,
FileName = fileName,
LocalPath = Path.Combine(fileBackupFolder, fileName),
InstallPath = installFilePath
};
FtpExtensions.DownloadFile(backupFile.LocalPath, backupFile.InstallPath);
BackupFiles.Add(backupFile);
}
private FileEntry ConsoleGetFileEntry(string fileName)
{
var possibleFiles = BackupFiles.Where(entry =>
{
var name = Path.GetFileNameWithoutExtension(fileName);
var ext = Path.GetExtension(fileName);
var pattern = name + @"(_[0-9]+)?";
if (!string.IsNullOrEmpty(ext))
{
pattern += '\\' + ext; // must escape .
}
return(Regex.IsMatch(entry.Key, pattern));
}).ToList();
if (possibleFiles.Count == 0)
{
Console.WriteLine("File not found.");
return(null);
}
while (possibleFiles.Count > 1)
{
Console.WriteLine("Which file do you want?");
foreach (var possibleFile in possibleFiles)
{
Console.WriteLine("- {0}", possibleFile.Key);
}
var chosenFile = Console.ReadLine();
if (string.IsNullOrWhiteSpace(chosenFile))
{
return(null);
}
possibleFiles.RemoveAll(entry => entry.Key != chosenFile);
if (possibleFiles.Count == 1)
{
break;
}
}
return(possibleFiles[0].Value);
}
private void DoDeleteBackup(object param)
{
if (CanDeleteBackup(null))
{
BackupFileViewModel bf = BackupFiles.LastSelected;
Logger.Info("DoDeleteBackup: Executing BackupFile.DeleteCommand");
bf.DeleteCommand.Execute(null);
if (bf.IsDeleted)
{
Logger.Info("DoDeleteBackup: Removing item from list");
BackupFiles.Remove(BackupFiles.LastSelected);
OnPropertyChanged("BackupFiles");
}
else
{
Logger.Info("DoDeleteBackup: BackupFile is not deleted, keeping in list");
}
}
}
private void DoDeleteAllBackups(ViewModelMessageContent messageContent)
{
if (messageContent.Confirmed)
{
Logger.Info("DoDeleteAllBackups: Iterating over {0} BackupFiles", BackupFiles.Count);
foreach (BackupFileViewModel vm in BackupFiles)
{
vm.DeleteCommand.Execute(null);
vm.IsSelected = vm.IsDeleted;
}
Logger.Info("DoDeleteAllBackups: Purging list");
BackupFiles.RemoveSelected();
Logger.Info("DoDeleteAllBackups: {0} BackupFiles remaining", BackupFiles.Count);
OnPropertyChanged("HasBackups");
}
else
{
Logger.Info("DoDeleteAllBackups: Action was not confirmed, not deleting backups");
}
}
private void BtRestoreToOld_Click(object sender, EventArgs e)
{
if (DgvFiles.CurrentRow != null && DgvFiles.CurrentRow.Index >= 0)
{
BackupFiles file = Files[DgvFiles.CurrentRow.Index];
string title = string.Format("文件还原", file.LastWriteTime);
string text = string.Format("您确定将文件：{0} [ {1} ]{2}还原到：{2}{3} 吗？", Path.GetFileName(file.FullPath), file.LastWriteTime, Environment.NewLine, file.FullPath);
if (MessageBox.Show(text, title, MessageBoxButtons.OKCancel) == DialogResult.OK)
{
string from = file.BackupFullPath;
string to = file.FullPath;
string topath = DirTool.GetFilePath(to);
if (DirTool.Create(topath))
{
File.Copy(from, to, true);
}
else
{
MessageBox.Show(string.Format("路径：{0} 不存在，请还原到其他路径。", topath), "路径不存在");
}
}
}
}
public FileEntry AddBackupFile(string fileName /* C:/Windows/write.exe */, int replicationDegree)
{
if (string.IsNullOrWhiteSpace(fileName))
{
throw new ArgumentNullException("fileName");
}
if (!File.Exists(fileName))
{
return(null);
}
// get a unique filename from the original file path
// if the new filename already exists, append a number to it
var fileNameWithoutPath = Path.GetFileName(fileName); /* write.exe */
var newFileName = fileNameWithoutPath;
var count = 1;
while (BackupFiles.ContainsKey(newFileName))
{
var ext = Path.GetExtension(newFileName);
var name = Path.GetFileNameWithoutExtension(newFileName);
newFileName = name + '_' + count + ext;
count++;
}
var fileEntry = new FileEntry
{
FileName = newFileName,
OriginalFileName = fileName,
ReplicationDegree = replicationDegree
};
BackupFiles.Add(newFileName, fileEntry);
return(fileEntry);
}
private static void BackupFiles(string strFilesToBackupFilePathAndName)
{
FilesToBackup objFilesToBackup;
try
{
using (StreamWriter w = File.CreateText("log.txt"))
{
Log(string.Format("Backup Operation Started at {0}", DateTime.Now), w);
// Close the writer and underlying file.
w.Close();
}
objFilesToBackup = new FilesToBackup(Path.GetDirectoryName(strFilesToBackupFilePathAndName) + "\\", Path.GetFileName(strFilesToBackupFilePathAndName));
BackupFileList = objFilesToBackup.ToBackupFiles();
Backup.WriteFilesToTape(BackupFileList);
BackupFileList.SaveToXMLFile(Directory.GetCurrentDirectory() + "\\", "BackedUpFiles.xml");
using (StreamWriter w = File.AppendText("log.txt"))
{
Log(string.Format("Backup Operation Ended at {0}", DateTime.Now), w);
// Close the writer and underlying file.
w.Close();
}
}
catch (Exception objEx)
{
using (StreamWriter w = File.AppendText("log.txt"))
{
Log(string.Format("Error {0}", objEx.ToString()), w);
// Close the writer and underlying file.
w.Close();
}
}
}
private static void BackupFile(string filename)
{
if (File.Exists(filename) == false)
{
return;
}
if (backupFiles.Exists(x => x.filename.Equals(filename, System.StringComparison.OrdinalIgnoreCase)))
{
return;
}
var backup = new BackupFiles();
backup.filename = filename;
try
{
backup.data = File.ReadAllBytes(filename);
backupFiles.Add(backup);
}
catch (System.Exception e)
{
Debug.LogError("Can't open file " + filename + "\n" + e.Message);
}
}
private void RefreshFilesList()
{
var selectedValue = BackupFiles.SelectedValue;
if (Directory.Exists(ApplySecurityRunner.BackupFolder))
{
var files = Directory
.GetFiles(ApplySecurityRunner.BackupFolder, "*.xml", SearchOption.TopDirectoryOnly)
.Select(x => new KeyValuePair <string, string>(x, Path.GetFileNameWithoutExtension(x)));
if (files.Any())
{
BackupFiles.DataSource = files;
}
}
BackupFiles.DataSource = BackupFiles.DataSource
?? new[] { new KeyValuePair <string, string>("", "No backup files found.") };
if (!string.IsNullOrWhiteSpace(selectedValue))
{
BackupFiles.SelectedValue = selectedValue;
}
BackupFiles.DataBind();
}
public void ReadFileFromTape(BackupFile objBackupFile)
{
BackupFiles objBackupFiles;
objBackupFiles = new BackupFiles();
objBackupFiles.Add(objBackupFile);
ReadFilesFromTape(objBackupFiles);
}
//public void WriteFileToTape(BackupFile objBackupFile)
//{
// TapeOperator objTapeOperator;
// TapeOperator.MediaInfo objMediaInfo;
// FileStream objFileStreamToWrite;
// byte[] objWriteBytes;
// Console.WriteLine("WriteFileToTape Method");
// Console.WriteLine("Initializing the tape drive...");
// objTapeOperator = new TapeOperator();
// objTapeOperator.Load(TapeName);
// Console.WriteLine("Setting Tape Position...");
// objTapeOperator.SetTapePosition(objBackupFile.StartTapeLocation);
// Console.WriteLine("Tape Position is " + objTapeOperator.GetTapePosition());
// //for some reason, I kept getting an error until I added the below statements
// Console.WriteLine("Getting the Tape Info...");
// objMediaInfo = objTapeOperator.GetTapeMediaParameters();
// //Console.WriteLine(objMediaInfo.BlockSize);
// //Console.WriteLine(objTapeOperator.BlockSize);
// Console.WriteLine("Opening the file...");
// objFileStreamToWrite = new FileStream(objBackupFile.FileNameAndPath, FileMode.Open, FileAccess.Read);
// objBackupFile.Size = objFileStreamToWrite.Length;
// //This code is where modification will be required to accomodate consecutive reads and writes to the tape for large file sizes
// if (objBackupFile.isLargeFile)
// {
// Console.WriteLine("This file will take " + objBackupFile.FileChunkCount + " Passes...");
// for (int intCounter = 1; intCounter <= objBackupFile.FileChunkCount; intCounter++)
// {
// if (intCounter < objBackupFile.FileChunkCount)
// {
// Console.WriteLine("This is pass " + intCounter);
// //Console.WriteLine("Initilizing Array");
// objWriteBytes = new byte[BackupFile.MaxMemoryChunk];
// //Console.WriteLine("Done Initilizing Array");
// Console.WriteLine("Reading file to Memory...");
// //Console.WriteLine(objFileStreamToWrite.Position);
// //lngPosition = objFileStreamToWrite.Position;
// objFileStreamToWrite.Read(objWriteBytes, 0, BackupFile.MaxMemoryChunk);
// //Console.WriteLine(objTapeOperator.GetTapePosition());
// Console.WriteLine("Writing Filestream to Tape");
// objTapeOperator.Write(objTapeOperator.GetTapePosition(), objWriteBytes);
// //Console.WriteLine("Finished Writing to Tape");
// //Console.WriteLine(objTapeOperator.GetTapePosition());
// }
// else
// {
// int intLeftOverBytes = (int)(objBackupFile.Size - BackupFile.MaxMemoryChunk * (intCounter - 1));
// Console.WriteLine("This is pass " + intCounter);
// //Console.WriteLine("Initilizing Array");
// objWriteBytes = new byte[intLeftOverBytes];
// //Console.WriteLine("Done Initilizing Array");
// Console.WriteLine("Reading file to Memory...");
// //lngPosition = objFileStreamToWrite.Position;
// objFileStreamToWrite.Read(objWriteBytes, 0, intLeftOverBytes);
// Console.WriteLine("Writing Filestream to Tape");
// objTapeOperator.Write(objTapeOperator.GetTapePosition(), objWriteBytes);
// //Console.WriteLine("Finished Writing to Tape");
// }
// }
// }
// else
// {
// //Console.WriteLine("Initilizing Array");
// objWriteBytes = new byte[objFileStreamToWrite.Length];//This one generates an IOException if the file size is greater than 2GB
// //Console.WriteLine("Done Initilizing Array");
// Console.WriteLine("Reading file to Memory...");
// objFileStreamToWrite.Read(objWriteBytes, 0, (int)objFileStreamToWrite.Length);
// Console.WriteLine("Writing Filestream to Tape");
// objTapeOperator.Write(objBackupFile.StartTapeLocation, objWriteBytes);
// Console.WriteLine("Finished Writing to Tape");
// }
// objBackupFile.EndTapeLocation = objTapeOperator.GetTapePosition();
// Console.WriteLine("Tape Position is " + objBackupFile.EndTapeLocation);
// Console.WriteLine("Now I'm Cleaning up resources...");
// objTapeOperator.Close();
// objFileStreamToWrite.Close();
// Console.WriteLine("Now I'm Done!");
// Console.WriteLine();
//}
public void WriteFilesToTape(BackupFiles objBackupFiles, bool isSingleFile = false)
{
Console.WriteLine("WriteFileToTape Method");
Console.WriteLine("Initializing the tape drive...");
TapeOperator = new TapeOperator();
TapeOperator.Load(TapeName);
Console.WriteLine("Setting Tape Position...");
//If it's a single file than I use the tape location specified on the BackupFile object, else I parse the collection for the next available location
TapeOperator.SetTapePosition(isSingleFile ? objBackupFiles[0].StartTapeLocation : objBackupFiles.NextAvailableTapeLocation);
Console.WriteLine("Tape Position is " + TapeOperator.GetTapePosition());
//for some reason, I kept getting an error until I added the below statements
Console.WriteLine("Getting the Tape Info...");
MediaInfo = TapeOperator.GetTapeMediaParameters();
//Console.WriteLine(objMediaInfo.BlockSize);
//Console.WriteLine(objTapeOperator.BlockSize);
foreach (BackupFile objBackupFile in objBackupFiles)
{
Console.WriteLine("Opening the file...");
FileStreamToWrite = new FileStream(objBackupFile.FileNameAndPath, FileMode.Open, FileAccess.Read);
objBackupFile.Size = FileStreamToWrite.Length;
objBackupFile.StartTapeLocation = TapeOperator.GetTapePosition();
//This code is where modification will be required to accomodate consecutive reads and writes to the tape for large file sizes
if (objBackupFile.isLargeFile)
{
Console.WriteLine("This file will take " + objBackupFile.FileChunkCount + " Passes...");
for (int intCounter = 1; intCounter <= objBackupFile.FileChunkCount; intCounter++)
{
if (intCounter < objBackupFile.FileChunkCount)
{
WriteBytes = null;//clears the memory...
GC.Collect();
Console.WriteLine("This is pass " + intCounter);
//Console.WriteLine("Initilizing Array");
WriteBytes = new byte[BackupFile.MaxMemoryChunk];
//Console.WriteLine("Done Initilizing Array");
Console.WriteLine("Reading file to Memory...");
//Console.WriteLine(objFileStreamToWrite.Position);
//lngPosition = objFileStreamToWrite.Position;
FileStreamToWrite.Read(WriteBytes, 0, BackupFile.MaxMemoryChunk);
//Console.WriteLine(objTapeOperator.GetTapePosition());
Console.WriteLine("Writing Filestream to Tape");
TapeOperator.Write(TapeOperator.GetTapePosition(), WriteBytes);
//Console.WriteLine("Finished Writing to Tape");
//Console.WriteLine(objTapeOperator.GetTapePosition());
}
else
{
int intLeftOverBytes = (int)(objBackupFile.Size - BackupFile.MaxMemoryChunk * (intCounter - 1));
WriteBytes = null;//clears the memory...
GC.Collect();
Console.WriteLine("This is pass " + intCounter);
//Console.WriteLine("Initilizing Array");
WriteBytes = new byte[intLeftOverBytes];
//Console.WriteLine("Done Initilizing Array");
Console.WriteLine("Reading file to Memory...");
//lngPosition = objFileStreamToWrite.Position;
FileStreamToWrite.Read(WriteBytes, 0, intLeftOverBytes);
Console.WriteLine("Writing Filestream to Tape");
TapeOperator.Write(TapeOperator.GetTapePosition(), WriteBytes);
//Console.WriteLine("Finished Writing to Tape");
}
}
}
else
{
WriteBytes = null;//clears the memory...
GC.Collect();
//Console.WriteLine("Initilizing Array");
WriteBytes = new byte[FileStreamToWrite.Length];//This one generates an IOException if the file size is greater than 2GB
//Console.WriteLine("Done Initilizing Array");
Console.WriteLine("Reading file to Memory...");
FileStreamToWrite.Read(WriteBytes, 0, (int)FileStreamToWrite.Length);
Console.WriteLine("Writing Filestream to Tape");
//TapeOperator.Write(objBackupFile.StartTapeLocation, WriteBytes);
TapeOperator.Write(isSingleFile ? objBackupFile.StartTapeLocation : objBackupFiles.NextAvailableTapeLocation, WriteBytes);
//Console.WriteLine("Finished Writing to Tape");
}
objBackupFile.EndTapeLocation = TapeOperator.GetTapePosition();
Console.WriteLine("Tape Position is " + objBackupFile.EndTapeLocation);
}
Console.WriteLine("Now I'm Cleaning up resources...");
TapeOperator.Close();
FileStreamToWrite.Close();
Console.WriteLine("Now I'm Done!");
Console.WriteLine();
}
public void WriteFileToTape(BackupFile objBackupFile)
{
BackupFiles objBackupFiles = new BackupFiles();
objBackupFiles.Add(objBackupFile);
WriteFilesToTape(objBackupFiles, true);
}
private static void RestoreFiles(string strFilesToRestoreFilePathAndName)
{
BackupFileList = new BackupFiles();
try
{
using (StreamWriter w = File.CreateText("log.txt"))
{
Log(string.Format("Restore Operation Started at {0}", DateTime.Now), w);
// Close the writer and underlying file.
w.Close();
}
BackupFileList = new BackupFiles(Path.GetDirectoryName(strFilesToRestoreFilePathAndName) + "\\", Path.GetFileName(strFilesToRestoreFilePathAndName));
//Checks to make sure you have set a default ouput directory for the backupfiles to use.
if (string.IsNullOrEmpty(BackupFile.DefaultOutPutDirectory) || !Directory.Exists(BackupFile.DefaultOutPutDirectory))
throw new DirectoryNotFoundException("Your Output Directory is invalid; use \"C:\\Temp\\\"");
Backup.ReadFilesFromTape(BackupFileList);
//BackupFileList.SaveToXMLFile(Directory.GetCurrentDirectory() + "\\", "BackedUpFiles.xml");
using (StreamWriter w = File.AppendText("log.txt"))
{
Log(string.Format("Restore Operation Ended at {0}", DateTime.Now), w);
// Close the writer and underlying file.
w.Close();
}
}
catch (Exception objEx)
{
using (StreamWriter w = File.AppendText("log.txt"))
{
Log(string.Format("Error {0}", objEx.ToString()), w);
// Close the writer and underlying file.
w.Close();
}
}
}
private static void BackupSingleFile(string strFileToBackupFilePathAndName)
{
SingleFileToBackUp objSingleFileToBackup;
//BackupFiles objBackupFiles;
BackupFile objBackupFile;
try
{
using (StreamWriter w = File.CreateText("log.txt"))
{
Log(string.Format("Backup Operation Started at {0}", DateTime.Now), w);
// Close the writer and underlying file.
w.Close();
}
BackupFileList = new BackupFiles();
objSingleFileToBackup = SingleFileToBackUp.DeSerialize(strFileToBackupFilePathAndName);
objBackupFile = new BackupFile { FileName = objSingleFileToBackup.FileName, FilePath = objSingleFileToBackup.FilePath, StartTapeLocation = objSingleFileToBackup.StartTapeLocation };
Backup.WriteFileToTape(objBackupFile);
BackupFileList.Add(objBackupFile);
BackupFileList.SaveToXMLFile(Directory.GetCurrentDirectory() + "\\", "BackedUpFile.xml");
using (StreamWriter w = File.AppendText("log.txt"))
{
Log(string.Format("Backup Operation Ended at {0}", DateTime.Now), w);
// Close the writer and underlying file.
w.Close();
}
}
catch (Exception objEx)
{
using (StreamWriter w = File.AppendText("log.txt"))
{
Log(string.Format("Error {0}", objEx.ToString()), w);
// Close the writer and underlying file.
w.Close();
}
}
}
//public void ReadFileFromTape(BackupFile objBackupFile)
//{
// TapeOperator objTapeOperator;
// FileStream objFileStream;
// byte[] objReadBytes;
// Console.WriteLine("ReadFileFromTape Method");
// Console.WriteLine("Initializing the tape drive...");
// objTapeOperator = new TapeOperator();
// objTapeOperator.Load(TapeName);
// Console.WriteLine("I'm Setting the tape position...");
// objTapeOperator.SetTapePosition(objBackupFile.StartTapeLocation);
// Console.WriteLine("Tape Position is " + objTapeOperator.GetTapePosition());
// Console.WriteLine("Creating the file on disk...");
// objFileStream = new FileStream(objBackupFile.NewFileNameAndPath, FileMode.OpenOrCreate, FileAccess.Write);
// if (objBackupFile.isLargeFile)
// {
// Console.WriteLine("This file will take " + objBackupFile.FileChunkCount + " Passes to read...");
// for (int intCounter = 1; intCounter <= objBackupFile.FileChunkCount; intCounter++)
// {
// if (intCounter < objBackupFile.FileChunkCount)
// {
// Console.WriteLine("This is pass " + intCounter);
// Console.WriteLine("Now I'm Reading file from tape into memory...");
// objReadBytes = objTapeOperator.Read(objTapeOperator.GetTapePosition(), BackupFile.MaxMemoryChunk);
// //objReadBytes = objTapeOperator.Read(objBackupFile.StartTapeLocation * intCounter, BackUpFile.MaxMemoryChunk);
// Console.WriteLine("Now I'm Writing file to disk...");
// objFileStream.Write(objReadBytes, 0, objReadBytes.Length);
// }
// else
// {
// Console.WriteLine("This is pass " + intCounter);
// Console.WriteLine("Now I'm Reading file from tape into memory...");
// objReadBytes = objTapeOperator.Read(objTapeOperator.GetTapePosition(), (int)(objBackupFile.Size - BackupFile.MaxMemoryChunk * (intCounter - 1)));
// Console.WriteLine("Now I'm Writing file to disk...");
// objFileStream.Write(objReadBytes, 0, objReadBytes.Length);
// }
// }
// }
// else
// {
// Console.WriteLine("Now I'm Reading file from tape into memory...");
// objReadBytes = objTapeOperator.Read(objBackupFile.StartTapeLocation, objBackupFile.Size);
// Console.WriteLine("Now I'm Writing file to disk...");
// objFileStream.Write(objReadBytes, 0, objReadBytes.Length);
// }
// Console.WriteLine("Tape Position is " + objTapeOperator.GetTapePosition());
// Console.WriteLine("Now I'm Cleaning up resources...");
// objFileStream.Close();
// objTapeOperator.Close();
// Console.WriteLine("Now I'm Done!");
// Console.WriteLine();
//}
public void ReadFilesFromTape(BackupFiles objBackupFiles)
{
Console.WriteLine("ReadFilesFromTape Method");
Console.WriteLine("Initializing the tape drive...");
TapeOperator = new TapeOperator();
TapeOperator.Load(TapeName);
foreach (BackupFile objBackupFile in objBackupFiles)
{
Console.WriteLine("I'm Setting the tape position...");
TapeOperator.SetTapePosition(objBackupFile.StartTapeLocation);
Console.WriteLine("Tape Position is " + TapeOperator.GetTapePosition());
Console.WriteLine("Creating the file on disk...");
FileStreamToWrite = new FileStream(objBackupFile.NewFileNameAndPath, FileMode.OpenOrCreate, FileAccess.Write);
if (objBackupFile.isLargeFile)
{
Console.WriteLine("This file will take " + objBackupFile.FileChunkCount + " Passes to read...");
for (int intCounter = 1; intCounter <= objBackupFile.FileChunkCount; intCounter++)
{
if (intCounter < objBackupFile.FileChunkCount)
{
ReadBytes = null;//clears the memory...
GC.Collect();
Console.WriteLine("This is pass " + intCounter);
Console.WriteLine("Now I'm Reading file from tape into memory...");
ReadBytes = TapeOperator.Read(TapeOperator.GetTapePosition(), BackupFile.MaxMemoryChunk);
//objReadBytes = objTapeOperator.Read(objBackupFile.StartTapeLocation * intCounter, BackUpFile.MaxMemoryChunk);
Console.WriteLine("Now I'm Writing file to disk...");
FileStreamToWrite.Write(ReadBytes, 0, ReadBytes.Length);
}
else
{
ReadBytes = null;//clears the memory...
GC.Collect();
Console.WriteLine("This is pass " + intCounter);
Console.WriteLine("Now I'm Reading file from tape into memory...");
ReadBytes = TapeOperator.Read(TapeOperator.GetTapePosition(), (int)(objBackupFile.Size - BackupFile.MaxMemoryChunk * (intCounter - 1)));
Console.WriteLine("Now I'm Writing file to disk...");
FileStreamToWrite.Write(ReadBytes, 0, ReadBytes.Length);
}
}
}
else
{
ReadBytes = null;//clears the memory...
GC.Collect();
Console.WriteLine("Now I'm Reading file from tape into memory...");
ReadBytes = TapeOperator.Read(objBackupFile.StartTapeLocation, objBackupFile.Size);
Console.WriteLine("Now I'm Writing file to disk...");
FileStreamToWrite.Write(ReadBytes, 0, ReadBytes.Length);
}
Console.WriteLine("Tape Position is " + TapeOperator.GetTapePosition());
}
Console.WriteLine("Now I'm Cleaning up resources...");
FileStreamToWrite.Close();
TapeOperator.Close();
Console.WriteLine("Now I'm Done!");
Console.WriteLine();
}
