// Token: 0x06001864 RID: 6244 RVA: 0x000646E8 File Offset: 0x000628E8
internal static bool StorePortNumber(ushort portNumber)
{
Exception ex = null;
try
{
using (RegistryKey registryKey = Registry.LocalMachine.CreateSubKey("SOFTWARE\\Microsoft\\ExchangeServer\\v15\\Replay\\Parameters"))
{
registryKey.SetValue("ReplicationPort", portNumber, RegistryValueKind.DWord);
return(true);
}
}
catch (IOException ex2)
{
ex = ex2;
}
catch (SecurityException ex3)
{
ex = ex3;
}
catch (UnauthorizedAccessException ex4)
{
ex = ex4;
}
if (ex != null)
{
NetworkManager.TraceError("TcpPortFallback.StorePortNumber fails: {0}", new object[]
{
ex
});
}
return(false);
}
internal static void ThrowException(Exception e)
{
NetworkManager.TraceError("Throwing exception: {0}", new object[]
{
e
});
throw e;
}
private void DriveMapRefreshInternal()
{
lock (this.m_mapRefreshLock)
{
bool flag2 = false;
Exception ex = null;
int num = 4;
for (int i = 1; i <= num; i++)
{
try
{
this.EnumerateNetworkMap();
flag2 = true;
break;
}
catch (ClusterNetworkDeletedException ex2)
{
ex = ex2;
}
catch (ClusterException ex3)
{
ex = ex3;
}
if (i < num)
{
NetworkManager.TraceError("DriveMapRefresh hit an exception during EnumerateNetworkMap, sleeping for 1 second and re-trying: {0}", new object[]
{
ex
});
Thread.Sleep(1000);
}
}
if (!flag2)
{
throw ex;
}
if (this.m_netMap != null)
{
ExchangeNetwork exchangeNetwork = null;
foreach (KeyValuePair<string, ExchangeNetwork> keyValuePair in this.m_netMap.Networks)
{
ExchangeNetwork value = keyValuePair.Value;
if (value.ReplicationEnabled)
{
exchangeNetwork = value;
break;
}
}
if (exchangeNetwork == null)
{
ReplayEventLogConstants.Tuple_NetworkReplicationDisabled.LogEvent("AllNetsDisabled", new object[0]);
}
}
}
}
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);
}
}
internal void CopyClusterNicState(AmNetInterfaceState clusterNicState)
{
this.ClusterNicState = NetworkEndPoint.MapNicState(clusterNicState);
if (this.ClusterNicState != DatabaseAvailabilityGroupNetworkInterface.InterfaceState.Up && this.ClusterNicState != DatabaseAvailabilityGroupNetworkInterface.InterfaceState.Unreachable)
{
NetworkManager.TraceError("NIC {0} is down: {1}", new object[]
{
this.IPAddress,
clusterNicState
});
this.Usable = false;
}
}
internal static TcpClientChannel OpenConnection(ref NetworkPath actualPath, int timeoutInMsec, bool ignoreNodeDown)
{
NetworkPath networkPath = actualPath;
NetworkTransportException ex = null;
ITcpConnector tcpConnector = Dependencies.TcpConnector;
TcpClientChannel tcpClientChannel = tcpConnector.TryConnect(networkPath, timeoutInMsec, out ex);
if (tcpClientChannel != null)
{
return tcpClientChannel;
}
if (!networkPath.NetworkChoiceIsMandatory)
{
NetworkManager.TraceError("Attempting alternate routes", new object[0]);
List<NetworkPath> list = null;
ExchangeNetworkMap map = NetworkManager.GetMap();
if (map != null)
{
list = map.EnumeratePaths(networkPath.TargetNodeName, ignoreNodeDown);
if (list != null)
{
NetworkPath networkPath2 = null;
foreach (NetworkPath networkPath3 in list)
{
if (string.Equals(networkPath3.NetworkName, networkPath.NetworkName, DatabaseAvailabilityGroupNetwork.NameComparison))
{
networkPath2 = networkPath3;
break;
}
}
if (networkPath2 != null)
{
list.Remove(networkPath2);
}
DagNetConfig dagConfig = DagNetEnvironment.FetchNetConfig();
foreach (NetworkPath networkPath4 in list)
{
networkPath4.Purpose = networkPath.Purpose;
networkPath4.ApplyNetworkPolicy(dagConfig);
tcpClientChannel = tcpConnector.TryConnect(networkPath, timeoutInMsec, out ex);
if (tcpClientChannel != null)
{
actualPath = networkPath4;
return tcpClientChannel;
}
}
}
}
}
throw ex;
}
// Token: 0x06001863 RID: 6243 RVA: 0x000645E4 File Offset: 0x000627E4
internal static bool LoadPortNumber(out ushort portNumber)
{
portNumber = 64327;
Exception ex = null;
try
{
using (RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\ExchangeServer\\v15\\Replay\\Parameters"))
{
RegistryValueKind valueKind = registryKey.GetValueKind("ReplicationPort");
if (valueKind == RegistryValueKind.DWord)
{
int num = (int)registryKey.GetValue("ReplicationPort");
if (num > 0 && num < 65536)
{
portNumber = (ushort)num;
return(true);
}
NetworkManager.TraceError("{0}\\{1} = {2} which is an invalid port number", new object[]
{
"SOFTWARE\\Microsoft\\ExchangeServer\\v15\\Replay\\Parameters",
"ReplicationPort",
num
});
}
}
}
catch (IOException ex2)
{
ex = ex2;
}
catch (SecurityException ex3)
{
ex = ex3;
}
catch (UnauthorizedAccessException ex4)
{
ex = ex4;
}
if (ex != null)
{
NetworkManager.TraceError("TcpPortFallback.LoadPortNumber fails: {0}", new object[]
{
ex
});
}
return(false);
}
private bool TryDriveMapRefresh()
{
Exception ex = null;
try
{
this.DriveMapRefresh();
}
catch (ClusterException ex2)
{
ex = ex2;
}
catch (DataSourceTransientException ex3)
{
ex = ex3;
}
catch (DataSourceOperationException ex4)
{
ex = ex4;
}
catch (TransientException ex5)
{
ex = ex5;
}
catch (Win32Exception ex6)
{
ex = ex6;
}
catch (SerializationException ex7)
{
ex = ex7;
ReplayCrimsonEvents.GeneralSerializationError.LogPeriodic<string>("NetworkManager", DiagCore.DefaultEventSuppressionInterval, ex7.ToString());
}
if (ex != null)
{
NetworkManager.TraceError("TryDriveMapRefresh hit exception: {0}", new object[]
{
ex
});
ReplayEventLogConstants.Tuple_NetworkMonitoringError.LogEvent(ex.Message.GetHashCode().ToString(), new object[]
{
ex.ToString()
});
return false;
}
return true;
}
// Token: 0x0600174F RID: 5967 RVA: 0x00060294 File Offset: 0x0005E494
internal static DatabaseAvailabilityGroupSubnetId ExtractSubnetId(AmClusterNetwork clusNet)
{
DatabaseAvailabilityGroupSubnetId databaseAvailabilityGroupSubnetId = null;
IEnumerable <string> enumerable = clusNet.EnumerateAlternateIPv4Names();
foreach (string text in enumerable)
{
try
{
databaseAvailabilityGroupSubnetId = new DatabaseAvailabilityGroupSubnetId(text);
break;
}
catch (FormatException ex)
{
NetworkManager.TraceError("Ignoring invalid ipv4 subnet {0}. Exception:{1}", new object[]
{
text,
ex
});
databaseAvailabilityGroupSubnetId = null;
}
}
if (databaseAvailabilityGroupSubnetId == null)
{
IEnumerable <string> enumerable2 = clusNet.EnumeratePureAlternateIPv6Names();
foreach (string text2 in enumerable2)
{
try
{
databaseAvailabilityGroupSubnetId = new DatabaseAvailabilityGroupSubnetId(text2);
break;
}
catch (FormatException ex2)
{
NetworkManager.TraceError("Ignoring invalid ipv6 subnet {0}. Exception:{1}", new object[]
{
text2,
ex2
});
databaseAvailabilityGroupSubnetId = null;
}
}
}
return(databaseAvailabilityGroupSubnetId);
}
private static ExchangeNetworkMap FetchInitializedMap()
{
ExchangeNetworkMap map = NetworkManager.GetMap();
if (map == null)
{
NetworkManager.TraceError("NetworkMap has not yet been initialized. Sleeping for {0}ms", new object[]
{
NetworkManager.GetInitializationTimeoutInMsec()
});
Thread.Sleep(NetworkManager.GetInitializationTimeoutInMsec());
map = NetworkManager.GetMap();
if (map == null)
{
throw new DagNetworkManagementException(ReplayStrings.NetworkManagerInitError);
}
}
return map;
}
private void RegisterForChangeNotification(IDistributedStoreKey dsKey, AmClusterNotifyHandle hChange)
{
AmClusterRegkeyHandle clusdbKeyHandle = this.GetClusdbKeyHandle(dsKey);
if (clusdbKeyHandle != null && !clusdbKeyHandle.IsInvalid)
{
ClusterNotifyFlags dwFilter = ClusterNotifyFlags.CLUSTER_CHANGE_REGISTRY_VALUE;
IntPtr dwNotifyKey = (IntPtr)1;
int num = ClusapiMethods.RegisterClusterNotify(hChange, dwFilter, clusdbKeyHandle, dwNotifyKey);
if (num != 0)
{
NetworkManager.TraceError("RegisterClusterNotify for reg notification 0x{0:X8}", new object[]
{
num
});
throw AmExceptionHelper.ConstructClusterApiException(num, "RegisterClusterNotify(Network Registry)", new object[0]);
}
}
}
// 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;
}
}
public ClusterNic(AmClusterNetInterface clusNic, ClusterNetwork owningClusNet)
{
this.Name = clusNic.Name;
this.ClusterNetwork = owningClusNet;
this.NodeName = clusNic.GetNodeName();
this.ClusterState = clusNic.GetState(false);
bool flag = false;
string address = clusNic.GetAddress();
IPAddress ipaddress = NetworkUtil.ConvertStringToIpAddress(address);
if (ipaddress != null)
{
flag = true;
}
else
{
NetworkManager.TraceError("Ignoring invalid IPV4 address on NIC {0} since it has invalid ip={1}", new object[]
{
this.Name,
address
});
string[] ipv6Addresses = clusNic.GetIPv6Addresses();
if (ipv6Addresses != null && ipv6Addresses.Length > 0)
{
ipaddress = NetworkUtil.ConvertStringToIpAddress(ipv6Addresses[0]);
if (ipaddress != null)
{
flag = true;
}
}
}
if (flag)
{
this.IPAddress = ipaddress;
this.HasIPAddress = true;
return;
}
NetworkManager.TraceError("ClusterNic '{0}' has no ip addr. Nic state is {1}", new object[]
{
this.Name,
this.ClusterState
});
}
internal static void RemoveDagNetwork(RemoveDagNetworkRequest req)
{
NetworkManager.RunRpcOperation("RemoveDagNetwork", delegate(object param0, EventArgs param1)
{
NetworkManager manager = NetworkManager.GetManager();
if (manager == null)
{
throw new DagNetworkManagementException(ReplayStrings.NetworkManagerInitError);
}
lock (manager.m_mapRefreshLock)
{
using (DagConfigurationStore dagConfigurationStore = new DagConfigurationStore())
{
dagConfigurationStore.Open();
PersistentDagNetworkConfig persistentDagNetworkConfig = dagConfigurationStore.LoadNetworkConfig();
if (persistentDagNetworkConfig != null)
{
string text = persistentDagNetworkConfig.Serialize();
ReplayEventLogConstants.Tuple_DagNetworkConfigOld.LogEvent(DateTime.UtcNow.ToString(), new object[]
{
text
});
}
}
ExchangeNetworkMap exchangeNetworkMap = NetworkManager.FetchInitializedMap();
PersistentDagNetworkConfig persistentDagNetworkConfig2 = exchangeNetworkMap.BuildPersistentDagNetworkConfig();
if (!persistentDagNetworkConfig2.RemoveNetwork(req.Name))
{
NetworkManager.TraceError("RemoveDagNetwork {0} not found", new object[]
{
req.Name
});
throw new DagNetworkManagementException(ReplayStrings.NetworkNameNotFound(req.Name));
}
manager.UpdateNetworkConfig(persistentDagNetworkConfig2);
}
});
}
// Token: 0x0600177E RID: 6014 RVA: 0x0006121C File Offset: 0x0005F41C
internal PersistentDagNetworkConfig UpdateNetConfig(SetDagNetworkRequest changeReq)
{
ExchangeNetwork network = this.GetNetwork(changeReq.Name);
if (changeReq.NewName != null)
{
ExchangeNetwork network2 = this.GetNetwork(changeReq.NewName);
if (network2 != null && network2 != network)
{
NetworkManager.TraceError("SetDagNetwork Cannot rename {0} because {1} already exists", new object[]
{
changeReq.Name,
changeReq.NewName
});
throw new DagNetworkManagementException(ServerStrings.DagNetworkCreateDupName(changeReq.NewName));
}
}
PersistentDagNetworkConfig persistentDagNetworkConfig = this.BuildNetConfigWithChange(changeReq);
if (network == null)
{
PersistentDagNetwork persistentDagNetwork = new PersistentDagNetwork();
persistentDagNetwork.Name = changeReq.Name;
persistentDagNetwork.Description = changeReq.Description;
persistentDagNetwork.IgnoreNetwork = changeReq.IgnoreNetwork;
persistentDagNetwork.ReplicationEnabled = changeReq.ReplicationEnabled;
if (changeReq.Subnets.Count > 0)
{
foreach (DatabaseAvailabilityGroupSubnetId databaseAvailabilityGroupSubnetId in changeReq.Subnets.Keys)
{
persistentDagNetwork.Subnets.Add(databaseAvailabilityGroupSubnetId.ToString());
}
}
persistentDagNetworkConfig.Networks.Add(persistentDagNetwork);
}
return(persistentDagNetworkConfig);
}
private bool RefreshClusterHandles()
{
this.CloseClusterHandles();
Exception ex = null;
try
{
this.m_hCluster = ClusapiMethods.OpenCluster(null);
if (this.m_hCluster == null || this.m_hCluster.IsInvalid)
{
int lastWin32Error = Marshal.GetLastWin32Error();
NetworkManager.TraceError("OpenCluster() failed with error {0}.", new object[]
{
lastWin32Error
});
return false;
}
this.m_clusterHandlesAreValid = true;
return true;
}
catch (ClusterException ex2)
{
ex = ex2;
}
catch (TransientException ex3)
{
ex = ex3;
}
if (ex != null)
{
NetworkManager.TraceError("RefreshClusterHandles() failed with error {0}.", new object[]
{
ex
});
}
return false;
}
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;
}
}
}
}
// 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 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();
}
}
}
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]);
}
