private static DateTime GetEventTime(MapiEventManager eventManager, long eventCounter)
{
MapiEvent[] array = eventManager.ReadEvents(eventCounter, 1);
if (array != null && array.Length != 0)
{
return(array[0].CreateTime);
}
return(DateTime.UtcNow);
}
public override MonitoringData InternalRunCheck()
{
MonitoringData monitoringData = new MonitoringData();
if (base.ExchangeServer.AdminDisplayVersion.Major < MailboxAssistantsWatermarks.minExpectedServerVersion.Major || (base.ExchangeServer.AdminDisplayVersion.Major == MailboxAssistantsWatermarks.minExpectedServerVersion.Major && base.ExchangeServer.AdminDisplayVersion.Minor < MailboxAssistantsWatermarks.minExpectedServerVersion.Minor))
{
monitoringData.Events.Add(new MonitoringEvent(AssistantTroubleshooterBase.EventSource, 5101, EventTypeEnumeration.Warning, Strings.TSMinServerVersion(MailboxAssistantsWatermarks.minExpectedServerVersion.ToString())));
return(monitoringData);
}
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=Management", base.ExchangeServer.Name, null, null, null))
{
List <MdbStatus> onlineMDBList = base.GetOnlineMDBList(exRpcAdmin);
foreach (MdbStatus mdbStatus in onlineMDBList)
{
Guid empty = Guid.Empty;
Watermark[] watermarksForMailbox = exRpcAdmin.GetWatermarksForMailbox(mdbStatus.MdbGuid, ref empty, Guid.Empty);
MapiEventManager mapiEventManager = MapiEventManager.Create(exRpcAdmin, Guid.Empty, mdbStatus.MdbGuid);
long eventCounter = mapiEventManager.ReadLastEvent().EventCounter;
bool flag = false;
foreach (Watermark watermark in watermarksForMailbox)
{
if (eventCounter - watermark.EventCounter > 50L)
{
flag = true;
break;
}
}
if (flag)
{
MailboxAssistantsWatermarks.WatermarkWithCreateTime[] array2 = MailboxAssistantsWatermarks.BuildWaterMarkWithCreateTimes(mapiEventManager, watermarksForMailbox);
DateTime eventTime = MailboxAssistantsWatermarks.GetEventTime(mapiEventManager, eventCounter);
List <MailboxAssistantsWatermarks.WatermarkWithCreateTime> list = new List <MailboxAssistantsWatermarks.WatermarkWithCreateTime>(watermarksForMailbox.Length);
foreach (MailboxAssistantsWatermarks.WatermarkWithCreateTime watermarkWithCreateTime in array2)
{
if (eventTime - watermarkWithCreateTime.CreateTime > this.WatermarkBehindWarningThrehold)
{
list.Add(watermarkWithCreateTime);
}
}
if (list.Count > 0)
{
monitoringData.Events.Add(new MonitoringEvent(AssistantTroubleshooterBase.EventSource, 5207, EventTypeEnumeration.Error, Strings.AIMDBWatermarksAreTooLow(base.ExchangeServer.Fqdn, mdbStatus.MdbName, ((int)this.WatermarkBehindWarningThrehold.TotalMinutes).ToString(), MailboxAssistantsWatermarks.BuildFormatedEventCounter(eventCounter, eventTime), MailboxAssistantsWatermarks.BuildFormatedWatermarks(list.ToArray()))));
}
}
}
}
return(monitoringData);
}
internal IEnumerable <DatabaseEvent> ReadEvents(MapiSession mapiSession, Database database, long startCounter, Restriction restriction, bool includeMoveDestinationEvents, int resultSize)
{
if (mapiSession == null)
{
throw new ArgumentException("mapiSession");
}
if (database == null)
{
throw new ArgumentException("database");
}
int count = 0;
long endCounter = (0L < startCounter) ? (startCounter - 1L) : 0L;
MapiEvent[] events = null;
DatabaseId databaseId = MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database);
MapiEventManager eventManager = MapiEventManager.Create(mapiSession.Administration, Guid.NewGuid(), databaseId.Guid);
for (;;)
{
startCounter = endCounter + 1L;
ReadEventsFlags flags = includeMoveDestinationEvents ? ReadEventsFlags.IncludeMoveDestinationEvents : ReadEventsFlags.None;
mapiSession.InvokeWithWrappedException(delegate()
{
events = eventManager.ReadEvents(startCounter, (0 < resultSize) ? resultSize : 1000, 0, restriction, flags, out endCounter);
}, Strings.ErrorCannotReadDatabaseEvents(databaseId.ToString()), databaseId);
foreach (MapiEvent mapiEvent in events)
{
yield return(new DatabaseEvent(mapiEvent, databaseId, this.server, database.Server.ObjectGuid == this.server.Guid));
count++;
if (0 < resultSize && count == resultSize)
{
goto Block_6;
}
}
if (endCounter == startCounter)
{
goto Block_8;
}
}
Block_6:
yield break;
Block_8:
yield break;
}
private void ConnectIfNecessary()
{
if (this.restartRequired)
{
ExTraceGlobals.EventAccessTracer.TraceError <EventAccess>((long)this.GetHashCode(), "{0}: Unable to connect; restart required", this);
throw new DatabaseRestartRequiredException();
}
if (this.exRpcAdmin == null)
{
bool flag = false;
ExTraceGlobals.EventAccessTracer.TraceDebug <EventAccess>((long)this.GetHashCode(), "{0}: Creating exRpcAdmin/eventManager...", this);
try
{
this.exRpcAdmin = ExRpcAdmin.Create("Client=EBA", null, null, null, null);
this.pollingEventManager = MapiEventManager.Create(this.exRpcAdmin, Guid.Empty, this.databaseInfo.Guid);
this.mapiEventManagers = new Dictionary <Guid, MapiEventManager>(this.assistantCollection.Count);
foreach (AssistantCollectionEntry assistantCollectionEntry in this.assistantCollection)
{
this.mapiEventManagers.Add(assistantCollectionEntry.Identity, MapiEventManager.Create(this.exRpcAdmin, assistantCollectionEntry.Identity, this.databaseInfo.Guid));
}
flag = true;
base.TracePfd("PFD AIS {0} {1}: Created eventManager successfully.", new object[]
{
25431,
this
});
}
finally
{
if (!flag)
{
ExTraceGlobals.EventAccessTracer.TraceError <EventAccess>((long)this.GetHashCode(), "{0}: Failed to create exRpcAdmin/eventManager.", this);
this.Disconnect();
}
}
}
}
private static MapiEvent[] ReadEvents(MapiEventManager mapiEventManager, object mapiEventManagerLock, long startCounter, int eventCountWanted, int eventCountToCheck, Restriction restriction, out long endCounter)
{
long num = 0L;
MapiEvent[] result = null;
StoreSession storeSession = null;
object thisObject = null;
bool flag = false;
try
{
if (storeSession != null)
{
storeSession.BeginMapiCall();
storeSession.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
lock (mapiEventManagerLock)
{
result = mapiEventManager.ReadEvents(startCounter, eventCountWanted, eventCountToCheck, restriction, ReadEventsFlags.FailIfEventsDeleted, false, out num);
}
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.ExCaughtMapiExceptionWhileReadingEvents, ex, storeSession, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("EventPump::ReadEvents. Caught MapiException while reading events.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.ExCaughtMapiExceptionWhileReadingEvents, ex2, storeSession, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("EventPump::ReadEvents. Caught MapiException while reading events.", new object[0]),
ex2
});
}
finally
{
try
{
if (storeSession != null)
{
storeSession.EndMapiCall();
if (flag)
{
storeSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
endCounter = num;
return(result);
}
internal EventPump(EventPumpManager eventPumpManager, string server, Guid mdbGuid)
{
StorageGlobals.TraceConstructIDisposable(this);
this.disposeTracker = this.GetDisposeTracker();
this.eventPumpManager = eventPumpManager;
this.server = server;
this.mdbGuid = mdbGuid;
this.threadLimiter = new EventPumpThreadLimiter(this);
StoreSession storeSession = null;
bool flag = false;
try
{
if (storeSession != null)
{
storeSession.BeginMapiCall();
storeSession.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
this.exRpcAdmin = ExRpcAdmin.Create("Client=EventPump", server, null, null, null);
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.ExFailedToCreateEventManager, ex, storeSession, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("EventPump::Constructor. Failed to create EventPump.", new object[0]),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.ExFailedToCreateEventManager, ex2, storeSession, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("EventPump::Constructor. Failed to create EventPump.", new object[0]),
ex2
});
}
finally
{
try
{
if (storeSession != null)
{
storeSession.EndMapiCall();
if (flag)
{
storeSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
StoreSession storeSession2 = null;
bool flag2 = false;
try
{
if (storeSession2 != null)
{
storeSession2.BeginMapiCall();
storeSession2.BeginServerHealthCall();
flag2 = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
this.mapiEventManager = MapiEventManager.Create(this.exRpcAdmin, Guid.Empty, this.mdbGuid);
}
catch (MapiPermanentException ex3)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.ExFailedToCreateEventManager, ex3, storeSession2, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("EventPump::Constructor. Failed to create EventPump.", new object[0]),
ex3
});
}
catch (MapiRetryableException ex4)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.ExFailedToCreateEventManager, ex4, storeSession2, this, "{0}. MapiException = {1}.", new object[]
{
string.Format("EventPump::Constructor. Failed to create EventPump.", new object[0]),
ex4
});
}
finally
{
try
{
if (storeSession2 != null)
{
storeSession2.EndMapiCall();
if (flag2)
{
storeSession2.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
this.lastEventCounter = this.ReadLastEventWatermark();
this.RegisterMainPump(EventPump.PollingTimeSpan);
ExTraceGlobals.EventTracer.TraceDebug <EventPump>((long)this.GetHashCode(), "EventPump::Constructor. {0}", this);
}
// Token: 0x06000011 RID: 17 RVA: 0x000028D4 File Offset: 0x00000AD4
internal static void DeleteWatermarksForDisabledAndDeprecatedAssistants(object stateNotUsed)
{
List <Guid> disabledEventAssistants = new List <Guid>(InfoworkerAssistants.EventBasedAssistantTypes.Length);
foreach (InfoworkerAssistants.EventAssistantConstructor eventAssistantConstructor in InfoworkerAssistants.EventBasedAssistantTypes)
{
if (InfoworkerAssistants.IsDisabled(eventAssistantConstructor.Name))
{
ExTraceGlobals.AssistantBaseTracer.TraceDebug <string>(0L, "[InfoworkerAssistants]: Event assistant '{0}' is disabled.", eventAssistantConstructor.Name);
disabledEventAssistants.Add(eventAssistantConstructor.Identity);
}
}
disabledEventAssistants.AddRange(InfoworkerAssistants.deprecatedAssistants);
if (disabledEventAssistants.Count == 0)
{
ExTraceGlobals.AssistantBaseTracer.TraceDebug(0L, "[InfoworkerAssistants]: There are no disabled or deprecated assistants.");
return;
}
ExTraceGlobals.AssistantBaseTracer.TraceDebug <int>(0L, "[InfoworkerAssistants]: There are {0} disabled and/or deprecated assistants.", disabledEventAssistants.Count);
Exception exception = null;
try
{
GrayException.MapAndReportGrayExceptions(delegate()
{
try
{
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=EBA", null, null, null, null))
{
MdbStatus[] array = exRpcAdmin.ListMdbStatus(false);
foreach (MdbStatus mdbStatus in array)
{
if (DatabaseManager.IsOnlineDatabase(mdbStatus))
{
foreach (Guid guid in disabledEventAssistants)
{
MapiEventManager mapiEventManager = MapiEventManager.Create(exRpcAdmin, guid, mdbStatus.MdbGuid);
ExTraceGlobals.AssistantBaseTracer.TraceDebug <Guid, string>(0L, "[InfoworkerAssistants]: Deleting watermarks for consumer {0} on database {1}.", guid, mdbStatus.MdbName);
mapiEventManager.DeleteWatermarks();
}
}
}
}
}
catch (MapiExceptionVersion exception2)
{
exception = exception2;
}
catch (MapiExceptionMdbOffline exception3)
{
exception = exception3;
}
catch (MapiExceptionExiting exception4)
{
exception = exception4;
}
catch (MapiExceptionNetworkError exception5)
{
exception = exception5;
}
catch (MapiExceptionADUnavailable exception6)
{
exception = exception6;
}
catch (MapiExceptionNoAccess exception7)
{
exception = exception7;
}
});
}
catch (GrayException exception)
{
GrayException exception8;
exception = exception8;
}
if (exception != null)
{
ExTraceGlobals.AssistantBaseTracer.TraceError <Exception>(0L, "[InfoworkerAssistants]: Failed to cleanup the watermarks at this time. Exception: {0}", exception);
}
}
internal IEnumerable <DatabaseEventWatermark> ReadWatermarks(MapiSession mapiSession, Database database, Guid?consumerGuid, Guid?mailboxGuid)
{
if (mapiSession == null)
{
throw new ArgumentException("mapiSession");
}
if (database == null)
{
throw new ArgumentException("database");
}
Watermark[] wms = null;
long lastCounter = 0L;
DatabaseId databaseId = MapiTaskHelper.ConvertDatabaseADObjectToDatabaseId(database);
if (consumerGuid != null)
{
MapiEventManager eventManager = MapiEventManager.Create(mapiSession.Administration, consumerGuid.Value, databaseId.Guid);
mapiSession.InvokeWithWrappedException(delegate()
{
lastCounter = eventManager.ReadLastEvent().EventCounter;
if (mailboxGuid != null)
{
Watermark watermark = eventManager.GetWatermark(mailboxGuid.Value);
wms = ((watermark == null) ? new Watermark[0] : new Watermark[]
{
watermark
});
return;
}
wms = eventManager.GetWatermarks();
}, Strings.ErrorCannotReadDatabaseWatermarks(databaseId.ToString()), databaseId);
foreach (Watermark wm in wms)
{
yield return(new DatabaseEventWatermark(wm, databaseId, lastCounter, this.server, database.Server.ObjectGuid == this.server.Guid));
}
}
else
{
GetDatabaseEventWatermark.< > c__DisplayClass7 CS$ < > 8__locals3 = new GetDatabaseEventWatermark.< > c__DisplayClass7();
CS$ < > 8__locals3.eventManager = MapiEventManager.Create(mapiSession.Administration, Guid.Empty, databaseId.Guid);
if (mailboxGuid != null)
{
CS$ < > 8__locals3.mailboxGuids = new Guid[]
{
mailboxGuid.Value
};
}
else if (database.IsPublicFolderDatabase)
{
CS$ < > 8__locals3.mailboxGuids = new Guid[]
{
Guid.Empty
};
}
else
{
PropValue[][] mailboxTable = null;
mapiSession.InvokeWithWrappedException(delegate()
{
mailboxTable = mapiSession.Administration.GetMailboxTable(databaseId.Guid, new PropTag[]
{
PropTag.UserGuid
});
}, Strings.ErrorCannotReadDatabaseWatermarks(databaseId.ToString()), databaseId);
CS$ < > 8__locals3.mailboxGuids = new Guid[mailboxTable.Length + 1];
CS$ < > 8__locals3.mailboxGuids[0] = Guid.Empty;
for (int j = 0; j < mailboxTable.Length; j++)
{
CS$ < > 8__locals3.mailboxGuids[j + 1] = new Guid(mailboxTable[j][0].GetBytes());
}
}
CS$ < > 8__locals3.databaseVersionGuid = Guid.Empty;
int i;
for (i = 0; i < CS$ < > 8__locals3.mailboxGuids.Length; i++)
{
mapiSession.InvokeWithWrappedException(delegate()
{
lastCounter = CS$ < > 8__locals3.eventManager.ReadLastEvent().EventCounter;
wms = mapiSession.Administration.GetWatermarksForMailbox(databaseId.Guid, ref CS$ < > 8__locals3.databaseVersionGuid, CS$ < > 8__locals3.mailboxGuids[i]);
}, Strings.ErrorCannotReadDatabaseWatermarks(databaseId.ToString()), databaseId);
foreach (Watermark wm2 in wms)
{
yield return(new DatabaseEventWatermark(wm2, databaseId, lastCounter, this.server, database.Server.ObjectGuid == this.server.Guid));
}
}
}
yield break;
}
private static MailboxAssistantsWatermarks.WatermarkWithCreateTime[] BuildWaterMarkWithCreateTimes(MapiEventManager eventManager, Watermark[] watermarks)
{
MailboxAssistantsWatermarks.WatermarkWithCreateTime[] array = new MailboxAssistantsWatermarks.WatermarkWithCreateTime[watermarks.Length];
for (int i = 0; i < watermarks.Length; i++)
{
DateTime eventTime = MailboxAssistantsWatermarks.GetEventTime(eventManager, watermarks[i].EventCounter);
array[i] = new MailboxAssistantsWatermarks.WatermarkWithCreateTime(watermarks[i].ConsumerGuid, watermarks[i].EventCounter, eventTime);
}
return(array);
}
