private static Exception DumpsterResubmitRpc(string hubServer, ReplayConfiguration config, SafetyNetRequestKey snKey, SafetyNetInfo snInfo, IMonitoringADConfig adConfig, bool inPrimaryPhase) { bool flag = false; Exception ex = null; SafetyNetRedelivery.Tracer.TraceDebug <string, string, string>((long)config.GetHashCode(), "DumpsterResubmitRpc() called for {0}({1}) to HUB server {2}.", config.Name, config.Identity, hubServer); if (SafetyNetRedelivery.IsSafetyNetRedeliveryRpcSupportedOnHubServer(hubServer, adConfig, out ex)) { AddResubmitRequestStatus addResubmitRequestStatus; ex = SafetyNetRedelivery.DumpsterResubmitRpcInternal(true, hubServer, config, snKey, snInfo, inPrimaryPhase, out addResubmitRequestStatus); if (addResubmitRequestStatus == AddResubmitRequestStatus.Disabled) { flag = true; SafetyNetRedelivery.Tracer.TraceDebug <string, string, string>((long)config.GetHashCode(), "DumpsterResubmitRpc() requested from SafetyNet for {0}({1}) to HUB server {2}, but it is Disabled. Falling back to classic Dumpster...", config.Name, config.Identity, hubServer); } else if (addResubmitRequestStatus == AddResubmitRequestStatus.DuplicateRequest) { SafetyNetRedelivery.Tracer.TraceDebug <string, string, string>((long)config.GetHashCode(), "DumpsterResubmitRpc() requested from SafetyNet for {0}({1}) to HUB server {2}, but it is DuplicateRequest. Treating this duplicate RPC as successful.", config.Name, config.Identity, hubServer); } } else if (ex != null) { SafetyNetRedelivery.LogResubmitToServerException(true, hubServer, config, snKey, snInfo, inPrimaryPhase, ex, string.Empty); } else { flag = true; } if (flag) { AddResubmitRequestStatus addResubmitRequestStatus; ex = SafetyNetRedelivery.DumpsterResubmitRpcInternal(false, hubServer, config, snKey, snInfo, inPrimaryPhase, out addResubmitRequestStatus); } return(ex); }
private static void DoRedeliveryIfRequiredLocked(ReplayConfiguration config, SafetyNetInfoCache snCache, SafetyNetInfoHashTable safetyNetInfos) { foreach (KeyValuePair <SafetyNetRequestKey, SafetyNetInfo> request in safetyNetInfos) { SafetyNetRedelivery.ProcessSingleRequest(config, snCache, request); } }
protected void PerformSeedIfNecessary() { TDataObject dataObject = this.DataObject; IIdentityParameter id = new DatabaseIdParameter(dataObject.Id); IConfigDataProvider dataSession = base.DataSession; ObjectId rootId = this.RootId; TDataObject dataObject2 = this.DataObject; LocalizedString? notFoundError = new LocalizedString?(Strings.ErrorDatabaseNotFound(dataObject2.Name)); TDataObject dataObject3 = this.DataObject; Database database = (Database)base.GetDataObject <Database>(id, dataSession, rootId, notFoundError, new LocalizedString?(Strings.ErrorDatabaseNotUnique(dataObject3.Name))); IADDatabaseAvailabilityGroup dag = null; if (this.m_server.DatabaseAvailabilityGroup != null) { DatabaseAvailabilityGroup dag2 = this.ConfigurationSession.Read <DatabaseAvailabilityGroup>(this.m_server.DatabaseAvailabilityGroup); dag = ADObjectWrapperFactory.CreateWrapper(dag2); } ReplayConfiguration config = RemoteReplayConfiguration.TaskGetReplayConfig(dag, ADObjectWrapperFactory.CreateWrapper(database), ADObjectWrapperFactory.CreateWrapper(this.m_server)); if (this.m_fSeeding) { this.SeedDatabase(config); } this.SuspendDatabaseCopyIfNecessary(config); }
protected sealed override void InternalProcessRecord() { TaskLogger.LogEnter(new object[] { this.DataObject }); try { base.Validate(this.DataObject); if (!base.HasErrors) { ExTraceGlobals.CmdletsTracer.TraceDebug <ObjectId>((long)this.GetHashCode(), "DatabaseCopyStateAction: enter InternalProcessRecord: {0}", this.DataObject.Identity); Database database = this.DataObject.GetDatabase <Database>(); if (!this.m_UseRpc) { ReplayConfiguration replayConfiguration = base.ConstructReplayConfiguration(database); this.ProcessRecordWorker(replayConfiguration); } else { this.ProcessRecordWorker(null); } ExTraceGlobals.CmdletsTracer.TraceDebug <ObjectId>((long)this.GetHashCode(), "DatabaseCopyStateAction: leave InternalProcessRecord: {0}", this.DataObject.Identity); } } finally { TaskLogger.LogExit(); } }
private static void ExitLock(ReplayConfiguration config) { lock (SafetyNetRedelivery.s_inProgressRequests) { SafetyNetRedelivery.s_inProgressRequests.Remove(config.IdentityGuid); } }
protected override bool RunIndividualCheck(ReplayConfiguration configToCheck, RpcDatabaseCopyStatus2 copyStatus) { bool flag = false; string text = null; CopyStatus copyStatus2 = CopyStatus.Unknown; if (copyStatus.CopyStatus == CopyStatusEnum.Suspended) { copyStatus2 = CopyStatus.Suspended; text = copyStatus.SuspendComment; flag = true; } else if (copyStatus.CopyStatus == CopyStatusEnum.FailedAndSuspended) { copyStatus2 = CopyStatus.FailedAndSuspended; text = copyStatus.ErrorMessage; flag = true; } if (flag) { text = ((!string.IsNullOrEmpty(text)) ? text : Strings.ReplicationCheckBlankMessage); base.FailContinue(Strings.DatabaseCopySuspendedCheck(new LocalizedReplayConfigType(configToCheck.Type).ToString(), configToCheck.DisplayName, copyStatus2.ToString(), base.ServerName, text)); return(false); } return(true); }
private void ResumeUsingState(ReplayConfiguration replayConfiguration) { ReplayState replayState = replayConfiguration.ReplayState; replayState.SuspendLockRemote.TryLeaveSuspend(); replayState.SuspendMessage = null; this.m_fSuccess = true; }
private Thread BeginSuspendUsingState(ReplayConfiguration replayConfiguration) { ReplayState replayState = replayConfiguration.ReplayState; Thread thread = new Thread(new ParameterizedThreadStart(this.SuspendStateThreadProc)); thread.IsBackground = true; thread.Start(replayState); return(thread); }
public void TriggerDumpster(Guid dbGuid, DateTime inspectorTime) { IADToplogyConfigurationSession iadtoplogyConfigurationSession = ADSessionFactory.CreatePartiallyConsistentRootOrgSession(true); IADDatabase db = iadtoplogyConfigurationSession.FindDatabaseByGuid(dbGuid); IADServer server = iadtoplogyConfigurationSession.FindServerByName(Environment.MachineName); IADDatabaseAvailabilityGroup dag = iadtoplogyConfigurationSession.FindDagByServer(server); ReplayConfiguration configuration = RemoteReplayConfiguration.TaskGetReplayConfig(dag, db, server); DumpsterRedeliveryWrapper.MarkRedeliveryRequired(configuration, inspectorTime, 0L, 0L); }
public void TriggerDumpsterEx(Guid dbGuid, bool fTriggerSafetyNet, DateTime failoverTimeUtc, DateTime startTimeUtc, DateTime endTimeUtc, long lastLogGenBeforeActivation, long numLogsLost) { IADToplogyConfigurationSession iadtoplogyConfigurationSession = ADSessionFactory.CreatePartiallyConsistentRootOrgSession(true); IADDatabase db = iadtoplogyConfigurationSession.FindDatabaseByGuid(dbGuid); IADServer server = iadtoplogyConfigurationSession.FindServerByName(Environment.MachineName); IADDatabaseAvailabilityGroup dag = iadtoplogyConfigurationSession.FindDagByServer(server); ReplayConfiguration configuration = RemoteReplayConfiguration.TaskGetReplayConfig(dag, db, server); DumpsterRedeliveryWrapper.MarkRedeliveryRequired(configuration, failoverTimeUtc, startTimeUtc, endTimeUtc, lastLogGenBeforeActivation, numLogsLost); }
public void DoDumpsterRedeliveryIfRequired(Guid dbGuid) { IADToplogyConfigurationSession iadtoplogyConfigurationSession = ADSessionFactory.CreatePartiallyConsistentRootOrgSession(true); IADDatabase db = iadtoplogyConfigurationSession.FindDatabaseByGuid(dbGuid); IADServer server = iadtoplogyConfigurationSession.FindServerByName(Environment.MachineName); IADDatabaseAvailabilityGroup dag = iadtoplogyConfigurationSession.FindDagByServer(server); ReplayConfiguration replayConfig = RemoteReplayConfiguration.TaskGetReplayConfig(dag, db, server); DumpsterRedeliveryWrapper.DoRedeliveryIfRequired(replayConfig); }
protected override bool RunIndividualCheck(ReplayConfiguration configToCheck, RpcDatabaseCopyStatus2 copyStatus) { long replayQueueLength = copyStatus.GetReplayQueueLength(); if (copyStatus.ReplayQueueNotKeepingUp) { base.FailContinue(Strings.DatabaseReplayQueueNotKeepingUp(configToCheck.DisplayName, base.ServerName, replayQueueLength)); return(false); } return(true); }
protected override bool RunIndividualCheck(ReplayConfiguration configToCheck, RpcDatabaseCopyStatus2 copyStatus) { if ((this.UseReplayRpc() && copyStatus.CopyStatus == CopyStatusEnum.Failed) || (!this.UseReplayRpc() && configToCheck.ReplayState.ConfigBroken)) { string text = this.UseReplayRpc() ? copyStatus.ErrorMessage : configToCheck.ReplayState.ConfigBrokenMessage; text = ((!string.IsNullOrEmpty(text)) ? text : Strings.ReplicationCheckBlankMessage); base.FailContinue(Strings.DatabaseCopyFailedCheck(new LocalizedReplayConfigType(configToCheck.Type).ToString(), configToCheck.DisplayName, CopyStatus.Failed.ToString(), base.ServerName, text), this.UseReplayRpc() ? copyStatus.ErrorEventId : 0U); return(false); } return(true); }
protected override bool ShouldCheckConfig(ReplayConfiguration replayconfig) { bool result = IgnoreTransientErrors.HasPassed(base.GetDefaultErrorKey(typeof(DatabasesSuspendedCheck))); if (base.ShouldCheckConfig(replayconfig)) { ExTraceGlobals.HealthChecksTracer.TraceDebug <string, string>((long)this.GetHashCode(), "ShouldCheckConfig(): Config '{0}': Dependent check SuspendCheck passed: {1}.", replayconfig.DisplayName, result.ToString()); return(result); } return(false); }
public static void MarkRedeliveryRequired(ReplayConfiguration configuration, DateTime failoverTimeUtc, DateTime startTimeUtc, DateTime endTimeUtc, long lastLogGenBeforeActivation, long numLogsLost) { SafetyNetRedelivery.Tracer.TraceDebug(0L, "MarkRedeliveryRequired() for {0}({1}) called: failoverTimeUtc={2}, startTimeUtc={3}, endTimeUtc={4}, lastLogGenBeforeActivation={5}, numLogsLost={6}", new object[] { configuration.Name, configuration.Identity, failoverTimeUtc, startTimeUtc, endTimeUtc, lastLogGenBeforeActivation, numLogsLost }); if (endTimeUtc < startTimeUtc) { SafetyNetRedelivery.Tracer.TraceError <string, string>(0L, "MarkRedeliveryRequired() for {0}({1}) failed because endTimeUtc should not be less than startTimeUtc", configuration.Name, configuration.Identity); DiagCore.AssertOrWatson(false, "endTimeUtc ({0}) should not be less than startTimeUtc ({1}) !", new object[] { endTimeUtc, startTimeUtc }); throw new DumpsterInvalidResubmitRequestException(configuration.DatabaseName); } TimeSpan timeSpan = endTimeUtc.Subtract(startTimeUtc); TimeSpan timeSpan2 = TimeSpan.FromSeconds((double)RegistryParameters.DumpsterRedeliveryMaxTimeRangeInSecs); if (timeSpan > timeSpan2) { SafetyNetRedelivery.Tracer.TraceError(0L, "MarkRedeliveryRequired() for {0}({1}) failed because the request window ({2}) is larger than the maximum allowed of {3}", new object[] { configuration.Name, configuration.Identity, timeSpan, timeSpan2 }); throw new DumpsterInvalidResubmitRequestException(configuration.DatabaseName); } string text; ActiveManagerCore.GetDatabaseMountStatus(configuration.IdentityGuid, out text); SafetyNetInfo safetyNetInfo = new SafetyNetInfo(text, lastLogGenBeforeActivation, numLogsLost, failoverTimeUtc, startTimeUtc, endTimeUtc); SafetyNetInfoCache safetyNetTable = configuration.ReplayState.GetSafetyNetTable(); safetyNetTable.Update(safetyNetInfo); ReplayEventLogConstants.Tuple_DatabaseDumpsterRedeliveryRequired.LogEvent(null, new object[] { configuration.DatabaseName, startTimeUtc, endTimeUtc }); ReplayCrimsonEvents.DumpsterRedeliveryRequired.Log <string, Guid, string, long, long, DateTime, DateTime, DateTime, bool, bool>(configuration.DatabaseName, configuration.IdentityGuid, text, lastLogGenBeforeActivation, numLogsLost, failoverTimeUtc, startTimeUtc, endTimeUtc, false, true); }
protected override bool RunIndividualCheck(ReplayConfiguration configToCheck, RpcDatabaseCopyStatus2 copyStatus) { if (copyStatus.CopyStatus == CopyStatusEnum.DisconnectedAndHealthy) { base.FailContinue(Strings.DatabaseCopyDisconnectedCheck(new LocalizedReplayConfigType(configToCheck.Type).ToString(), configToCheck.DisplayName, CopyStatus.DisconnectedAndHealthy.ToString(), copyStatus.MailboxServer)); return(false); } if (copyStatus.CopyStatus == CopyStatusEnum.DisconnectedAndResynchronizing) { base.FailContinue(Strings.DatabaseCopyDisconnectedCheck(new LocalizedReplayConfigType(configToCheck.Type).ToString(), configToCheck.DisplayName, CopyStatus.DisconnectedAndResynchronizing.ToString(), copyStatus.MailboxServer)); return(false); } return(true); }
private static void LogSpecificRequestFailedEvent(ReplayConfiguration config, SafetyNetRequestKey snKey, SafetyNetInfo snInfo, string errorMessageFormatStr, params object[] messageParams) { if (SafetyNetRedelivery.Tracer.IsTraceEnabled(TraceType.ErrorTrace)) { SafetyNetRedelivery.Tracer.TraceError((long)config.GetHashCode(), "ProcessSingleRequest: Redelivery request ({2}) for {0}({1}) failed. Error: {3}", new object[] { config.Name, config.Identity, snKey, string.Format(errorMessageFormatStr, messageParams) }); } ReplayCrimsonEvents.DumpsterRedeliverySpecificRequestFailed.LogPeriodic <string, Guid, bool, DateTime, SafetyNetRequestKey, string, string>(config.Identity + snKey.ToString(), DiagCore.DefaultEventSuppressionInterval, config.DatabaseName, config.IdentityGuid, false, snKey.RequestCreationTimeUtc, snKey, snInfo.GetSerializedForm(), string.Format(errorMessageFormatStr, messageParams)); }
private static bool TryEnterLock(ReplayConfiguration config) { bool result; lock (SafetyNetRedelivery.s_inProgressRequests) { if (SafetyNetRedelivery.s_inProgressRequests.Contains(config.IdentityGuid)) { result = false; } else { SafetyNetRedelivery.s_inProgressRequests.Add(config.IdentityGuid); result = true; } } return(result); }
protected override bool ShouldCheckConfig(ReplayConfiguration replayconfig) { bool flag = IgnoreTransientErrors.HasPassed(base.GetDefaultErrorKey(typeof(DatabasesSuspendedCheck))); bool flag2 = IgnoreTransientErrors.HasPassed(base.GetDefaultErrorKey(typeof(DatabasesFailedCheck))); bool flag3 = flag && flag2; if (this.UseReplayRpc()) { bool flag4 = IgnoreTransientErrors.HasPassed(base.GetDefaultErrorKey(typeof(DatabasesInitializingCheck))); flag3 = (flag3 && flag4); } if (base.ShouldCheckConfig(replayconfig)) { ExTraceGlobals.HealthChecksTracer.TraceDebug <string, string, string>((long)this.GetHashCode(), "ShouldCheckConfig(): Config '{0}': Dependent checks SuspendCheck and FailedCheck {2} passed: {1}.", replayconfig.DisplayName, flag3.ToString(), this.UseReplayRpc() ? "and InitializingCheck" : string.Empty); return(flag3); } return(false); }
internal void SuspendDatabaseCopyIfNecessary(ReplayConfiguration config) { string text = string.Empty; text = config.TargetMachine; if (!this.m_fConfigOnly && !WmiWrapper.IsFileExisting(text, config.DestinationEdbPath)) { string fileName = string.Empty; fileName = Path.Combine(config.DestinationLogPath, EseHelper.MakeLogfileName(config.LogFilePrefix, "." + config.LogExtension, 1L)); if (!WmiWrapper.IsFileExisting(SharedHelper.GetFqdnNameFromNode(config.SourceMachine), fileName)) { try { this.WriteWarning(Strings.EnableDBCSuspendReplayNoDbComment(config.Name)); ReplayRpcClientWrapper.RequestSuspend(text, config.IdentityGuid, Strings.EnableDBCSuspendReplayNoDbComment(config.Name)); ReplayEventLogConstants.Tuple_DbSeedingRequired.LogEvent(null, new object[] { config.Name, text }); } catch (TaskServerTransientException ex) { ExTraceGlobals.CmdletsTracer.TraceDebug <TaskServerTransientException>((long)this.GetHashCode(), "SeedDatabase: Caught exception in RPC: {0}", ex); base.WriteError(new InvalidOperationException(Strings.SgcFailedToSuspendRpc(config.Name, ex.Message)), ErrorCategory.InvalidOperation, this.Identity); } catch (TaskServerException ex2) { ExTraceGlobals.CmdletsTracer.TraceDebug <TaskServerException>((long)this.GetHashCode(), "SeedDatabase: Caught exception in RPC: {0}", ex2); if (!(ex2 is ReplayServiceSuspendWantedSetException)) { if (ex2 is ReplayServiceSuspendRpcPartialSuccessCatalogFailedException) { base.WriteWarning(ex2.Message); } else { base.WriteError(new InvalidOperationException(Strings.SgcFailedToSuspendRpc(config.Name, ex2.Message)), ErrorCategory.InvalidOperation, this.Identity); } } } } } }
private void QueryDumpsterStats(Server mailboxServer, string databaseDn, ref MailboxDatabase entry) { List <string> serversWithServerRoleInSiteByServer = ReplayConfiguration.GetServersWithServerRoleInSiteByServer(ADObjectWrapperFactory.CreateWrapper(mailboxServer), ServerRole.HubTransport); List <string> list = new List <string>(); List <DumpsterStatisticsEntry> list2 = new List <DumpsterStatisticsEntry>(); foreach (string text in serversWithServerRoleInSiteByServer) { MailSubmissionServiceRpcClient mailSubmissionServiceRpcClient2; MailSubmissionServiceRpcClient mailSubmissionServiceRpcClient = mailSubmissionServiceRpcClient2 = new MailSubmissionServiceRpcClient(text); try { long ticksOldestItem = 0L; long queueSize = 0L; int numberOfItems = 0; long num = mailSubmissionServiceRpcClient.QueryDumpsterStats(databaseDn, ref ticksOldestItem, ref queueSize, ref numberOfItems); if (num != 0L) { ExTraceGlobals.CmdletsTracer.TraceError <string, long>((long)this.GetHashCode(), "GetDatabase.QueryDumpsterStats: RPC to server '{0}' returned {1}", text, num); list.Add(text); } else { list2.Add(new DumpsterStatisticsEntry(text, ticksOldestItem, queueSize, numberOfItems)); } } catch (RpcException) { list.Add(text); } finally { if (mailSubmissionServiceRpcClient2 != null) { ((IDisposable)mailSubmissionServiceRpcClient2).Dispose(); } } } entry.m_DumpsterStatistics = new DumpsterStatisticsEntry[list2.Count]; list2.CopyTo(entry.m_DumpsterStatistics); entry.m_DumpsterServersNotAvailable = new string[list.Count]; list.CopyTo(entry.m_DumpsterServersNotAvailable); }
protected override bool RunIndividualCheck(ReplayConfiguration configToCheck, RpcDatabaseCopyStatus2 copyStatus) { long queueLength; if (this.UseReplayRpc()) { queueLength = copyStatus.GetCopyQueueLength(); } else { queueLength = Math.Max(0L, configToCheck.ReplayState.CopyNotificationGenerationNumber - configToCheck.ReplayState.InspectorGenerationNumber); } if (copyStatus.CopyQueueNotKeepingUp) { base.FailContinue(Strings.DatabaseCopyQueueNotKeepingUp(configToCheck.DisplayName, base.ServerName, queueLength)); return(false); } return(true); }
public static void MarkRedeliveryRequired(ReplayConfiguration configuration, DateTime inspectorTime, long lastLogGenBeforeActivation, long numLogsLost) { DateTime utcNow = DateTime.UtcNow; SafetyNetRedelivery.Tracer.TraceDebug(0L, "Setting Dumpster re-delivery required for instance {0}. CreationTime {1}, StartTime {2}, LastLogGenBeforeActivation={3}, NumLogsLost={4}.", new object[] { configuration.Name, utcNow, inspectorTime, lastLogGenBeforeActivation, numLogsLost }); DiagCore.AssertOrWatson(inspectorTime > ReplayState.ZeroFileTime, "inspectorTime is '{0}' which is unexpected!", new object[] { inspectorTime }); DateTime utcNow2 = DateTime.UtcNow; DateTime startTimeUtc; DateTime endTimeUtc; SafetyNetRedelivery.GetConservativeLossTimes(inspectorTime, out startTimeUtc, out endTimeUtc); SafetyNetRedelivery.MarkRedeliveryRequired(configuration, utcNow2, startTimeUtc, endTimeUtc, lastLogGenBeforeActivation, numLogsLost); }
internal void SeedDatabase(ReplayConfiguration config) { ReplayState replayState = config.ReplayState; if (config is RemoteReplayConfiguration) { string targetMachine = config.TargetMachine; try { string machineFqdn = targetMachine; string destinationLogPath = config.DestinationLogPath; string destinationEdbPath = config.DestinationEdbPath; TDataObject dataObject = this.DataObject; AddDatabaseCopyTaskBase <TDataObject> .CheckSeedingPath(machineFqdn, destinationLogPath, destinationEdbPath, dataObject.LogFilePrefix); } catch (SeedingPathWarningException ex) { if (this.m_SeedingPostponedSpecified) { base.WriteWarning(ex.Message); } return; } catch (SeedingPathErrorException exception) { base.WriteError(exception, ErrorCategory.InvalidOperation, this.Identity); } SystemConfigurationTasksHelper.TryCreateDirectory(this.m_server.Fqdn, config.DestinationLogPath, Database_Directory.GetDomainWidePermissions(), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); using (TaskSeeder taskSeeder = this.ConstructSeeder()) { taskSeeder.SeedDatabase(); } return; } throw new NotSupportedException(config.GetType() + " is not supported"); }
internal abstract void ProcessRecordWorker(ReplayConfiguration replayConfiguration);
public static bool IsRedeliveryRequired(ReplayConfiguration replayConfig) { SafetyNetInfoCache safetyNetTable = replayConfig.ReplayState.GetSafetyNetTable(); return(safetyNetTable.IsRedeliveryRequired(true, true)); }
protected virtual bool ShouldCheckConfig(ReplayConfiguration replayconfig) { return(replayconfig.Type == ReplayConfigType.RemoteCopyTarget); }
protected abstract bool RunIndividualCheck(ReplayConfiguration configToCheck, RpcDatabaseCopyStatus2 copyStatus);
public static void MarkRedeliveryRequired(ReplayConfiguration configuration, DateTime inspectorTime, long lastLogGenBeforeActivation, long numLogsLost) { SafetyNetRedelivery.MarkRedeliveryRequired(configuration, inspectorTime, lastLogGenBeforeActivation, numLogsLost); }
internal override void ProcessRecordWorker(ReplayConfiguration replayConfiguration) { ExTraceGlobals.CmdletsTracer.TraceDebug <ObjectId, string>((long)this.GetHashCode(), "Suspend-DBC: ProcessRecordWorker: {0}, {1}", this.DataObject.Identity, this.SuspendComment); ExTraceGlobals.PFDTracer.TracePfd <int, ObjectId, string>((long)this.GetHashCode(), "PFD CRS {0} Suspend-DBC Initiated for : ProcessRecordWorker: {1}, {2}", 25051, this.DataObject.Identity, this.SuspendComment); if (this.EnableReplayLag) { Database database = this.DataObject.GetDatabase <Database>(); ReplayRpcClientHelper.RpccEnableReplayLag(base.Server.Name, database.Guid, ActionInitiatorType.Administrator); return; } if (this.SuspendComment != null && this.SuspendComment.Length > 512) { ExTraceGlobals.CmdletsTracer.TraceDebug((long)this.GetHashCode(), "Suspend-DBC {0}: ProcessRecordWorker: SuspendComment length (length={1}, max length={2}) is too long: {3}", new object[] { this.DataObject.Identity, this.SuspendComment.Length, 512, this.SuspendComment }); base.WriteError(new SuspendCommentTooLongException(this.SuspendComment.Length, 512), ErrorCategory.InvalidOperation, this.Identity); } if (!base.Stopping) { if (!base.UseRpc) { this.m_suspendThread = this.BeginSuspendUsingState(replayConfiguration); } else { this.m_suspendThread = base.BeginRpcOperation(); } try { TimeSpan timeSpan = base.UseRpc ? DatabaseCopyStateAction.TimeoutRpc : SuspendDatabaseCopy.Timeout; if (!this.m_suspendThread.Join(timeSpan)) { ExTraceGlobals.CmdletsTracer.TraceDebug <TimeSpan>((long)this.GetHashCode(), "Suspend-DBC: suspend is being slow: timeout={0}", timeSpan); this.WriteWarning(Strings.SuspendSgcTimeout); if (!base.UseRpc) { this.m_suspendThread.Join(); } else { this.m_event.WaitOne(); } } } finally { if (this.m_Exception != null) { if (this.m_Terminating) { base.ThrowTerminatingError(this.m_Exception, ErrorCategory.NotSpecified, null); } else { ErrorCategory category; this.TranslateException(ref this.m_Exception, out category); if (this.m_Exception is ReplayServiceSuspendWantedSetException) { base.WriteWarning(this.m_Exception.Message); this.m_fSuccess = true; } else if (this.m_Exception is ReplayServiceSuspendRpcPartialSuccessCatalogFailedException) { base.WriteWarning(this.m_Exception.Message); this.m_fSuccess = true; } else if (!this.m_fFallbackToState) { this.WriteError(this.m_Exception, category, null, false); } else if (!base.Stopping) { ExTraceGlobals.CmdletsTracer.TraceDebug <ObjectId>((long)this.GetHashCode(), "ProcessRecordWorker: There was an RPC connection error, so now falling back to Suspend through the State, for {0}.", this.DataObject.Identity); this.WriteWarning(Strings.SuspendSgcFallbackToState(this.DataObject.Identity.ToString(), this.m_Exception.Message)); } } } } } if (!this.m_fSuccess && base.Stopping) { ExTraceGlobals.CmdletsTracer.TraceDebug <ObjectId>((long)this.GetHashCode(), "Suspend was cancelled for {0}", this.DataObject.Identity); return; } if (!base.UseRpc && this.m_Exception == null && this.m_fSuccess) { replayConfiguration.ReplayState.SuspendMessage = this.SuspendComment; } else if (base.UseRpc && this.m_fFallbackToState) { ReplayConfiguration replayConfiguration2 = base.ConstructReplayConfiguration(this.DataObject.GetDatabase <Database>()); replayConfiguration2.ReplayState.SuspendLockRemote.EnterSuspend(); replayConfiguration2.ReplayState.SuspendMessage = this.SuspendComment; this.m_fSuccess = true; } if (this.m_fSuccess) { ExTraceGlobals.CmdletsTracer.TraceDebug <string, ObjectId>((long)this.GetHashCode(), "Suspended ({0}) for {1}", this.SuspendComment, this.DataObject.Identity); ExTraceGlobals.PFDTracer.TracePfd <int, string, ObjectId>((long)this.GetHashCode(), "PFD CRS {0} Sucessfully Suspended ({1}) for {2}", 20955, this.SuspendComment, this.DataObject.Identity); if (this.m_fFallbackToState) { ReplayEventLogConstants.Tuple_SuspendMarkedForDatabaseCopy.LogEvent(null, new object[] { this.DataObject.Identity }); } } TaskLogger.LogExit(); }