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(); } } }