/// <summary> /// Load the measurement configuration with a supplied filename. This will /// normally be called as part of the command line options where the /// file name is supplied in the command arguments /// </summary> /// <param name="fileName">Config file name</param> /// <param name="showExceptionDialog">True if we want to show the user an exception dialog /// If false, the exception will not be caught.</param> /// <returns>BDC Settings</returns> public static BuildControlParameters LoadConfiguration(string fileName) { BuildControlParameters ret = null; try { XmlSerializer mySerializer = new XmlSerializer(typeof(BuildControlParameters)); // To read the file, create a FileStream. FileStream myFileStream = new FileStream(fileName, FileMode.Open); // Call the Deserialize method and cast to the object type. ret = (BuildControlParameters)mySerializer.Deserialize(myFileStream); myFileStream.Close(); } catch (FileNotFoundException e) { ProgramExecutionLog.AddEntry("Configuration file " + fileName + " was not found! Error was " + e.Message); } if (ret != null) { // For backwards compatibility, set the default to the HeroApps build // folder if this is not specified in the configuration file. if (String.IsNullOrEmpty(ret.ApplicationParentFolderName)) { ret.ApplicationParentFolderName = ApplicationParentDefaultFolderName; } } return(ret); }
/// <summary> /// Resets the specified configuration. /// </summary> /// <param name="configuration">The configuration.</param> public void Reset(BuildControlParameters configuration) { this.EnlistmentSync.Reset(); this.UninstallWdpt.Reset(); this.InstallWdpt.Reset(); this.ModifyWdpt.Reset(); this.UninstallYdr.Reset(); this.InstallYdr.Reset(); this.PublishToReleaseShare.Reset(); this.EmailBuildResults.Reset(); this.BuildTargets = null; this.InitializeBuildTargetResults(configuration); this.EnlistmentSync.RequestedToRun = configuration.SyncEnlistment; this.UninstallWdpt.RequestedToRun = configuration.UpdateWpdt; this.InstallWdpt.RequestedToRun = configuration.UpdateWpdt; this.UninstallYdr.RequestedToRun = configuration.UpdateYdr; this.InstallYdr.RequestedToRun = configuration.UpdateYdr; if (configuration.UpdateWpdt) { this.ModifyWdpt.RequestedToRun = configuration.InstallOnW2k8; } else { this.ModifyWdpt.RequestedToRun = false; } this.PublishToReleaseShare.RequestedToRun = true; this.EmailBuildResults.RequestedToRun = configuration.EmailResults; }
/// <summary> /// Checks for WPDT test case files. /// </summary> /// <param name="configuration">The configuration.</param> private static void CheckForWpdtTestCaseFiles(BuildControlParameters configuration) { if (configuration.UpdateWpdt) { string uninstallTestCase = Path.Combine(configuration.SwanTestCasePath, configuration.WpdtUninstallTestCase); string installTestCase = Path.Combine(configuration.SwanTestCasePath, configuration.WpdtInstallTestCase); bool exitProgram = false; if (!File.Exists(uninstallTestCase)) { exitProgram = true; string error1 = "Wpddt uninstall Test Case File " + uninstallTestCase + " not found. Program will exit"; Console.WriteLine(error1); ProgramExecutionLog.AddEntry(error1); Thread.Sleep(2000); } if (!File.Exists(installTestCase)) { exitProgram = true; string error2 = "Wpddt install Test Case File " + installTestCase + " not found. Program will exit"; Console.WriteLine(error2); ProgramExecutionLog.AddEntry(error2); Thread.Sleep(2000); } if (exitProgram) { Environment.Exit(1); } } }
/// <summary> /// Determines whether [is ydr installed] [the specified configuration]. /// </summary> /// <param name="configuration">The configuration.</param> /// <returns> /// <c>true</c> if [is ydr installed] [the specified configuration]; otherwise, <c>false</c>. /// </returns> public static bool IsYdrInstalled(BuildControlParameters configuration) { string outputFile = Path.Combine(Application.StartupPath, InstallationFileCheckName); string app = Path.Combine(Application.StartupPath, InstallationCheckProgramName); try { string arguments = @"/p"; ProcessInformation process = ProcessOperations.RunProcess(app, Application.StartupPath, arguments, true); string[] contents = process.GetStandardOutput(); if (contents != null) { var ydrInstalled = (from installId in contents where installId.Contains(BuildControlParameters.YdrGuid) select installId).Count(); return(ydrInstalled > 0 ? true : false); } else { ProgramExecutionLog.AddEntry( "No output was returned from the msiinv.exe program"); return(false); } } catch (Exception e) { ProgramExecutionLog.AddEntry( "Failure checking for Installation of Wpdt. Error was " + e.Message); } return(false); }
/// <summary> /// Reverts the build version files. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> private static void RevertBuildVersionFiles( BuildControlParameters configuration, DailyBuildFullResults results) { string heroAppSource = FindHeroAppSourceFolder(configuration); for (Int32 i = 0; i < configuration.Projects.Length; i++) { string assemblyFile = ""; try { string appFolder = Path.Combine(heroAppSource, configuration.Projects[i].ProjectPath); assemblyFile = Path.Combine(appFolder, configuration.Projects[i].AssemblyFilePathAndNameFromProjectRoot); ProcessInformation process = ProcessOperations.SDRevert(configuration, assemblyFile); CheckForErrorFromSDOperation(process, results, results.BuildTargets[i].RevertVersion); results.BuildTargets[i].RevertVersion.Success = true; } catch (Exception e) { ProgramExecutionLog.AddEntry( "Failed to revert file " + assemblyFile + " Exception information was " + e.ToString()); results.BuildTargets[i].RevertVersion.SetResults(false, e.Message); } } }
/// <summary> /// Zips the source files. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> /// <param name="sourceDirectory">The source directory.</param> public static void ZipSourceFiles( BuildControlParameters configuration, DailyBuildFullResults results, string sourceDirectory) { string archive = Path.Combine(sourceDirectory, SourceArchiveName); try { string heroAppSource = FindHeroAppSourceFolder(configuration); using (ZipFile zip = new ZipFile(archive)) { for (Int32 i = 0; i < configuration.Projects.Length; i++) { if (configuration.Projects[i].BuildConfiguration != BuildProjectControl.None) { string appFolder = Path.Combine(heroAppSource, configuration.Projects[i].ProjectPath); zip.AddDirectory(appFolder, configuration.Projects[i].ProjectPath); } } zip.Save(); } } catch (Exception e) { ProgramExecutionLog.AddEntry( "Failed to archive source files" + " Error was " + e.Message); } }
/// <summary> /// Call sd sync command for the enlistment /// </summary> /// <param name="configuration">Main program configuration</param> /// <param name="fileName">File name to have the sd command execute on</param> /// <returns>ProcessInformation, so the caller can look at the return code etc</returns> public static ProcessInformation SDSync( BuildControlParameters configuration) { string arguments = "sync "; ProcessInformation procInfo = SDCommand(configuration, ".", arguments); return(procInfo); }
/// <summary> /// Sends the result via email. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> private static void SendResultViaEmail( BuildControlParameters configuration, DailyBuildFullResults results) { Console.WriteLine("Emailing results ...."); EmailOps.SendMailtoExchange(configuration.EmailFromAlias, configuration, results); Console.WriteLine("Completed mailing of results"); }
/// <summary> /// This function will send email messages for either a success or failed work item. /// The checking will be done whether we should send the mail messages, and mail /// will be sent for either success or fail /// </summary> public static void SendMailtoExchange( string senderEmailAddress, BuildControlParameters configuration, DailyBuildFullResults results) { if (configuration.EmailResults) { MailMessage message; SmtpClient client; String subject; try { client = new SmtpClient(SmtpServer); message = new MailMessage(); message.IsBodyHtml = true; client.UseDefaultCredentials = true; MailAddress from = new MailAddress(senderEmailAddress + @"@microsoft.com"); message.From = from; subject = "Hero Apps Daily Build Status for: " + DateTime.Now.ToString("MM/dd/yyyy"); message.To.Add(new MailAddress(configuration.EmailAlias + @"@microsoft.com")); message.Subject = subject; } catch (Exception e) { ProgramExecutionLog.AddEntry("Email SMTP, send address or to address failure." + e.Message); return; } try { // No point sending if there are none in the email list if (message.To.Count > 0) { message.Body += "\n\n"; message.Body = results.MakeHeroAppsReport(configuration); client.Send(message); Debug.WriteLine("Sent WI email with subject: " + message.Subject); } } catch (SmtpFailedRecipientException e) { ProgramExecutionLog.AddEntry("Partial email send failure. " + e.Message); } catch (ArgumentException e) { ProgramExecutionLog.AddEntry("Email send failure. " + e.Message); } catch (InvalidOperationException e) { ProgramExecutionLog.AddEntry("Email send failure. " + e.Message); } catch (SmtpException e) { ProgramExecutionLog.AddEntry("Email send failure. " + e.Message); } } }
/// <summary> /// Save the program configuration to disk /// </summary> /// <param name="config">Configuration settings</param> /// <param name="directoryForSave">Directory where to save the file</param> /// <param name="fileName">File name to use for the saving of the file</param> public static void SaveConfiguration( BuildControlParameters config, string directoryForSave, string fileName) { string fullPath = Path.Combine(directoryForSave, fileName); WriteConfiguration(config, fullPath); }
/// <summary> /// Call sd edit command on the given input file /// </summary> /// <param name="configuration">Main program configuration</param> /// <param name="fileName">File name to have the sd command execute on</param> /// <returns>ProcessInformation, so the caller can look at the return code etc</returns> public static ProcessInformation SDEdit( BuildControlParameters configuration, string fileName) { string arguments = "edit " + Path.GetFileName(fileName); ProcessInformation procInfo = SDCommand(configuration, fileName, arguments); return(procInfo); }
/// <summary> /// Call sd Revert command on the given input file /// </summary> /// <param name="configuration">Main program configuration</param> /// <param name="fileName">File name to have the sd command execute on</param> /// <returns>ProcessInformation, so the caller can look at the return code etc</returns> public static ProcessInformation SDRevert( BuildControlParameters configuration, string fileName) { string arguments = "revert " + fileName; ProcessInformation procInfo = SDCommand(configuration, fileName, arguments); return(procInfo); }
/// <summary> /// Updates the ydr. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> private static void UpdateYdr( BuildControlParameters configuration, DailyBuildFullResults results) { if (configuration.UpdateYdr) { WpdtOperations.UninstallYdr(configuration); WpdtOperations.InstallYdr(configuration, results); } }
/// <summary> /// Initializes the build target results. /// </summary> /// <param name="configuration">The configuration.</param> public void InitializeBuildTargetResults(BuildControlParameters configuration) { BuildTargets = new BuildTargetResults[configuration.Projects.Length]; for (Int32 i = 0; i < configuration.Projects.Length; i++) { BuildTargets[i] = new BuildTargetResults(); BuildTargets[i].ProjectTargetName = configuration.Projects[i].ProjectPath; BuildTargets[i].Reset(configuration); } }
/// <summary> /// Installs the ydr. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> public static void InstallYdr( BuildControlParameters configuration, DailyBuildFullResults results) { if (IsYdrInstalled(configuration)) { UninstallWdpt(configuration); } Console.WriteLine("Beginning install of Ydr for branch " + configuration.YdrBranchSelection + " ..."); string buildFolderFile = ""; string setupBranchRoot = ""; switch (configuration.YdrBranchSelection) { case YdrBranch.Mainline: buildFolderFile = File.ReadAllText( Path.Combine(BuildControlParameters.YdrRootFolder, BuildControlParameters.YdrLatestBuildFolderFile)); setupBranchRoot = Path.Combine(BuildControlParameters.YdrRootFolder, YdrBuildFolder(buildFolderFile)); break; case YdrBranch.Wm7_AppPlatform: case YdrBranch.Wm7_AppPlatform_DevDiv: string branchRoot = Path.Combine(BuildControlParameters.YdrRootFolder, configuration.YdrBranchSelection.ToString()); buildFolderFile = File.ReadAllText( Path.Combine(branchRoot, BuildControlParameters.YdrLatestBuildFolderFile)); setupBranchRoot = Path.Combine(branchRoot, YdrBuildFolder(buildFolderFile)); break; } string fullInstallPath = Path.Combine(setupBranchRoot, BuildControlParameters.YdrInstallPathFromBranchRoot); Console.WriteLine("Ydr Installation Path = " + fullInstallPath); try { string arguments = @""; ProcessInformation process = ProcessOperations.RunProcess(fullInstallPath, Application.StartupPath, arguments, true); results.InstallYdr.Success = true; results.YdrVersion = "Branch: " + configuration.YdrBranchSelection.ToString() + " Build " + YdrVersion(YdrBuildFolder(buildFolderFile)).ToString(); ; Console.WriteLine("Ydr Install Completed!"); } catch (Exception e) { string errorMessage = "Failed to install Ydr. Error message was " + e.Message; ProgramExecutionLog.AddEntry(errorMessage); results.InstallYdr.SetResults(false, errorMessage); } }
/// <summary> /// Execute a sd command /// </summary> /// <param name="configuration">Main Program configuration</param> /// <param name="fileName">File name to perform the SD command on</param> /// <param name="arguments">Filled out argument string that will contain the sd command as /// well as the file to operate on.</param> /// <returns></returns> private static ProcessInformation SDCommand( BuildControlParameters configuration, string fileName, string arguments) { string progName = Path.Combine(configuration.PathForSourceDepotProgram, "sd.exe"); string workingDirectory = Path.GetDirectoryName(fileName); ProcessInformation procInfo = RunProcess(progName, workingDirectory, arguments, true); return(procInfo); }
public void UpdateWpdtOpsForInstalledVersion(BuildControlParameters configuration) { if (configuration.UpdateWpdt) { if (WpdtOperations.IsInstalledWpdtVersionSameAsLkg(configuration)) { this.UninstallWdpt.RequestedToRun = false; this.InstallWdpt.RequestedToRun = false; this.ModifyWdpt.RequestedToRun = false; } } }
/// <summary> /// Uninstalls the WDPT. /// </summary> /// <param name="configuration">The configuration.</param> public static void UninstallWdpt(BuildControlParameters configuration) { ProcessOperations.KillSwanProcesses(); UninstallYdr(configuration); Console.WriteLine("Beginning uninstall of Wpdt ..."); GeneralFileOperations.WriteProgramStatusFile(ExecutionStatus.UninstallWdpt); string swanController = Path.Combine(configuration.SwanPath, BuildControlParameters.SwanControllerExeName); string swanArguments = "/f " + Path.Combine(configuration.SwanTestCasePath, configuration.WpdtUninstallTestCase); ProcessOperations.RunProcess(swanController, configuration.SwanTestCasePath, swanArguments, false); }
/// <summary> /// Determines whether [is installed WPDT version same as LKG] [the specified configuration]. /// </summary> /// <param name="configuration">The configuration.</param> /// <returns> /// <c>true</c> if [is installed WPDT version same as LKG] [the specified configuration]; otherwise, <c>false</c>. /// </returns> public static bool IsInstalledWpdtVersionSameAsLkg(BuildControlParameters configuration) { string currentInstalledWpdtVersion = DetermineWdptInstalledVersion(configuration); if (!String.IsNullOrEmpty(currentInstalledWpdtVersion)) { return(configuration.WpdtLkgSourcePath.ToLower().Contains(currentInstalledWpdtVersion.ToLower())); } else { return(false); } }
/// <summary> /// Installs the WDPT. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> public static void InstallWdpt( BuildControlParameters configuration, DailyBuildFullResults results) { ProcessOperations.KillSwanProcesses(); Console.WriteLine("Starting Wpdt installation ...."); GeneralFileOperations.WriteProgramStatusFile(ExecutionStatus.InstallWdpt); string swanController = Path.Combine(configuration.SwanPath, BuildControlParameters.SwanControllerExeName); string swanArguments = "/f " + Path.Combine(configuration.SwanTestCasePath, configuration.WpdtInstallTestCase); Console.WriteLine("SwanController = " + swanController); Console.WriteLine("SwanArguments = " + swanArguments); ProcessOperations.RunProcess(swanController, configuration.SwanTestCasePath, swanArguments, false); Console.WriteLine("Waiting " + configuration.WpdtInstallationTimeMinutes.ToString() + " minutes for install to complete"); bool wpdtInstalled = false; for (Int32 i = 0; i < configuration.WpdtInstallationTimeMinutes; i++) { for (Int32 j = 0; j < 12; j++) { Thread.Sleep(5000); Console.Write("."); } // Wait one more minute after we detect the product is installed to be sure // of any final cleanup required. if (wpdtInstalled) { break; } Console.WriteLine(""); Console.WriteLine("Waited " + (i + 1).ToString() + " minutes"); } wpdtInstalled = IsWpdtInstalled(configuration); if (wpdtInstalled) { results.InstallWdpt.SetResults(true, ""); Console.WriteLine("Completed Install of Wpdt!"); } else { results.InstallWdpt.SetResults(false, "Wpdt did not install int the alloted time!"); Console.WriteLine("Wpdt did not install int the alloted time!"); } ProcessOperations.KillSwanProcesses(); ProcessOperations.KillSetupProcesses(); results.WpdtVersion = WpdtOperations.DetermineWdptInstalledVersion(configuration); results.YdrVersion = "Same as Wpdt"; }
/// <summary> /// Helper function to initialize a test set of files for development /// </summary> /// <param name="configuration">Main program configuration</param> /// <returns>Destination folder path. To use for other operations</returns> public static string PrepareWpdtTargetDirectory( BuildControlParameters configuration, DailyBuildFullResults results) { string sourcePath = configuration.WpdtLkgSourcePath; string destinationPath = configuration.WpdtLkgTargetPath; if (Directory.Exists(destinationPath)) { GeneralFileOperations.DeleteDirectory(destinationPath); } CopyWpdtLkgToTargetDirectory(sourcePath, destinationPath, results); return(destinationPath); }
/// <summary> /// Creates the build script and execute. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> public static void CreateBuildScriptAndExecute( BuildControlParameters configuration, DailyBuildFullResults results) { string heroAppSource = FindHeroAppSourceFolder(configuration); if (String.IsNullOrEmpty(heroAppSource)) { Console.WriteLine("Could not find Application Parent Folder. Aborting ..."); ProgramExecutionLog.AddEntry("Could not find Application Parent Folder. Aborting ..."); return; } Console.Write("Starting Build/Sign/License Process... "); GeneralFileOperations.WriteProgramStatusFile(ExecutionStatus.Running); if (configuration.BuildType == BuildTypeEnum.Daily && configuration.UpdateDailyBuildVersion) { bool allCompletedWithSuccess = ModifyBuildVersionFiles(configuration, results); Console.WriteLine("Completed Modifying Revision Files. Overall status was " + allCompletedWithSuccess.ToString()); } else { foreach (BuildTargetResults t in results.BuildTargets) { t.ModifyVersion.RequestedToRun = false; } } Console.WriteLine("Completed!"); Console.Write("Beginning to create batch file for build/sign/license operations ... "); string commandFile = BuildBatchFile(configuration, results); Console.WriteLine("Completed. Running batch file ...."); ProcessOperations.RunProcess(commandFile, Application.StartupPath, "", true); Console.WriteLine("Batch File completed. Status not reported here"); ValidateBuildResults(configuration, results); PublishBuildOutput(configuration, results); if (configuration.BuildType == BuildTypeEnum.Daily && configuration.UpdateDailyBuildVersion) { RevertBuildVersionFiles(configuration, results); } if (configuration.EmailResults) { SendResultViaEmail(configuration, results); } }
/// <summary> /// WPDTs the ops install. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> private static void WpdtOpsInstall( BuildControlParameters configuration, DailyBuildFullResults results) { if (configuration.UpdateWpdt && !WpdtOperations.IsInstalledWpdtVersionSameAsLkg(configuration)) { WpdtOperations.PrepareWpdtTargetDirectory(configuration, results); if (configuration.InstallOnW2k8) { WpdtOperations.ModifyInstallForW2k8(configuration, results); } WpdtOperations.InstallWdpt(configuration, results); } }
/// <summary> /// Writes the summary results. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> private static void WriteSummaryResults( BuildControlParameters configuration, DailyBuildFullResults results) { // Summary results via writing execution logs to output share. GeneralFileOperations.WriteProgramStatusFile(ExecutionStatus.Idle); string[] logEntries = ProgramExecutionLog.FullLogContents(); string[] emailSummary = results.GenerateResultsSummary().ToArray <string>(); File.WriteAllLines(ExecutionLogFile, logEntries); File.WriteAllLines(EmailSummaryLogFile, emailSummary); if (!String.IsNullOrEmpty(results.PublishLogShare)) { File.WriteAllLines(Path.Combine(results.PublishLogShare, ExecutionLogFile), logEntries); File.WriteAllLines(Path.Combine(results.PublishLogShare, EmailSummaryLogFile), emailSummary); } }
/// <summary> /// Write to config file /// </summary> /// <param name="config">BDC config settings</param> /// <param name="fileName">Config file</param> private static void WriteConfiguration(BuildControlParameters config, string fileName) { try { XmlSerializer mySerializer = new XmlSerializer(typeof(BuildControlParameters)); // To write to a file, create a StreamWriter object. StreamWriter myWriter = new StreamWriter(fileName); mySerializer.Serialize(myWriter, config); myWriter.Close(); } catch (Exception e) { ProgramExecutionLog.AddEntry("Configuration file " + fileName + " could not be written to disk! Error was " + e.Message); } }
/// <summary> /// WPDTs the ops uninstall. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> private static void WpdtOpsUninstall( BuildControlParameters configuration, DailyBuildFullResults results) { ExecutionStatus status = GeneralFileOperations.ReadProgramStatusFile(); results.WpdtVersion = WpdtOperations.DetermineWdptInstalledVersion(configuration); results.YdrVersion = "Same as Wpdt"; if (status != ExecutionStatus.UninstallWdpt && configuration.UpdateWpdt) { if (WpdtOperations.IsWpdtInstalled(configuration)) { if (!WpdtOperations.IsInstalledWpdtVersionSameAsLkg(configuration)) { WpdtOperations.UninstallWdpt(configuration); // Just show some time on the console before we exit for (Int32 i = 0; i < 10; i++) { Console.Write("."); Thread.Sleep(1000); } Console.WriteLine("Exiting process, waiting for Wpdt Uninstall to complete and reboot"); // Just show some more time on the console for (Int32 i = 0; i < 10; i++) { Console.Write("."); Thread.Sleep(1000); } Environment.Exit(0); } } else { Console.WriteLine("Requested to Uninstall Wpdt, but it was not installed!"); ProgramExecutionLog.AddEntry( "Requested to uninstall Wpdt, but it was not installed"); } } if (status == ExecutionStatus.UninstallWdpt) { results.UninstallWdpt.SetResults(true, ""); ProcessOperations.KillSwanProcesses(); Console.WriteLine("Continuing build process after reboot from Wpdt uninstall ..."); GeneralFileOperations.WriteProgramStatusFile(ExecutionStatus.Running); } }
/// <summary> /// Helper function that will check to see if a file has a read only /// attribute set. If it does, then the attribute is removed. /// </summary> /// <param name="configuration">Main program configuration</param> /// <param name="fullFileName">File Name to check for read only attribute</param> public static void RemoveReadOnlyAttribute( BuildControlParameters configuration, string fullFileName) { FileInfo f = new FileInfo(fullFileName); if ((f.Attributes & FileAttributes.ReadOnly) != 0) { if (configuration.SourceDepotOnlineMode) { ProcessOperations.SDEdit(configuration, fullFileName); } else { f.Attributes = f.Attributes & ~FileAttributes.ReadOnly; } } }
/// <summary> /// Uninstalls the ydr. /// </summary> /// <param name="configuration">The configuration.</param> public static void UninstallYdr(BuildControlParameters configuration) { if (IsYdrInstalled(configuration)) { Console.Write("Beginning uninstall of YDR... "); try { string arguments = @"/x" + BuildControlParameters.YdrGuid + @" /qb /quiet"; ProcessInformation process = ProcessOperations.RunProcess(MsiExec, Application.StartupPath, arguments, true); Console.WriteLine("Completed!"); } catch (Exception e) { Console.WriteLine(" Failed to uninstall YDR!"); ProgramExecutionLog.AddEntry( "Failed to uninstall Ydr. Error message was " + e.Message); } } }
/// <summary> /// Syncs the enlistment. /// </summary> /// <param name="configuration">The configuration.</param> /// <param name="results">The results.</param> public static void SyncEnlistment( BuildControlParameters configuration, DailyBuildFullResults results) { Console.Write("Syncing Enlistment ... "); GeneralFileOperations.WriteProgramStatusFile(ExecutionStatus.SynEnlistment); try { ProcessInformation process = ProcessOperations.SDSync(configuration); CheckForErrorFromSDOperation(process, results, results.EnlistmentSync); Console.WriteLine("Success!"); } catch (Exception e) { Console.WriteLine("Fail!"); results.EnlistmentSync.SetResults(false, e.Message); ProgramExecutionLog.AddEntry( "Failed to sync enlistment " + " Error was " + e.Message); } Console.WriteLine("Enlistment Sync Status = " + results.EnlistmentSync.ToString()); }
public void Reset(BuildControlParameters configuration) { Build.Reset(); ModifyVersion.Reset(); RevertVersion.Reset(); SignXap.Reset(); LicenseXap.Reset(); if (configuration.BuildType == BuildTypeEnum.None) { Build.StatusToNotRun(); ModifyVersion.StatusToNotRun(); RevertVersion.StatusToNotRun(); SignXap.StatusToNotRun(); LicenseXap.StatusToNotRun(); } if (!configuration.UpdateDailyBuildVersion) { ModifyVersion.StatusToNotRun(); RevertVersion.StatusToNotRun(); } }