public static void DeleteFiles(ArrayList toDelete, bool isTemp)
{
if (toDelete == null)
{
return;
}
for (int i = 0; i < toDelete.Count; i++)
{
RemoteFile rm = (RemoteFile)toDelete[i];
if (!rm.Valid || rm.IsStarterReplacer)
{
continue;
}
string path = rm.GetPath(isTemp);
try
{
if (Utils.DeleteFile(path))
{
RawLog.Default.Log("Del " + path);
}
string dir = Path.GetDirectoryName(path);
Utils.DeleteEmptyDir(dir, true);
}
catch (Exception xx) { Utils.OnError(xx); }
}
}
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 GetNewFiles(ArrayList localFiles, ArrayList remoteFiles, bool checkOnlyPath, bool isTemp)
{
if ((remoteFiles == null) || (remoteFiles.Count <= 0))
{
return(null);
}
if ((localFiles == null) || (localFiles.Count <= 0))
{
return(remoteFiles);
}
ArrayList newFiles = new ArrayList();
for (int i = 0; i < remoteFiles.Count; i++)
{
RemoteFile rm = (RemoteFile)remoteFiles[i];
bool found = false;
for (int j = 0; j < localFiles.Count; j++)
{
RemoteFile lc = (RemoteFile)localFiles[j];
bool sameFile = false;
bool sameVersion = false;
bool sameName = lc.IsSamePathFile(rm, ref sameVersion);
if (checkOnlyPath)
{
sameFile = lc.name.Equals(rm.name);
}
else
{
sameFile = lc.IsSameFile(rm);
}
if (sameFile)
{
if (checkOnlyPath)
{
found = true;
}
else
{
string file = rm.GetPath(isTemp);
bool exists = File.Exists(file);
if (exists)
{
if (rm.ValidateSize(file))
{
if (rm.ShouldCheckCrc)
{
if (Crc.HashFile(file, false).ToLower().Equals(rm.crc))
{
found = true;
}
}
else
{
found = true;
}
}
}
else
{
// handle partial files
string tempFile = HttpGetter.GetTempFilePath(file);
bool tempExists = File.Exists(tempFile);
if (tempExists)
{
if (rm.IsSizeValid())
{
if (rm.ValidateSize(tempFile))
{
if (rm.ShouldCheckCrc)
{
if (Crc.HashFile(tempFile, false).ToLower().Equals(rm.crc))
{
File.Move(tempFile, file);
found = true;
}
else
{
Utils.DeleteFile(tempFile);
}
}
else
{
File.Move(tempFile, file);
found = true;
}
}
}
}
}
}
break;
}
else
{
if (sameName && !sameVersion)
{
string file = rm.GetPath(isTemp);
Utils.DeleteFile(HttpGetter.GetTempFilePath(file));
}
}
}
if (!found)
{
newFiles.Add(rm);
}
}
return(newFiles);
}