public override void SetResult(NodeResult result) { if (result == NodeResult.Failure) { _isOnceFailure = true; } }
// running in range returns true, but since simple firing is called on all tags children, it's triggered on all fighters, every sequence // solution: make tags run all only once, with diff results for all(dict for list nodes) // solution 2(taken): run only tags that are under some root.(compare root) public override NodeResult Execute() { if (nodes.Count == 0) { return(NodeResult.None); } for (int i = 0; i < nodes.Count; i++) { NodeResult r = nodes[i].StandardNodeExecute(); switch (r) { case NodeResult.Success: break; case NodeResult.Failure: return(NodeResult.Failure); case NodeResult.Running: break; case NodeResult.None: break; default: break; } } return(NodeResult.Success); }
internal RestartNodeResult(SelectedReplica selectedReplica, NodeResult nodeResult) { ReleaseAssert.AssertIfNull(nodeResult, "Node result cannot be null"); ReleaseAssert.AssertIfNull(selectedReplica, "Selected replica cannot be null"); this.NodeResult = nodeResult; this.SelectedReplica = selectedReplica; }
public override IEnumerator <NodeResult> Tick() { NodeResult state = NodeResult.Success; foreach (var node in _nodes) { IEnumerator <NodeResult> result = node.Tick(); while (result.MoveNext()) { if (result.Current == NodeResult.Running) { yield return(result.Current); } else { break; } } if (result.Current == NodeResult.Failure) { state = result.Current; break; } } yield return(state); }
public override IEnumerator <NodeResult> Tick() { NodeResult returnNodeResult = NodeResult.Succes; foreach (INode node in _nodes) { IEnumerator <NodeResult> result = node.Tick(); while (result.MoveNext() && result.Current == NodeResult.Running) { yield return(NodeResult.Running); } returnNodeResult = result.Current; if (returnNodeResult == NodeResult.Succes) { continue; } if (returnNodeResult == NodeResult.Failure) { break; } } yield return(returnNodeResult); }
public static CompilerMessage[] ParseCompilerOutput(NodeResult nodeResult) { // TODO: future improvement opportunity: write a single parser that can parse warning, errors files from all tools that we use. if (nodeResult.annotation.StartsWith("CopyFiles")) { if (nodeResult.exitcode == 0) { return(Array.Empty <CompilerMessage>()); } return(new[] { new CompilerMessage { file = nodeResult.outputfile, message = $"{nodeResult.outputfile}: {nodeResult.stdout}", type = CompilerMessageType.Error } }); } var parser = nodeResult.annotation.StartsWith("ILPostProcess") ? (CompilerOutputParserBase) new PostProcessorOutputParser() : (CompilerOutputParserBase) new MicrosoftCSharpCompilerOutputParser(); return(parser .Parse( (nodeResult.stdout ?? string.Empty).Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries), nodeResult.exitcode != 0).ToArray()); }
public async void Pipeline_Result_Ids_Equal_Node_Ids() { var pipelineNode = new PipelineNode <TestObjectA> { Id = "PipelineNode1", FlowId = "Flow1" }; pipelineNode.AddChild(new SimpleTestNodeA1 { FlowId = "Flow1" }); pipelineNode.AddChild(new SimpleTestNodeA2 { Id = "Child2", FlowId = "Flow1" }); var testObject = new TestObjectA(); NodeResult result = await pipelineNode.ExecuteAsync(testObject); pipelineNode.Status.ShouldEqual(NodeRunStatus.Completed); result.FlowId.ShouldEqual("Flow1"); result.Id.ShouldEqual("PipelineNode1"); result.ChildResults.First().Id.ShouldEqual("Banzai.Test.SimpleTestNodeA1"); result.ChildResults.First().FlowId.ShouldEqual("Flow1"); var secondResult = result.ChildResults.FirstOrDefault(x => x.Id == "Child2"); secondResult.ShouldNotBeNull(); secondResult.FlowId.ShouldEqual("Flow1"); }
public override void Report(NodeResult nodeResult) { nodesInFlight.Remove(nodeResult.annotation); UpdateReportedNode(); Report(nodeResult.processed_node_count / (float)nodeResult.number_of_nodes_ever_queued); }
public async void Parent_Pipeline_Cancels_Execution_When_Child_Pipeline_Node_Cancelled() { var testNode1 = new SimpleTestNodeA1(); var testNode2 = new SimpleTestNodeA1(true, false, true); var testNode3 = new SimpleTestNodeA2(); var innerPipelineNode = new PipelineNode <TestObjectA>(); innerPipelineNode.AddChild(testNode1); innerPipelineNode.AddChild(testNode2); var pipelineNode = new PipelineNode <TestObjectA>(); pipelineNode.AddChild(innerPipelineNode); pipelineNode.AddChild(testNode3); var testObject = new TestObjectA(); NodeResult result = await pipelineNode.ExecuteAsync(testObject); result.Status.ShouldEqual(NodeResultStatus.Succeeded); innerPipelineNode.Status.ShouldEqual(NodeRunStatus.Completed); testNode1.Status.ShouldEqual(NodeRunStatus.Completed); testNode2.Status.ShouldEqual(NodeRunStatus.NotRun); pipelineNode.Status.ShouldEqual(NodeRunStatus.Completed); testNode3.Status.ShouldEqual(NodeRunStatus.NotRun); }
public override int DiscoverSubCategories(Category parentCategory) { Section section = (Section)parentCategory.Other; parentCategory.Other = section; parentCategory.SubCategories = new List <Category>(); NodeResult result = section.Update(); if (result == NodeResult.Failed) { return(parentCategory.SubCategories.Count); } parentCategory.SubCategories = new List <Category>(); foreach (Section subSection in section.Sections) { Category cat = new Category(); cat.ParentCategory = parentCategory; cat.Name = subSection.Name; cat.Other = subSection; cat.HasSubCategories = hasSubCategories(subSection); parentCategory.SubCategories.Add(cat); } parentCategory.SubCategoriesDiscovered = true; return(parentCategory.SubCategories.Count); }
public async Task Pipeline_Overall_Result_Subject_Equals_Last_Changed_Subject() { var pipelineNode = new PipelineNode <TestObjectA>(); var node1 = new SimpleTestNodeA1(); var node2 = new SubjectChangingNode1(); var node3 = new SimpleTestNodeA2(); var node4 = new SubjectChangingNode1(); pipelineNode.AddChild(node1); pipelineNode.AddChild(node2); pipelineNode.AddChild(node3); pipelineNode.AddChild(node4); var testObject = new TestObjectA(); NodeResult result = await pipelineNode.ExecuteAsync(testObject); pipelineNode.Status.Should().Be(NodeRunStatus.Completed); var childResults = result.ChildResults.ToList(); result.Subject.Should().NotBeSameAs(testObject); result.Subject.Should().NotBeSameAs(childResults[1].Subject); result.Subject.Should().NotBeSameAs(childResults[2].Subject); result.Subject.Should().BeSameAs(childResults[3].Subject); }
private object ParseSingleIPRelationships(IStatementResult result) { var node = new NodeResult(); var tempDomainNodes = new List <NodeResult>(); var relationships = new List <object>(); int i = 0; foreach (var record in result) { var target = i; node = new NodeResult { title = record["i"].As <string>(), label = "ip" }; i += 1; var domains = record["domains"].As <List <string> >(); foreach (var domain in domains) { var source = tempDomainNodes.FindIndex(c => c.title == domain); if (source == -1) { tempDomainNodes.Add(new NodeResult { title = domain, label = "domain" }); source = i; i += 1; } relationships.Add(new { target, source }); } } return(new { node, links = tempDomainNodes }); }
void IXmlSerializable.ReadXml(XmlReader reader) { reader.MoveToContent(); this.Version = reader.GetAttributeDouble("version"); this.Generator = reader.GetAttribute("generator"); List <OsmGeoResult> results = null; while (reader.Read()) { var moveToContent = reader.MoveToContent(); if (moveToContent == XmlNodeType.None || moveToContent == XmlNodeType.EndElement) { break; } if (reader.Name == "node") { if (results == null) { results = new List <OsmGeoResult>(); } var nodeResult = new NodeResult(); (nodeResult as IXmlSerializable).ReadXml(reader); results.Add(nodeResult); } else if (reader.Name == "way") { if (results == null) { results = new List <OsmGeoResult>(); } var wayResult = new WayResult(); (wayResult as IXmlSerializable).ReadXml(reader); results.Add(wayResult); } else if (reader.Name == "relation") { if (results == null) { results = new List <OsmGeoResult>(); } var relationResult = new RelationResult(); (relationResult as IXmlSerializable).ReadXml(reader); results.Add(relationResult); } else { if (results == null) { results = new List <OsmGeoResult>(); } return; } } if (results != null) { this.Results = results.ToArray(); } }
/// <summary> /// A helper function /// </summary> /// <param name="ndRoot"></param> /// <param name="nNodeNumber"></param> /// <param name="ndNodeParent"></param> /// <returns></returns> static NodeResult FindNodeRecursive(Node ndRoot, int nNodeNumber, Node ndNodeParent) { nCurrentNodeNumber++; if (nCurrentNodeNumber == nNodeNumber) { NodeResult rslFoundResult = new NodeResult(); rslFoundResult.ndNode = ndRoot; rslFoundResult.ndNodeParent = ndNodeParent; return(rslFoundResult); } if (ndRoot is FunctionNode) { FunctionNode fndNode = (FunctionNode)ndRoot; for (int nSonNum = 0; nSonNum != fndNode.m_arrSons.Length; nSonNum++) { NodeResult rslFoundResult = FindNodeRecursive(fndNode.m_arrSons[nSonNum], nNodeNumber, fndNode); if (rslFoundResult != null) { return(rslFoundResult); } } } return(null); }
public ActionResult Search(String query) { Directory directory = FSDirectory.Open(new System.IO.DirectoryInfo(Server.MapPath("~/Data/Index"))); IndexSearcher searcher = new IndexSearcher(directory, true); Analyzer analyzer = new StandardAnalyzer(Version.LUCENE_29); MultiFieldQueryParser queryParser = new MultiFieldQueryParser( Version.LUCENE_29, new String[] { "Name", "Content" }, analyzer ); ScoreDoc[] scoreDocs = searcher.Search(queryParser.Parse(query), 10).scoreDocs; List <ISearchResult> results = new List <ISearchResult>(); foreach (ScoreDoc doc in scoreDocs) { ISearchResult result; Document document = searcher.Doc(doc.doc); String type = document.Get("Type").ToLower(); switch (type) { case "node": Node node = new Node(); node.Id = Convert.ToInt32(document.Get("ID")); node.Name = document.Get("Name"); node.CourseId = Convert.ToInt32(document.Get("CourseID")); node.IsFolder = Convert.ToBoolean(document.Get("isFolder")); result = new NodeResult(node, document.Get("Content")); break; case "course": Course course = new Course(); course.Id = Convert.ToInt32(document.Get("ID")); course.Name = document.Get("Name"); result = new CourseResult(course); break; default: throw new Exception("Unknown result type"); } results.Add(result); } analyzer.Close(); searcher.Close(); directory.Close(); ViewData["SearchString"] = query; return(View(results)); }
public override string GetVideoUrl(VideoInfo video) { string videoUrl = string.Empty; Video clip = video.Other as Video; if (clip == null) { clip = apiSession.Get <Video>(video.VideoUrl); video.Other = clip; } else if (!string.IsNullOrEmpty(video.VideoUrl) && !video.VideoUrl.StartsWith("file://")) // todo : test with favorites! { clip = apiSession.Get <Video>(video.VideoUrl); } NodeResult result = clip.Update(); if (clip.State != NodeState.Complete) { return(videoUrl); } video.Length = clip.Duration.ToString(); Dictionary <string, string> files = new Dictionary <string, string>(); foreach (var file in clip.Files) { var uri = new OnlineVideos.MPUrlSourceFilter.HttpUrl(file.Value); uri.UserAgent = QuickTimeUserAgent; files[file.Key.ToTitleString()] = uri.ToString(); } // no files if (files.Count == 0) { return(videoUrl); } if (AlwaysPlaybackPreferredQuality) { if (files.Count > 0 && !files.TryGetValue(PreferredVideoQuality.ToTitleString(), out videoUrl)) { video.PlaybackOptions = files; videoUrl = files.Values.ToArray()[files.Count - 1]; } } else { video.PlaybackOptions = files; if (files.Count > 0 && !files.TryGetValue(PreferredVideoQuality.ToTitleString(), out videoUrl)) { videoUrl = files.Values.ToArray()[files.Count - 1]; } } return(videoUrl); }
public static AssemblyData_Out FindOutputDataAssemblyInfoFor(NodeResult nodeResult, BeeDriver beeDriver) { var scriptCompilationDataOut = beeDriver.DataFromBuildProgram.Get <ScriptCompilationData_Out>(); var outputfileForwardSlash = new NPath(nodeResult.outputfile).ToString(); var assemblyDataOut = scriptCompilationDataOut.Assemblies.FirstOrDefault(a => a.Path == outputfileForwardSlash); return(assemblyDataOut ?? throw new ArgumentException($"Unable to find entry for {outputfileForwardSlash} in dataFromBuildProgram")); }
public NodeResult Policy(NodeResult result) { if (result == NodeResult.Succes) { _count++; } return((_count >= _n) ? NodeResult.Succes : NodeResult.Failure); }
protected void Return(NodeResult result = NodeResult.Success) { this.result = result; evaluating = false; evaluated = true; end.Set(); }
public NodeResult Policy(NodeResult result) { if (result == NodeResult.Running) { _count++; } return((_count >= _n) ? NodeResult.Running : NodeResult.Succes); }
public async void Successful_Group_Run_Status_Is_Succeeded() { var groupNode = new GroupNode <TestObjectA>(); groupNode.AddChild(new SimpleTestNodeA1()); groupNode.AddChild(new SimpleTestNodeA2()); var testObject = new TestObjectA(); NodeResult result = await groupNode.ExecuteAsync(testObject); groupNode.Status.ShouldEqual(NodeRunStatus.Completed); }
public async Task Successful_Pipeline_Run_Status_Is_Succeeded() { var pipelineNode = new PipelineNode <TestObjectA>(); pipelineNode.AddChild(new SimpleTestNodeA1()); pipelineNode.AddChild(new SimpleTestNodeA2()); var testObject = new TestObjectA(); NodeResult result = await pipelineNode.ExecuteAsync(testObject); pipelineNode.Status.Should().Be(NodeRunStatus.Completed); }
public async void Failed_Group_Run_Returns_Failed_Status() { var groupNode = new GroupNode <TestObjectA>(); groupNode.AddChild(new FailingTestNodeA()); groupNode.AddChild(new FailingTestNodeA()); var testObject = new TestObjectA(); NodeResult result = await groupNode.ExecuteAsync(testObject); result.Status.ShouldEqual(NodeResultStatus.Failed); groupNode.Status.ShouldEqual(NodeRunStatus.Completed); }
public async Task Pipeline_Run_With_Initial_Failure_Returns_Failed_Status() { var pipelineNode = new PipelineNode <TestObjectA>(); pipelineNode.AddChild(new FailingTestNodeA()); pipelineNode.AddChild(new SimpleTestNodeA1()); var testObject = new TestObjectA(); NodeResult result = await pipelineNode.ExecuteAsync(testObject); result.Status.Should().Be(NodeResultStatus.Failed); pipelineNode.Status.Should().Be(NodeRunStatus.Completed); }
public async void Pipeline_Result_Should_Equal_Initial_Subject() { var pipelineNode = new PipelineNode <TestObjectA>(); pipelineNode.AddChild(new SimpleTestNodeA1()); pipelineNode.AddChild(new SimpleTestNodeA2()); var testObject = new TestObjectA(); NodeResult result = await pipelineNode.ExecuteAsync(testObject); pipelineNode.Status.ShouldEqual(NodeRunStatus.Completed); result.Subject.ShouldBeSameAs(testObject); }
public async void Pipeline_Child_Result_Count_Equals_Child_Node_Count() { var pipelineNode = new PipelineNode <TestObjectA>(); pipelineNode.AddChild(new SimpleTestNodeA1()); pipelineNode.AddChild(new SimpleTestNodeA2()); var testObject = new TestObjectA(); NodeResult result = await pipelineNode.ExecuteAsync(testObject); pipelineNode.Status.ShouldEqual(NodeRunStatus.Completed); result.ChildResults.Count().ShouldEqual(2); }
public async void Pipeline_Run_With_Failure_After_Success_Returns_Failed_Status() { var pipelineNode = new PipelineNode <TestObjectA>(); pipelineNode.AddChild(new SimpleTestNodeA1()); pipelineNode.AddChild(new FailingTestNodeA()); var testObject = new TestObjectA(); NodeResult result = await pipelineNode.ExecuteAsync(testObject); result.Status.ShouldEqual(NodeResultStatus.Failed); pipelineNode.Status.ShouldEqual(NodeRunStatus.Completed); }
public async Task Group_Run_With_Fault_Returns_Failed_Status() { var groupNode = new GroupNode <TestObjectA>(); groupNode.AddChild(new SimpleTestNodeA1()); groupNode.AddChild(new FaultingTestNodeA()); var testObject = new TestObjectA(); NodeResult result = await groupNode.ExecuteAsync(testObject); result.Status.Should().Be(NodeResultStatus.Failed); groupNode.Status.Should().Be(NodeRunStatus.Completed); }
public override Task StartIfYouCanFixProblemsInTheseMessages(NodeResult nodeResult, BeeDriver beeDriver) { var containsUpdatableCompilerMessage = ContainsUpdatableCompilerMessage(nodeResult, beeDriver); if (containsUpdatableCompilerMessage == CanUpdateAny.No) { return(null); } var assemblyInfo = Helpers.FindOutputDataAssemblyInfoFor(nodeResult, beeDriver); return(new UnityScriptUpdaterTask(assemblyInfo.ScriptUpdaterRsp, ProjectRoot, _scriptUpdaterProgram, nodeResult, containsUpdatableCompilerMessage == CanUpdateAny.Certainly)); }
public async void Subject_Of_Inherited_Type_Works_With_Func_Node() { var node = new FuncNode <TestObjectA>(); node.ShouldExecuteFunc = context => Task.FromResult(((TestObjectA)context.Subject).TestValueInt == 0); node.ExecutedFunc = context => { context.Subject.TestValueString = "Completed"; return(Task.FromResult(NodeResultStatus.Succeeded)); }; var testObject = new TestObjectASub(); NodeResult result = await node.ExecuteAsync(testObject); node.Status.ShouldEqual(NodeRunStatus.Completed); result.Status.ShouldEqual(NodeResultStatus.Succeeded); result.GetSubjectAs <TestObjectA>().TestValueString.ShouldEqual("Completed"); }
public NodeStep(NodeResult result, Slot slot) { Result = result; Slot = slot; }
public NodeStep(NodeResult result) { Result = result; }