public InstallationSummary(ApplicationWithOverrideVariableGroup applicationWithOverrideVariableGroup, ApplicationServer applicationServer, DateTime startTime) { this.ApplicationWithOverrideVariableGroup = applicationWithOverrideVariableGroup; this.ApplicationServer = applicationServer; this.InstallationStart = startTime; this.InstallationStartUtc = TimeZoneInfo.ConvertTimeToUtc(startTime); }
public override void Execute(ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup applicationWithOverrideVariableGroup) { if (applicationServer == null) { throw new ArgumentNullException("applicationServer"); } try { this.AppWithGroup.Install(applicationServer, DateTime.Now, false); this.TaskSucceeded = true; } catch (Exception ex) { this.TaskSucceeded = false; this.TaskDetails = ex.Message + Environment.NewLine; Logger.LogException(ex); } finally { string logMessage = string.Format(CultureInfo.CurrentCulture, PrestoCommonResources.TaskAppLogMessage, this.Description); this.TaskDetails += logMessage; Logger.LogInformation(logMessage); } }
private void SetProcessCredentials(ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup appWithGroup, Process process) { string domainAndUser = CustomVariableGroup.ResolveCustomVariable(this.RunAsUser, applicationServer, appWithGroup); // If this task contains a user name, use those credentials. if (string.IsNullOrWhiteSpace(domainAndUser)) { return; } int indexOfBackslash = domainAndUser.IndexOf(@"\", StringComparison.OrdinalIgnoreCase); if (indexOfBackslash < 0) { throw new InvalidOperationException("User name missing backslash. Unable to parse domain name."); } string domain = domainAndUser.Substring(0, indexOfBackslash); string user = domainAndUser.Substring(indexOfBackslash + 1); process.StartInfo.Domain = domain; process.StartInfo.UserName = user; process.StartInfo.Password = new SecureString(); string password = CustomVariableGroup.ResolveCustomVariable(this.RunAsPassword, applicationServer, appWithGroup); foreach (char c in password) { process.StartInfo.Password.AppendChar(c); } }
public override void Execute(ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup applicationWithOverrideVariableGroup) { if (applicationServer == null) { throw new ArgumentNullException("applicationServer"); } string sourcePath = this.SourcePath; string sourceFileName = this.SourceFileName; string destinationPath = this.DestinationPath; string status = "Succeeded"; try { sourcePath = CustomVariableGroup.ResolveCustomVariable(this.SourcePath, applicationServer, applicationWithOverrideVariableGroup); sourceFileName = CustomVariableGroup.ResolveCustomVariable(this.SourceFileName, applicationServer, applicationWithOverrideVariableGroup); destinationPath = CustomVariableGroup.ResolveCustomVariable(this.DestinationPath, applicationServer, applicationWithOverrideVariableGroup); List <string> listOfFilesToCopy = new List <string>(); listOfFilesToCopy.AddRange(Directory.GetFiles(sourcePath, sourceFileName)); // Supports wildcards string fileNameOnly = string.Empty; foreach (string fileToCopy in listOfFilesToCopy) { fileNameOnly = fileToCopy.Substring(fileToCopy.LastIndexOf(@"\", StringComparison.OrdinalIgnoreCase) + 1); // Get just the file name if (!destinationPath.EndsWith(@"\", StringComparison.OrdinalIgnoreCase)) { destinationPath += @"\"; } File.Copy(fileToCopy, destinationPath + fileNameOnly, true); } this.TaskSucceeded = true; } catch (Exception ex) { this.TaskSucceeded = false; status = ex.Message; Logger.LogException(ex); } finally { string message = "Copy File\r\n" + "Task Desc : " + this.Description + "\r\n" + "Source : " + sourcePath + @"\" + sourceFileName + "\r\n" + "Destination: " + destinationPath + "\r\n" + "Result : " + status; this.TaskDetails = message; Logger.LogInformation(message); } }
public static string ResolveCustomVariable(string rawString, ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup appWithGroup, bool leaveValueEncrypted = false) { if (applicationServer == null) { throw new ArgumentNullException("applicationServer"); } if (appWithGroup == null) { throw new ArgumentNullException("appWithGroup"); } if (String.IsNullOrWhiteSpace(rawString)) { return(rawString); } if (!StringHasCustomVariable(rawString)) { return(rawString); } List <CustomVariable> allCustomVariables = new List <CustomVariable>(); // Add system variables AddSystemVariables(allCustomVariables, applicationServer, appWithGroup); // Add all custom variables associated with the app server. foreach (CustomVariableGroup customVariableGroup in applicationServer.CustomVariableGroups) { ThrowIfDuplicateCustomVariableKeyExists(allCustomVariables, customVariableGroup); allCustomVariables.AddRange(customVariableGroup.CustomVariables); } // Add all custom variables associated with the application. foreach (CustomVariableGroup customVariableGroup in appWithGroup.Application.CustomVariableGroups) { ThrowIfDuplicateCustomVariableKeyExists(allCustomVariables, customVariableGroup); allCustomVariables.AddRange(customVariableGroup.CustomVariables); } // Add the override custom variables. If they already exist in our list, replace them. // Since these are overrides, duplicates are okay here. AddRangeOverride(allCustomVariables, appWithGroup); if (!CustomVariableExistsInListOfAllCustomVariables(rawString, allCustomVariables)) { LogMissingVariableAndThrow(rawString); } return(ResolveCustomVariable(rawString, allCustomVariables, leaveValueEncrypted)); }
public override void Execute(ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup appWithGroup) { if (applicationServer == null) { throw new ArgumentNullException("applicationServer"); } using (Process process = new Process()) { string processOutput = string.Empty; try { process.StartInfo.FileName = CustomVariableGroup.ResolveCustomVariable(this.DosExecutable, applicationServer, appWithGroup); process.StartInfo.Arguments = CustomVariableGroup.ResolveCustomVariable(this.Parameters, applicationServer, appWithGroup); process.StartInfo.UseShellExecute = false; process.StartInfo.RedirectStandardError = true; process.StartInfo.RedirectStandardInput = true; // See Note 1 at the bottom of this file. process.StartInfo.RedirectStandardOutput = true; SetProcessCredentials(applicationServer, appWithGroup, process); process.Start(); processOutput = process.StandardOutput.ReadToEnd(); process.WaitForExit(); PossiblyPause(); // Used to check process.ExitCode here. See Note 2 at the bottom of this file for notes. this.TaskSucceeded = true; } catch (Exception ex) { this.TaskSucceeded = false; this.TaskDetails = ex.Message + Environment.NewLine; Logger.LogException(ex); } finally { string logMessage = string.Format(CultureInfo.CurrentCulture, PrestoCommonResources.TaskDosCommandLogMessage, this.Description, process.StartInfo.FileName, process.StartInfo.Arguments, processOutput); this.TaskDetails += logMessage; Logger.LogInformation(logMessage); } } }
private static void AddSystemVariables(List <CustomVariable> allCustomVariables, ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup appWithOverrideGroup) { allCustomVariables.Add(new CustomVariable() { Key = "sys:applicationName", Value = appWithOverrideGroup.Application.Name }); allCustomVariables.Add(new CustomVariable() { Key = "sys:applicationVersion", Value = appWithOverrideGroup.Application.Version }); allCustomVariables.Add(new CustomVariable() { Key = "sys:serverName", Value = applicationServer.Name }); allCustomVariables.Add(new CustomVariable() { Key = "sys:installationTimestamp", Value = ApplicationWithOverrideVariableGroup.InstallationStartTimestamp }); }
private static void AddRangeOverride(List <CustomVariable> allCustomVariables, ApplicationWithOverrideVariableGroup applicationWithOverrideVariableGroup) { if (applicationWithOverrideVariableGroup.CustomVariableGroups == null || applicationWithOverrideVariableGroup.CustomVariableGroups.Count < 1) { return; // No custom variable group to add to main list. } // Add the new custom variables to the list, overwriting any duplicates. // ... but before we add the overrides, need to make sure the overrides don't // have any duplicates within themselves. var hashset = new HashSet <string>(); foreach (var cvg in applicationWithOverrideVariableGroup.CustomVariableGroups) { foreach (var cv in cvg.CustomVariables) { if (!hashset.Add(cv.Key)) { LogDuplicateVariableAndThrow(cv.Key); } } } var newCustomVariables = new List <CustomVariable>(); foreach (var cvg in applicationWithOverrideVariableGroup.CustomVariableGroups) { newCustomVariables.AddRange(cvg.CustomVariables.ToList()); } // First, remove variables that are the same as the new/override variables. foreach (CustomVariable newCustomVariable in newCustomVariables) { CustomVariable customVariable = allCustomVariables.Where(variable => variable.Key == newCustomVariable.Key).FirstOrDefault(); if (customVariable != null) { allCustomVariables.Remove(customVariable); } } // Now add all the new variables. allCustomVariables.AddRange(newCustomVariables); }
/// <summary> /// Executes this instance. /// </summary> public abstract void Execute(ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup applicationWithOverrideVariableGroup);
/// <summary> /// Finds the matching <see cref="ApplicationWithOverrideVariableGroup"/> from the force install list. /// </summary> /// <param name="appWithGroup">The <see cref="ApplicationWithOverrideVariableGroup"/></param> /// <returns>If a match is found, returns the <see cref="ApplicationWithOverrideVariableGroup"/> instance. /// If no match is found, returns null. /// </returns> public ServerForceInstallation GetFromForceInstallList(ApplicationWithOverrideVariableGroup appWithGroup) { return(CommonUtility.GetForceInstallationContainingAppWithGroup(this.ForceInstallationsToDo, appWithGroup)); }
public override void Execute(ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup applicationWithOverrideVariableGroup) { string sourceFileVersion = string.Empty; string destinationFileVersion = string.Empty; string sourceFolder = string.Empty; string destinationFolder = string.Empty; string fileName = string.Empty; try { sourceFolder = CustomVariableGroup.ResolveCustomVariable(this.SourceFolder, applicationServer, applicationWithOverrideVariableGroup); destinationFolder = CustomVariableGroup.ResolveCustomVariable(this.DestinationFolder, applicationServer, applicationWithOverrideVariableGroup); fileName = CustomVariableGroup.ResolveCustomVariable(this.FileName, applicationServer, applicationWithOverrideVariableGroup); // Will throw if file doesn't exist string sourcePathAndFile = SetSourcePathAndFile(sourceFolder, fileName); sourceFileVersion = FileVersionInfo.GetVersionInfo(sourcePathAndFile).FileVersion; string destinationPathAndFile = destinationFolder + @"\" + fileName; // It's okay if the destination file doesn't exist. This just means (hopefully) that this is // the first time we're deploying this file. if (!File.Exists(destinationPathAndFile)) { this.TaskSucceeded = true; } else { destinationFileVersion = FileVersionInfo.GetVersionInfo(destinationPathAndFile).FileVersion; this.TaskSucceeded = false; // default // We want the file versions to be different. Otherwise we're just deploying the same thing again, // which is what this is designed to detect. if (sourceFileVersion != destinationFileVersion) { this.TaskSucceeded = true; } } } catch (Exception ex) { this.TaskSucceeded = false; this.TaskDetails = ex.Message + Environment.NewLine; Logger.LogException(ex); } finally { string logMessage = string.Format(CultureInfo.CurrentCulture, PrestoCommonResources.TaskVersionCheckerLogMessage, this.Description, fileName, sourceFileVersion, sourceFolder, destinationFileVersion, destinationFolder); this.TaskDetails += logMessage; Logger.LogInformation(logMessage); } }
public ServerForceInstallation(ApplicationServer server, ApplicationWithOverrideVariableGroup appWithGroup) { this.ApplicationServer = server; this.ApplicationWithOverrideGroup = appWithGroup; }
public override void Execute(ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup applicationWithOverrideVariableGroup) { string taskDetails = string.Empty; try { TaskXmlModify taskResolved = GetTaskXmlModifyWithCustomVariablesResolved(applicationServer, applicationWithOverrideVariableGroup); taskDetails = ConvertTaskDetailsToString(taskResolved); XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(taskResolved.XmlPathAndFileName); XmlElement rootElement = xmlDocument.DocumentElement; XmlNamespaceManager namespaceManager = new XmlNamespaceManager(xmlDocument.NameTable); string prefix = ""; // default string prefixSuffix = ""; // yes, a suffix for a prefix. Eat me. if (!string.IsNullOrWhiteSpace(taskResolved.NodeNamespace)) { prefix = "nssnuh"; // use something that we'll never expect to see in an XML doc. prefixSuffix = ":"; namespaceManager.AddNamespace(prefix, taskResolved.NodeNamespace); } if (this.AddNode) { AddNewNode(xmlDocument, taskResolved, rootElement); } else { ModifyExistingNode(taskResolved, rootElement, prefix, prefixSuffix, namespaceManager); } // If internal subset doesn't have a value, then make it null. Making it null will cause // <!DOCTYPE HTML> to be the result (which is what we want), instead of <!DOCTYPE HTML[]>. // The brackets enable quirks mode. We don't want quirks mode. // http://stackoverflow.com/q/38832479/279516 // http://stackoverflow.com/a/16451790/279516 if (xmlDocument.DocumentType != null && string.IsNullOrWhiteSpace(xmlDocument.DocumentType.InternalSubset)) { var name = xmlDocument.DocumentType.Name; var publicId = xmlDocument.DocumentType.PublicId; var systemId = xmlDocument.DocumentType.SystemId; var parent = xmlDocument.DocumentType.ParentNode; var documentTypeWithNullInternalSubset = xmlDocument.CreateDocumentType(name, publicId, systemId, null); parent.ReplaceChild(documentTypeWithNullInternalSubset, xmlDocument.DocumentType); } xmlDocument.Save(taskResolved.XmlPathAndFileName); xmlDocument = null; this.TaskSucceeded = true; this.TaskDetails = taskDetails; Logger.LogInformation(taskDetails); } catch (Exception ex) { this.TaskSucceeded = false; this.TaskDetails = ex.Message + Environment.NewLine + taskDetails; Logger.LogException(ex); } }
private TaskXmlModify GetTaskXmlModifyWithCustomVariablesResolved(ApplicationServer applicationServer, ApplicationWithOverrideVariableGroup applicationWithOverrideVariableGroup) { TaskXmlModify taskXmlModifyResolved = new TaskXmlModify(); taskXmlModifyResolved.Description = this.Description; taskXmlModifyResolved.FailureCausesAllStop = this.FailureCausesAllStop; taskXmlModifyResolved.PrestoTaskType = this.PrestoTaskType; taskXmlModifyResolved.Sequence = this.Sequence; taskXmlModifyResolved.TaskSucceeded = this.TaskSucceeded; taskXmlModifyResolved.AttributeKey = CustomVariableGroup.ResolveCustomVariable(this.AttributeKey, applicationServer, applicationWithOverrideVariableGroup); taskXmlModifyResolved.AttributeKeyValue = CustomVariableGroup.ResolveCustomVariable(this.AttributeKeyValue, applicationServer, applicationWithOverrideVariableGroup); taskXmlModifyResolved.AttributeToChange = CustomVariableGroup.ResolveCustomVariable(this.AttributeToChange, applicationServer, applicationWithOverrideVariableGroup); taskXmlModifyResolved.AttributeToChangeValue = CustomVariableGroup.ResolveCustomVariable(this.AttributeToChangeValue, applicationServer, applicationWithOverrideVariableGroup); taskXmlModifyResolved.NodeNamespace = CustomVariableGroup.ResolveCustomVariable(this.NodeNamespace, applicationServer, applicationWithOverrideVariableGroup); taskXmlModifyResolved.NodeToChange = CustomVariableGroup.ResolveCustomVariable(this.NodeToChange, applicationServer, applicationWithOverrideVariableGroup); taskXmlModifyResolved.XmlPathAndFileName = CustomVariableGroup.ResolveCustomVariable(this.XmlPathAndFileName, applicationServer, applicationWithOverrideVariableGroup); taskXmlModifyResolved.AddNode = this.AddNode; return(taskXmlModifyResolved); }
public TaskApp(ApplicationWithOverrideVariableGroup appWithGroup) { this.AppWithGroup = appWithGroup; this.PrestoTaskType = TaskType.App; }