private async Task <Possible <Unit, Failure> > TryMaterializeCoreAsync( FileRealizationMode fileRealizationModes, ExpandedAbsolutePath path, ContentHash contentHash) { FileToDelete fileToDelete = FileToDelete.Create(path.ExpandedPath); string pathForCache = GetExpandedPathForCache(path); FileToDelete fileForCacheToDelete = (string.IsNullOrEmpty(pathForCache) || string.Equals(path.ExpandedPath, pathForCache, OperatingSystemHelper.PathComparison)) ? FileToDelete.Invalid : FileToDelete.Create(pathForCache); if (!m_replaceExistingFileOnMaterialization) { // BuildXL controls the file deletion if the place file mode is FailIfExists. var mayBeDelete = fileToDelete.TryDelete(); // The file materialization below can fail if fileToDelete and fileForCacheToDelete // point to different object files. One can think that fileForCacheToDelete should // be deleted as well by adding the following expression in the above statement: // // .Then(r => fileForCacheToDelete.IsValid ? fileForCacheToDelete.TryDelete() : r); // // However, this deletion masks a possibly serious underlying issue because we expect // both fileToDelete and fileForCacheToDelete point to the same object file. if (!mayBeDelete.Succeeded) { return(new FailToDeleteForMaterializationFailure(mayBeDelete.Failure)); } } if (fileRealizationModes.AllowVirtualization) { pathForCache = AddVfsSuffix(pathForCache); } Possible <ICacheSession, Failure> maybeOpen = m_cache.Get(nameof(TryMaterializeAsync)); Possible <string, Failure> maybePlaced = await PerformArtifactCacheOperationAsync( () => maybeOpen.ThenAsync(cache => cache.ProduceFileAsync( new CasHash(new global::BuildXL.Cache.Interfaces.Hash(contentHash)), pathForCache, GetFileStateForRealizationMode(fileRealizationModes))), nameof(TryMaterializeAsync)); if (!maybePlaced.Succeeded && maybePlaced.Failure.DescribeIncludingInnerFailures().Contains("File exists at destination")) { string diagnostic = await fileToDelete.GetDiagnosticsAsync(); diagnostic = fileForCacheToDelete.IsValid ? diagnostic + Environment.NewLine + (await fileForCacheToDelete.GetDiagnosticsAsync()) : diagnostic; return(maybePlaced.Failure.Annotate(diagnostic)); } return(maybePlaced.Then(p => Unit.Void)); }
public bool Run(out string ErrorMessage) { StringBuilder FailMessage = new StringBuilder(); if (FilesToSync.Count > 0) { List <string> RevisionsToSync = new List <string>(); foreach (FileInfo FileToSync in FilesToSync) { RevisionsToSync.Add(String.Format("{0}#have", PerforceUtils.EscapePath(FileToSync.FullName))); } StringWriter Log = new StringWriter(); if (!Perforce.Sync(RevisionsToSync, x => { }, new List <string>(), true, null, Log)) { FailMessage.Append(Log.ToString()); } } foreach (FileInfo FileToDelete in FilesToDelete) { try { FileToDelete.IsReadOnly = false; FileToDelete.Delete(); } catch (Exception Ex) { FailMessage.AppendFormat("{0} ({1})\r\n", FileToDelete.FullName, Ex.Message.Trim()); } } foreach (DirectoryInfo DirectoryToDelete in DirectoriesToDelete) { try { DirectoryToDelete.Delete(true); } catch (Exception Ex) { FailMessage.AppendFormat("{0} ({1})\r\n", DirectoryToDelete.FullName, Ex.Message.Trim()); } } if (FailMessage.Length == 0) { ErrorMessage = null; return(true); } else { ErrorMessage = FailMessage.ToString(); return(false); } }
public bool Run(out string ErrorMessage) { StringBuilder FailMessage = new StringBuilder(); foreach (FileInfo FileToSync in FilesToSync) { StringWriter Log = new StringWriter(); if (!Perforce.ForceSync(String.Format("{0}#have", FileToSync.FullName), Log)) { FailMessage.AppendFormat("{0} ({1})\r\n", FileToSync.FullName, Log.ToString().Trim().Replace('\n', ' ')); } } foreach (FileInfo FileToDelete in FilesToDelete) { try { FileToDelete.IsReadOnly = false; FileToDelete.Delete(); } catch (Exception Ex) { FailMessage.AppendFormat("{0} ({1})\r\n", FileToDelete.FullName, Ex.Message.Trim()); } } foreach (DirectoryInfo DirectoryToDelete in DirectoriesToDelete) { try { DirectoryToDelete.Delete(true); } catch (Exception Ex) { FailMessage.AppendFormat("{0} ({1})\r\n", DirectoryToDelete.FullName, Ex.Message.Trim()); } } if (FailMessage.Length == 0) { ErrorMessage = null; return(true); } else { ErrorMessage = FailMessage.ToString(); return(false); } }
public override void ExecuteBuild() { SetupStaticBuildEnvironment(); bool bBuildSolutions = true; if (ParseParam("SkipBuildSolutions")) { bBuildSolutions = false; } bool bBuildLibraries = true; if (ParseParam("SkipBuild")) { bBuildLibraries = false; } bool bAutoCreateChangelist = true; if (ParseParam("SkipCreateChangelist")) { bAutoCreateChangelist = false; } bool bAutoSubmit = false; // bAutoCreateChangelist; if (ParseParam("SkipSubmit")) { bAutoSubmit = false; } // if we don't pass anything, we'll just merge by default string RobomergeCommand = ParseParamValue("Robomerge", "").ToLower(); if (!string.IsNullOrEmpty(RobomergeCommand)) { // for merge default action, add flag to make sure buildmachine commit isn't skipped if (RobomergeCommand == "merge") { RobomergeCommand = "#robomerge[all] #DisregardExcludedAuthors"; } // otherwise add hashtags else if (RobomergeCommand == "ignore") { RobomergeCommand = "#robomerge #ignore"; } else if (RobomergeCommand == "null") { RobomergeCommand = "#robomerge #null"; } // otherwise the submit will likely fail. else { throw new AutomationException("Invalid Robomerge param passed in {0}. Must be \"merge\", \"null\", or \"ignore\"", RobomergeCommand); } } // get the platforms we want to build for List <TargetPlatformData> TargetPlatforms = GetTargetPlatforms(); // get the platforms we want to build for List <WindowsCompiler> TargetWindowsCompilers = GetTargetWindowsCompilers(); // get the configurations we want to build for List <string> TargetConfigurations = GetTargetConfigurations(); if (bBuildSolutions) { // build target lib for all platforms foreach (TargetPlatformData TargetData in TargetPlatforms) { if (!PlatformSupportsTargetLib(TargetData)) { continue; } SetupBuildForTargetLibAndPlatform(TargetData, TargetConfigurations, TargetWindowsCompilers, false); } } HashSet <FileReference> FilesToReconcile = new HashSet <FileReference>(); if (bBuildLibraries) { // build target lib for all platforms foreach (TargetPlatformData TargetData in TargetPlatforms) { if (!PlatformSupportsTargetLib(TargetData)) { continue; } HashSet <FileReference> FilesToDelete = new HashSet <FileReference>(); foreach (string TargetConfiguration in TargetConfigurations) { // Delete output files before building them if (TargetData.Platform == UnrealTargetPlatform.Win64) { foreach (WindowsCompiler TargetCompiler in TargetWindowsCompilers) { FindOutputFiles(FilesToDelete, TargetData, TargetConfiguration, TargetCompiler); } } else { FindOutputFiles(FilesToDelete, TargetData, TargetConfiguration); } } foreach (FileReference FileToDelete in FilesToDelete) { FilesToReconcile.Add(FileToDelete); InternalUtils.SafeDeleteFile(FileToDelete.ToString()); } BuildTargetLibForPlatform(TargetData, TargetConfigurations, TargetWindowsCompilers); if (DoesPlatformUseMSBuild(TargetData)) { foreach (WindowsCompiler TargetWindowsCompiler in TargetWindowsCompilers) { CopyLibsToFinalDestination(TargetData, TargetConfigurations, TargetWindowsCompiler); } } else { CopyLibsToFinalDestination(TargetData, TargetConfigurations); } } } int P4ChangeList = InvalidChangeList; if (bAutoCreateChangelist) { string RobomergeLine = string.Empty; if (!string.IsNullOrEmpty(RobomergeCommand)) { RobomergeLine = Environment.NewLine + RobomergeCommand; } P4ChangeList = P4.CreateChange(P4Env.Client, "BuildHlslcc.Automation: Deploying hlslcc libs." + Environment.NewLine + "#rb none" + Environment.NewLine + "#lockdown Nick.Penwarden" + Environment.NewLine + "#tests none" + Environment.NewLine + "#jira none" + Environment.NewLine + "#okforgithub ignore" + RobomergeLine); } if (P4ChangeList != InvalidChangeList) { foreach (string TargetConfiguration in TargetConfigurations) { //Add any new files that p4 is not yet tracking. foreach (TargetPlatformData TargetData in TargetPlatforms) { if (!PlatformSupportsTargetLib(TargetData)) { continue; } if (TargetData.Platform == UnrealTargetPlatform.Win64) { foreach (WindowsCompiler TargetCompiler in TargetWindowsCompilers) { FindOutputFiles(FilesToReconcile, TargetData, TargetConfiguration, TargetCompiler); } } else { FindOutputFiles(FilesToReconcile, TargetData, TargetConfiguration); } } } foreach (FileReference FileToReconcile in FilesToReconcile) { P4.Reconcile(P4ChangeList, FileToReconcile.ToString()); } } if (bAutoSubmit && (P4ChangeList != InvalidChangeList)) { if (!P4.TryDeleteEmptyChange(P4ChangeList)) { LogInformation("Submitting changelist " + P4ChangeList.ToString()); int SubmittedChangeList = InvalidChangeList; P4.Submit(P4ChangeList, out SubmittedChangeList); } else { LogInformation("Nothing to submit!"); } } }
private void UpdateOpenHAB() { ResetSummary(); string OpenHABUpdateFileWithPath; if (MainForm.UpdateTypeValue == 1) { UpdateDownloadComplete = false; Uri UpdateFileURI; string OpenHABUpdateFile; WebClient OpenHABDownload = new WebClient(); WriteLog("Downloading OpenHAB update" + Environment.NewLine, true); Uri.TryCreate(MainForm.UpdateURL.Text.Trim(), UriKind.Absolute, out UpdateFileURI); OpenHABUpdateFile = Path.GetFileName(UpdateFileURI.LocalPath); OpenHABUpdateFileWithPath = new Uri(MainForm.UpdatePath.Text.Trim() + "\\" + OpenHABUpdateFile.Trim()).LocalPath; if (File.Exists(OpenHABUpdateFileWithPath)) { File.Delete(OpenHABUpdateFileWithPath); } OpenHABDownload.DownloadProgressChanged += new DownloadProgressChangedEventHandler(DownloadProgressCallback); OpenHABDownload.DownloadFileCompleted += new AsyncCompletedEventHandler(DownloadFileCompletedCallback); try { OpenHABDownload.DownloadFileAsync(new System.Uri(MainForm.UpdateURL.Text.Trim()), OpenHABUpdateFileWithPath.Trim()); while (!UpdateDownloadComplete) { Application.DoEvents(); } } catch (Exception DownloadException) { WriteLog("An error occured while downloading OpenHAB update (" + DownloadException.Message + ")" + Environment.NewLine, true, true); return; } TotalNumberOfItems = 0; CurrentItemNumber = 0; bwrPerformUpdate.ReportProgress(0); } else { OpenHABUpdateFileWithPath = MainForm.UpdateFile.Text.Trim(); } if (!StopOpenHABService()) { return; } ZipArchive ZipFileToExtract = null; try { ZipFileToExtract = ZipFile.Open(OpenHABUpdateFileWithPath.Trim(), ZipArchiveMode.Read); } catch (Exception UpdateException) { WriteLog("Cannot update OpenHAB using update file: " + OpenHABUpdateFileWithPath.Trim() + " (" + UpdateException.Message + ")" + Environment.NewLine, true, true); return; } foreach (ZipArchiveEntry ZipEntryToCount in ZipFileToExtract.Entries) { if (!string.IsNullOrEmpty(ZipEntryToCount.FullName)) { TotalNumberOfItems++; } } if (MainForm.BeforeUpdatingValue == 2) { CreateFullBackup(); } else if (MainForm.BeforeUpdatingValue == 3) { CreateConfigurationBackup(); } WriteLog("Updating OpenHAB using update file: " + OpenHABUpdateFileWithPath.Trim() + Environment.NewLine, true); var FilesToDelete = File.ReadAllLines(AppDomain.CurrentDomain.BaseDirectory + "DeleteList.dat"); foreach (var FileToDelete in FilesToDelete) { bool IsFolder = false; if ((!FileToDelete.ToString().Trim().Contains("*")) && (!FileToDelete.ToString().Trim().Contains("?")) && (Directory.Exists(new Uri(MainForm.OpenHABPath.Text.Trim() + "\\" + FileToDelete.ToString().Trim()).LocalPath))) { if (File.GetAttributes(new Uri(MainForm.OpenHABPath.Text.Trim() + "\\" + FileToDelete.ToString().Trim()).LocalPath).HasFlag(FileAttributes.Directory)) { IsFolder = true; } } if (IsFolder) { try { Directory.Delete(new Uri(MainForm.OpenHABPath.Text.Trim() + "\\" + FileToDelete.ToString().Trim()).LocalPath, true); SummaryFoldersDeleteSucceeded++; WriteLog("Deleting folder: " + new Uri(MainForm.OpenHABPath.Text.Trim() + "\\" + FileToDelete.ToString().Trim()).LocalPath); } catch (Exception DeleteException) { SummaryFoldersDeleteFailed++; WriteLog("Cannot delete folder: " + new Uri(MainForm.OpenHABPath.Text.Trim() + "\\" + FileToDelete.ToString().Trim()).LocalPath + " (" + DeleteException.Message + ")", false, true); } } else { foreach (var SingleFile in Directory.GetFiles(new Uri(MainForm.OpenHABPath.Text.Trim() + "\\").LocalPath, FileToDelete)) { try { File.Delete(SingleFile.ToString().Trim()); SummaryFilesDeleteSucceeded++; WriteLog("Deleting file: " + SingleFile.ToString().Trim()); } catch (Exception DeleteException) { SummaryFilesDeleteFailed++; WriteLog("Cannot delete file: " + SingleFile.ToString().Trim() + " (" + DeleteException.Message + ")", false, true); } } } } foreach (ZipArchiveEntry ZipEntryToExtract in ZipFileToExtract.Entries) { CurrentItemNumber++; if (String.IsNullOrEmpty(ZipEntryToExtract.Name)) { if (!Directory.Exists(new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath.Substring(0, new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath.Length - ZipEntryToExtract.Name.Length))) { try { Directory.CreateDirectory(new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath.Substring(0, new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath.Length - ZipEntryToExtract.Name.Length)); bwrPerformUpdate.ReportProgress(CurrentItemNumber * 100 / TotalNumberOfItems); SummaryFoldersCreateSucceeded++; WriteLog("Creating folder: " + new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath.Substring(0, new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath.Length - ZipEntryToExtract.Name.Length)); } catch (Exception UpdateException) { SummaryFoldersCreateFailed++; WriteLog("Cannot create folder: " + new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath.Substring(0, new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath.Length - ZipEntryToExtract.Name.Length) + " (" + UpdateException.Message + ")", false, true); } } } else { try { ZipEntryToExtract.ExtractToFile(new Uri(Path.Combine(MainForm.OpenHABPath.Text.Trim(), ZipEntryToExtract.FullName)).LocalPath, false); bwrPerformUpdate.ReportProgress(CurrentItemNumber * 100 / TotalNumberOfItems); SummaryFilesExtractSucceeded++; WriteLog("Extracting file: " + ZipEntryToExtract.FullName); } catch (Exception UpdateException) { bwrPerformUpdate.ReportProgress(CurrentItemNumber * 100 / TotalNumberOfItems); SummaryFilesExtractSkipped++; WriteLog("Skipping file extraction: " + ZipEntryToExtract.FullName + " (" + UpdateException.Message.ToString() + ")"); } } } ZipFileToExtract.Dispose(); WriteSummary("Update summary"); WriteLog(Environment.NewLine + "Update complete" + Environment.NewLine, true); }
private void CreateConfigurationBackup() { ResetSummary(); int NumberOfBackupsToDelete = 0; string BackupZipFileName = ""; TotalNumberOfItems += Directory.GetFiles(MainForm.OpenHABPath.Text.Trim() + "\\userdata", "*.*", SearchOption.AllDirectories).Length; TotalNumberOfItems += Directory.GetFiles(MainForm.OpenHABPath.Text.Trim() + "\\conf", "*.*", SearchOption.AllDirectories).Length; if (MainForm.DeleteOldConfigurationBackups.Checked) { NumberOfBackupsToDelete = Directory.GetFiles(MainForm.BackupPath.Text.Trim(), "OpenHAB_Configuration*.zip", SearchOption.TopDirectoryOnly).Length; NumberOfBackupsToDelete -= Convert.ToInt16(MainForm.KeepLastConfigurationBackups.Value); NumberOfBackupsToDelete++; if (NumberOfBackupsToDelete > 0) { TotalNumberOfItems += NumberOfBackupsToDelete; var BackupPathFolder = new DirectoryInfo(MainForm.BackupPath.Text.Trim()); FileInfo[] FilesToDelete = BackupPathFolder.EnumerateFiles("OpenHAB_Configuration*.zip").Take(NumberOfBackupsToDelete).OrderBy(BackupWriteTime => BackupWriteTime.LastWriteTime).ToArray(); foreach (var FileToDelete in FilesToDelete) { try { CurrentItemNumber++; FileToDelete.Delete(); SummaryBackupsDeleteSucceeded++; WriteLog("Deleting configuration backup: " + FileToDelete.Name + Environment.NewLine, true); } catch (Exception DeleteException) { SummaryBackupsDeleteFailed++; WriteLog("Cannot delete configuration backup: " + FileToDelete.Name + " (" + DeleteException.Message + ")" + Environment.NewLine, true, true); } } } } BackupZipFileName = MainForm.BackupPath.Text.Trim() + "\\OpenHAB_Configuration_" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".zip"; ZipArchive BackupZipFile = null; try { BackupZipFile = ZipFile.Open(BackupZipFileName, ZipArchiveMode.Create); WriteLog("Creating configuration backup archive: " + BackupZipFileName + Environment.NewLine, true); } catch (Exception CompressionException) { WriteLog("Cannot create configuration backup archive: " + BackupZipFileName + " (" + CompressionException.Message + ")", true, true); return; } foreach (string FileToBackup in Directory.GetFiles(MainForm.OpenHABPath.Text.Trim() + "\\userdata", "*.*", SearchOption.AllDirectories)) { try { CurrentItemNumber++; BackupZipFile.CreateEntryFromFile(FileToBackup, FileToBackup.Substring(MainForm.OpenHABPath.Text.Trim().Length + 1)); if (OperationTypeId == OperationType.Update) { bwrPerformUpdate.ReportProgress(CurrentItemNumber * 100 / TotalNumberOfItems); } else { bwrCompressConfigurationBackup.ReportProgress(CurrentItemNumber * 100 / TotalNumberOfItems); } SummaryFilesCompressSucceeded++; WriteLog("Compressing file: " + FileToBackup); } catch (Exception CompressionException) { SummaryFilesCompressFailed++; WriteLog("Cannot compress file: " + FileToBackup + " (" + CompressionException.Message + ")", false, true); } } foreach (string FileToBackup in Directory.GetFiles(MainForm.OpenHABPath.Text.Trim() + "\\conf", "*.*", SearchOption.AllDirectories)) { try { CurrentItemNumber++; BackupZipFile.CreateEntryFromFile(FileToBackup, FileToBackup.Substring(MainForm.OpenHABPath.Text.Trim().Length + 1)); if (OperationTypeId == OperationType.Update) { bwrPerformUpdate.ReportProgress(CurrentItemNumber * 100 / TotalNumberOfItems); } else { bwrCompressConfigurationBackup.ReportProgress(CurrentItemNumber * 100 / TotalNumberOfItems); } SummaryFilesCompressSucceeded++; WriteLog("Compressing file: " + FileToBackup); } catch (Exception CompressionException) { SummaryFilesCompressFailed++; WriteLog("Cannot compress file: " + FileToBackup + " (" + CompressionException.Message + ")", false, true); } } BackupZipFile.Dispose(); WriteSummary("Configuration backup summary"); WriteLog(Environment.NewLine + "Configuration backup complete" + Environment.NewLine, true); }
private async Task <Possible <Unit, Failure> > TryMaterializeCoreAsync( FileRealizationMode fileRealizationModes, ExpandedAbsolutePath path, ContentHash contentHash) { FileToDelete fileToDelete = FileToDelete.Create(path.ExpandedPath); string pathForCache = GetExpandedPathForCache(path); FileToDelete fileForCacheToDelete = (string.IsNullOrEmpty(pathForCache) || string.Equals(path.ExpandedPath, pathForCache, OperatingSystemHelper.IsUnixOS ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase)) ? FileToDelete.Invalid : FileToDelete.Create(pathForCache); if (!m_replaceExistingFileOnMaterialization) { // BuildXL controls the file deletion if the place file mode is FailIfExists. var mayBeDelete = fileToDelete.TryDelete(); // The file materialization below can fail if fileToDelete and fileForCacheToDelete // point to different object files. One can think that fileForCacheToDelete should // be deleted as well by adding the following expression in the above statement: // // .Then(r => fileForCacheToDelete.IsValid ? fileForCacheToDelete.TryDelete() : r); // // However, this deletion masks a possibly serious underlying issue because we expect // both fileToDelete and fileForCacheToDelete point to the same object file. if (!mayBeDelete.Succeeded) { return(mayBeDelete.Failure); } } Possible <ICacheSession, Failure> maybeOpen = m_cache.Get(nameof(TryMaterializeAsync)); Possible <string, Failure> maybePlaced = await maybeOpen.ThenAsync(cache => cache.ProduceFileAsync( new CasHash(new global::BuildXL.Cache.Interfaces.Hash(contentHash)), pathForCache, GetFileStateForRealizationMode(fileRealizationModes))); if (!maybePlaced.Succeeded && maybePlaced.Failure.DescribeIncludingInnerFailures().Contains("File exists at destination")) { string diagnostic = await fileToDelete.GetDiagnosticsAsync(); diagnostic = fileForCacheToDelete.IsValid ? diagnostic + Environment.NewLine + (await fileForCacheToDelete.GetDiagnosticsAsync()) : diagnostic; return(maybePlaced.Failure.Annotate(diagnostic)); } return(maybePlaced.Then(p => { // TODO:58494: Occasionally we see odd behavior where materialization seems to succeed, but the file is not present in the file system // layer. This check tries to see if the file exits after successful materialization and fails if it doesn't. if (!FileUtilities.FileExistsNoFollow(pathForCache)) { return new Failure <string>(string.Format( CultureInfo.InvariantCulture, "The file '{0}' with content hash '{1}' was materialzed successfully, but can't be found on disk", pathForCache, contentHash)); } return new Possible <Unit, Failure>(Unit.Void); })); }