private static int Deploy(object script,
IOperationTracker operationTracker,
IReadOnlyList <string> nodeAddresses,
IEnumerable <string> arguments,
TimeSpan connectTimeout)
{
var method = FindDeployMethod(script);
if (nodeAddresses.Count == 1)
{
return(DeployTo(script, method, operationTracker, nodeAddresses[0], arguments, connectTimeout));
}
var tracker = new NodeTracker(operationTracker, nodeAddresses);
Parallel.ForEach(nodeAddresses, nodeAddress =>
{
var nodeTracker = tracker.Get(nodeAddress);
try
{
DeployTo(script, method, nodeTracker, nodeAddress, arguments, connectTimeout);
nodeTracker.Success();
}
catch (Exception e)
{
// We want keep track of failures on individual nodes
// and only rethrow those exceptions after everything's done.
nodeTracker.Failed(e);
}
});
tracker.ThrowOnFailure();
return(0);
}
public void Add_Should_Add_Node_To_Collection()
{
var tracker = new NodeTracker();
var node = new GraphNode("name");
tracker.AddNode(node);
Assert.AreEqual(tracker.Nodes.Count(), 1);
Assert.AreSame(tracker.Nodes.First(), node);
}
public void GetNodeByTag_With_Invalid_Tag_Should_Return_Null() {
var tracker = new NodeTracker();
var node1 = new GraphNode("name1") { Tag = 1 };
tracker.AddNode(node1);
Assert.AreEqual(tracker.Nodes.Count(), 1);
Assert.IsNull(tracker.GetNodeByTag(2));
}
public async Task Should_add_the_first_node()
{
var manager = new NodeTracker <SimpleValue>(1000, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(60), () => DateTime.UtcNow);
Bucket <SimpleValue> bucket = new Bucket <SimpleValue>(manager);
var valueNode = new BucketNode <SimpleValue>(await SimpleValueFactory.Healthy("Hello"));
bucket.Push(valueNode);
}
public async Task Should_add_the_first_node()
{
var settings = new CacheSettings(1000, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(60));
var manager = new NodeTracker <SimpleValue>(settings);
var bucket = new Bucket <SimpleValue>(manager);
var valueNode = new BucketNode <SimpleValue>(await SimpleValueFactory.Healthy("Hello"));
bucket.Push(valueNode);
}
public NodeTrackerTests()
{
store = A.Fake <ICsDataStore>();
time = A.Fake <ITimeProvider>();
mediator = A.Fake <IMediator>();
config = new CommunicationsServerConfiguration {
CommunicationsTimeout = Timeout
};
A.CallTo(() => time.Now()).Returns(CurrentDate);
tracker = new NodeTracker(store, time, mediator, config);
}
public void GetNodeByTag_Should_Retrieve_Node_By_Tag() {
var tracker = new NodeTracker();
var node1 = new GraphNode("name1") {Tag = 1};
var node2 = new GraphNode("name2") {Tag = 2};
tracker.AddNode(node1);
tracker.AddNode(node2);
Assert.AreEqual(tracker.Nodes.Count(), 2);
Assert.AreSame(tracker.GetNodeByTag(1), node1);
Assert.AreSame(tracker.GetNodeByTag(2), node2);
}
public void GetNodeByName_Should_Retrieve_Node_By_Name()
{
var tracker = new NodeTracker();
var node1 = new GraphNode("name1");
var node2 = new GraphNode("name2");
tracker.AddNode(node1);
tracker.AddNode(node2);
Assert.AreEqual(tracker.Nodes.Count(), 2);
Assert.AreSame(tracker.GetNodeByName("name1"), node1);
Assert.AreSame(tracker.GetNodeByName("name2"), node2);
}
private static NodeTracker GetNodeTracker(this Node node)
{
var tracker = node.GetNodeOrNull <NodeTracker>(NodeTracker.DefaultName);
if (tracker == null)
{
tracker = new NodeTracker
{
Name = NodeTracker.DefaultName
};
node.AddChild(tracker);
}
return(tracker);
}
public NodeTracker TrackNode(AstNode node)
{
if (curTrack != null)
{
throw new InvalidOperationException("Previous tracker must be freed");
}
astnode = node;
if (node != null)
{
astnode.FullRequest = text;
astnode.Position = index;
astnode.Length = 0;
}
return(curTrack = new NodeTracker(this));
}
public async Task Should_accept_a_completed_node()
{
var tracker = new NodeTracker <SimpleValue>(1000, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(60), () => DateTime.UtcNow);
var observer = new NodeObserver();
tracker.Connect(observer);
var pendingValue = new PendingValue <string, SimpleValue>("Hello", SimpleValueFactory.Healthy);
var nodeValueFactory = new NodeValueFactory <SimpleValue>(pendingValue, 100);
var node = new FactoryNode <SimpleValue>(nodeValueFactory);
tracker.Add(nodeValueFactory);
var value = await node.Value;
var observedNode = await observer.Value;
Assert.That(observedNode, Is.InstanceOf <BucketNode <SimpleValue> >());
}
public NodeTracker TrackNode(ASTNode node)
{
if (curTrack != null)
throw new InvalidOperationException("Previous tracker must be freed");
astnode = node;
if (node != null)
{
astnode.FullRequest = text;
astnode.Position = index;
astnode.Length = 0;
}
return (curTrack = new NodeTracker(this));
}
private void UntrackNode()
{
curTrack = null;
astnode = null;
}
void SpawnPlayer()
{
if (playerPrefab == null) {
Debug.LogWarning("No player prefab assigned to MazeController!");
return;
}
if (spawnPlayer) {
GameObject spawnedPlayer = Instantiate(playerPrefab, startNode.transform.position, Quaternion.identity) as GameObject;
player = spawnedPlayer.GetComponent<NodeTracker>();
player.closestNode = startNode;
playerNode = startNode;
}
}
private void Start()
{
tracker = GetComponentInParent <NodeTracker>();
}
void UntrackNode()
{
curTrack = null;
astnode = null;
}
// Update is called once per frame
void Update()
{
switch (state)
{
default:
case State.idle:
break;
case State.gathering:
if (!moving && !moveai.arrived)
{
if (goldDest == null)
{
NodeTracker t = sys.GetComponent <NodeTracker>();
List <GameObject> goldNodes = t.goldNodes;
goldDest = NodeTracker.closestObject(goldNodes, this.transform);
goldnode = goldDest.GetComponent <GoldNode>();
}
Vector3 goldGather = goldnode.gatherPoint;
moveTo(goldGather);
}
if (moveai.arrived)
{
moving = false;
if (!Mrunning)
{
StartCoroutine(mining());
}
if (worker.carrying >= worker.capacity)
{
moveai.arrived = false;
state = State.depositing;
}
}
break;
case State.depositing:
if (!moving && !moveai.arrived)
{
moveTo(depotDest);
}
if (moveai.arrived)
{
moving = false;
if (!Drunning)
{
StartCoroutine(depositing());
}
}
if (worker.carrying == 0)
{
moveai.arrived = false;
state = State.gathering;
}
break;
}
}
private void LoadedNetworkData_finishedLoadingData(LoadingNetworkDataArgs args, object sender)
{
nodes = args.HDP2.data;
// preprocess all GP nodes into childs of BR nodes
foreach (var GP in nodes)
{
if (GP.deviceType == GENERAL_PURPOSE)
{
foreach (var BRN in GP.connections)
{
var BR = nodes[BRN];
if (BR.deviceType == BROADBAND_ROUTER)
{
if (!BR.connections.Contains(GP.id))
{
BR.connections = BR.connections.Append(GP.id).ToArray();
}
}
}
GP.connections = new int[0];
}
}
Random.InitState(42);
// places router stuff first!// it also places all nodes in some default position.
foreach (var l1n in nodes)
{
//string name;
var go = Instantiate(nodePrefab.gameObject);
if (l1n.deviceType == GENERAL_PURPOSE)
{
go.transform.SetParent(PCs);
go.AddComponent <PCNodeTracker>();
}
if (l1n.deviceType == BROADBAND_ROUTER)
{
go.transform.SetParent(Routers);
}
var octahedron = go.GetComponent <Octahedron>();
go.GetComponent <MeshRenderer>().material = nodeMat;
octahedron.radius = 1;
//what to do with octet 0?
//var nodePosition = getLocationFromOctet(l1n.octets) * 2;
var nodePosition = getFromRandomSphere();
go.transform.localPosition = nodePosition;
// set text position
var textObj = Instantiate(textPrefab, go.transform);
textObj.transform.localPosition = new Vector3(0, 1, 0);
var tmp = textObj.GetComponent <TextMeshPro>();
tmp.SetText($" {l1n.deviceType} | {l1n.octets[0]}.{l1n.octets[1]}.{l1n.octets[2]}.{l1n.octets[3]}");
// set to follow the camera's movement
var script = textObj.GetComponent <FaceCamera>();
script.cameraToLookAt = playerCamera;
l1n.AssignedGameObject = go;
}
// finally create all the connections
//return;
foreach (var l1n in nodes)
{
int index = 0;
var nodePosition = l1n.AssignedGameObject.transform.position;
if (l1n.connections.Length > 0)
{
var rtNode = l1n.AssignedGameObject.AddComponent <RouterNodeTracker>();
LineRenderer hiddenLr = l1n.AssignedGameObject.AddComponent <LineRenderer>();
hiddenLr.enabled = false;
hiddenLr.sharedMaterial = searchLineMat;
NodeTracker hiddenNt = l1n.AssignedGameObject.AddComponent <NodeTracker>();
hiddenNt.HostNode = l1n.AssignedGameObject;
hiddenNt.ConnectionNode = CenterTransform.gameObject; // TODO: update this to whatever you want to pivot on search.
// skip generals
//if (l1n.deviceType == GENERAL_PURPOSE) continue;
// All l2n should be GP now.
foreach (var l2n in l1n.connections)
{
var go2 = Instantiate(linePrefab.gameObject, l1n.AssignedGameObject.transform);
HostNode2 adjNode = nodes[l2n];
//go2.GetComponent<MeshRenderer>().material = Lvl2_Host_Mat;
LineRenderer lr = go2.GetComponent <LineRenderer>();
// added node tracker to maintain the position of the nodes.
NodeTracker nt = go2.AddComponent <NodeTracker>();
nt.HostNode = l1n.AssignedGameObject;
nt.ConnectionNode = nodes[l2n].AssignedGameObject;
// both are broadband types
if (adjNode.deviceType == BROADBAND_ROUTER && l1n.deviceType == BROADBAND_ROUTER)
{
lr.sharedMaterial = lineMat2;
rtNode.connectionLines.Add(nt);
}
// a pc node is adjacent, assign it as child.
if (adjNode.deviceType == GENERAL_PURPOSE && l1n.deviceType == BROADBAND_ROUTER)
{
// Since I'm a PC node, I'm going to have this system override stuff.
var pcnt = adjNode.AssignedGameObject.GetComponent <PCNodeTracker>();
pcnt.HostNode = l1n;
rtNode.childrenNodes.Add(adjNode);
pcnt.index = index;
nt.childIdnex = index;
rtNode.childrenLines.Add(nt);
}
index++;
}
}
}
}
void Awake()
{
nodeTracker = GetComponent<NodeTracker>();
motor = GetComponent<Motor>();
currentBehavior = AIState.idle;
hasLineOfSight = false;
lastKnownPlayerLocation = null;
freezeAI = false;
matController = GetComponent<AgentMaterialController>();
}
