private IEnumerable <NodeDescription> GetSeedNodes(ReliabilityLevel reliabilityLevel, int primaryNodeCount, IEnumerable <NodeTypeDescription> primaryNodeTypes, bool isVmss)
{
// In add non-primary node scenario, topology.nodes is set to the new node count; targetNodeConfig.NodeStatus still contains the old node count. This will cause exceptions
// in var matchingNodeStatus = this.TargetNodeConfig.NodesStatus.First(nodeStatus => nodeStatus.NodeName.Equals(node.NodeName));
// So here originalTopology contains the original nodes which we use to calculate the seednode based on.
Dictionary <string, NodeDescription> originalTopology = new Dictionary <string, NodeDescription>();
foreach (var node in this.Topology.Nodes)
{
if (this.TargetNodeConfig.NodesStatus.Select(n => n.NodeName).Distinct().ToList().Contains(node.Key))
{
originalTopology.Add(node.Key, node.Value);
}
}
IEnumerable <NodeDescription> primaryNodeTypeNodes = originalTopology.Values
.Where(node => primaryNodeTypes.Any(primaryNodeType => primaryNodeType.Name == node.NodeTypeRef))
.Where(node =>
{
// skip nodes which are either in removed state or disabled with intent to RemoveNode
var matchingNodeStatus = this.TargetNodeConfig.NodesStatus.FirstOrDefault(nodeStatus => nodeStatus.NodeName.Equals(node.NodeName));
return(matchingNodeStatus != null ? (matchingNodeStatus.NodeState != NodeState.Removed) && (matchingNodeStatus.NodeDeactivationIntent != WrpNodeDeactivationIntent.RemoveNode) : false);
});
IEnumerable <NodeDescription> seedNodes = this.SeedNodeSelector.Select(
reliabilityLevel,
primaryNodeCount,
primaryNodeTypeNodes,
this.ClusterManifestGeneratorSettings.FDCount,
this.ClusterManifestGeneratorSettings.UDCount,
isVmss);
return(seedNodes);
}
public MessageOptions(Type messageType, ReliabilityLevel reliabilityLevel, WireTransportType transportType, ISubscriptionFilter subscriptionFilter)
{
MessageType = messageType;
ReliabilityLevel = reliabilityLevel;
TransportType = transportType;
SubscriptionFilter = subscriptionFilter;
}
public MessageSubscription(Type messageType, PeerId peer, IEndpoint endpoint, ISubscriptionFilter subscriptionFilter, ReliabilityLevel reliabilityLevel)
{
MessageType = messageType;
Peer = peer;
Endpoint = endpoint;
SubscriptionFilter = (subscriptionFilter);
ReliabilityLevel = reliabilityLevel;
}
internal override void UpdateFromUserConfig(IUserConfig userConfig)
{
base.UpdateFromUserConfig(userConfig);
this.Security = new SecurityGA();
if (userConfig.Security != null)
{
this.Security.FromInternal(userConfig.Security);
}
this.ReliabilityLevel = userConfig.ReliabilityLevel;
}
private async Task <ReliabilityLevel> GetActualReliabilityLevelForCluster(CancellationToken cancellationToken)
{
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "Entering GetCurrentReliabilityLevelForCluster");
System.Fabric.Query.NodeList nodes = await StandaloneUtility.GetNodesFromFMAsync(this.fabricClient, cancellationToken).ConfigureAwait(false);
int seedNodeCount = nodes.Count(p => p.IsSeedNode);
ReliabilityLevel actualReliabilityLevelInCluster = ReliabilityLevelExtension.GetReliabilityLevel(seedNodeCount);
UpgradeOrchestrationTrace.TraceSource.WriteInfo(TraceType, "SeedNodeCount from cluster {0}, actualReliabilityLevelInCluster {1}", seedNodeCount, actualReliabilityLevelInCluster);
return(actualReliabilityLevelInCluster);
}
public bool TryUpdate(
ReliabilityLevel reliabilityLevel,
IEnumerable <NodeDescription> existingSeedNodes,
IEnumerable <NodeDescription> enabledNodes, /*list of nodes which are enabled*/
int faultDomainCount,
int upgradeDomainCount,
out List <NodeDescription> seedNodesToAdd,
out List <NodeDescription> seedNodesToRemove)
{
existingSeedNodes.ThrowIfNull("existingSeedNodes");
enabledNodes.ThrowIfNull("nodes");
seedNodesToAdd = new List <NodeDescription>();
seedNodesToRemove = new List <NodeDescription>();
var targetSeedNodeCount = reliabilityLevel.GetSeedNodeCount();
if (targetSeedNodeCount == existingSeedNodes.Count())
{
return(true);
}
else if (targetSeedNodeCount < existingSeedNodes.Count())
{
var seedNodesToRemoveCount = existingSeedNodes.Count() - targetSeedNodeCount;
seedNodesToRemove = this.RemoveSeedNodes(
seedNodesToRemoveCount,
existingSeedNodes);
}
else
{
var seedNodesToAddCount = targetSeedNodeCount - existingSeedNodes.Count();
seedNodesToAdd = this.AddSeedNodes(
seedNodesToAddCount,
enabledNodes,
existingSeedNodes,
faultDomainCount,
upgradeDomainCount);
if (seedNodesToAdd == null)
{
// not enough nodes available to reach target seed nodes
return(false);
}
}
return(true);
}
public static ReplicaSetSize GetReplicaSetSize(this ReliabilityLevel reliabilityLevel)
{
switch (reliabilityLevel)
{
case ReliabilityLevel.Iron:
return(new ReplicaSetSize()
{
MinReplicaSetSize = 1,
TargetReplicaSetSize = 1
});
case ReliabilityLevel.Bronze:
return(new ReplicaSetSize()
{
MinReplicaSetSize = 3,
TargetReplicaSetSize = 3
});
case ReliabilityLevel.Silver:
return(new ReplicaSetSize()
{
MinReplicaSetSize = 3,
TargetReplicaSetSize = 5
});
case ReliabilityLevel.Gold:
return(new ReplicaSetSize()
{
MinReplicaSetSize = 5,
TargetReplicaSetSize = 7
});
case ReliabilityLevel.Platinum:
return(new ReplicaSetSize()
{
MinReplicaSetSize = 5,
TargetReplicaSetSize = 7
});
default:
throw new ClusterManagementException(ClusterManagementErrorCode.BadRequest);
}
}
public static int GetSeedNodeCount(this ReliabilityLevel reliabilityLevel)
{
switch (reliabilityLevel)
{
case ReliabilityLevel.Iron:
return(1);
case ReliabilityLevel.Bronze:
return(3);
case ReliabilityLevel.Silver:
return(5);
case ReliabilityLevel.Gold:
return(7);
case ReliabilityLevel.Platinum:
return(9);
default:
throw new ClusterManagementException(ClusterManagementErrorCode.BadRequest);
}
}
public IEnumerable <NodeDescription> Select(
ReliabilityLevel reliabilityLevel,
int totalExpectedPrimaryNodeCount,
IEnumerable <NodeDescription> primaryNodeTypeNodes,
int faultDomainCount,
int upgradeDomainCount,
bool isVmss)
{
this.traceLogger.WriteInfo(
SeedNodeSelector.TraceType,
"SeedNodeSelector.Select: Entering. reliabilityLevel: {0}, primaryNodeCount: {1}, primaryNodeTypeNodes.Count: {2}, faultDomainCount: {3}, upgradeDomainCount: {4}, primaryNodeTypeNodes: {5}",
reliabilityLevel,
totalExpectedPrimaryNodeCount,
primaryNodeTypeNodes.Count(),
faultDomainCount,
upgradeDomainCount,
this.DumpSeedNodes(primaryNodeTypeNodes));
bool foundNewNode = this.UpdateNodeInfo(primaryNodeTypeNodes, faultDomainCount, upgradeDomainCount);
this.traceLogger.WriteInfo(SeedNodeSelector.TraceType, "SeedNodeSelector.Select: foundNewNode is {0}", foundNewNode);
var targetSeedNodeCount = reliabilityLevel.GetSeedNodeCount();
this.traceLogger.WriteInfo(SeedNodeSelector.TraceType, "SeedNodeSelector.Select: nodes.Count: {0}, targetSeedNodeCount: {1}, totalExpectedNode: {2}", primaryNodeTypeNodes.Count(), targetSeedNodeCount, totalExpectedPrimaryNodeCount);
if (primaryNodeTypeNodes.Count() < targetSeedNodeCount)
{
return(null);
}
if (targetSeedNodeCount == totalExpectedPrimaryNodeCount && primaryNodeTypeNodes.Count() == targetSeedNodeCount)
{
return(primaryNodeTypeNodes);
}
if (!foundNewNode && !TimeoutHelper.HasExpired(this.timeoutHelper))
{
// During optimal seed node selection, run the logic when
// more nodes are available than the last attempt
return(null);
}
if (isVmss)
{
var selectedSeedNodes =
primaryNodeTypeNodes.OrderBy(item => item.NodeInstance)
.Take(targetSeedNodeCount)
.TakeWhile((nodeDescription, index) => index == nodeDescription.NodeInstance);
if (selectedSeedNodes.Count() == targetSeedNodeCount)
{
return(selectedSeedNodes);
}
if (!TimeoutHelper.HasExpired(this.timeoutHelper))
{
return(null);
}
return(this.AddSeedNodes(
targetSeedNodeCount - selectedSeedNodes.Count(),
primaryNodeTypeNodes,
selectedSeedNodes,
faultDomainCount,
upgradeDomainCount));
}
else
{
return(this.SelectInternal(targetSeedNodeCount, primaryNodeTypeNodes, TimeoutHelper.HasExpired(this.timeoutHelper) || primaryNodeTypeNodes.Count() == totalExpectedPrimaryNodeCount));
}
}
public BusOptionsAttribute(ReliabilityLevel reliabilityLevel, WireTransportType transportType)
{
ReliabilityLevel = reliabilityLevel;
TransportType = transportType;
}
