private void DumpResourceIpAddress(AmClusterResource resource, string typeName)
{
this.m_indentlevel += 1U;
this.WriteLine("Address = [{0}]", new object[]
{
resource.GetPrivateProperty <string>("Address")
});
if (SharedHelper.StringIEquals(typeName, "IP Address"))
{
this.m_indentlevel += 1U;
this.WriteLine("EnableDhcp = [{0}]", new object[]
{
resource.GetPrivateProperty <int>("EnableDhcp")
});
this.m_indentlevel -= 1U;
}
string networkNameFromIpResource = AmClusterResourceHelper.GetNetworkNameFromIpResource(null, resource);
this.m_indentlevel += 1U;
this.WriteLine("Network = [{0}]", new object[]
{
networkNameFromIpResource
});
this.m_indentlevel -= 1U;
this.m_indentlevel -= 1U;
}
private void ReopenClusterIfNecessary()
{
if (this.m_removeNode)
{
this.m_clusDag.Dispose();
this.CheckServerDagAdSettings();
IEnumerable <AmServerName> enumerable = from server in this.m_serversInDag
where !SharedHelper.StringIEquals(server.Fqdn, this.m_mailboxAmServerName.Fqdn)
select new AmServerName(server.Fqdn);
try
{
IEnumerable <string> source = from serverName in enumerable
select serverName.NetbiosName;
this.m_output.AppendLogMessage("Reopening a handle to the cluster using the names [{0}].", new object[]
{
string.Join(", ", source.ToArray <string>())
});
this.m_clusDag = AmCluster.OpenByNames(enumerable);
}
catch (ClusterException)
{
this.m_output.WriteErrorSimple(new DagTaskClusteringMustBeInstalledAndRunningException(this.m_mailboxServerName));
}
}
}
public static List <string> GetServersWithServerRoleInSite(string serverName, ServerRole serverRole)
{
IADToplogyConfigurationSession iadtoplogyConfigurationSession = ADSessionFactory.CreateIgnoreInvalidRootOrgSession(true);
IADServer iadserver = null;
if (!string.IsNullOrEmpty(serverName))
{
if (!SharedHelper.StringIEquals(serverName, "localhost"))
{
goto IL_2F;
}
}
try
{
iadserver = iadtoplogyConfigurationSession.FindServerByName(Environment.MachineName);
goto IL_5A;
}
catch (LocalServerNotFoundException)
{
goto IL_5A;
}
IL_2F:
string nodeNameFromFqdn = MachineName.GetNodeNameFromFqdn(serverName);
iadserver = iadtoplogyConfigurationSession.FindServerByName(nodeNameFromFqdn);
string arg = "FindServerByName";
if (iadserver == null)
{
ExTraceGlobals.ReplayConfigurationTracer.TraceDebug <string, string>(0L, "GetServersWithServerRoleInSite: {0} didn't find any server for {1}", arg, serverName);
}
IL_5A:
return(ReplayConfiguration.GetServersWithServerRoleInSiteByServer(iadserver, serverRole));
}
internal void SetCrossSiteFlag(IADServer activeServer, IADServer passiveServer)
{
this.m_isCrossSite = false;
if (activeServer == null)
{
PassiveBlockMode.Tracer.TraceError((long)this.GetHashCode(), "Unable to determine the cross-site flag, because active server AD object is null.");
return;
}
if (passiveServer == null)
{
PassiveBlockMode.Tracer.TraceError((long)this.GetHashCode(), "Unable to determine the cross-site flag, because passive server AD object is null.");
return;
}
if (passiveServer.ServerSite == null && activeServer.ServerSite != null)
{
PassiveBlockMode.Tracer.TraceDebug <string>((long)this.GetHashCode(), "This block mode client is cross-site because passive server has no site and active server is in site '{0}'.", activeServer.ServerSite.Name);
this.m_isCrossSite = true;
return;
}
if (passiveServer.ServerSite != null && activeServer.ServerSite == null)
{
PassiveBlockMode.Tracer.TraceDebug <string>((long)this.GetHashCode(), "This block mode client is cross-site because active server has no site and passive server is in site '{0}'.", passiveServer.ServerSite.Name);
this.m_isCrossSite = true;
return;
}
if (!SharedHelper.StringIEquals(activeServer.ServerSite.Name, passiveServer.ServerSite.Name))
{
PassiveBlockMode.Tracer.TraceDebug <string, string>((long)this.GetHashCode(), "This block mode client is cross-site. Active site is '{0}' and passive site is '{1}'.", activeServer.ServerSite.Name, passiveServer.ServerSite.Name);
this.m_isCrossSite = true;
}
}
// Token: 0x06001D3C RID: 7484 RVA: 0x00083D00 File Offset: 0x00081F00
protected override void CheckForGaps(long fromNumber)
{
this.m_countdownToGapTest = 6L;
string text = Path.Combine(this.FromDir, base.GetFilenameFromGenerationNumber(fromNumber));
string searchPattern = this.Config.LogFilePrefix + "*." + this.Config.LogExtension;
string[] files = Directory.GetFiles(this.FromDir, searchPattern);
if (files.Length > 0)
{
string text2 = files[0];
if (SharedHelper.StringIEquals(this.Config.LogFilePrefix, Path.GetFileNameWithoutExtension(text2)))
{
if (files.Length == 1)
{
return;
}
text2 = files[1];
}
if (File.Exists(text))
{
ExTraceGlobals.LogInspectorTracer.TraceError <long>((long)this.GetHashCode(), "CheckForGaps() shouldn't be called since fromNumber {0} generation is there.", fromNumber);
return;
}
ExTraceGlobals.LogInspectorTracer.TraceError <string>((long)this.GetHashCode(), "Gap in log file generations after file {0}", text);
string text3 = string.Format("LogGap:'{0}' Length={1}", text2, files.Length);
this.m_setBroken.SetBroken(FailureTag.AlertOnly, ReplayEventLogConstants.Tuple_LogInspectorFailed, new string[]
{
text,
text3
});
}
}
// Token: 0x06001170 RID: 4464 RVA: 0x00047134 File Offset: 0x00045334
public void Validate(Guid dbGuid, long pageSizeBytes, string patchFile)
{
bool flag = true;
if (flag && (this.Version.Major != EseDatabasePatchState.VersionNumber.Major || this.Version.Minor > EseDatabasePatchState.VersionNumber.Minor))
{
EseDatabasePatchState.Tracer.TraceError <Version, Version>((long)this.GetHashCode(), "Patch file validation failed! Version number is not supported. Actual: {0}; Supported: {1}", this.Version, EseDatabasePatchState.VersionNumber);
flag = false;
}
if (flag && !SharedHelper.StringIEquals(this.ServerName, Environment.MachineName))
{
EseDatabasePatchState.Tracer.TraceError <string, string>((long)this.GetHashCode(), "Patch file validation failed! Actual ServerName: {0}; Expected: {1}", this.ServerName, Environment.MachineName);
flag = false;
}
if (flag && this.PageSizeBytes != pageSizeBytes)
{
EseDatabasePatchState.Tracer.TraceError <long, long>((long)this.GetHashCode(), "Patch file validation failed! Actual PageSizeBytes: {0}; Expected: {1}", this.PageSizeBytes, pageSizeBytes);
flag = false;
}
if (flag && !dbGuid.Equals(this.DatabaseGuid))
{
EseDatabasePatchState.Tracer.TraceError <Guid, Guid>((long)this.GetHashCode(), "Patch file validation failed! Actual DatabaseGuid: {0}; Expected: {1}", this.DatabaseGuid, dbGuid);
flag = false;
}
if (!flag)
{
throw new PagePatchInvalidFileException(patchFile);
}
}
internal static ADObjectId FindServerAdObjectIdInStampGroup(StampGroup stampGroup, AmServerName serverName)
{
foreach (ADObjectId adobjectId in stampGroup.Servers)
{
if (SharedHelper.StringIEquals(adobjectId.Name, serverName.NetbiosName))
{
return(adobjectId);
}
}
return(null);
}
private bool DoesClusterNetworkContainNode(ClusterNetwork clusNet, string nodeName)
{
foreach (ClusterNic clusterNic in clusNet.Nics)
{
if (SharedHelper.StringIEquals(nodeName, clusterNic.NodeName))
{
return(true);
}
}
return(false);
}
public bool IsClusterGroup()
{
using (IAmClusterGroup amClusterGroup = this.OwningCluster.FindCoreClusterGroup())
{
if (amClusterGroup != null && SharedHelper.StringIEquals(amClusterGroup.Name, this.Name))
{
return(true);
}
}
return(false);
}
public ClusterNode FindNode(string nodeName)
{
foreach (ClusterNode clusterNode in this.Nodes)
{
if (SharedHelper.StringIEquals(nodeName, clusterNode.Name.NetbiosName))
{
return(clusterNode);
}
}
return(null);
}
private bool IsNodeMemberOfDag(AmServerName node, IADDatabaseAvailabilityGroup dag)
{
foreach (ADObjectId adobjectId in dag.Servers)
{
if (SharedHelper.StringIEquals(node.NetbiosName, adobjectId.Name))
{
return(true);
}
}
return(false);
}
// Token: 0x06000111 RID: 273 RVA: 0x00007432 File Offset: 0x00005632
private ServiceStartMode MapStartMode(string mode)
{
if (SharedHelper.StringIEquals(mode, "Manual"))
{
return(ServiceStartMode.Manual);
}
if (SharedHelper.StringIEquals(mode, "Disabled"))
{
return(ServiceStartMode.Disabled);
}
return(ServiceStartMode.Automatic);
}
internal static IEnumerable <AmClusterResource> GetIpResourcesFromNetName(AmClusterGroup resGroup, AmClusterResource netName)
{
if (!SharedHelper.StringIEquals(netName.GetTypeName(), "Network Name"))
{
throw new ArgumentException("GetIpResourceFromNetName() needs a NetName resource.");
}
List <AmClusterResource> list = new List <AmClusterResource>(8);
list.AddRange(resGroup.EnumerateResourcesOfType("IP Address"));
list.AddRange(resGroup.EnumerateResourcesOfType("IPv6 Address"));
return(list);
}
// Token: 0x06001986 RID: 6534 RVA: 0x0006AA54 File Offset: 0x00068C54
protected SeederInstanceBase(RpcSeederArgs rpcArgs, ConfigurationArgs configArgs)
{
this.SeederArgs = rpcArgs;
this.ConfigArgs = configArgs;
this.m_seederStatus = new RpcSeederStatus();
ExTraceGlobals.SeederServerTracer.TraceDebug <string, string>((long)this.GetHashCode(), "SeederInstanceBase constructed with the following arguments: {0}; {1}", this.SeederArgs.ToString(), this.ConfigArgs.ToString());
this.InitializePerfCounters();
this.m_completedTimeUtc = DateTime.MaxValue;
if (!string.IsNullOrEmpty(rpcArgs.SourceMachineName) && !SharedHelper.StringIEquals(rpcArgs.SourceMachineName, configArgs.SourceMachine))
{
this.m_fPassiveSeeding = true;
}
}
public static bool IsAutoActivationAllowed(IADServer sourceServer, IADServer targetServer, out LocalizedString error)
{
string name = sourceServer.Name;
string name2 = targetServer.Name;
error = LocalizedString.Empty;
if (SharedHelper.StringIEquals(name, name2))
{
AmTrace.Debug("IsAutoActivationAllowed: Skipping check since source == target. TargetServer: {0}", new object[]
{
name2
});
return(true);
}
switch (targetServer.DatabaseCopyAutoActivationPolicy)
{
case DatabaseCopyAutoActivationPolicyType.Unrestricted:
return(true);
case DatabaseCopyAutoActivationPolicyType.IntrasiteOnly:
if (!targetServer.ServerSite.Equals(sourceServer.ServerSite))
{
AmTrace.Debug("IsAutoActivationAllowed: Rejecting server '{0}' (Site={1}) because it is in a different site from source server '{2}' (Site={2}). ", new object[]
{
name2,
targetServer.ServerSite.Name,
name,
sourceServer.ServerSite.Name
});
error = ReplayStrings.AmBcsTargetServerActivationIntraSite(targetServer.Fqdn, sourceServer.Fqdn, targetServer.ServerSite.Name, sourceServer.ServerSite.Name);
return(false);
}
return(true);
case DatabaseCopyAutoActivationPolicyType.Blocked:
AmTrace.Debug("IsAutoActivationAllowed: Rejecting server '{0}' because it is activation policy Blocked.", new object[]
{
name2
});
error = ReplayStrings.AmBcsTargetServerActivationBlocked(targetServer.Fqdn);
return(false);
default:
DiagCore.RetailAssert(false, "Unhandled case for DatabaseCopyAutoActivationPolicyType: {0}", new object[]
{
targetServer.DatabaseCopyAutoActivationPolicy
});
return(false);
}
}
public IEnumerable <AmClusterResource> EnumerateResourcesOfType(string resourceType)
{
IEnumerable <AmClusterResource> enumerable = this.EnumerateResources();
List <AmClusterResource> list = (from resource in enumerable
where SharedHelper.StringIEquals(resource.GetTypeName(), resourceType)
select resource).ToList <AmClusterResource>();
IEnumerable <AmClusterResource> enumerable2 = enumerable.Except(list);
foreach (AmClusterResource amClusterResource in enumerable2)
{
amClusterResource.Dispose();
}
return(list);
}
// Token: 0x06000F2A RID: 3882 RVA: 0x0004059C File Offset: 0x0003E79C
private bool IsPropertyChanged <T>(T oldValue, T newValue)
{
if (oldValue is string)
{
return(!SharedHelper.StringIEquals(oldValue as string, newValue as string));
}
if (oldValue is List <string> )
{
List <string> first = oldValue as List <string>;
List <string> second = newValue as List <string>;
return(!first.SequenceEqual(second, StringComparer.OrdinalIgnoreCase));
}
return(!oldValue.Equals(newValue));
}
// Token: 0x060001D5 RID: 469 RVA: 0x000087E4 File Offset: 0x000069E4
public bool IsNetworkVisible(string networkStr1, out AmClusterNetInterface networkInterface)
{
networkInterface = null;
foreach (AmClusterNetInterface amClusterNetInterface in this.EnumerateNetInterfaces())
{
string networkName = amClusterNetInterface.GetNetworkName();
if (SharedHelper.StringIEquals(networkStr1, networkName))
{
networkInterface = amClusterNetInterface;
return(true);
}
amClusterNetInterface.Dispose();
}
return(false);
}
public IAmClusterResource FindResourceByTypeName(string desiredTypeName)
{
AmClusterResource amClusterResource = null;
foreach (AmClusterResource amClusterResource2 in this.EnumerateResources())
{
if (amClusterResource != null || !SharedHelper.StringIEquals(amClusterResource2.GetTypeName(), desiredTypeName))
{
amClusterResource2.Dispose();
}
else
{
amClusterResource = amClusterResource2;
}
}
return(amClusterResource);
}
// Token: 0x06000F4F RID: 3919 RVA: 0x00041E64 File Offset: 0x00040064
public SafetyNetInfo ReadRequestInfo(SafetyNetRequestKey requestKey, SafetyNetInfo prevInfo)
{
this.EnsureOpen();
string valueName = requestKey.ToString();
string text = this.ReadString(valueName);
SafetyNetInfo safetyNetInfo = null;
if (prevInfo != null && SharedHelper.StringIEquals(text, prevInfo.GetSerializedForm()))
{
safetyNetInfo = prevInfo;
}
if (safetyNetInfo == null && !string.IsNullOrEmpty(text))
{
safetyNetInfo = SafetyNetInfo.Deserialize(this.m_dbName, text, ExTraceGlobals.DumpsterTracer, true);
}
return(safetyNetInfo);
}
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);
}
}
public CiFilesSeederInstance(RpcSeederArgs rpcArgs, ConfigurationArgs configArgs) : base(rpcArgs, configArgs)
{
ITopologyConfigurationSession adSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.FullyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 73, ".ctor", "f:\\15.00.1497\\sources\\dev\\cluster\\src\\Replay\\seeder\\cifileseederinstance.cs");
this.targetServer = CiFilesSeederInstance.GetLocalServer(adSession);
if (!string.IsNullOrEmpty(rpcArgs.SourceMachineName) && !SharedHelper.StringIEquals(rpcArgs.SourceMachineName, configArgs.SourceMachine))
{
this.m_fPassiveSeeding = true;
}
Server server = this.m_fPassiveSeeding ? CiFilesSeederInstance.GetServerByName(adSession, rpcArgs.SourceMachineName) : CiFilesSeederInstance.GetServerByName(adSession, configArgs.SourceMachine);
string indexSystemName = FastIndexVersion.GetIndexSystemName(this.ConfigArgs.IdentityGuid);
this.targetIndexSeeder = new IndexSeeder(indexSystemName);
this.sourceSeederProvider = new CiFileSeederProvider(server.Fqdn, this.targetServer.Fqdn, this.ConfigArgs.IdentityGuid);
this.sourceSeederProvider.NetworkName = this.SeederArgs.NetworkId;
this.sourceSeederProvider.CompressOverride = this.SeederArgs.CompressOverride;
this.sourceSeederProvider.EncryptOverride = this.SeederArgs.EncryptOverride;
base.ReadSeedTestHook();
ExTraceGlobals.SeederServerTracer.TraceDebug <string, string>((long)this.GetHashCode(), "CiFilesSeederInstance constructed with the following arguments: {0}; {1}", this.SeederArgs.ToString(), this.ConfigArgs.ToString());
}
// Token: 0x06000136 RID: 310 RVA: 0x00007620 File Offset: 0x00005820
internal static AmConfigChangedFlags CheckForChanges(AmConfig left, AmConfig right)
{
AmConfigChangedFlags amConfigChangedFlags = AmConfigChangedFlags.None;
if (left.Role != right.Role)
{
amConfigChangedFlags |= AmConfigChangedFlags.Role;
}
if (!object.ReferenceEquals(left.DbState, right.DbState))
{
amConfigChangedFlags |= AmConfigChangedFlags.DbState;
}
if (!SharedHelper.StringIEquals(left.LastError, right.LastError))
{
amConfigChangedFlags |= AmConfigChangedFlags.LastError;
}
if ((left.DagConfig == null && right.DagConfig != null) || (left.DagConfig != null && right.DagConfig == null))
{
amConfigChangedFlags |= AmConfigChangedFlags.DagConfig;
}
if (left.DagConfig != null && right.DagConfig != null)
{
if (!left.DagConfig.Id.Equals(right.DagConfig.Id))
{
amConfigChangedFlags |= AmConfigChangedFlags.DagId;
}
if (!AmServerName.IsArrayEquals(left.DagConfig.MemberServers, right.DagConfig.MemberServers))
{
amConfigChangedFlags |= AmConfigChangedFlags.MemberServers;
}
if (!AmServerName.IsEqual(left.DagConfig.CurrentPAM, right.DagConfig.CurrentPAM))
{
amConfigChangedFlags |= AmConfigChangedFlags.CurrentPAM;
}
if (!object.ReferenceEquals(left.DagConfig.Cluster, right.DagConfig.Cluster))
{
amConfigChangedFlags |= AmConfigChangedFlags.Cluster;
}
}
return(amConfigChangedFlags);
}
private bool ShouldUpgradeService()
{
RegistryKey registryKey = Registry.LocalMachine.OpenSubKey("system\\currentcontrolset\\services\\msexchangerepl");
bool result;
if (registryKey == null)
{
result = true;
}
else
{
using (registryKey)
{
string input = (string)registryKey.GetValue("imagepath");
string str = Regex.Replace(input, "\"", "");
string str2 = base.ServiceInstallContext.Parameters["assemblypath"];
result = !SharedHelper.StringIEquals(str, str2);
}
}
return(result);
}
private void DumpResource(AmClusterResource resource)
{
string typeName = resource.GetTypeName();
List <string> list = new List <string>(resource.EnumeratePossibleOwnerNames());
string text = string.Join(",", list.ToArray());
this.WriteLine("Resource: {0} [{1}, type = {2}, PossibleOwners = {3} ]", new object[]
{
resource.Name,
resource.GetState(),
typeName,
text
});
if (SharedHelper.StringIEquals(typeName, "IP Address") || SharedHelper.StringIEquals(typeName, "IPv6 Address"))
{
this.DumpResourceIpAddress(resource, typeName);
return;
}
if (SharedHelper.StringIEquals(typeName, "Network Name"))
{
this.DumpResourceNetName(resource);
}
}
public void SetCopyProperty(Guid dbGuid, string propName, string propVal)
{
char[] separator = new char[]
{
'.'
};
string[] array = propName.Split(separator, 2);
if (array.Length > 1)
{
if (SharedHelper.StringIEquals(array[0], "MonitoredDatabase"))
{
MonitoredDatabase.SetCopyProperty(dbGuid, array[1], propVal);
return;
}
if (SharedHelper.StringIEquals(array[0], "LogCopier"))
{
LogCopier.SetCopyProperty(dbGuid, array[1], propVal);
return;
}
}
string message = string.Format("SetCopyProperty doesn't recognize '{0}'", propName);
throw new ArgumentException(message);
}
// Token: 0x0600032D RID: 813 RVA: 0x0001219C File Offset: 0x0001039C
private void Persist()
{
AmLastKnownConfigSerializable amLastKnownConfigSerializable = new AmLastKnownConfigSerializable();
amLastKnownConfigSerializable.Role = (int)this.Role;
amLastKnownConfigSerializable.AuthoritativeServer = this.AuthoritativeServer.Fqdn;
amLastKnownConfigSerializable.Members = (from server in this.Members
select server.Fqdn).ToArray <string>();
string text = string.Empty;
try
{
text = SerializationUtil.ObjectToXml(amLastKnownConfigSerializable);
if (!SharedHelper.StringIEquals(text, this.m_prevObjectXml))
{
this.SaveToRegistry(text);
this.m_prevObjectXml = text;
}
}
catch (Exception ex)
{
ReplayCrimsonEvents.LastKnownGoodConfigSerializationError.Log <string, string>("Serialize", ex.ToString());
}
}
private void PreventMoveOfActiveSeedingSource(AmServerName server, Database[] databases)
{
if (this.SkipActiveCopyChecks)
{
TaskLogger.Trace("PreventMoveOfActiveSeedingSource: Check skipped because -SkipActiveCopyChecks flag is specified.", new object[0]);
return;
}
Exception ex = null;
RpcDatabaseCopyStatus2[] array = null;
try
{
Guid[] array2 = null;
if (databases != null && databases.Length > 0)
{
array2 = new Guid[databases.Length];
for (int i = 0; i < databases.Length; i++)
{
array2[i] = databases[i].Guid;
}
}
array = ReplayRpcClientHelper.GetCopyStatus(server.Fqdn, RpcGetDatabaseCopyStatusFlags2.ReadThrough, array2);
}
catch (TaskServerTransientException ex2)
{
ex = ex2;
}
catch (TaskServerException ex3)
{
ex = ex3;
}
if (ex != null)
{
TaskLogger.Trace("PreventMoveOfActiveSeedingSource: Check failed because of exception: {2}", new object[]
{
ex
});
base.WriteError(new ErrorMoveUnableToGetCopyStatusException(server.NetbiosName, ex.Message), ErrorCategory.InvalidOperation, server.Fqdn);
}
foreach (RpcDatabaseCopyStatus2 rpcDatabaseCopyStatus in array)
{
if (SharedHelper.StringIEquals(rpcDatabaseCopyStatus.ActiveDatabaseCopy, server.NetbiosName) && rpcDatabaseCopyStatus.SeedingSource)
{
if (!rpcDatabaseCopyStatus.SeedingSourceForDB)
{
if (rpcDatabaseCopyStatus.SeedingSourceForDB || rpcDatabaseCopyStatus.SeedingSourceForCI)
{
goto IL_1B6;
}
}
try
{
IADDatabase iaddatabase = AmHelper.FindDatabaseByGuid(rpcDatabaseCopyStatus.DBGuid);
TaskLogger.Trace("PreventMoveOfActiveSeedingSource: Check failed for {0}\\{1} because it is seeding source.", new object[]
{
iaddatabase.Name,
rpcDatabaseCopyStatus.MailboxServer
});
base.WriteError(new ErrorMoveActiveCopyIsSeedingSourceException(iaddatabase.Name, rpcDatabaseCopyStatus.MailboxServer), ErrorCategory.InvalidOperation, iaddatabase.Identity);
}
catch (AmDatabaseNotFoundException ex4)
{
TaskLogger.Trace("PreventMoveOfActiveSeedingSource: Check failed for '{0}' because it is not found in AD. Error: {1}", new object[]
{
rpcDatabaseCopyStatus.DBGuid,
ex4.Message
});
base.WriteError(new ErrorMoveActiveCopyNotFoundException(rpcDatabaseCopyStatus.DBGuid, ex4.Message), ErrorCategory.InvalidOperation, rpcDatabaseCopyStatus.DBGuid);
}
}
IL_1B6 :;
}
}
public bool Equals(AmBcsServerFailureLogger.AmBcsCheckInfo other)
{
return(this.Type == other.Type && SharedHelper.StringIEquals(this.CheckName, other.CheckName));
}
private void ReportFailureInternal(AmServerName server, AmBcsServerFailureLogger.AmBcsCheckInfo checkInfo, string errorMessage, bool overwriteAllowed, ReplayCrimsonEvent evt, params object[] evtArgs)
{
OrderedDictionary orderedDictionary;
if (this.m_failureTable.ContainsKey(server))
{
orderedDictionary = this.m_failureTable[server];
}
else
{
orderedDictionary = new OrderedDictionary(10);
this.m_failureTable.Add(server, orderedDictionary);
}
string str;
bool flag = !this.TryGetErrorFromCheckTable(orderedDictionary, checkInfo, out str) || (overwriteAllowed && !SharedHelper.StringIEquals(str, errorMessage));
if (flag)
{
this.AddErrorIntoCheckTable(orderedDictionary, checkInfo, errorMessage);
if (this.IsEventLoggingEnabled)
{
evt.LogGeneric(evtArgs);
return;
}
}
else
{
AmTrace.Debug("BCS: Failure for server '{0}' and check [{1}] has already been recorded. Suppressing raising another event.", new object[]
{
server,
checkInfo
});
}
}