public static void Register(ArrayList f, bool on)
{
if (Config.Default.IsRemovableDiskType)
{
return;
}
if ((f == null) || (f.Count <= 0))
{
return;
}
for (int i = 0; i < f.Count; i++)
{
FileAssoc fa = (FileAssoc)f[i];
if (fa == null)
{
continue;
}
try
{
fa.Register(on);
}
catch (Exception xx) { Utils.OnError(xx); }
}
try
{
FileAssocWin.NotifyShell();
}
catch (Exception xx) { Utils.OnError(xx); }
}
public bool IsEqual(FileAssoc other)
{
if (this.extension != other.extension)
{
return(false);
}
if (this.progId != other.progId)
{
return(false);
}
if (this.desc != other.desc)
{
return(false);
}
if (this.exePath != other.exePath)
{
return(false);
}
if (this.iconPath != other.iconPath)
{
return(false);
}
if (this.iconIdx != other.iconIdx)
{
return(false);
}
return(true);
}
private static void InitLocalFiles()
{
localFiles = null;
localFileAsocs = new ArrayList();
try
{
string path = Config.Default.GetFileListPath(false);
if (File.Exists(path))
{
localFiles = RemoteFile.Load(path, ref localFileAsocs);
if ((localFileAsocs != null) && (localFileAsocs.Count > 0))
{
string currentStarterExePath = System.Windows.Forms.Application.ExecutablePath;
string np = Config.Default.KeyStore.GetString(KeyStoreIds.StarterLastPathS, null, false);
if (np == null)
{
Config.Default.KeyStore.SetString(KeyStoreIds.StarterLastPathS, currentStarterExePath, true);
}
else if (!np.Equals(currentStarterExePath))
{
Config.Default.KeyStore.SetString(KeyStoreIds.StarterLastPathS, currentStarterExePath, true);
RawLog.Default.Log("!path");
FileAssoc.Register(localFileAsocs, true);
}
}
}
}
catch (Exception ex)
{
localFiles = new ArrayList();
throw ex;
}
}
public static bool AreEqual(ArrayList f1, ArrayList f2)
{
if ((f1 == null) && (f2 == null))
{
return(true);
}
if ((f1 == null) && (f2.Count == 0))
{
return(true);
}
if ((f2 == null) && (f1.Count == 0))
{
return(true);
}
if (f1 == null)
{
return(false);
}
if (f2 == null)
{
return(false);
}
if ((f1.Count == 0) && (f2.Count == 0))
{
return(true);
}
if (f1.Count != f2.Count)
{
return(false);
}
for (int i = 0; i < f1.Count; i++)
{
FileAssoc fa = (FileAssoc)f1[i];
bool found = false;
for (int j = 0; j < f2.Count; j++)
{
if (((FileAssoc)f2[j]).IsEqual(fa))
{
found = true;
}
}
if (!found)
{
return(false);
}
}
return(true);
}
public static void KillApp(bool killSelf, bool unregister)
{
ArrayList files = null;
ArrayList filesAsoc = new ArrayList();
try
{
files = RemoteFile.Load(Config.Default.GetFileListPath(false), ref filesAsoc);
}
catch (Exception xx) { Utils.OnError(xx); }
RemoteFile.Start(files, true);
if (unregister)
{
try
{
FileAssoc.Register(filesAsoc, false);
}
catch (Exception xx) { Utils.OnError(xx); }
}
if (killSelf)
{
Utils.KillProcess(Path.GetFileNameWithoutExtension(Application.ExecutablePath));
}
}
public void DoWork(Monitor m, bool callStart, DBeforeCallStart beforeCallStart)
{
// check time interval if not gui
if (!callStart && !CanCheckServer())
{
return;
}
// clean up temp dir as neccesary
string remoteFilesList = Config.Default.GetFileListPath(true);
ArrayList remoteCurrentFiles = null;
ArrayList remoteCurrentFilesAsoc = new ArrayList();
if (File.Exists(remoteFilesList))
{
try
{
remoteCurrentFiles = RemoteFile.Load(remoteFilesList, ref remoteCurrentFilesAsoc);
}
catch (Exception ex)
{
RawLog.Default.Log(ex.Message, true);
Config.Default.NewVersionFileTag = false;
string tempDir = Config.Default.GetPath(null, true, true);
Utils.DeleteDir(tempDir);
}
}
// get data from server
if (m != null)
{
m.Log(Str.Def.Get(Str.Connecting));
}
long lastTimeTicks = Config.Default.KeyStore.GetLong(KeyStoreIds.RemoteFilesLastDateL, DateTime.MinValue.Ticks, false);
if (!GetRemoteVersion(m, ref lastTimeTicks))
{
if ((m != null) && m.ShouldStop())
{
return;
}
SetLastCheckDate(lastTimeTicks);
if (Config.Default.updateBeforeStart)
{
if (callStart)
{
if (beforeCallStart != null)
{
beforeCallStart();
}
if (Local.Start())
{
throw new Exception("Nothing to execute");
}
if (m != null)
{
m.Log(string.Empty);
}
}
}
return;
}
if ((m != null) && m.ShouldStop())
{
return;
}
if (remoteFiles == null)
{
throw new Exception(Str.Def.Get(Str.RemoteError));
}
ArrayList newRemoteFiles = this.remoteFiles;
if ((remoteCurrentFiles != null) && (remoteCurrentFiles.Count > 0))
{
newRemoteFiles = RemoteFile.GetNewFiles(remoteCurrentFiles, this.remoteFiles, false, true);
ArrayList tempFileToDelete = RemoteFile.GetRemovedFiles(remoteCurrentFiles, this.remoteFiles, true);
RemoteFile.DeleteFiles(tempFileToDelete, true);
}
if ((m != null) && m.ShouldStop())
{
return;
}
//string tempDir = Config.Default.GetPath(null, true, true);
//Utils.DeleteDir(tempDir);
ArrayList files = RemoteFile.GetNewFiles(Local.localFiles, newRemoteFiles); // this.remoteFiles
if ((files == null) || (callStart && (files.Count <= 0)))
{
throw new Exception(Str.Def.Get(Str.RemoteError));
}
if (files.Count <= 0)
{
RemoteFile.Save(Config.Default.GetFileListPath(true), this.remoteFiles, this.remoteFileAsocs);
SetLastCheckDate(lastTimeTicks);
ArrayList toDelete = RemoteFile.GetRemovedFiles(Local.localFiles, this.remoteFiles, false);
bool newAssoc = !FileAssoc.AreEqual(Local.localFileAsocs, this.remoteFileAsocs);
if (newAssoc || ((toDelete != null) && (toDelete.Count > 0)))
{
Config.Default.NewVersionFileTag = true;
}
//if (m != null) m.Log(Str.Def.Get(Str.NothingToDo));
return;
}
// invalidate current update if any
Config.Default.NewVersionFileTag = false;
RemoteFile.Save(Config.Default.GetFileListPath(true), remoteFiles, this.remoteFileAsocs);
// delete new files in any, and check for space
RemoteFile.DeleteFiles(files, true);
long outSize = 0;
if (!RemoteFile.CheckDiskSpace(files, ref outSize))
{
throw new Exception(Str.Def.Get(Str.NoSpace) + " " + Utils.SizeStr(outSize));
}
if (m != null)
{
m.Log("(" + files.Count.ToString(System.Globalization.CultureInfo.InvariantCulture) + ")");
}
bool isStarter = false;
for (int i = 0; i < files.Count; i++)
{
if ((m != null) && m.ShouldStop())
{
return;
}
RemoteFile rm = (RemoteFile)files[i];
isStarter = rm.IsStarterReplacer;
if (isStarter)
{
Config.Default.StarterNewVersion = Config.Default.StarterLastVersion;
}
if ((m != null) && m.ShouldStop())
{
return;
}
string msgRaw = "[" + (i + 1) + " / " + files.Count + "] " + rm.DisplayName;
string msg = msgRaw;
if (Config.Default.ReportFileSize && rm.IsSizeValid())
{
msg += " " + Utils.SizeStr(rm.size);
}
m.Log(msg);
using (HttpGetter hg = new HttpGetter())
{
hg.Init(rm);
string outFile = rm.GetPath(true);
try
{
hg.Dump(outFile, m, msgRaw);
}
catch (Exception ex)
{
Utils.DeleteFile(outFile);
throw ex;
}
finally
{
hg.Dispose();
}
if ((m != null) && m.ShouldStop())
{
Utils.DeleteFile(outFile);
break;
}
// file ok
if (isStarter)
{
RawLog.Default.Log("snver " + rm.version);
Config.Default.StarterNewVersion = rm.version;
}
}
}
if ((m != null) && m.ShouldStop())
{
return;
}
// normal finish
RemoteFile.Save(Config.Default.GetFileListPath(true), remoteFiles, this.remoteFileAsocs); // again
SetLastCheckDate(lastTimeTicks);
if (isStarter && (files.Count == 1))
{
//nothing new
}
else
{
Config.Default.NewVersionFileTag = true;
}
if (callStart)
{
if (beforeCallStart != null)
{
beforeCallStart();
}
if (Local.Start())
{
throw new Exception("Nothing to execute");
}
if (m != null)
{
m.Log(string.Empty);
}
}
else
{
if (Config.Default.NewVersionFileTag)
{
//if (m != null) m.Log(Str.Def.Get(Str.RestartNeeded));
}
}
}
public static ArrayList Load(StreamReader sr, ref ArrayList fileAssoc)
{
if (fileAssoc == null)
{
fileAssoc = new ArrayList();
}
fileAssoc.Clear();
ArrayList files = new ArrayList();
Hashtable variables = new Hashtable();
string crc = string.Empty;
Crc hash = new Crc(true);
for (string line = sr.ReadLine(); line != null; line = sr.ReadLine())
{
line = line.Trim(' ', '\t', '\r', '\n');
if (string.IsNullOrEmpty(line))
{
continue;
}
else if (line.StartsWith(Crc.Prefix))
{
crc = line.Substring(Crc.Prefix.Length);
continue;
}
else if (line.StartsWith("#") && !line.StartsWith("##"))
{
continue;
}
else if (line.StartsWith("$$"))
{
int idx = line.IndexOf('=');
if (idx < 0)
{
continue;
}
string key = line.Substring(1, idx - 1).Trim();
string val = line.Substring(idx + 1).Trim();
variables[key] = val;
continue;
}
foreach (string k in variables.Keys)
{
line = line.Replace(k, (string)variables[k]);
}
if (line.StartsWith(FileAssoc.Prefix))
{
FileAssoc fa = new FileAssoc();
fa.FromString(line);
if (fa.Valid)
{
hash.Update(fa.ToString());
fileAssoc.Add(fa);
}
continue;
}
RemoteFile rm = new RemoteFile();
rm.Init(line);
if (rm.Valid)
{
// add starter only if new
if (rm.IsStarterReplacer)
{
if (rm.version.Equals(Config.Default.StarterLastVersion))
{
continue;
}
else
{
string newExePath = Config.Default.GetNewStarterPath();
if (File.Exists(newExePath))
{
string newExeVersion = Config.Default.StarterNewVersion;
if (newExeVersion.Equals(rm.version))
{
// already downloaded this starter version
continue;
}
}
}
}
hash.Update(rm.ToString());
files.Add(rm);
}
}
if (!string.IsNullOrEmpty(crc))
{
string newCrc = hash.GetValue();
if (!crc.ToLower().Equals(newCrc))
{
throw new Exception(Str.Def.Get(Str.FailedCrc));
}
}
return(files);
}
// false if replace needed but could not get lock
public static bool ReplaceFiles()
{
ExclusiveLocker replaceLock = new ExclusiveLocker();
replaceLock.id = Local.ReplaceLockId;
try
{
if (!replaceLock.Lock(0))
{
return(false);
}
if (!Config.Default.NewVersionFileTag)
{
return(true);
}
RawLog.Default.Log("rep>");
string tempDir = Config.Default.GetPath(null, true, true);
string workingDir = Config.Default.GetPath(null, false, true);
if (!Directory.Exists(tempDir))
{
Config.Default.NewVersionFileTag = false;
return(true);
}
if (!Utils.CheckFullAccess(workingDir))
{
RawLog.Default.Log("!work");
return(true);
}
if (!Utils.CheckFullAccess(tempDir))
{
RawLog.Default.Log("!temp");
return(true);
}
ArrayList localFilesTmp = null;
ArrayList remoteFilesTmp = null;
ArrayList localFilesAsocTmp = new ArrayList();
ArrayList remoteFilesAsocTmp = new ArrayList();
string localFileTmp = Config.Default.GetFileListPath(false);
string remoteFileTmp = Config.Default.GetFileListPath(true);
bool localExits = File.Exists(localFileTmp);
bool remoteExits = File.Exists(remoteFileTmp);
try
{
if (localExits && remoteExits)
{
localFilesTmp = RemoteFile.Load(localFileTmp, ref localFilesAsocTmp);
remoteFilesTmp = RemoteFile.Load(remoteFileTmp, ref remoteFilesAsocTmp);
}
}
catch (Exception xx) { Utils.OnError(xx); }
// copy / replace new files
//Utils.DeleteDir(workingDir);
//Directory.Move(tempDir, workingDir);
Utils.CopyReplaceFiles(tempDir, workingDir);
InitLocalFiles();
// delete removed files
try
{
if (localExits && remoteExits)
{
ArrayList toDelete = RemoteFile.GetRemovedFiles(localFilesTmp, remoteFilesTmp, false);
RemoteFile.DeleteFiles(toDelete, false);
}
}
catch (Exception xx) { Utils.OnError(xx); }
// set file associations
if (!FileAssoc.AreEqual(localFilesAsocTmp, localFileAsocs))
{
try
{
FileAssoc.Register(localFilesAsocTmp, false);
}
catch (Exception xx) { Utils.OnError(xx); }
try
{
FileAssoc.Register(localFileAsocs, true);
}
catch (Exception xx) { Utils.OnError(xx); }
}
RawLog.Default.Log("rep<");
Config.Default.NewVersionFileTag = false;
}
finally
{
replaceLock.Dispose();
}
return(true);
}