/// <summary> /// Delete one file in backup folder /// </summary> /// <param name="BackupFile">Backup file</param> private void DeleteFile ( FileInfo BackupFile ) { // log WriteToLogFile?.Invoke(LogControl.Log, "Delete: " + BackupFile.FullName); FormatAttributes(BackupFile.Attributes); try { // if file is read only, remove attribute if (BackupFile.IsReadOnly) { BackupFile.IsReadOnly = false; } // delete file BackupFile.Delete(); // update counter FileDeleteCounter++; } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Delete exception: " + Ex.Message); } return; }
/// <summary> /// Create single backup folder based on source folder info /// </summary> /// <param name="SourceFolder">Source folder</param> /// <param name="BackupFullName">Backup folder full name</param> private void CreateFolder ( DirectoryInfo SourceFolder, string BackupFullName ) { // log file WriteToLogFile?.Invoke(LogControl.Log, "Create folder: " + SourceFolder.FullName); FormatAttributes(SourceFolder.Attributes); try { // directory info for new backup folder DirectoryInfo BackupFolder = new DirectoryInfo(Path.Combine(BackupFullName, SourceFolder.Name)); // create new folder BackupFolder.Create(); // update counter FolderCreateCounter++; // get source child folders and files DirectoryInfo[] SourceSubFolders = SourceFolder.GetDirectories(); FileInfo[] SourceFiles = SourceFolder.GetFiles(); // source has files if (SourceFiles.Length != 0) { CopyFiles(SourceFiles, BackupFolder.FullName); } // source has folders if (SourceSubFolders.Length != 0) { CreateFolders(SourceSubFolders, BackupFolder.FullName); } // set hidden directory flag if ((SourceFolder.Attributes & FileAttributes.Hidden) != 0) { BackupFolder.Attributes |= FileAttributes.Hidden; } //if((SourceFolder.Attributes & FileAttributes.System) != 0) BackupFolder.Attributes |= FileAttributes.System; // set creation and last write time BackupFolder.CreationTimeUtc = SourceFolder.CreationTimeUtc; BackupFolder.LastWriteTimeUtc = SourceFolder.LastWriteTimeUtc; } catch (CanceBackupException) { throw; } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Create folder exception: " + Ex.Message); } return; }
/// <summary> /// Delete single folder /// </summary> /// <param name="BackupFolder">Backup folder</param> private void DeleteFolder ( DirectoryInfo BackupFolder ) { // get backup child files FileInfo[] BackupFiles = BackupFolder.GetFiles(); // delete all files in backup folder if (BackupFiles.Length != 0) { DeleteFiles(BackupFiles); } // backup folder has folders DirectoryInfo[] BackupSubFolders = BackupFolder.GetDirectories(); // delete all folders in backup folder if (BackupSubFolders.Length != 0) { DeleteFolders(BackupSubFolders); } // log file WriteToLogFile?.Invoke(LogControl.Log, "Delete folder: " + BackupFolder.FullName); FormatAttributes(BackupFolder.Attributes); try { if ((BackupFolder.Attributes & FileAttributes.ReadOnly) != 0) { BackupFolder.Attributes &= ~FileAttributes.ReadOnly; } // delete the empty backup folder BackupFolder.Delete(); // update counter FolderDeleteCounter++; } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Delete folder exception: " + Ex.Message); } return; }
/// <summary> /// Copy one file from source overriding existing file in backup /// </summary> /// <param name="SourceFile">Source file</param> /// <param name="BackupFullName">Backup directory full name</param> private void OverrideFile ( FileInfo SourceFile, FileInfo BackupFile ) { // log WriteToLogFile?.Invoke(LogControl.Log, "Update: " + SourceFile.FullName); FormatAttributes(SourceFile.Attributes); try { // if backup is read only, remove this flag if (BackupFile.IsReadOnly) { BackupFile.IsReadOnly = false; } // override backup with source string BackupFileName = Path.Combine(BackupFile.DirectoryName, SourceFile.Name); SourceFile.CopyTo(BackupFileName, true); // make sure creation time and last access are the same BackupFile = new FileInfo(BackupFileName); if (BackupFile.IsReadOnly) { BackupFile.IsReadOnly = false; BackupFile.CreationTimeUtc = SourceFile.CreationTimeUtc; BackupFile.LastAccessTimeUtc = SourceFile.LastAccessTimeUtc; BackupFile.IsReadOnly = true; } else { BackupFile.CreationTimeUtc = SourceFile.CreationTimeUtc; BackupFile.LastAccessTimeUtc = SourceFile.LastAccessTimeUtc; } // update counter FileOverrideCounter++; } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Update exception: " + Ex.Message); } return; }
/// <summary> /// Format file attributes for log file /// </summary> /// <param name="Attr"></param> private void FormatAttributes ( FileAttributes Attr ) { Attr &= ~FileAttributes.Archive; if (Attr == 0 || Attr == FileAttributes.Normal || Attr == FileAttributes.Directory) { return; } StringBuilder Str = new StringBuilder("Attributes:"); for (int Index = 0; Index < 18; Index++) { if ((Attr & (FileAttributes)(1 << Index)) != 0) { Str.Append(" " + FileAttrText[Index]); } } WriteToLogFile?.Invoke(LogControl.Log, Str.ToString()); }
/// <summary> /// Copy one file from source to backup (no override) /// </summary> /// <param name="SourceFile">Source file</param> /// <param name="BackupFullName">Backup directory full name</param> private void CopyFile ( FileInfo SourceFile, string BackupFullName ) { // log WriteToLogFile?.Invoke(LogControl.Log, "Copy: " + SourceFile.FullName); FormatAttributes(SourceFile.Attributes); try { // copy file to backup string BackupFileName = Path.Combine(BackupFullName, SourceFile.Name); SourceFile.CopyTo(BackupFileName); // make sure creation time and last access are the same FileInfo BackupFile = new FileInfo(BackupFileName); if (BackupFile.IsReadOnly) { BackupFile.IsReadOnly = false; BackupFile.CreationTimeUtc = SourceFile.CreationTimeUtc; BackupFile.LastAccessTimeUtc = SourceFile.LastAccessTimeUtc; BackupFile.IsReadOnly = true; } else { BackupFile.CreationTimeUtc = SourceFile.CreationTimeUtc; BackupFile.LastAccessTimeUtc = SourceFile.LastAccessTimeUtc; } // update counter FileCopyCounter++; } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Copy exception: " + Ex.Message); } return; }
/// <summary> /// recursive folder backup /// </summary> /// <param name="SourceFolderName">Source folder name</param> /// <param name="BackupFolderName">Backup folder name</param> private void PerformFolderBackup ( DirectoryInfo SourceFolderInfo, DirectoryInfo BackupFolderInfo ) { // cancel backup if (BackupWorker.CancellationPending) { throw new CanceBackupException(); } // backup folder full name shortcut string BackupFolderFullName = BackupFolderInfo.FullName; // get source child files FileInfo[] SourceFiles; try { SourceFiles = SourceFolderInfo.GetFiles(); } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Source folder get files exception: " + Ex.Message); SourceFiles = new FileInfo[0]; } // get backup child files FileInfo[] BackupFiles = BackupFolderInfo.GetFiles(); // source has files if (SourceFiles.Length != 0) { // backup has files if (BackupFiles.Length != 0) { // backup has files EqualizeFiles(SourceFiles, BackupFiles, BackupFolderFullName); } // backup has no files else { // copy all source files to backup folder CopyFiles(SourceFiles, BackupFolderFullName); } } // source has no files but backup has files else if (BackupFiles.Length != 0) { // delete all files of backup folder DeleteFiles(BackupFiles); } // get source child folders DirectoryInfo[] SourceFolders; try { SourceFolders = SourceFolderInfo.GetDirectories(); } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Source folder get folders exception: " + Ex.Message); SourceFolders = new DirectoryInfo[0]; } // get backup child folders DirectoryInfo[] BackupFolders = BackupFolderInfo.GetDirectories(); // source has folders if (SourceFolders.Length != 0) { // backup has folders if (BackupFolders.Length != 0) { // backup has folders EqualizeFolders(SourceFolders, BackupFolders, BackupFolderFullName); } // backup has no folders else { // copy all source child folders to backup folder CreateFolders(SourceFolders, BackupFolderFullName); } } // source has no folders but backup has folders else if (BackupFolders.Length != 0) { // delete all files of backup folder DeleteFolders(BackupFolders); } // done return; }
/// <summary> /// Backup one folder /// </summary> /// <param name="SourceFolderName">Source folder name</param> /// <param name="BackupFolderName">Backup folder name</param> private void FolderBackup ( string SourceFolderName, string BackupFolderName ) { // get source folder information DirectoryInfo SourceFolderInfo; try { SourceFolderInfo = new DirectoryInfo(SourceFolderName); } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Source folder exception " + Ex.Message); return; } // save full name SourceFolderFullName = SourceFolderInfo.FullName; // make sure folder exist if (!SourceFolderInfo.Exists) { WriteToLogFile?.Invoke(LogControl.Error, "Source folder does not exist " + SourceFolderFullName); return; } // make sure folder is not a root if (SourceFolderFullName == SourceFolderInfo.Root.FullName) { WriteToLogFile?.Invoke(LogControl.Error, "Source folder cannot be a root folder " + SourceFolderFullName); return; } // get backup folder information DirectoryInfo BackupFolderInfo; try { BackupFolderInfo = new DirectoryInfo(BackupFolderName); } catch (Exception Ex) { WriteToLogFile?.Invoke(LogControl.Error, "Backup folder exception " + Ex.Message); return; } // save full name BackupFolderFullName = BackupFolderInfo.FullName; // make sure folder exist if (!BackupFolderInfo.Exists) { WriteToLogFile?.Invoke(LogControl.Error, "Backup folder does not exist " + BackupFolderFullName); return; } // make sure folder is not a root if (BackupFolderFullName == BackupFolderInfo.Root.FullName) { WriteToLogFile?.Invoke(LogControl.Error, "Backup folder cannot be a root folder " + BackupFolderFullName); return; } // make sure one is not child of the other if (SourceFolderFullName.Length >= BackupFolderFullName.Length) { if (SourceFolderFullName.StartsWith(BackupFolderFullName)) { WriteToLogFile?.Invoke(LogControl.Error, "Source folder " + SourceFolderFullName + "\r\ncannot be a child of backup folder " + BackupFolderFullName); return; } } else { if (BackupFolderFullName.StartsWith(SourceFolderFullName)) { WriteToLogFile?.Invoke(LogControl.Error, "Backup folder " + BackupFolderFullName + "\r\ncannot be a child of source folder " + SourceFolderFullName); return; } } // perform recursive backup PerformFolderBackup(SourceFolderInfo, BackupFolderInfo); return; }