public void ReadWriteRequest() { Task.Run(async () => { var request = new BuildRequest( BuildProtocolConstants.ProtocolVersion, BuildProtocolConstants.RequestLanguage.VisualBasicCompile, ImmutableArray.Create( new BuildRequest.Argument(BuildProtocolConstants.ArgumentId.CurrentDirectory, argumentIndex: 0, value: "directory"), new BuildRequest.Argument(BuildProtocolConstants.ArgumentId.CommandLineArgument, argumentIndex: 1, value: "file"))); var memoryStream = new MemoryStream(); await request.WriteAsync(memoryStream, default(CancellationToken)).ConfigureAwait(false); Assert.True(memoryStream.Position > 0); memoryStream.Position = 0; var read = await BuildRequest.ReadAsync(memoryStream, default(CancellationToken)).ConfigureAwait(false); Assert.Equal(BuildProtocolConstants.ProtocolVersion, read.ProtocolVersion); Assert.Equal(BuildProtocolConstants.RequestLanguage.VisualBasicCompile, read.Language); Assert.Equal(2, read.Arguments.Length); Assert.Equal(BuildProtocolConstants.ArgumentId.CurrentDirectory, read.Arguments[0].ArgumentId); Assert.Equal(0, read.Arguments[0].ArgumentIndex); Assert.Equal("directory", read.Arguments[0].Value); Assert.Equal(BuildProtocolConstants.ArgumentId.CommandLineArgument, read.Arguments[1].ArgumentId); Assert.Equal(1, read.Arguments[1].ArgumentIndex); Assert.Equal("file", read.Arguments[1].Value); }).Wait(); }
internal static string[] GetCommandLineArguments(BuildRequest req, out string currentDirectory, out string tempDirectory, out string libDirectory) { currentDirectory = null; libDirectory = null; tempDirectory = null; List<string> commandLineArguments = new List<string>(); foreach (BuildRequest.Argument arg in req.Arguments) { if (arg.ArgumentId == BuildProtocolConstants.ArgumentId.CurrentDirectory) { currentDirectory = arg.Value; } else if (arg.ArgumentId == BuildProtocolConstants.ArgumentId.TempDirectory) { tempDirectory = arg.Value; } else if (arg.ArgumentId == BuildProtocolConstants.ArgumentId.LibEnvVariable) { libDirectory = arg.Value; } else if (arg.ArgumentId == BuildProtocolConstants.ArgumentId.CommandLineArgument) { int argIndex = arg.ArgumentIndex; while (argIndex >= commandLineArguments.Count) commandLineArguments.Add(""); commandLineArguments[argIndex] = arg.Value; } } return commandLineArguments.ToArray(); }
public object Get(BuildRequest request) { if(request != null && !string.IsNullOrEmpty(request.Id)) { return _buildManager.GetBuild(request.Id); } else { return _buildManager.GetBuildList(request.BuildListOptions(), request.ProjectId, request.ProjectBranchId, request.ProjectComponentId); } }
public object Post(BuildRequest request) { if(string.IsNullOrEmpty(request.Id)) { return this._buildManager.CreateBuild(request.ProjectId, request.ProjectComponentId, request.ProjectBranchId, request.FileId, request.Version); } else { return this._buildManager.UpdateBuild(request.Id, request.ProjectId, request.ProjectComponentId, request.ProjectBranchId, request.FileId, request.Version); } }
internal static RunRequest GetRunRequest(BuildRequest req) { string currentDirectory; string libDirectory; string[] arguments = GetCommandLineArguments(req, out currentDirectory, out libDirectory); string language = ""; switch (req.Language) { case RequestLanguage.CSharpCompile: language = LanguageNames.CSharp; break; case RequestLanguage.VisualBasicCompile: language = LanguageNames.VisualBasic; break; } return new RunRequest(language, currentDirectory, libDirectory, arguments); }
/// <summary> /// An incoming request as occurred. This is called on a new thread to handle /// the request. /// </summary> public BuildResponse HandleRequest(BuildRequest request, CancellationToken cancellationToken) { var req = BuildProtocolUtil.GetRunRequest(request); switch (req.Language) { case LanguageNames.CSharp: _compilerServerHost.Log("Request to compile C#"); return RunCompile(req, CreateCSharpCompiler, cancellationToken); case LanguageNames.VisualBasic: _compilerServerHost.Log("Request to compile VB"); return RunCompile(req, CreateBasicCompiler, cancellationToken); default: // We can't do anything with a request we don't know about. _compilerServerHost.Log($"Got request with id '{req.Language}'"); return new CompletedBuildResponse(-1, false, "", ""); } }
/// <summary> /// Logs the project started/finished pair for projects which are skipped entirely because all /// of their results are available in the cache. /// </summary> internal void LogRequestHandledFromCache(BuildRequest request, BuildRequestConfiguration configuration, BuildResult result) { ProjectLoggingContext projectLoggingContext = LogProjectStarted(request, configuration); // When pulling a request from the cache, we want to make sure we log a task skipped message for any targets which // were used to build the request including default and inital targets. foreach (string target in configuration.GetTargetsUsedToBuildRequest(request)) { projectLoggingContext.LogComment ( MessageImportance.Low, result[target].ResultCode == TargetResultCode.Failure ? "TargetAlreadyCompleteFailure" : "TargetAlreadyCompleteSuccess", target ); if (result[target].ResultCode == TargetResultCode.Failure) { break; } } projectLoggingContext.LogProjectFinished(result.OverallResult == BuildResultCode.Success); }
public void Clone() { BuildRequest request = CreateNewBuildRequest(1, new string[0]); BuildResult result1 = new BuildResult(request); result1.ResultsByTarget.Add("FOO", BuildResultUtilities.GetEmptySucceedingTargetResult()); Assert.True(result1.ResultsByTarget.ContainsKey("foo")); // test comparer BuildResult result2 = result1.Clone(); result1.ResultsByTarget.Add("BAR", BuildResultUtilities.GetEmptySucceedingTargetResult()); Assert.True(result1.ResultsByTarget.ContainsKey("foo")); // test comparer Assert.True(result1.ResultsByTarget.ContainsKey("bar")); Assert.Equal(result1.SubmissionId, result2.SubmissionId); Assert.Equal(result1.ConfigurationId, result2.ConfigurationId); Assert.Equal(result1.GlobalRequestId, result2.GlobalRequestId); Assert.Equal(result1.ParentGlobalRequestId, result2.ParentGlobalRequestId); Assert.Equal(result1.NodeRequestId, result2.NodeRequestId); Assert.Equal(result1.CircularDependency, result2.CircularDependency); Assert.Equal(result1.ResultsByTarget["foo"], result2.ResultsByTarget["foo"]); Assert.Equal(result1.OverallResult, result2.OverallResult); }
public void TestOverallResult() { BuildRequest request = CreateNewBuildRequest(1, Array.Empty <string>()); BuildResult result = new BuildResult(request); Assert.Equal(BuildResultCode.Success, result.OverallResult); result.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult()); Assert.Equal(BuildResultCode.Success, result.OverallResult); result.AddResultsForTarget("bar", new TargetResult(Array.Empty <TaskItem>(), new WorkUnitResult(WorkUnitResultCode.Success, WorkUnitActionCode.Continue, new Exception()))); Assert.Equal(BuildResultCode.Success, result.OverallResult); result.AddResultsForTarget("baz", new TargetResult(Array.Empty <TaskItem>(), BuildResultUtilities.GetStopWithErrorResult(new Exception()))); Assert.Equal(BuildResultCode.Failure, result.OverallResult); BuildRequest request2 = CreateNewBuildRequest(2, Array.Empty <string>()); BuildResult result2 = new BuildResult(request2); result2.AddResultsForTarget("foo", BuildResultUtilities.GetEmptySucceedingTargetResult()); result2.AddResultsForTarget("bar", BuildResultUtilities.GetEmptyFailingTargetResult()); Assert.Equal(BuildResultCode.Failure, result2.OverallResult); }
public void TestTranslation() { BuildRequest request = CreateNewBuildRequest(1, new string[] { "alpha", "omega" }); Assert.Equal(NodePacketType.BuildRequest, request.Type); ((INodePacketTranslatable)request).Translate(TranslationHelpers.GetWriteTranslator()); INodePacket packet = BuildRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator()); BuildRequest deserializedRequest = packet as BuildRequest; Assert.Equal(request.BuildEventContext, deserializedRequest.BuildEventContext); Assert.Equal(request.ConfigurationId, deserializedRequest.ConfigurationId); Assert.Equal(request.GlobalRequestId, deserializedRequest.GlobalRequestId); Assert.Equal(request.IsConfigurationResolved, deserializedRequest.IsConfigurationResolved); Assert.Equal(request.NodeRequestId, deserializedRequest.NodeRequestId); Assert.Equal(request.ParentBuildEventContext, deserializedRequest.ParentBuildEventContext); Assert.Equal(request.Targets.Count, deserializedRequest.Targets.Count); for (int i = 0; i < request.Targets.Count; i++) { Assert.Equal(request.Targets[i], deserializedRequest.Targets[i]); } }
public void TestMaxNodeCountNotExceededWithRequestsOfAffinityAny() { _host.BuildParameters.MaxNodeCount = 3; CreateConfiguration(1, "foo.proj"); CreateConfiguration(2, "bar.proj"); CreateConfiguration(3, "baz.proj"); CreateConfiguration(4, "quz.proj"); BuildRequest request1 = CreateBuildRequest(1, 1, new string[] { "foo" }); BuildRequest request2 = CreateBuildRequest(2, 2, new string[] { "bar" }); BuildRequest request3 = CreateBuildRequest(3, 3, new string[] { "baz" }); BuildRequest request4 = CreateBuildRequest(4, 4, new string[] { "qux" }); BuildRequestBlocker blocker = new BuildRequestBlocker(request1.ParentGlobalRequestId, new string[] { }, new BuildRequest[] { request1, request2, request3, request4 }); List <ScheduleResponse> response = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, blocker)); Assert.Equal(2, response.Count); Assert.Equal(ScheduleActionType.ScheduleWithConfiguration, response[0].Action); Assert.Equal(request1, response[0].BuildRequest); Assert.Equal(ScheduleActionType.CreateNode, response[1].Action); Assert.Equal(NodeAffinity.OutOfProc, response[1].RequiredNodeType); Assert.Equal(2, response[1].NumberOfNodesToCreate); }
public void TestMaxNodeCountOOPNodesCreatedForOOPAffinitizedRequests() { _host.BuildParameters.MaxNodeCount = 3; CreateConfiguration(1, "foo.proj"); CreateConfiguration(2, "bar.proj"); CreateConfiguration(3, "baz.proj"); CreateConfiguration(4, "quz.proj"); BuildRequest request1 = CreateBuildRequest(1, 1, new string[] { "foo" }, NodeAffinity.OutOfProc, _defaultParentRequest); BuildRequest request2 = CreateBuildRequest(2, 2, new string[] { "bar" }, NodeAffinity.OutOfProc, _defaultParentRequest); BuildRequest request3 = CreateBuildRequest(3, 3, new string[] { "baz" }, NodeAffinity.OutOfProc, _defaultParentRequest); BuildRequest request4 = CreateBuildRequest(4, 4, new string[] { "qux" }, NodeAffinity.OutOfProc, _defaultParentRequest); BuildRequestBlocker blocker = new BuildRequestBlocker(request1.ParentGlobalRequestId, new string[] { }, new BuildRequest[] { request1, request2, request3, request4 }); List <ScheduleResponse> response = new List <ScheduleResponse>(_scheduler.ReportRequestBlocked(1, blocker)); // Parent request is blocked by the fact that both child requests require the out-of-proc node that doesn't // exist yet. Assert.Single(response); Assert.Equal(ScheduleActionType.CreateNode, response[0].Action); Assert.Equal(NodeAffinity.OutOfProc, response[0].RequiredNodeType); Assert.Equal(3, response[0].NumberOfNodesToCreate); }
internal EngineProxy CreateEngineProxyWithDummyTaskEngine(Engine e, Project p) { // UNDONE need a real handle Id and a real TEM pointer XmlElement taskNode = new XmlDocument().CreateElement("MockTask"); BuildRequest request = new BuildRequest(EngineCallback.invalidEngineHandle, "mockproject", null, (BuildPropertyGroup)null, null, -1, false, false); ProjectBuildState context = new ProjectBuildState(request, new ArrayList(), new BuildEventContext(0, 0, 0, 0)); int handleId = e.EngineCallback.CreateTaskContext(p, null, context, taskNode, 0, new BuildEventContext(0, 0, 0, 0)); TaskEngine taskEngine = new TaskEngine ( taskNode, null, /* host object */ p.FullFileName, p.FullFileName, e.LoggingServices, handleId, e.NodeManager.TaskExecutionModule, new BuildEventContext(0, 0, 0, 0) ); e.Scheduler.Initialize(new INodeDescription[] { null }); return(new EngineProxy(e.NodeManager.TaskExecutionModule, handleId, p.FullFileName, p.FullFileName, e.LoggingServices, new BuildEventContext(0, 0, 0, 0))); }
public void TestAddAndRetrieveResultsByConfiguration() { ResultsCache cache = new ResultsCache(); BuildRequest request = new BuildRequest(1 /* submissionId */, 0, 1, new string[1] { "testTarget" }, null, BuildEventContext.Invalid, null); BuildResult result = new BuildResult(request); result.AddResultsForTarget("testTarget", TestUtilities.GetEmptyFailingTargetResult()); cache.AddResult(result); request = new BuildRequest(1 /* submissionId */, 0, 1, new string[1] { "otherTarget" }, null, BuildEventContext.Invalid, null); result = new BuildResult(request); result.AddResultsForTarget("otherTarget", TestUtilities.GetEmptySucceedingTargetResult()); cache.AddResult(result); BuildResult retrievedResult = cache.GetResultsForConfiguration(1); Assert.IsTrue(retrievedResult.HasResultsForTarget("testTarget")); Assert.IsTrue(retrievedResult.HasResultsForTarget("otherTarget")); }
public BuildRequestsList DeleteRequest(BuildRequest param) { try { var queue = BuildRequestsQueue.Queue; var elem = (from c in queue.QueueList where c.Name.Equals(param.Name) && c.RequestTime == param.RequestTime select c).FirstOrDefault(); if (elem != null) { queue.QueueList.Remove(elem); } WebOperationContext.Current.OutgoingResponse.StatusCode = HttpStatusCode.OK; } catch (Exception e) { WebOperationContext.Current.OutgoingResponse.StatusCode = HttpStatusCode.NotAcceptable; } return(BuildRequestsList.GetList()); }
public ResultsCacheResponse SatisfyRequest( BuildRequest request, List <string> configInitialTargets, List <string> configDefaultTargets, List <string> additionalTargetsToCheckForOverallResult, bool skippedResultsAreOK) { var overrideRequest = _override.SatisfyRequest( request, configInitialTargets, configDefaultTargets, additionalTargetsToCheckForOverallResult, skippedResultsAreOK); if (overrideRequest.Type == ResultsCacheResponseType.Satisfied) { #if DEBUG ErrorUtilities.VerifyThrow( CurrentCache.SatisfyRequest( request, configInitialTargets, configDefaultTargets, additionalTargetsToCheckForOverallResult, skippedResultsAreOK) .Type == ResultsCacheResponseType.NotSatisfied, "caches should not overlap"); #endif return(overrideRequest); } return(CurrentCache.SatisfyRequest( request, configInitialTargets, configDefaultTargets, additionalTargetsToCheckForOverallResult, skippedResultsAreOK)); }
//<----------------------------------used for generating the test request------------------------------------> public void generatetestrequest(List<string> outputfilelist, CommMessage msg) { BuildRequest newRequest = buildRequestContent.FromXml<BuildRequest>(); TestRequest testRequest = new TestRequest(); testRequest.author = "Ramteja Repaka"; List<string> testDriverList = new List<string>(); foreach (BuildItem item in newRequest.Builds) { TestElement element = new TestElement(); element.testName = item.builddesc; string testdrivername = null; foreach (file f in item.driver) { String s = f.name; s = s.Replace(".cs", ".dll"); element.addDriver(s); testdrivername = s; } foreach (file f in item.sourcefiles) { String s = f.name; s = s.Replace(".cs", ".dll"); element.addCode(s); } if (outputfilelist.Contains(testdrivername)) { testRequest.tests.Add(element); testDriverList.Add(testdrivername); } } string testxml = testRequest.ToXml(); string filename = msg.filename; filename = filename.Replace("BuildRequest", "TestRequest"); File.WriteAllText(ServiceEnvironment.fileStorage + "/" + builderId + "/" + filename, testxml); Console.WriteLine("TestRequest saved to BuilderStorage\n"); sendfilestoharness(testDriverList, filename); }
public void CancelBuilding(uint unitType) { foreach (Agent agent in Bot.Main.UnitManager.Agents.Values) { if (agent.Unit.UnitType == unitType && agent.Unit.BuildProgress < 0.99) { agent.Order(Abilities.CANCEL); } } for (int i = ConstructionTask.Task.BuildRequests.Count - 1; i >= 0; i--) { BuildRequest request = ConstructionTask.Task.BuildRequests[i]; if (request.Type != unitType) { continue; } ConstructionTask.Task.BuildRequests.RemoveAt(i); if (ConstructionTask.Task.NaturalProbe != request.worker) { IdleTask.Task.Add(request.worker); ConstructionTask.Task.Units.Remove(request.worker); } } for (int i = ConstructionTask.Task.UnassignedRequests.Count - 1; i >= 0; i--) { BuildRequest request = ConstructionTask.Task.UnassignedRequests[i]; if (request.Type != unitType) { continue; } ConstructionTask.Task.UnassignedRequests.RemoveAt(i); } }
public async Task <BuildResponse> GetResponseAsync(BuildRequest req, CancellationToken cancellationToken) { NamedPipeClientStream pipeStream; if (TryAutoConnectToServer(cancellationToken, out pipeStream)) { // We have a good connection BuildResponse response = await DoCompilationAsync(pipeStream, req, cancellationToken).ConfigureAwait(false); if (response != null) { return(response); } else { CompilerServerLogger.Log("Compilation failed, constructing new compiler server"); // The compilation failed. There are a couple possible reasons for this, // including that we are using a 32-bit compiler server and we are out of // memory. This is the last attempt -- we will create a new server manually // and try to compile. There is no mutex because anyone else using // this server is accidental only. int newProcessId = CreateNewServerProcess(); if (newProcessId != 0 && TryConnectToProcess(newProcessId, TimeOutMsNewProcess, cancellationToken, out pipeStream)) { return(await DoCompilationAsync(pipeStream, req, cancellationToken).ConfigureAwait(false)); } } } return(null); }
/// <summary> /// Set up /// </summary> public Scheduler_Tests() { // Since we're creating our own BuildManager, we need to make sure that the default // one has properly relinquished the inproc node NodeProviderInProc nodeProviderInProc = ((IBuildComponentHost)BuildManager.DefaultBuildManager).GetComponent(BuildComponentType.InProcNodeProvider) as NodeProviderInProc; nodeProviderInProc?.Dispose(); _host = new MockHost(); _scheduler = new Scheduler(); _scheduler.InitializeComponent(_host); CreateConfiguration(99, "parent.proj"); _defaultParentRequest = CreateBuildRequest(99, 99, new string[] { }, null); // Set up the scheduler with one node to start with. _scheduler.ReportNodesCreated(new NodeInfo[] { new NodeInfo(1, NodeProviderType.InProc) }); _scheduler.ReportRequestBlocked(1, new BuildRequestBlocker(-1, new string[] { }, new BuildRequest[] { _defaultParentRequest })); _logger = new MockLogger(); _parameters = new BuildParameters(); _parameters.Loggers = new ILogger[] { _logger }; _parameters.ShutdownInProcNodeOnBuildFinish = true; _buildManager = new BuildManager(); }
public async Task <ActionResult> Test(BuildRequestModel model) { if (ModelState.IsValid) { var jobId = Guid.NewGuid(); var blobName = "test_" + DateTime.Now.Ticks + ".txt"; var blockBlob = requestBlob.GetBlockBlobReference(blobName); await blockBlob.UploadTextAsync(model.Source); Uri url = new Uri(Url.Action("StatusNotification", null, null, Request.Url.Scheme)); BuildRequest request = new BuildRequest() { BlobUri = blockBlob.Uri, JobId = jobId, Url = url }; var queueMessage = new CloudQueueMessage(JsonConvert.SerializeObject(request)); await requestsQueue.AddMessageAsync(queueMessage); Trace.TraceInformation("Created test queue message"); return(Json(new { jobId }, JsonRequestBehavior.AllowGet)); } return(new HttpStatusCodeResult(HttpStatusCode.NotAcceptable)); }
public void TestSimpleBuildScenario() { BuildRequestData data = new BuildRequestData("TestFile", new Dictionary <string, string>(), "TestToolsVersion", new string[0], null); BuildRequestConfiguration config = new BuildRequestConfiguration(1, data, "2.0"); _cache.AddConfiguration(config); string[] targets = new string[3] { "target1", "target2", "target3" }; BuildRequest request = CreateNewBuildRequest(1, targets); VerifyEngineStatus(BuildRequestEngineStatus.Uninitialized); _engine.InitializeForBuild(new NodeLoggingContext(_host.LoggingService, 0, false)); _engine.SubmitBuildRequest(request); Thread.Sleep(250); VerifyEngineStatus(BuildRequestEngineStatus.Active); WaitForEvent(_requestCompleteEvent, "RequestComplete"); Assert.Equal(request, _requestComplete_Request); Assert.Equal(BuildResultCode.Success, _requestComplete_Result.OverallResult); VerifyEngineStatus(BuildRequestEngineStatus.Idle); }
//<------------------ Contains core logic to process build request-----------------------------------> public Dictionary <string, string> processbuildrequest(string path, RepoMock mockobj) { Console.WriteLine("---------------------------------Build Server processing build request-----------------------------------"); Console.WriteLine("\n"); string xmlstring = File.ReadAllText(path); BuildRequest newRequest = xmlstring.FromXml <BuildRequest>(); repomock = mockobj; foreach (BuildItem item in newRequest.Builds) { string child = ""; List <string> parent = new List <string>(); foreach (file f in item.driver) { parent.Add(f.name); Console.WriteLine("requesting " + f.name); Console.WriteLine("\n"); repomock.processfilerequest(f.name); } foreach (file f in item.sourcefiles) { child = child + f.name + " "; Console.WriteLine("requesting " + f.name); Console.WriteLine("\n"); repomock.processfilerequest(f.name); } foreach (string str in parent) { dict.Add(str, child); } } return(dict); }
public BuildCondition WaitForRequest() { if (! HasPendingRequests()) { latch.WaitOne(); } lock (this) { BuildCondition result = request.Condition; request = NoBuildRequested; latch.Reset(); Debug.Assert(result != BuildCondition.NoBuild); return result; } }
public void Delete(BuildRequest build) { this._buildManager.DeleteBuild(build.Id); }
public void RequestBuild(BuildCondition condition) { lock (this) { if (request.IsHigherPriority(condition)) { request = new BuildRequest(condition); latch.Set(); } } }
public void TestRequestCaching() { CacheManager cacheManager = new CacheManager("3.5"); ArrayList actuallyBuiltTargets; // Test the case where we pass in null targets Dictionary <string, string> dictionary = new Dictionary <string, string>(); BuildRequest emptyRequest = new BuildRequest(1, "test.proj", null, dictionary, null, 1, true, false); Assert.IsNull(cacheManager.GetCachedBuildResult(emptyRequest, out actuallyBuiltTargets), "Expect a null return value if T=null"); // Test the case where we pass in length 0 targets BuildRequest length0Request = new BuildRequest(1, "test.proj", new string[0], dictionary, null, 1, true, false); Assert.IsNull(cacheManager.GetCachedBuildResult(length0Request, out actuallyBuiltTargets), "Expect a null return value if T.Length=0"); // Test the case when the scope doesn't exist string[] targets = new string[1]; targets[0] = "Target1"; BuildRequest length1Request = new BuildRequest(1, "test.proj", targets, new BuildPropertyGroup(), null, 1, true, false); Assert.IsNull(cacheManager.GetCachedBuildResult(length1Request, out actuallyBuiltTargets), "Expect a null return value if no scope"); // Test the case when the scope exists but is empty CacheScope cacheScope = cacheManager.GetCacheScope("test.proj", new BuildPropertyGroup(), "3.5", CacheContentType.BuildResults); Assert.IsNull(cacheManager.GetCachedBuildResult(length1Request, out actuallyBuiltTargets), "Expect a null return value if scope is empty"); // Test the case when the scope exists but contains wrong data CacheEntry cacheEntry = new BuildResultCacheEntry("Target2", null, true); cacheManager.SetCacheEntries(new CacheEntry[] { cacheEntry }, "test.proj", new BuildPropertyGroup(), "3.5", CacheContentType.BuildResults); Assert.IsNull(cacheManager.GetCachedBuildResult(length1Request, out actuallyBuiltTargets), "Expect a null return value if scope contains wrong data"); // Test the case when everything is correct cacheScope.AddCacheEntry(new PropertyCacheEntry(Constants.defaultTargetCacheName, string.Empty)); cacheScope.AddCacheEntry(new PropertyCacheEntry(Constants.initialTargetCacheName, string.Empty)); cacheScope.AddCacheEntry(new PropertyCacheEntry(Constants.projectIdCacheName, "1")); cacheEntry = new BuildResultCacheEntry("Target1", null, true); cacheManager.SetCacheEntries(new CacheEntry[] { cacheEntry }, "test.proj", new BuildPropertyGroup(), "3.5", CacheContentType.BuildResults); BuildResult buildResult = cacheManager.GetCachedBuildResult(length1Request, out actuallyBuiltTargets); Assert.IsNotNull(buildResult, "Expect a cached value if scope contains data"); Assert.AreEqual(1, actuallyBuiltTargets.Count); Assert.AreEqual("Target1", actuallyBuiltTargets[0]); Assert.AreEqual(1, buildResult.ResultByTarget.Count); Assert.AreEqual(Target.BuildState.CompletedSuccessfully, buildResult.ResultByTarget["Target1"]); // Test the case when the scope contains partially correct data targets = new string[2]; targets[0] = "Target2"; targets[1] = "Target3"; BuildRequest length2Request = new BuildRequest(1, "test.proj", targets, new BuildPropertyGroup(), null, 1, true, false); Assert.IsNull(cacheManager.GetCachedBuildResult(length2Request, out actuallyBuiltTargets), "Expect a null return value if partial data in the scope"); // Test the correctness case for multiple targets cacheEntry = new BuildResultCacheEntry("Target3", null, true); cacheManager.SetCacheEntries(new CacheEntry[] { cacheEntry }, "test.proj", new BuildPropertyGroup(), "3.5", CacheContentType.BuildResults); buildResult = cacheManager.GetCachedBuildResult(length2Request, out actuallyBuiltTargets); Assert.IsNotNull(buildResult, "Expect a cached value if scope contains data"); Assert.AreEqual(2, actuallyBuiltTargets.Count); Assert.AreEqual("Target2", actuallyBuiltTargets[0]); Assert.AreEqual("Target3", actuallyBuiltTargets[1]); Assert.AreEqual(2, buildResult.ResultByTarget.Count); Assert.AreEqual(Target.BuildState.CompletedSuccessfully, buildResult.ResultByTarget["Target2"]); Assert.AreEqual(Target.BuildState.CompletedSuccessfully, buildResult.ResultByTarget["Target3"]); Assert.AreEqual(1, buildResult.ProjectId); }
/// <summary> /// Constructs a new build result with existing results, but associated with the specified request. /// </summary> /// <param name="request">The build request with which these results should be associated.</param> /// <param name="existingResults">The existing results, if any.</param> /// <param name="exception">The exception, if any</param> internal BuildResult(BuildRequest request, BuildResult existingResults, Exception exception) : this(request, existingResults, null, null, exception) { }
protected override void ValidateBuildRequest(BuildRequest request) { ValidateBuildRequestFunc?.Invoke(request); }
/// <summary> /// Constructs a build result with an exception /// </summary> /// <param name="request">The build request to which these results should be associated.</param> /// <param name="exception">The exception, if any.</param> internal BuildResult(BuildRequest request, Exception exception) : this(request, null, exception) { }
protected virtual void ValidateBuildRequest(BuildRequest request) { }
private bool IsShutdownRequest(BuildRequest request) { return request.Arguments.Length == 1 && request.Arguments[0].ArgumentId == BuildProtocolConstants.ArgumentId.Shutdown; }
private async Task<ConnectionData> HandleCompilationRequest(BuildRequest request, CancellationToken cancellationToken) { var keepAlive = CheckForNewKeepAlive(request); // Kick off both the compilation and a task to monitor the pipe for closing. var buildCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken); var compilationTask = ServeBuildRequest(request, buildCts.Token); var monitorTask = CreateMonitorDisconnectTask(buildCts.Token); await Task.WhenAny(compilationTask, monitorTask).ConfigureAwait(false); // Do an 'await' on the completed task, preference being compilation, to force // any exceptions to be realized in this method for logging. CompletionReason reason; if (compilationTask.IsCompleted) { var response = await compilationTask.ConfigureAwait(false); try { Log("Begin writing response."); await response.WriteAsync(_stream, cancellationToken).ConfigureAwait(false); reason = CompletionReason.CompilationCompleted; Log("End writing response."); } catch { reason = CompletionReason.ClientDisconnect; } } else { await monitorTask.ConfigureAwait(false); reason = CompletionReason.ClientDisconnect; } // Begin the tear down of the Task which didn't complete. buildCts.Cancel(); return new ConnectionData(reason, keepAlive); }
/// <summary> /// Callback for event raised when a build request is completed /// </summary> /// <param name="request">The request which completed</param> /// <param name="result">The result for the request</param> private void Engine_RequestComplete(BuildRequest request, BuildResult result) { _requestComplete_Request = request; _requestComplete_Result = result; _requestCompleteEvent.Set(); }
public AppCommandProcessor(IMongoCollection <AppData> apps, GridFSBucket files, RepositoryApi repository, DataTransferManager dataTransfer, IMongoCollection <ToDeleteRevision> toDelete, WorkDistributor <BuildRequest, BuildCompled> workDistributor, IActorRef changeTracker) { _apps = apps; CommandPhase1 <CreateAppCommand>("CreateApp", repository, (command, reporter) => { reporter.Send(DeploymentMessages.RegisterRepository); return(new RegisterRepository(command.TargetRepo) { IgnoreDuplicate = true }); }, (command, reporter, op) => new ContinueCreateApp(op, command, reporter)); CommandPhase2 <ContinueCreateApp, CreateAppCommand, AppInfo>("CreateApp2", (command, result, reporter, data) => { if (!result.Ok) { if (reporter.IsCompled) { return(null); } reporter.Compled(OperationResult.Failure(result.Error ?? BuildErrorCodes.CommandErrorRegisterRepository)); return(null); } if (data != null) { reporter.Compled(OperationResult.Failure(BuildErrorCodes.CommandDuplicateApp)); return(null); } var newData = new AppData(command.AppName, -1, DateTime.UtcNow, DateTime.MinValue, command.TargetRepo, command.ProjectName, ImmutableList <AppFileInfo> .Empty); apps.InsertOne(newData); var info = newData.ToInfo(); changeTracker.Tell(info); return(info); }); CommandPhase1 <PushVersionCommand>("PushVersion", (command, reporter) => { var data = apps.AsQueryable().FirstOrDefault(ad => ad.Name == command.AppName); if (data == null) { reporter.Compled(OperationResult.Failure(BuildErrorCodes.CommandAppNotFound)); } else { BuildRequest.SendWork(workDistributor, reporter, data, repository, BuildEnv.TempFiles.CreateFile()) .PipeTo(Self, success: c => new ContinuePushNewVersion(OperationResult.Success(c), command, reporter), failure: e => new ContinuePushNewVersion(OperationResult.Failure(e.Unwrap()?.Message ?? "Cancel"), command, reporter)); } }); CommandPhase2 <ContinuePushNewVersion, PushVersionCommand, AppBinary>("PushVersion2", (command, result, reporter, data) => { if (data == null) { if (!reporter.IsCompled) { reporter.Compled(OperationResult.Failure(BuildErrorCodes.CommandAppNotFound)); } return(null); } if (!result.Ok) { return(null); } using var transaction = apps.Database.Client.StartSession(new ClientSessionOptions { DefaultTransactionOptions = new TransactionOptions(writeConcern: WriteConcern.Acknowledged) }); var dataFilter = Builders <AppData> .Filter.Eq(ad => ad.Name, data.Name); var(commit, fileName) = ((string, ITempFile))result.Outcome !; using var targetStream = fileName; var newId = files.UploadFromStream(data.Name + ".zip", targetStream.Stream); var newBinary = new AppFileInfo(newId, data.Last + 1, DateTime.UtcNow, false, commit); var newBinarys = data.Versions.Add(newBinary); var definition = Builders <AppData> .Update; var updates = new List <UpdateDefinition <AppData> > { definition.Set(ad => ad.Last, newBinary.Version), definition.Set(ad => ad.Versions, newBinarys) }; var deleteUpdates = new List <ToDeleteRevision>(); if (data.Versions.Count(s => !s.Deleted) > 5) { foreach (var info in newBinarys.OrderByDescending(i => i.CreationTime).Skip(5)) { if (info.Deleted) { continue; } info.Deleted = true; deleteUpdates.Add(new ToDeleteRevision(info.File.ToString())); } } transaction.StartTransaction(); if (deleteUpdates.Count != 0) { toDelete.InsertMany(transaction, deleteUpdates); } if (!apps.UpdateOne(transaction, dataFilter, definition.Combine(updates)).IsAcknowledged) { transaction.AbortTransaction(); reporter.Compled(OperationResult.Failure(BuildErrorCodes.DatabaseError)); return(null); } transaction.CommitTransaction(); changeTracker.Tell(_apps.AsQueryable().FirstOrDefault(ad => ad.Name == command.AppName)); return(new AppBinary(command.AppName, newBinary.Version, newBinary.CreationTime, false, newBinary.Commit, data.Repository)); });
/// <summary> /// Callback for event raised when a request is resumed /// </summary> /// <param name="request">The request being resumed</param> private void Engine_RequestResumed(BuildRequest request) { _requestResumed_Request = request; _requestResumedEvent.Set(); }
public void QueueBuild(string agentUri, string buildUri) { BuildServiceSoapClient soapClient = new BuildServiceSoapClient(GetBinding(Protocol, "BuildServiceSoap"), GetBuildEndpointAddress()); BuildRequest request = new BuildRequest { BuildAgentUri = agentUri, BuildDefinitionUri = buildUri }; soapClient.QueueBuild(request, QueueOptions.None); }
/// <summary> /// Check the request arguments for a new keep alive time. If one is present, /// set the server timer to the new time. /// </summary> private TimeSpan? CheckForNewKeepAlive(BuildRequest request) { TimeSpan? timeout = null; foreach (var arg in request.Arguments) { if (arg.ArgumentId == BuildProtocolConstants.ArgumentId.KeepAlive) { int result; // If the value is not a valid integer for any reason, // ignore it and continue with the current timeout. The client // is responsible for validating the argument. if (int.TryParse(arg.Value, out result)) { // Keep alive times are specified in seconds timeout = TimeSpan.FromSeconds(result); } } } return timeout; }
protected override void ValidateBuildRequest(BuildRequest request) { // Now that we've read data from the stream we can validate the identity. if (!ClientAndOurIdentitiesMatch(_pipeStream)) { throw new Exception("Client identity does not match server identity."); } }
protected virtual Task<BuildResponse> ServeBuildRequest(BuildRequest buildRequest, CancellationToken cancellationToken) { Func<BuildResponse> func = () => { // Do the compilation Log("Begin compilation"); var request = BuildProtocolUtil.GetRunRequest(buildRequest); var response = _compilerServerHost.RunCompilation(request, cancellationToken); Log("End compilation"); return response; }; var task = new Task<BuildResponse>(func, cancellationToken, TaskCreationOptions.LongRunning); task.Start(); return task; }
protected virtual Task<BuildResponse> ServeBuildRequest(BuildRequest request, CancellationToken cancellationToken) { return Task.Run(() => { try { // Do the compilation Log("Begin compilation"); BuildResponse response = ServeBuildRequestCore(request, cancellationToken); Log("End compilation"); return response; } catch (Exception e) when (FatalError.Report(e)) { throw ExceptionUtilities.Unreachable; } }); }
/// <summary> /// A new build request for this definition is submitted. This call is in the ProcessorThread of the TestDataProvider /// </summary> public void RaiseOnNewBuildRequest(BuildRequest request) { this.Build(request); }
private BuildResponse ServeBuildRequestCore(BuildRequest buildRequest, CancellationToken cancellationToken) { var request = BuildProtocolUtil.GetRunRequest(buildRequest); CommonCompiler compiler; if (!_compilerServerHost.TryCreateCompiler(request, out compiler)) { // TODO: is this the right option? Right now it will cause the fall back in the command line // to fail because it's a valid response. Probably should add a "server failed" response // for command line to deal with. // We can't do anything with a request we don't know about. Log($"Got request with id '{request.Language}'"); return new CompletedBuildResponse(-1, false, "", ""); } Log($"CurrentDirectory = '{request.CurrentDirectory}'"); Log($"LIB = '{request.LibDirectory}'"); for (int i = 0; i < request.Arguments.Length; ++i) { Log($"Argument[{i}] = '{request.Arguments[i]}'"); } bool utf8output = compiler.Arguments.Utf8Output; if (!_compilerServerHost.CheckAnalyzers(request.CurrentDirectory, compiler.Arguments.AnalyzerReferences)) { return new AnalyzerInconsistencyBuildResponse(); } Log($"****Running {request.Language} compiler..."); TextWriter output = new StringWriter(CultureInfo.InvariantCulture); int returnCode = compiler.Run(output, cancellationToken); Log($"****{request.Language} Compilation complete.\r\n****Return code: {returnCode}\r\n****Output:\r\n{output.ToString()}\r\n"); return new CompletedBuildResponse(returnCode, utf8output, output.ToString(), ""); }
/// <summary> /// Constructor creates an empty build result /// </summary> /// <param name="request">The build request to which these results should be associated.</param> internal BuildResult(BuildRequest request) : this(request, null) { }
void build(BuildRequest request, CancellationToken cancellation, Action<BuildStatus> onCompleted) { var status = BuildStatus.Failed; try { lock (_coreSyncRoot) { _coreRunning = true; Monitor.PulseAll(_coreSyncRoot); } // cancelAndWait() may cancel _and_ return before _coreRunning was set to true, we // want to be sure to not start another build then. cancellation.ThrowIfCancellationRequested(); coreToIDE(() => { _pane.Clear(); _pane.Activate(); }); status = buildCore(request, cancellation); } catch (Exception e) { Log.E(e, "build crashed"); coreToIDE(() => { _pane.reportException(e); }); } finally { lock (_coreSyncRoot) { _coreRunning = false; Monitor.PulseAll(_coreSyncRoot); } _mainThread.Post(_ => onCompleted(status), null); } }
/// <summary> /// Constructor creates a build result indicating a circular dependency was created. /// </summary> /// <param name="request">The build request to which these results should be associated.</param> /// <param name="circularDependency">Set to true if a circular dependency was detected.</param> internal BuildResult(BuildRequest request, bool circularDependency) : this(request, null) { _circularDependency = circularDependency; }
BuildStatus buildCore(BuildRequest request, CancellationToken cancellation) { #if DEBUG var verbosity = LoggerVerbosity.Minimal; #else var verbosity = LoggerVerbosity.Quiet; #endif var consoleLogger = new ConsoleLogger(verbosity, str => coreToIDE(() => _pane.OutputString(str)), color => { }, () => { }) { SkipProjectStartedText = true, ShowSummary = false }; var summaryLogger = new SummaryLogger(); var parameters = new BuildParameters() { Loggers = new ILogger[] {consoleLogger, summaryLogger}, EnableNodeReuse = true, ShutdownInProcNodeOnBuildFinish = false, DetailedSummary = false, }; printIntro(request); var status = buildCore(request, cancellation, parameters); printSummary(summaryLogger, request.AllProjectsToBuildOrdered); return status; }
/// <summary> /// Constructs a new build result with existing results, but associated with the specified request. /// </summary> /// <param name="request">The build request with which these results should be associated.</param> /// <param name="existingResults">The existing results, if any.</param> /// <param name="targetNames">The list of target names that are the subset of results that should be returned.</param> /// <param name="additionalTargetsToCheck">The additional targets that need to be taken into account when computing the overall result, if any.</param> /// <param name="exception">The exception, if any</param> internal BuildResult(BuildRequest request, BuildResult existingResults, string[] targetNames, List <string> additionalTargetsToCheck, Exception exception) { ErrorUtilities.VerifyThrow(request != null, "Must specify a request."); _submissionId = request.SubmissionId; _configurationId = request.ConfigurationId; _globalRequestId = request.GlobalRequestId; _parentGlobalRequestId = request.ParentGlobalRequestId; _nodeRequestId = request.NodeRequestId; _circularDependency = false; if (existingResults == null) { _requestException = exception; _resultsByTarget = CreateTargetResultDictionary(0); _baseOverallResult = true; } else { _requestException = exception ?? existingResults._requestException; _resultsByTarget = targetNames == null ? existingResults._resultsByTarget : CreateTargetResultDictionaryWithContents(existingResults, targetNames); if (existingResults.OverallResult == BuildResultCode.Success || (additionalTargetsToCheck == null || additionalTargetsToCheck.Count == 0)) { // If we know for a fact that all of the existing results succeeded, then by definition we'll have // succeeded too. Alternately, if we don't have any additional targets to check, then we want the // overall result to reflect only the targets included in this result, which the OverallResult // property already does -- so just default to true in that case as well. _baseOverallResult = true; } else { // If the existing result is a failure, then we need to determine whether the targets we are // specifically interested in contributed to that failure or not. If they did not, then this // result should be sucessful even though the result it is based on failed. // // For the most part, this is taken care of for us because any dependent targets that fail also // mark their parent targets (up to and including the entrypoint target) as failed. However, // there is one case in which this is not true: if the entrypoint target has AfterTargets that // fail, then as far as the entrypoint target knows when it is executing, it has succeeded. The // failure doesn't come until after. On the other hand, we don't want to actually include the // AfterTarget results in the build result itself if the user hasn't asked for them. // // So in the case where there are AfterTargets, we will check them for failure so that we can // make sure the overall success/failure result is correct, but not actually add their contents // to the new result. _baseOverallResult = true; foreach (string additionalTarget in additionalTargetsToCheck) { if (existingResults.ResultsByTarget.TryGetValue(additionalTarget, out TargetResult targetResult)) { if (targetResult.ResultCode == TargetResultCode.Failure && !targetResult.TargetFailureDoesntCauseBuildFailure) { _baseOverallResult = false; break; } } } } } }
BuildStatus buildCore(BuildRequest request, CancellationToken cancellation, BuildParameters parameters) { using (measureBlock("build time")) using (beginBuild(BuildManager, parameters)) using (cancellation.Register(() => { Log.I("cancelling background build"); BuildManager.CancelAllSubmissions(); })) { var projects = request.AllProjectsToBuildOrdered; foreach (var project in projects) { if (cancellation.IsCancellationRequested) return BuildStatus.Indeterminate; if (request.mustBeSkipped(project)) { notifyProjectSkipped(project); continue; } var buildData = request.createBuildRequestData(project); var result = BuildManager.BuildRequest(buildData); switch (result.OverallResult) { case BuildResultCode.Success: continue; case BuildResultCode.Failure: return BuildStatus.Failed; default: throw new ArgumentOutOfRangeException(); } } return BuildStatus.Ok; } }
public void TestPacketType() { BuildRequest request = CreateNewBuildRequest(0, Array.Empty <string>()); Assert.Equal(NodePacketType.BuildRequest, request.Type); }
void printIntro(BuildRequest request) { var isSolution = request.WholeSolutionBuild; var projectInfo = isSolution ? "Solution: " + getSolutionNameFromFilename(request.SolutionPath) : (request.PrimaryProjects.Length == 1 ? ("Project: " + nameOfProject(request.PrimaryProjects[0])) : ("Projects: " + request.PrimaryProjects.Select(nameOfProject).Aggregate((a, b) => a + ";" + b))); var configurationInfo = "Configuration: " + request.Configuration + " " + request.Platform; coreToIDE(() => _pane.OutputString($"---------- BuildOnSave: {projectInfo}, {configurationInfo} ----------\n")); }
public static bool CheckPlacement(Point2D location, Point2D size, uint type, BuildRequest skipRequest, bool buildingsOnly) { // Check if the building can be placed on this position of the map. for (float x = -size.X / 2f; x < size.X / 2f + 0.1f; x++) { for (float y = -size.Y / 2f; y < size.Y / 2f + 0.1f; y++) { if (!SC2Util.GetTilePlacable((int)Math.Round(location.X + x), (int)Math.Round(location.Y + y))) { return(false); } } } if (CanHaveAddOn(type)) { if (!SC2Util.GetTilePlacable((int)Math.Round(location.X + 2f), (int)Math.Round(location.Y - 1))) { return(false); } if (!SC2Util.GetTilePlacable((int)Math.Round(location.X + 2f), (int)Math.Round(location.Y))) { return(false); } if (!SC2Util.GetTilePlacable((int)Math.Round(location.X + 3f), (int)Math.Round(location.Y - 1))) { return(false); } if (!SC2Util.GetTilePlacable((int)Math.Round(location.X + 3f), (int)Math.Round(location.Y))) { return(false); } } foreach (Unit unit in Tyr.Bot.Observation.Observation.RawData.Units) { if (!unit.IsFlying && (unit.Owner != Tyr.Bot.PlayerId || unit.UnitType == UnitTypes.SIEGE_TANK_SIEGED || UnitTypes.BuildingTypes.Contains(unit.UnitType)) && !CheckDistance(location, type, SC2Util.To2D(unit.Pos), unit.UnitType, buildingsOnly)) { return(false); } } foreach (BuildRequest request in ConstructionTask.Task.UnassignedRequests) { if (request != skipRequest && !CheckDistance(location, type, request.Pos, request.Type, buildingsOnly)) { return(false); } } foreach (BuildRequest request in ConstructionTask.Task.BuildRequests) { if (request != skipRequest && !CheckDistance(location, type, request.Pos, request.Type, buildingsOnly)) { return(false); } } if (Tyr.Bot.MyRace == Race.Zerg && type != UnitTypes.HATCHERY && type != UnitTypes.EXTRACTOR) { BoolGrid creep = new ImageBoolGrid(Tyr.Bot.Observation.Observation.RawData.MapState.Creep, 1); for (float dx = -size.X / 2f; dx <= size.X / 2f + 0.01f; dx++) { for (float dy = -size.Y / 2f; dy <= size.Y / 2f + 0.01f; dy++) { if (!creep[(int)(location.X + dx), (int)(location.Y + dy)]) { return(false); } } } } if (Tyr.Bot.MyRace != Race.Zerg) { BoolGrid creep = new ImageBoolGrid(Tyr.Bot.Observation.Observation.RawData.MapState.Creep, 1); for (float dx = -size.X / 2f; dx <= size.X / 2f + 0.01f; dx++) { for (float dy = -size.Y / 2f; dy <= size.Y / 2f + 0.01f; dy++) { if (creep[(int)(location.X + dx), (int)(location.Y + dy)]) { return(false); } } } } if (type != UnitTypes.PYLON && Tyr.Bot.MyRace == Race.Protoss) { foreach (Unit unit in Tyr.Bot.Observation.Observation.RawData.Units) { if (unit.UnitType != UnitTypes.PYLON || unit.BuildProgress < 1) { continue; } if (Tyr.Bot.MapAnalyzer.MapHeight((int)unit.Pos.X, (int)unit.Pos.Y) < Tyr.Bot.MapAnalyzer.MapHeight((int)location.X, (int)location.Y)) { continue; } if (location.X - size.X / 2f >= unit.Pos.X - 6 && location.X + size.X / 2f <= unit.Pos.X + 6 && location.Y - size.Y / 2f >= unit.Pos.Y - 7 && location.Y + size.Y / 2f <= unit.Pos.Y + 7) { if (SC2Util.DistanceGrid(unit.Pos, location) <= 10 - size.X / 2f - size.Y / 2f) { return(true); } } } return(false); } return(true); }
/// <summary> /// Log that a project has started if it is serviced from the cache /// </summary> /// <param name="request">The build request.</param> /// <param name="configuration">The configuration used to build the request.</param> /// <returns>The BuildEventContext to use for this project.</returns> internal ProjectLoggingContext LogProjectStarted(BuildRequest request, BuildRequestConfiguration configuration) { ErrorUtilities.VerifyThrow(this.IsValid, "Build not started."); return new ProjectLoggingContext(this, request, configuration.ProjectFullPath, configuration.ToolsVersion, request.ParentBuildEventContext); }