// Token: 0x060003E8 RID: 1000 RVA: 0x000128BC File Offset: 0x00010ABC
internal AssistantTaskContext ProcessNextTask(AssistantTaskContext context)
{
this.performanceCounters.NumberOfThreadsUsed.Increment();
AssistantTaskContext nextContext = null;
try
{
base.CatchMeIfYouCan(delegate
{
nextContext = this.ProcessOneMailbox(ref context);
}, this.Assistant.NonLocalizedName);
}
catch (AIException e)
{
if (context != null && context.Job != null)
{
context.Job.LogAIException(context.MailboxData, e);
}
else
{
AssistantsLog.LogErrorProcessingMailboxEvent(this.Assistant.NonLocalizedName, (context == null) ? null : context.MailboxData, e, this.DatabaseInfo.DatabaseName, "", MailboxSlaRequestType.Unknown);
}
}
catch (Exception e2)
{
AssistantsLog.LogErrorProcessingMailboxEvent(this.Assistant.NonLocalizedName, (context == null) ? null : context.MailboxData, e2, this.DatabaseInfo.DatabaseName, "", MailboxSlaRequestType.Unknown);
throw;
}
finally
{
this.performanceCounters.NumberOfThreadsUsed.Decrement();
}
return(nextContext);
}
private static string FormatMapiEvent(MapiEvent mapiEvent)
{
string text = string.Format("Counter: 0x{0,0:X}, MailboxGUID: {1}, Mask: {2}, Flags: {3}, ExtendedFlags: {4}, Object Class: {5}, Created Time: {6}, Item Type: {7}, Item EntryId: {8}, Parent entryId: {9}, Old Item entryId: {10}, Old parent entryId: {11}, SID: {12}, Client Type: {13}, Document ID: {14}", new object[]
{
mapiEvent.EventCounter,
mapiEvent.MailboxGuid,
mapiEvent.EventMask,
mapiEvent.EventFlags,
mapiEvent.ExtendedEventFlags,
mapiEvent.ObjectClass,
mapiEvent.CreateTime,
mapiEvent.ItemType,
AssistantsLog.FormatEntryId(mapiEvent.ItemEntryId),
AssistantsLog.FormatEntryId(mapiEvent.ParentEntryId),
AssistantsLog.FormatEntryId(mapiEvent.OldItemEntryId),
AssistantsLog.FormatEntryId(mapiEvent.OldParentEntryId),
(null != mapiEvent.Sid) ? mapiEvent.Sid.ToString() : "<null>",
mapiEvent.ClientType,
mapiEvent.DocumentId
});
if (ObjectType.MAPI_FOLDER == mapiEvent.ItemType)
{
text += string.Format(", Item Count: {0}, Unread Item Count: {1}", mapiEvent.ItemCount, mapiEvent.UnreadItemCount);
}
return(text);
}
private void LogStoreDriverMailboxFilterEvent(TimeSpan filterLogInterval, Guid activityId, Guid mailboxGuid, string mailboxDisplayNameTracingOnlyUsage, string message, MailboxSlaFilterReasonType filterReason, params object[] args)
{
DateTime utcNow = DateTime.UtcNow;
Tuple <string, MailboxSlaFilterReasonType> key = Tuple.Create <string, MailboxSlaFilterReasonType>(base.Assistant.NonLocalizedName, filterReason);
if (this.filterEventsLastLogDateTimes.ContainsKey(key) && utcNow - this.filterEventsLastLogDateTimes[key] < filterLogInterval)
{
return;
}
string arg = string.Format("{0}: ", this);
string text;
if (!string.IsNullOrEmpty(message))
{
if (args != null)
{
text = string.Format("{0}{1}", arg, string.Format(message, args));
}
else
{
text = string.Format("{0}{1}", arg, message);
}
}
else
{
text = string.Empty;
}
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), text);
AssistantsLog.LogMailboxFilteredEvent(activityId, base.Assistant.NonLocalizedName, base.Assistant as AssistantBase, text, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, filterReason);
this.filterEventsLastLogDateTimes[key] = utcNow;
}
private AssistantTaskContext ProcessStoreMailboxUnderPoisonControl(AssistantTaskContext context, EmergencyKit kit)
{
StoreMailboxData storeMailboxData = context.MailboxData as StoreMailboxData;
AssistantTaskContext result = null;
Guid activityId = (ActivityContext.ActivityId != null) ? ActivityContext.ActivityId.Value : Guid.Empty;
base.TracePfd("PFD AIS {0} {1}: ProcessMailbox: {2}", new object[]
{
23127,
this,
storeMailboxData.DisplayName
});
AssistantsLog.LogStartProcessingMailboxEvent(activityId, this.Assistant as AssistantBase, storeMailboxData.MailboxGuid, storeMailboxData.DisplayName, this);
bool flag = false;
IMailboxFilter mailboxFilter = this.Driver.AssistantType as IMailboxFilter;
if (mailboxFilter != null && mailboxFilter.MailboxType.Contains(MailboxType.InactiveMailbox))
{
flag = true;
ADSessionSettingsFactory.InactiveMailboxVisibilityEnabler.Enable();
}
try
{
result = this.ProcessStoreMailbox(context, kit);
}
finally
{
if (flag)
{
ADSessionSettingsFactory.InactiveMailboxVisibilityEnabler.Disable();
}
}
AssistantsLog.LogEndProcessingMailboxEvent(activityId, this.Assistant as AssistantBase, context.CustomDataToLog, storeMailboxData.MailboxGuid, storeMailboxData.DisplayName, this);
return(result);
}
internal static void LogEndProcessingMailboxEvent(Guid activityId, AssistantBase assistant, List <KeyValuePair <string, object> > customData, Guid mailboxGuid, string mailboxDisplayNameTracingOnlyUsage, TimeBasedDatabaseJob job = null)
{
AssistantsLog.InternalLogAssistantEvent(activityId, assistant, AssistantsEventType.EndProcessingMailbox, customData, mailboxGuid);
if (job != null)
{
AssistantsLog.LogMailboxSlaEvent(assistant, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, job, MailboxSlaEventType.EndProcessingMailbox, MailboxSlaFilterReasonType.None, null);
}
}
internal static void LogErrorProcessingMailboxEvent(string assistantName, MailboxData mailbox, Exception e, string databaseName = "", string jobId = "", MailboxSlaRequestType requestType = MailboxSlaRequestType.Unknown)
{
string value = string.Empty;
string value2 = "unknown";
string value3 = "unknown";
Guid guid = Guid.Empty;
string value4 = string.Empty;
string value5 = (e.InnerException != null) ? e.InnerException.GetType().ToString() : "null";
string diagnosticContext = AssistantsLog.GetDiagnosticContext(e);
Guid activityId = (ActivityContext.ActivityId != null) ? ActivityContext.ActivityId.Value : Guid.Empty;
if (mailbox != null)
{
value3 = mailbox.DatabaseGuid.ToString();
StoreMailboxData storeMailboxData = mailbox as StoreMailboxData;
if (storeMailboxData != null)
{
value2 = "Store";
guid = storeMailboxData.Guid;
if (storeMailboxData.OrganizationId != null)
{
value = storeMailboxData.OrganizationId.ToString();
}
}
else
{
AdminRpcMailboxData adminRpcMailboxData = mailbox as AdminRpcMailboxData;
if (adminRpcMailboxData != null)
{
value2 = "AdminRpc";
value4 = adminRpcMailboxData.MailboxNumber.ToString(CultureInfo.InvariantCulture);
}
}
}
List <KeyValuePair <string, object> > customData = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("MailboxType", value2),
new KeyValuePair <string, object>("MailboxGuid", guid),
new KeyValuePair <string, object>("MailboxId", value4),
new KeyValuePair <string, object>("TenantId", value),
new KeyValuePair <string, object>("Database", value3),
new KeyValuePair <string, object>("ExceptionType", e.GetType().ToString()),
new KeyValuePair <string, object>("InnerExceptionType", value5),
new KeyValuePair <string, object>("DiagnosticContext", diagnosticContext)
};
AssistantsLog.InternalLogRow(activityId, assistantName, null, AssistantsEventType.ErrorProcessingMailbox, customData, guid);
if (!string.IsNullOrEmpty(assistantName))
{
MailboxAssistantsSlaReportLogFactory.MailboxAssistantsSlaReportLog logInstance = MailboxAssistantsSlaReportLogFactory.GetLogInstance(assistantName, SlaLogType.MailboxSlaLog);
if (logInstance != null)
{
logInstance.LogMailboxEvent(assistantName, databaseName, jobId, requestType, guid, (mailbox == null) ? string.Empty : mailbox.DisplayName, MailboxSlaEventType.ErrorProcessingMailbox, MailboxSlaFilterReasonType.None, e);
}
}
}
internal static void LogStartProcessingMailboxEvent(Guid activityId, AssistantBase assistant, MapiEvent mapiEvent, Guid mailboxGuid)
{
ArgumentValidator.ThrowIfNull("mapiEvent", mapiEvent);
List <KeyValuePair <string, object> > customData = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("MapiEvent", AssistantsLog.FormatMapiEvent(mapiEvent))
};
AssistantsLog.InternalLogAssistantEvent(activityId, assistant, AssistantsEventType.StartProcessingMailbox, customData, mailboxGuid);
}
internal static void LogBeginJob(string assistantName, string databaseName, int startingPendingQueueCount)
{
List <KeyValuePair <string, object> > customData = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("DatabaseName", databaseName),
new KeyValuePair <string, object>("PendingQueueCount", startingPendingQueueCount)
};
AssistantsLog.InternalLogRow(Guid.Empty, assistantName, null, AssistantsEventType.BeginJob, customData, Guid.Empty);
}
internal static void LogMailboxFilteredEvent(Guid activityId, string assistantName, AssistantBase assistant, string reason, Guid mailboxGuid, string mailboxDisplayNameTracingOnlyUsage, MailboxSlaFilterReasonType filterReason)
{
List <KeyValuePair <string, object> > customData = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("Reason", reason)
};
AssistantsLog.InternalLogRow(activityId, assistantName, assistant, AssistantsEventType.FilterMailbox, customData, mailboxGuid);
AssistantsLog.LogMailboxSlaEvent(assistant, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, null, MailboxSlaEventType.FilterMailbox, filterReason, null);
}
internal static void LogEndGetMailboxesEvent(Guid activityId, string assistantName, int numberOfMailboxesToProcess, AssistantBase assistant)
{
List <KeyValuePair <string, object> > customData = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("MailboxesToProcess", numberOfMailboxesToProcess)
};
AssistantsLog.InternalLogRow(activityId, assistantName, null, AssistantsEventType.EndGetMailboxes, customData, Guid.Empty);
AssistantsLog.LogDatabaseSlaEvent(assistant, DatabaseSlaEventType.EndMailboxTableQuery, null);
}
internal void LogAIException(MailboxData mailbox, AIException e)
{
ExTraceGlobals.TimeBasedDatabaseJobTracer.TraceError <TimeBasedDatabaseJob, string, AIException>((long)this.GetHashCode(), "{0}: Exception on mailbox {1}: {2}", this, (mailbox == null) ? "No Mailbox Present" : mailbox.DisplayName, e);
base.LogEvent(AssistantsEventLogConstants.Tuple_TimeBasedAssistantFailed, null, new object[]
{
this.Assistant.Name,
(mailbox == null) ? "No Mailbox Present" : mailbox.MailboxGuid.ToString(),
e
});
AssistantsLog.LogErrorProcessingMailboxEvent(this.Assistant.NonLocalizedName, mailbox, e, this.DatabaseInfo.DatabaseName, this.StartTime.ToString("O"), (this is TimeBasedDatabaseWindowJob) ? MailboxSlaRequestType.Scheduled : MailboxSlaRequestType.OnDemand);
}
protected override void LogJobBegin(int initialPendingQueueCount)
{
base.StartTime = DateTime.UtcNow;
base.LogEvent(AssistantsEventLogConstants.Tuple_TimeWindowBegin, null, new object[]
{
base.Assistant.Name,
base.DatabaseInfo.DisplayName,
initialPendingQueueCount
});
AssistantsLog.LogBeginJob(base.Assistant.NonLocalizedName, base.DatabaseInfo.DisplayName, initialPendingQueueCount);
}
private static void InternalLogRow(Guid activityId, string assistantShortName, AssistantBase assistant, AssistantsEventType eventType, List <KeyValuePair <string, object> > customData, Guid mailboxGuid)
{
if (!AssistantsLog.Instance.Enabled)
{
AssistantsLog.Instance.SafeTraceDebug(0L, "Mailbox assistant log is disabled, skip writing to the log file.", new object[0]);
return;
}
if (AssistantsLog.LogDisabledAssistants.Contains(assistantShortName))
{
AssistantsLog.Instance.SafeTraceDebug(0L, "Mailbox assistant '{0}' is disabled for logging, skip writing to the log file.", new object[]
{
assistantShortName
});
return;
}
string text = string.Empty;
if (assistant != null && assistant.DatabaseInfo != null)
{
text = assistant.DatabaseInfo.DatabaseName;
}
LogRowFormatter logRowFormatter = new LogRowFormatter(AssistantsLog.Instance.LogSchema);
if (AssistantsLog.Instance.IsDebugTraceEnabled)
{
string text2 = string.Empty;
if (customData != null)
{
bool flag;
text2 = LogRowFormatter.FormatCollection(customData, out flag);
}
AssistantsLog.Instance.SafeTraceDebug(0L, "Start writing row to mailbox assistant log: ServerName='{0}', Location='{1}', AssistantName='{2}', ActivityId='{3}', TargetObject='{4}', Event='{5}', CustomData='{6}'", new object[]
{
AssistantsLog.Instance.ServerName,
text,
assistantShortName,
activityId,
mailboxGuid,
AssistantsLog.stringDictionary[eventType],
text2
});
}
logRowFormatter[1] = AssistantsLog.Instance.ServerName;
logRowFormatter[3] = assistantShortName;
logRowFormatter[6] = AssistantsLog.stringDictionary[eventType];
logRowFormatter[2] = text;
logRowFormatter[7] = customData;
logRowFormatter[5] = ((mailboxGuid == Guid.Empty) ? string.Empty : mailboxGuid.ToString("D"));
logRowFormatter[4] = ((activityId == Guid.Empty) ? string.Empty : activityId.ToString("D"));
AssistantsLog.Append(logRowFormatter);
AssistantsLog.Instance.SafeTraceDebug(0L, "The above row is written to mailbox assistant log successfully.", new object[0]);
}
protected override void InternalLogActivityEvent(IActivityScope activityScope, ActivityEventType eventType)
{
object userState = activityScope.UserState;
AssistantBase assistantBase = null;
string assistantShortName;
if (activityScope.ActivityType == ActivityType.Global)
{
assistantShortName = "GlobalActivity";
}
else
{
SystemTaskBase systemTaskBase = userState as SystemTaskBase;
if (systemTaskBase != null)
{
assistantShortName = systemTaskBase.Workload.Id;
}
else
{
AssistantBase assistantBase2 = userState as AssistantBase;
if (assistantBase2 == null)
{
return;
}
assistantBase = assistantBase2;
assistantShortName = assistantBase.NonLocalizedName;
}
}
AssistantsEventType eventType2;
switch (eventType)
{
case ActivityEventType.SuspendActivity:
eventType2 = AssistantsEventType.SuspendActivity;
goto IL_92;
case ActivityEventType.EndActivity:
eventType2 = AssistantsEventType.EndActivity;
goto IL_92;
}
base.SafeTraceDebug(0L, "Skip logging ActivityEvent '{0}'.", new object[]
{
eventType
});
return;
IL_92:
List <KeyValuePair <string, object> > customData = WorkloadManagementLogger.FormatWlmActivity(activityScope, true);
AssistantsLog.InternalLogRow(activityScope.ActivityId, assistantShortName, assistantBase, eventType2, customData, Guid.Empty);
}
// Token: 0x060003E9 RID: 1001 RVA: 0x00012A0C File Offset: 0x00010C0C
internal void UpdateWorkCycle(TimeSpan workCyclePeriod)
{
bool flag = false;
bool flag2 = false;
lock (this.instanceLock)
{
if (this.assistantWorkloadState == TimeBasedDatabaseDriver.AssistantWorkloadStateOnDatabase.Enabled || this.assistantWorkloadState == TimeBasedDatabaseDriver.AssistantWorkloadStateOnDatabase.EnabledAndRunning)
{
flag = true;
if (this.assistantWorkloadState == TimeBasedDatabaseDriver.AssistantWorkloadStateOnDatabase.Enabled)
{
this.windowJobHistory.Clear();
this.startTime = DateTime.UtcNow;
this.assistantWorkloadState = TimeBasedDatabaseDriver.AssistantWorkloadStateOnDatabase.EnabledAndRunning;
}
if (!this.inWorkCycle)
{
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedDatabaseDriver, bool, bool>((long)this.GetHashCode(), "{0}: Start Work Cycle. Started: {1}, Job Running: {2}.", this, this.started, this.WindowJobRunning);
if (!this.started)
{
AssistantsLog.LogDriverNotStartedEvent(this.Assistant.NonLocalizedName, this.Assistant as AssistantBase);
}
else if (this.WindowJobRunning)
{
AssistantsLog.LogJobAlreadyRunningEvent(this.Assistant.NonLocalizedName);
}
else
{
flag2 = true;
}
}
}
else if (this.assistantWorkloadState == TimeBasedDatabaseDriver.AssistantWorkloadStateOnDatabase.Disabled)
{
this.windowJobHistory.Clear();
this.startTime = DateTime.UtcNow;
this.assistantWorkloadState = TimeBasedDatabaseDriver.AssistantWorkloadStateOnDatabase.DisabledAndNotRunning;
}
}
if (flag && !this.inWorkCycle)
{
if (flag2)
{
this.assistantType.OnWorkCycleStart(this.DatabaseInfo);
this.TryStartWorkCycle(workCyclePeriod);
}
this.inWorkCycle = true;
}
}
// Token: 0x060003DB RID: 987 RVA: 0x000123A4 File Offset: 0x000105A4
public void Start()
{
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedDatabaseDriver>((long)this.GetHashCode(), "{0}: Starting...", this);
lock (this.instanceLock)
{
this.started = true;
AssistantsLog.LogDatabaseStartEvent(this.Assistant as AssistantBase);
}
base.TracePfd("PFD AIS {0} {1}: Started", new object[]
{
30295,
this
});
}
internal static void LogErrorEnumeratingMailboxes(ITimeBasedAssistant assistant, Guid mailboxGuid, Exception exception, bool isExceptionHandled)
{
string value = (exception.InnerException != null) ? exception.InnerException.GetType().ToString() : string.Empty;
List <KeyValuePair <string, object> > customData = new List <KeyValuePair <string, object> >
{
new KeyValuePair <string, object>("MailboxGuid", mailboxGuid.ToString()),
new KeyValuePair <string, object>("ExceptionType", exception.GetType().ToString()),
new KeyValuePair <string, object>("InnerExceptionType", value),
new KeyValuePair <string, object>("IsExceptionHandled", isExceptionHandled.ToString()),
new KeyValuePair <string, object>("ExceptionDetail", exception.ToString())
};
AssistantsLog.InternalLogRow(Guid.Empty, (assistant != null) ? assistant.NonLocalizedName : string.Empty, null, AssistantsEventType.ErrorEnumeratingMailbox, customData, Guid.Empty);
AssistantsLog.LogDatabaseSlaEvent(assistant as AssistantBase, DatabaseSlaEventType.ErrorMailboxTableQuery, exception);
}
protected override void LogJobEnd(int initialPendingQueueCount, int mailboxesProcessedSuccessfullyCount, int mailboxesProcessedFailureCount, int mailboxesFailedToOpenStoreSessionCount, int mailboxesProcessedSeparatelyCount, int mailboxesRetriedCount)
{
int num = initialPendingQueueCount - mailboxesProcessedSuccessfullyCount - mailboxesProcessedFailureCount - mailboxesFailedToOpenStoreSessionCount - mailboxesProcessedSeparatelyCount + mailboxesRetriedCount;
base.EndTime = DateTime.UtcNow;
AssistantEndWorkCycleCheckpointStatistics assistantEndWorkCycleCheckpointStatistics = new AssistantEndWorkCycleCheckpointStatistics
{
DatabaseName = base.DatabaseInfo.DisplayName,
StartTime = base.StartTime,
EndTime = base.EndTime,
TotalMailboxCount = initialPendingQueueCount,
ProcessedMailboxCount = mailboxesProcessedSuccessfullyCount,
MailboxErrorCount = mailboxesProcessedFailureCount,
FailedToOpenStoreSessionCount = mailboxesFailedToOpenStoreSessionCount,
RetriedMailboxCount = mailboxesRetriedCount,
MailboxesProcessedSeparatelyCount = mailboxesProcessedSeparatelyCount,
MailboxRemainingCount = num
};
AssistantsLog.LogEndJobEvent(base.Assistant.NonLocalizedName, assistantEndWorkCycleCheckpointStatistics.FormatCustomData());
if (mailboxesProcessedSuccessfullyCount == 0 && initialPendingQueueCount != 0)
{
base.LogEvent(AssistantsEventLogConstants.Tuple_DatabaseNotProcessedInTimeWindow, null, new object[]
{
base.Assistant.Name,
base.DatabaseInfo.DisplayName,
mailboxesProcessedFailureCount,
mailboxesFailedToOpenStoreSessionCount,
mailboxesRetriedCount,
num
});
return;
}
base.LogEvent(AssistantsEventLogConstants.Tuple_TimeWindowEnd, null, new object[]
{
base.Assistant.Name,
base.DatabaseInfo.DisplayName,
base.EndTime.Subtract(base.StartTime),
mailboxesProcessedSuccessfullyCount,
mailboxesProcessedFailureCount,
mailboxesProcessedSeparatelyCount,
mailboxesFailedToOpenStoreSessionCount,
mailboxesRetriedCount,
num
});
}
internal static void LogMailboxFailedToOpenStoreSessionEvent(Guid activityId, string assistantName, AssistantBase assistant, Exception storeSessionException, Guid mailboxGuid, string mailboxDisplayNameTracingOnlyUsage, TimeBasedDatabaseJob job)
{
List <KeyValuePair <string, object> > list = new List <KeyValuePair <string, object> >();
if (storeSessionException != null)
{
list.Add(new KeyValuePair <string, object>("ExceptionType", storeSessionException.GetType().ToString()));
list.Add(new KeyValuePair <string, object>("ExceptionMessage", storeSessionException.Message));
if (storeSessionException.InnerException != null)
{
list.Add(new KeyValuePair <string, object>("InnerExceptionType", storeSessionException.InnerException.GetType().ToString()));
list.Add(new KeyValuePair <string, object>("InnerExceptionMessage", storeSessionException.InnerException.Message));
}
}
AssistantsLog.InternalLogRow(activityId, assistantName, assistant, AssistantsEventType.FailedOpenMailboxStoreSession, list, mailboxGuid);
AssistantsLog.LogMailboxSlaEvent(assistant, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, job, MailboxSlaEventType.FailedOpenMailboxStoreSession, MailboxSlaFilterReasonType.None, storeSessionException);
}
protected override List <MailboxData> GetMailboxesForCurrentWindow(out int totalMailboxOnDatabaseCount, out int notInterestingMailboxCount, out int filteredMailboxCount, out int failedFilteringCount)
{
List <MailboxData> list = base.Assistant.GetMailboxesToProcess();
list = (list ?? new List <MailboxData>());
totalMailboxOnDatabaseCount = list.Count;
notInterestingMailboxCount = 0;
filteredMailboxCount = 0;
failedFilteringCount = 0;
Guid activityId = Guid.NewGuid();
foreach (MailboxData mailboxData in list)
{
AssistantsLog.LogMailboxInterestingEvent(activityId, base.Assistant.NonLocalizedName, base.Assistant as AssistantBase, null, mailboxData.MailboxGuid, mailboxData.DisplayName);
}
return(list);
}
// Token: 0x060003DC RID: 988 RVA: 0x00012430 File Offset: 0x00010630
public void RequestStop()
{
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedDatabaseDriver>((long)this.GetHashCode(), "{0}: Requesting stop", this);
AIBreadcrumbs.ShutdownTrail.Drop("Stopping time assistant: " + this.Assistant.NonLocalizedName);
this.Assistant.OnShutdown();
AIBreadcrumbs.ShutdownTrail.Drop("Finished stopping " + this.Assistant.NonLocalizedName);
lock (this.instanceLock)
{
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedDatabaseDriver>((long)this.GetHashCode(), "{0}: Stopping all jobs", this);
this.StopAllJobs();
this.started = false;
AssistantsLog.LogDatabaseStopEvent(this.Assistant as AssistantBase);
}
base.TracePfd("PFD AIS {0} {1}: Requested Stop.", new object[]
{
19031,
this
});
}
private AssistantTaskContext ProcessAdminRpcMailboxUnderPoisonControl(AssistantTaskContext context, EmergencyKit kit)
{
TimeBasedDatabaseJob.processMailboxTestHook.Value();
AssistantTaskContext result = null;
Guid activityId = (ActivityContext.ActivityId != null) ? ActivityContext.ActivityId.Value : Guid.Empty;
if (context.Args == null)
{
context.Args = InvokeArgs.Create(null, this.Driver.TimePerTask, context.MailboxData);
}
AssistantsLog.LogStartProcessingMailboxEvent(activityId, this.Assistant as AssistantBase, context.MailboxData.MailboxGuid, context.MailboxData.DisplayName, this);
try
{
kit.SetContext(this.Assistant, context.MailboxData);
result = context.Step(context);
}
finally
{
kit.UnsetContext();
}
AssistantsLog.LogEndProcessingMailboxEvent(activityId, this.Assistant as AssistantBase, context.CustomDataToLog, context.MailboxData.MailboxGuid, context.MailboxData.DisplayName, this);
return(result);
}
internal static void LogEndJobEvent(string assistantName, List <KeyValuePair <string, object> > customData)
{
AssistantsLog.InternalLogRow(Guid.Empty, assistantName, null, AssistantsEventType.EndJob, customData, Guid.Empty);
}
internal static void LogDatabaseStopEvent(AssistantBase assistant)
{
AssistantsLog.LogDatabaseSlaEvent(assistant, DatabaseSlaEventType.StopDatabase, null);
}
private static void InternalLogAssistantEvent(Guid activityId, AssistantBase assistant, AssistantsEventType eventType, List <KeyValuePair <string, object> > customData, Guid mailboxGuid)
{
string assistantShortName = (assistant == null) ? "Unknown" : assistant.NonLocalizedName;
AssistantsLog.InternalLogRow(activityId, assistantShortName, assistant, eventType, customData, mailboxGuid);
}
internal static void LogDriverNotStartedEvent(string assistantName, AssistantBase assistant)
{
AssistantsLog.InternalLogRow(Guid.Empty, assistantName, null, AssistantsEventType.DriverNotStarted, null, Guid.Empty);
AssistantsLog.LogDatabaseSlaEvent(assistant, DatabaseSlaEventType.DatabaseIsStopped, null);
}
internal static void LogJobAlreadyRunningEvent(string assistantName)
{
AssistantsLog.InternalLogRow(Guid.Empty, assistantName, null, AssistantsEventType.JobAlreadyRunning, null, Guid.Empty);
}
internal static void LogNoMailboxesPendingEvent(string assistantName)
{
AssistantsLog.InternalLogRow(Guid.Empty, assistantName, null, AssistantsEventType.NoMailboxes, null, Guid.Empty);
}
protected override List <MailboxData> GetMailboxesForCurrentWindow(out int totalMailboxOnDatabaseCount, out int notInterestingMailboxCount, out int filteredMailboxCount, out int failedFilteringCount)
{
Guid activityId = Guid.NewGuid();
PropTag[] mailboxProperties = this.GetMailboxProperties();
PropValue[][] mailboxes = MailboxTableQuery.GetMailboxes("Client=TBA", base.DatabaseInfo, mailboxProperties);
totalMailboxOnDatabaseCount = ((mailboxes == null) ? 0 : mailboxes.Length);
notInterestingMailboxCount = 0;
filteredMailboxCount = 0;
failedFilteringCount = 0;
AssistantsLog.LogGetMailboxesQueryEvent(activityId, base.Assistant.NonLocalizedName, totalMailboxOnDatabaseCount, base.Assistant as AssistantBase);
if (mailboxes == null)
{
return(new List <MailboxData>());
}
List <MailboxInformation> list3 = new List <MailboxInformation>(mailboxes.Length);
Guid mailboxGuid = Guid.Empty;
VariantConfigurationSnapshot snapshot = VariantConfiguration.GetSnapshot(DatabaseSettingsContext.Get(base.DatabaseInfo.Guid), null, null);
TimeSpan notInterestingLogInterval = snapshot.MailboxAssistants.GetObject <IMailboxAssistantSettings>(base.AssistantType.Identifier, new object[0]).MailboxNotInterestingLogInterval;
int filteredMailboxCountLocal = 0;
int notInterestingMailboxCountLocal = 0;
string traceMessage;
foreach (PropValue[] propertiesForDelegateClosure2 in mailboxes)
{
try
{
PropValue[] propertiesForDelegateClosure = propertiesForDelegateClosure2;
List <MailboxInformation> list = list3;
base.CatchMeIfYouCan(delegate
{
PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.UserGuid);
PropValue mailboxProperty2 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.DisplayName);
string mailboxDisplayNameTracingOnlyUsage = (mailboxProperty2.IsNull() || mailboxProperty2.Value == null) ? string.Empty : mailboxProperty2.Value.ToString();
if (mailboxProperty.PropTag != PropTag.UserGuid || mailboxProperty2.PropTag != PropTag.DisplayName)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNoGuidFilter, MailboxSlaFilterReasonType.NoGuid, new object[]
{
mailboxProperty.Value
});
filteredMailboxCountLocal++;
return;
}
byte[] bytes = mailboxProperty.GetBytes();
if (bytes != null && bytes.Length == 16)
{
mailboxGuid = new Guid(bytes);
}
if (MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.DateDiscoveredAbsentInDS).PropTag == PropTag.DateDiscoveredAbsentInDS)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNotInDirectoryFilter, MailboxSlaFilterReasonType.NotInDirectory, new object[0]);
filteredMailboxCountLocal++;
return;
}
PropValue mailboxProperty3 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.MailboxMiscFlags);
MailboxMiscFlags @int = (MailboxMiscFlags)mailboxProperty3.GetInt(0);
if ((@int & MailboxMiscFlags.CreatedByMove) == MailboxMiscFlags.CreatedByMove)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxMoveDestinationFilter, MailboxSlaFilterReasonType.MoveDestination, new object[0]);
filteredMailboxCountLocal++;
return;
}
MailboxMiscFlags mailboxMiscFlags = @int & (MailboxMiscFlags.DisabledMailbox | MailboxMiscFlags.SoftDeletedMailbox | MailboxMiscFlags.MRSSoftDeletedMailbox);
if (mailboxMiscFlags != MailboxMiscFlags.None)
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxInaccessibleFilter, MailboxSlaFilterReasonType.Inaccessible, new object[]
{
mailboxMiscFlags
});
filteredMailboxCountLocal++;
return;
}
IMailboxFilter mailboxFilter = this.AssistantType as IMailboxFilter;
if (mailboxFilter != null && mailboxProperty3.PropTag == PropTag.MailboxMiscFlags)
{
MailboxMiscFlags int2 = (MailboxMiscFlags)mailboxProperty3.GetInt();
bool flag = (int2 & MailboxMiscFlags.ArchiveMailbox) == MailboxMiscFlags.ArchiveMailbox;
if (flag && !mailboxFilter.MailboxType.Contains(MailboxType.Archive))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxArchiveFilter, MailboxSlaFilterReasonType.Archive, new object[0]);
filteredMailboxCountLocal++;
return;
}
}
ControlData controlData = ControlData.Empty;
if (this.AssistantType.ControlDataPropertyDefinition != null)
{
PropValue mailboxProperty4 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, (PropTag)this.AssistantType.ControlDataPropertyDefinition.PropertyTag);
if (mailboxProperty4.PropTag == (PropTag)this.AssistantType.ControlDataPropertyDefinition.PropertyTag)
{
controlData = ControlData.CreateFromByteArray(mailboxProperty4.GetBytes());
}
}
TenantPartitionHint tenantPartitionHint = null;
PropValue mailboxProperty5 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.PersistableTenantPartitionHint);
if (mailboxProperty5.PropTag == PropTag.PersistableTenantPartitionHint)
{
byte[] bytes2 = mailboxProperty5.GetBytes();
if (bytes2 != null && bytes2.Length != 0)
{
tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes2);
}
}
MailboxInformation mailboxInformation2 = MailboxInformation.Create(mailboxProperty.GetBytes(), this.DatabaseInfo.Guid, mailboxProperty2.GetString(), controlData, propertiesForDelegateClosure, MailboxInformation.GetLastLogonTime(propertiesForDelegateClosure), tenantPartitionHint);
if (!this.DatabaseInfo.IsUserMailbox(mailboxInformation2.MailboxGuid))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNotUserFilter, MailboxSlaFilterReasonType.NotUser, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (mailboxInformation2.MailboxData.IsPublicFolderMailbox && (mailboxFilter == null || !mailboxFilter.MailboxType.Contains(MailboxType.PublicFolder)))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxPublicFolderFilter, MailboxSlaFilterReasonType.PublicFolder, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (this.IsMailboxInDemandJob(mailboxInformation2.MailboxData))
{
this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxInDemandJobFilter, MailboxSlaFilterReasonType.InDemandJob, new object[0]);
filteredMailboxCountLocal++;
return;
}
if (this.AssistantType.MailboxExtendedProperties != null)
{
if (!this.AssistantType.IsMailboxInteresting(mailboxInformation2))
{
traceMessage = string.Format("{0}: {1} is not interesting for the assistant {2}.", this, mailboxGuid, this.Assistant.NonLocalizedName);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
DateTime utcNow = DateTime.UtcNow;
if (!this.notInterestingEventsLastLogDateTimes.ContainsKey(this.Assistant.NonLocalizedName) || utcNow - this.notInterestingEventsLastLogDateTimes[this.Assistant.NonLocalizedName] >= notInterestingLogInterval)
{
AssistantsLog.LogMailboxNotInterestingEvent(activityId, this.Assistant.NonLocalizedName, this.Assistant as AssistantBase, mailboxGuid, mailboxDisplayNameTracingOnlyUsage);
this.notInterestingEventsLastLogDateTimes[this.Assistant.NonLocalizedName] = utcNow;
}
notInterestingMailboxCountLocal++;
return;
}
}
else
{
traceMessage = string.Format("{0}: {1} mailbox properties are null, IsMailboxInteresting was not called.", this, mailboxGuid);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
}
traceMessage = string.Format("{0}: {1} is interesting for the assistant {2}.", this, mailboxGuid, this.Assistant.NonLocalizedName);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
AssistantsLog.LogMailboxInterestingEvent(activityId, this.Assistant.NonLocalizedName, this.Assistant as AssistantBase, null, mailboxGuid, mailboxDisplayNameTracingOnlyUsage);
list.Add(mailboxInformation2);
}, base.AssistantType.NonLocalizedName);
}
catch (AIException exception)
{
failedFilteringCount++;
AssistantsLog.LogErrorEnumeratingMailboxes(base.Assistant, mailboxGuid, exception, true);
}
catch (Exception exception2)
{
AssistantsLog.LogErrorEnumeratingMailboxes(base.Assistant, mailboxGuid, exception2, false);
throw;
}
}
traceMessage = string.Format("{0}: {1} mailboxes after filtering", this, list3.Count);
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage);
if (this.firstIteration || base.AssistantType.WorkCycleCheckpoint < base.AssistantType.WorkCycle)
{
int count = list3.Count;
list3 = list3.FindAll((MailboxInformation mailbox) => DateTime.UtcNow - mailbox.LastProcessedDate > base.AssistantType.WorkCycle - base.AssistantType.WorkCycleCheckpoint);
this.firstIteration = false;
filteredMailboxCountLocal += count - list3.Count;
}
list3.Sort((MailboxInformation m1, MailboxInformation m2) => m1.LastProcessedDate.CompareTo(m2.LastProcessedDate));
List <MailboxData> list2 = new List <MailboxData>();
foreach (MailboxInformation mailboxInformation in list3)
{
list2.Add(mailboxInformation.MailboxData);
}
AssistantsLog.LogEndGetMailboxesEvent(activityId, base.Assistant.NonLocalizedName, list2.Count, base.Assistant as AssistantBase);
filteredMailboxCount = filteredMailboxCountLocal;
notInterestingMailboxCount = notInterestingMailboxCountLocal;
return(list2);
}
internal static void LogFolderSyncExceptionEvent(Guid activityId, string assistantName, List <KeyValuePair <string, object> > customData)
{
AssistantsLog.InternalLogRow(activityId, assistantName, null, AssistantsEventType.FolderSyncException, customData, Guid.Empty);
}
