// Token: 0x06000BB0 RID: 2992 RVA: 0x00034350 File Offset: 0x00032550
public void LinkWithMonitoredDatabase(MonitoredDatabase curDatabase)
{
if (curDatabase.IsPassiveCopy)
{
bool flag = false;
NetworkChannelMessage.MessageType type = base.Type;
if (type <= NetworkChannelMessage.MessageType.ProgressCiFileRequest)
{
if (type <= NetworkChannelMessage.MessageType.SeedLogCopyRequest)
{
if (type != NetworkChannelMessage.MessageType.CancelCiFileRequest && type != NetworkChannelMessage.MessageType.SeedLogCopyRequest)
{
goto IL_7C;
}
}
else if (type != NetworkChannelMessage.MessageType.PassiveDatabaseFileRequest && type != NetworkChannelMessage.MessageType.ProgressCiFileRequest)
{
goto IL_7C;
}
}
else if (type <= NetworkChannelMessage.MessageType.SeedCiFileRequest2)
{
if (type != NetworkChannelMessage.MessageType.SeedCiFileRequest && type != NetworkChannelMessage.MessageType.SeedCiFileRequest2)
{
goto IL_7C;
}
}
else if (type != NetworkChannelMessage.MessageType.CancelCiFileReply && type != NetworkChannelMessage.MessageType.ProgressCiFileReply && type != NetworkChannelMessage.MessageType.SeedCiFileReply)
{
goto IL_7C;
}
flag = true;
IL_7C:
if (!flag)
{
ExTraceGlobals.NetworkChannelTracer.TraceError <NetworkChannelMessage.MessageType, string, string>((long)this.GetHashCode(), "LinkWithMonitoredDatabase rejecting request {0} from {1} for database {2}", base.Type, base.Channel.PartnerNodeName, curDatabase.DatabaseName);
Exception ex = new SourceDatabaseNotFoundException(this.DatabaseGuid, Environment.MachineName);
base.Channel.SendException(ex);
throw ex;
}
}
if (base.Channel.MonitoredDatabase != curDatabase)
{
if (base.Channel.MonitoredDatabase == null)
{
base.Channel.MonitoredDatabase = curDatabase;
return;
}
if (curDatabase.DatabaseGuid != this.DatabaseGuid)
{
ExTraceGlobals.NetworkChannelTracer.TraceError <Guid, string>(0L, "Unexpected dbguid: got: {0}, expected:{1}", this.DatabaseGuid, curDatabase.Identity);
base.Channel.ThrowUnexpectedMessage(this);
}
base.Channel.TraceDebug("Source instance must have restarted. Relinking to database {0}", new object[]
{
curDatabase.DatabaseName
});
base.Channel.MonitoredDatabase = curDatabase;
}
}
public static void SetCopyProperty(Guid dbGuid, string propName, string propVal)
{
MonitoredDatabase monitoredDatabase = MonitoredDatabase.FindMonitoredDatabase(Environment.MachineName, dbGuid);
if (monitoredDatabase == null)
{
throw new ArgumentException(string.Format("Monitored database '{0}' not active", dbGuid));
}
if (MonitoredDatabase.StringIEquals(propName, "TestGranularReplicationExceptionDuringAcll"))
{
bool testGranularReplicationExceptionDuringAcll;
if (!bool.TryParse(propVal, out testGranularReplicationExceptionDuringAcll))
{
throw new ArgumentException("TestGranularReplicationExceptionDuringAcll must be a bool");
}
monitoredDatabase.TestGranularReplicationExceptionDuringAcll = testGranularReplicationExceptionDuringAcll;
return;
}
else
{
if (!MonitoredDatabase.StringIEquals(propName, "TestGranularReplicationDeliveryDelay"))
{
throw new ArgumentException(string.Format("'{0}' is not recognized", propName));
}
int testGranularReplicationDeliveryDelay;
if (!int.TryParse(propVal, out testGranularReplicationDeliveryDelay))
{
throw new ArgumentException("TestGranularReplicationDeliveryDelay must be an int");
}
monitoredDatabase.TestGranularReplicationDeliveryDelay = testGranularReplicationDeliveryDelay;
return;
}
}
// Token: 0x06001AC5 RID: 6853 RVA: 0x00072DCC File Offset: 0x00070FCC
public void SendLogFiles()
{
MonitoredDatabase monitoredDatabase = this.GetMonitoredDatabase();
string suffix = '.' + monitoredDatabase.Config.LogExtension;
DirectoryInfo di = new DirectoryInfo(monitoredDatabase.Config.SourceLogPath);
long num = ShipControl.HighestGenerationInDirectory(di, monitoredDatabase.Config.LogFilePrefix, suffix);
long num2 = ShipControl.LowestGenerationInDirectory(di, monitoredDatabase.Config.LogFilePrefix, suffix, false);
for (long num3 = num2; num3 <= num; num3 += 1L)
{
this.CheckSeedingCancelled();
try
{
monitoredDatabase.SendLog(num3, this.m_channel, null);
}
catch (FileIOonSourceException ex)
{
ExTraceGlobals.SeederServerTracer.TraceDebug <long, Exception>((long)this.GetHashCode(), "failed to send generation 0x{0:X} because {1}", num3, ex.InnerException);
this.m_channel.SendException(ex.InnerException);
this.CancelSeeding(ex.LocalizedString);
return;
}
}
NotifyEndOfLogReply notifyEndOfLogReply = new NotifyEndOfLogReply(this.m_channel, NetworkChannelMessage.MessageType.NotifyEndOfLogReply, num, DateTime.UtcNow);
this.TraceDebug("reached the end of log files", new object[0]);
notifyEndOfLogReply.Send();
}
// Token: 0x06001AB8 RID: 6840 RVA: 0x000724B0 File Offset: 0x000706B0
internal SeederServerContext(NetworkChannel channel, MonitoredDatabase database, Guid?targetServerGuid, SeedType seedType)
{
this.m_channel = channel;
this.m_databaseGuid = database.DatabaseGuid;
this.DatabaseName = database.DatabaseName;
this.SeedType = seedType;
this.m_targetServerGuid = targetServerGuid;
if (database.Config.IsPassiveCopy)
{
this.m_fPassiveSeeding = true;
switch (seedType)
{
case SeedType.Database:
this.m_passiveSeedingSourceContext = PassiveSeedingSourceContextEnum.Database;
break;
case SeedType.Catalog:
this.m_passiveSeedingSourceContext = PassiveSeedingSourceContextEnum.Catalogue;
break;
}
}
else
{
this.m_passiveSeedingSourceContext = PassiveSeedingSourceContextEnum.None;
}
if (!TestSupport.IsCatalogSeedDisabled())
{
string indexSystemName = FastIndexVersion.GetIndexSystemName(this.m_databaseGuid);
this.indexSeederSource = new IndexSeeder(indexSystemName);
}
}
public override void Execute()
{
MonitoredDatabase monitoredDatabase = base.Channel.MonitoredDatabase;
EndOfLog currentEndOfLog = monitoredDatabase.CurrentEndOfLog;
NotifyEndOfLogReply notifyEndOfLogReply = new NotifyEndOfLogReply(base.Channel, NetworkChannelMessage.MessageType.NotifyEndOfLogReply, currentEndOfLog.Generation, currentEndOfLog.Utc);
notifyEndOfLogReply.Send();
}
private void SetBrokenInternal(FailureTag failureTag, ExEventLog.EventTuple setBrokenEventTuple, ExtendedErrorInfo extendedErrorInfo, params string[] setBrokenArgsPlusDb)
{
int num;
string text = setBrokenEventTuple.EventLogToString(out num, setBrokenArgsPlusDb);
Exception failureException = extendedErrorInfo.FailureException;
int num2 = 0;
if (failureException != null)
{
num2 = failureException.HResult;
}
ReplayCrimsonEvents.SetBroken.LogPeriodic <Guid, string, string, string, Exception, int>(this.m_databaseName, DiagCore.DefaultEventSuppressionInterval, this.m_guid, this.m_databaseName, text, Environment.StackTrace, failureException, num2);
bool flag = false;
lock (this.m_instance)
{
flag = this.IsBroken;
this.FailureInfo.SetBroken(setBrokenEventTuple, new LocalizedString(text), extendedErrorInfo);
if (this.m_perfmonCounters != null)
{
this.m_perfmonCounters.Failed = 1L;
this.m_perfmonCounters.Disconnected = 0L;
if (this.Suspended)
{
this.m_perfmonCounters.FailedSuspended = 1L;
}
}
bool flag3;
setBrokenEventTuple.LogEvent(this.m_identity, out flag3, setBrokenArgsPlusDb);
ExTraceGlobals.ReplicaInstanceTracer.TraceDebug <string, FailureTag, string>((long)this.GetHashCode(), "{0} SetBroken with tag {1} because {2}", this.m_displayName, failureTag, text);
MonitoredDatabase monitoredDatabase = MonitoredDatabase.FindMonitoredDatabase(this.ReplicaInstance.Configuration.ServerName, this.m_guid);
if (monitoredDatabase != null && this.PassiveSeedingSourceContext != PassiveSeedingSourceContextEnum.None)
{
ExTraceGlobals.ReplicaInstanceTracer.TraceDebug <Guid>((long)this.GetHashCode(), "Cancel seeding for mdb {0}", this.m_guid);
SourceSeedTable.Instance.CancelSeedingIfAppropriate(SourceSeedTable.CancelReason.CopyFailed, monitoredDatabase.DatabaseGuid);
}
bool flag4 = false;
if (flag3 && (!RegistryParameters.DisableSetBrokenFailureItemSuppression || this.IsSuppressableFailureTag(failureTag)) && !this.IsNonSuppressableFailureTag(failureTag))
{
flag4 = true;
}
if (!flag4 && failureTag != FailureTag.NoOp)
{
FailureItemPublisherHelper.PublishAction(failureTag, this.m_guid, this.m_databaseName);
}
if (!flag)
{
this.FailureInfo.PersistFailure(this.m_replayState);
}
this.ExternalStatus.Refresh();
}
if (!flag)
{
this.m_instance.PrepareToStop();
}
}
// Token: 0x06001AC4 RID: 6852 RVA: 0x00072D8C File Offset: 0x00070F8C
private MonitoredDatabase GetMonitoredDatabase()
{
MonitoredDatabase monitoredDatabase = MonitoredDatabase.FindMonitoredDatabase(this.m_channel.LocalNodeName, this.DatabaseGuid);
if (monitoredDatabase == null)
{
throw new SourceDatabaseNotFoundException(this.DatabaseGuid, this.m_channel.LocalNodeName);
}
return(monitoredDatabase);
}
public void UpdateLastLogGeneratedAndEndOfLogInfo(long highestLogGen)
{
ActiveManagerCore.SetLastLogGenerationNumber(this.DatabaseGuid, highestLogGen);
MonitoredDatabase monitoredDatabase = MonitoredDatabase.FindMonitoredDatabase(this.ServerName, this.DatabaseGuid);
if (monitoredDatabase != null)
{
monitoredDatabase.UpdateCurrentEndOfLog(highestLogGen, true);
}
}
// Token: 0x0600239F RID: 9119 RVA: 0x000A7414 File Offset: 0x000A5614
public static MonitoredDatabase GetMonitoredDatabase(string dbGuid)
{
MonitoredDatabase result = null;
if (!RemoteDataProvider.s_databases.TryGetInstance(dbGuid, out result))
{
return(null);
}
return(result);
}
public static MonitoredDatabase FindMonitoredDatabase(string nodeName, Guid dbGuid)
{
MonitoredDatabase result = null;
IFindComponent componentFinder = Dependencies.ComponentFinder;
if (componentFinder != null)
{
result = componentFinder.FindMonitoredDatabase(nodeName, dbGuid);
}
return(result);
}
// Token: 0x0600186E RID: 6254 RVA: 0x00064C38 File Offset: 0x00062E38
public NetworkChannel FindSeedingChannel(MonitoredDatabase db)
{
lock (this.m_activeClientConnections)
{
foreach (NetworkChannel networkChannel in this.m_activeClientConnections)
{
if (networkChannel.IsSeeding && object.ReferenceEquals(networkChannel.MonitoredDatabase, db))
{
return(networkChannel);
}
}
}
return(null);
}
// Token: 0x06002399 RID: 9113 RVA: 0x000A7154 File Offset: 0x000A5354
public static void StopMonitoredDatabase(string dbGuidStr)
{
MonitoredDatabase monitoredDatabase = null;
lock (RemoteDataProvider.s_singletonLock)
{
if (RemoteDataProvider.s_databases.TryGetInstance(dbGuidStr, out monitoredDatabase) && monitoredDatabase != null)
{
RemoteDataProvider.s_databases.RemoveInstance(monitoredDatabase);
}
}
if (monitoredDatabase != null)
{
monitoredDatabase.StopMonitoring();
return;
}
RemoteDataProvider.Tracer.TraceDebug <string>(0L, "StopMonitoredDatabase found no database for {0}", dbGuidStr);
}
// Token: 0x0600239A RID: 9114 RVA: 0x000A71C8 File Offset: 0x000A53C8
public static void StartMonitoredDatabase(ReplayConfiguration config)
{
lock (RemoteDataProvider.s_singletonLock)
{
MonitoredDatabase monitoredDatabase = null;
if (RemoteDataProvider.s_databases.TryGetInstance(config.Identity, out monitoredDatabase))
{
throw new MonitoredDatabaseInitException(config.DatabaseName, "MonitoredDatabase should not have existed");
}
MonitoredDatabase monitoredDatabase2 = new MonitoredDatabase(config);
MonitoredDatabaseInitException ex = monitoredDatabase2.StartMonitoring();
if (ex != null)
{
throw ex;
}
RemoteDataProvider.s_databases.AddInstance(monitoredDatabase2);
RemoteDataProvider.Tracer.TraceDebug <string>((long)monitoredDatabase2.GetHashCode(), "StartMonitoredDatabase has activated {0}", monitoredDatabase2.DatabaseName);
}
}
private static void DirectoryChangeEvent(object source, FileSystemEventArgs eventInfo)
{
MonitoredDatabase.FileWatcher fileWatcher = source as MonitoredDatabase.FileWatcher;
MonitoredDatabase database = fileWatcher.Database;
long num = 0L;
if (database.GetGenerationNumberFromFilename(eventInfo.Name, out num))
{
MonitoredDatabase.Tracer.TraceDebug <long, string>((long)database.GetHashCode(), "DirectoryChangeEvent: Log 0x{0:X} exists for db '{1}'", num, database.DatabaseName);
DateTime? writeTimeUtc = null;
Exception ex = null;
try
{
FileInfo fileInfo = new FileInfo(eventInfo.FullPath);
if (!fileInfo.Exists)
{
throw new FileNotFoundException("FileNotFound");
}
writeTimeUtc = new DateTime?(fileInfo.LastWriteTimeUtc);
}
catch (IOException ex2)
{
ex = ex2;
}
catch (UnauthorizedAccessException ex3)
{
ex = ex3;
}
if (ex != null)
{
MonitoredDatabase.Tracer.TraceError <string, string>((long)database.GetHashCode(), "DirectoryChangeEvent for {0} failed with exception {1}", eventInfo.FullPath, ex.Message);
ReplayCrimsonEvents.MonitoredDBFileNotifyFailure.Log <string, string, string, string>(database.DatabaseName, Environment.MachineName, eventInfo.FullPath, ex.ToString());
}
database.DetectNewEndOfLog(num, writeTimeUtc, false);
}
}
// Token: 0x06002398 RID: 9112 RVA: 0x000A6E5C File Offset: 0x000A505C
public static void MonitorDatabases(List <string> databasesToStopMonitoring, List <string> databasesToRestartMonitoring, Dictionary <string, ReplayConfiguration> configurationsFound)
{
List <MonitoredDatabase> list = new List <MonitoredDatabase>(databasesToStopMonitoring.Count);
lock (RemoteDataProvider.s_singletonLock)
{
if (RemoteDataProvider.s_tprEnabled)
{
return;
}
MonitoredDatabase[] allInstances = RemoteDataProvider.s_databases.GetAllInstances();
foreach (MonitoredDatabase monitoredDatabase in allInstances)
{
if (databasesToStopMonitoring.Contains(monitoredDatabase.Identity))
{
ExTraceGlobals.MonitoredDatabaseTracer.TraceDebug <string>(0L, "Config for MonitoredDatabase is gone: {0}", monitoredDatabase.Config.DatabaseName);
SourceSeedTable.Instance.CancelSeedingIfAppropriate(SourceSeedTable.CancelReason.CopyRemoved, monitoredDatabase.DatabaseGuid);
list.Add(monitoredDatabase);
RemoteDataProvider.s_databases.RemoveInstance(monitoredDatabase);
}
}
foreach (KeyValuePair <string, ReplayConfiguration> keyValuePair in configurationsFound)
{
ReplayConfiguration value = keyValuePair.Value;
bool flag2 = value.Type == ReplayConfigType.RemoteCopySource;
bool flag3 = flag2 || (value.Type == ReplayConfigType.RemoteCopyTarget && !value.ReplayState.Suspended);
MonitoredDatabase monitoredDatabase2 = null;
if (RemoteDataProvider.s_databases.TryGetInstance(value.Identity, out monitoredDatabase2))
{
if (flag3 && !databasesToRestartMonitoring.Contains(monitoredDatabase2.Identity))
{
RemoteDataProvider.Tracer.TraceDebug <string>((long)monitoredDatabase2.GetHashCode(), "Config not changed, or the associated RI was not restarted. Continuing to monitor: {0}", value.DatabaseName);
continue;
}
RemoteDataProvider.Tracer.TraceDebug <string>((long)monitoredDatabase2.GetHashCode(), "Config for MonitoredDatabase is changing or a restart was requested: {0}", value.DatabaseName);
SourceSeedTable.Instance.CancelSeedingIfAppropriate(SourceSeedTable.CancelReason.ConfigChanged, monitoredDatabase2.DatabaseGuid);
list.Add(monitoredDatabase2);
}
if (!flag2)
{
RemoteDataProvider.Tracer.TraceDebug <string>(0L, "Not starting monitor for {0}", value.DatabaseName);
if (monitoredDatabase2 != null)
{
RemoteDataProvider.s_databases.RemoveInstance(monitoredDatabase2);
}
}
else
{
if (monitoredDatabase2 != null && !monitoredDatabase2.IsPassiveCopy)
{
monitoredDatabase2.StopMonitoring();
}
MonitoredDatabase monitoredDatabase3 = new MonitoredDatabase(value);
if (monitoredDatabase3.StartMonitoring() == null)
{
if (monitoredDatabase2 != null)
{
RemoteDataProvider.s_databases.UpdateInstance(monitoredDatabase2, monitoredDatabase3);
}
else
{
RemoteDataProvider.s_databases.AddInstance(monitoredDatabase3);
}
RemoteDataProvider.Tracer.TraceDebug <string>((long)monitoredDatabase3.GetHashCode(), "Now monitoring: {0}", value.DatabaseName);
}
else
{
RemoteDataProvider.Tracer.TraceError <ReplayConfiguration>((long)monitoredDatabase3.GetHashCode(), "Unable to monitor remote requests for configuration {0}", value);
if (monitoredDatabase2 != null)
{
RemoteDataProvider.s_databases.RemoveInstance(monitoredDatabase2);
}
}
}
}
}
foreach (MonitoredDatabase monitoredDatabase4 in list)
{
monitoredDatabase4.StopMonitoring();
}
list.Clear();
}
// Token: 0x06001AC6 RID: 6854 RVA: 0x00072EDC File Offset: 0x000710DC
public void SendDatabaseFile()
{
ReplayStopwatch replayStopwatch = new ReplayStopwatch();
replayStopwatch.Start();
bool flag = false;
SafeFileHandle safeFileHandle = null;
try
{
this.TraceDebug("PassiveSeedDatabaseFileRequest. Opening up the backup context for {0}.", new object[]
{
this.DatabaseGuid
});
MonitoredDatabase monitoredDatabase = this.GetMonitoredDatabase();
string databaseFullPath = monitoredDatabase.GetDatabaseFullPath();
int num = 0;
for (;;)
{
this.CheckSeedingCancelled();
try
{
using (IStoreMountDismount storeMountDismountInstance = Dependencies.GetStoreMountDismountInstance(null))
{
storeMountDismountInstance.UnmountDatabase(Guid.Empty, monitoredDatabase.Config.IdentityGuid, 16);
this.TraceDebug("dismounted the replayer database", new object[0]);
}
}
catch (MapiExceptionNotFound)
{
this.TraceDebug("replay database is not mounted", new object[0]);
}
catch (MapiExceptionTimeout mapiExceptionTimeout)
{
this.TraceError("Rethrowing timeout exception: {0}", new object[]
{
mapiExceptionTimeout
});
throw;
}
catch (MapiRetryableException ex)
{
if (num++ < 3)
{
this.TraceDebug("got {0}, but we will keep retrying for 3 times", new object[]
{
ex.ToString()
});
Thread.Sleep(1000);
continue;
}
throw;
}
catch (MapiPermanentException ex2)
{
if (num++ < 3)
{
this.TraceDebug("got {0}, but we will keep retrying for 3 times", new object[]
{
ex2.ToString()
});
Thread.Sleep(1000);
continue;
}
throw;
}
break;
}
safeFileHandle = this.OpenFile(databaseFullPath, true);
this.m_passiveDatabaseStream = SeederServerContext.OpenFileStream(safeFileHandle, true);
SeedDatabaseFileReply seedDatabaseFileReply = new SeedDatabaseFileReply(this.m_channel);
seedDatabaseFileReply.FileSize = new FileInfo(databaseFullPath).Length;
seedDatabaseFileReply.LastWriteUtc = DateTime.UtcNow;
seedDatabaseFileReply.Send();
ExTraceGlobals.SeederServerTracer.TraceDebug <Guid>((long)this.GetHashCode(), "PassiveSeedDatabaseFileRequest. Sending the data for {0}.", this.DatabaseGuid);
this.m_channel.SendSeedingDataTransferReply(seedDatabaseFileReply, new ReadDatabaseCallback(this.ReadDbCallback));
flag = true;
}
finally
{
if (this.m_passiveDatabaseStream != null)
{
this.m_passiveDatabaseStream.Dispose();
}
ExTraceGlobals.SeederServerTracer.TraceDebug <long, string>((long)this.GetHashCode(), "PassiveSeedDatabaseFile finished streaming after {0} sec. Operation successful: {1}", replayStopwatch.ElapsedMilliseconds / 1000L, flag.ToString());
if (safeFileHandle != null)
{
safeFileHandle.Dispose();
}
}
}
internal LogCopyServerContext(NetworkChannel channel, MonitoredDatabase database)
{
this.m_channel = channel;
this.m_database = database;
}
