// Token: 0x060008BA RID: 2234 RVA: 0x00029FC4 File Offset: 0x000281C4 private static bool EvictDagClusterNodeInternal(HaTaskStringBuilderOutputHelper output, AmServerName convictedNode, out string verboseLog) { ExTraceGlobals.ClusterTracer.TraceDebug <AmServerName>(0L, "Going to EvictClusterNode( {0} ) on this machine.", convictedNode); try { using (IAmCluster amCluster = ClusterFactory.Instance.Open()) { amCluster.EvictNodeFromCluster(convictedNode); } } catch (ClusterException ex) { output.AppendLogMessage("EvictDagClusterNode got exception {0}", new object[] { ex }); AmClusterException exception = DagHelper.TranslateClusterExceptionForClient(ex); DagHelper.ThrowDagTaskOperationWrapper(exception); } catch (LocalizedException ex2) { output.AppendLogMessage("EvictDagClusterNode got exception {0}", new object[] { ex2 }); DagHelper.ThrowDagTaskOperationWrapper(ex2); } finally { verboseLog = output.ToString(); } return(true); }
// Token: 0x060008B3 RID: 2227 RVA: 0x00029B08 File Offset: 0x00027D08 internal static IAmCluster CreateDagCluster(string clusterName, AmServerName firstNodeName, string[] ipAddresses, uint[] netmasks, out string verboseLog) { IAmCluster result = null; HaTaskStringBuilderOutputHelper haTaskStringBuilderOutputHelper = new HaTaskStringBuilderOutputHelper("m.e.cluster.replay.dll!CreateDagCluster"); GCHandle value = GCHandle.Alloc(haTaskStringBuilderOutputHelper); Exception ex = null; try { haTaskStringBuilderOutputHelper.WriteProgressSimple(ReplayStrings.DagTaskFormingClusterProgress(clusterName, firstNodeName.NetbiosName)); haTaskStringBuilderOutputHelper.LastException = null; haTaskStringBuilderOutputHelper.MaxPercentageDuringCallback = 0; result = ClusterFactory.Instance.CreateExchangeCluster(clusterName, firstNodeName, ipAddresses, netmasks, haTaskStringBuilderOutputHelper, GCHandle.ToIntPtr(value), out ex, true); if (ex != null) { haTaskStringBuilderOutputHelper.WriteErrorSimple(ex); } } catch (LocalizedException exception) { DagHelper.ThrowDagTaskOperationWrapper(exception); } finally { verboseLog = haTaskStringBuilderOutputHelper.ToString(); value.Free(); } return(result); }
// Token: 0x06000F53 RID: 3923 RVA: 0x00041F2C File Offset: 0x0004012C private void Open() { AmClusterHandle amClusterHandle = null; AmSystemManager instance = AmSystemManager.Instance; if (instance != null) { AmConfig config = instance.Config; if (config != null) { AmDagConfig dagConfig = config.DagConfig; if (dagConfig != null) { IAmCluster cluster = dagConfig.Cluster; if (cluster != null) { amClusterHandle = cluster.Handle; } } } } if (amClusterHandle == null || amClusterHandle.IsInvalid) { throw new AmClusterNotRunningException(); } using (IDistributedStoreKey clusterKey = DistributedStore.Instance.GetClusterKey(amClusterHandle, null, null, DxStoreKeyAccessMode.Write, false)) { string keyName = string.Format("{0}\\SafetyNet2\\{1}", "ExchangeActiveManager", this.m_dbGuidStr); this.m_dbRegKeyHandle = clusterKey.OpenKey(keyName, DxStoreKeyAccessMode.CreateIfNotExist, false, null); } }
public static void ValidateIpv4Addresses(IAmCluster cluster, IPAddress[] ipv4Addresses) { for (int i = 0; i < ipv4Addresses.Length - 1; i++) { for (int j = i + 1; j < ipv4Addresses.Length; j++) { if (object.Equals(ipv4Addresses[i], ipv4Addresses[j])) { throw new IPv4AddressesHasDuplicateEntries(ipv4Addresses[i].ToString()); } } } if (cluster != null) { IDictionary <IPAddress, AmClusterNetwork> dictionary = null; try { dictionary = AmClusterResourceHelper.GetIpv4StaticNetworkMap(cluster, ipv4Addresses); } finally { if (dictionary != null) { SharedHelper.DisposeObjectList <AmClusterNetwork>(dictionary.Values); } } } }
// Token: 0x060001CB RID: 459 RVA: 0x000086DD File Offset: 0x000068DD internal AmClusterNode(AmServerName nodeName, IAmCluster owningCluster, AmClusterNodeHandle nodeHandle) { this.m_disposeTracker = this.GetDisposeTracker(); this.Name = nodeName; this.OwningCluster = owningCluster; this.Handle = nodeHandle; }
protected virtual Dictionary <AmServerName, AmNodeState> GetAllClusterNodeStates(ITaskOutputHelper output) { Dictionary <AmServerName, AmNodeState> dictionary = new Dictionary <AmServerName, AmNodeState>(15); try { using (IAmCluster amCluster = ClusterFactory.Instance.Open()) { foreach (IAmClusterNode amClusterNode in amCluster.EnumerateNodes()) { using (amClusterNode) { AmNodeState state = amClusterNode.GetState(false); dictionary[amClusterNode.Name] = state; } } } } catch (ClusterException ex) { output.AppendLogMessage("GetAllClusterNodeStates() failed with error {0}", new object[] { ex.Message }); } return(dictionary); }
public static void MoveClusterGroupWithTimeout(AmServerName clusterNode, AmServerName destinationNode, TimeSpan timeout) { uint errorCode = 0U; bool flag = false; try { InvokeWithTimeout.Invoke(delegate() { using (IAmCluster amCluster = MockableCluster.Instance.OpenByName(clusterNode)) { using (IAmClusterGroup amClusterGroup = amCluster.FindCoreClusterGroup()) { if (!amClusterGroup.OwnerNode.Equals(destinationNode)) { amClusterGroup.MoveGroup(timeout, destinationNode); } } } }, timeout); } catch (TimeoutException) { errorCode = 258U; flag = true; } if (flag) { throw AmExceptionHelper.ConstructClusterApiException((int)errorCode, "MoveClusterGroup( dest={0}, timeout={1})", new object[] { destinationNode.NetbiosName, timeout }); } }
public static Exception Write(IAmCluster cluster, AmServerName srvName, AmClusterNodeNetworkStatus status) { Exception ex = null; try { using (AmClusterNodeStatusAccessor amClusterNodeStatusAccessor = new AmClusterNodeStatusAccessor(cluster, srvName, DxStoreKeyAccessMode.CreateIfNotExist)) { amClusterNodeStatusAccessor.Write(status); } } catch (SerializationException ex2) { ex = ex2; } catch (ClusterException ex3) { ex = ex3; } if (ex != null) { AmClusterNodeStatusAccessor.Tracer.TraceError <AmServerName, AmClusterNodeNetworkStatus, Exception>(0L, "AmClusterNodeNetworkStatus.Write({0},{1}) failed: {2}", srvName, status, ex); } return(ex); }
public static AmClusterNodeNetworkStatus Read(IAmCluster cluster, AmServerName srvName, out Exception ex) { ex = null; AmClusterNodeNetworkStatus amClusterNodeNetworkStatus = null; try { using (AmClusterNodeStatusAccessor amClusterNodeStatusAccessor = new AmClusterNodeStatusAccessor(cluster, srvName, DxStoreKeyAccessMode.Read)) { amClusterNodeNetworkStatus = amClusterNodeStatusAccessor.Read(); } } catch (SerializationException ex2) { ex = ex2; } catch (ClusterException ex3) { ex = ex3; } if (ex != null) { AmClusterNodeStatusAccessor.Tracer.TraceError <AmServerName, Exception>(0L, "AmClusterNodeNetworkStatus.Read({0}) failed: {1}", srvName, ex); } else if (amClusterNodeNetworkStatus == null) { AmClusterNodeStatusAccessor.Tracer.TraceError <AmServerName>(0L, "AmClusterNodeNetworkStatus.Read({0}) No status has yet been published", srvName); } return(amClusterNodeNetworkStatus); }
// Token: 0x060008B5 RID: 2229 RVA: 0x00029C34 File Offset: 0x00027E34 internal static void DestroyDagCluster(string clusterName, out string verboseLog) { HaTaskStringBuilderOutputHelper haTaskStringBuilderOutputHelper = new HaTaskStringBuilderOutputHelper("m.e.cluster.replay.dll!DestroyDagCluster"); ExTraceGlobals.ClusterTracer.TraceDebug <string>(0L, "Going to DestroyCluster( {0} ) on this machine.", clusterName); GCHandle value = GCHandle.Alloc(haTaskStringBuilderOutputHelper); Exception ex = null; try { haTaskStringBuilderOutputHelper.LastException = null; haTaskStringBuilderOutputHelper.MaxPercentageDuringCallback = 0; using (IAmCluster amCluster = ClusterFactory.Instance.Open()) { amCluster.DestroyExchangeCluster(haTaskStringBuilderOutputHelper, GCHandle.ToIntPtr(value), out ex, true); } if (ex != null) { haTaskStringBuilderOutputHelper.WriteErrorSimple(ex); } } catch (LocalizedException exception) { DagHelper.ThrowDagTaskOperationWrapper(exception); } finally { verboseLog = haTaskStringBuilderOutputHelper.ToString(); value.Free(); } }
// Token: 0x06000449 RID: 1097 RVA: 0x00016D00 File Offset: 0x00014F00 internal AmPersistentClusdbState(IAmCluster cluster, string keyName) { using (IDistributedStoreKey clusterKey = DistributedStore.Instance.GetClusterKey(cluster.Handle, null, null, DxStoreKeyAccessMode.Write, false)) { string keyName2 = "ExchangeActiveManager\\" + keyName; this.m_regHandle = clusterKey.OpenKey(keyName2, DxStoreKeyAccessMode.CreateIfNotExist, false, null); } }
internal static void SetDagNetworkConfig(SetDagNetworkConfigRequest configChange) { NetworkManager.RunRpcOperation("SetDagNetworkConfig", delegate(object param0, EventArgs param1) { NetworkManager manager = NetworkManager.GetManager(); if (manager == null) { throw new DagNetworkManagementException(ReplayStrings.NetworkManagerInitError); } lock (manager.m_mapRefreshLock) { using (IAmCluster amCluster = ClusterFactory.Instance.Open()) { using (DagConfigurationStore dagConfigurationStore = new DagConfigurationStore()) { dagConfigurationStore.Open(); PersistentDagNetworkConfig persistentDagNetworkConfig = dagConfigurationStore.LoadNetworkConfig(); if (persistentDagNetworkConfig == null) { persistentDagNetworkConfig = new PersistentDagNetworkConfig(); } else { string text = persistentDagNetworkConfig.Serialize(); ReplayEventLogConstants.Tuple_DagNetworkConfigOld.LogEvent(DateTime.UtcNow.ToString(), new object[] { text }); } if (configChange.SetPort) { persistentDagNetworkConfig.ReplicationPort = configChange.ReplicationPort; manager.ReplicationPort = configChange.ReplicationPort; } manager.NetworkCompression = configChange.NetworkCompression; persistentDagNetworkConfig.NetworkCompression = configChange.NetworkCompression; manager.NetworkEncryption = configChange.NetworkEncryption; persistentDagNetworkConfig.NetworkEncryption = configChange.NetworkEncryption; manager.ManualDagNetworkConfiguration = configChange.ManualDagNetworkConfiguration; persistentDagNetworkConfig.ManualDagNetworkConfiguration = configChange.ManualDagNetworkConfiguration; if (configChange.DiscoverNetworks) { NetworkDiscovery networkDiscovery = new NetworkDiscovery(); networkDiscovery.LoadClusterObjects(amCluster); networkDiscovery.DetermineDnsStatus(); networkDiscovery.AggregateNetworks(true); ExchangeNetworkMap exchangeNetworkMap = new ExchangeNetworkMap(manager); exchangeNetworkMap.Load(networkDiscovery); persistentDagNetworkConfig = exchangeNetworkMap.BuildPersistentDagNetworkConfig(); } manager.UpdateNetworkConfig(persistentDagNetworkConfig); } } } }); }
public AmClusterNodeStatusAccessor(IAmCluster cluster, AmServerName nodeName, DxStoreKeyAccessMode mode = DxStoreKeyAccessMode.Read) { this.ServerName = nodeName; string keyName = string.Format("{0}\\{1}", "ExchangeActiveManager\\NodeState", nodeName.NetbiosName); using (IDistributedStoreKey clusterKey = DistributedStore.Instance.GetClusterKey(cluster.Handle, null, null, mode, false)) { this.distributedStoreKey = clusterKey.OpenKey(keyName, mode, false, null); } }
// Token: 0x060008AF RID: 2223 RVA: 0x00029954 File Offset: 0x00027B54 internal static bool IsQuorumTypeFileShareWitness(IAmCluster cluster) { using (AmClusterResource amClusterResource = cluster.OpenQuorumResource()) { if (amClusterResource != null && amClusterResource.GetTypeName() == "File Share Witness") { return(true); } } return(false); }
// 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 void ProcessNicEvent(AmClusterEventInfo cei) { Dictionary <string, AmNetworkMonitor.Nic> nicTable = this.m_nicTable; IAmCluster cluster = this.GetCluster(); if (nicTable == null || cluster == null) { AmNetworkMonitor.Tracer.TraceError(0L, "Not yet initialized. Ignoring event"); return; } AmNetworkMonitor.Nic nic; if (!nicTable.TryGetValue(cei.ObjectName, out nic)) { this.TriggerClusterRefresh("nic not found"); return; } AmNetInterfaceState nicState = this.GetNicState(cei.ObjectName); switch (nicState) { case AmNetInterfaceState.Unavailable: AmNetworkMonitor.Tracer.TraceError <string, AmNetInterfaceState>(0L, "MAPI NIC '{0}' is {1}.", cei.ObjectName, nicState); return; case AmNetInterfaceState.Failed: case AmNetInterfaceState.Unreachable: { AmNetworkMonitor.Tracer.TraceError <string, AmNetInterfaceState>(0L, "MAPI NIC '{0}' is {1}.", cei.ObjectName, nicState); AmEvtMapiNetworkFailure amEvtMapiNetworkFailure = new AmEvtMapiNetworkFailure(nic.Node.Name); amEvtMapiNetworkFailure.Notify(true); return; } case AmNetInterfaceState.Up: AmNetworkMonitor.Tracer.TraceDebug <string>(0L, "MAPI NIC '{0}' is Up.", cei.ObjectName); if (nic.Node.Name.IsLocalComputerName) { AmClusterNodeNetworkStatus amClusterNodeNetworkStatus = new AmClusterNodeNetworkStatus(); Exception ex = AmClusterNodeStatusAccessor.Write(cluster, nic.Node.Name, amClusterNodeNetworkStatus); if (ex != null) { ReplayCrimsonEvents.AmNodeStatusUpdateFailed.Log <string, string>(amClusterNodeNetworkStatus.ToString(), ex.Message); return; } } break; default: AmNetworkMonitor.Tracer.TraceError <AmNetInterfaceState, string>(0L, "Unexpected NIC state {0} for {1}", nicState, cei.ObjectName); break; } }
// Token: 0x060008B4 RID: 2228 RVA: 0x00029BAC File Offset: 0x00027DAC internal static void FollowBestPractices(ITaskOutputHelper output, IAmCluster cluster) { if (string.Empty != cluster.CnoName) { using (IAmClusterGroup amClusterGroup = cluster.FindCoreClusterGroup()) { using (IAmClusterResource amClusterResource = amClusterGroup.FindResourceByTypeName("Network Name")) { output.AppendLogMessage("Setting the DNS TTL to 300", new object[0]); amClusterResource.SetPrivateProperty <int>("HostRecordTTL", 300); } } } }
public static bool MovePrimaryActiveManagerRole(string CurrentPrimaryName) { AmServerName serverName = new AmServerName(CurrentPrimaryName); bool result; using (IAmCluster amCluster = ClusterFactory.Instance.OpenByName(serverName)) { using (IAmClusterGroup amClusterGroup = amCluster.FindCoreClusterGroup()) { string text; result = amClusterGroup.MoveGroupToReplayEnabledNode((string targetNode) => AmHelper.IsReplayRunning(targetNode), "Network Name", new TimeSpan(0, 3, 0), out text); } } return(result); }
public void LoadClusterObjects(IAmCluster cluster) { IEnumerable <IAmClusterNode> enumerable = cluster.EnumerateNodes(); try { foreach (IAmClusterNode clusNode in enumerable) { ClusterNode item = new ClusterNode(clusNode); this.m_clusterNodes.Add(item); } } finally { foreach (IAmClusterNode amClusterNode in enumerable) { using (amClusterNode) { } } } IEnumerable <AmClusterNetwork> enumerable2 = cluster.EnumerateNetworks(); try { foreach (AmClusterNetwork clusNet in enumerable2) { ClusterNetwork item2 = new ClusterNetwork(clusNet); this.m_clusterNets.Add(item2); } } finally { foreach (AmClusterNetwork amClusterNetwork in enumerable2) { using (amClusterNetwork) { } } } int testWithFakeNetwork = RegistryParameters.GetTestWithFakeNetwork(); if (testWithFakeNetwork > 0) { this.AddFakeNetworkForTesting(testWithFakeNetwork); } this.LinkNicsToNodes(); }
// Token: 0x060000E3 RID: 227 RVA: 0x000066B4 File Offset: 0x000048B4 public void Start(IAmCluster cluster) { if (this.m_cem == null || !this.m_cem.IsMonitoring || !object.ReferenceEquals(this.Cluster, cluster)) { AmClusterMonitor.Tracer.TraceDebug(0L, "Starting AmClusterEventManager"); this.Cluster = cluster; AmSystemManager.Instance.NetworkMonitor.UseCluster(this.Cluster); AmSystemManager.Instance.NetworkMonitor.RefreshMapiNetwork(); if (this.m_cem != null) { this.m_cem.Stop(); } this.m_cem = new AmClusterEventManager(this.Cluster); this.m_cem.Start(); } }
// Token: 0x060008B2 RID: 2226 RVA: 0x00029A88 File Offset: 0x00027C88 public static IEnumerable <AmServerName> EnumeratePausedNodes(IAmCluster cluster) { IList <AmServerName> list = new List <AmServerName>(8); foreach (IAmClusterNode amClusterNode in cluster.EnumerateNodes()) { using (amClusterNode) { if (amClusterNode.State == AmNodeState.Paused) { list.Add(amClusterNode.Name); } } } return(list); }
private AmNetInterfaceState GetNicState(string nicName) { AmNetInterfaceState result = AmNetInterfaceState.Unknown; IAmCluster cluster = this.GetCluster(); if (cluster != null) { Exception ex; result = cluster.GetNetInterfaceState(nicName, out ex); if (ex != null) { AmNetworkMonitor.Tracer.TraceError <string, Exception>(0L, "Failed to get state for nic '{0}': {1}", nicName, ex); this.TriggerClusterRefresh("GetNicState failed"); } } return(result); }
// Token: 0x060000E4 RID: 228 RVA: 0x00006750 File Offset: 0x00004950 public void Stop() { if (this.m_cem != null) { AmClusterMonitor.Tracer.TraceDebug(0L, "Stopping AmClusterEventManager"); this.m_cem.Stop(); this.m_cem = null; this.Cluster = null; if (AmSystemManager.Instance.NetworkMonitor != null) { AmSystemManager.Instance.NetworkMonitor.UseCluster(this.Cluster); return; } } else { AmClusterMonitor.Tracer.TraceDebug(0L, "Ignoring cluster event manager stop since it is not active"); } }
public static Dictionary <string, AmClusterNetwork> GetIpv6AutoCfgNetworkMap(IAmCluster cluster, string[] ipv6Networks) { Dictionary <string, AmClusterNetwork> dictionary = new Dictionary <string, AmClusterNetwork>(8); foreach (string text in ipv6Networks) { AmClusterNetwork amClusterNetwork = cluster.FindNetworkByName(text, IPVersion.IPv6); if (amClusterNetwork == null) { throw new FailedToFindNetwork(text); } if (!amClusterNetwork.SupportsIPv6AutoConfiguration()) { throw new RequestedNetworkIsNotIPv6Enabled(text); } dictionary[text] = amClusterNetwork; } return(dictionary); }
public static void ValidateIpv6Networks(IAmCluster cluster, string[] ipv6Networks) { for (int i = 0; i < ipv6Networks.Length - 1; i++) { for (int j = i + 1; j < ipv6Networks.Length; j++) { if (SharedHelper.StringIEquals(ipv6Networks[i], ipv6Networks[j])) { throw new IPv6NetworksHasDuplicateEntries(ipv6Networks[i]); } } } Dictionary <string, AmClusterNetwork> ipv6AutoCfgNetworkMap = AmClusterResourceHelper.GetIpv6AutoCfgNetworkMap(cluster, ipv6Networks); if (ipv6AutoCfgNetworkMap != null) { SharedHelper.DisposeObjectList <AmClusterNetwork>(ipv6AutoCfgNetworkMap.Values); } }
// Token: 0x060008B8 RID: 2232 RVA: 0x00029E34 File Offset: 0x00028034 private static void AddDagClusterNodeInternal(HaTaskStringBuilderOutputHelper output, AmServerName mailboxServerName, out string verboseLog) { try { Exception ex = null; output.AppendLogMessage("Opening a local AmCluster handle.", new object[0]); using (IAmCluster amCluster = ClusterFactory.Instance.Open()) { output.WriteProgressSimple(ReplayStrings.DagTaskAddingServerToDag(mailboxServerName.NetbiosName, amCluster.Name)); GCHandle value = GCHandle.Alloc(output); try { output.LastException = null; output.MaxPercentageDuringCallback = 0; amCluster.AddNodeToCluster(mailboxServerName, output, GCHandle.ToIntPtr(value), out ex, true); } finally { value.Free(); } } if (output.LastException != null) { output.WriteErrorSimple(output.LastException); } if (ex != null) { output.WriteErrorSimple(ex); } output.WriteProgressSimple(ReplayStrings.DagTaskJoinedNodeToCluster(mailboxServerName.NetbiosName)); } catch (LocalizedException exception) { DagHelper.ThrowDagTaskOperationWrapper(exception); } finally { verboseLog = output.ToString(); } }
// Token: 0x060008AD RID: 2221 RVA: 0x000296B0 File Offset: 0x000278B0 private static void SetFswSharePath(ITaskOutputHelper output, IAmCluster cluster, IAmClusterResource fsw, string fswShare) { try { fsw.OfflineResource(); fsw.SetPrivateProperty <string>("SharePath", fswShare); fsw.OnlineResource(); } catch (ClusterException ex) { Win32Exception ex2 = null; if (ex.TryGetTypedInnerException(out ex2)) { output.AppendLogMessage("SetFswSharePath() caught an AmClusterApiException with errorcode={0} and NativeErrorCode={1}. ex = {2}", new object[] { ex2.ErrorCode, ex2.NativeErrorCode, ex2 }); if (ex2.NativeErrorCode == 5) { string text = cluster.CnoName; if (text == string.Empty) { using (IAmClusterGroup amClusterGroup = cluster.FindCoreClusterGroup()) { if (amClusterGroup != null && amClusterGroup.OwnerNode != null) { text = amClusterGroup.OwnerNode.NetbiosName; } } } output.WriteErrorSimple(new DagTaskFswNeedsCnoPermissionException(fswShare, text)); } } throw; } }
private bool IsNodePubliclyUp(AmNetworkMonitor.Node node) { IAmCluster cluster = this.GetCluster(); if (cluster == null) { AmNetworkMonitor.Tracer.TraceError <AmServerName>(0L, "If cluster object is not valid, then assume node {0} is up", node.Name); return(true); } Exception ex; AmNodeState nodeState = cluster.GetNodeState(node.Name, out ex); if (ex != null) { return(false); } if (!AmClusterNode.IsNodeUp(nodeState)) { return(false); } AmClusterNodeNetworkStatus amClusterNodeNetworkStatus = AmClusterNodeStatusAccessor.Read(cluster, node.Name, out ex); return(amClusterNodeNetworkStatus == null || amClusterNodeNetworkStatus.HasADAccess); }
// 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: 0x0600043D RID: 1085 RVA: 0x000168A4 File Offset: 0x00014AA4 internal AmClusterDbState(IAmCluster cluster) { this.m_cluster = cluster; this.InitializeHandles(); }