internal void AddEndPoint(NetworkEndPoint ep, int nodeIndex)
{
if (this.m_endPoints == null)
{
this.m_endPoints = new NetworkNodeEndPoints[this.m_map.Nodes.Count];
}
NetworkNodeEndPoints networkNodeEndPoints = this.m_endPoints[nodeIndex];
if (networkNodeEndPoints == null)
{
networkNodeEndPoints = new NetworkNodeEndPoints();
this.m_endPoints[nodeIndex] = networkNodeEndPoints;
}
if (networkNodeEndPoints.EndPoints.Count > 0)
{
string errorText = string.Format("Multiple endpoints for node {0} on network {1}. Ignoring ep:{2}.", ep.NodeName, this.Name, ep.IPAddress);
this.m_map.RecordInconsistency(errorText);
this.IsMisconfigured = true;
}
else
{
NetworkManager.TraceDebug("Added endpoint for node {0} on network {1} at {2}", new object[]
{
ep.NodeName,
this.Name,
ep.IPAddress
});
}
networkNodeEndPoints.EndPoints.Add(ep);
}
// Token: 0x06001787 RID: 6023 RVA: 0x00061814 File Offset: 0x0005FA14
private bool ExtractEndpoints(ExchangeNetwork xNet, ExchangeNetworkNode xNode, int targetNodeIndex, out NetworkEndPoint sourceEp, out NetworkEndPoint targetEp)
{
sourceEp = null;
targetEp = null;
NetworkNodeEndPoints[] endPoints = xNet.EndPoints;
if (endPoints == null || endPoints[this.SourceNodeIndex] == null || endPoints[targetNodeIndex] == null || endPoints[this.SourceNodeIndex].EndPoints.Count == 0 || endPoints[targetNodeIndex].EndPoints.Count == 0)
{
NetworkManager.TraceDebug("Node {0} is not reachable over network {1}", new object[]
{
xNode.Name,
xNet.Name
});
return(false);
}
sourceEp = endPoints[this.SourceNodeIndex].EndPoints[0];
targetEp = endPoints[targetNodeIndex].EndPoints[0];
if (!sourceEp.Usable || !targetEp.Usable)
{
NetworkManager.TraceDebug("Node {0} is not reachable over network {1}. EP({2})Usable:{3}. EP({4})Usable:{5}", new object[]
{
xNode.Name,
xNet.Name,
sourceEp.IPAddress,
sourceEp.Usable,
targetEp.IPAddress,
targetEp.Usable
});
return(false);
}
return(true);
}
internal static void Shutdown()
{
lock (NetworkManager.s_mgrLock)
{
NetworkManager.TraceDebug("Shutdown initiated.", new object[0]);
NetworkManager.s_mgr.m_shutdown = true;
NetworkManager.s_mgr.m_firstDriveMapRefreshCompleted.Close();
}
}
private bool IsPAM()
{
AmConfig config = AmSystemManager.Instance.Config;
if (!config.IsPAM && !config.IsSAM)
{
NetworkManager.TraceDebug("NetworkManager startup skipped. Not running in DAG role", new object[0]);
return false;
}
return config.IsPAM;
}
protected static void RunRpcOperation(string rpcName, EventHandler ev)
{
Exception ex = null;
NetworkManager.TraceDebug("RunRpcOperation({0})", new object[]
{
rpcName
});
try
{
ev(null, null);
return;
}
catch (ClusterNetworkDeletedException ex2)
{
ex = ex2;
}
catch (ClusterException ex3)
{
ex = ex3;
}
catch (DagNetworkManagementException ex4)
{
ex = ex4;
}
catch (COMException ex5)
{
ex = ex5;
}
catch (IOException ex6)
{
ex = ex6;
}
catch (UnauthorizedAccessException ex7)
{
ex = ex7;
}
catch (TransientException ex8)
{
ex = ex8;
}
catch (Win32Exception ex9)
{
ex = ex9;
}
if (ex != null)
{
NetworkManager.TraceError("RunRpcOperation({0}) hit exception {1}", new object[]
{
rpcName,
ex
});
throw new DagNetworkRpcServerException(rpcName, ex.Message, ex);
}
}
// Token: 0x06001795 RID: 6037 RVA: 0x00061B28 File Offset: 0x0005FD28
internal void GetDnsRecords()
{
Exception ex = null;
try
{
if (MachineName.Comparer.Equals(this.Name, Environment.MachineName))
{
List <IPAddress> list = ExchangeNetworkNode.FindCandidateDnsAddrs();
this.m_dnsAddresses = list.ToArray();
}
else
{
this.m_dnsAddresses = Dns.GetHostAddresses(this.Name);
}
foreach (IPAddress ipaddress in this.m_dnsAddresses)
{
NetworkManager.TraceDebug("Node {0} has DNS for {1}", new object[]
{
this.Name,
ipaddress
});
}
}
catch (SocketException ex2)
{
ex = ex2;
}
catch (NetworkInformationException ex3)
{
ex = ex3;
}
finally
{
if (ex != null)
{
NetworkManager.TraceError("NetworkMap.GetDnsRecords failed: {0}", new object[]
{
ex
});
}
this.m_hasDnsBeenChecked = true;
}
}
// Token: 0x06001777 RID: 6007 RVA: 0x000608D4 File Offset: 0x0005EAD4
public List <NetworkPath> EnumeratePaths(string targetNodeName, bool ignoreNodeDown)
{
this.m_rwLock.AcquireReaderLock(-1);
List <NetworkPath> result;
try
{
int num = this.Nodes.IndexOfKey(targetNodeName);
if (num < 0)
{
NetworkManager.TraceDebug("Node {0} is not in the DAG", new object[]
{
targetNodeName
});
result = null;
}
else
{
ExchangeNetworkNode exchangeNetworkNode = this.Nodes.Values[num];
if (exchangeNetworkNode.ClusterState == AmNodeState.Down && !ignoreNodeDown)
{
NetworkManager.TraceDebug("Node {0} is reported as down.", new object[]
{
exchangeNetworkNode.Name
});
result = null;
}
else
{
List <NetworkPath> list = new List <NetworkPath>();
this.EnumeratePaths(list, this.m_preferredNets, exchangeNetworkNode, num);
this.EnumeratePaths(list, this.m_regularNets, exchangeNetworkNode, num);
result = list;
}
}
}
finally
{
this.m_rwLock.ReleaseReaderLock();
}
return(result);
}
// Token: 0x0600177D RID: 6013 RVA: 0x00060F88 File Offset: 0x0005F188
private PersistentDagNetworkConfig BuildNetConfigWithChange(SetDagNetworkRequest changeReq)
{
PersistentDagNetworkConfig persistentDagNetworkConfig = new PersistentDagNetworkConfig();
persistentDagNetworkConfig.ReplicationPort = this.m_mgr.ReplicationPort;
persistentDagNetworkConfig.NetworkCompression = this.m_mgr.NetworkCompression;
persistentDagNetworkConfig.NetworkEncryption = this.m_mgr.NetworkEncryption;
foreach (KeyValuePair <string, ExchangeNetwork> keyValuePair in this.m_networks)
{
ExchangeNetwork value = keyValuePair.Value;
PersistentDagNetwork persistentDagNetwork = new PersistentDagNetwork();
persistentDagNetwork.Name = value.Name;
persistentDagNetwork.Description = value.Description;
persistentDagNetwork.ReplicationEnabled = value.ReplicationEnabled;
persistentDagNetwork.IgnoreNetwork = value.IgnoreNetwork;
bool flag = false;
if (changeReq != null && DatabaseAvailabilityGroupNetwork.NameComparer.Equals(changeReq.Name, value.Name))
{
if (changeReq.NewName != null)
{
persistentDagNetwork.Name = changeReq.NewName;
}
if (changeReq.Description != null)
{
persistentDagNetwork.Description = changeReq.Description;
}
if (changeReq.IsIgnoreChanged)
{
persistentDagNetwork.IgnoreNetwork = changeReq.IgnoreNetwork;
}
if (changeReq.IsReplicationChanged)
{
persistentDagNetwork.ReplicationEnabled = changeReq.ReplicationEnabled;
}
if (changeReq.SubnetListIsSet || changeReq.Subnets.Count > 0)
{
flag = true;
foreach (KeyValuePair <DatabaseAvailabilityGroupSubnetId, object> keyValuePair2 in changeReq.Subnets)
{
persistentDagNetwork.Subnets.Add(keyValuePair2.Key.ToString());
}
}
}
if (!flag)
{
foreach (ExchangeSubnet exchangeSubnet in value.Subnets)
{
if (changeReq != null && changeReq.Subnets.Count > 0 && changeReq.Subnets.ContainsKey(exchangeSubnet.SubnetId))
{
NetworkManager.TraceDebug("Subnet '{0}' moving from net '{1}' to net '{2}'", new object[]
{
exchangeSubnet.SubnetId,
value.Name,
changeReq.LatestName
});
}
else
{
string item = exchangeSubnet.SubnetId.ToString();
persistentDagNetwork.Subnets.Add(item);
}
}
}
persistentDagNetworkConfig.Networks.Add(persistentDagNetwork);
}
return(persistentDagNetworkConfig);
}
// Token: 0x06001779 RID: 6009 RVA: 0x00060A2C File Offset: 0x0005EC2C
internal void SynchronizeClusterNetworkRoles(IAmCluster cluster)
{
IEnumerable <AmClusterNetwork> enumerable = cluster.EnumerateNetworks();
try
{
foreach (AmClusterNetwork amClusterNetwork in enumerable)
{
DatabaseAvailabilityGroupSubnetId databaseAvailabilityGroupSubnetId = ExchangeSubnet.ExtractSubnetId(amClusterNetwork);
if (databaseAvailabilityGroupSubnetId != null)
{
ExchangeSubnet exchangeSubnet = this.FindSubnet(databaseAvailabilityGroupSubnetId);
if (exchangeSubnet != null)
{
AmNetworkRole nativeClusterNetworkRole = exchangeSubnet.Network.GetNativeClusterNetworkRole();
AmNetworkRole nativeRole = amClusterNetwork.GetNativeRole();
if (nativeRole != nativeClusterNetworkRole)
{
NetworkManager.TraceDebug("Changing network role for subnet {0} from {1} to {2}", new object[]
{
databaseAvailabilityGroupSubnetId,
nativeRole,
nativeClusterNetworkRole
});
bool flag = false;
try
{
amClusterNetwork.SetNativeRole(nativeClusterNetworkRole);
flag = true;
}
finally
{
if (!flag)
{
if (nativeClusterNetworkRole == AmNetworkRole.ClusterNetworkRoleNone)
{
exchangeSubnet.Network.IgnoreNetwork = false;
this.ConfigUpdated = true;
}
}
else
{
ReplayEventLogConstants.Tuple_NetworkRoleChanged.LogEvent(null, new object[]
{
amClusterNetwork.Name,
databaseAvailabilityGroupSubnetId.ToString(),
nativeRole.ToString(),
nativeClusterNetworkRole.ToString()
});
}
}
}
}
}
}
}
finally
{
foreach (AmClusterNetwork amClusterNetwork2 in enumerable)
{
using (amClusterNetwork2)
{
}
}
}
}
// Token: 0x06001775 RID: 6005 RVA: 0x00060680 File Offset: 0x0005E880
public NetworkPath ChoosePath(string targetNodeName, string selectedNetworkName)
{
this.m_rwLock.AcquireWriterLock(-1);
NetworkPath result;
try
{
int num = this.Nodes.IndexOfKey(targetNodeName);
if (num < 0)
{
NetworkManager.TraceDebug("Node {0} is not in the DAG", new object[]
{
targetNodeName
});
result = null;
}
else
{
ExchangeNetworkNode exchangeNetworkNode = this.Nodes.Values[num];
if (exchangeNetworkNode.ClusterState == AmNodeState.Down)
{
NetworkManager.TraceDebug("Node {0} is reported as down.", new object[]
{
exchangeNetworkNode.Name
});
result = null;
}
else
{
ExchangeNetwork exchangeNetwork = null;
NetworkEndPoint networkEndPoint = null;
NetworkEndPoint networkEndPoint2 = null;
if (selectedNetworkName != null)
{
exchangeNetwork = this.UseNetwork(selectedNetworkName, exchangeNetworkNode, num, out networkEndPoint, out networkEndPoint2);
}
else
{
if (this.m_preferredNets != null)
{
exchangeNetwork = this.ChooseNetwork(this.m_preferredNets, exchangeNetworkNode, num, out networkEndPoint, out networkEndPoint2);
}
if (exchangeNetwork == null && this.m_regularNets != null)
{
exchangeNetwork = this.ChooseNetwork(this.m_regularNets, exchangeNetworkNode, num, out networkEndPoint, out networkEndPoint2);
}
}
if (exchangeNetwork == null)
{
NetworkManager.TraceDebug("All paths to Node {0} are down", new object[]
{
targetNodeName
});
result = null;
}
else
{
IPAddress ipaddress = networkEndPoint2.IPAddress;
if (ipaddress.IsIPv6LinkLocal)
{
if (networkEndPoint.IPAddress.AddressFamily != AddressFamily.InterNetworkV6)
{
NetworkManager.TraceError("Target {0} has linkLocal v6 addr {1} which is unreachable on outbound ip {2}", new object[]
{
targetNodeName,
ipaddress,
networkEndPoint.IPAddress
});
return(null);
}
byte[] addressBytes = ipaddress.GetAddressBytes();
ipaddress = new IPAddress(addressBytes, networkEndPoint.IPAddress.ScopeId);
}
result = new NetworkPath(targetNodeName, ipaddress, (int)this.m_mgr.ReplicationPort, networkEndPoint.IPAddress)
{
NetworkName = exchangeNetwork.Name,
CrossSubnet = (networkEndPoint.Subnet != networkEndPoint2.Subnet)
};
}
}
}
}
finally
{
this.m_rwLock.ReleaseWriterLock();
}
return(result);
}
private void ClusterNotificationThread()
{
if (this.RefreshClusterHandles())
{
this.TryDriveMapRefresh();
}
while (!this.m_shutdown)
{
Exception ex = null;
try
{
AmConfig config = AmSystemManager.Instance.Config;
if (!config.IsPAM && !config.IsSAM)
{
NetworkManager.TraceDebug("NetworkManager sleeping. Not running in DAG role", new object[0]);
Thread.Sleep(NetworkManager.GetInitializationTimeoutInMsec());
}
else if (this.RefreshClusterHandles())
{
this.MonitorEvents();
}
else
{
Thread.Sleep(NetworkManager.GetInitializationTimeoutInMsec());
}
}
catch (ClusterException ex2)
{
ex = ex2;
}
catch (DataSourceTransientException ex3)
{
ex = ex3;
}
catch (DataSourceOperationException ex4)
{
ex = ex4;
}
catch (TransientException ex5)
{
ex = ex5;
}
catch (COMException ex6)
{
ex = ex6;
}
catch (Win32Exception ex7)
{
ex = ex7;
}
if (ex != null)
{
NetworkManager.TraceError("ClusterNotificationThread monitoring encountered an exception: {0}", new object[]
{
ex
});
ReplayEventLogConstants.Tuple_NetworkMonitoringError.LogEvent(ex.Message.GetHashCode().ToString(), new object[]
{
ex.ToString()
});
}
if (!this.m_shutdown)
{
Thread.Sleep(1000);
}
}
NetworkManager.TraceDebug("ClusterNotificationThread exiting", new object[0]);
}
private void EnumerateNetworkMap()
{
NetworkManager.TraceDebug("EnumerateNetworkMap: attempting to reload", new object[0]);
using (IAmCluster amCluster = ClusterFactory.Instance.Open())
{
PersistentDagNetworkConfig persistentDagNetworkConfig = null;
string text = null;
Exception ex = null;
using (DagConfigurationStore dagConfigurationStore = new DagConfigurationStore())
{
dagConfigurationStore.Open();
persistentDagNetworkConfig = dagConfigurationStore.LoadNetworkConfig(out text);
PersistentDagNetworkConfig persistentDagNetworkConfig2;
if (persistentDagNetworkConfig == null)
{
persistentDagNetworkConfig2 = new PersistentDagNetworkConfig();
}
else
{
persistentDagNetworkConfig2 = persistentDagNetworkConfig.Copy();
}
IADDatabaseAvailabilityGroup localDag = Dependencies.ADConfig.GetLocalDag();
if (localDag == null)
{
NetworkManager.TraceError("EnumerateNetworkMap can't get the DAG!", new object[0]);
}
else
{
if (persistentDagNetworkConfig2.NetworkCompression != localDag.NetworkCompression)
{
persistentDagNetworkConfig2.NetworkCompression = localDag.NetworkCompression;
}
if (persistentDagNetworkConfig2.NetworkEncryption != localDag.NetworkEncryption)
{
persistentDagNetworkConfig2.NetworkEncryption = localDag.NetworkEncryption;
}
if (persistentDagNetworkConfig2.ManualDagNetworkConfiguration != localDag.ManualDagNetworkConfiguration)
{
persistentDagNetworkConfig2.ManualDagNetworkConfiguration = localDag.ManualDagNetworkConfiguration;
}
}
this.NetworkCompression = persistentDagNetworkConfig2.NetworkCompression;
this.NetworkEncryption = persistentDagNetworkConfig2.NetworkEncryption;
this.ReplicationPort = persistentDagNetworkConfig2.ReplicationPort;
this.ManualDagNetworkConfiguration = persistentDagNetworkConfig2.ManualDagNetworkConfiguration;
if (this.m_portInLocalRegistry != this.ReplicationPort && TcpPortFallback.StorePortNumber(this.ReplicationPort))
{
this.m_portInLocalRegistry = this.ReplicationPort;
}
NetworkDiscovery networkDiscovery = new NetworkDiscovery();
networkDiscovery.LoadClusterObjects(amCluster);
if (this.ManualDagNetworkConfiguration)
{
networkDiscovery.LoadExistingConfiguration(persistentDagNetworkConfig2);
}
networkDiscovery.DetermineDnsStatus();
networkDiscovery.AggregateNetworks(true);
if (!this.ManualDagNetworkConfiguration)
{
networkDiscovery.RemoveEmptyNets();
}
ExchangeNetworkMap exchangeNetworkMap = new ExchangeNetworkMap(this);
exchangeNetworkMap.Load(networkDiscovery);
AmConfig config = AmSystemManager.Instance.Config;
if (config.IsPAM)
{
try
{
exchangeNetworkMap.SynchronizeClusterNetworkRoles(amCluster);
}
catch (ClusCommonFailException ex2)
{
NetworkManager.TraceError("SynchronizeClusterNetworkRoles threw: {0}", new object[]
{
ex2
});
ex = ex2;
}
}
exchangeNetworkMap.SetupPerfmon();
persistentDagNetworkConfig2 = exchangeNetworkMap.BuildPersistentDagNetworkConfig();
string text2 = persistentDagNetworkConfig2.Serialize();
bool flag = false;
if (config.IsPAM)
{
if (persistentDagNetworkConfig == null || text != text2)
{
flag = true;
Interlocked.Exchange(ref this.m_skipNextClusterRegistryEvent, 1);
dagConfigurationStore.StoreNetworkConfig(text2);
if (persistentDagNetworkConfig != null)
{
ReplayEventLogConstants.Tuple_DagNetworkConfigOld.LogEvent("DAGNET", new object[]
{
text
});
}
}
}
else if (this.m_lastWrittenClusterNetConfigXML != null && this.m_lastWrittenClusterNetConfigXML != text2)
{
flag = true;
}
if (flag)
{
ReplayEventLogConstants.Tuple_DagNetworkConfigNew.LogEvent("DAGNET", new object[]
{
text2
});
}
this.m_lastWrittenClusterNetConfigXML = text2;
DagNetConfig dagNetConfig = this.Convert2DagNetConfig(networkDiscovery);
string text3 = dagNetConfig.Serialize();
if (this.m_lastWrittenEseReplNetConfigXML == null || this.EseReplDagNetConfigIsStale || text3 != this.m_lastWrittenEseReplNetConfigXML)
{
DagNetEnvironment.PublishDagNetConfig(text3);
this.EseReplDagNetConfigIsStale = false;
}
this.m_lastWrittenEseReplNetConfigXML = text3;
this.m_mapLoadTime = ExDateTime.Now;
this.m_netMap = exchangeNetworkMap;
NetworkManager.TraceDebug("EnumerateNetworkMap: completed reload", new object[0]);
AmSystemManager instance = AmSystemManager.Instance;
if (instance != null)
{
AmNetworkMonitor networkMonitor = instance.NetworkMonitor;
if (networkMonitor != null)
{
networkMonitor.RefreshMapiNetwork();
}
}
if (ex != null)
{
throw ex;
}
}
}
}
private void MonitorEvents()
{
AmClusterNotifyHandle amClusterNotifyHandle = null;
IDistributedStoreKey distributedStoreKey = null;
IDistributedStoreChangeNotify distributedStoreChangeNotify = null;
try
{
ClusterNotifyFlags networkClusterNotificationMask = RegistryParameters.NetworkClusterNotificationMask;
NetworkManager.TraceDebug("SettingClusterMask as 0x{0:x}", new object[]
{
networkClusterNotificationMask
});
amClusterNotifyHandle = ClusapiMethods.CreateClusterNotifyPort(AmClusterNotifyHandle.InvalidHandle, this.ClusterHandle, networkClusterNotificationMask, IntPtr.Zero);
if (amClusterNotifyHandle == null || amClusterNotifyHandle.IsInvalid)
{
int lastWin32Error = Marshal.GetLastWin32Error();
NetworkManager.TraceError("CreateClusterNotifyPort failed. Error code 0x{0:X8}", new object[]
{
lastWin32Error
});
throw new ClusCommonTransientException("CreateClusterNotifyPort", new Win32Exception(lastWin32Error));
}
using (IDistributedStoreKey clusterKey = DistributedStore.Instance.GetClusterKey(this.ClusterHandle, null, null, DxStoreKeyAccessMode.Write, false))
{
distributedStoreKey = clusterKey.OpenKey("Exchange\\DagNetwork", DxStoreKeyAccessMode.CreateIfNotExist, false, null);
}
this.RegisterForChangeNotification(distributedStoreKey, amClusterNotifyHandle);
TimeSpan t = new TimeSpan(0, 0, RegistryParameters.NetworkStatusPollingPeriodInSecs);
while (this.m_clusterHandlesAreValid && !this.m_shutdown)
{
StringBuilder stringBuilder = new StringBuilder(256);
uint num = Convert.ToUInt32(stringBuilder.Capacity);
IntPtr zero = IntPtr.Zero;
ClusterNotifyFlags clusterNotifyFlags;
int clusterNotify = ClusapiMethods.GetClusterNotify(amClusterNotifyHandle, out zero, out clusterNotifyFlags, stringBuilder, ref num, 3000U);
if (this.m_shutdown)
{
break;
}
if (this.m_netMap == null)
{
if (!this.TryDriveMapRefresh())
{
break;
}
}
else if (clusterNotify == 258)
{
if (t < ExDateTime.TimeDiff(ExDateTime.Now, this.m_mapLoadTime) && !this.TryDriveMapRefresh())
{
break;
}
}
else if (clusterNotify != 0)
{
NetworkManager.TraceDebug("GetClusterNotify() returned unexpected status code 0x{0:X)", new object[]
{
clusterNotify
});
}
else
{
string text = stringBuilder.ToString();
NetworkManager.TraceDebug("GetClusterNotify() returned notifyKey={0}, filterType=0x{1:x}, resName={2}", new object[]
{
zero,
clusterNotifyFlags,
text
});
if ((clusterNotifyFlags & ~(ClusterNotifyFlags.CLUSTER_CHANGE_NODE_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_NAME | ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_ATTRIBUTES | ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_VALUE | ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_SUBTREE | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_GROUP_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_GROUP_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_GROUP_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_GROUP_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_TYPE_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_TYPE_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_TYPE_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_CLUSTER_RECONNECT | ClusterNotifyFlags.CLUSTER_CHANGE_QUORUM_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_CLUSTER_PROPERTY)) != ~(ClusterNotifyFlags.CLUSTER_CHANGE_NODE_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_NODE_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_NODE_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_NODE_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_NAME | ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_ATTRIBUTES | ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_VALUE | ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_SUBTREE | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_GROUP_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_GROUP_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_GROUP_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_GROUP_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_TYPE_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_TYPE_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_RESOURCE_TYPE_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_CLUSTER_RECONNECT | ClusterNotifyFlags.CLUSTER_CHANGE_NETWORK_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_NETWORK_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_NETWORK_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_NETWORK_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_NETINTERFACE_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_NETINTERFACE_DELETED | ClusterNotifyFlags.CLUSTER_CHANGE_NETINTERFACE_ADDED | ClusterNotifyFlags.CLUSTER_CHANGE_NETINTERFACE_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_QUORUM_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_CLUSTER_STATE | ClusterNotifyFlags.CLUSTER_CHANGE_CLUSTER_PROPERTY | ClusterNotifyFlags.CLUSTER_CHANGE_HANDLE_CLOSE) && !this.TryDriveMapRefresh())
{
break;
}
}
}
}
finally
{
if (amClusterNotifyHandle != null)
{
amClusterNotifyHandle.Dispose();
amClusterNotifyHandle = null;
}
if (distributedStoreChangeNotify != null)
{
distributedStoreChangeNotify.Dispose();
}
if (distributedStoreKey != null)
{
distributedStoreKey.Dispose();
}
}
}
