void pollDownloadSettingsFile(Settings settings)
{
try
{
string file = downloadFolder + Path.DirectorySeparatorChar + PathRoutines.GetFileName(settings.__Info.File);
if (!File.Exists(file))
{
return;
}
DateTime downloadLWT = File.GetLastWriteTime(file);
if (downloadLWT.AddSeconds(100) > DateTime.Now)//it is being written
{
return;
}
if (File.Exists(settings.__Info.File) && downloadLWT <= File.GetLastWriteTime(settings.__Info.File))
{
return;
}
copy(file, settings.__Info.File);
onNewerSettingsFile(settings);
}
catch (Exception e)
{
ErrorHandler(e);
}
}
void pollUploadSettingsFile(Settings settings)
{
try
{
if (!File.Exists(settings.__Info.File))
{
return;
}
DateTime uploadLWT = File.GetLastWriteTime(settings.__Info.File);
if (uploadLWT.AddSeconds(10) > DateTime.Now)//it is being written
{
return;
}
string file2 = uploadFolder + Path.DirectorySeparatorChar + PathRoutines.GetFileName(settings.__Info.File);
if (File.Exists(file2) && uploadLWT <= File.GetLastWriteTime(file2))
{
return;
}
copy(settings.__Info.File, file2);
}
catch (Exception e)
{
ErrorHandler(e);
}
}
public static void CopyDirectory(string directory1, string directory2, bool overwrite = false)
{
if (!Directory.Exists(directory2))
{
Directory.CreateDirectory(directory2);
}
foreach (string file in Directory.GetFiles(directory1))
{
File.Copy(file, directory2 + Path.DirectorySeparatorChar + PathRoutines.GetFileName(file), overwrite);
}
foreach (string d in Directory.GetDirectories(directory1))
{
CopyDirectory(d, directory2 + Path.DirectorySeparatorChar + PathRoutines.GetDirName(d), overwrite);
}
}
/// <summary>
/// Copies storage files of all the Settings fields in the application to the specified directory.
/// </summary>
/// <param name="toDirectory">folder where files are to be copied</param>
static public void ExportStorageFiles(string toDirectory)
{
lock (settingsFieldFullNames2SettingsFieldInfo)
{
foreach (SettingsFieldInfo sfi in EnumSettingsFieldInfos())
//foreach (SettingsFieldInfo sfi in settingsFieldFullNames2SettingsFieldInfo.Values)
{
string file2 = toDirectory + System.IO.Path.DirectorySeparatorChar + PathRoutines.GetFileName(sfi.File);
if (File.Exists(sfi.File))//it can be absent if default settings are used still
{
File.Copy(sfi.File, file2);
}
else if (File.Exists(sfi.InitFile))
{
File.Copy(sfi.InitFile, file2);
}
else
{
Settings s = Settings.Create(sfi, true, true);
s.Save();
File.Move(sfi.File, file2);
}
}
}
}
void polling()
{
try
{
while (parameters.Synchronize)
{
foreach (string ssfn in synchronizedSettingsFieldFullNames)
{
SettingsFieldInfo sfi = Config.GetSettingsFieldInfo(ssfn);
Settings settings = sfi.GetObject();
if (settings == null)
{
continue;
}
pollDownloadSettingsFile(settings);
pollUploadSettingsFile(settings);
}
//foreach (Type sst in synchronizedSettingsTypes)
//{
// List<SettingsFieldInfo> sfis = Config.GetSettingsFieldInfos(sst);
// if (sfis.Count < 1)
// throw new Exception("Settings type " + sst.FullName + " was not found.");
// foreach (SettingsFieldInfo sfi in sfis)
// {
// Settings settings = sfi.GetObject();
// if (settings == null)
// continue;
// pollUploadSettingsFile(settings);
// pollDownloadSettingsFile(settings);
// }
//}
if (synchronizedFolders != null)
{
foreach (SynchronizedFolder sf in synchronizedFolders)
{
string synchronizationFolder = downloadFolder + Path.DirectorySeparatorChar + sf.SynchronizationFolderName;
if (Directory.Exists(synchronizationFolder))
{
foreach (string file in Directory.GetFiles(synchronizationFolder))
{
if (sf.FileNameFilter.IsMatch(PathRoutines.GetFileName(file)) == false)
{
continue;
}
try
{
DateTime downloadLWT = File.GetLastWriteTime(file);
if (downloadLWT.AddSeconds(100) > DateTime.Now)//it is being written
{
return;
}
string file2 = sf.Folder + Path.DirectorySeparatorChar + PathRoutines.GetFileName(file);
if (File.Exists(file2) && downloadLWT <= File.GetLastWriteTime(file2))
{
return;
}
copy(file, file2);
onNewerFile(file);
}
catch (Exception e)
{
ErrorHandler(e);
}
}
}
foreach (string file in Directory.GetFiles(sf.Folder))
{
if (sf.FileNameFilter.IsMatch(PathRoutines.GetFileName(file)) == false)
{
continue;
}
try
{
DateTime uploadLWT = File.GetLastWriteTime(file);
if (uploadLWT.AddSeconds(10) > DateTime.Now)//it is being written
{
return;
}
string file2 = FileSystemRoutines.CreateDirectory(uploadFolder + Path.DirectorySeparatorChar + sf.SynchronizationFolderName) + Path.DirectorySeparatorChar + PathRoutines.GetFileName(file);
if (File.Exists(file2) && uploadLWT <= File.GetLastWriteTime(file2))
{
return;
}
copy(file, file2);
}
catch (Exception e)
{
ErrorHandler(e);
}
}
}
}
string appSetupFile = null;
foreach (string file in Directory.GetFiles(appSetupFolder))
{
Match m = appSetupFileFilter?.Match(file);
if (m?.Success != true)
{
continue;
}
if (!Version.TryParse(m.Groups[1].Value, out Version v))
{
continue;
}
if (v > programVersion && v > lastAppVersion)
{
lastAppVersion = v;
appSetupFile = file;
}
}
if (appSetupFile != null)
{
AppNewSetupFile = appSetupFile;
onNewerAppVersion(appSetupFile);
return;
}
Thread.Sleep(parameters.PollingPeriodMss);
}
}
catch (Exception e)
{
ErrorHandler(new Exception("Synchronization thread exited due to exception.", e));
}
}
static public void CopyFiles(string toDirectory)
{
lock (objectFullNames2serializable)
{
string d = FileSystemRoutines.CreateDirectory(toDirectory + System.IO.Path.DirectorySeparatorChar + CONFIG_FOLDER_NAME);
foreach (Serializable s in objectFullNames2serializable.Values)
{
if (File.Exists(s.__File))//it can be absent if default settings are used still
{
File.Copy(s.__File, d + System.IO.Path.DirectorySeparatorChar + PathRoutines.GetFileName(s.__File));
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="unknownTypeStorageDir">only unknown Serializable types will be saved to a new location</param>
static public void Save(string unknownTypeStorageDir = null)
{
if (unknownTypeStorageDir != null)
{
if (ReadOnly && PathRoutines.ArePathsEqual(unknownTypeStorageDir, UnknownTypeStorageDir))
{
throw new Exception("Config is read-only and cannot be saved to the same location: " + unknownTypeStorageDir);
}
}
UnknownTypeStorageDir = unknownTypeStorageDir;
lock (objectFullNames2serializable)
{
foreach (Serializable s in objectFullNames2serializable.Values)
{
if (s is AppSettings)
{
s.Save(AppSettings.StorageDir + System.IO.Path.DirectorySeparatorChar + PathRoutines.GetFileName(s.__File));
}
else if (s is UserSettings)
{
s.Save(UserSettings.StorageDir + System.IO.Path.DirectorySeparatorChar + PathRoutines.GetFileName(s.__File));
}
else
{
s.Save(UnknownTypeStorageDir + System.IO.Path.DirectorySeparatorChar + PathRoutines.GetFileName(s.__File));
}
}
}
}
static public string GetNameWithExtension(Process p = null)
{
return(PathRoutines.GetFileName(GetFile(p)));
}
