public bool Sync()
{
if (!ServiceSetting.GetSettingValue(SettingStrings.StorageType).Equals("SMB"))
{
return(true);
}
using (var unc = new UncServices())
{
if (unc.NetUseWithCredentials() || unc.LastError == 1219)
{
RoboCommand backup = new RoboCommand();
// events
backup.OnFileProcessed += backup_OnFileProcessed;
backup.OnCommandCompleted += backup_OnCommandCompleted;
// copy options
backup.CopyOptions.Source = ServiceSetting.GetSettingValue(SettingStrings.StoragePath);
backup.CopyOptions.Destination = ConfigurationManager.AppSettings["LocalStoragePath"].Trim('\\');
backup.CopyOptions.CopySubdirectories = true;
backup.CopyOptions.UseUnbufferedIo = true;
// select options
//backup.SelectionOptions.OnlyCopyArchiveFilesAndResetArchiveFlag = true;
backup.CopyOptions.Mirror = true;
backup.CopyOptions.Purge = false;
backup.SelectionOptions.ExcludeOlder = true;
backup.LoggingOptions.VerboseOutput = true;
// retry options
backup.RetryOptions.RetryCount = 1;
backup.RetryOptions.RetryWaitTime = 2;
backup.Start();
return(true);
}
return(false);
}
}
public bool Sync()
{
if (!ServiceSetting.GetSettingValue(SettingStrings.StorageType).Equals("SMB"))
{
return(true);
}
var guid = ConfigurationManager.AppSettings["ComServerUniqueId"];
var thisComServer = new ServiceClientComServer().GetServerByGuid(guid);
if (thisComServer == null)
{
Logger.Error($"Com Server With Guid {guid} Not Found");
return(false);
}
using (var unc = new UncServices())
{
if (unc.NetUseWithCredentials() || unc.LastError == 1219)
{
foreach (var folder in new [] { "client_versions", "software_uploads" })
{
RoboCommand backup = new RoboCommand();
// events
backup.OnError += Backup_OnError;
// copy options
backup.CopyOptions.Source = ServiceSetting.GetSettingValue(SettingStrings.StoragePath) + folder;
backup.CopyOptions.Destination = thisComServer.LocalStoragePath + folder.Trim('\\');
backup.CopyOptions.CopySubdirectories = true;
backup.CopyOptions.UseUnbufferedIo = true;
if (thisComServer.ReplicationRateIpg != 0)
{
backup.CopyOptions.InterPacketGap = thisComServer.ReplicationRateIpg;
}
else
{
backup.CopyOptions.InterPacketGap = 0;
}
// select options
backup.CopyOptions.Mirror = true;
backup.CopyOptions.Purge = true;
backup.LoggingOptions.VerboseOutput = false;
// retry options
backup.RetryOptions.RetryCount = 3;
backup.RetryOptions.RetryWaitTime = 10;
backup.Start().Wait();
}
return(true);
}
return(false);
}
}
/// <summary>
/// The main method that performs the copy
/// </summary>
/// <returns></returns>
public Task Copy()
{
if (!DirExists(CopyParameters.TestDataRepoRootDir))
{
throw new Exception("Test data repository root directory not found, " + CopyParameters.TestDataRepoRootDir);
}
// Append project name to destination folder
string destinationDir = Path.Combine(CopyParameters.DestinationRootDir, CopyParameters.Project);
if (!DirExists(destinationDir))
{
throw new Exception("Destination root directory not found, " + destinationDir);
}
// Append test data name to test data repository root
string sourceDir = Path.Combine(CopyParameters.TestDataRepoRootDir, CopyParameters.Name);
if (!DirExists(sourceDir))
{
throw new Exception("Test data directory to copy not found, " + sourceDir);
}
destinationDir = Path.Combine(destinationDir, CopyParameters.Name); // Add the test data name to destination
LogHelper.Log(LogLevel.INFO, "Source folder = " + sourceDir);
LogHelper.Log(LogLevel.INFO, "Destination folder = " + destinationDir);
RoboCopy = new RoboCommand();
// events
RoboCopy.OnFileProcessed += rbc_OnFileProcessed;
RoboCopy.OnCopyProgressChanged += rbc_OnCopyProgressChanged;
RoboCopy.OnCommandCompleted += rbc_OnCommandCompleted;
// copy options
RoboCopy.CopyOptions.MultiThreadedCopiesCount = 16;
RoboCopy.CopyOptions.Source = sourceDir;
RoboCopy.CopyOptions.Destination = destinationDir;
RoboCopy.CopyOptions.CopySubdirectories = true;
RoboCopy.CopyOptions.UseUnbufferedIo = true;
RoboCopy.CopyOptions.Mirror = true;
RoboCopy.CopyOptions.EnableRestartMode = true;
RoboCopy.CopyOptions.UseUnbufferedIo = true;
RoboCopy.CopyOptions.InterPacketGap = 0;
// retry options
RoboCopy.RetryOptions.RetryCount = 1;
RoboCopy.RetryOptions.RetryWaitTime = 2;
var cpTask = RoboCopy.Start();
return(cpTask);
}
public void CopyApplicationSite(string source, string destination)
{
RoboCommand roboCommand = new RoboCommand();
//roboCommand.OnFileProcessed += OnFileProcessed;
roboCommand.OnCommandCompleted += OnCommandCompleted;
roboCommand.CopyOptions.Source = source;
roboCommand.CopyOptions.Destination = destination;
roboCommand.CopyOptions.Mirror = true;
roboCommand.CopyOptions.CopySubdirectories = true;
roboCommand.LoggingOptions.NoFileSizes = true;
roboCommand.LoggingOptions.NoFileList = true;
roboCommand.LoggingOptions.NoDirectoryList = true;
roboCommand.LoggingOptions.NoProgress = true;
var cmd = roboCommand.Start();
cmd.Wait();
ConfigureApplicationSite();
}
private void CopyForm_Load(object sender, EventArgs e)
{
_RoboCommand = new RoboCommand();
// event handlers
_RoboCommand.OnCommandError += _RoboCommand_OnCommandError;
_RoboCommand.OnError += _RoboCommand_OnError;
_RoboCommand.OnCopyProgressChanged += _RoboCommand_OnCopyProgressChanged;
_RoboCommand.OnFileProcessed += _RoboCommand_OnFileProcessed;
_RoboCommand.OnCommandCompleted += _RoboCommand_OnCommandCompleted;
// _RoboCommand options
_RoboCommand.CopyOptions.Source = ProfileManager.CurrentProfile.Source;
//
_RoboCommand.CopyOptions.Destination = ProfileManager.CurrentProfile.Destination;
//
_RoboCommand.CopyOptions.FileFilter = ProfileManager.CurrentProfile.FileFilter;
//
if (ProfileManager.CurrentProfile.Mirror)
{
_RoboCommand.CopyOptions.Mirror = true;
}
else
{
if (ProfileManager.CurrentProfile.CopySubdirectoriesIncludingEmpty)
{
_RoboCommand.CopyOptions.CopySubdirectoriesIncludingEmpty = true;
}
else
{
_RoboCommand.CopyOptions.CopySubdirectories = ProfileManager.CurrentProfile.CopySubdirectories;
}
//
_RoboCommand.CopyOptions.Purge = ProfileManager.CurrentProfile.Purge;
}
//
if (ProfileManager.CurrentProfile.EnableRestartMode && ProfileManager.CurrentProfile.EnableBackupMode)
{
_RoboCommand.CopyOptions.EnableRestartModeWithBackupFallback = true;
}
else
{
_RoboCommand.CopyOptions.EnableRestartMode = ProfileManager.CurrentProfile.EnableRestartMode;
_RoboCommand.CopyOptions.EnableBackupMode = ProfileManager.CurrentProfile.EnableBackupMode;
}
//
_RoboCommand.CopyOptions.UseUnbufferedIo = ProfileManager.CurrentProfile.UseUnbufferedIo;
//
if (ProfileManager.CurrentProfile.EnableEfsRawMode || ProfileManager.CurrentProfile.InterPacketGap > 0)
{
_RoboCommand.CopyOptions.EnableEfsRawMode = ProfileManager.CurrentProfile.EnableEfsRawMode;
_RoboCommand.CopyOptions.InterPacketGap = ProfileManager.CurrentProfile.InterPacketGap;
}
else
{
_RoboCommand.CopyOptions.MultiThreadedCopiesCount = ProfileManager.CurrentProfile.MultiThreadedCopiesCount;
}
//
_RoboCommand.CopyOptions.Depth = ProfileManager.CurrentProfile.Depth;
//
_RoboCommand.CopyOptions.FatFiles = ProfileManager.CurrentProfile.FatFiles;
//
_RoboCommand.CopyOptions.TurnLongPathSupportOff = ProfileManager.CurrentProfile.TurnLongPathSupportOff;
//
_RoboCommand.CopyOptions.CopySymbolicLink = ProfileManager.CurrentProfile.CopySymobolicLink;
//
_RoboCommand.CopyOptions.DoNotUseWindowsCopyOffload = ProfileManager.CurrentProfile.DoNotUseWindowsCopyOffload;
//
_RoboCommand.CopyOptions.CheckPerFile = ProfileManager.CurrentProfile.CheckPerFile;
//
_RoboCommand.CopyOptions.CopyFlags = ProfileManager.CurrentProfile.FileCopyFlags.ToString();
//
_RoboCommand.CopyOptions.DirectoryCopyFlags = ProfileManager.CurrentProfile.DirectoryCopyFlags.ToString();
//
_RoboCommand.CopyOptions.AddAttributes = ProfileManager.CurrentProfile.AddAttributes.ToString();
//
_RoboCommand.CopyOptions.RemoveAttributes = ProfileManager.CurrentProfile.RemoveAttributes.ToString();
//
/*_RoboCommand.CopyOptions.MoveFiles = ProfileManager.Current.MoveFiles;
* //
* _RoboCommand.CopyOptions.MoveFilesAndDirectories = ProfileManager.Current.MoveFilesAndDirectories;
* //
* _RoboCommand.CopyOptions.CreateDirectoryAndFileTree = ProfileManager.Current.CreateDirectoryAndFileTree;*/
//
_RoboCommand.RetryOptions.RetryCount = ProfileManager.CurrentProfile.RetryCount;
//
_RoboCommand.RetryOptions.RetryWaitTime = ProfileManager.CurrentProfile.RetryWaitTime;
_Stopwatch = new Stopwatch();
_Stopwatch.Start();
_RoboCommand.Start();
PauseResumeButton.Enabled = true;
}
/// <summary>
/// Start transferring data from a given source directory to the destination
/// location that is derived from TxTargetUser. Requires CopyState to be in
/// status "Stopped", sets CopyState to "Active" and FilecopyFinished to
/// false. The currently processed path is stored in the global status
/// variable CurrentTransferSrc.
/// </summary>
/// <param name="sourcePath">The full path to a folder. By convention, the
/// LAST element of the path has to match the target user name!</param>
private void StartTransfer(string sourcePath)
{
// only proceed when in a valid state:
if (_transferState != TxState.Stopped)
{
return;
}
var totalSize = FsUtils.GetDirectorySize(sourcePath);
if (totalSize == 0)
{
Log.Warn("Total size of all files in [{0}] is zero, NOT STARTING a transfer!",
sourcePath);
// we also have to move it out of the way, otherwise it will block all transfers:
var sourceDir = new DirectoryInfo(sourcePath);
var errorTargetPath = Path.Combine(_config.ErrorPath, TimeUtils.Timestamp());
sourceDir.MoveTo(errorTargetPath);
Log.Warn("Moved empty directory tree [{0}] to [{1}].", sourcePath, errorTargetPath);
return;
}
Log.Debug("Size of all files under [{0}] is {1} bytes ({2})",
sourcePath, totalSize, Conv.BytesToString(totalSize));
_status.CurrentTransferSize = totalSize;
_status.CurrentTransferSrc = sourcePath;
// the user name is expected to be the last part of sourcePath:
_status.TxTargetUser = new DirectoryInfo(sourcePath).Name;
FsUtils.CreateNewDirectory(_status.TxTargetTmp, false);
_transferState = TxState.Active;
_status.TransferInProgress = true;
_roboCommand = new RoboCommand();
try {
// events
_roboCommand.OnCopyProgressChanged += RsProgressChanged;
_roboCommand.OnFileProcessed += RsFileProcessed;
_roboCommand.OnCommandCompleted += RsCommandCompleted;
// copy options
_roboCommand.CopyOptions.Source = sourcePath;
_roboCommand.CopyOptions.Destination = _status.TxTargetTmp;
// limit the transfer bandwidth by waiting between packets:
_roboCommand.CopyOptions.InterPacketGap = _config.InterPacketGap;
// /S :: copy Subdirectories, but not empty ones
// _roboCommand.CopyOptions.CopySubdirectories = true;
// /E :: copy subdirectories, including Empty ones
_roboCommand.CopyOptions.CopySubdirectoriesIncludingEmpty = true;
// /PF :: check run hours on a Per File (not per pass) basis
// _roboCommand.CopyOptions.CheckPerFile = true;
// /SECFIX :: fix file security on all files, even skipped files
// _roboCommand.CopyOptions.FixFileSecurityOnAllFiles = true;
// copyflags :
// D=Data, A=Attributes, T=Timestamps
// S=Security=NTFS ACLs, O=Owner info, U=aUditing info
_roboCommand.CopyOptions.CopyFlags = _config.CopyFlags;
// /DCOPY :: directory copy settings (T=Timestamps)
_roboCommand.CopyOptions.DirectoryCopyFlags = _config.DirectoryCopyFlags;
// select options
_roboCommand.SelectionOptions.ExcludeOlder = true;
// retry options
_roboCommand.RetryOptions.RetryCount = 0;
_roboCommand.RetryOptions.RetryWaitTime = 0;
// robocopy logging (NOTE: the "OutputToRoboSharpAndLog" option is required as
// otherwise messages will go to the log only and can't be processed by RoboSharp
// any more, resulting in no callbacks and therefore no progress reports etc.)
if (!string.IsNullOrWhiteSpace(_config.RoboCopyLog))
{
Log.Debug("Setting RoboCopy log file to [{0}]", _config.RoboCopyLog);
_roboCommand.LoggingOptions = new LoggingOptions {
LogPath = _config.RoboCopyLog,
OutputToRoboSharpAndLog = true,
VerboseOutput = true
};
}
_roboCommand.Start();
Log.Info("Transfer started, total size: {0}",
Conv.BytesToString(_status.CurrentTransferSize));
Log.Trace("RoboCopy command options: {0}", _roboCommand.CommandOptions);
}
catch (ManagementException ex) {
Log.Error("Error in StartTransfer(): {0}", ex.Message);
}
}
public void Backup()
{
copy = new RoboCommand();
copy.OnFileProcessed += copy_OnFileProcessed;
copy.OnCommandError += copy_OnCommandError;
copy.OnError += copy_OnError;
copy.OnCopyProgressChanged += copy_OnCopyProgressChanged;
copy.OnCommandCompleted += copy_OnCommandCompleted;
// copy options
copy.CopyOptions.Source = Source.Text;
copy.CopyOptions.Destination = Destination.Text;
copy.CopyOptions.FileFilter = FileFilter.Text;
copy.CopyOptions.CopySubdirectories = CopySubDirectories.IsChecked ?? false;
copy.CopyOptions.CopySubdirectoriesIncludingEmpty = CopySubdirectoriesIncludingEmpty.IsChecked ?? false;
if (!string.IsNullOrWhiteSpace(Depth.Text))
{
copy.CopyOptions.Depth = Convert.ToInt32(Depth.Text);
}
copy.CopyOptions.EnableRestartMode = EnableRestartMode.IsChecked ?? false;
copy.CopyOptions.EnableBackupMode = EnableBackupMode.IsChecked ?? false;
copy.CopyOptions.EnableRestartModeWithBackupFallback = EnableRestartModeWithBackupFallback.IsChecked ?? false;
copy.CopyOptions.UseUnbufferedIo = UseUnbufferedIo.IsChecked ?? false;
copy.CopyOptions.EnableEfsRawMode = EnableEfsRawMode.IsChecked ?? false;
copy.CopyOptions.CopyFlags = CopyFlags.Text;
copy.CopyOptions.CopyFilesWithSecurity = CopyFilesWithSecurity.IsChecked ?? false;
copy.CopyOptions.CopyAll = CopyAll.IsChecked ?? false;
copy.CopyOptions.RemoveFileInformation = RemoveFileInformation.IsChecked ?? false;
copy.CopyOptions.FixFileSecurityOnAllFiles = FixFileSecurityOnAllFiles.IsChecked ?? false;
copy.CopyOptions.FixFileTimesOnAllFiles = FixFileTimesOnAllFiles.IsChecked ?? false;
copy.CopyOptions.Purge = Purge.IsChecked ?? false;
copy.CopyOptions.Mirror = Mirror.IsChecked ?? false;
copy.CopyOptions.MoveFiles = MoveFiles.IsChecked ?? false;
copy.CopyOptions.MoveFilesAndDirectories = MoveFilesAndDirectories.IsChecked ?? false;
copy.CopyOptions.AddAttributes = AddAttributes.Text;
copy.CopyOptions.RemoveAttributes = RemoveAttributes.Text;
copy.CopyOptions.CreateDirectoryAndFileTree = CreateDirectoryAndFileTree.IsChecked ?? false;
copy.CopyOptions.FatFiles = FatFiles.IsChecked ?? false;
copy.CopyOptions.TurnLongPathSupportOff = TurnLongPathSupportOff.IsChecked ?? false;
if (!string.IsNullOrWhiteSpace(MonitorSourceChangesLimit.Text))
{
copy.CopyOptions.MonitorSourceChangesLimit = Convert.ToInt32(MonitorSourceChangesLimit.Text);
}
if (!string.IsNullOrWhiteSpace(MonitorSourceTimeLimit.Text))
{
copy.CopyOptions.MonitorSourceTimeLimit = Convert.ToInt32(MonitorSourceTimeLimit.Text);
}
// select options
copy.SelectionOptions.OnlyCopyArchiveFiles = OnlyCopyArchiveFiles.IsChecked ?? false;
copy.SelectionOptions.OnlyCopyArchiveFilesAndResetArchiveFlag = OnlyCopyArchiveFilesAndResetArchiveFlag.IsChecked ?? false;
copy.SelectionOptions.IncludeAttributes = IncludeAttributes.Text;
copy.SelectionOptions.ExcludeAttributes = ExcludeAttributes.Text;
copy.SelectionOptions.ExcludeFiles = ExcludeFiles.Text;
copy.SelectionOptions.ExcludeDirectories = ExcludeDirectories.Text;
copy.SelectionOptions.ExcludeOlder = ExcludeOlder.IsChecked ?? false;
copy.SelectionOptions.ExcludeJunctionPoints = ExcludeJunctionPoints.IsChecked ?? false;
// retry options
if (!string.IsNullOrWhiteSpace(RetryCount.Text))
{
copy.RetryOptions.RetryCount = Convert.ToInt32(RetryCount.Text);
}
if (!string.IsNullOrWhiteSpace(RetryWaitTime.Text))
{
copy.RetryOptions.RetryWaitTime = Convert.ToInt32(RetryWaitTime.Text);
}
// logging options
copy.LoggingOptions.VerboseOutput = VerboseOutput.IsChecked ?? false;
copy.LoggingOptions.NoFileSizes = NoFileSizes.IsChecked ?? false;
copy.LoggingOptions.NoProgress = NoProgress.IsChecked ?? false;
copy.Start();
}
private void PerformBackup(object sender, EventArgs eventArgs)
{
taskbarIcon.TrayBalloonTipClicked -= PerformBackup;
if (MessageBox.Show("Soll das Backup jetzt wirklich gestartet werden?", "Backup starten?", MessageBoxButton.YesNo, MessageBoxImage.Question) != MessageBoxResult.Yes)
{
BaloonTipDisplayed = false;
return;
}
string backupRoot = string.Empty;
string exclusionString = string.Empty;
CopyExecuting = true;
foreach (string exclude in ApplicationConfiguration.Exclusions)
{
exclusionString = exclusionString + exclude + " ";
}
DriveInfo[] drives = System.IO.DriveInfo.GetDrives();
foreach (DriveInfo drive in drives)
{
if (!drive.IsReady)
{
continue;
}
if (Directory.Exists(System.IO.Path.Combine(drive.RootDirectory.FullName, "USBBackup", ApplicationConfiguration.UniqueIdentifyer)))
{
backupRoot = System.IO.Path.Combine(drive.RootDirectory.FullName, "USBBackup", ApplicationConfiguration.UniqueIdentifyer);
break;
}
}
if (backupRoot == string.Empty)
{
taskbarIcon.ShowBalloonTip("Fehler beim Durchführen des Backups", "Das Laufwerk war nicht bereit zum Schreiben.\r\nBitte versuchen Sie es erneut.", BalloonIcon.Error);
return;
}
string rootBackupRoot = backupRoot;
RunningCopyOperations = 0;
foreach (string backupSourceRoot in ApplicationConfiguration.BackupFolders)
{
if (!Directory.Exists(backupSourceRoot))
{
continue;
}
DirectoryInfo info = new DirectoryInfo(backupSourceRoot);
backupRoot = CreateParentDirectory(rootBackupRoot, info);
RoboCommand robo = new RoboCommand();
robo.CopyOptions.Source = backupSourceRoot;
robo.CopyOptions.Destination = backupRoot;
robo.CopyOptions.CopySubdirectoriesIncludingEmpty = true;
robo.RetryOptions.RetryCount = 10;
robo.RetryOptions.RetryWaitTime = 5;
robo.SelectionOptions.ExcludeDirectories = exclusionString;
robo.OnCommandCompleted += Robo_OnCopyCompleted;
robo.OnCommandError += Robo_OnCopyError;
robo.OnFileProcessed += delegate(object o, RoboSharp.FileProcessedEventArgs e) { };
robo.Start();
taskbarIcon.ToolTipText = "USB-Backup - Backup läuft...";
RunningCopyOperations++;
}
}
public async Task Execute(IJobExecutionContext context)
{
Debug.WriteLine(string.Format("'{0}' tick: {1}", context.JobDetail.Key.Name.ToString().Substring(0, 5), DateTime.Now));
// Notify the UI that the job is now running.
BackupInfoViewModel.SetBackupItemStatus(context.JobDetail.Key.Name.ToString(), (int)StatusCodes.RUNNING);
JobDataMap dataMap = context.JobDetail.JobDataMap;
string originPath = dataMap.GetString("originPath");
string backupPath = dataMap.GetString("backupPath");
if (originPath.EndsWith(@"\"))
{
// Copy directory
try
{
Debug.WriteLine(string.Format("{0} Copying directory: '{1}' to '{2}'", DateTime.Now, originPath, backupPath));
RoboCommand roboCopy = new RoboCommand();
// Copy options
roboCopy.CopyOptions.Source = originPath;
roboCopy.CopyOptions.Destination = Path.Combine(backupPath, Path.GetFileName(Path.GetDirectoryName(originPath)));
roboCopy.CopyOptions.CopySubdirectories = true;
roboCopy.CopyOptions.UseUnbufferedIo = true;
roboCopy.CopyOptions.Mirror = true;
// Selection options
roboCopy.SelectionOptions.IncludeSame = false;
roboCopy.SelectionOptions.IncludeTweaked = true;
roboCopy.SelectionOptions.ExcludeOlder = true;
// Retry options
roboCopy.RetryOptions.RetryCount = 3;
roboCopy.RetryOptions.RetryWaitTime = 5;
// Start and wait for the robocopy to finish.
await roboCopy.Start();
}
catch (Exception e)
{
Debug.WriteLine("Error in BackupJob.Execute() folder " + e.Message);
// Notify the UI that the job has errored.
BackupInfoViewModel.SetBackupItemStatus(context.JobDetail.Key.Name.ToString(), (int)StatusCodes.ERROR);
}
}
else
{
// Copy file
try
{
Debug.WriteLine(string.Format("{0} Copying file: '{1}' to '{2}'", DateTime.Now, originPath, backupPath));
RoboCommand roboCopy = new RoboCommand();
//Debug.WriteLine(Path.GetDirectoryName(originPath));
//Debug.WriteLine(backupPath);
//Debug.WriteLine(Path.GetFileName(originPath));
// Copy options
roboCopy.CopyOptions.Source = Path.GetDirectoryName(originPath);
roboCopy.CopyOptions.Destination = backupPath;
roboCopy.CopyOptions.FileFilter = new string[] { Path.GetFileName(originPath) };
// Selection options
roboCopy.SelectionOptions.IncludeSame = false;
roboCopy.SelectionOptions.IncludeTweaked = true;
roboCopy.SelectionOptions.ExcludeOlder = true;
// Retry options
roboCopy.RetryOptions.RetryCount = 3;
roboCopy.RetryOptions.RetryWaitTime = 5;
// Start and wait for the robocopy to finish.
await roboCopy.Start();
}
catch (Exception e)
{
Debug.WriteLine("Error in BackupJob.Execute() file" + e.Message);
// Notify the UI that the job has errored.
BackupInfoViewModel.SetBackupItemStatus(context.JobDetail.Key.Name.ToString(), (int)StatusCodes.ERROR);
}
}
Debug.WriteLine(string.Format("Copy job '{0}' completed at: {1}", context.JobDetail.Key.Name.ToString().Substring(0, 5), DateTime.Now));
// If the backup was successful, then update information for the item and save the BackupItem collection config to file.
BackupInfoViewModel.NotifyItemHasBeenBackedUp(context.JobDetail.Key.Name);
BackupInfoViewModel.UpdateNextBackupDate(context.JobDetail.Key.Name);
BackupInfoViewModel.SaveConfig();
}
private void BeginRestore()
{
if (Utilities.IsGameRunning(Game))
{
M3L.ShowDialog(window, M3L.GetString(M3L.string_interp_dialogCannotRestoreXWhileItIsRunning, Game.ToGameName()), M3L.GetString(M3L.string_gameRunning), MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
var useNewMethod = M3L.ShowDialog(window,
M3L.GetString(M3L.string_beta_useNewRestoreMethod),
M3L.GetString(M3L.string_useBetaFeatureQuestion), MessageBoxButton.YesNo, MessageBoxImage.Question) == MessageBoxResult.Yes;
bool restore = RestoreTarget.IsCustomOption || useNewMethod; //custom option is restore to custom location
restore = restore || M3L.ShowDialog(window, M3L.GetString(M3L.string_dialog_restoringXWillDeleteGameDir, Game.ToGameName()), M3L.GetString(M3L.string_gameTargetWillBeDeleted), MessageBoxButton.YesNo, MessageBoxImage.Warning) == MessageBoxResult.Yes;
if (restore)
{
NamedBackgroundWorker nbw = new NamedBackgroundWorker(Game + @"-Restore");
nbw.WorkerReportsProgress = true;
nbw.ProgressChanged += (a, b) =>
{
if (b.UserState is double d)
{
TaskbarHelper.SetProgress(d);
}
};
nbw.DoWork += (a, b) =>
{
RestoreInProgress = true;
// Nuke the LODs
if (!RestoreTarget.IsCustomOption && RestoreTarget.Game.IsOTGame())
{
Log.Information($@"Resetting LODs for {RestoreTarget.Game}");
Utilities.SetLODs(RestoreTarget, false, false, false);
}
string restoreTargetPath = b.Argument as string;
string backupPath = BackupLocation;
if (!useNewMethod)
{
BackupStatusLine2 = M3L.GetString(M3L.string_deletingExistingGameInstallation);
if (Directory.Exists(restoreTargetPath))
{
if (Directory.GetFiles(restoreTargetPath).Any() ||
Directory.GetDirectories(restoreTargetPath).Any())
{
Log.Information(@"Deleting existing game directory: " + restoreTargetPath);
try
{
bool deletedDirectory =
Utilities.DeleteFilesAndFoldersRecursively(restoreTargetPath);
if (deletedDirectory != true)
{
b.Result = RestoreResult.ERROR_COULD_NOT_DELETE_GAME_DIRECTORY;
return;
}
}
catch (Exception ex)
{
//todo: handle this better
Log.Error(
$@"Exception deleting game directory: {restoreTargetPath}: {ex.Message}");
b.Result = RestoreResult.EXCEPTION_DELETING_GAME_DIRECTORY;
return;
}
}
}
else
{
Log.Error(@"Game directory not found! Was it removed while the app was running?");
}
var created = Utilities.CreateDirectoryWithWritePermission(restoreTargetPath);
if (!created)
{
b.Result = RestoreResult.ERROR_COULD_NOT_CREATE_DIRECTORY;
return;
}
}
BackupStatusLine2 = M3L.GetString(M3L.string_restoringGameFromBackup);
if (restoreTargetPath != null)
{
//callbacks
#region callbacks
void fileCopiedCallback()
{
ProgressValue++;
if (ProgressMax != 0)
{
nbw.ReportProgress(0, ProgressValue * 1.0 / ProgressMax);
}
}
string dlcFolderpath = MEDirectories.GetDLCPath(Game, backupPath) + '\\'; //\ at end makes sure we are restoring a subdir
int dlcSubStringLen = dlcFolderpath.Length;
Debug.WriteLine(@"DLC Folder: " + dlcFolderpath);
Debug.Write(@"DLC Folder path len:" + dlcFolderpath);
bool aboutToCopyCallback(string fileBeingCopied)
{
if (fileBeingCopied.Contains(@"\cmmbackup\"))
{
return(false); //do not copy cmmbackup files
}
Debug.WriteLine(fileBeingCopied);
if (fileBeingCopied.StartsWith(dlcFolderpath, StringComparison.InvariantCultureIgnoreCase))
{
//It's a DLC!
string dlcname = fileBeingCopied.Substring(dlcSubStringLen);
int index = dlcname.IndexOf('\\');
if (index > 0) //Files directly in the DLC directory won't have path sep
{
try
{
dlcname = dlcname.Substring(0, index);
if (MEDirectories.OfficialDLCNames(RestoreTarget.Game).TryGetValue(dlcname, out var hrName))
{
BackupStatusLine2 = M3L.GetString(M3L.string_interp_restoringX, hrName);
}
else
{
BackupStatusLine2 = M3L.GetString(M3L.string_interp_restoringX, dlcname);
}
}
catch (Exception e)
{
Crashes.TrackError(e, new Dictionary <string, string>()
{
{ @"Source", @"Restore UI display callback" },
{ @"Value", fileBeingCopied },
{ @"DLC Folder path", dlcFolderpath }
});
}
}
}
else
{
//It's basegame
if (fileBeingCopied.EndsWith(@".bik"))
{
BackupStatusLine2 = M3L.GetString(M3L.string_restoringMovies);
}
else if (new FileInfo(fileBeingCopied).Length > 52428800)
{
BackupStatusLine2 = M3L.GetString(M3L.string_interp_restoringX, Path.GetFileName(fileBeingCopied));
}
else
{
BackupStatusLine2 = M3L.GetString(M3L.string_restoringBasegame);
}
}
return(true);
}
void totalFilesToCopyCallback(int total)
{
ProgressValue = 0;
ProgressIndeterminate = false;
ProgressMax = total;
}
#endregion
BackupStatus = M3L.GetString(M3L.string_restoringGame);
// LE: Backup Config file so settings don't get lost
string configText = null;
var configPath = RestoreTarget.Game.IsLEGame() ? M3Directories.GetLODConfigFile(RestoreTarget) : null;
if (File.Exists(configPath))
{
configText = File.ReadAllText(configPath); // backup to memory
}
Log.Information($@"Copying backup to game directory: {backupPath} -> {restoreTargetPath}");
if (useNewMethod)
{
string CurrentRCFile = null;
RoboCommand rc = new RoboCommand();
rc.CopyOptions.Destination = restoreTargetPath;
rc.CopyOptions.Source = backupPath;
rc.CopyOptions.Mirror = true;
rc.CopyOptions.MultiThreadedCopiesCount = 2;
rc.OnCopyProgressChanged += (sender, args) =>
{
ProgressIndeterminate = false;
ProgressValue = (int)args.CurrentFileProgress;
ProgressMax = 100;
};
rc.OnFileProcessed += (sender, args) =>
{
if (args.ProcessedFile.Name.StartsWith(backupPath) && args.ProcessedFile.Name.Length > backupPath.Length)
{
CurrentRCFile = args.ProcessedFile.Name.Substring(backupPath.Length + 1);
BackupStatusLine2 = M3L.GetString(M3L.string_interp_copyingX, CurrentRCFile);
}
};
rc.Start().Wait();
}
else
{
CopyDir.CopyAll_ProgressBar(new DirectoryInfo(backupPath),
new DirectoryInfo(restoreTargetPath),
totalItemsToCopyCallback: totalFilesToCopyCallback,
aboutToCopyCallback: aboutToCopyCallback,
fileCopiedCallback: fileCopiedCallback,
ignoredExtensions: new[] { @"*.pdf", @"*.mp3" });
}
Log.Information(@"Restore of game data has completed");
if (configText != null)
{
// Restore config file
try
{
Directory.CreateDirectory(Directory.GetParent(configPath).FullName);
File.WriteAllText(configPath, configText);
Log.Information(@"Restored config file");
}
catch (Exception e)
{
Log.Error($@"Could not restore config file: {e.Message}");
}
}
BackupCopyFinished(restoreTargetPath);
}
};
nbw.RunWorkerCompleted += (a, b) =>
{
if (b.Error != null)
{
Log.Error($@"Exception occurred in {nbw.Name} thread: {b.Error.Message}");
}
TaskbarHelper.SetProgressState(TaskbarProgressBarState.NoProgress);
if (b.Result is RestoreResult result)
{
switch (result)
{
case RestoreResult.ERROR_COULD_NOT_CREATE_DIRECTORY:
Analytics.TrackEvent(@"Restored game", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"Result", @"Failure, Could not create target directory" }
});
M3L.ShowDialog(window, M3L.GetString(M3L.string_dialogCouldNotCreateGameDirectoryAfterDeletion), M3L.GetString(M3L.string_errorRestoringGame), MessageBoxButton.OK, MessageBoxImage.Error);
break;
case RestoreResult.ERROR_COULD_NOT_DELETE_GAME_DIRECTORY:
Analytics.TrackEvent(@"Restored game", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"Result", @"Failure, Could not delete existing game directory" }
});
M3L.ShowDialog(window, M3L.GetString(M3L.string_dialogcouldNotFullyDeleteGameDirectory), M3L.GetString(M3L.string_errorRestoringGame), MessageBoxButton.OK, MessageBoxImage.Error);
break;
case RestoreResult.EXCEPTION_DELETING_GAME_DIRECTORY:
Analytics.TrackEvent(@"Restored game", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"Result", @"Failure, Exception deleting existing game directory" }
});
M3L.ShowDialog(window, M3L.GetString(M3L.string_dialogErrorOccuredDeletingGameDirectory), M3L.GetString(M3L.string_errorRestoringGame), MessageBoxButton.OK, MessageBoxImage.Error);
break;
case RestoreResult.RESTORE_OK:
Analytics.TrackEvent(@"Restored game", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"Result", @"Success" }
});
break;
}
}
EndRestore();
CommandManager.InvalidateRequerySuggested();
};
var restoreTargetPath = RestoreTarget.TargetPath;
if (RestoreTarget.IsCustomOption)
{
CommonOpenFileDialog m = new CommonOpenFileDialog
{
IsFolderPicker = true,
EnsurePathExists = true,
Title = M3L.GetString(M3L.string_selectNewRestoreDestination)
};
if (m.ShowDialog() == CommonFileDialogResult.Ok)
{
//Check empty
restoreTargetPath = m.FileName;
if (Directory.Exists(restoreTargetPath))
{
if (Directory.GetFiles(restoreTargetPath).Length > 0 || Directory.GetDirectories(restoreTargetPath).Length > 0)
{
Log.Warning($@"The selected restore directory is not empty: {restoreTargetPath}");
//Directory not empty
if (!useNewMethod)
{
M3L.ShowDialog(window,
M3L.GetString(M3L
.string_dialogDirectoryIsNotEmptyLocationToRestoreToMustBeEmpty),
M3L.GetString(M3L.string_cannotRestoreToThisLocation), MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
else
{
// Warn user
var shouldContinue = MessageBoxResult.Yes == M3L.ShowDialog(window,
M3L.GetString(M3L.string_interp_directoryNotEmptyWillDeleteEverything, restoreTargetPath),
M3L.GetString(M3L.string_directoryNotEmpty), MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (!shouldContinue)
{
return;
}
Log.Warning($@"The user is continuing to new-gen restore on existing directory anyways");
}
}
//TODO: PREVENT RESTORING TO DOCUMENTS/BIOWARE
}
Analytics.TrackEvent(@"Chose to restore game to custom location", new Dictionary <string, string>()
{
{ @"Game", Game.ToString() },
{ @"New-gen", useNewMethod.ToString() }
});
}
else
{
return;
}
}
RefreshTargets = true;
TaskbarHelper.SetProgress(0);
TaskbarHelper.SetProgressState(TaskbarProgressBarState.Normal);
nbw.RunWorkerAsync(restoreTargetPath);
}
}
public void Backup()
{
Debugger.Instance.DebugMessageEvent += DebugMessage;
copy = new RoboCommand();
copy.OnFileProcessed += copy_OnFileProcessed;
copy.OnCommandError += copy_OnCommandError;
copy.OnError += copy_OnError;
copy.OnCopyProgressChanged += copy_OnCopyProgressChanged;
copy.OnCommandCompleted += copy_OnCommandCompleted;
// copy options
copy.CopyOptions.Source = Source.Text;
copy.CopyOptions.Destination = Destination.Text;
copy.CopyOptions.FileFilter = FileFilter.Text;
copy.CopyOptions.CopySubdirectories = CopySubDirectories.IsChecked ?? false;
copy.CopyOptions.CopySubdirectoriesIncludingEmpty = CopySubdirectoriesIncludingEmpty.IsChecked ?? false;
if (!string.IsNullOrWhiteSpace(Depth.Text))
copy.CopyOptions.Depth = Convert.ToInt32(Depth.Text);
copy.CopyOptions.EnableRestartMode = EnableRestartMode.IsChecked ?? false;
copy.CopyOptions.EnableBackupMode = EnableBackupMode.IsChecked ?? false;
copy.CopyOptions.EnableRestartModeWithBackupFallback = EnableRestartModeWithBackupFallback.IsChecked ?? false;
copy.CopyOptions.UseUnbufferedIo = UseUnbufferedIo.IsChecked ?? false;
copy.CopyOptions.EnableEfsRawMode = EnableEfsRawMode.IsChecked ?? false;
copy.CopyOptions.CopyFlags = CopyFlags.Text;
copy.CopyOptions.CopyFilesWithSecurity = CopyFilesWithSecurity.IsChecked ?? false;
copy.CopyOptions.CopyAll = CopyAll.IsChecked ?? false;
copy.CopyOptions.RemoveFileInformation = RemoveFileInformation.IsChecked ?? false;
copy.CopyOptions.FixFileSecurityOnAllFiles = FixFileSecurityOnAllFiles.IsChecked ?? false;
copy.CopyOptions.FixFileTimesOnAllFiles = FixFileTimesOnAllFiles.IsChecked ?? false;
copy.CopyOptions.Purge = Purge.IsChecked ?? false;
copy.CopyOptions.Mirror = Mirror.IsChecked ?? false;
copy.CopyOptions.MoveFiles = MoveFiles.IsChecked ?? false;
copy.CopyOptions.MoveFilesAndDirectories = MoveFilesAndDirectories.IsChecked ?? false;
copy.CopyOptions.AddAttributes = AddAttributes.Text;
copy.CopyOptions.RemoveAttributes = RemoveAttributes.Text;
copy.CopyOptions.CreateDirectoryAndFileTree = CreateDirectoryAndFileTree.IsChecked ?? false;
copy.CopyOptions.FatFiles = FatFiles.IsChecked ?? false;
copy.CopyOptions.TurnLongPathSupportOff = TurnLongPathSupportOff.IsChecked ?? false;
if (!string.IsNullOrWhiteSpace(MonitorSourceChangesLimit.Text))
copy.CopyOptions.MonitorSourceChangesLimit = Convert.ToInt32(MonitorSourceChangesLimit.Text);
if (!string.IsNullOrWhiteSpace(MonitorSourceTimeLimit.Text))
copy.CopyOptions.MonitorSourceTimeLimit = Convert.ToInt32(MonitorSourceTimeLimit.Text);
// select options
copy.SelectionOptions.OnlyCopyArchiveFiles = OnlyCopyArchiveFiles.IsChecked ?? false;
copy.SelectionOptions.OnlyCopyArchiveFilesAndResetArchiveFlag = OnlyCopyArchiveFilesAndResetArchiveFlag.IsChecked ?? false;
copy.SelectionOptions.IncludeAttributes = IncludeAttributes.Text;
copy.SelectionOptions.ExcludeAttributes = ExcludeAttributes.Text;
copy.SelectionOptions.ExcludeFiles = ExcludeFiles.Text;
copy.SelectionOptions.ExcludeDirectories = ExcludeDirectories.Text;
copy.SelectionOptions.ExcludeOlder = ExcludeOlder.IsChecked ?? false;
copy.SelectionOptions.ExcludeJunctionPoints = ExcludeJunctionPoints.IsChecked ?? false;
// retry options
if (!string.IsNullOrWhiteSpace(RetryCount.Text))
copy.RetryOptions.RetryCount = Convert.ToInt32(RetryCount.Text);
if (!string.IsNullOrWhiteSpace(RetryWaitTime.Text))
copy.RetryOptions.RetryWaitTime = Convert.ToInt32(RetryWaitTime.Text);
// logging options
copy.LoggingOptions.VerboseOutput = VerboseOutput.IsChecked ?? false;
copy.LoggingOptions.NoFileSizes = NoFileSizes.IsChecked ?? false;
copy.LoggingOptions.NoProgress = NoProgress.IsChecked ?? false;
copy.Start();
}
public bool SyncToCom(List <int> imageIds)
{
if (!ServiceSetting.GetSettingValue(SettingStrings.StorageType).Equals("SMB"))
{
return(true);
}
var guid = ConfigurationManager.AppSettings["ComServerUniqueId"];
var thisComServer = new ServiceClientComServer().GetServerByGuid(guid);
if (thisComServer == null)
{
Logger.Error($"Com Server With Guid {guid} Not Found");
return(false);
}
using (var unc = new UncServices())
{
if (unc.NetUseWithCredentials() || unc.LastError == 1219)
{
foreach (var imageId in imageIds)
{
var image = new ServiceImage().GetImage(imageId);
if (string.IsNullOrEmpty(image.Name))
{
continue;
}
var sourcePath = Path.Combine(ServiceSetting.GetSettingValue(SettingStrings.StoragePath), "images", image.Name);
var destPath = Path.Combine(thisComServer.LocalStoragePath, "images", image.Name).TrimEnd('\\');
using (RoboCommand backup = new RoboCommand())
{
// events
/*backup.OnFileProcessed += backup_OnFileProcessed;
* backup.OnCommandCompleted += backup_OnCommandCompleted;
* backup.OnCopyProgressChanged += Backup_OnCopyProgressChanged;
*/
backup.OnError += Backup_OnError;
// copy options
backup.CopyOptions.Source = sourcePath;
backup.CopyOptions.Destination = destPath;
backup.CopyOptions.CopySubdirectories = true;
backup.SelectionOptions.IncludeSame = true;
backup.CopyOptions.UseUnbufferedIo = true;
if (thisComServer.ReplicationRateIpg != 0)
{
backup.CopyOptions.InterPacketGap = thisComServer.ReplicationRateIpg;
}
else
{
backup.CopyOptions.InterPacketGap = 0;
}
// select options
backup.CopyOptions.Mirror = true;
backup.CopyOptions.Purge = true;
backup.LoggingOptions.VerboseOutput = false;
backup.SelectionOptions.ExcludeFiles = "guid";
// retry options
backup.RetryOptions.RetryCount = 3;
backup.RetryOptions.RetryWaitTime = 60;
backup.Start().Wait();
if (backup.Results.Status.ExitCodeValue == 0 || backup.Results.Status.ExitCodeValue == 1)
{
//backup succesful, copy the guid now
try
{
var guidPath = Path.Combine(sourcePath, "guid");
File.Copy(guidPath, destPath + Path.DirectorySeparatorChar + "guid");
}
catch (Exception ex)
{
Logger.Error(ex.Message);
Logger.Error("Could Not Replicate Image " + image.Name);
}
}
}
}
}
else
{
return(false);
}
}
return(true);
}
