public virtual void Setup()
{
_backupProcess = A.Fake<BackupProcess>();
_backupStorage = A.Fake<BackupStorage>();
_backupNotifier = A.Fake<BackupNotifier>();
_backupCleanUp = A.Fake<BackupCleanUp>();
}
/// <summary>
/// Prepares the backup
/// </summary>
/// <returns>True when preparation finished OK, otherwise we should exit</returns>
public bool Prepare()
{
var log = OpenLog();
if (_backupTaskTitles.Count == 0)
{
log.WriteLine(LoggingEvent.Error, Translation.Current[620], TaskCommandLineArgument);
return(false);
}
foreach (var backupTaskTitle in _backupTaskTitles)
{
if (!_options.BackupTasks.ContainsKey(backupTaskTitle))
{
log.WriteLine(LoggingEvent.Error, Translation.Current[621], backupTaskTitle);
return(false);
}
else
{
var task = _options.BackupTasks[backupTaskTitle];
if (!_backupTasks.Contains(task))
{
_backupTasks.Add(task);
}
}
}
_backup = new BackupProcess(_backupTasks, _options, log);
return(true);
}
/// <summary>
/// In this function backup process goes
/// </summary>
void thread_process(object parameter)
{
var scheduler = (Scheduler)parameter;
FileLog log = null;
try
{
log = new FileLog(_options.LogsFolder, _options.LoggingLevel, true);
log.Open();
}
catch (LogException e)
{
// "Cannot open file log due to crytical error {0}"
Messages.ShowErrorBox(string.Format(CultureInfo.InstalledUICulture, Translation.Current[312], e.Message));
onBackupFinished();
}
// initing objects that we should dispose
_processor = new BackupProcess(new List <BackupTask> {
scheduler.Task
}, _options, log);
_processor.BackupFinished += onBackupFinished;
_processor.NotificationEventHandler += onNotificationReceived;
_processor.Run();
onBackupFinished();
}
public void RunBackup()
{
string profilePath = GetProfileFolder(profile.Id, profile.Name);
string destFolder = GetSavedBackUpPath(profile.Name);
var backupProcess = new BackupProcess(profilePath, destFolder, profile);
List <BackupDataItem> listItems = BackupDataItems.Concat(CommonBackupDataItems).ToList();
backupProcess.StartBackUpAutomation(AutomationBackUpFileName, listItems);
}
public void MakeBackup(UpdateModel updateModel)
{
var process = new BackupProcess(ConfigurationRoot);
process.ProcessEvent += ProcessEvent;
process.ConfirmEvent += ConfirmEvent;
ResultEvetnt(process.Process(updateModel), null);
}
public BackupController(
BackupProcess backupProcess,
BackupStorage backupStorage,
BackupCleanUp backupCleanUp,
BackupNotifier backupNotifier)
{
_backupProcess = backupProcess;
_backupStorage = backupStorage;
_backupCleanUp = backupCleanUp;
_backupNotifier = backupNotifier;
}
public void AcceptBackup()
{
var spy = new BackupFake(SaveBackupResult.Done);
var process = new BackupProcess(
spy,
new QuestionToBackupFake(QuestionToBackupResult.YesIWantBackup)
);
Assert.Equal(SaveBackupResult.Done, process.Save("NEW SYSTEM PATH", "NEW USER PATH"));
Assert.Equal(new[] { "NEW SYSTEM PATH" }, spy.SystemSaved);
Assert.Equal(new[] { "NEW USER PATH" }, spy.UserSaved);
}
public void CancelBackup()
{
var spy = new BackupFake(SaveBackupResult.Done);
var process = new BackupProcess(
spy,
new QuestionToBackupFake(QuestionToBackupResult.Cancel)
);
Assert.Equal(SaveBackupResult.Cancel, process.Save("NEW SYSTEM PATH", "NEW USER PATH"));
Assert.Empty(spy.SystemSaved);
Assert.Empty(spy.UserSaved);
}
/// <summary>
/// Event occurs when backup completed or aborted
/// </summary>
void onBackupFinished()
{
if (_processor != null)
{
_processor.Dispose();
_processor = null;
notifyUser(Translation.Current[589]);// that backup is finished
}
foreach (var scheduler in _schedulers)
{
scheduler.Resume();
}
}
public void PrepareBackup()
{
var log = new FileLog(_options.LogsFolder, _options.LoggingLevel, false);
_fileLogFile = log.LogFilename;
log.Open();
_backupper = new BackupProcess(new List <BackupTask> {
_task
}, Options, log);
_backupper.BackupFinished +=
new BackupFinished(onBackupFinsihedHelper);
_backupper.CriticalErrorOccur +=
new CriticalErrorOccur(Messages.ShowErrorBox);
}
private async Task BackupAsync()
{
string targetPath = string.Empty;
try
{
foreach (var dir in DriveInfo.GetDrives())
{
if (dir.DriveType == DriveType.Removable && dir.IsReady)
{
string nowDate = DateTime.Now.ToShortDateString().Replace(':', '_');
targetPath = dir.Name + $"backup - {nowDate}";
//+ Path.DirectorySeparatorChar;
//+ Environment.CurrentDirectory.Split(Path.DirectorySeparatorChar).Last();
Directory.CreateDirectory(targetPath);
_backupWin = new BackupProcess();
using (WaitCursor cursor = new WaitCursor())
{
await CopyData(Environment.CurrentDirectory, targetPath);
_backupWin.Close();
}
MessageBox.Show($"Данные сохранены по пути: {targetPath}", "Резервное копирование произведено");
return;
}
}
MessageBox.Show($"Внешние носители не найдены");
}
catch (Exception ex)
{
MessageBox.Show($"Непредвиденная ошибка: {ex.Message}");
}
finally
{
_backupWin?.Close();
}
}
public static void RestoreToPointedFolderHelper(ImageReader openedReader, MetaRecord record, string pointedFolder, bool imageDataIsPasswordProtected, string password)
{
try
{
string tempFile = Path.GetTempFileName();
UnpackParameters unpackParameters;
if (imageDataIsPasswordProtected)
{
unpackParameters = new UnpackParameters(password, tempFile, pointedFolder);
}
else
{
unpackParameters = new UnpackParameters(tempFile, pointedFolder);
}
try
{
openedReader.Extract(record, tempFile);
UnpackArchive aup = new UnpackArchive(unpackParameters);
aup.StartJob();
}
finally
{
if (imageDataIsPasswordProtected)
{
BackupProcess.OverwriteFileWithZerosWithoutLogging(tempFile);
}
File.Delete(tempFile);
}
}
catch (Exception exc)
{
MessageBox.Show(exc.Message, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0);
}
}
