public override void executeAction(actionBase Action) {
try {
var updateFiles =
new List<string>(Directory.GetFiles(currentConfiguration.Settings.downloadLocation, "*",
SearchOption.AllDirectories));
int fileCounter = 0;
foreach (string file in updateFiles) {
try {
onProgressChanged(string.Format(Language.GetString("applyCleanupAction_progress"), Path.GetFileName(file)),
Percent(fileCounter, updateFiles.Count));
fileCounter++;
File.Delete(file);
}
catch {
continue;
}
}
//Alte Updatedateien löschen
cleanObsoleteData();
//Aktuelle Installation zur liste alter Daten hinzufügen
writeObsoleteData();
}
catch {
return;
}
}
public override void executeAction(actionBase Action) {
var action = (closeProcessAction) Action;
//using (UI.Forms.dlgOpenProcesses dlg = new updateSystemDotNet.Updater.UI.Forms.dlgOpenProcesses(action.processList.ToArray()))
//{
// if (dlg.ShowDialog() != System.Windows.Forms.DialogResult.OK)
// {
// throw new Exception("Ein oder mehrere Prozesse konnten nicht beendet werden weshalb der Updatevorgang abgebrochen werden musste.");
// }
//}
foreach (string processItem in action.processList) {
Process[] processes = Process.GetProcessesByName(processItem);
if (processes.Length > 0) {
foreach (Process process in processes) {
try {
process.CloseMainWindow();
process.WaitForExit(5000);
process.Kill();
}
catch (Exception) {
/* TODO: Unbedingt noch was wegen ner gescheiten Fehlerbehandlung überlegen */
}
}
}
}
}
public override void executeAction(actionBase Action) {
var action = (addRegistryValueAction) Action;
RegistryKey rootKey = getRegistryRoot(action.rootHive);
m_rootKey = rootKey;
m_registryPath = action.Path;
//Überprüfen ob Basisschlüssel existiert
if (!registryKeyExists(rootKey, action.Path)) {
rootKey.CreateSubKey(action.Path);
}
int itemCount = 0;
foreach (addRegistryValueAction.registryItem item in action.Items) {
onProgressChanged(Language.GetString("applyAddRegistryValueAction_progress"), Percent(itemCount, action.Items.Count));
object currentData = rootKey.OpenSubKey(action.Path).GetValue(item.Name, null);
object newValue = item.Value;
if (item.Type == registryValueTypes.REG_SZ)
newValue = ParsePath((string) newValue);
rootKey.OpenSubKey(action.Path, true).SetValue(item.Name, newValue, getRegistryValueKind(item.Type));
if (currentData != null) {
m_addedValues.Add(new registryRollbackItem(item.Name, currentData,
rootKey.OpenSubKey(action.Path).GetValueKind(item.Name)));
}
else {
m_addedValues.Add(new registryRollbackItem(item.Name, null, RegistryValueKind.Unknown));
}
itemCount++;
}
}
public override void executeAction(actionBase Action) {
var action = (deleteFilesAction) Action;
string basePath = ParsePath(action.Path);
string tempPath = currentConfiguration.Settings.downloadLocation;
int fileCount = 0;
foreach (string file in action.filesToRemove) {
string filePath = Path.Combine(basePath, file);
if (File.Exists(filePath)) {
//Status senden
onProgressChanged(string.Format(Language.GetString("applyDeleteFileAction_progress"), file),
Percent(fileCount, action.filesToRemove.Count));
//Datei sichern
string tempFilename = Path.Combine(tempPath, file);
copyFile(filePath, tempFilename);
//Versuchen die Datei zu löschen
if (deleteFile(filePath)) {
m_backupFiles.Add(filePath, tempFilename);
}
else {
throw new IOException(string.Format(Language.GetString("applyDeleteFileAction_exception"), filePath));
}
}
fileCount++;
}
}
public override void executeAction(actionBase Action) {
var action = (removeRegistryKeyAction) Action;
RegistryKey rootKey = getRegistryRoot(action.rootHive);
m_rootKey = rootKey;
//Erstelle ein Backup des Registryschlüssels einschl. aller Unterschlüssel
getSubKeys(m_removedKeys, rootKey, action.Path);
//Sichere Registrywerte in dem Rootschlüssel
m_removedKeys.Add(action.Path);
onProgressChanged(Language.GetString("applyRemoveRegistryKeyAction_progressStep_1"), 30);
foreach (string baseRegVal in rootKey.OpenSubKey(action.Path).GetValueNames()) {
m_removedValues.Add(new rollbackRegistryItem(action.Path, baseRegVal,
rootKey.OpenSubKey(action.Path).GetValue(baseRegVal),
rootKey.OpenSubKey(action.Path).GetValueKind(baseRegVal)));
}
//Sichere Registrywerte in allen Unterschlüsseln
onProgressChanged(Language.GetString("applyRemoveRegistryKeyAction_progressStep_2"), 60);
foreach (string Item in m_removedKeys) {
foreach (string regVal in rootKey.OpenSubKey(Item).GetValueNames()) {
m_removedValues.Add(new rollbackRegistryItem(Item, regVal, m_rootKey.OpenSubKey(Item).GetValue(regVal),
m_rootKey.OpenSubKey(Item).GetValueKind(regVal)));
}
}
//Registryschlüssel löschen
onProgressChanged(
string.Format(Language.GetString("applyRemoveRegistryKeyAction_progressStep_3"), rootKey, action.Path), 100);
rootKey.DeleteSubKeyTree(action.Path);
}
/// <summary>
/// Initialisiert eine neue Instanz der <see cref="applyUpdateBase"/>Action.
/// </summary>
/// <param name="Action">Die Updateaction.</param>
public applyUpdateBase(actionBase Action) {
m_action = Action;
m_bgwAction.WorkerReportsProgress = true;
m_bgwAction.WorkerSupportsCancellation = true;
m_bgwAction.DoWork += m_bgwAction_DoWork;
m_bgwAction.ProgressChanged += m_bgwAction_ProgressChanged;
m_bgwAction.RunWorkerCompleted += m_bgwAction_RunWorkerCompleted;
}
public override void executeAction(actionBase Action) {
var action = (addRegistryKeyAction) Action;
m_path = action.Path;
RegistryKey root = getRegistryRoot(action.rootHive);
m_rootKey = root;
onProgressChanged(
string.Format(Language.GetString("applyAddRegistryKeyAction_progress"), action.Path, action.rootHive.ToString()),
100);
root.CreateSubKey(action.Path);
}
public override void executeAction(actionBase Action) {
var action = (renameFileAction) Action;
string rPath = ParsePath(action.Path);
string newPath = Path.Combine(Path.GetDirectoryName(rPath), action.newFilename);
if (File.Exists(rPath)) {
onProgressChanged(string.Format(Language.GetString("applyRenameFileAction_progress"), new FileInfo(rPath).Name), 100);
copyFile(rPath, newPath);
deleteFile(rPath);
m_originalPath = rPath;
m_renamedPath = newPath;
}
}
public override void executeAction(actionBase Action) {
var action = (userInteractionAction) Action;
string title = string.Empty;
string message = string.Empty;
if (Thread.CurrentThread.CurrentCulture.Name.StartsWith("de")) {
title = action.germanTitle;
message = action.germanMessage;
}
else {
title = action.englishTitle;
message = action.englishMessage;
}
onProgressChanged("", 100);
if (showInteractionDialog(action.Buttons, title, message) != DialogResult.OK) {
throw new userCancelledException();
}
}
public override void executeAction(actionBase Action) {
//Ohne Adminrechte keine Schreibrechte in der Registry im HKEY_LOCAL_MACHINE HIVE
if (!isAdmin)
return;
//Überprüfe ob der Schlüssel existiert
RegistryKey key = Registry.LocalMachine.OpenSubKey(uninstallHive + currentConfiguration.ServerConfiguration.setupId,
true);
if (key == null) {
key = Registry.LocalMachine.OpenSubKey(uninstallHiveX86 + currentConfiguration.ServerConfiguration.setupId, true);
}
if (key == null)
return;
if (new List<string>(key.GetValueNames()).Contains("DisplayVersion")) {
oldVersion = (string) key.GetValue("DisplayVersion");
key.SetValue("DisplayVersion", (Action as updateRegistryAction).newVersion, RegistryValueKind.String);
}
}
public override void executeAction(actionBase Action) {
var action = (stopServiceAction) Action;
ServiceController[] services = ServiceController.GetServices();
var timeout = new TimeSpan(0, 0, 10);
foreach (ServiceController service in services) {
if (string.Equals(service.ServiceName.ToLower(), action.serviceName.ToLower())) {
//Überprüfe ob der Dienst läuft
if (service.Status == ServiceControllerStatus.Running) {
//Status senden
onProgressChanged(string.Format(Language.GetString("applyStopServiceAction_stopService"), service.DisplayName),
100);
service.Stop();
service.WaitForStatus(ServiceControllerStatus.Stopped, timeout);
if (service.Status != ServiceControllerStatus.Stopped) {
throw new stopServiceException(service.DisplayName);
}
}
break;
}
}
}
public override void executeAction(actionBase Action) {
onProgressChanged(Language.GetString("applyValidatePackageAction_progressStep_1"), 50);
//Paketpfad erstellen
string packageFile = Path.Combine(currentConfiguration.Settings.downloadLocation, currentPackage.getFilename());
//Öffentlichen Schlüssel ermitteln
string publicKey = (string.IsNullOrEmpty(currentConfiguration.Settings.PublicKey)
? currentConfiguration.ServerConfiguration.PublicKey
: currentConfiguration.Settings.PublicKey);
//Hashwert von dem Updatepaket ermitteln
string packageHash = Convert.ToBase64String(SHA512.Create().ComputeHash(File.ReadAllBytes(packageFile)));
//Signatur validieren
if (!RSA.validateSign(packageHash, currentPackage.packageSignature, publicKey)) {
throw new ApplicationException(string.Format(Language.GetString("applyValidatePackageAction_exception"),
currentPackage.releaseInfo.Version));
}
onProgressChanged(Language.GetString("applyValidatePackageAction_progressStep_2"), 100);
}
public override void executeAction(actionBase Action) {
var action = (removeRegistryValuesAction) Action;
RegistryKey rootKey = getRegistryRoot(action.rootHive);
//Daten sichern
m_rootKey = rootKey;
m_registryPath = action.Path;
int itemCount = 0;
foreach (string item in action.valueNames) {
onProgressChanged(
string.Format(Language.GetString("applyRemoveRegistryValueAction_progress"), item),
Percent(itemCount, action.valueNames.Count));
object itemValue = rootKey.OpenSubKey(action.Path).GetValue(item, null);
if (itemValue != null) {
m_removedValues.Add(new registryRollbackItem(item, itemValue,
rootKey.OpenSubKey(action.Path, false).GetValueKind(item)));
rootKey.OpenSubKey(action.Path, true).DeleteValue(item, false);
}
itemCount++;
}
}
public override void executeAction(actionBase Action) {
var action = (fileCopyAction) Action;
//Pfad zu dem heruntergeladenen Updatepaket erstellen.
string packageFile = Path.Combine(currentConfiguration.Settings.downloadLocation, currentPackage.getFilename());
//Temporäres Verzeichnis zum sichern von Dateien
string tempDirectory = currentConfiguration.Settings.downloadLocation;
//Wenn das Updatepaket nicht exisitiert, dann eine FileNotFoundException werfen.
if (!File.Exists(packageFile)) {
throw new FileNotFoundException(packageFile);
}
var rnd = new Random(Environment.TickCount);
int fileCounter = 0;
foreach (FileType file in action.Files) {
string fileDirectory = ParsePath(file.Destination);
string fileCompletePath = Path.Combine(fileDirectory, file.Filename);
//Überprüfe die filecopyflags
switch (file.copyFlag) {
case fileCopyFlags.OnlyIfExists:
if (!File.Exists(fileCompletePath)) {
fileCounter++;
continue;
}
break;
case fileCopyFlags.OnlyIfNotExists:
if (File.Exists(fileCompletePath)) {
fileCounter++;
continue;
}
break;
}
//Überprüfe ob Verzeichnis existiert
if (!Directory.Exists(fileDirectory)) {
Directory.CreateDirectory(fileDirectory);
SetDirectoryAccessControl(fileDirectory);
}
//Überprüfe ob die Datei existiert
if (File.Exists(fileCompletePath)) {
string rbFilename = Path.Combine(tempDirectory,
string.Format("{0}_rollback_{1}", file.Filename, rnd.Next(5000, 10000)));
//Wenn die Datei noch nicht gesichert wurde, dann sichern.
if (!rbFileExists(fileCompletePath)) {
onProgressChanged(string.Format(Language.GetString("applyFileCopyAction_progressStep_1"), file.Filename),
Percent(fileCounter, action.Files.Count));
copyFile(fileCompletePath, rbFilename);
}
//Versuche Datei zu löschen
if (deleteFile(fileCompletePath)) {
m_rollbackFiles.Add(new rollbackFile(fileCompletePath, rbFilename));
}
else {
throw new userCancelledException();
}
}
else {
m_rollbackFiles.Add(new rollbackFile(fileCompletePath, string.Empty));
}
onProgressChanged(string.Format(Language.GetString("applyFileCopyAction_progressStep_2"), file.Filename),
Percent(fileCounter, action.Files.Count));
byte[] data = Decompress(accessUpdatePackage(packageFile, file.ID));
onProgressChanged(string.Format(Language.GetString("applyFileCopyAction_progressStep_3"), file.Filename),
Percent(fileCounter, action.Files.Count));
File.WriteAllBytes(fileCompletePath, data);
SetFileAccessControl(fileCompletePath);
//NGen Image erzeugen
//if (Core.Helper.IsNetAssembly(fileCompletePath))
//{
// //onProgressChanged(string.Format("Optimiere .Net Assembly '{0}'...", file.Filename), Percent(fileCounter, action.Files.Count));
// //NGenUninstall(fileCompletePath);
// //NGenInstall(fileCompletePath);
//}
if (fileCompletePath.EndsWith(".exe") && currentConfiguration.ServerConfiguration.generateNativeImages &&
assemblyInfo.FromFile(fileCompletePath) != null) {
onProgressChanged(Language.GetString("applyFileCopyAction_progressStep_4"),
Percent(fileCounter, action.Files.Count));
NGenUninstall(fileCompletePath);
NGenInstall(fileCompletePath);
}
fileCounter++;
}
}
public applyFileCopyAction(actionBase action, InternalConfig config, updatePackage currentPackage)
: base(action, config, currentPackage) {
}
/// <summary>Fügt einem Updatepaket eine beliebige Updateaction hinzu.</summary>
/// <param name="action">Die updateAction die hinzugefügt werden soll.</param>
/// <param name="package">Das Updatepaket in welche die updateAction hinzugefügt werden soll.</param>
/// <returns>Gibt True zurück wenn die updateAction erfolgreich hinzugefügt wurde, andernfalls False.</returns>
public bool addActionToPackage(actionBase action, updatePackage package) {
foreach (PropertyInfo property in package.GetType().GetProperties()) {
if (!property.Name.ToLower().Contains(action.GetType().Name.ToLower())) continue;
object instance = property.GetValue(package, null);
MethodInfo mInfo = instance.GetType().GetMethod("Add");
mInfo.Invoke(instance, new object[] {action});
return true;
}
return false;
}
public override void executeAction(actionBase Action) {
var action = (startProcessAction) Action;
string filePath = ParsePath(action.Path);
string processVerb = string.Empty;
//Wenn die Datei nicht existiert, Aktion abbrechen
if (!File.Exists(filePath)) {
return;
}
//Wenn der Prozess bereits läuft und ein entsprechendes Flag gesetzt ist, dann Abbrechen
if (action.dontRunIfExists && isProcessRunnig(new FileInfo(filePath).Name)) {
return;
}
onProgressChanged(
string.Format(Language.GetString("applyStartProcessAction_progress"), new FileInfo(filePath).Name), 100);
//Überprüfe, ob der Prozess Administratorrechte einfordert
if (action.needElevatedRights) {
//Wenn der aktuelle Prozess bereits über Adminrechte verfügt
if (isAdmin) {
//Digitale Signatur überprüfen, wenn das fehlschlägt Exception werfen
//SecurityLevel auswerten
switch (currentConfiguration.Settings.processSafetyLevel) {
case processSafetyLevel.AskAlways:
if (!Security.VerifySignedFile(ownerForm, filePath, true, true)) {
throw new SecurityException(string.Format(Language.GetString("applyStartProcessAction_exception"), filePath));
}
break;
case processSafetyLevel.AskIfUnsigned:
if (!Security.VerifySignedFile(ownerForm, filePath, true, false)) {
throw new SecurityException(string.Format(Language.GetString("applyStartProcessAction_exception"), filePath));
}
break;
}
}
else {
processVerb = "runas";
}
}
else {
if (isVistaOrLater && isAdmin)
//Wenn Vista und der Benutzer Administrator ist, dann einen Prozess ohne Admintoken erstellen
{
IntPtr hProcess = IntPtr.Zero;
int success = Security.ExecRequireNonAdmin(ownerForm, filePath, action.Arguments, out hProcess);
if (action.waitForExit) //Auf das Ende des Prozesses warten
{
if (success == 0) {
Process[] processes = Process.GetProcessesByName(Path.GetFileNameWithoutExtension(filePath));
if (processes.Length > 0) {
processes[0].WaitForExit();
}
}
}
//Testen!!!!
//Marshal.Release(hProcess);
//Funktion hier abbrechen
return;
}
}
var p = new Process();
var psi = new ProcessStartInfo();
psi.FileName = filePath;
psi.Arguments = action.Arguments;
psi.Verb = processVerb;
p.StartInfo = psi;
p.Start();
if (action.waitForExit) {
p.WaitForExit();
}
}
public applyStartProcessAction(actionBase action, InternalConfig config, updatePackage currentPackage)
: base(action, config, currentPackage) {
}
public applyCloseProcessAction(actionBase Action, InternalConfig config, updatePackage currentPackage)
: base(Action, config, currentPackage) {
}
public applyRenameFileAction(actionBase Action, InternalConfig config, updatePackage currentPackage)
: base(Action, config, currentPackage) {
}
public applyUserInteractionAction(actionBase action, InternalConfig config, updatePackage currentPackage)
: base(action, config, currentPackage) {
}
public applyUpdateRegistryAction(actionBase action, InternalConfig config)
: base(action, config, new updatePackage()) {
}
private readonly TimeSpan m_timeout = new TimeSpan(0, 0, 10); //Timeout für den Service Start/Stopp
public applyStartServiceAction(actionBase Action, InternalConfig config, updatePackage currentPackage)
: base(Action, config, currentPackage) {
}
public override void executeAction(actionBase Action) {
var action = (startServiceAction) Action;
ServiceController[] services = ServiceController.GetServices();
foreach (ServiceController service in services) {
if (string.Equals(service.ServiceName.ToLower(), action.serviceName.ToLower())) {
switch (service.Status) {
case ServiceControllerStatus.Stopped: //Dienst starten
//Status senden
onProgressChanged(
string.Format(Language.GetString("applyStartServiceAction_startService"), service.DisplayName), 100);
//Dienst starten
if (!string.IsNullOrEmpty(action.Arguments)) {
service.Start(action.Arguments.Split(' '));
}
else {
service.Start();
}
//Warten bis der Dienst den Status ändert (max. 10 Sekunden)
service.WaitForStatus(ServiceControllerStatus.Running, m_timeout);
//Wenn der Status nicht Runnig ist, dann eine Exception werfen, dass der Dienst nicht gestartet werden konnte
if (service.Status != ServiceControllerStatus.Running) {
throw new startServiceException(service.DisplayName);
}
break;
case ServiceControllerStatus.Running:
if (action.restartIfRunnig)
//Dienst neu starten wenn dieser bereits läuft und die entsprechende Option gegeben ist
{
//Status senden
onProgressChanged(
string.Format(Language.GetString("applyStartServiceAction_stopService"), service.DisplayName), 100);
//Dienst anhalten
service.Stop();
//Warten bis der Dienst angehalten wurde (max 10 Sekunden)
service.WaitForStatus(ServiceControllerStatus.Stopped, m_timeout);
//Wenn der Dienst gestoppt wurde versuchen diesen neu zu starten
if (service.Status == ServiceControllerStatus.Stopped) {
//Status senden
onProgressChanged(
string.Format(Language.GetString("applyStartServiceAction_startService"), service.DisplayName), 100);
//Dienst starten
if (!string.IsNullOrEmpty(action.Arguments)) {
service.Start(action.Arguments.Split(' '));
}
else {
service.Start();
}
service.WaitForStatus(ServiceControllerStatus.Running, m_timeout);
if (service.Status != ServiceControllerStatus.Running) {
throw new stopServiceException(service.DisplayName);
}
}
else //Andernfalls eine Exception werfen, dass der Dienst nicht beendet werden konnte.
{
throw new startServiceException(service.DisplayName);
}
}
break;
}
return; //Schleife beenden, da Dienst gefunden.
}
}
}
private string localizeActionDescription(actionBase action) {
return Session.getLocalizedString(string.Format("updateActions.Actions.{0}.Description", action.GetType().Name));
}
public abstract void executeAction(actionBase Action);
public applyValidatePackageSignature(actionBase action, InternalConfig config, updatePackage package)
: base(action, config, package) {
}
public applyAddRegistryValueAction(actionBase Action, InternalConfig config, updatePackage currentPackage)
: base(Action, config, currentPackage) {
}
public applyCleanupAction(actionBase action, InternalConfig config)
: base(action, config, new updatePackage()) {
}
/// <summary>
/// Initialisiert eine neue Instanz der <see cref="applyUpdateBase"/>Action.
/// </summary>
/// <param name="Action">Die Updateaction</param>
/// <param name="Config">Die Konfiguration.</param>
public applyUpdateBase(actionBase Action, InternalConfig Config, updatePackage currentPackage)
: this(Action) {
m_config = Config;
m_currentPackage = currentPackage;
}
