public override void AddEdge(Node src, Node dest)
{
src.Outgoing.Add(dest);
dest.Incoming.Add(src);
_states.Clear();
SortedNodes.Clear();
try
{
for (var i = 0; i < Nodes.Count; i++)
{
TopoSort(Nodes[i]);
}
}
catch
{
src.Outgoing.RemoveAt(src.Outgoing.Count - 1);
dest.Incoming.RemoveAt(dest.Incoming.Count - 1);
throw;
}
SortedNodes.Reverse();
for (int i = 0; i < SortedNodes.Count; i++)
{
SortedNodes[i].Index = i;
}
}
protected BaseApproximation(SerializationInfo info, StreamingContext context)
{
_nodes = (SortedNodes)info.GetValue("Nodes", typeof(SortedNodes));
_baseFunction = (Function)info.GetValue("Function", typeof(Function));
_basePoints = (Point2D[])info.GetValue("Points", typeof(Point2D[]));
_amountPoints = info.GetInt32("AmountPoints");
}
public BaseApproximation(IEnumerable <Point2D> points)
{
_baseFunction = new Function();
_basePoints = points.ToArray();
_nodes = _basePoints.Select(p => new Node(p.X)).ToList();
_amountPoints = _nodes.Count;
}
public BaseApproximation(double startPoints, double endPoints, int countPoints, Function baseFunction)
{
_baseFunction = baseFunction;
_basePoints = GetBasePoints(startPoints, endPoints, countPoints, _baseFunction);
_nodes = _basePoints.Select(p => new Node(p.X)).ToList();
_amountPoints = _nodes.Count;
}
public BaseApproximation(SortedNodes nodes, Function baseFunction)
{
_nodes = nodes;
_baseFunction = baseFunction;
_basePoints = GetBasePoints(_nodes, _baseFunction);
_amountPoints = _nodes.Count;
}
private Point2D[] GetBasePoints(SortedNodes nodes, Function function)
{
Point2D[] points = new Point2D[nodes.Count];
for (int i = 0; i < points.Length; i++)
{
points[i] = new Point2D(nodes[i], function.Invoke(nodes[i]));
}
return(points);
}
private void TopoSort(Node cur)
{
if (_states.TryGetValue(cur, out var b))
{
if (!b)
{
throw new InvalidOperationException("A cycle has been encountered");
}
return;
}
_states[cur] = false;
for (var i = 0; i < cur.Outgoing.Count; i++)
{
TopoSort(cur.Outgoing[i]);
}
_states[cur] = true;
SortedNodes.Add(cur);
}
public void ValidatePrivateNodeAddresses()
{
var ipAddressToNode = new Dictionary <IPAddress, NodeDefinition>();
if (string.IsNullOrEmpty(Network.NodesSubnet))
{
throw new HiveDefinitionException($"The [{nameof(HiveDefinition)}.{nameof(HiveDefinition.Network)}.{nameof(NetworkOptions.NodesSubnet)}] property is required.");
}
if (!NetworkCidr.TryParse(Network.NodesSubnet, out var nodesSubnet))
{
throw new HiveDefinitionException($"The [{nameof(HiveDefinition)}.{nameof(HiveDefinition.Network)}.{nameof(NetworkOptions.NodesSubnet)}={Network.NodesSubnet}] property is not valid.");
}
foreach (var node in SortedNodes.OrderBy(n => n.Name))
{
if (string.IsNullOrEmpty(node.PrivateAddress))
{
throw new HiveDefinitionException($"Node [{node.Name}] has not been assigned a private IP address.");
}
if (!IPAddress.TryParse(node.PrivateAddress, out var address))
{
throw new HiveDefinitionException($"Node [{node.Name}] has invalid private IP address [{node.PrivateAddress}].");
}
if (address == IPAddress.Any)
{
throw new HiveDefinitionException($"Node [{node.Name}] has not been assigned a private IP address.");
}
if (ipAddressToNode.TryGetValue(address, out var conflictingNode))
{
throw new HiveDefinitionException($"Nodes [{conflictingNode.Name}] and [{node.Name}] have the same IP address [{address}].");
}
ipAddressToNode.Add(address, node);
}
}
IEnumerator IEnumerable.GetEnumerator()
{
return(SortedNodes.GetEnumerator());
}
public IEnumerator <INode> GetEnumerator()
{
return(SortedNodes.GetEnumerator());
}
public override void AddEdge(Node src, Node dest)
{
for (; SortedNodes.Count < Nodes.Count;)
{
SortedNodes.Add(Nodes[SortedNodes.Count]);
}
if (src.Index < dest.Index)
{
src.Outgoing.Add(dest);
dest.Incoming.Add(src);
return;
}
_deltaPlus.Clear();
Dfs(dest, _deltaPlus, n => n.Outgoing, dest.Index, src.Index);
_deltaMinus.Clear();
Dfs(src, _deltaMinus, n => n.Incoming, dest.Index, src.Index);
_deltaPlusList.Clear();
_deltaPlusList.AddRange(_deltaPlus.OrderBy(node => node.Index));
_deltaPlus.IntersectWith(_deltaMinus);
if (_deltaPlus.Count > 0)
{
throw new InvalidOperationException("The edge to be added would introduce a cycle");
}
src.Outgoing.Add(dest);
dest.Incoming.Add(src);
_deltaMinusList.Clear();
_deltaMinusList.AddRange(_deltaMinus.OrderBy(node => node.Index));
_merged.Clear();
int f = 0, s = 0;
while (f < _deltaPlusList.Count && s < _deltaMinusList.Count)
{
if (_deltaPlusList[f].Index < _deltaMinusList[s].Index)
{
_merged.Add(_deltaPlusList[f].Index);
f++;
}
else
{
_merged.Add(_deltaMinusList[s].Index);
s++;
}
}
for (; f < _deltaPlusList.Count; f++)
{
_merged.Add(_deltaPlusList[f].Index);
}
for (; s < _deltaMinusList.Count; s++)
{
_merged.Add(_deltaMinusList[s].Index);
}
var cEntry = 0;
for (int q = 0; q < _merged.Count; q++)
{
var cNode = cEntry < _deltaMinusList.Count ? _deltaMinusList[cEntry] : _deltaPlusList[cEntry - _deltaMinusList.Count];
cEntry++;
SortedNodes[_merged[q]] = cNode;
}
for (int q = 0; q < _merged.Count; q++)
{
SortedNodes[_merged[q]].Index = _merged[q];
}
}
/// <summary>
/// Returns a dictionary mapping hive host group names to the list of node
/// definitions specifying the nodes within each group. The group name keys
/// are case insenstive and the groups returned will include built-in groups
/// like <b>all</b>, <b>swarm</b>, <b>managers</b>, <b>worker</b>, <b>pets</b>,
/// etc. in addition to any explicit groups specified by <see cref="NodeDefinition.HostGroups"/>.
/// </summary>
/// <param name="excludeAllGroup">Optionally exclude the built-in <b>all</b> group from the results.</param>
/// <returns></returns>
public Dictionary <string, List <NodeDefinition> > GetHostGroups(bool excludeAllGroup = false)
{
var groups = new Dictionary <string, List <NodeDefinition> >(StringComparer.InvariantCultureIgnoreCase);
// Add explicit group assignments. Note that we're going to ignore
// any explicit assignments to built-in groups to avoid having nodes
// appear multiple times in the same group.
foreach (var node in this.Nodes)
{
foreach (var group in node.HostGroups)
{
if (HiveHostGroups.BuiltIn.Contains(group))
{
continue; // Ignore explicit built-in group assignments.
}
if (!groups.TryGetValue(group, out var groupAssignments))
{
groupAssignments = new List <NodeDefinition>();
groups.Add(group, groupAssignments);
}
groupAssignments.Add(node);
}
}
// Add built-in group assignments. Note that we're going to take care
// to ensure that only one instance of a node will be added to any
// given group. This could happen if the user explicitly specified
// that a node as a member of a built-in group (which should probably
// be detected as an error).
var members = new List <NodeDefinition>();
// [all] group
if (!excludeAllGroup)
{
members.Clear();
foreach (var node in SortedNodes)
{
members.Add(node);
}
groups.Add(HiveHostGroups.All, members);
}
// [swarm] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.InSwarm))
{
members.Add(node);
}
groups.Add(HiveHostGroups.Swarm, members);
// [managers] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.IsManager))
{
members.Add(node);
}
groups.Add(HiveHostGroups.Managers, members);
// [workers] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.IsWorker))
{
members.Add(node);
}
groups.Add(HiveHostGroups.Workers, members);
// [pets] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.IsPet))
{
members.Add(node);
}
groups.Add(HiveHostGroups.Pets, members);
// [ceph] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.Labels.CephMON || n.Labels.CephMDS || n.Labels.CephOSD))
{
members.Add(node);
}
groups.Add(HiveHostGroups.Ceph, members);
// [ceph-mon] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.Labels.CephMON))
{
members.Add(node);
}
groups.Add(HiveHostGroups.CephMON, members);
// [ceph-mds] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.Labels.CephMDS))
{
members.Add(node);
}
groups.Add(HiveHostGroups.CephMDS, members);
// [ceph-osd] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.Labels.CephOSD))
{
members.Add(node);
}
groups.Add(HiveHostGroups.CephOSD, members);
// [hivemq] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.Labels.HiveMQ || n.Labels.HiveMQManager))
{
members.Add(node);
}
groups.Add(HiveHostGroups.HiveMQ, members);
// [hivemq-managers] group
members.Clear();
foreach (var node in SortedNodes.Where(n => n.Labels.HiveMQManager))
{
members.Add(node);
}
groups.Add(HiveHostGroups.HiveMQManagers, members);
return(groups);
}
