/// <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;
}
public static bool CheckMachine(string Machine)
{
if ((String.IsNullOrEmpty(Machine)))
{
WriteToLogFile.writeMessage("Machine Name Received null");
}
bool Check = false;
try
{
//WriteToLogFile.writeMessage("Check Machine [Started]");
using (CBDB db = new CBDB())
{
//WriteToLogFile.writeMessage("Connection With DB Created");
var mobj = db.tbl_MachineInfo.Where(x => x.MachineName.Equals(Machine)).FirstOrDefault();
if (mobj == null)
{
//WriteToLogFile.writeMessage("No machine is present with this name");
//WriteToLogFile.writeMessage("Creating New Machine Entry in DB");
tbl_MachineInfo obj = new tbl_MachineInfo();
obj.MachineName = Machine;
obj.CreatedTs = DateTime.Now;
obj.IsActive = true;
///WriteToLogFile.writeMessage("Adding Entry in Table");
db.tbl_MachineInfo.Add(obj);
// WriteToLogFile.writeMessage("Entry Added Successfully in Table");
db.SaveChanges();
//WriteToLogFile.writeMessage("Changes Saved Successfully");
Check = true;
}
else if (mobj.IsActive == false)
{
// WriteToLogFile.writeMessage("Machine Already present but with is asctive as false");
mobj.IsActive = true;
mobj.CreatedTs = DateTime.Now;
//WriteToLogFile.writeMessage("Saving Changes to DB");
db.SaveChanges();
//WriteToLogFile.writeMessage("Changes Saved Successfully");
Check = true;
}
else
{
//WriteToLogFile.writeMessage("Machine Already present and with is asctive as True");
//WriteToLogFile.writeMessage("Checking Time Difference");
int TimeDiff = Convert.ToInt32(ConfigurationManager.AppSettings["TimeDiff"].ToString());
//WriteToLogFile.writeMessage("Time Diff = "+TimeDiff.ToString());
int diff = (DateTime.Now - Convert.ToDateTime(mobj.CreatedTs)).Minutes;
///WriteToLogFile.writeMessage("diff in minutes "+diff.ToString());
if (diff >= TimeDiff)
{
// WriteToLogFile.writeMessage("Machine Time out reached to maximun updating is active to true");
mobj.IsActive = true;
mobj.CreatedTs = DateTime.Now;
//WriteToLogFile.writeMessage("Saving Changes to DB");
db.SaveChanges();
//WriteToLogFile.writeMessage("Changes Saved Successfully");
Check = true;
}
else
{
// WriteToLogFile.writeMessage("Cannot activate machine because time out not reached");
}
}
}
}
catch (Exception Ex)
{
//throw Ex;
// WriteToLogFile.writeMessage("Exception Occured While processing this method exception msg = " + Ex.Message.ToString());
}
//WriteToLogFile.writeMessage("Returned Check Value "+Check.ToString());
return(Check);
}
