private XamDataTree CreateXamDataTree() { XamDataTree MyTree = new XamDataTree(); ExperimentNode experiment1 = new ExperimentNode("Experiment1"); CompoundsGroupNode compoundsGroup = new CompoundsGroupNode("CompoundsGroup1"); ClusterNode cluster = new ClusterNode("Cluster1"); cluster.AddChild(new ExperimentNode("Experiment2")); ExperimentNode experiment3 = new ExperimentNode("Experiment3"); experiment3.HoverText = "My experiment"; experiment3.AddChild(new CompoundsGroupNode("CompoundsGroup2")); experiment3.AddChild(new CompoundsGroupNode("CompoundsGroup3")); cluster.AddChild(experiment3); experiment1.AddChild(compoundsGroup); experiment1.AddChild(cluster); MyTree.ItemsSource = new ObservableCollection <IDataNode> { experiment1 }; NodeLayout mylayout = new NodeLayout(); mylayout.Key = "NodeLayout1"; mylayout.TargetTypeName = "IDataNode"; mylayout.DisplayMemberPath = "Name"; MyTree.GlobalNodeLayouts.Add(mylayout); return(MyTree); }
/// <summary> /// Return an execution back into the domain. /// </summary> /// <param name="contextID">The context ID of the execution.</param> /// <param name="nodeID">The node ID where the execution was run.</param> /// <param name="result">The serialized result of the excution.</param> public void ReturnExecution(string contextID, ClusterNode node, byte[] result) { SerializationEngine serializer = new SerializationEngine (); PrestoResult resultObj = (PrestoResult)serializer.Deserialize(result); resultObj.ExecutionNode = node; Cluster.ReturnExecution(contextID, resultObj); }
public Task <int> UpdateClusterNodeAsync(ClusterNode entity) { serviceDbContext.Entry(entity).State = EntityState.Modified; return(serviceDbContext.SaveChangesAsync()); }
internal void Resume(int suspended) { Assert.IsNull(members[suspended]); members[suspended] = new ClusterNode(cfg, cfg.Members[suspended], new Address(basePort + suspended), GetAddressOf); members[suspended].Attachment = attachments[suspended]; }
//public IEnumerator agglomerate() public void agglomerate(ProgressUpdateDelegate progFunc) { if (items.Count <= 1) { clusters = new ClusterNode[0]; return; //yield break; } clusters = new ClusterNode[items.Count * 2 - 1]; for (int i = 0; i < items.Count; i++) { clusters[i] = new ClusterNode(items[i], i); } float[][] distances = new float[items.Count * 2 - 1][]; for (int i = 0; i < distances.Length; i++) { distances[i] = new float[items.Count * 2 - 1]; } int numClussters = items.Count; List <ClusterNode> unclustered = new List <ClusterNode>(); for (int i = 0; i < numClussters; i++) { unclustered.Add(clusters[i]); for (int j = 0; j < numClussters; j++) { distances[i][j] = euclidean_distance(clusters[i].centroid, clusters[j].centroid); } } int height = 0; System.Timers.Timer timer = new System.Timers.Timer(); timer.Start(); while (unclustered.Count > 1) { height++; //find closest pair float min = 10e15f; int a, b; a = b = -1; for (int i = 0; i < unclustered.Count; i++) { for (int j = 0; j < unclustered.Count; j++) { if (i != j) { int idxa = unclustered[i].idx; int idxb = unclustered[j].idx; float newDist = distances[idxa][idxb]; if (newDist < min) { min = newDist; a = idxa; b = idxb; } } } } //make a new cluster with pair as children set merge height numClussters++; ClusterNode cn = new ClusterNode(clusters[a], clusters[b], numClussters - 1, height, min, clusters); //remove children from unclustered unclustered.Remove(clusters[a]); unclustered.Remove(clusters[b]); //add new cluster to unclustered clusters[numClussters - 1] = cn; unclustered.Add(cn); //update new clusteres distance for (int i = 0; i < numClussters - 1; i++) { distances[numClussters - 1][i] = euclidean_distance(clusters[numClussters - 1].centroid, clusters[i].centroid); distances[i][numClussters - 1] = euclidean_distance(clusters[i].centroid, clusters[numClussters - 1].centroid); } //if (timer.Interval > .2f) //{ // yield return null; // timer.Start(); //} if (progFunc != null) { progFunc("Creating clusters:", ((float)(items.Count - unclustered.Count)) / items.Count); } } }
private static void InitClusterNode(ClusterNode node) { node.RootActors = new List<IActorRef>(); foreach (var role in node.Roles) { IActorRef rootActor; switch (role) { case "table": rootActor = node.Context.System.ActorOf(Props.Create( () => new Table("TestTable", node.Context.ClusterActorDiscovery, typeof(IncrementalIntegerIdGenerator), null))); break; case "container": rootActor = node.Context.System.ActorOf(Props.Create( () => new TableContainer("TestTable", node.Context.ClusterActorDiscovery, typeof(CommonActorFactory<TestActor>), null, null))); break; default: throw new InvalidOperationException("Invalid role: " + role); } node.RootActors.Add(rootActor); } }
public void constructClustersOfBrokenGateways() { foreach (var gateway in _dataStorage.gateways) { foreach (var inbound in gateway.inbound_gateways) { var clusterName = inbound.Key; foreach (var server in inbound.Value) { if (!_dataStorage.foundServers.Contains(server.connection.name)) { var clusterToAddTo = _dataStorage.errorClusters.Where(c => c.name == clusterName) .Select(c => c).FirstOrDefault(); var node = new ServerNode { server_id = server.connection.name, server_name = "Unknown name", ntv_error = true, clients = new ConcurrentBag <ConnectionNode>() }; if (clusterToAddTo is null) { var newCluster = new ClusterNode { name = clusterName, servers = new ConcurrentBag <ServerNode>() }; newCluster.servers.Add(node); _dataStorage.errorClusters.Add(newCluster); } else { clusterToAddTo.servers.Add(node); } _dataStorage.processedServers.Add(node); _dataStorage.foundServers.Add(server.connection.name); } } } foreach (var outbound in gateway.outbound_gateways) { var clusterName = outbound.Key; if (!_dataStorage.foundServers.Contains(outbound.Value.connection.name)) { var clusterToAddTo = _dataStorage.errorClusters.Where(c => c.name == clusterName).Select(c => c) .FirstOrDefault(); var node = new ServerNode { server_id = outbound.Value.connection.name, server_name = "Unknown name", ntv_error = true, clients = new ConcurrentBag <ConnectionNode>() }; if (clusterToAddTo is null) { var newCluster = new ClusterNode { name = clusterName, servers = new ConcurrentBag <ServerNode>() }; newCluster.servers.Add(node); _dataStorage.errorClusters.Add(newCluster); } else { clusterToAddTo.servers.Add(node); } _dataStorage.processedServers.Add(node); _dataStorage.foundServers.Add(outbound.Value.connection.name); } } foreach (var cluster in _dataStorage.processedClusters) { if (!cluster.ContainsServer(gateway.server_id)) { continue; } if (gateway.name is null) { continue; } cluster.name = gateway.name; } } foreach (var cluster in _dataStorage.errorClusters) { _dataStorage.processedClusters.Add(cluster); } }
public async Task <bool> UpdateClusterNode(ClusterNode node) { return(await _db.HashSetAsync(_clusterOptions.ClusterID, node.Address, JsonConvert.SerializeObject(node))); }
public virtual ClusterNode <T> Merge(ClusterNode <T> cont) { return(Merge(cont.Content)); }
public virtual bool Contains(ClusterNode <T> cont) { return(Contains(cont.Content)); }
public virtual float BreakDraw(ClusterNode <T> cont) { return(BreakDraw(cont.Content)); }
public bool agglomerate(ProgressUpdateCancelableDelegate progFunc) { wasCanceled = true; if (progFunc != null) { wasCanceled = progFunc("Filling Priority Queue:", 0); } if (items.Count <= 1) { clusters = new ClusterNode[0]; return(false); //yield break; } clusters = new ClusterNode[items.Count * 2 - 1]; for (int i = 0; i < items.Count; i++) { clusters[i] = new ClusterNode(items[i], i); } int numClussters = items.Count; List <ClusterNode> unclustered = new List <ClusterNode>(); for (int i = 0; i < numClussters; i++) { clusters[i].isUnclustered = true; unclustered.Add(clusters[i]); } int height = 0; System.Diagnostics.Stopwatch timer = new System.Diagnostics.Stopwatch(); timer.Start(); float largestDistInQ = 0; long usedMemory = GC.GetTotalMemory(false) / 1000000; PriorityQueue <float, ClusterDistance> pq = new PriorityQueue <float, ClusterDistance>(); //largestDistInQ = _RefillPriorityQWithSome(pq, unclustered, clusters /*,null,null*/); int numRefills = 0; while (unclustered.Count > 1) { int numToFindClosetPair = 0; height++; //find closest pair if (pq.Count == 0) { numRefills++; usedMemory = GC.GetTotalMemory(false) / 1000000; if (progFunc != null) { wasCanceled = progFunc("Refilling Q:" + ((float)(items.Count - unclustered.Count) * 100) / items.Count + " unclustered:" + unclustered.Count + " inQ:" + pq.Count + " usedMem:" + usedMemory, ((float)(items.Count - unclustered.Count)) / items.Count); } largestDistInQ = _RefillPriorityQWithSome(pq, unclustered, clusters, progFunc); if (pq.Count == 0) { break; } } KeyValuePair <float, ClusterDistance> closestPair = pq.Dequeue(); // should only consider unclustered pairs. It is more effecient to discard nodes that have already been clustered as they are popped off the Q // than to try to remove them from the Q when they have been clustered. while (!closestPair.Value.a.isUnclustered || !closestPair.Value.b.isUnclustered) { if (pq.Count == 0) { numRefills++; usedMemory = GC.GetTotalMemory(false) / 1000000; if (progFunc != null) { wasCanceled = progFunc("Creating clusters:" + ((float)(items.Count - unclustered.Count) * 100) / items.Count + " unclustered:" + unclustered.Count + " inQ:" + pq.Count + " usedMem:" + usedMemory, ((float)(items.Count - unclustered.Count)) / items.Count); } largestDistInQ = _RefillPriorityQWithSome(pq, unclustered, clusters, progFunc); if (pq.Count == 0) { break; } } closestPair = pq.Dequeue(); numToFindClosetPair++; } //make a new cluster with pair as children set merge height numClussters++; ClusterNode cn = new ClusterNode(closestPair.Value.a, closestPair.Value.b, numClussters - 1, height, closestPair.Key, clusters); //remove children from unclustered unclustered.Remove(closestPair.Value.a); unclustered.Remove(closestPair.Value.b); //We NEED TO REMOVE ALL DISTANCE PAIRS THAT INVOLVE A AND B FROM PRIORITY Q. However searching for all these pairs and removing is very slow. // Instead we will leave them in the Queue and flag the clusters as isUnclustered = false and discard them as they are popped from the Q which is O(1) operation. closestPair.Value.a.isUnclustered = false; closestPair.Value.b.isUnclustered = false; //add new cluster to unclustered int newIdx = numClussters - 1; if (newIdx == clusters.Length) { Debug.LogError("how did this happen"); } clusters[newIdx] = cn; unclustered.Add(cn); cn.isUnclustered = true; //update new clusteres distance for (int i = 0; i < unclustered.Count - 1; i++) { float dist = euclidean_distance(cn.centroid, unclustered[i].centroid); if (dist < largestDistInQ) //avoid cluttering Qwith { pq.Add(new KeyValuePair <float, ClusterDistance>(dist, new ClusterDistance(cn, unclustered[i]))); } } //if (timer.Interval > .2f) //{ // yield return null; // timer.Start(); //} if (wasCanceled) { break; } usedMemory = GC.GetTotalMemory(false) / 1000000; if (progFunc != null) { wasCanceled = progFunc("Creating clusters:" + ((float)(items.Count - unclustered.Count) * 100) / items.Count + " unclustered:" + unclustered.Count + " inQ:" + pq.Count + " usedMem:" + usedMemory, ((float)(items.Count - unclustered.Count)) / items.Count); } } if (progFunc != null) { wasCanceled = progFunc("Finished clustering:", 100); } //Debug.Log("Time " + timer.Elapsed); if (wasCanceled) { return(false); } else { return(true); } }
public ClusterDistance(ClusterNode aa, ClusterNode bb) { a = aa; b = bb; }
/// <summary> /// Deliver the message sent from an outside node. /// </summary> /// <param name="payload">The message sent from the outside node.</param> /// <param name="sender"> The node object of the sending Node.</param> public void DeliverMessage(string payload, ClusterNode sender) { Cluster.DeliverMessage(payload, sender); }
private static void InitClusterNode(ClusterNode node) { node.RootActors = new List<IActorRef>(); foreach (var role in node.Roles) { IActorRef rootActor; switch (role) { case "producer": rootActor = node.Context.System.ActorOf(Props.Create(() => new EchoProducerActor(node.Context))); break; case "consumer": rootActor = node.Context.System.ActorOf(Props.Create(() => new EchoConsumerActor(node.Context))); break; default: throw new InvalidOperationException("Invalid role: " + role); } node.RootActors.Add(rootActor); } }
public async Task <bool> RemoveClusterNode(ClusterNode node) { return(await _db.HashDeleteAsync(_clusterOptions.ClusterID, node.Address)); }
public virtual int MergeSize(ClusterNode <T> cont) { return(MergeSize(cont.Content)); }
public virtual int Distance(ClusterNode <T> cont) { return(Distance(cont.Content)); }
static void Main(string[] args) { while (localPort < 1 || remotePort < 1) { Console.Write("Local port : "); localPort = Convert.ToInt32(Console.ReadLine()); Console.Write("Remote port : "); remotePort = Convert.ToInt32(Console.ReadLine()); } n = new ClusterNode("127.0.0.1", remotePort, localPort, ClusterHealthy, ClusterUnhealthy, MessageReceived, false); bool runForever = true; while (runForever) { Console.Write("Command [? for help]: "); string userInput = Console.ReadLine(); if (String.IsNullOrEmpty(userInput)) continue; switch (userInput) { case "?": Console.WriteLine("---"); Console.WriteLine(" q quit"); Console.WriteLine(" ? this menu"); Console.WriteLine(" cls clear screen"); Console.WriteLine(" send send message to peer"); Console.WriteLine(" sendasync send message to peer, asynchronously"); Console.WriteLine(" health display cluster health"); break; case "q": runForever = false; break; case "cls": Console.Clear(); break; case "send": Console.Write("Data: "); userInput = Console.ReadLine(); if (Send(Encoding.UTF8.GetBytes(userInput))) { Console.WriteLine("Success"); } else { Console.WriteLine("Failed"); } break; case "sendasync": Console.Write("Data: "); userInput = Console.ReadLine(); if (SendAsync(Encoding.UTF8.GetBytes(userInput))) { Console.WriteLine("Success"); } else { Console.WriteLine("Failed"); } break; case "health": Console.WriteLine("Healthy: " + n.IsHealthy()); break; } } }
private static void CreateClusterNode(Config commonConfig, int port, params string[] roles) { var config = commonConfig .WithFallback("akka.remote.helios.tcp.port = " + port) .WithFallback("akka.cluster.roles = " + "[" + string.Join(",", roles) + "]"); var system = ActorSystem.Create("BasicCluster", config); var cluster = Cluster.Get(system); var clusterNode = new ClusterNode { Context = new ClusterNodeContext { System = system, ClusterActorDiscovery = system.ActorOf(Props.Create(() => new ClusterActorDiscovery(cluster)), "cluster_actor_discovery") }, Roles = roles }; InitClusterNode(clusterNode); _clusterNodes.Add(clusterNode); }
static void Main(string[] args) { while (localPort < 1 || remotePort < 1) { Console.Write("Local port : "); localPort = Convert.ToInt32(Console.ReadLine()); Console.Write("Remote port : "); remotePort = Convert.ToInt32(Console.ReadLine()); } n = new ClusterNode("127.0.0.1", localPort, "127.0.0.1", remotePort, null, null); n.AcceptInvalidCertificates = true; n.MutuallyAuthenticate = true; n.Debug = false; n.ReadDataStream = false; n.PresharedKey = "0000000000000000"; n.MessageReceived = MessageReceived; n.StreamReceived = StreamReceived; n.ClusterHealthy = ClusterHealthy; n.ClusterUnhealthy = ClusterUnhealthy; n.Start(); bool runForever = true; while (runForever) { Console.Write("Command [? for help]: "); string userInput = Console.ReadLine(); if (String.IsNullOrEmpty(userInput)) { continue; } byte[] data = null; MemoryStream ms = null; switch (userInput) { case "?": Console.WriteLine("---"); Console.WriteLine(" q quit"); Console.WriteLine(" ? this menu"); Console.WriteLine(" cls clear screen"); Console.WriteLine(" send bytes send message to peer"); Console.WriteLine(" send bytes async send message to peer, asynchronously"); Console.WriteLine(" send stream send message to peer using a stream"); Console.WriteLine(" send stream async send message to peer using a stream, asynchronously"); Console.WriteLine(" health display cluster health"); break; case "q": runForever = false; break; case "cls": Console.Clear(); break; case "send bytes": Console.Write("Data: "); userInput = Console.ReadLine(); if (n.Send(Encoding.UTF8.GetBytes(userInput))) { Console.WriteLine("Success"); } else { Console.WriteLine("Failed"); } break; case "send bytes async": Console.Write("Data: "); userInput = Console.ReadLine(); if (n.SendAsync(Encoding.UTF8.GetBytes(userInput)).Result) { Console.WriteLine("Success"); } else { Console.WriteLine("Failed"); } break; case "send stream": Console.Write("Data: "); userInput = Console.ReadLine(); data = Encoding.UTF8.GetBytes(userInput); ms = new MemoryStream(data); if (n.Send(data.Length, ms)) { Console.WriteLine("Success"); } else { Console.WriteLine("Failed"); } break; case "send stream async": Console.Write("Data: "); userInput = Console.ReadLine(); data = Encoding.UTF8.GetBytes(userInput); ms = new MemoryStream(data); if (n.SendAsync(data.Length, ms).Result) { Console.WriteLine("Success"); } else { Console.WriteLine("Failed"); } break; case "health": Console.WriteLine("Healthy: " + n.IsHealthy); break; } } }
public void Node(string nodeAddress) { _nodes.Add(ClusterNode.Parse(nodeAddress)); }
private RedisCluster(ClusterNode[] nodes) { this.nodes = new List<ClusterNode>(nodes); }
Task IBucketInternal.Bootstrap(ClusterNode clusterNode) { throw new NotImplementedException(); }
public Task <int> InsertClusterNodeAsync(ClusterNode entity) { serviceDbContext.ClusterNode.Add(entity); return(serviceDbContext.SaveChangesAsync()); }
public Task <int> DeleteAsync(ClusterNode entity) { return(UpdateAsync(entity)); }
protected bool Equals(ClusterNode other) { return(string.Equals(ClusterTag, other.ClusterTag)); }
private async Task <List <ClusterNode> > BuildClustersAsync(List <Node> nodes, IDistanceMetric distanceMetric, ProgressData progressData) { var nodeCount = nodes .SelectMany(node => node.NeighborsByDistance.Select(neighbor => neighbor.Node.FirstLeaf.Index)) .Concat(nodes.Select(node => node.FirstLeaf.Index)) .Distinct().Count(); progressData.Reset($"Building clusters for {nodeCount} matches...", nodes.Count - 1); await Task.Run(async() => { while (nodes.Count > 1) { // This is a little verbose, but optimized for performance -- O(N) overall. Node secondNode = null; Neighbor neighborToCluster = new Neighbor() { DistanceSquared = float.MaxValue }; foreach (var node in nodes) { if (node.FirstLeaf.NeighborsByDistance.Count > 0 && node.FirstLeaf.NeighborsByDistance.First().DistanceSquared < neighborToCluster.DistanceSquared) { secondNode = node; neighborToCluster = node.FirstLeaf.NeighborsByDistance.First(); } if (node.FirstLeaf != node.SecondLeaf && node.SecondLeaf.NeighborsByDistance.Count > 0 && node.SecondLeaf.NeighborsByDistance.First().DistanceSquared < neighborToCluster.DistanceSquared) { secondNode = node; neighborToCluster = node.SecondLeaf.NeighborsByDistance.First(); } } ClusterNode clusterNode; if (secondNode == null) { var nodesLargestFirst = nodes.OrderByDescending(node => node.GetOrderedLeafNodes().Count()).Take(2).ToList(); clusterNode = new ClusterNode(nodesLargestFirst[0], nodesLargestFirst[1], double.PositiveInfinity, distanceMetric); } else { var firstNode = neighborToCluster.Node; var first = firstNode.GetHighestParent(); var second = secondNode.GetHighestParent(); clusterNode = new ClusterNode(first, second, neighborToCluster.DistanceSquared, distanceMetric); } if (clusterNode.First.FirstLeaf != clusterNode.First.SecondLeaf) { var removeNeighborsTasks = nodes.Select(node => Task.Run(() => { node.FirstLeaf.NeighborsByDistance?.RemoveAll(neighbor => neighbor.Node == clusterNode.First.SecondLeaf); if (node.FirstLeaf != node.SecondLeaf) { node.SecondLeaf.NeighborsByDistance?.RemoveAll(neighbor => neighbor.Node == clusterNode.First.SecondLeaf); } })); await Task.WhenAll(removeNeighborsTasks); } if (clusterNode.Second.FirstLeaf != clusterNode.Second.SecondLeaf) { var removeNeighborsTasks = nodes.Select(node => Task.Run(() => { node.FirstLeaf.NeighborsByDistance?.RemoveAll(neighbor => neighbor.Node == clusterNode.Second.FirstLeaf); if (node.FirstLeaf != node.SecondLeaf) { node.SecondLeaf.NeighborsByDistance?.RemoveAll(neighbor => neighbor.Node == clusterNode.Second.FirstLeaf); } })); await Task.WhenAll(removeNeighborsTasks); } nodes.Remove(clusterNode.First); nodes.Remove(clusterNode.Second); var leafNodes = new HashSet <LeafNode>(clusterNode.GetOrderedLeafNodes()); clusterNode.FirstLeaf.NeighborsByDistance.RemoveAll(neighbor => leafNodes.Contains(neighbor.Node)); clusterNode.SecondLeaf.NeighborsByDistance.RemoveAll(neighbor => leafNodes.Contains(neighbor.Node)); nodes.Add(clusterNode); progressData.Increment(); } }); progressData.Reset("Done"); return(nodes.OfType <ClusterNode>().ToList()); }