internal static Dictionary <AmServerName, Server> GetServersInSite(ILogTraceHelper output, IEnumerable <Server> servers, AdSiteIdParameter adSite)
{
if (servers == null)
{
throw new ArgumentNullException("servers");
}
if (adSite == null)
{
throw new ArgumentNullException("adSite");
}
Dictionary <AmServerName, Server> dictionary = new Dictionary <AmServerName, Server>(16);
foreach (Server server in servers)
{
if (DatabaseAvailabilityGroupAction.SiteEquals(server.ServerSite, adSite))
{
dictionary.Add(new AmServerName(server.Fqdn), server);
}
}
output.AppendLogMessage("The following servers are in the site {0}:", new object[]
{
adSite
});
foreach (AmServerName amServerName in dictionary.Keys)
{
output.AppendLogMessage("\t{0}", new object[]
{
amServerName.NetbiosName
});
}
return(dictionary);
}
private static List <AmClusterResource> AddIpAddressesToStrandedNetworks(ILogTraceHelper logger, AmClusterGroup group, AmClusterResource netname, IEnumerable <AmClusterNetwork> publicNetworks, IEnumerable <string> networksWithResources)
{
logger = (logger ?? NullLogTraceHelper.GetNullLogger());
if (publicNetworks.Count <AmClusterNetwork>() <= networksWithResources.Count <string>())
{
logger.AppendLogMessage("AddIpAddressesToStrandedNetworks: publicNetworks.Count({0}) <= networksWithResources.Count({1}). So we're doing nothing.", new object[]
{
publicNetworks.Count <AmClusterNetwork>(),
networksWithResources.Count <string>()
});
return(new List <AmClusterResource>(0));
}
List <AmClusterResource> list = new List <AmClusterResource>(publicNetworks.Count <AmClusterNetwork>() - networksWithResources.Count <string>());
IEnumerable <AmClusterNetwork> enumerable = from publicNet in publicNetworks
where !networksWithResources.Contains(publicNet.Name)
select publicNet;
foreach (AmClusterNetwork amClusterNetwork in enumerable)
{
logger.AppendLogMessage("AddIpAddressesToStrandedNetworks() There doesn't appear to be an IP resource on network '{0}'.", new object[]
{
amClusterNetwork.Name
});
IEnumerable <string> source = amClusterNetwork.EnumerateAlternateIPv4Names();
IEnumerable <string> source2 = amClusterNetwork.EnumeratePureAlternateIPv6Names();
List <AmClusterResource> collection = AmClusterResourceHelper.CreateIpAddressResources(logger, group, netname, null, source.ToArray <string>(), source2.ToArray <string>());
list.AddRange(collection);
}
return(list);
}
public static string ConstructIPDependencyExpression(ILogTraceHelper logger, IEnumerable <AmClusterResource> ipResList, bool enforceIPv4AndIPv6)
{
int capacity = 80;
StringBuilder stringBuilder = new StringBuilder(capacity);
StringBuilder stringBuilder2 = new StringBuilder(capacity);
StringBuilder stringBuilder3 = new StringBuilder(capacity);
logger = (logger ?? NullLogTraceHelper.GetNullLogger());
foreach (AmClusterResource amClusterResource in ipResList)
{
if (amClusterResource.IsIpv4())
{
if (stringBuilder.Length > 0)
{
stringBuilder.Append(" OR ");
}
stringBuilder.Append("[" + amClusterResource.Name + "]");
}
else
{
if (stringBuilder2.Length > 0)
{
stringBuilder2.Append(" OR ");
}
stringBuilder2.Append("[" + amClusterResource.Name + "]");
}
}
if (enforceIPv4AndIPv6)
{
if (stringBuilder.Length > 0)
{
stringBuilder3.Append("(" + stringBuilder + ")");
}
if (stringBuilder2.Length > 0 && stringBuilder.Length > 0)
{
stringBuilder3.Append(" AND ");
}
if (stringBuilder2.Length > 0)
{
stringBuilder3.Append("(" + stringBuilder2 + ")");
}
}
else
{
stringBuilder3.Append(stringBuilder);
if (stringBuilder2.Length > 0 && stringBuilder.Length > 0)
{
stringBuilder3.Append(" OR ");
}
stringBuilder3.Append(stringBuilder2);
}
logger.AppendLogMessage("Constructed dependency expression: {0} (enforceIPv4AndIPv6={1})", new object[]
{
stringBuilder3,
enforceIPv4AndIPv6
});
return(stringBuilder3.ToString());
}
public IAmClusterResource CreateUniqueResource(ILogTraceHelper logger, string resPrefix, string resType, ref int nextIndex)
{
int num = nextIndex;
string text = null;
IAmClusterResource result = null;
logger = (logger ?? NullLogTraceHelper.GetNullLogger());
if (resPrefix == null)
{
resPrefix = resType;
}
try
{
IL_1A:
text = string.Format("{0} {1} ({2})", resPrefix, num, this.Name);
logger.AppendLogMessage("CreateUniqueResource() Trying to create a resource named '{0}'.", new object[]
{
text
});
result = this.CreateResource(text, resType);
num++;
nextIndex = num;
logger.AppendLogMessage("CreateUniqueResource() Created a resource named '{0}'.", new object[]
{
text
});
}
catch (ClusResourceAlreadyExistsException)
{
logger.AppendLogMessage("CreateUniqueResource() Resource '{0}' already exists. Trying again.", new object[]
{
text
});
num++;
goto IL_1A;
}
return(result);
}
// Token: 0x060008AE RID: 2222 RVA: 0x00029798 File Offset: 0x00027998
internal static void RevertToMnsQuorum(ILogTraceHelper output, IAmCluster cluster)
{
using (IAmClusterGroup amClusterGroup = cluster.FindCoreClusterGroup())
{
string text;
uint maxLogSize;
string quorumResourceInformation = cluster.GetQuorumResourceInformation(out text, out maxLogSize);
if (string.IsNullOrEmpty(quorumResourceInformation))
{
output.AppendLogMessage("RevertToMnsQuorum: It's already using MNS!", new object[0]);
using (IAmClusterResource amClusterResource = amClusterGroup.FindResourceByTypeName("File Share Witness"))
{
if (amClusterResource != null)
{
output.AppendLogMessage("Even though the quorum is set to MNS, there is a FSW resource present named '{0}', which will be deleted shortly.", new object[]
{
amClusterResource.Name
});
amClusterResource.DeleteResource();
output.AppendLogMessage("The resource has been deleted!", new object[0]);
}
goto IL_13D;
}
}
using (AmClusterResource amClusterResource2 = cluster.OpenResource(quorumResourceInformation))
{
output.AppendLogMessage("Setting cluster quorum to MNS", new object[0]);
if (cluster.CnoName == string.Empty)
{
cluster.ClearQuorumResource();
}
else
{
using (IAmClusterResource amClusterResource3 = amClusterGroup.FindResourceByTypeName("Network Name"))
{
output.AppendLogMessage("Setting cluster quorum resource to the netname resource (i.e. MNS quorum).", new object[0]);
cluster.SetQuorumResource(amClusterResource3, null, maxLogSize);
if (amClusterResource2 != null && amClusterResource2.GetTypeName() == "File Share Witness")
{
output.AppendLogMessage("Offlining and deleting the old FSW resource '{0}'.", new object[]
{
quorumResourceInformation
});
amClusterResource2.OfflineResource();
amClusterResource2.DeleteResource();
}
}
}
}
IL_13D :;
}
}
private static List <AmClusterResource> CreateIpAddressResources(ILogTraceHelper logger, AmClusterGroup group, AmClusterResource netname, IPAddress ipv4StaticAddress, string[] ipv4Networks, string[] ipv6Networks)
{
logger = (logger ?? NullLogTraceHelper.GetNullLogger());
logger.AppendLogMessage("CreateIpAddressResources(). IPv4Networks=[{0}]. IPv6Networks=[{1}].", new object[]
{
(ipv4Networks == null) ? string.Empty : string.Join(",", ipv4Networks),
(ipv6Networks == null) ? string.Empty : string.Join(",", ipv6Networks)
});
List <AmClusterResource> list = new List <AmClusterResource>(2);
if (ipv4Networks != null)
{
list.AddRange(AmClusterResourceHelper.ConfigureIPv4DhcpResources(logger, group, ipv4Networks));
}
if (ipv6Networks != null)
{
list.AddRange(AmClusterResourceHelper.ConfigureIPv6AutoCfgResources(logger, group, ipv6Networks));
}
return(list);
}
private static void ResolveServersInternal(ILogTraceHelper output, DatabaseAvailabilityGroup dag, Dictionary <AmServerName, Server> servers, Dictionary <AmServerName, Server> startedServers, Dictionary <AmServerName, Server> stoppedServers, bool startedListIsReadFromAd)
{
if (dag == null)
{
throw new ArgumentNullException("dag");
}
if (servers == null)
{
throw new ArgumentNullException("servers");
}
if (startedServers == null)
{
throw new ArgumentNullException("startedServers");
}
if (stoppedServers == null)
{
throw new ArgumentNullException("stoppedServers");
}
output = (output ?? NullLogTraceHelper.GetNullLogger());
foreach (ADObjectId entryId in dag.Servers)
{
Server server = dag.Session.Read <Server>(entryId);
AmServerName amServerName = new AmServerName(server.Fqdn);
if (!server.IsMailboxServer)
{
throw new OperationOnlyOnMailboxServerException(server.Name);
}
if (server.MajorVersion != Server.CurrentExchangeMajorVersion)
{
throw new DagTaskErrorServerWrongVersion(server.Name);
}
servers.Add(amServerName, server);
bool flag = false;
if (dag.StoppedMailboxServers.Contains(amServerName.Fqdn))
{
stoppedServers.Add(amServerName, server);
flag = true;
}
if (startedListIsReadFromAd)
{
if (dag.StartedMailboxServers.Contains(amServerName.Fqdn))
{
startedServers.Add(amServerName, server);
}
}
else if (!flag)
{
startedServers.Add(amServerName, server);
}
}
output.AppendLogMessage("Successfully resolved the servers based on the stopped servers list.", new object[0]);
string text;
if (startedListIsReadFromAd)
{
text = "The list is the StartedServers property of the DAG in AD";
}
else
{
text = "The list is all of the servers that are not in the StoppedServers list.";
}
output.AppendLogMessage("The following servers are in the StartedServers list ({0}):", new object[]
{
text
});
foreach (AmServerName amServerName2 in startedServers.Keys)
{
output.AppendLogMessage("\t{0}", new object[]
{
amServerName2.NetbiosName
});
}
output.AppendLogMessage("The following servers are in the StoppedServers list:", new object[0]);
foreach (AmServerName amServerName3 in stoppedServers.Keys)
{
output.AppendLogMessage("\t{0}", new object[]
{
amServerName3.NetbiosName
});
}
}
internal static int DeleteOrphanedIpAddresses(ILogTraceHelper logger, AmClusterGroup owningGroup, AmClusterResource netname, IEnumerable <AmClusterResource> currentIpResources, IEnumerable <IPAddress> staticIpAddresses, IEnumerable <AmClusterNetwork> allNetworks, out IList <string> networksWithResources)
{
logger = (logger ?? NullLogTraceHelper.GetNullLogger());
int num = 0;
networksWithResources = new List <string>(allNetworks.Count <AmClusterNetwork>());
bool flag = staticIpAddresses != null && staticIpAddresses.Count <IPAddress>() > 0;
bool flag2 = staticIpAddresses != null && staticIpAddresses.Count <IPAddress>() == 0;
if (currentIpResources.Count <AmClusterResource>() < 1)
{
logger.AppendLogMessage("DeleteOrphanedIpAddresses() found no IP address resources in the cluster at all!", new object[0]);
}
else
{
IAmCluster owningCluster = owningGroup.OwningCluster;
Dictionary <string, int> dictionary = new Dictionary <string, int>(networksWithResources.Count <string>());
IEnumerable <string> enumerable = netname.EnumerateDependentNames();
logger.AppendLogMessage("Netname resource '{0}' depends on the following resources:", new object[]
{
netname.Name
});
foreach (string text in enumerable)
{
logger.AppendLogMessage(" -> {0}", new object[]
{
text
});
}
foreach (AmClusterResource amClusterResource in currentIpResources)
{
bool flag3 = false;
string privateProperty = amClusterResource.GetPrivateProperty <string>("Network");
int privateProperty2 = amClusterResource.GetPrivateProperty <int>("EnableDhcp");
logger.AppendLogMessage("Resource '{0}' is on network '{1}' (enableDhcp={2}).", new object[]
{
amClusterResource.Name,
privateProperty,
privateProperty2
});
if (!enumerable.Contains(amClusterResource.Name))
{
logger.AppendLogMessage("Resource '{0}' should be deleted because the cluster netname does not depend on it.", new object[]
{
amClusterResource.Name
});
flag3 = true;
}
else if (string.IsNullOrEmpty(privateProperty))
{
logger.AppendLogMessage("Resource '{0}' should be deleted because it does not have a valid network.", new object[]
{
amClusterResource.Name
});
flag3 = true;
}
else
{
if (flag)
{
if (privateProperty2 != 0)
{
logger.AppendLogMessage("Resource '{0}' should be deleted because it's a DHCP resource and we're converting to static addresses.", new object[]
{
amClusterResource.Name
});
flag3 = true;
}
else if (amClusterResource.IsIpv6())
{
logger.AppendLogMessage("Resource '{0}' should be deleted because it's an IPv6 resource and we're converting to static addresses.", new object[]
{
amClusterResource.Name
});
flag3 = true;
}
else
{
string privateProperty3 = amClusterResource.GetPrivateProperty <string>("Address");
IPAddress ipaddress = IPAddress.Parse(privateProperty3);
if (!staticIpAddresses.Contains(ipaddress))
{
logger.AppendLogMessage("Resource '{0}' should be deleted because it's a static address ({1}) that is not in the list of updated addresses.", new object[]
{
amClusterResource.Name,
ipaddress
});
flag3 = true;
}
}
}
else if (flag2 && privateProperty2 == 0 && amClusterResource.IsIpv4())
{
logger.AppendLogMessage("Resource '{0}' should be deleted because it's a static IPv4 resource and we're converting to dynamic addresses.", new object[]
{
amClusterResource.Name
});
flag3 = true;
}
if (!flag3)
{
using (AmClusterNetwork networkFromIpResource = AmClusterResourceHelper.GetNetworkFromIpResource(logger, amClusterResource))
{
if (networkFromIpResource == null)
{
logger.AppendLogMessage("Resource '{0}' should be deleted because it does not have a valid network.", new object[]
{
amClusterResource.Name
});
flag3 = true;
}
else
{
dictionary[networkFromIpResource.Name] = 1;
}
}
}
}
if (flag3)
{
logger.AppendLogMessage("Deleting resource named '{0}' because its network ({1}) does not appear to be valid (enableDhcp={2}).", new object[]
{
amClusterResource.Name,
privateProperty,
privateProperty2
});
amClusterResource.OfflineResource();
netname.RemoveDependency(amClusterResource);
amClusterResource.DeleteResource();
amClusterResource.Dispose();
num++;
}
}
foreach (string item in dictionary.Keys)
{
networksWithResources.Add(item);
}
}
return(num);
}
public static List <AmClusterResource> ConfigureIPv6AutoCfgResources(ILogTraceHelper logger, AmClusterGroup group, string[] ipv6Networks)
{
bool flag = false;
Dictionary <string, AmClusterResource> dictionary = new Dictionary <string, AmClusterResource>(8);
Dictionary <string, AmClusterNetwork> dictionary2 = null;
AmClusterResource[] array = null;
List <AmClusterResource> list = new List <AmClusterResource>(10);
List <AmClusterResource> list2 = null;
try
{
logger = (logger ?? NullLogTraceHelper.GetNullLogger());
dictionary2 = AmClusterResourceHelper.GetIpv6AutoCfgNetworkMap(group.OwningCluster, ipv6Networks);
IEnumerable <AmClusterResource> source = group.EnumerateResourcesOfType("IPv6 Address");
if (source.Count <AmClusterResource>() > 0)
{
array = source.ToArray <AmClusterResource>();
}
if (array != null)
{
foreach (string key in ipv6Networks)
{
for (int j = 0; j < array.Length; j++)
{
AmClusterResource amClusterResource = array[j];
string privateProperty = amClusterResource.GetPrivateProperty <string>("Network");
AmClusterNetwork amClusterNetwork = dictionary2[key];
if (SharedHelper.StringIEquals(amClusterNetwork.Name, privateProperty))
{
logger.AppendLogMessage("Reusing ipv6 resource because its network is matching. (resource:{0}, network:{1}/{2}", new object[]
{
amClusterResource.Name,
privateProperty,
amClusterNetwork.Name
});
dictionary[key] = amClusterResource;
array[j] = null;
break;
}
}
}
}
if (dictionary.Count < ipv6Networks.Length)
{
int num = 1;
foreach (string text in ipv6Networks)
{
if (!dictionary.ContainsKey(text))
{
AmClusterResource amClusterResource = (AmClusterResource)group.CreateUniqueResource(logger, "IPv6 Auto Config Address", "IPv6 Address", ref num);
list.Add(amClusterResource);
logger.AppendLogMessage("Created new ipv6 resource. (resource:{0}, network:{1})", new object[]
{
amClusterResource.Name,
text
});
dictionary[text] = amClusterResource;
}
}
}
list2 = new List <AmClusterResource>(ipv6Networks.Length);
foreach (string key2 in ipv6Networks)
{
AmClusterResource amClusterResource = dictionary[key2];
AmClusterNetwork amClusterNetwork = dictionary2[key2];
logger.AppendLogMessage("ConfigureIPv6AutoCfgResources: Setting resource '{0}' to be on network '{1}' (role={2}).", new object[]
{
amClusterResource.Name,
amClusterNetwork.Name,
amClusterNetwork.GetNativeRole()
});
amClusterResource.SetPrivateProperty <string>("Network", amClusterNetwork.Name);
AmClusterResourceHelper.SetPossibleOwnersForIpResource(logger, amClusterResource);
list2.Add(amClusterResource);
}
flag = true;
}
finally
{
if (!flag)
{
SharedHelper.DisposeObjectList <AmClusterResource>(list);
}
SharedHelper.DisposeObjectList <AmClusterResource>(array);
if (dictionary2 != null)
{
SharedHelper.DisposeObjectList <AmClusterNetwork>(dictionary2.Values);
}
}
return(list2);
}
public static List <AmClusterResource> ConfigureIPv4DhcpResources(ILogTraceHelper logger, AmClusterGroup group, string[] ipv4Networks)
{
bool flag = false;
Dictionary <string, AmClusterResource> dictionary = new Dictionary <string, AmClusterResource>(8);
Dictionary <string, AmClusterNetwork> dictionary2 = null;
AmClusterResource[] array = null;
List <AmClusterResource> list = new List <AmClusterResource>(10);
List <AmClusterResource> list2 = new List <AmClusterResource>(10);
List <AmClusterResource> list3 = null;
try
{
logger = (logger ?? NullLogTraceHelper.GetNullLogger());
dictionary2 = AmClusterResourceHelper.GetIpv4DhcpNetworkMap(group.OwningCluster, ipv4Networks);
IEnumerable <AmClusterResource> enumerable = group.EnumerateResourcesOfType("IP Address");
if (enumerable != null)
{
array = enumerable.ToArray <AmClusterResource>();
for (int i = 0; i < array.Length; i++)
{
AmClusterResource amClusterResource = array[i];
if (amClusterResource.GetPrivateProperty <int>("EnableDhcp") != 0)
{
list.Add(amClusterResource);
array[i] = null;
}
}
}
foreach (string key in ipv4Networks)
{
for (int k = 0; k < list.Count; k++)
{
AmClusterResource amClusterResource2 = list[k];
string privateProperty = amClusterResource2.GetPrivateProperty <string>("Network");
AmClusterNetwork amClusterNetwork = dictionary2[key];
if (SharedHelper.StringIEquals(amClusterNetwork.Name, privateProperty))
{
logger.AppendLogMessage("Reusing ipv4 dhcp resource because its network is matching. (resource:{0}, network:{1}/{2}", new object[]
{
amClusterResource2.Name,
privateProperty,
amClusterNetwork.Name
});
dictionary[key] = amClusterResource2;
list[k] = null;
break;
}
}
}
if (dictionary.Count < ipv4Networks.Length)
{
int num = 1;
foreach (string text in ipv4Networks)
{
if (!dictionary.ContainsKey(text))
{
AmClusterResource amClusterResource2 = (AmClusterResource)group.CreateUniqueResource(logger, "IPv4 DHCP Address", "IP Address", ref num);
list2.Add(amClusterResource2);
logger.AppendLogMessage("Created new ipv4 dhcp resource. (resource:{0}, network:{1})", new object[]
{
amClusterResource2.Name,
text
});
dictionary[text] = amClusterResource2;
}
}
}
list3 = new List <AmClusterResource>(ipv4Networks.Length);
foreach (string key2 in ipv4Networks)
{
AmClusterResource amClusterResource2 = dictionary[key2];
AmClusterNetwork amClusterNetwork = dictionary2[key2];
int num2;
using (AmClusterPropListDisposable amClusterPropListDisposable = AmClusPropListMaker.CreatePropListInt("EnableDhcp", 1, out num2))
{
using (AmClusterPropListDisposable amClusterPropListDisposable2 = AmClusPropListMaker.DupeAndAppendPropListString(amClusterPropListDisposable.RawBuffer, (int)amClusterPropListDisposable.BufferSize, "Network", amClusterNetwork.Name, out num2))
{
logger.AppendLogMessage("ConfigureIPv4DhcpResources: Setting resource '{0}' to be DHCP-enabled on network '{1}' (role={2}).", new object[]
{
amClusterResource2.Name,
amClusterNetwork.Name,
amClusterNetwork.GetNativeRole()
});
amClusterResource2.SetPrivatePropertyList(amClusterPropListDisposable2);
}
}
AmClusterResourceHelper.SetPossibleOwnersForIpResource(logger, amClusterResource2);
list3.Add(amClusterResource2);
}
flag = true;
}
finally
{
if (!flag)
{
SharedHelper.DisposeObjectList <AmClusterResource>(list2);
}
SharedHelper.DisposeObjectList <AmClusterResource>(array);
SharedHelper.DisposeObjectList <AmClusterResource>(list);
if (dictionary2 != null)
{
SharedHelper.DisposeObjectList <AmClusterNetwork>(dictionary2.Values);
}
}
return(list3);
}