public bool RemoveEmptyNets()
{
bool result = false;
for (int i = this.m_logicalNets.Count - 1; i >= 0; i--)
{
LogicalNetwork logicalNetwork = this.m_logicalNets[i];
bool flag = true;
foreach (Subnet subnet in logicalNetwork.Subnets)
{
if (subnet.ClusterNetwork != null)
{
flag = false;
break;
}
}
if (flag)
{
foreach (Subnet subnet2 in logicalNetwork.Subnets)
{
this.m_subnets.Remove(subnet2.SubnetId);
}
this.m_logicalNets.RemoveAt(i);
result = true;
NetworkDiscovery.Tracer.TraceDebug <string>((long)this.GetHashCode(), "Net {0} removed since it has no active subnets", logicalNetwork.Name);
}
}
return(result);
}
private void ResolveLogicalNetworkNames()
{
bool[] array = new bool[this.m_logicalNets.Count];
bool flag = false;
foreach (LogicalNetwork logicalNetwork in this.m_logicalNets)
{
int num;
if (string.IsNullOrEmpty(logicalNetwork.Name))
{
flag = true;
}
else if (logicalNetwork.Name.StartsWith("ReplicationDagNetwork", DatabaseAvailabilityGroupNetwork.NameComparison) && int.TryParse(logicalNetwork.Name.Substring("ReplicationDagNetwork".Length), out num) && num > 0 && num <= array.Length)
{
array[num - 1] = true;
}
}
if (flag)
{
int index = 0;
foreach (LogicalNetwork logicalNetwork2 in this.m_logicalNets)
{
if (string.IsNullOrEmpty(logicalNetwork2.Name))
{
while (array[index++])
{
}
logicalNetwork2.Name = LogicalNetwork.BuildDefaultReplNetName(index);
}
}
}
}
public void LoadExistingConfiguration(PersistentDagNetworkConfig existingConfig)
{
foreach (PersistentDagNetwork persistentDagNetwork in existingConfig.Networks)
{
LogicalNetwork logicalNetwork = this.AddNewLogicalNetwork();
logicalNetwork.Name = persistentDagNetwork.Name;
logicalNetwork.Description = persistentDagNetwork.Description;
logicalNetwork.ReplicationEnabled = persistentDagNetwork.ReplicationEnabled;
logicalNetwork.IgnoreNetwork = persistentDagNetwork.IgnoreNetwork;
foreach (string expression in persistentDagNetwork.Subnets)
{
DatabaseAvailabilityGroupSubnetId databaseAvailabilityGroupSubnetId = new DatabaseAvailabilityGroupSubnetId(expression);
if (this.m_subnets.ContainsKey(databaseAvailabilityGroupSubnetId))
{
string errorText = string.Format("Ignoring inconsistent DagNetworkConfig. Subnet {0} is defined in multiple places.", databaseAvailabilityGroupSubnetId);
this.RecordInconsistency(errorText);
}
else
{
Subnet subnet = new Subnet(databaseAvailabilityGroupSubnetId);
subnet.LogicalNetwork = logicalNetwork;
this.m_subnets.Add(databaseAvailabilityGroupSubnetId, subnet);
logicalNetwork.Add(subnet);
}
}
}
}
private LogicalNetwork AddNewLogicalNetwork()
{
LogicalNetwork logicalNetwork = new LogicalNetwork();
this.m_logicalNets.Add(logicalNetwork);
return(logicalNetwork);
}
private void HandleUnassignedDnsNets(List <ClusterNetwork> unassignedNets)
{
LogicalNetwork logicalNetwork = null;
LogicalNetwork logicalNetwork2 = null;
foreach (LogicalNetwork logicalNetwork3 in this.LogicalNetworks)
{
if (DatabaseAvailabilityGroupNetwork.NameComparer.Equals("MapiDagNetwork", logicalNetwork3.Name))
{
logicalNetwork = logicalNetwork3;
}
if (logicalNetwork3.HasDnsNic() && logicalNetwork2 == null)
{
logicalNetwork2 = logicalNetwork3;
}
}
if (logicalNetwork2 == null)
{
if (logicalNetwork == null)
{
logicalNetwork = this.AddNewLogicalNetwork();
logicalNetwork.Name = "MapiDagNetwork";
NetworkDiscovery.Tracer.TraceDebug <string>((long)this.GetHashCode(), "{0} created to hold DNS nets", "MapiDagNetwork");
}
logicalNetwork2 = logicalNetwork;
}
else if (logicalNetwork != logicalNetwork2 && logicalNetwork != null && logicalNetwork.HasDnsNic())
{
logicalNetwork2 = logicalNetwork;
}
foreach (ClusterNetwork clusterNetwork in unassignedNets)
{
Subnet subnet;
if (this.m_subnets.TryGetValue(clusterNetwork.SubnetId, out subnet))
{
logicalNetwork2.Add(subnet);
clusterNetwork.LogicalNetwork = logicalNetwork2;
}
}
}
private void ResolveLocalNic(ClusterNic localNic)
{
Subnet subnet = this.GetSubnet(localNic.ClusterNetwork.SubnetId);
if (localNic.ClusterState == AmNetInterfaceState.Up)
{
List <LogicalNetwork> list = this.FindLogicalNetsWithoutNode(localNic.NodeName);
if (list.Count > 0)
{
List <PingRequest> list2 = new List <PingRequest>(list.Count * 3);
foreach (LogicalNetwork logicalNetwork in list)
{
foreach (Subnet subnet2 in logicalNetwork.Subnets)
{
if (subnet2.ClusterNetwork != null)
{
this.SelectPingCandidates(subnet2.ClusterNetwork, list2);
}
}
}
if (list2.Count > 0)
{
PingRequest[] array = list2.ToArray();
PingProber pingProber = null;
try
{
pingProber = new PingProber(localNic.IPAddress);
pingProber.SendPings(array);
pingProber.GatherReplies(3000);
foreach (PingRequest pingRequest in array)
{
if (pingRequest.Success)
{
ClusterNic clusterNic = (ClusterNic)pingRequest.UserContext;
localNic.ClusterNetwork.LogicalNetwork = clusterNic.ClusterNetwork.LogicalNetwork;
localNic.ClusterNetwork.LogicalNetwork.Add(subnet);
break;
}
}
}
catch (SocketException arg)
{
NetworkDiscovery.Tracer.TraceError <IPAddress, SocketException>((long)this.GetHashCode(), "Prober failed from {0}:{1}", localNic.IPAddress, arg);
}
finally
{
if (pingProber != null)
{
pingProber.Dispose();
}
}
}
}
}
if (localNic.ClusterNetwork.LogicalNetwork == null)
{
LogicalNetwork logicalNetwork2 = this.AddNewLogicalNetwork();
logicalNetwork2.Add(subnet);
localNic.ClusterNetwork.LogicalNetwork = logicalNetwork2;
}
}
public bool AggregateNetworks(bool pingAllowed)
{
bool result = false;
List <ClusterNetwork> list = new List <ClusterNetwork>(3);
List <ClusterNetwork> list2 = new List <ClusterNetwork>(3);
foreach (ClusterNetwork clusterNetwork in this.m_clusterNets)
{
Subnet subnet = null;
if (this.m_subnets.TryGetValue(clusterNetwork.SubnetId, out subnet))
{
if (subnet.ClusterNetwork != null)
{
string errorText = string.Format("Subnet {0} is used in multiple cluster networks.", clusterNetwork.SubnetId);
this.RecordInconsistency(errorText);
}
else
{
subnet.ClusterNetwork = clusterNetwork;
clusterNetwork.LogicalNetwork = subnet.LogicalNetwork;
}
}
else
{
subnet = new Subnet(clusterNetwork);
this.m_subnets.Add(subnet.SubnetId, subnet);
NetworkDiscovery.Tracer.TraceDebug <DatabaseAvailabilityGroupSubnetId, bool>((long)this.GetHashCode(), "Subnet '{0}' has DNS = {1}", clusterNetwork.SubnetId, clusterNetwork.HasDnsNic);
result = true;
if (clusterNetwork.HasDnsNic)
{
list.Add(clusterNetwork);
}
else
{
list2.Add(clusterNetwork);
}
}
}
if (list.Count > 0)
{
this.HandleUnassignedDnsNets(list);
}
if (list2.Count > 0 && pingAllowed)
{
this.HandleUnassignedReplNets(list2);
}
foreach (ClusterNetwork clusterNetwork2 in this.m_clusterNets)
{
if (clusterNetwork2.LogicalNetwork == null)
{
Subnet subnet2 = this.GetSubnet(clusterNetwork2.SubnetId);
if (subnet2 == null)
{
string errorText2 = string.Format("A subnet was not constructed for cluster net {0}.", clusterNetwork2.SubnetId);
this.RecordInconsistency(errorText2);
}
else
{
LogicalNetwork logicalNetwork = this.AddNewLogicalNetwork();
logicalNetwork.Add(subnet2);
clusterNetwork2.LogicalNetwork = logicalNetwork;
}
}
}
this.ResolveLogicalNetworkNames();
return(result);
}
