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;
}
protected void Return(NodeResult result = NodeResult.Success)
{
this.result = result;
evaluating = false;
evaluated = true;
end.Set();
}
public NodeStep(NodeResult result)
{
Result = result;
}
