internal override async Task <bool> OnUpdate(SafeDictionary <string, object> keys)
{
if (keys["noupdate"]?.ToString() == "1")
{
return(true);
}
_keys = keys;
ReportProgress("Fetching version information..");
_getAllVersionsResponse =
await
ServerRequestHelper.GetObjectFromServerAsync <GetAllVersionsResponse>(keys["hospitalserver"].ToString(),
"get_all_versions/");
if (!_getAllVersionsResponse.Success)
{
ReportProgress("Terminal registered in management but not in hospital server");
await Task.Delay(5000);
ProcessHelper.StartRegistrator(_keys["server"].ToString());
App.ShutdownSafe();
return(false);
}
var files = (await GetCoreFiles()).Concat(await GetPluginFiles()).ToList();
var corePath =
Path.GetFullPath(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\..\\");
var result = await CompareAndDownloadFileList(files, corePath, new[] { "cache.db" }, new[] { "txt", "csv" }, new [] { "Lib\\VLC\\x64", "Lib\\VLC\\x86" });
return(result);
}
async Task <List <CoreFile> > GetPluginFiles()
{
var path = Path.GetFullPath(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\..\\");
var count = _getAllVersionsResponse.Result.Plugins.Count;
var list = new List <CoreFile>();
foreach (var f in _getAllVersionsResponse.Result.Plugins)
{
ReportProgress(String.Format("Fetching information for {0}...", f.Name));
var files =
await
ServerRequestHelper.GetObjectFromServerAsync <List <CoreFile> >(_keys["hospitalserver"].ToString(),
"get_plugin_files/" + f.Name + "/" + f.Version + "/");
var pluginPath =
Path.GetFullPath(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) +
"\\..\\ibt-plugins\\" + f.Name + "\\");
foreach (var file in files.Result)
{
file.LocalPath = Path.GetFullPath(pluginPath + file.FileName);
}
list.AddRange(files.Result);// await CompareAndDownloadFileList(files.Result, pluginPath);
}
return(list);
//return true;
}
async Task <List <CoreFile> > GetCoreFiles()
{
var result = _getAllVersionsResponse.Result;
var coreVersion = result.CoreVersion.Version;
ReportProgress(String.Format("Fetching information for {0}...", "Core"));
var fileList =
await
ServerRequestHelper.GetObjectFromServerAsync <List <CoreFile> >(_keys["hospitalserver"].ToString(),
"get_core_files/core/" + coreVersion + "/");
if (fileList.Result == null)
{
throw new Exception("Bad result format from server");
}
var corePath =
Path.GetFullPath(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\..\\");
foreach (var file in fileList.Result)
{
file.LocalPath = Path.GetFullPath(corePath + file.FileName);
}
return(fileList.Result);
//return
}
internal async Task ReportToServer(string hospitalServer, string updateId, string packageId, int code)
{
await ServerRequestHelper.GetObjectFromServerAsync <object>(hospitalServer,
"update/result/", new
{
timestamp =
(long)
DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1, 0, 0, 0,
DateTimeKind.Utc))
.TotalMilliseconds,
updateId = updateId,
exitCode = code,
packageId = packageId
});
}
internal override async Task <bool> OnPreUpdate(SafeDictionary <string, object> keys)
{
ReportProgress("Identifying...");
int tries = 0;
while (await TerminalIdentificationManager.GetIdentificationInfoAsync() == null && tries < 10)
{
tries++;
await TerminalIdentificationManager.IdentifyAsync();
if (await TerminalIdentificationManager.GetIdentificationInfoAsync() == null)
{
await Task.Delay(30000);
}
}
if (await TerminalIdentificationManager.GetIdentificationInfoAsync() == null)
{
App.ShutdownSafe();
return(false);
}
keys["server"] = _server = (await PanaceaRegistry.GetServerInformation(false)).ManagementServer;
if (string.IsNullOrEmpty(_server))
{
ReportProgress("Please add a terminal server in registry...");
await Task.Delay(4000);
App.ShutdownSafe();
return(false);
}
//we can allow a failure to access TS if HS server is stored locally
BrowserSettingsHelper.UpdateSettings(new[] { "WebBrowser.SubProcess.exe", "Panacea.exe" });
ServerResponse <GetHospitalServersResponse> getHospitalServerResponse = null;
try
{
getHospitalServerResponse =
await
ServerRequestHelper.GetObjectFromServerAsync <GetHospitalServersResponse>(_server,
"get_hospital_servers/");
}
catch
{
getHospitalServerResponse =
(await PanaceaRegistry.GetServerInformation(false)).ManagementServerResponse;
}
if (getHospitalServerResponse == null)
{
throw new Exception("Terminal Server unreachable and no information stored in registry...");
}
if (!getHospitalServerResponse.Success)
{
if (getHospitalServerResponse.Error != "self destruct")
{
ReportProgress(getHospitalServerResponse.Error);
await Task.Delay(4000);
ProcessHelper.StartRegistrator(_server);
App.ShutdownSafe();
return(false);
}
var path = Path.GetFullPath(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) + "\\..\\");
foreach (var directory in Directory.GetDirectories(path))
{
try
{
if (!directory.EndsWith("\\Updater"))
{
Directory.Delete(directory, true);
}
}
catch
{
// ignored
}
}
foreach (var directory in Directory.GetFiles(path))
{
try
{
File.Delete(directory);
}
catch
{
// ignored
}
}
App.ShutdownSafe();
return(false);
}
if (!await UpdateRegistry(getHospitalServerResponse))
{
return(false);
}
keys["hospitalserver"] = _hospitalServer = getHospitalServerResponse.Result.HospitalServers[0];
if (string.IsNullOrEmpty(getHospitalServerResponse.Result.Crutch))
{
return(true);
}
_crutch = getHospitalServerResponse.Result.Crutch;
ReportProgress("Waiting for traffic controller... Please wait...");
var req =
BuildHttpRequest(
new Uri(new Uri(_crutch), "api/" + Common.GetMacAddress() + "/requestAccessLock/")
.ToString());
try
{
var resp = await req.GetHttpResponseAsync(120000);
if (resp.StatusCode != HttpStatusCode.Conflict && resp.StatusCode != HttpStatusCode.OK)
{
throw new WebException("Not conflict");
}
}
catch (WebException)
{
ReportProgress("Traffic controller unreachable... Please wait...");
await Task.Delay(new Random().Next(10000, 60000));
App.Restart();
return(false);
}
return(true);
}
internal override async Task <bool> OnAfterUpdate(SafeDictionary <string, object> keys)
{
if (Debugger.IsAttached)
{
if (MessageBox.Show("Install updates?", "Caution", MessageBoxButton.YesNo) == MessageBoxResult.No)
{
return(true);
}
}
ReportProgress("Installing Updates");
await Task.Delay(1000);
var dir = new DirectoryInfo(Common.Path() + "Updates");
if (!dir.Exists)
{
dir.Create();
}
var name = Environment.MachineName;
try
{
var resp =
await
ServerRequestHelper.GetObjectFromServerAsync <TerminalInfoResponse>(keys["hospitalserver"].ToString(),
"get_terminal_info/");
name = resp.Result.TerminalName;
}
catch
{
//maybe get_terminal_info not implemented - compatibility
}
var nameRequiresChange = name != Environment.MachineName;
////throw new Exception("Sfgfg");
var response =
await
ServerRequestHelper.GetObjectFromServerAsync <List <UpdatePackage> >(keys["hospitalserver"].ToString(), "get_terminal_updates/");
var updates = new List <Update>();
var freeze = FreezeHelper.IsFreezeEnabled();
if (!response.Success)
{
return(true);
}
if (nameRequiresChange)
{
if (await LockdownManager.IsFrozen() == true)
{
ReportProgress("Rebooting to unfreeze");
await Task.Delay(1500);
LockdownManager.Unfreeze();
App.ShutdownSafe(false);
return(true);
}
}
response.Result.ForEach(p => p.Updates.ForEach(u => u.PackageId = p.Id));
if (nameRequiresChange)
{
if (Debugger.IsAttached)
{
if (MessageBox.Show("Change hostname?", "Question", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
Common.SetMachineName(name);
}
}
else
{
Common.SetMachineName(name);
ReportProgress("Rebooting to change hostname");
await Task.Delay(3000);
ProcessHelper.Reboot();
return(true);
}
}
foreach (var package in response.Result)
{
ReportProgress(package.Name);
foreach (var update in package.Updates)
{
try
{
if (SkipUpdate(update.Id))
{
continue;
}
if (await LockdownManager.IsFrozen() == true)
{
ReportProgress("Rebooting to unfreeze");
await Task.Delay(1500);
LockdownManager.Unfreeze();
App.ShutdownSafe(false);
return(true);
}
updates.Add(update);
var tempPath = System.IO.Path.GetTempPath(); //C:\\Users\\<UserName>\\AppData\\Local\\Temp
var updateDir = new DirectoryInfo(tempPath + "PanaceaUpdates\\" + update.Id);
if (!updateDir.Exists)
{
updateDir.Create();
}
await _webClient.DownloadFileTaskAsync(
new Uri(keys["hospitalserver"] + "/" + update.PatchScript),
updateDir + "\\" + Path.GetFileName(update.PatchScript));
foreach (var file in update.RequiredFiles)
{
await _webClient.DownloadFileTaskAsync(
new Uri(keys["hospitalserver"] + "/" + file),
updateDir + "\\" + Path.GetFileName(file));
}
ReportProgress("Installing...");
var code = await Task.Run(() =>
{
var info = new ProcessStartInfo()
{
WorkingDirectory = updateDir.ToString(),
FileName = updateDir + "\\" + Path.GetFileName(update.PatchScript),
CreateNoWindow = true,
UseShellExecute = false,
Verb = "runas"
};
var p = new Process {
StartInfo = info
};
try
{
p.Start();
p.WaitForExit();
return(p.ExitCode);
}
catch
{
return(9001);
}
});
//OnProgressFiles(code == 0 ? "Installation successful!" : "Installation failed");
await Task.Delay(1000);
update.Installed = code == 0;
update.ExitCode = code;
if (code != 0)
{
continue;
}
AddRegistryUpdate(update);
await ReportToServer(keys["hospitalserver"].ToString(), update.Id, package.Id, code);
try
{
File.Delete(updateDir + "\\" + Path.GetFileName(update.PatchScript));
foreach (var file in update.RequiredFiles)
{
File.Delete(updateDir + "\\" + Path.GetFileName(file));
}
}
catch { }
if (update.RequiresReboot != "yes")
{
continue;
}
ProcessHelper.Reboot();
return(false);
}
catch
{
update.ExitCode = 9999;
AddRegistryUpdate(update);
await ReportToServer(keys["hospitalserver"].ToString(), update.Id, package.Id, 9999);
}
}
}
if (updates.All(u => u.ExitCode != 0))
{
foreach (var update in updates)
{
AddRegistryUpdate(update);
await ReportToServer(keys["hospitalserver"].ToString(), update.Id, update.PackageId, update.ExitCode);
}
}
if (updates.Any(u => u.RequiresReboot == "batch" && u.ExitCode == 0))
{
ReportProgress("Restarting...");
await Task.Delay(1500);
ProcessHelper.Reboot();
return(false);
}
if (updates.Any(u => u.ExitCode != 0) && updates.Any(u => u.ExitCode == 0))
{
ReportProgress("Rebooting to retry updates that failed...");
await Task.Delay(1500);
ProcessHelper.Reboot();
return(false);
}
if (await LockdownManager.IsFrozen() == false && freeze)
{
if (updates.All(u => u.ExitCode == 0) || updates.All(u => u.ExitCode != 0))
{
ReportProgress("Rebooting to freeze");
await Task.Delay(1500);
LockdownManager.Freeze();
}
App.ShutdownSafe(false);
return(false);
}
return(true);
}
internal override async Task <bool> OnAfterUpdate(SafeDictionary <string, object> keys)
{
if (Debugger.IsAttached)
{
return(true);
}
string hostsEntries = null;
try
{
hostsEntries = File.ReadAllText(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) +
"/AdBlock/hosts.txt");
} catch { }
try
{
hostsEntries = Start + Environment.NewLine + (await ServerRequestHelper.GetObjectFromServerAsync <string>(keys["hospitalserver"].ToString(),
"get_hosts_modifications/")).Result + Environment.NewLine + End;
}
catch { }
if (hostsEntries == null)
{
return(true);
}
try
{
ReportProgress("Updating domains...");
using (
var sr =
new StreamReader(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System),
"drivers/etc/hosts")))
{
var hosts = await sr.ReadToEndAsync();
sr.Close();
var index = hosts.IndexOf(Start, StringComparison.InvariantCulture);
if (index >= 0)
{
var endIndex = hosts.IndexOf(End, index, StringComparison.InvariantCulture);
hosts = hosts.Remove(index, endIndex + End.Length - index);
}
using (
var sw =
new StreamWriter(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System),
"drivers/etc/hosts")))
{
if (hosts.EndsWith(Environment.NewLine))
{
await sw.WriteAsync(hosts);
}
else
{
await sw.WriteLineAsync(hosts);
}
await sw.WriteLineAsync(hostsEntries);
}
}
}
catch
{
}
return(true);
}
