internal RpcDatabaseCopyStatus2 GetCopyStatus(RpcGetDatabaseCopyStatusFlags2 flags)
{
if ((flags & RpcGetDatabaseCopyStatusFlags2.ReadThrough) == RpcGetDatabaseCopyStatusFlags2.None)
{
return(this.GetCachedCopyStatus(flags));
}
RpcDatabaseCopyStatus2 copyStatusWithTimeout = this.GetCopyStatusWithTimeout(flags);
CopyStatusServerCachedEntry copyStatusServerCachedEntry = this.UpdateCachedCopyStatus(copyStatusWithTimeout);
return(copyStatusServerCachedEntry.CopyStatus);
}
private static RpcGetDatabaseCopyStatusFlags ConvertToLegacyCopyStatusFlags(RpcGetDatabaseCopyStatusFlags2 newFlags)
{
RpcGetDatabaseCopyStatusFlags rpcGetDatabaseCopyStatusFlags = RpcGetDatabaseCopyStatusFlags.None;
rpcGetDatabaseCopyStatusFlags |= RpcGetDatabaseCopyStatusFlags.CollectConnectionStatus;
rpcGetDatabaseCopyStatusFlags |= RpcGetDatabaseCopyStatusFlags.CollectExtendedErrorInfo;
if ((newFlags & RpcGetDatabaseCopyStatusFlags2.ReadThrough) == RpcGetDatabaseCopyStatusFlags2.None)
{
rpcGetDatabaseCopyStatusFlags |= RpcGetDatabaseCopyStatusFlags.UseServerSideCaching;
}
return(rpcGetDatabaseCopyStatusFlags);
}
public RpcDatabaseCopyStatus2[] GetCopyStatus(string serverName, RpcGetDatabaseCopyStatusFlags2 collectionFlags2, Guid[] dbGuids, int timeoutMs)
{
if (dbGuids == null || dbGuids.Length == 0)
{
dbGuids = new Guid[]
{
Guid.Empty
};
}
RpcDatabaseCopyStatus2[] statusResults = null;
ReplayRpcClientWrapper.RunRpcOperation(serverName, null, timeoutMs, TasksRpcExceptionWrapper.Instance, delegate(ReplayRpcClient rpcClient)
{
RpcErrorExceptionInfo result;
try
{
if (ReplayRpcVersionControl.IsGetCopyStatusEx4RpcSupported(ReplayRpcClientWrapper.GetServerVersion(serverName)))
{
ExTraceGlobals.ReplayServiceRpcTracer.TraceDebug <string>(0L, "GetCopyStatus(): Now making RpccGetCopyStatusEx4() RPC to server {0}.", serverName);
RpcErrorExceptionInfo rpcErrorExceptionInfo = rpcClient.RpccGetCopyStatusEx4(collectionFlags2, dbGuids, ref statusResults);
if (!rpcErrorExceptionInfo.IsFailed())
{
ReplayRpcClientWrapper.DeserializeExtendedErrorInfo(statusResults);
}
result = rpcErrorExceptionInfo;
}
else
{
RpcDatabaseCopyStatus[] array = null;
ExTraceGlobals.ReplayServiceRpcTracer.TraceDebug <string>(0L, "GetCopyStatus(): Now making GetCopyStatusEx2() RPC to server {0}.", serverName);
RpcErrorExceptionInfo copyStatusEx = rpcClient.GetCopyStatusEx2(ReplayRpcClientWrapper.ConvertToLegacyCopyStatusFlags(collectionFlags2), dbGuids, ref array);
if (!copyStatusEx.IsFailed() && array != null)
{
statusResults = ReplayRpcClientWrapper.ConvertLegacyCopyStatusArray(array);
}
result = copyStatusEx;
}
}
catch (RpcException ex)
{
if (ReplayRpcErrorCode.IsRpcTimeoutError(ex.ErrorCode))
{
throw new ReplayServiceDownException(serverName, ex.Message, ex);
}
throw;
}
return(result);
});
return(statusResults);
}
private RpcDatabaseCopyStatus2 GetCopyStatusWithTimeout(RpcGetDatabaseCopyStatusFlags2 flags)
{
RpcDatabaseCopyStatus2 status = null;
TimeSpan invokeTimeout = InvokeWithTimeout.InfiniteTimeSpan;
if (RegistryParameters.GetCopyStatusServerTimeoutEnabled)
{
invokeTimeout = ReplicaInstanceContainer.CopyStatusServerTimeout;
}
InvokeWithTimeout.Invoke(delegate()
{
status = this.ReplicaInstance.GetCopyStatus(flags);
}, null, invokeTimeout, true, null);
return(status);
}
private RpcDatabaseCopyStatus2 GetCachedCopyStatus(RpcGetDatabaseCopyStatusFlags2 flags)
{
CopyStatusServerCachedEntry copyStatusServerCachedEntry = this.m_cachedStatus;
if (this.IsCopyStatusReadThroughNeeded(copyStatusServerCachedEntry))
{
TimeSpan copyStatusServerTimeout = ReplicaInstanceContainer.CopyStatusServerTimeout;
bool flag = Monitor.TryEnter(this.m_statusCallLocker);
try
{
if (!flag)
{
ManualOneShotEvent.Result result = this.m_firstCachedStatusCallCompleted.WaitOne(copyStatusServerTimeout);
if (result != ManualOneShotEvent.Result.Success)
{
throw new ReplayServiceRpcCopyStatusTimeoutException(this.ReplicaInstance.Configuration.DisplayName, (int)copyStatusServerTimeout.TotalSeconds);
}
lock (this.m_statusCacheLocker)
{
copyStatusServerCachedEntry = this.m_cachedStatus;
if (copyStatusServerCachedEntry == null)
{
throw new ReplayServiceRpcCopyStatusTimeoutException(this.ReplicaInstance.Configuration.DisplayName, (int)copyStatusServerTimeout.TotalSeconds);
}
if (copyStatusServerCachedEntry.CreateTimeUtc < DateTime.UtcNow - ReplicaInstanceContainer.CopyStatusStaleTimeout)
{
Exception ex = new ReplayServiceRpcCopyStatusTimeoutException(this.ReplicaInstance.Configuration.DisplayName, (int)ReplicaInstanceContainer.CopyStatusStaleTimeout.TotalSeconds);
copyStatusServerCachedEntry.CopyStatus.CopyStatus = CopyStatusEnum.Failed;
copyStatusServerCachedEntry.CopyStatus.ErrorMessage = ex.Message;
copyStatusServerCachedEntry.CopyStatus.ExtendedErrorInfo = new ExtendedErrorInfo(ex);
}
return(copyStatusServerCachedEntry.CopyStatus);
}
}
copyStatusServerCachedEntry = this.m_cachedStatus;
if (this.IsCopyStatusReadThroughNeeded(copyStatusServerCachedEntry))
{
try
{
ExTraceGlobals.ReplayServiceRpcTracer.TraceDebug <string, Guid>((long)this.GetHashCode(), "GetCachedCopyStatus() for DB '{0}' ({1}): Cache TTL expired or force refresh requested.", this.ReplicaInstance.Configuration.DisplayName, this.ReplicaInstance.Configuration.IdentityGuid);
RpcDatabaseCopyStatus2 copyStatusWithTimeout = this.GetCopyStatusWithTimeout(flags);
copyStatusServerCachedEntry = this.UpdateCachedCopyStatus(copyStatusWithTimeout);
}
catch (TimeoutException arg)
{
ExTraceGlobals.ReplayServiceRpcTracer.TraceError <string, TimeoutException>((long)this.GetHashCode(), "GetCachedCopyStatus() Timeout for DB '{0}': {1}", this.ReplicaInstance.Configuration.DisplayName, arg);
throw new ReplayServiceRpcCopyStatusTimeoutException(this.ReplicaInstance.Configuration.DisplayName, (int)copyStatusServerTimeout.TotalSeconds);
}
finally
{
this.m_firstCachedStatusCallCompleted.Set();
}
}
}
finally
{
if (flag)
{
Monitor.Exit(this.m_statusCallLocker);
}
}
}
return(copyStatusServerCachedEntry.CopyStatus);
}
internal static RpcDatabaseCopyStatus2[] GetCopyStatus(string serverName, RpcGetDatabaseCopyStatusFlags2 collectionFlags2, Guid[] dbGuids)
{
return(ReplayRpcClientHelper.defaultInstance.GetCopyStatus(serverName, collectionFlags2, dbGuids));
}
// Token: 0x06001353 RID: 4947 RVA: 0x0004E3D8 File Offset: 0x0004C5D8
internal static CopyStatusClientCachedEntry[] GetAllCopyStatuses(AmServerName amServer, RpcGetDatabaseCopyStatusFlags2 collectionFlags2, IEnumerable <IADDatabase> expectedDatabases, int timeoutMs, ActiveManager activeManager, bool isGetHealthStates, out RpcHealthStateInfo[] healthStates, out Exception exception)
{
CopyStatusClientCachedEntry[] result = null;
RpcDatabaseCopyStatus2[] statuses = null;
TimeSpan rpcDuration = TimeSpan.Zero;
new ReplayStopwatch();
Exception tempEx = null;
exception = null;
healthStates = null;
RpcHealthStateInfo[] tmpHealthStates = null;
tempEx = CopyStatusHelper.TimeCopyStatusRpc(delegate
{
if (!isGetHealthStates)
{
statuses = Dependencies.ReplayRpcClientWrapper.GetCopyStatus(amServer.Fqdn, collectionFlags2, null, timeoutMs);
return;
}
RpcCopyStatusContainer copyStatusWithHealthState = Dependencies.ReplayRpcClientWrapper.GetCopyStatusWithHealthState(amServer.Fqdn, collectionFlags2, null, timeoutMs);
statuses = copyStatusWithHealthState.CopyStatuses;
tmpHealthStates = copyStatusWithHealthState.HealthStates;
}, out rpcDuration);
healthStates = tmpHealthStates;
exception = tempEx;
if (exception != null)
{
result = (from db in expectedDatabases
select CopyStatusHelper.ConstructCopyStatusCachedEntry(db.Guid, amServer, null, tempEx, rpcDuration, activeManager)).ToArray <CopyStatusClientCachedEntry>();
}
else if (statuses != null)
{
Dictionary <Guid, RpcDatabaseCopyStatus2> tempStatusTable = statuses.ToDictionary((RpcDatabaseCopyStatus2 status) => status.DBGuid);
tempEx = new ReplayServiceRpcUnknownInstanceException();
result = (from db in expectedDatabases
let guid = db.Guid
let statusFound = tempStatusTable.ContainsKey(guid)
select CopyStatusHelper.ConstructCopyStatusCachedEntry(guid, amServer, statusFound ? tempStatusTable[guid] : null, statusFound ? null : tempEx, rpcDuration, activeManager)).ToArray <CopyStatusClientCachedEntry>();
}
else
{
DiagCore.RetailAssert(false, "If no exception was thrown by GetCopyStatus RPC, then we should have some status results!", new object[0]);
}
return(result);
}
// Token: 0x06001351 RID: 4945 RVA: 0x0004DC80 File Offset: 0x0004BE80
internal static CopyStatusClientCachedEntry[] GetCopyStatus(AmServerName amServer, RpcGetDatabaseCopyStatusFlags2 collectionFlags2, Guid[] dbGuids, int timeoutMs, ActiveManager activeManager, out Exception exception)
{
RpcHealthStateInfo[] array = null;
return(CopyStatusHelper.GetCopyStatus(amServer, collectionFlags2, dbGuids, timeoutMs, activeManager, false, out array, out exception));
}
public RpcCopyStatusContainer GetCopyStatusWithHealthState(string serverName, RpcGetDatabaseCopyStatusFlags2 collectionFlags2, Guid[] dbGuids, int timeoutMs)
{
if (dbGuids == null || dbGuids.Length == 0)
{
dbGuids = new Guid[]
{
Guid.Empty
};
}
RpcCopyStatusContainer container = null;
if (ReplayRpcVersionControl.IsGetCopyStatusWithHealthStateRpcSupported(ReplayRpcClientWrapper.GetServerVersion(serverName)))
{
ReplayRpcClientWrapper.RunRpcOperation(serverName, null, timeoutMs, TasksRpcExceptionWrapper.Instance, delegate(ReplayRpcClient rpcClient)
{
RpcErrorExceptionInfo result;
try
{
ExTraceGlobals.ReplayServiceRpcTracer.TraceDebug <string>(0L, "GetCopyStatusWithHealthState(): Now making RpccGetCopyStatusWithHealthState() RPC to server {0}.", serverName);
RpcErrorExceptionInfo rpcErrorExceptionInfo = rpcClient.RpccGetCopyStatusWithHealthState(collectionFlags2, dbGuids, ref container);
if (!rpcErrorExceptionInfo.IsFailed())
{
ReplayRpcClientWrapper.DeserializeExtendedErrorInfo(container.CopyStatuses);
}
result = rpcErrorExceptionInfo;
}
catch (RpcException ex)
{
if (ReplayRpcErrorCode.IsRpcTimeoutError(ex.ErrorCode))
{
throw new ReplayServiceDownException(serverName, ex.Message, ex);
}
throw;
}
return(result);
});
}
else
{
container = new RpcCopyStatusContainer();
container.HealthStates = null;
container.CopyStatuses = this.GetCopyStatus(serverName, collectionFlags2, dbGuids, timeoutMs);
}
return(container);
}
public RpcDatabaseCopyStatus2[] GetCopyStatus(string serverName, RpcGetDatabaseCopyStatusFlags2 collectionFlags2, Guid[] dbGuids)
{
return(this.GetCopyStatus(serverName, collectionFlags2, dbGuids, RegistryParameters.GetMailboxDatabaseCopyStatusRPCTimeoutInMSec));
}
private DatabaseCopyStatusEntry[] PrepareStatusEntryFromRpc(Server server, Collection <DatabaseCopy> databaseCopies)
{
DatabaseCopyStatusEntry[] array = new DatabaseCopyStatusEntry[databaseCopies.Count];
Guid[] array2 = new Guid[databaseCopies.Count];
for (int i = 0; i < databaseCopies.Count; i++)
{
DatabaseCopy databaseCopy3 = databaseCopies[i];
Database database = databaseCopy3.GetDatabase <Database>();
array2[i] = database.Guid;
array[i] = this.ConstructNewSatusEntry(databaseCopy3);
}
RpcGetDatabaseCopyStatusFlags2 rpcGetDatabaseCopyStatusFlags = RpcGetDatabaseCopyStatusFlags2.None;
if (!this.UseServerCache)
{
rpcGetDatabaseCopyStatusFlags |= RpcGetDatabaseCopyStatusFlags2.ReadThrough;
}
try
{
IEnumerable <string> source = from databaseCopy in databaseCopies
select databaseCopy.DatabaseName;
base.WriteVerbose(Strings.GetDbcsRpcQuery(server.Fqdn, string.Join(",", source.ToArray <string>())));
RpcDatabaseCopyStatus2[] copyStatus = ReplayRpcClientHelper.GetCopyStatus(server.Fqdn, rpcGetDatabaseCopyStatusFlags, array2);
if (copyStatus != null && copyStatus.Length > 0)
{
base.WriteVerbose(Strings.GetDbcsRpcQueryAllDone(copyStatus.Length));
Dictionary <Guid, RpcDatabaseCopyStatus2> dictionary = new Dictionary <Guid, RpcDatabaseCopyStatus2>(copyStatus.Length);
for (int j = 0; j < copyStatus.Length; j++)
{
dictionary[copyStatus[j].DBGuid] = copyStatus[j];
}
for (int k = 0; k < array2.Length; k++)
{
RpcDatabaseCopyStatus2 copyStatus2;
if (dictionary.TryGetValue(array2[k], out copyStatus2))
{
GetMailboxDatabaseCopyStatus.GetEntryFromStatus(copyStatus2, array[k]);
}
else if (!databaseCopies[k].IsValid)
{
ExTraceGlobals.CmdletsTracer.TraceDebug <Guid, string>((long)this.GetHashCode(), "GetCopyStatus() didn't find replica instance for database {0} on server {1}. The DatabaseCopy is misconfigured in the Active Directory!", array2[k], server.Fqdn);
this.UpdateMisconfiguredCopyStatusEntry(array[k], databaseCopies[k]);
}
else
{
ExTraceGlobals.CmdletsTracer.TraceDebug <Guid, string>((long)this.GetHashCode(), "GetCopyStatus() didn't find replica instance for database {0} on server {1}.", array2[k], server.Fqdn);
this.UpdateCopyStatusNoReplicaInstance(array[k]);
}
}
}
}
catch (ArgumentException ex)
{
ExTraceGlobals.CmdletsTracer.TraceError <ArgumentException>((long)this.GetHashCode(), "GetMailboxDatabaseCopyStatus: ArgumentException: {0}", ex);
this.WriteError(ex, ErrorCategory.ReadError, null, false);
}
catch (TaskServerTransientException ex2)
{
ExTraceGlobals.CmdletsTracer.TraceError <TaskServerTransientException>((long)this.GetHashCode(), "GetMailboxDatabaseCopyStatus: ArgumentException: {0}", ex2);
this.WriteError(ex2, ErrorCategory.ReadError, null, false);
}
catch (TaskServerException ex3)
{
ExTraceGlobals.CmdletsTracer.TraceError <TaskServerException>((long)this.GetHashCode(), "GetMailboxDatabaseCopyStatus: ReplayServiceRpcException: {0}", ex3);
if (ex3 is ReplayServiceDownException)
{
base.WriteVerbose(Strings.GetDbcsDetectReplayServiceDown(server.Fqdn, ex3.Message));
for (int l = 0; l < array.Length; l++)
{
DatabaseCopyStatusEntry databaseCopyStatusEntry = array[l];
DatabaseCopy databaseCopy2 = databaseCopies[l];
if (!databaseCopy2.IsValid)
{
this.UpdateMisconfiguredCopyStatusEntry(databaseCopyStatusEntry, databaseCopy2);
}
else
{
databaseCopyStatusEntry.Status = CopyStatus.ServiceDown;
databaseCopyStatusEntry.m_errorMessage = ex3.Message;
databaseCopyStatusEntry.m_extendedErrorInfo = new ExtendedErrorInfo(ex3);
}
}
}
else if (ex3 is ReplayServiceRpcUnknownInstanceException)
{
ExTraceGlobals.CmdletsTracer.TraceDebug <string>((long)this.GetHashCode(), "GetCopyStatus() was not able to find any replica instances on server {0}.", server.Fqdn);
for (int m = 0; m < array.Length; m++)
{
if (!databaseCopies[m].IsValid)
{
this.UpdateMisconfiguredCopyStatusEntry(array[m], databaseCopies[m]);
}
else
{
this.UpdateCopyStatusNoReplicaInstance(array[m]);
}
}
}
else
{
this.WriteError(ex3, ErrorCategory.ReadError, null, false);
}
}
return(array);
}
public AmMultiNodeCopyStatusFetcher(List <AmServerName> nodeList, Guid[] mdbGuids, Dictionary <AmServerName, IEnumerable <IADDatabase> > databasesMap, RpcGetDatabaseCopyStatusFlags2 rpcFlags, ActiveManager activeManager, int rpcTimeoutInMs, bool isGetHealthStates = false) : base(nodeList, "AmMultiNodeCopyStatusFetcher")
{
this.m_rpcTimeoutInMs = rpcTimeoutInMs;
this.m_mdbGuids = mdbGuids;
this.m_databaseMap = databasesMap;
this.m_rpcFlags = rpcFlags;
this.m_activeManager = activeManager;
this.m_isGetHealthStates = isGetHealthStates;
this.m_healthStateTable = new Dictionary <AmServerName, RpcHealthStateInfo[]>(16);
if (mdbGuids == null || mdbGuids.Length == 0)
{
this.m_copyStatusMap = new Dictionary <Guid, Dictionary <AmServerName, CopyStatusClientCachedEntry> >(160);
return;
}
this.m_copyStatusMap = new Dictionary <Guid, Dictionary <AmServerName, CopyStatusClientCachedEntry> >(mdbGuids.Length);
}
public AmMultiNodeCopyStatusFetcher(List <AmServerName> nodeList, Dictionary <AmServerName, IEnumerable <IADDatabase> > databasesMap, RpcGetDatabaseCopyStatusFlags2 rpcFlags, ActiveManager activeManager, bool isGetHealthStates, int rpcTimeoutInMs) : this(nodeList, null, databasesMap, rpcFlags, activeManager, rpcTimeoutInMs, isGetHealthStates)
{
}
public AmMultiNodeCopyStatusFetcher(List <AmServerName> nodeList, Guid[] mdbGuids, Dictionary <AmServerName, IEnumerable <IADDatabase> > databasesMap, RpcGetDatabaseCopyStatusFlags2 rpcFlags, ActiveManager activeManager, bool isGetHealthStates = false) : this(nodeList, mdbGuids, databasesMap, rpcFlags, activeManager, RegistryParameters.BCSGetCopyStatusRPCTimeoutInMSec, isGetHealthStates)
{
}
