/// <summary> /// Mark a verb as completed, and adjust our schedule accordingly. /// </summary> /// <param name="verb">The verb that completed.</param> /// <param name="disp">The disposition of the verb's execution.</param> private void verbIsComplete(IVerb verb, Disposition disp) { ////Say(string.Format(" {0} is complete: {1}", verb, dbgDisposition)); ////if (disp is Failed) ////{ //// // Failures can be hard to debug, since they don't leave any //// // output in nuobj/. So report these even if they aren't //// // built this run. //// emitRealtimeReport(verb, disp); ////} // Invariant: all of this verb's objs are non-Stale. foreach (BuildObject obj in verb.getOutputs()) { ////Say(string.Format(" waking {0}", obj)); IEnumerable <IVerb> wokenSet = this.waitIndex.awaken(obj); ////foreach (IVerb wokenVerb in wokenSet) ////{ //// //Say(string.Format(" {0} woken", wokenVerb)); ////} this.nextVerbs.UnionWith(wokenSet); } this.emitRealtimeReport(verb, disp); this.requiredVerbs.Remove(verb); this.completedVerbs.Add(verb); }
static public ResultSummaryRecord readXml(XmlReader xr) { Util.Assert(xr.Name.Equals(_xml_tag)); bool isVerificationTimeout = false; Boolean.TryParse( xr.GetAttribute(_IsVerificationTimeout_attr), out isVerificationTimeout); xr.ReadToFollowing(Disposition._xml_tag); Disposition d = Disposition.readXml(xr); List <BuildObjectValuePointer> lbovp = new List <BuildObjectValuePointer>(); while (xr.Read()) { if (xr.NodeType == XmlNodeType.EndElement) { Util.Assert(xr.Name.Equals(_xml_tag)); break; } else if (xr.NodeType == XmlNodeType.Element) { if (xr.Name.Equals(BuildObjectValuePointer._xml_tag)) { lbovp.Add(BuildObjectValuePointer.readXml(xr)); } else { throw new Exception("Unknown xml tag " + xr.Name); } } } return(new ResultSummaryRecord(d, lbovp, isVerificationTimeout)); }
/// <summary> /// Initializes a new instance of the ResultSummaryRecord class. /// </summary> /// <param name="verb"> /// The verb whose execution this is the result of. /// </param> /// <param name="disposition"> /// The disposition of the verb execution. /// </param> /// <param name="outputs"> /// The build objects that were produced by this verb execution. /// </param> internal ResultSummaryRecord( IVerb verb, Disposition disposition, IEnumerable <BuildObjectValuePointer> outputs) : this(verb, disposition, outputs, false) { }
public override Presentation getRealtimePresentation(Disposition d) { if (d is Failed) { return base.getRealtimePresentation(d); } VerificationResult vr = VerificationResult.fromXmlFile(this.getOutputFile()); PresentationBuilder pr = new PresentationBuilder(); pr.startLine(); pr.color( vr.pass ? Presentation.GREEN : Presentation.RED, string.Format( "{0} {1} {2,5:0.0}s", ////getSource().getRelativePath(), this.getAbstractIdentifier(), vr.pass ? "Success" : "Fail", vr.cpuTime)); pr.endLine(); if (!vr.pass) { foreach (VerificationMessage msg in vr.getMessages()) { pr.pre(msg.Message); } } return pr.fix(); }
/// <summary> /// Initializes a new instance of the ResultSummaryRecord class. /// </summary> /// <param name="verb"> /// The verb whose execution this is the result of. /// </param> /// <param name="disposition"> /// The disposition of the verb execution. /// </param> /// <param name="outputs"> /// The build objects that were produced by this verb execution. /// </param> internal ResultSummaryRecord( IVerb verb, Disposition disposition, IEnumerable<BuildObjectValuePointer> outputs) : this(verb, disposition, outputs, false) { }
public ResultSummaryRecord( Disposition disposition, IEnumerable <BuildObjectValuePointer> outputs, bool isVerificationTimeout) { Init(null, disposition, outputs, isVerificationTimeout); }
/// <summary> /// Initializes a new instance of the ResultSummaryRecord class. /// </summary> /// <param name="disposition"> /// The disposition of the verb execution. /// </param> /// <param name="outputs"> /// The build objects that were produced by this verb execution. /// </param> /// <param name="isVerificationTimeout"> /// Whether this result is a verification timeout. /// </param> internal ResultSummaryRecord( Disposition disposition, IEnumerable<BuildObjectValuePointer> outputs, bool isVerificationTimeout) : this(null, disposition, outputs, isVerificationTimeout) { }
void verbIsComplete(IVerb verb, Disposition disp, BlessingRequest blessingRequest) { emitRealtimeReport(verb, disp); //-Say(String.Format(" {0} is complete: {1}", verb, dbgDisposition)); //-if (disp is Failed) //-{ //- //- //- //- emitRealtimeReport(verb, disp); //-} //- invariant: all of this verb's objs are non-Stale. foreach (BuildObject obj in verb.getOutputs()) { if (blessingRequest == BlessingRequest.Bless) { nuObjContents.blessGeneral(obj, disp); } //-Say(String.Format(" waking {0}", obj)); IEnumerable <IVerb> wokenSet = waitIndex.awaken(obj); //-foreach (IVerb wokenVerb in wokenSet) //-{ //- //-} nextVerbs.UnionWith(wokenSet); } requiredVerbs.Remove(verb); completedVerbs.Add(verb); }
public override Presentation getRealtimePresentation(Disposition d) { if (d is Failed) { return(base.getRealtimePresentation(d)); } VerificationResult vr = VerificationResult.fromXmlFile(getOutputFile().getFilesystemPath()); PresentationBuilder pr = new PresentationBuilder(); pr.startLine(); pr.color( vr.pass ? Presentation.GREEN : Presentation.RED, String.Format("{0} {1} {2,5:0.0}s", //-getSource().getRelativePath(), this.getAbstractIdentifier(), (vr.pass ? "Success" : "Fail"), vr.cpuTime)); pr.endLine(); if (!vr.pass) { foreach (VerificationMessage msg in vr.getMessages()) { pr.pre(msg.message); } } return(pr.fix()); }
/// <summary> /// Reads a build object from the local filesystem and stores it in the /// cache. /// </summary> /// <param name="workingDirectory"> /// Private directory for verb execution. /// </param> /// <param name="obj">The build object to store in the cache.</param> /// <param name="disposition"> /// Disposition of verb which created this object (if known). /// </param> /// <returns>A BuildObjectValuePointer describing the object.</returns> public BuildObjectValuePointer Store(WorkingDirectory workingDirectory, BuildObject obj, Disposition disposition) { string contentHash = Util.hashFilesystemPath(workingDirectory.PathTo(obj)); this.itemCache.StoreItemFromFile(ItemCacheContainer.Objects, contentHash, workingDirectory.PathTo(obj)); this.Add(obj, disposition, contentHash, null); return new BuildObjectValuePointer(contentHash, obj.getRelativePath()); }
/// <summary> /// Logs output regarding a verb's execution disposition. /// </summary> /// <param name="verb">The verb in question.</param> /// <param name="disposition">Disposition of the verb execution.</param> private void emitRealtimeReport(IVerb verb, Disposition disposition) { Presentation pr = verb.getRealtimePresentation(disposition); ASCIIPresentater ascii = new ASCIIPresentater(); pr.format(ascii); Logger.Write(ascii.ToString()); }
public override Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { if (!(disposition is Failed)) { File.WriteAllText(workingDirectory.PathTo(this.getOutputFile()), stdout); } return disposition; }
/// <summary> /// Completes a task (verb run). /// </summary> /// <remarks> /// Note that for Async verb workers, this method runs on a separate thread. /// </remarks> /// <param name="verb">The verb which was run.</param> /// <param name="worker">The verb's worker.</param> private void completeTask(IVerb verb, IVerbWorker worker) { this.taskCompletionsLock.AcquireWriterLock(Timeout.Infinite); Disposition disp = worker.Complete(); TaskCompletion tc = new TaskCompletion(worker.GetWorkingDirectory(), verb, disp); this.taskCompletions.Add(tc); this.completionEvent.Set(); this.taskCompletionsLock.ReleaseWriterLock(); }
void completeTask(IVerb verb, IVerbWorker worker) { taskCompletionsLock.AcquireWriterLock(Timeout.Infinite); Disposition disp = worker.complete(); TaskCompletion tc = new TaskCompletion(verb, disp); taskCompletions.Add(tc); completionEvent.Set(); taskCompletionsLock.ReleaseWriterLock(); }
void blessInternal(BuildObject obj, string hashIfKnown, Disposition disp, VirtualContents contents) { Util.Assert(!theCache.ContainsKey(obj)); //- I don't think we should ever write the same file twice in one run. string hash = hashIfKnown; if (hash == null && disp is Fresh && !(obj is VirtualBuildObject)) { hash = _hasher.hash(obj.getFilesystemPath()); } theCache[obj] = new NuObjValue(hash, disp, contents); }
private void processTaskCompletions(List <AsyncRunner.TaskCompletion> taskCompletions) { foreach (AsyncRunner.TaskCompletion tc in taskCompletions) { //- We may record a Failure if the verb didn't output //- everything it promised to. Disposition recordedDisposition = recordResult(tc.verb, tc.disposition); Say(String.Format(" {0} completed with disposition {1}", tc.verb, tc.disposition)); } //- Waking process may have shaken some verbs loose for us to evaluate next time around. }
public ResultSummaryRecord( IVerb verb, Disposition disposition, IEnumerable <BuildObjectValuePointer> outputs) { bool isVerificationTimeout = false; if (verb != null && verb is IRejectable) { isVerificationTimeout = ((IRejectable)verb).resultWasVerificationTimeout(); } Init(verb, disposition, outputs, isVerificationTimeout); }
private void Init( IVerb verb, Disposition disposition, IEnumerable <BuildObjectValuePointer> outputs, bool isVerificationTimeout) { this._verb = verb; this._disposition = disposition; this._outputs = new List <BuildObjectValuePointer>(outputs); this._isVerificationTimeout = isVerificationTimeout; if (_verb is IRejectable) { _isVerificationTimeout = ((IRejectable)_verb).resultWasVerificationTimeout(); } }
/// <summary> /// Initializes a new instance of the ResultSummaryRecord class. /// </summary> /// <param name="verb"> /// The verb whose execution this is the result of. /// </param> /// <param name="disposition"> /// The disposition of the verb execution. /// </param> /// <param name="outputs"> /// The build objects that were produced by this verb execution. /// </param> /// <param name="isRejectableFailure"> /// Whether this result is a rejectable failure. /// </param> internal ResultSummaryRecord( IVerb verb, Disposition disposition, IEnumerable <BuildObjectValuePointer> outputs, bool isRejectableFailure) { this.verb = verb; this.disposition = disposition; this.outputs = new List <BuildObjectValuePointer>(outputs); this.isRejectableFailure = isRejectableFailure; IRejectable rejectableVerb = verb as IRejectable; if (rejectableVerb != null) { this.isRejectableFailure = rejectableVerb.resultWasRejectableFailure(); } }
//- Called by tool when we want a short (one-line) //- summary for showing in-progress results. public virtual Presentation getRealtimePresentation(Disposition d) { PresentationBuilder pr = new PresentationBuilder(); pr.startLine(); pr.color( d is Fresh ? Presentation.GREEN : Presentation.RED, ToString() + " " + d.ToString()); pr.endLine(); if (d is Failed) { //- This isn't a verification failure, a tool itself broke. //- Provide that report. foreach (string m in d.getMessages()) { pr.pre(Presentation.abbreviateLines(m)); } } return(pr.fix()); }
/// <summary> /// Add information about an object to the Repository. /// </summary> /// <param name="obj">The object to add.</param> /// <param name="disposition"> /// Disposition of the verb which created this object. /// </param> /// <param name="hash">Hash of the object's contents.</param> /// <param name="contents">Contents of the object (if virtual).</param> private void Add(BuildObject obj, Disposition disposition, string hash, VirtualContents contents) { // Every object in the repository should either have a hash value // or virtual contents, but not both. Util.Assert((string.IsNullOrEmpty(hash) && contents != null) || (!string.IsNullOrEmpty(hash) && (contents == null))); // Check to see if the object is already in this repository. if (this.entries.ContainsKey(obj)) { // We shouldn't be adding conflicting information for // the same object during the same build run. RepositoryEntry entry = this.entries[obj]; Util.Assert(entry.Disposition.GetType() == disposition.GetType()); Util.Assert(entry.Hash.Equals(hash, StringComparison.Ordinal)); Util.Assert(entry.VirtualContents == contents); // Don't replace existing entry with equivalent. return; } this.entries[obj] = new RepositoryEntry(disposition, hash, contents); }
public void blessGeneral(BuildObject obj, Disposition disp) { if (obj is VirtualBuildObject) { if (disp is Fresh) { //- The object is fresh, so the verb ran its Execute //- method and squirted the results into theCache; //- this call is from the scheduler cleaning up, //- and we can ignore it. Util.Assert(theCache.ContainsKey(obj)); Util.Assert(theCache[obj].disp is Fresh); } else { Util.Assert(disp is Failed); storeVirtual(obj, disp, null); } } else { bless(obj, null, disp); } }
public override Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { // No cleanup to do. return(disposition); }
/// <summary> /// Add information about an object to the Repository. /// </summary> /// <param name="obj">The object to add.</param> /// <param name="disposition"> /// Disposition of the verb which created this object. /// </param> /// <param name="hash">Hash of the object's contents.</param> /// <param name="contents">Contents of the object (if virtual).</param> private void Add(BuildObject obj, Disposition disposition, string hash, VirtualContents contents) { // Every object in the repository should either have a hash value // or virtual contents, but not both. Util.Assert((string.IsNullOrEmpty(hash) && contents != null) || (!string.IsNullOrEmpty(hash) && (contents == null))); // Check to see if the object is already in this repository. if (this.entries.ContainsKey(obj)) { // We shouldn't be adding conflicting information for // the same object during the same build run. RepositoryEntry entry = this.entries[obj]; Util.Assert(entry.Disposition.GetType() == disposition.GetType()); Util.Assert(entry.Hash.Equals(hash, StringComparison.Ordinal)); Util.Assert(entry.VirtualContents == contents); // Don't replace existing entry with equivalent. return; } this.entries[obj] = new RepositoryEntry(disposition, hash, contents); }
/// <summary> /// Logs output regarding a verb's execution disposition. /// </summary> /// <param name="verb">The verb in question.</param> /// <param name="disposition">Disposition of the verb execution.</param> private void emitRealtimeReport(IVerb verb, Disposition disposition) { Presentation pr = verb.getRealtimePresentation(disposition); ASCIIPresentater ascii = new ASCIIPresentater(); pr.format(ascii); Logger.Write(ascii.ToString()); }
public virtual Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { return disposition; }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { if (disposition is Failed) { return disposition; } HashSet<string> createdFiles = new HashSet<string>(Directory.GetFiles(workingDirectory.PathTo(this.getAbsDestPath())).Select(path => Path.GetFileName(path))); HashSet<string> expectedFiles = new HashSet<string>(this.getOutputs().Select(obj => obj.getFileName())); // DafnyCC/DafnySpec process a big batch of files together. Did we correctly understand what it did? if (!createdFiles.SetEquals(expectedFiles)) { // REVIEW: These are never used by anything. Remove? bool dummy = createdFiles.SetEquals(expectedFiles); int missing = expectedFiles.Except(createdFiles).Count(); int extra = createdFiles.Except(expectedFiles).Count(); string msg = "Missing files: " + string.Join(",", expectedFiles.Except(createdFiles)) + "\n" + " Extra files: " + string.Join(",", createdFiles.Except(expectedFiles)); return new Failed(msg); } // Propagate the NuBuild annotations. foreach (InOutMapping mapping in this.getInOutMappings()) { if (mapping.dfysource != null && this.transformFilterAccepts(mapping.dfysource)) { AnnotationScanner.transferAnnotations( workingDirectory, mapping.dfysource, mapping.basmIfc, BoogieAsmDepBase.CommentSymbol); AnnotationScanner.transferAnnotations( workingDirectory, mapping.dfysource, mapping.basmImp, BoogieAsmDepBase.CommentSymbol); } } return new Fresh(); }
/// <summary> /// Mark a verb as completed, and adjust our schedule accordingly. /// </summary> /// <param name="verb">The verb that completed.</param> /// <param name="disp">The disposition of the verb's execution.</param> private void verbIsComplete(IVerb verb, Disposition disp) { ////Say(string.Format(" {0} is complete: {1}", verb, dbgDisposition)); ////if (disp is Failed) ////{ //// // Failures can be hard to debug, since they don't leave any //// // output in nuobj/. So report these even if they aren't //// // built this run. //// emitRealtimeReport(verb, disp); ////} // Invariant: all of this verb's objs are non-Stale. foreach (BuildObject obj in verb.getOutputs()) { ////Say(string.Format(" waking {0}", obj)); IEnumerable<IVerb> wokenSet = this.waitIndex.awaken(obj); ////foreach (IVerb wokenVerb in wokenSet) ////{ //// //Say(string.Format(" {0} woken", wokenVerb)); ////} this.nextVerbs.UnionWith(wokenSet); } this.emitRealtimeReport(verb, disp); this.requiredVerbs.Remove(verb); this.completedVerbs.Add(verb); }
/// <summary> /// Adds the output objects from a cached verb execution to the /// repository, and ensures they are present in the item cache. /// </summary> /// <param name="verb">The verb whose outputs to add.</param> /// <param name="resultRecord"> /// The result summary record of the verb execution. /// </param> /// <remarks> /// Call only when output objects are known to be cached /// (i.e. because FetchResult returned non-Stale). /// REVIEW: This function probably shouldn't be in this file. /// It does something similar for cached verb results that /// the scheduler's recordResult method does for new verb /// executions. Move this there and/or refactor? /// </remarks> public void AddVerbResults(IVerb verb, ResultSummaryRecord resultRecord) { if (this.alreadyAddedVerbs.Contains(verb)) { // We only need to add a cached verb execution's outputs once. return; } Disposition disposition = resultRecord.Disposition; // REVIEW: In the below, some of these IEnumerables should be // HashSets, and the HashSet should be a simple List. // Create a collection of the potential outputs. IEnumerable <BuildObject> outputs = verb.getOutputs(); IEnumerable <BuildObject> failureOutputs = verb.getFailureOutputs(); outputs = outputs.Concat(failureOutputs); Dictionary <string, BuildObject> potentialOutputs = new Dictionary <string, BuildObject>(); foreach (BuildObject obj in outputs) { potentialOutputs.Add(obj.getRelativePath(), obj); } // Compare the actual outputs with the potential outputs, // and add the actual ones to the repository. HashSet <BuildObject> recorded = new HashSet <BuildObject>(); foreach (BuildObjectValuePointer actualOutput in resultRecord.Outputs) { if (potentialOutputs.ContainsKey(actualOutput.RelativePath)) { BuildObject obj = potentialOutputs[actualOutput.RelativePath]; // TODO: Verify that the object exists in the item cache! this.AddObject(obj, disposition, actualOutput.ObjectHash); recorded.Add(obj); // Store a copy of this verb output as a file in the real nuobj directory. Util.Assert(actualOutput.RelativePath.StartsWith(BuildEngine.theEngine.getObjRoot(), StringComparison.Ordinal)); this.itemCache.FetchItemToFile(ItemCacheContainer.Objects, actualOutput.ObjectHash, IronRootDirectory.PathTo(actualOutput.RelativePath)); } else { // Complain if we find interloping outputs. throw new Exception("Distressing: some actual verb outputs aren't in the verb's list of potential outputs"); } } // Create a collection of missing outputs. IEnumerable <BuildObject> unrecorded = outputs.Except(recorded).Except(failureOutputs); // For non-Failed verb runs, complain if all expected outputs don't // show up in the actual outputs. Util.Assert(unrecorded.Count() == 0 || disposition is Failed); // For cached verb runs with permanent failures (i.e. disposition // is Failed), we want to mark all of the expected outputs as Failed // even if no corresponding actual output was produced during the // failed verb run. foreach (BuildObject obj in unrecorded) { this.AddObject(obj, disposition, null); } // Remember that we've already added this verb's outputs. this.alreadyAddedVerbs.Add(verb); }
/// <summary> /// Initializes a new instance of the TaskCompletion class. /// </summary> /// <param name="workingDirectory"> /// The private working directory the task executed in. /// </param> /// <param name="verb"> /// The verb whose completion this instance describes. /// </param> /// <param name="disposition"> /// The disposition of this task. /// </param> public TaskCompletion(WorkingDirectory workingDirectory, IVerb verb, Disposition disposition) { this.workingDirectory = workingDirectory; this.verb = verb; this.disposition = disposition; }
public virtual Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { if (!(disposition is Failed)) { // Check that the executable isn't too large. long exeSize = new FileInfo(workingDirectory.PathTo(this.outputObject)).Length; if (exeSize > this.maxExeSize) { return new Failed("Executable too big"); } } return disposition; }
/// <summary> /// Add information about a virtual object to the Repository, /// including its contents. /// </summary> /// <param name="obj">The object in question.</param> /// <param name="disposition"> /// Disposition of the verb which created this object. /// </param> /// <param name="contents">Contents of the object.</param> public void StoreVirtual(BuildObject obj, Disposition disposition, VirtualContents contents) { Util.Assert(obj is VirtualBuildObject); this.Add(obj, disposition, null, contents); }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { var dis = disposition; string cSharpPath = Path.ChangeExtension(workingDirectory.PathTo(this.expandedSource), CSharpExt); if (!File.Exists(cSharpPath)) { // Dafny has a bug where compilation fails but result code is still 0. dis = new Failed(); } if (dis is Fresh) { this.RewriteCSharpFile(cSharpPath, workingDirectory.PathTo(this.output)); } return dis; }
//- Contract: call only when output objects are known to be cached //- (because fetchResult returned non-Stale). public void fetchOutputObjects(IVerb verb, IEnumerable <BuildObjectValuePointer> values, Disposition disp) { if (this.alreadyFetchedVerbs.Contains(verb)) { return; } IEnumerable <BuildObject> objects = verb.getOutputs(); IEnumerable <BuildObject> failureObjs = verb.getFailureOutputs(); objects = objects.Concat(failureObjs); Dictionary <string, BuildObject> objectDict = new Dictionary <string, BuildObject>(); foreach (BuildObject obj in objects) { objectDict.Add(obj.getRelativePath(), obj); } HashSet <BuildObject> recorded = new HashSet <BuildObject>(); foreach (BuildObjectValuePointer value in values) { if (objectDict.ContainsKey(value.relativePath)) { BuildObject obj = objectDict[value.relativePath]; obj.prepareObjDirectory(); this.fetchObject(value, obj); nuObjectContents.bless(obj, value.objectHash, disp); recorded.Add(obj); } else { throw new Exception("Distressing: some BOVPs aren't in obj.getOutputs"); } } IEnumerable <BuildObject> unrecorded = objects.Except(recorded).Except(failureObjs); Util.Assert(unrecorded.Count() == 0 || disp is Failed); foreach (BuildObject obj in unrecorded) { nuObjectContents.bless(obj, null, disp); } this.alreadyFetchedVerbs.Add(verb); }
void main(string[] cmdline_args) { string[] all_args = fetchConfigArgs().Concat(cmdline_args).ToArray(); logNubuildInvocation(all_args); try { parseArgs(all_args); } catch (UserError err) { usage(err.Message); } BuildEngine.theEngine.ItemCache = GetItemCache(); BuildEngine.theEngine.Repository = new Repository(BuildEngine.theEngine.ItemCache); if (this.useCloudExecution) { if (!this.useCloudCache) { usage("Cloud Execution requires Cloud Cache!"); } BuildEngine.theEngine.CloudReportQueueName = Path.GetRandomFileName().Substring(0, 8); // BuildEngine.theEngine.CloudExecutionQueue = new CloudExecutionQueue(BuildEngine.theEngine.CloudReportQueueName); Logger.WriteLine("Using cloud report queue name: " + BuildEngine.theEngine.CloudReportQueueName); } Scheduler scheduler = new Scheduler(jobParallelism); scheduler.addTargetVerbs(verbs); ////try ////{ scheduler.parallelSchedule(); ////} ////catch (Exception ex) ////{ //// scheduler.dbgDisplayCounts(); //// throw; ////} IEnumerable <BuildObject> targets = scheduler.getTargets(); BuildObject outputTarget = null; if (targets.Count() > 0) { outputTarget = targets.First(); } else { Logger.WriteLine("No targets requested."); } if (targets.Count() > 1) { // TODO need a better story for relaying failure results. Right now // they get stuck in the results cache, but don't appear where we // can find them. Emit to a log, or to files in nuobj? Logger.WriteLine("Multiple targets build. First result follows."); } if (outputTarget != null) { Disposition d = scheduler.getObjectDisposition(outputTarget); if (d is Fresh) { ASCIIPresentater ascii = new ASCIIPresentater(); IVerb verb = scheduler.getParent(outputTarget); verb.getPresentation().format(ascii); Logger.Write(ascii.ToString()); if (this.html_output != null) { HTMLPresentater html = new HTMLPresentater(); verb.getPresentation().format(html); try { using (StreamWriter sw = new StreamWriter(this.html_output)) { sw.Write(html.ToString()); } } catch (Exception e) { Logger.WriteLine("Failed to write html output to file: " + html_output); Logger.WriteLine("Exception was: " + e); } } } else { Logger.WriteLine("Build failed."); foreach (string msg in d.getMessages()) { Logger.Write(msg); } } } else if (targets.Count() == 0) { Logger.WriteLine("No targets requested."); } else { Logger.WriteLine("Multiple targets built. Look for results in nuobj/."); } // - // We have to explicitly ask the BackgroundWorker thread to exit // as it will prevent the process from exiting until it does. // - this.backgroundWorker.StopWork(); // - // Report what the background worker accomplished during this run. // - this.backgroundWorker.WaitForCompletion(); Logger.WriteLine(string.Format("Background Worker completed {0} work items out of {1} queued.", this.backgroundWorker.GetWorkItemsPerformed, this.backgroundWorker.GetWorkItemsQueued)); if (this.backgroundWorker.GetWorkItemsFailed != 0) { Logger.WriteLine(string.Format( "{0} work item procedures failed (threw an exception).", this.backgroundWorker.GetWorkItemsFailed)); } }
/// <summary> /// Add information about an object to the Repository. /// The object path must be under the object root. /// </summary> /// <param name="obj">The object in question.</param> /// <param name="disposition"> /// Disposition of the verb which created this object. /// </param> /// <param name="hash">Hash of the object's contents.</param> public void AddObject(BuildObject obj, Disposition disposition, string hash) { Util.Assert(obj.getRelativePath().StartsWith(BuildEngine.theEngine.getObjRoot(), StringComparison.Ordinal)); this.Add(obj, disposition, hash, null); }
/// <summary> /// Add information about an object to the Repository. /// The object path must be under the object root. /// </summary> /// <param name="obj">The object in question.</param> /// <param name="disposition"> /// Disposition of the verb which created this object. /// </param> /// <param name="hash">Hash of the object's contents.</param> public void AddObject(BuildObject obj, Disposition disposition, string hash) { Util.Assert(obj.getRelativePath().StartsWith(BuildEngine.theEngine.getObjRoot(), StringComparison.Ordinal)); this.Add(obj, disposition, hash, null); }
/// <summary> /// Add information about a virtual object to the Repository, /// including its contents. /// </summary> /// <param name="obj">The object in question.</param> /// <param name="disposition"> /// Disposition of the verb which created this object. /// </param> /// <param name="contents">Contents of the object.</param> public void StoreVirtual(BuildObject obj, Disposition disposition, VirtualContents contents) { Util.Assert(obj is VirtualBuildObject); this.Add(obj, disposition, null, contents); }
public override Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { // No cleanup to do. return disposition; }
/// <summary> /// Initializes a new instance of the ResultSummaryRecord class. /// </summary> /// <param name="verb"> /// The verb whose execution this is the result of. /// </param> /// <param name="disposition"> /// The disposition of the verb execution. /// </param> /// <param name="outputs"> /// The build objects that were produced by this verb execution. /// </param> /// <param name="isRejectableFailure"> /// Whether this result is a rejectable failure. /// </param> internal ResultSummaryRecord( IVerb verb, Disposition disposition, IEnumerable<BuildObjectValuePointer> outputs, bool isRejectableFailure) { this.verb = verb; this.disposition = disposition; this.outputs = new List<BuildObjectValuePointer>(outputs); this.isRejectableFailure = isRejectableFailure; IRejectable rejectableVerb = verb as IRejectable; if (rejectableVerb != null) { this.isRejectableFailure = rejectableVerb.resultWasRejectableFailure(); } }
public override Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { if (!(disposition is Failed)) { File.WriteAllText(workingDirectory.PathTo(this.getOutputFile()), stdout); } return(disposition); }
// Called by tool when we want a short (one-line) // summary for showing in-progress results. public virtual Presentation getRealtimePresentation(Disposition d) { PresentationBuilder pr = new PresentationBuilder(); pr.startLine(); pr.color( d is Fresh ? Presentation.GREEN : Presentation.RED, this.ToString() + " " + d.ToString()); pr.endLine(); if (d is Failed) { // This isn't a verification failure, a tool itself broke. // Provide that report. foreach (string m in d.getMessages()) { pr.pre(Presentation.abbreviateLines(m)); } } return pr.fix(); }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { VerificationResult vr = new VerificationResult( this.dfysource.getRelativePath(), cpuTimeSeconds, stdout, stderr, new VerificationResultDafnyParser()); vr.addBasicPresentation(); vr.toXmlFile(workingDirectory.PathTo(this.getOutputFile())); this.setWasRejectableFailure(!vr.pass); return disposition; }
public TaskCompletion(IVerb verb, Disposition disposition) { this.verb = verb; this.disposition = disposition; }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { VerificationResult vr = new VerificationResult( bplInput.getRelativePath(), cpuTimeSeconds, stdout, stderr, new VerificationResultBoogieParser()); vr.addBasicPresentation(); vr.toXmlFile(workingDirectory.PathTo(getOutputFile())); setWasRejectableFailure(vr.wasOnlyTimeouts()); return disposition; }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { VerificationResult vr = new VerificationResult( this.dfysource.getRelativePath(), cpuTimeSeconds, stdout, stderr, new VerificationResultDafnyParser()); vr.addBasicPresentation(); vr.toXmlFile(workingDirectory.PathTo(this.getOutputFile())); this.setWasRejectableFailure(!vr.pass); return(disposition); }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { postprocess(workingDirectory); return disposition; }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { if (disposition is Fresh) { BeatExtensions.propagatePrivateImports(workingDirectory, this.contextVerb, this.beatobj, this.outputFile()); // And then propagate the NuBuild annotations, too. AnnotationScanner.transferAnnotations( workingDirectory, this.beatobj, this.outputFile(), BoogieAsmDepBase.CommentSymbol); } return(disposition); }
/// <summary> /// Initializes a new instance of the RepositoryEntry class. /// </summary> /// <param name="disposition"> /// Disposition of the verb that created this object. /// </param> /// <param name="hash">Hash of the object's contents.</param> /// <param name="virtualContents"> /// Computed value of the object (if virtual, null otherwise). /// </param> public RepositoryEntry(Disposition disposition, string hash, VirtualContents virtualContents) { this.hash = hash; this.disposition = disposition; this.virtualContents = virtualContents; }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { return(disposition); }
/// <summary> /// Initializes a new instance of the RepositoryEntry class. /// </summary> /// <param name="disposition"> /// Disposition of the verb that created this object. /// </param> /// <param name="hash">Hash of the object's contents.</param> /// <param name="virtualContents"> /// Computed value of the object (if virtual, null otherwise). /// </param> public RepositoryEntry(Disposition disposition, string hash, VirtualContents virtualContents) { this.hash = hash; this.disposition = disposition; this.virtualContents = virtualContents; }
public Disposition Complete(WorkingDirectory workingDirectory, double cpuTimeSeconds, string stdout, string stderr, Disposition disposition) { if (disposition is Fresh) { BeatExtensions.propagatePrivateImports(workingDirectory, this.contextVerb, this.beatobj, this.outputFile()); // And then propagate the NuBuild annotations, too. AnnotationScanner.transferAnnotations( workingDirectory, this.beatobj, this.outputFile(), BoogieAsmDepBase.CommentSymbol); } return disposition; }
/// <summary> /// Reads a build object from the local filesystem and stores it in the /// cache. /// </summary> /// <param name="workingDirectory"> /// Private directory for verb execution. /// </param> /// <param name="obj">The build object to store in the cache.</param> /// <param name="disposition"> /// Disposition of verb which created this object (if known). /// </param> /// <returns>A BuildObjectValuePointer describing the object.</returns> public BuildObjectValuePointer Store(WorkingDirectory workingDirectory, BuildObject obj, Disposition disposition) { string contentHash = Util.hashFilesystemPath(workingDirectory.PathTo(obj)); this.itemCache.StoreItemFromFile(ItemCacheContainer.Objects, contentHash, workingDirectory.PathTo(obj)); this.Add(obj, disposition, contentHash, null); return(new BuildObjectValuePointer(contentHash, obj.getRelativePath())); }