public override BuildResults Crawl()
{
if (CosmosStream.StreamExists(base.URI))
{
string randomFilePath = this.PrepareFolderAndRandomFile();
for (int count = 0; count < 3; count++)
{
BuildResults result = CrawlInternal(randomFilePath);
switch (result)
{
case BuildResults.Crawler_Succeed:
FileHelper.MoveFile(randomFilePath, this.LocalPath);
return(result);
case BuildResults.Crawler_NoNewFileFound:
return(result);
default:
System.Threading.Thread.Sleep(1000);
break;
}
}
return(BuildResults.Crawler_UnexpectedError);
}
else
{
return(BuildResults.Crawler_CannotCopyRemoteFile);
}
}
protected void CallbackMethod(BuildResults results)
{
lastBuildResults = results;
ShowResults(results);
AfterBuild();
OnBuildComplete(EventArgs.Empty);
}
private async Task <BuildResults> BuildAsync(string target = Targets.GetBuildVersion, LoggerVerbosity logVerbosity = LoggerVerbosity.Detailed, bool assertSuccessfulBuild = true)
{
var eventLogger = new MSBuildLogger {
Verbosity = LoggerVerbosity.Minimal
};
var loggers = new ILogger[] { eventLogger };
var buildResult = await this.buildManager.BuildAsync(
this.Logger,
this.projectCollection,
this.testProject,
target,
this.globalProperties,
logVerbosity,
loggers);
var result = new BuildResults(buildResult, eventLogger.LoggedEvents);
this.Logger.WriteLine(result.ToString());
if (assertSuccessfulBuild)
{
Assert.Equal(BuildResultCode.Success, buildResult.OverallResult);
}
return(result);
}
protected void CallbackMethod(BuildResults results)
{
lastBuildResults = results;
ShowResults(results);
AfterBuild();
OnBuildComplete(EventArgs.Empty);
}
public void Build(ExecutionCompletedHandler handler = null)
{
Status = ApplicationStatus.Building;
if (AppEnvironment.Settings.TestMode)
{
SolutionObj = new DummySolution(WorkSpace, Solution);
}
else
{
SolutionObj = new Solution(WorkSpace, Solution);
}
SolutionObj.ExecutionCompleted += handler;
SolutionObj.ExecutionCompleted += (s, e) => {
var buildResults = BuildResults.FromOutput(SolutionObj.Output);
StatusMessage = buildResults.ToString();
if (buildResults.Success)
{
Status = ApplicationStatus.BuildCompleted;
}
else
{
Status = ApplicationStatus.BuildFailed;
}
};
var binaries = WorkSpace + Path.GetDirectoryName(Solution) + BinaryDirectory;
OutputDirectory = GetNextOutputDirectory();
SolutionObj.BuildAsync(binaries, OutputDirectory);
SetActiveApplication(_parent);
Status = ApplicationStatus.Building;
}
public override bool Execute()
{
if (LauncherPath == null)
{
// Launcher lives next to ClickOnce bootstrapper.
// GetDefaultPath obtains the root ClickOnce boostrapper path.
LauncherPath = Path.Combine(
Microsoft.Build.Tasks.Deployment.Bootstrapper.Util.GetDefaultPath(VisualStudioVersion),
ENGINE_PATH,
LAUNCHER_EXE);
}
if (EntryPoint == null)
{
Log.LogErrorWithCodeFromResources("GenerateLauncher.InvalidInput");
return(false);
}
var launcherBuilder = new LauncherBuilder(LauncherPath);
string entryPointFileName = Path.GetFileName(EntryPoint.ItemSpec);
//
// If the EntryPoint specified is apphost.exe, we need to use the assemblyname instead since
// apphost.exe is the source file that will get copied to outdir as {assemblyname}.exe.
//
if (entryPointFileName.Equals(Constants.AppHostExe, StringComparison.InvariantCultureIgnoreCase) &&
!String.IsNullOrEmpty(AssemblyName))
{
entryPointFileName = AssemblyName;
}
BuildResults results = launcherBuilder.Build(entryPointFileName, OutputPath);
BuildMessage[] messages = results.Messages;
if (messages != null)
{
foreach (BuildMessage message in messages)
{
switch (message.Severity)
{
case BuildMessageSeverity.Error:
Log.LogError(null, message.HelpCode, message.HelpKeyword, null, 0, 0, 0, 0, message.Message);
break;
case BuildMessageSeverity.Warning:
Log.LogWarning(null, message.HelpCode, message.HelpKeyword, null, 0, 0, 0, 0, message.Message);
break;
case BuildMessageSeverity.Info:
Log.LogMessage(null, message.HelpCode, message.HelpKeyword, null, 0, 0, 0, 0, message.Message);
continue;
}
}
}
OutputEntryPoint = new TaskItem(Path.Combine(Path.GetDirectoryName(EntryPoint.ItemSpec), results.KeyFile));
OutputEntryPoint.SetMetadata(ItemMetadataNames.targetPath, results.KeyFile);
return(!Log.HasLoggedErrors);
}
protected void CallbackMethod(BuildResults results)
{
lastBuildResults = results;
ShowResults(results);
AfterBuild();
if (BuildComplete != null)
BuildComplete(this, EventArgs.Empty);
}
BuildResults GetBuildTimeoutResult()
{
var results = new BuildResults {
Result = BuildResultCode.Error
};
results.Add(new BuildError(String.Empty, "Timed out waiting for build to complete."));
return(results);
}
protected void CallbackMethod(BuildResults results)
{
lastBuildResults = results;
ShowResults(results);
AfterBuild();
if (BuildComplete != null)
{
BuildComplete(this, EventArgs.Empty);
}
}
public void OnBuildExit(BuildResults result)
{
BuildExited = true;
BuildResult = result;
_LoadIssuesFromFile(Path.Combine(BuildInfo.LogsDirPath, BuildManager.MsBuildIssuesFileName));
UpdateIssuesList();
GodotSharpEditor.Instance.BottomPanel.RaiseBuildTab(this);
}
public void DefaultBuildTasks_WriteSerializedFiles()
{
IBuildParameters buildParams = GetBuildParameters();
IDependencyData dependencyData = new BuildDependencyData();
IWriteData writeData = new BuildWriteData();
IBuildResults results = new BuildResults();
ReturnCode exitCode = RunTask <WriteSerializedFiles>(buildParams, dependencyData, writeData, results);
Assert.AreEqual(ReturnCode.Success, exitCode);
}
void UpdateLastBuildInfo(BuildResults buildResults)
{
if (buildResults.ErrorCount > 0)
{
lastBuildInfo = 1;
}
else
{
lastBuildInfo = 0;
}
}
public override BuildResults Crawl()
{
string randomFilePath = this.PrepareFolderAndRandomFile();
Exception exception = null;
//CustomHttpCrawler client = new CustomHttpCrawler(new Uri(base.URI), randomFilePath, this.Encoding, this.LocalVersion, this.UserAgent);
using (CustomWebClient client = new CustomWebClient(new Uri(base.URI), randomFilePath, this.Encoding, this.LocalVersion, this.UserAgent, proxyType))
{
if (this.ManualProxy != null)
{
client.ManualProxy = this.ManualProxy;
}
//[Bug 730427:DownloadFileActivity need return directly when set manully proxy and download failed]
for (int count = 0; count < CustomWebClient.ProxyList.Count; count++)
{
BuildResults result = client.DownloadFile();
this.RemoteVersion = client.RemoteVersion;
exception = client.Exception;
switch (result)
{
case BuildResults.Crawler_Succeed:
FileHelper.MoveFile(randomFilePath, this.LocalPath);
return(BuildResults.Crawler_Succeed);
case BuildResults.Crawler_NoNewFileFound:
return(result);
case BuildResults.Crawler_404NotFound:
throw exception;
case BuildResults.Crawler_RemoteServerNoResponse:
case BuildResults.Crawler_UnexpectedError:
//System.Threading.Thread.Sleep(5 * 1000);
break;
case BuildResults.Crawler_ProtocolError:
throw exception;
}
}
}
if (exception == null)
{
return(BuildResults.Crawler_UnexpectedError);
}
else
{
throw exception;
}
}
public static void ShowResults(BuildResults results)
{
if (results != null) {
TaskService.InUpdate = true;
foreach (BuildError error in results.Errors) {
TaskService.Add(new Task(error));
}
TaskService.InUpdate = false;
if (results.Errors.Count > 0 && ErrorListPad.ShowAfterBuild) {
WorkbenchSingleton.Workbench.GetPad(typeof(ErrorListPad)).BringPadToFront();
}
}
}
public BuildEventArgs(IBuildable buildable, BuildOptions options, BuildResults results)
{
if (buildable == null)
{
throw new ArgumentNullException("buildable");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
this.Buildable = buildable;
this.Options = options;
this.Results = results;
}
public override void Run()
{
if (BuildModifiedProjectsOnlyService.Setting == BuildOnExecuteSetting.DoNotBuild)
{
LastBuildResults = new BuildResults {
Result = BuildResultCode.Success
};
OnBuildComplete(EventArgs.Empty);
}
else
{
base.Run();
}
}
public override void Run()
{
if (BuildOptions.BuildOnExecute == BuildDetection.DoNotBuild)
{
LastBuildResults = new BuildResults {
Result = BuildResultCode.Success
};
OnBuildComplete(EventArgs.Empty);
}
else
{
base.Run();
}
}
private async Task <BuildResults> BuildAsync(string target = Targets.GetBuildVersion)
{
var buildResult = await this.buildManager.BuildAsync(
this.Logger,
this.projectCollection,
this.testProject,
target,
this.globalProperties);
var result = new BuildResults(buildResult);
this.Logger.WriteLine(result.ToString());
Assert.Equal(BuildResultCode.Success, buildResult.OverallResult);
return(result);
}
/// <summary>
/// Runs the test for the project after a successful build.
/// </summary>
void OnBuildComplete(BuildResults results, SelectedTests selectedTests)
{
if (BuildHasNoErrorsAndStillRunningTests(results))
{
RunTests(selectedTests);
}
else
{
if (IsRunningTest)
{
Stop();
}
ShowErrorList();
}
}
public static void ShowResults(BuildResults results)
{
if (results != null)
{
TaskService.InUpdate = true;
foreach (BuildError error in results.Errors)
{
TaskService.Add(new Task(error));
}
TaskService.InUpdate = false;
if (results.Errors.Count > 0 && ErrorListPad.ShowAfterBuild)
{
WorkbenchSingleton.Workbench.GetPad(typeof(ErrorListPad)).BringPadToFront();
}
}
}
public void Build(IProject project)
{
var build = new BuildProject(project);
build.BuildComplete += BuildComplete;
buildCompleteEvent.Reset();
WorkbenchSingleton.SafeThreadAsyncCall(() => build.Run());
if (buildCompleteEvent.WaitOne(DefaultBuildTimeout))
{
BuildResults = build.LastBuildResults;
}
else
{
BuildResults = GetBuildTimeoutResult();
}
build.BuildComplete -= BuildComplete;
}
public void Build(IProject project)
{
var build = new BuildProject(project);
build.BuildComplete += BuildComplete;
buildCompleteEvent.Reset();
SD.MainThread.InvokeAsyncAndForget(() => build.Run());
if (buildCompleteEvent.WaitOne(DefaultBuildTimeout))
{
BuildResults = build.LastBuildResults;
}
else
{
BuildResults = GetBuildTimeoutResult();
}
build.BuildComplete -= BuildComplete;
}
public BuildResults Build(string filename, string outputPath)
{
string launcherFilename = Path.GetFileName(LauncherPath);
_results = new BuildResults();
try
{
if (filename == null)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.InvalidInput"));
return(_results);
}
if (String.IsNullOrEmpty(outputPath))
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.NoOutputPath"));
return(_results);
}
// Copy setup.bin to the output directory
string strOutputExe = System.IO.Path.Combine(outputPath, launcherFilename);
if (!CopyLauncherToOutputDirectory(strOutputExe))
{
// Appropriate messages should have been stuffed into the results already
return(_results);
}
var resourceUpdater = new ResourceUpdater();
resourceUpdater.AddStringResource(LAUNCHER_RESOURCE_TABLE, LAUNCHER_RESOURCENAME, filename);
if (!resourceUpdater.UpdateResources(strOutputExe, _results))
{
return(_results);
}
_results.SetKeyFile(launcherFilename);
_results.BuildSucceeded();
}
catch (Exception ex)
{
_results.AddMessage(BuildMessage.CreateMessage(BuildMessageSeverity.Error, "GenerateLauncher.General", ex.Message));
}
return(_results);
}
/// <summary>
/// Runs the test for the project after a successful build.
/// </summary>
void OnBuildComplete(BuildResults results, IProject project, string namespaceFilter, IClass fixture, IMember test)
{
if (results.ErrorCount == 0 && IsRunningTest)
{
UnitTestApplicationStartHelper helper = new UnitTestApplicationStartHelper();
UnitTestingOptions options = new UnitTestingOptions();
helper.NoThread = options.NoThread;
helper.NoLogo = options.NoLogo;
helper.NoDots = options.NoDots;
helper.Labels = options.Labels;
helper.ShadowCopy = !options.NoShadow;
if (options.CreateXmlOutputFile)
{
helper.XmlOutputFile = Path.Combine(Path.GetDirectoryName(project.OutputAssemblyFullPath), project.AssemblyName + "-TestResult.xml");
}
helper.Initialize(project, namespaceFilter, fixture, test);
helper.Results = Path.GetTempFileName();
ResetTestResults(project);
testResultsMonitor.FileName = helper.Results;
testResultsMonitor.Start();
try {
RunTests(helper);
} catch {
StopMonitoring();
throw;
}
}
else
{
if (IsRunningTest)
{
Stop();
}
if (TaskService.SomethingWentWrong && ErrorListPad.ShowAfterBuild)
{
ShowErrorList();
}
}
}
public void DefaultBuildTasks_PostScriptsCallbacks()
{
bool scriptsCallbackCalled = false;
IBuildParameters buildParameters = GetBuildParameters();
IBuildResults results = new BuildResults();
BuildCallbacks callback = new BuildCallbacks();
callback.PostScriptsCallbacks = (parameters, buildResults) =>
{
scriptsCallbackCalled = true;
return(ReturnCode.Success);
};
ReturnCode exitCode = RunTask <PostScriptsCallback>(buildParameters, results, callback);
Assert.AreEqual(ReturnCode.Success, exitCode);
Assert.IsTrue(scriptsCallbackCalled);
}
public void DefaultBuildTasks_PostWritingCallback()
{
bool writingCallbackCalled = false;
IBuildParameters buildParams = GetBuildParameters();
IDependencyData dep = GetDependencyData();
IWriteData writeData = new BuildWriteData();
IBuildResults results = new BuildResults();
BuildCallbacks callback = new BuildCallbacks();
callback.PostWritingCallback = (parameters, data, arg3, arg4) =>
{
writingCallbackCalled = true;
return(ReturnCode.Success);
};
ReturnCode exitCode = RunTask <PostWritingCallback>(buildParams, dep, writeData, results, callback);
Assert.AreEqual(ReturnCode.Success, exitCode);
Assert.IsTrue(writingCallbackCalled);
}
private void AssertStandardProperties(string prerelease, BuildResults buildResult)
{
int height = this.Repo.Head.GetHeight();
string commitIdShort = this.Repo.Head.Commits.First().Id.Sha.Substring(0, 10);
Version version = this.Repo.Head.Commits.First().GetIdAsVersion();
Assert.Equal($"{version}", buildResult.AssemblyFileVersion);
Assert.Equal($"{version.Major}.{version.Minor}.{height}{prerelease}+g{commitIdShort}", buildResult.AssemblyInformationalVersion);
Assert.Equal($"{version.Major}.{version.Minor}", buildResult.AssemblyVersion);
Assert.Equal(height.ToString(), buildResult.BuildNumber);
Assert.Equal(height.ToString(), buildResult.BuildNumberFirstAndSecondComponentsIfApplicable);
Assert.Equal(height.ToString(), buildResult.BuildNumberFirstComponent);
Assert.Equal(string.Empty, buildResult.BuildNumberSecondComponent);
Assert.Equal($"{version}", buildResult.BuildVersion);
Assert.Equal($"{version.Major}.{version.Minor}.{height}", buildResult.BuildVersion3Components);
Assert.Equal(height.ToString(), buildResult.BuildVersionNumberComponent);
Assert.Equal($"{version.Major}.{version.Minor}.{height}", buildResult.BuildVersionSimple);
Assert.Equal(this.Repo.Head.Commits.First().Id.Sha, buildResult.GitCommitId);
Assert.Equal(commitIdShort, buildResult.GitCommitIdShort);
Assert.Equal(height.ToString(), buildResult.GitHeight);
Assert.Equal($"{version.Major}.{version.Minor}", buildResult.MajorMinorVersion);
Assert.Equal(prerelease, buildResult.PrereleaseVersion);
Assert.Equal($"+g{commitIdShort}", buildResult.SemVerBuildSuffix);
}
public override BuildResults Crawl()
{
if (File.Exists(base.URI))
{
string randomFilePath = this.PrepareFolderAndRandomFile();
BuildResults result = CrawlInternal(randomFilePath);
switch (result)
{
case BuildResults.Crawler_Succeed:
FileHelper.MoveFile(randomFilePath, this.LocalPath);
break;
default:
break;
}
return(result);
}
else
{
return(BuildResults.Crawler_CannotCopyRemoteFile);
}
}
private void timer1_Tick(object sender, EventArgs e)
{
string message = string.Empty;
try
{
timer1.Stop();
var config = new Configuration().Load();
// get latest build
JenkinsJob job = JsonHelpers.GetJsonDataFor<JenkinsJob>(string.Format(@"/job/{0}", config.JobNames[0]));
JenkinsJobDetails jobDetails = JsonHelpers.GetJsonDataFor<JenkinsJobDetails>(string.Format("/job/{0}/{1}", job.Name, job.LastBuild.Number));
var causeJson = JsonConvert.SerializeObject(jobDetails.Actions[0]);
jobDetails.Causes = JsonConvert.DeserializeObject<CausesObject>(causeJson);
if (jobDetails == null || jobDetails.Result == null)
{
return;
}
if (jobDetails.Result.Equals("FAILURE", StringComparison.InvariantCultureIgnoreCase) && this.LastBuildResult != BuildResults.FAILURE)
{
this.LastBuildResult = BuildResults.FAILURE;
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1));
this.notifyIcon1.Icon = ((System.Drawing.Icon)(resources.GetObject("notifyIcon1.Error")));
notifyIcon1.ShowBalloonTip(10000, "Build Failed", jobDetails.Causes.Causes[0].UserName + " broke the build.", ToolTipIcon.Error);
this.notifyIcon1.Text = "Butler says Last Build Failed by " + jobDetails.Causes.Causes[0].UserName;
}
if (jobDetails.Result.Equals("SUCCESS", StringComparison.InvariantCultureIgnoreCase) && this.LastBuildResult != BuildResults.SUCCESS)
{
this.LastBuildResult = BuildResults.SUCCESS;
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(Form1));
this.notifyIcon1.Icon = ((System.Drawing.Icon)(resources.GetObject("notifyIcon1.Icon")));
notifyIcon1.ShowBalloonTip(10000, "Build Is now back to normal", "Build Is back to normal", ToolTipIcon.Info);
this.notifyIcon1.Text = "Butler says All builds are good!";
}
timer1.Start();
}
catch (Exception ex)
{
message = ex.Message;
}
finally
{
if (!string.IsNullOrEmpty(message))
{
notifyIcon1.ShowBalloonTip(5000, "Invalid Jenkins Server or Job Name", message, ToolTipIcon.Error);
}
else
{
timer1.Start();
}
}
}
public FakeProjectBuilder()
{
BuildResults = new BuildResults();
}
private async Task<BuildResults> BuildAsync(string target = Targets.GetBuildVersion)
{
var buildResult = await this.buildManager.BuildAsync(
this.Logger,
this.projectCollection,
this.testProject,
target,
this.globalProperties);
var result = new BuildResults(buildResult);
this.Logger.WriteLine(result.ToString());
Assert.Equal(BuildResultCode.Success, buildResult.OverallResult);
return result;
}
private async Task<BuildResults> BuildAsync(ProjectRootElement project, string target = Targets.GetBuildVersion, LoggerVerbosity logVerbosity = LoggerVerbosity.Detailed, bool assertSuccessfulBuild = true)
{
var eventLogger = new MSBuildLogger { Verbosity = LoggerVerbosity.Minimal };
var loggers = new ILogger[] { eventLogger };
var buildResult = await this.buildManager.BuildAsync(
this.Logger,
this.projectCollection,
project,
target,
this.globalProperties,
logVerbosity,
loggers);
var result = new BuildResults(buildResult, eventLogger.LoggedEvents);
this.Logger.WriteLine(result.ToString());
if (assertSuccessfulBuild)
{
Assert.Equal(BuildResultCode.Success, buildResult.OverallResult);
}
return result;
}
/// <summary>
/// Generate the bootstrapper.
/// </summary>
/// <returns> Return true on success, false on failure.</returns>
public override bool Execute()
{
if (_path == null)
{
_path = Util.GetDefaultPath(_visualStudioVersion);
}
BootstrapperBuilder bootstrapperBuilder = new BootstrapperBuilder();
bootstrapperBuilder.Validate = this.Validate;
bootstrapperBuilder.Path = this.Path;
ProductCollection products = bootstrapperBuilder.Products;
BuildSettings settings = new BuildSettings();
settings.ApplicationFile = ApplicationFile;
settings.ApplicationName = ApplicationName;
settings.ApplicationRequiresElevation = ApplicationRequiresElevation;
settings.ApplicationUrl = ApplicationUrl;
settings.ComponentsLocation = ConvertStringToComponentsLocation(this.ComponentsLocation);
settings.ComponentsUrl = ComponentsUrl;
settings.CopyComponents = CopyComponents;
settings.Culture = _culture;
settings.FallbackCulture = _fallbackCulture;
settings.OutputPath = this.OutputPath;
settings.SupportUrl = this.SupportUrl;
if (String.IsNullOrEmpty(settings.Culture) || settings.Culture == "*")
{
settings.Culture = settings.FallbackCulture;
}
if (this.BootstrapperItems != null)
{
// The bootstrapper items may not be in the correct order, because XMake saves
// items in alphabetical order. So we will attempt to put items into the correct
// order, according to the Products order in the search. To do this, we add all
// the items we are told to build into a hashtable, then go through our products
// in order, looking to see if the item is built. If it is, remove the item from
// the hashtable. All remaining items in the table can not be built, so errors
// will be issued.
Hashtable items = new Hashtable(StringComparer.OrdinalIgnoreCase);
foreach (ITaskItem bootstrapperItem in this.BootstrapperItems)
{
string installAttribute = bootstrapperItem.GetMetadata("Install");
if (String.IsNullOrEmpty(installAttribute) || Shared.ConversionUtilities.ConvertStringToBool(installAttribute))
{
if (!items.Contains(bootstrapperItem.ItemSpec))
{
items.Add(bootstrapperItem.ItemSpec, bootstrapperItem);
}
else
{
Log.LogWarningWithCodeFromResources("GenerateBootstrapper.DuplicateItems", bootstrapperItem.ItemSpec);
}
}
}
foreach (Product product in products)
{
if (items.Contains(product.ProductCode))
{
settings.ProductBuilders.Add(product.ProductBuilder);
items.Remove(product.ProductCode);
}
}
foreach (ITaskItem bootstrapperItem in items.Values)
{
Log.LogWarningWithCodeFromResources("GenerateBootstrapper.ProductNotFound", bootstrapperItem.ItemSpec, bootstrapperBuilder.Path);
}
}
BuildResults results = bootstrapperBuilder.Build(settings);
BuildMessage[] messages = results.Messages;
if (messages != null)
{
foreach (BuildMessage message in messages)
{
if (message.Severity == BuildMessageSeverity.Error)
{
Log.LogError(null, message.HelpCode, message.HelpKeyword, null, 0, 0, 0, 0, message.Message);
}
else if (message.Severity == BuildMessageSeverity.Warning)
{
Log.LogWarning(null, message.HelpCode, message.HelpKeyword, null, 0, 0, 0, 0, message.Message);
}
}
}
this.BootstrapperKeyFile = results.KeyFile;
this.BootstrapperComponentFiles = results.ComponentFiles;
return(results.Succeeded);
}
private void AssertStandardProperties(VersionOptions versionOptions, BuildResults buildResult, string relativeProjectDirectory = null)
{
int versionHeight = this.Repo.GetVersionHeight(relativeProjectDirectory);
Version idAsVersion = this.Repo.GetIdAsVersion(relativeProjectDirectory);
string commitIdShort = this.Repo.Head.Commits.First().Id.Sha.Substring(0, 10);
Version version = this.Repo.GetIdAsVersion(relativeProjectDirectory);
Version assemblyVersion = GetExpectedAssemblyVersion(versionOptions, version);
var additionalBuildMetadata = from item in buildResult.BuildResult.ProjectStateAfterBuild.GetItems("BuildMetadata")
select item.EvaluatedInclude;
var expectedBuildMetadata = $"+g{commitIdShort}";
if (additionalBuildMetadata.Any())
{
expectedBuildMetadata += "." + string.Join(".", additionalBuildMetadata);
}
Assert.Equal($"{version}", buildResult.AssemblyFileVersion);
Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}{expectedBuildMetadata}", buildResult.AssemblyInformationalVersion);
// The assembly version property should always have four integer components to it,
// per bug https://github.com/AArnott/Nerdbank.GitVersioning/issues/26
Assert.Equal($"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}.{assemblyVersion.Revision}", buildResult.AssemblyVersion);
Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumber);
Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstAndSecondComponentsIfApplicable);
Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstComponent);
Assert.Equal(string.Empty, buildResult.BuildNumberSecondComponent);
Assert.Equal($"{version}", buildResult.BuildVersion);
Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}", buildResult.BuildVersion3Components);
Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildVersionNumberComponent);
Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}", buildResult.BuildVersionSimple);
Assert.Equal(this.Repo.Head.Commits.First().Id.Sha, buildResult.GitCommitId);
Assert.Equal(commitIdShort, buildResult.GitCommitIdShort);
Assert.Equal(versionHeight.ToString(), buildResult.GitVersionHeight);
Assert.Equal($"{version.Major}.{version.Minor}", buildResult.MajorMinorVersion);
Assert.Equal(versionOptions.Version.Prerelease, buildResult.PrereleaseVersion);
Assert.Equal(expectedBuildMetadata, buildResult.SemVerBuildSuffix);
string pkgVersionSuffix = buildResult.PublicRelease
? string.Empty
: $"-g{commitIdShort}";
Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}{pkgVersionSuffix}", buildResult.NuGetPackageVersion);
var buildNumberOptions = versionOptions.CloudBuild?.BuildNumber ?? new VersionOptions.CloudBuildNumberOptions();
if (buildNumberOptions.Enabled)
{
var commitIdOptions = buildNumberOptions.IncludeCommitId ?? new VersionOptions.CloudBuildNumberCommitIdOptions();
var buildNumberSemVer = SemanticVersion.Parse(buildResult.CloudBuildNumber);
bool hasCommitData = commitIdOptions.When == VersionOptions.CloudBuildNumberCommitWhen.Always
|| (commitIdOptions.When == VersionOptions.CloudBuildNumberCommitWhen.NonPublicReleaseOnly && !buildResult.PublicRelease);
Version expectedVersion = hasCommitData && commitIdOptions.Where == VersionOptions.CloudBuildNumberCommitWhere.FourthVersionComponent
? idAsVersion
: new Version(version.Major, version.Minor, version.Build);
Assert.Equal(expectedVersion, buildNumberSemVer.Version);
Assert.Equal(buildResult.PrereleaseVersion, buildNumberSemVer.Prerelease);
string expectedBuildNumberMetadata = hasCommitData && commitIdOptions.Where == VersionOptions.CloudBuildNumberCommitWhere.BuildMetadata
? $"+g{commitIdShort}"
: string.Empty;
if (additionalBuildMetadata.Any())
{
expectedBuildNumberMetadata = expectedBuildNumberMetadata.Length == 0
? "+" + string.Join(".", additionalBuildMetadata)
: expectedBuildNumberMetadata + "." + string.Join(".", additionalBuildMetadata);
}
Assert.Equal(expectedBuildNumberMetadata, buildNumberSemVer.BuildMetadata);
}
else
{
Assert.Equal(string.Empty, buildResult.CloudBuildNumber);
}
}
public override void Run()
{
if (BuildOptions.BuildOnExecute == BuildDetection.DoNotBuild) {
LastBuildResults = new BuildResults { Result = BuildResultCode.Success };
OnBuildComplete(EventArgs.Empty);
} else {
base.Run();
}
}
public override void Run()
{
runMethodCalled = true;
LastBuildResults = new BuildResults();
}
private async Task<BuildResults> BuildAsync(string target = Targets.GetBuildVersion, Microsoft.Build.Framework.LoggerVerbosity logVerbosity = Microsoft.Build.Framework.LoggerVerbosity.Detailed)
{
var buildResult = await this.buildManager.BuildAsync(
this.Logger,
this.projectCollection,
this.testProject,
target,
this.globalProperties,
logVerbosity);
var result = new BuildResults(buildResult);
this.Logger.WriteLine(result.ToString());
Assert.Equal(BuildResultCode.Success, buildResult.OverallResult);
return result;
}
public override bool Execute()
{
BootstrapperBuilder builder = new BootstrapperBuilder {
Validate = this.Validate,
Path = this.Path
};
ProductCollection products = builder.Products;
BuildSettings settings = new BuildSettings {
ApplicationFile = this.ApplicationFile,
ApplicationName = this.ApplicationName,
ApplicationRequiresElevation = this.ApplicationRequiresElevation,
ApplicationUrl = this.ApplicationUrl,
ComponentsLocation = this.ConvertStringToComponentsLocation(this.ComponentsLocation),
ComponentsUrl = this.ComponentsUrl,
CopyComponents = this.CopyComponents,
Culture = this.culture,
FallbackCulture = this.fallbackCulture,
OutputPath = this.OutputPath,
SupportUrl = this.SupportUrl
};
if (this.BootstrapperItems != null)
{
Hashtable hashtable = new Hashtable(StringComparer.OrdinalIgnoreCase);
foreach (ITaskItem item in this.BootstrapperItems)
{
string metadata = item.GetMetadata("Install");
if (string.IsNullOrEmpty(metadata) || ConversionUtilities.ConvertStringToBool(metadata))
{
if (!hashtable.Contains(item.ItemSpec))
{
hashtable.Add(item.ItemSpec, item);
}
else
{
base.Log.LogWarningWithCodeFromResources("GenerateBootstrapper.DuplicateItems", new object[] { item.ItemSpec });
}
}
}
foreach (Product product in products)
{
if (hashtable.Contains(product.ProductCode))
{
settings.ProductBuilders.Add(product.ProductBuilder);
hashtable.Remove(product.ProductCode);
}
}
foreach (ITaskItem item2 in hashtable.Values)
{
base.Log.LogWarningWithCodeFromResources("GenerateBootstrapper.ProductNotFound", new object[] { item2.ItemSpec, builder.Path });
}
}
BuildResults results = builder.Build(settings);
BuildMessage[] messages = results.Messages;
if (messages != null)
{
foreach (BuildMessage message in messages)
{
if (message.Severity == BuildMessageSeverity.Error)
{
base.Log.LogError(null, message.HelpCode, message.HelpKeyword, null, 0, 0, 0, 0, message.Message, new object[0]);
}
else if (message.Severity == BuildMessageSeverity.Warning)
{
base.Log.LogWarning(null, message.HelpCode, message.HelpKeyword, null, 0, 0, 0, 0, message.Message, new object[0]);
}
}
}
this.BootstrapperKeyFile = results.KeyFile;
this.BootstrapperComponentFiles = results.ComponentFiles;
return(results.Succeeded);
}
public override void Run()
{
if (BuildModifiedProjectsOnlyService.Setting == BuildOnExecuteSetting.DoNotBuild) {
LastBuildResults = new BuildResults { Result = BuildResultCode.Success };
OnBuildComplete(EventArgs.Empty);
} else {
base.Run();
}
}
bool BuildHasNoErrorsAndStillRunningTests(BuildResults results)
{
return((results.ErrorCount == 0) && IsRunningTest);
}
private void AssertStandardProperties(string prerelease, BuildResults buildResult, string relativeProjectDirectory = null)
{
int height = this.Repo.Head.GetHeight();
string commitIdShort = this.Repo.Head.Commits.First().Id.Sha.Substring(0, 10);
Version version = this.Repo.Head.Commits.First().GetIdAsVersion(relativeProjectDirectory);
Assert.Equal($"{version}", buildResult.AssemblyFileVersion);
Assert.Equal($"{version.Major}.{version.Minor}.{height}{prerelease}+g{commitIdShort}", buildResult.AssemblyInformationalVersion);
Assert.Equal($"{version.Major}.{version.Minor}", buildResult.AssemblyVersion);
Assert.Equal(height.ToString(), buildResult.BuildNumber);
Assert.Equal(height.ToString(), buildResult.BuildNumberFirstAndSecondComponentsIfApplicable);
Assert.Equal(height.ToString(), buildResult.BuildNumberFirstComponent);
Assert.Equal(string.Empty, buildResult.BuildNumberSecondComponent);
Assert.Equal($"{version}", buildResult.BuildVersion);
Assert.Equal($"{version.Major}.{version.Minor}.{height}", buildResult.BuildVersion3Components);
Assert.Equal(height.ToString(), buildResult.BuildVersionNumberComponent);
Assert.Equal($"{version.Major}.{version.Minor}.{height}", buildResult.BuildVersionSimple);
Assert.Equal(this.Repo.Head.Commits.First().Id.Sha, buildResult.GitCommitId);
Assert.Equal(commitIdShort, buildResult.GitCommitIdShort);
Assert.Equal(height.ToString(), buildResult.GitHeight);
Assert.Equal($"{version.Major}.{version.Minor}", buildResult.MajorMinorVersion);
Assert.Equal(prerelease, buildResult.PrereleaseVersion);
Assert.Equal($"+g{commitIdShort}", buildResult.SemVerBuildSuffix);
}
private static void PrintBuildResults(BuildOptions options, BuildResults buildResults)
{
for (int i = 0; i < Console.WindowWidth - 1; i++) {
Console.Write("=");
}
Console.WriteLine("");
Console.WriteLine("BuildResults.Action = {0}", buildResults.Action);
Console.WriteLine("BuildResults.Success = {0}", buildResults.Success);
Console.WriteLine("BuildResults.TranslationCount = {0}", buildResults.TranslationCount);
Console.WriteLine("BuildResults.UpToDateCount = {0}", buildResults.UpToDateCount);
Console.WriteLine("BuildResults.UpdateImplicitInputsCount = {0}", buildResults.UpdateImplicitInputsCount);
Console.WriteLine("BuildOptions.FileDecider.FStatCount = {0}", options.FileDecider.FStatCount);
Console.WriteLine("BuildOptions.FileDecider.BytesRead = {0}", options.FileDecider.BytesRead);
TimeSpan executionTime = buildResults.ExecuteEndTime - buildResults.ExecuteStartTime;
Console.WriteLine("# ExecutionTime = {0}", executionTime);
}
private void AssertStandardProperties(VersionOptions versionOptions, BuildResults buildResult, string relativeProjectDirectory = null)
{
int versionHeight = this.Repo.GetVersionHeight(relativeProjectDirectory);
Version idAsVersion = this.Repo.GetIdAsVersion(relativeProjectDirectory);
string commitIdShort = this.Repo.Head.Commits.First().Id.Sha.Substring(0, 10);
Version version = this.Repo.GetIdAsVersion(relativeProjectDirectory);
Version assemblyVersion = (versionOptions.AssemblyVersion ?? versionOptions.Version.Version).EnsureNonNegativeComponents();
Assert.Equal($"{version}", buildResult.AssemblyFileVersion);
Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}+g{commitIdShort}", buildResult.AssemblyInformationalVersion);
// The assembly version property should always have four integer components to it,
// per bug https://github.com/AArnott/Nerdbank.GitVersioning/issues/26
Assert.Equal($"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}.{assemblyVersion.Revision}", buildResult.AssemblyVersion);
Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumber);
Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstAndSecondComponentsIfApplicable);
Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildNumberFirstComponent);
Assert.Equal(string.Empty, buildResult.BuildNumberSecondComponent);
Assert.Equal($"{version}", buildResult.BuildVersion);
Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}", buildResult.BuildVersion3Components);
Assert.Equal(idAsVersion.Build.ToString(), buildResult.BuildVersionNumberComponent);
Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}", buildResult.BuildVersionSimple);
Assert.Equal(this.Repo.Head.Commits.First().Id.Sha, buildResult.GitCommitId);
Assert.Equal(commitIdShort, buildResult.GitCommitIdShort);
Assert.Equal(versionHeight.ToString(), buildResult.GitVersionHeight);
Assert.Equal($"{version.Major}.{version.Minor}", buildResult.MajorMinorVersion);
Assert.Equal(versionOptions.Version.Prerelease, buildResult.PrereleaseVersion);
Assert.Equal($"+g{commitIdShort}", buildResult.SemVerBuildSuffix);
string pkgVersionSuffix = buildResult.PublicRelease
? string.Empty
: $"-g{commitIdShort}";
Assert.Equal($"{idAsVersion.Major}.{idAsVersion.Minor}.{idAsVersion.Build}{versionOptions.Version.Prerelease}{pkgVersionSuffix}", buildResult.NuGetPackageVersion);
}
