private string GetErrorStringBasedOnDatabaseCopyState()
{
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=StoreActiveMonitoring", this.targetServer.Name, null, null, null))
{
MdbStatus[] array = exRpcAdmin.ListMdbStatus(new Guid[]
{
this.database.Guid
});
if (array.Length != 0)
{
if (this.isDatabaseCopyActive)
{
if ((array[0].Status & MdbStatusFlags.Online) != MdbStatusFlags.Online)
{
return(Strings.MapiTransactionDiagnosticTargetDatabaseDismounted);
}
}
else if ((array[0].Status & MdbStatusFlags.AttachedReadOnly) != MdbStatusFlags.AttachedReadOnly)
{
return(Strings.MapiTransactionDiagnosticTargetDatabaseNotAttached);
}
}
}
return(null);
}
private static bool IsStoreDisconnectedMailboxInternal(ExRpcAdmin rpcAdmin, Guid mdbGuid, Guid mailboxGuid)
{
PropValue[][] mailboxTableInfo = rpcAdmin.GetMailboxTableInfo(mdbGuid, mailboxGuid, MailboxTableFlags.IncludeSoftDeletedMailbox, new PropTag[]
{
PropTag.UserGuid,
PropTag.MailboxMiscFlags
});
if (mailboxTableInfo == null)
{
throw new RecipientNotFoundPermanentException(mailboxGuid);
}
foreach (PropValue[] array2 in mailboxTableInfo)
{
if (array2.Length == 2 && array2[0].PropTag == PropTag.UserGuid)
{
byte[] bytes = array2[0].GetBytes();
Guid a = (bytes != null && bytes.Length == 16) ? new Guid(bytes) : Guid.Empty;
if (!(a != mailboxGuid))
{
MailboxMiscFlags mailboxMiscFlags = (MailboxMiscFlags)((array2[1].PropTag == PropTag.MailboxMiscFlags) ? array2[1].GetInt() : 0);
return(mailboxMiscFlags.HasFlag(MailboxMiscFlags.SoftDeletedMailbox) || mailboxMiscFlags.HasFlag(MailboxMiscFlags.DisabledMailbox) || mailboxMiscFlags.HasFlag(MailboxMiscFlags.MRSSoftDeletedMailbox));
}
}
}
throw new RecipientNotFoundPermanentException(mailboxGuid);
}
public DatabaseSizeInfo GetDatabaseSize(DirectoryDatabase database)
{
DatabaseSizeInfo result;
using (ExRpcAdmin exRpcAdminForDatabase = this.GetExRpcAdminForDatabase(database))
{
ulong bytesValue;
ulong bytesValue2;
exRpcAdminForDatabase.GetDatabaseSize(database.Guid, out bytesValue, out bytesValue2);
ByteQuantifiedSize byteQuantifiedSize = ByteQuantifiedSize.FromBytes(bytesValue);
ByteQuantifiedSize byteQuantifiedSize2 = ByteQuantifiedSize.FromBytes(bytesValue2);
if (byteQuantifiedSize2 > byteQuantifiedSize)
{
this.logger.LogWarning("Database {0} has more free space ({1}) than its total size ({2}), assuming sparse EDB file with no free pages.", new object[]
{
database.Name,
byteQuantifiedSize2,
byteQuantifiedSize
});
byteQuantifiedSize2 = ByteQuantifiedSize.Zero;
}
result = new DatabaseSizeInfo
{
AvailableWhitespace = byteQuantifiedSize2,
CurrentPhysicalSize = byteQuantifiedSize
};
}
return(result);
}
// Token: 0x060000E8 RID: 232 RVA: 0x000058FC File Offset: 0x00003AFC
protected static void TrackAdminRpcCalls(DatabaseInfo databaseInfo, string clientType, Action <ExRpcAdmin> rpcDelegate)
{
ExRpcAdmin exRpcAdmin = null;
Stopwatch stopwatch = Stopwatch.StartNew();
try
{
exRpcAdmin = ExRpcAdmin.Create(clientType, null, null, null, null);
rpcDelegate(exRpcAdmin);
}
finally
{
stopwatch.Stop();
if (exRpcAdmin != null)
{
IRPCLatencyProvider mdbHealthMonitor = TimeBasedAssistant.GetMdbHealthMonitor(databaseInfo.Guid);
if (mdbHealthMonitor != null)
{
PerRPCPerformanceStatistics storePerRPCStats = exRpcAdmin.GetStorePerRPCStats();
mdbHealthMonitor.Update((int)storePerRPCStats.avgDbLatency, (storePerRPCStats.validVersion >= 2U) ? storePerRPCStats.totalDbOperations : 100U);
}
exRpcAdmin.Dispose();
exRpcAdmin = null;
}
ActivityContext.AddOperation(ActivityOperationType.ExRpcAdmin, databaseInfo.DatabaseName, (float)stopwatch.Elapsed.TotalMilliseconds, 1);
}
}
private ExRpcAdmin GetExRpcAdminForDatabase(DirectoryDatabase database)
{
ActiveManager activeManager = LoadBalanceADSettings.Instance.Value.UseCachingActiveManager ? ActiveManager.GetCachingActiveManagerInstance() : ActiveManager.GetNoncachingActiveManagerInstance();
DatabaseLocationInfo serverForDatabase = activeManager.GetServerForDatabase(database.Guid, true);
return(ExRpcAdmin.Create("Client=MSExchangeMailboxLoadBalance", serverForDatabase.ServerFqdn, null, null, null));
}
Guid IMailbox.StartIsInteg(List <uint> mailboxCorruptionTypes)
{
ExAssert.RetailAssert(mailboxCorruptionTypes != null, "IMailbox.StartIsInteg input must be non-null");
Guid result = Guid.Empty;
using (ExRpcAdmin rpcAdmin = base.GetRpcAdmin())
{
using (base.RHTracker.Start())
{
MrsTracer.Provider.Debug("Starting IsInteg task \"{0}\" in MDB {1}", new object[]
{
base.TraceMailboxId,
base.MdbGuid
});
PropValue[][] array = rpcAdmin.StoreIntegrityCheckEx(base.MdbGuid, base.MailboxGuid, Guid.Empty, 1U, 20U, mailboxCorruptionTypes.ToArray(), IsInteg.JobPropTags);
foreach (PropValue[] propValues in array)
{
StoreIntegrityCheckJob storeIntegrityCheckJob = new StoreIntegrityCheckJob(propValues);
result = storeIntegrityCheckJob.RequestGuid;
MrsTracer.Provider.Debug("Started Store IsInteg task: {0}", new object[]
{
storeIntegrityCheckJob.ToString()
});
}
}
}
return(result);
}
byte[] ISourceMailbox.GetMailboxBasicInfo(MailboxSignatureFlags flags)
{
MrsTracer.Provider.Function("MapiSourceMailbox.GetMailboxBasicInfo", new object[0]);
base.CheckDisposed();
if (base.IsPublicFolderMigrationSource)
{
return(MailboxSignatureConverter.CreatePublicFolderMailboxBasicInformation());
}
base.VerifyMailboxConnection(VerifyMailboxConnectionFlags.None);
uint mailboxSignatureServerVersion;
byte[] array;
using (ExRpcAdmin rpcAdmin = base.GetRpcAdmin())
{
using (base.RHTracker.Start())
{
MrsTracer.Provider.Debug("Reading mailbox basic info \"{0}\" in MDB {1}, flags {2}", new object[]
{
base.TraceMailboxId,
base.MdbGuid,
flags
});
mailboxSignatureServerVersion = rpcAdmin.GetMailboxSignatureServerVersion();
array = rpcAdmin.GetMailboxBasicInfo(base.MdbGuid, base.MailboxGuid, flags);
}
}
if (flags == MailboxSignatureFlags.GetLegacy && mailboxSignatureServerVersion >= 102U)
{
array = MailboxSignatureConverter.ExtractMailboxBasicInfo(array);
}
return(array);
}
private void FillDatabaseSize(ExRpcAdmin rpcAdmin, Database database)
{
try
{
FaultInjectionUtils.FaultInjectionTracer.TraceTest(3395693885U);
ulong bytesValue;
ulong bytesValue2;
rpcAdmin.GetDatabaseSize(database.Guid, out bytesValue, out bytesValue2);
database.DatabaseSize = new ByteQuantifiedSize?(ByteQuantifiedSize.FromBytes(bytesValue));
database.AvailableNewMailboxSpace = new ByteQuantifiedSize?(ByteQuantifiedSize.FromBytes(bytesValue2));
}
catch (MapiExceptionNoSupport)
{
}
catch (MapiPermanentException ex)
{
TaskLogger.Trace(string.Format(CultureInfo.InvariantCulture, "GetDatabase.FillDatabaseSize(Database '{0}') raises exception: {1}", new object[]
{
database.Identity.ToString(),
ex.Message
}), new object[0]);
this.WriteWarning(Strings.ErrorFailedToGetDatabaseSize(database.Identity.ToString()));
}
catch (MapiRetryableException ex2)
{
TaskLogger.Trace(string.Format(CultureInfo.InvariantCulture, "GetDatabase.FillDatabaseSize(Database '{0}') raises exception: {1}", new object[]
{
database.Identity.ToString(),
ex2.Message
}), new object[0]);
this.WriteWarning(Strings.ErrorFailedToGetDatabaseSize(database.Identity.ToString()));
}
}
public static void UnlockMoveTarget(string serverFQDN, Guid dbGuid, Guid mbxGuid, OrganizationId ordID)
{
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=Management", serverFQDN, null, null, null))
{
exRpcAdmin.PurgeCachedMailboxObject(mbxGuid);
}
ExchangePrincipal mailboxOwner = ExchangePrincipal.FromMailboxData(mbxGuid, dbGuid, ordID ?? OrganizationId.ForestWideOrgId, UnlockMoveTargetUtil.EmptyCultures, RemotingOptions.AllowCrossSite);
using (MailboxSession mailboxSession = MailboxSession.OpenAsSystemService(mailboxOwner, CultureInfo.InvariantCulture, "Client=MSExchangeMigration;Action=MailboxRepairRequestUnlockMailbox"))
{
mailboxSession.Mailbox.SetProperties(new PropertyDefinition[]
{
MailboxSchema.InTransitStatus
}, new object[]
{
InTransitStatus.SyncDestination
});
mailboxSession.Mailbox.Save();
mailboxSession.Mailbox.Load();
mailboxSession.Mailbox.SetProperties(new PropertyDefinition[]
{
MailboxSchema.InTransitStatus
}, new object[]
{
InTransitStatus.NotInTransit
});
mailboxSession.Mailbox.Save();
}
}
// Token: 0x06000ABC RID: 2748 RVA: 0x000461D8 File Offset: 0x000443D8
private List <MailboxInfo> GetAllLocalUserMailboxes()
{
ExTraceGlobals.MWITracer.TraceDebug <string>((long)this.GetHashCode(), "GetAllLocalUserMailboxes(): Getting user mailboxes for database {0}", base.DatabaseInfo.DisplayName);
LocalizedException ex = null;
List <MailboxInfo> list = new List <MailboxInfo>();
try
{
Hashtable umenabledUsersFromAD = this.GetUMEnabledUsersFromAD();
ExTraceGlobals.MWITracer.TraceDebug <int>((long)this.GetHashCode(), "GetAllLocalUserMailboxes:GetUMEnabledUsersFromAD returned {0} records.", umenabledUsersFromAD.Count);
if (umenabledUsersFromAD.Count != 0)
{
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=EBA", null, null, null, null))
{
PropValue[][] mailboxTable = exRpcAdmin.GetMailboxTable(base.DatabaseInfo.Guid, new PropTag[]
{
PropTag.UserGuid,
PropTag.DisplayName,
PropTag.DateDiscoveredAbsentInDS
});
ExTraceGlobals.MWITracer.TraceError <string, int>((long)this.GetHashCode(), "GetAllLocalUserMailboxes: Database({0}).GetMailboxTable returned {1} records", base.DatabaseInfo.DisplayName, mailboxTable.Length);
foreach (PropValue[] array2 in mailboxTable)
{
if (array2.Length == 3 && array2[0].PropTag == PropTag.UserGuid && array2[1].PropTag == PropTag.DisplayName && array2[2].PropTag != PropTag.DateDiscoveredAbsentInDS)
{
Guid guid = new Guid(array2[0].GetBytes());
if (base.DatabaseInfo.IsUserMailbox(guid) && umenabledUsersFromAD.Contains(guid))
{
MailboxInfo mailboxInfo = new MailboxInfo(guid, array2[1].GetString(), (OrganizationId)umenabledUsersFromAD[guid]);
ExTraceGlobals.MWITracer.TraceDebug <MailboxInfo>((long)this.GetHashCode(), "GetAllLocalUserMailboxes(): Adding {0} to the mailbox list", mailboxInfo);
list.Add(mailboxInfo);
}
}
}
goto IL_1CF;
}
}
ExTraceGlobals.MWITracer.TraceError((long)this.GetHashCode(), "GetAllLocalUserMailboxes:GetUMEnabledUsersFromAD returned 0 records.");
IL_1CF :;
}
catch (MapiPermanentException ex2)
{
ex = ex2;
}
catch (MapiRetryableException ex3)
{
ex = ex3;
}
if (ex != null)
{
ExTraceGlobals.MWITracer.TraceError <string, LocalizedException>((long)this.GetHashCode(), "TryGetMailboxEnumerator: Could not get the list of mailboxes for DB {0}: {1}", base.DatabaseInfo.DisplayName, ex);
UmGlobals.ExEvent.LogEvent(UMEventLogConstants.Tuple_MwiQueryDatabaseFailed, null, new object[]
{
base.DatabaseInfo.DisplayName,
this.syncInterval.TotalMinutes,
CommonUtil.ToEventLogString(ex)
});
}
return(list);
}
List <StoreIntegrityCheckJob> IMailbox.QueryIsInteg(Guid isIntegRequestGuid)
{
List <StoreIntegrityCheckJob> list = new List <StoreIntegrityCheckJob>(1);
using (ExRpcAdmin rpcAdmin = base.GetRpcAdmin())
{
using (base.RHTracker.Start())
{
MrsTracer.Provider.Debug("Starting IsInteg task \"{0}\" in MDB {1}", new object[]
{
base.TraceMailboxId,
base.MdbGuid
});
PropValue[][] array = rpcAdmin.StoreIntegrityCheckEx(base.MdbGuid, base.MailboxGuid, isIntegRequestGuid, 2U, 0U, null, IsInteg.JobPropTags);
foreach (PropValue[] propValues in array)
{
StoreIntegrityCheckJob storeIntegrityCheckJob = new StoreIntegrityCheckJob(propValues);
list.Add(storeIntegrityCheckJob);
MrsTracer.Provider.Debug("Queried Store IsInteg task: {0}", new object[]
{
storeIntegrityCheckJob.ToString()
});
}
}
}
return(list);
}
public static MailboxMiscFlags GetMailboxTableFlags(ExRpcAdmin rpcAdmin, Guid mdbGuid, Guid mailboxGuid)
{
MailboxMiscFlags result = MailboxMiscFlags.None;
try
{
PropValue[][] mailboxTableInfo = rpcAdmin.GetMailboxTableInfo(mdbGuid, mailboxGuid, new PropTag[]
{
PropTag.UserGuid,
PropTag.MailboxMiscFlags
});
if (mailboxTableInfo != null)
{
foreach (PropValue[] array2 in mailboxTableInfo)
{
if (array2 != null && array2.Length == 2 && array2[0].PropTag == PropTag.UserGuid)
{
byte[] bytes = array2[0].GetBytes();
Guid a = (bytes != null && bytes.Length == 16) ? new Guid(bytes) : Guid.Empty;
if (a == mailboxGuid)
{
result = (MailboxMiscFlags)((array2[1].PropTag == PropTag.MailboxMiscFlags) ? array2[1].GetInt() : 0);
}
}
}
}
}
catch (MapiExceptionNotFound)
{
}
return(result);
}
internal static LocalizedString DiagnoseException(string serverFqdn, Guid mdbGuid, Exception exception)
{
try
{
bool flag = false;
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=Management", serverFqdn, null, null, null))
{
MdbStatus[] array = exRpcAdmin.ListMdbStatus(new Guid[]
{
mdbGuid
});
if (array.Length != 0)
{
flag = ((array[0].Status & MdbStatusFlags.Online) == MdbStatusFlags.Online);
}
}
if (!flag)
{
return(Strings.MapiTransactionDiagnosticTargetDatabaseDismounted);
}
}
catch (MapiPermanentException exception2)
{
return(Strings.MapiTransactionDiagnosticStoreStateCheckFailure(SearchCommon.ShortErrorMsgFromException(exception2)));
}
catch (MapiRetryableException exception3)
{
return(Strings.MapiTransactionDiagnosticStoreStateCheckFailure(SearchCommon.ShortErrorMsgFromException(exception3)));
}
return(SearchCommon.ShortErrorMsgFromException(exception));
}
public static bool IsStoreDisconnectedMailbox(ExRpcAdmin rpcAdmin, Guid mdbGuid, Guid mailboxGuid)
{
if (MapiUtils.IsStoreDisconnectedMailboxInternal(rpcAdmin, mdbGuid, mailboxGuid))
{
return(true);
}
rpcAdmin.SyncMailboxWithDS(mdbGuid, mailboxGuid);
return(MapiUtils.IsStoreDisconnectedMailboxInternal(rpcAdmin, mdbGuid, mailboxGuid));
}
// Token: 0x0600034B RID: 843 RVA: 0x00010548 File Offset: 0x0000E748
private static PropValue[][] GetPropValuesFromMailboxTable(string clientId, Guid databaseGuid, PropTag[] properties)
{
PropValue[][] mailboxTable;
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create(clientId, null, null, null, null))
{
mailboxTable = exRpcAdmin.GetMailboxTable(databaseGuid, properties);
}
return(mailboxTable);
}
// Token: 0x060020F8 RID: 8440 RVA: 0x00097DE4 File Offset: 0x00095FE4
private void CreateExRpcAdminWithTimeout(TimeSpan timeout)
{
Action operation = delegate()
{
this.m_exRpcAdmin = ExRpcAdmin.Create(this.m_clientTypeId, this.m_serverNameOrFqdn, null, null, null);
};
base.ProtectedCallWithTimeout("ExRpcAdmin.Create", timeout, operation);
}
public static List <Guid> GetDatabasesOnThisServer()
{
if (MapiUtils.localMDBs != null && DateTime.UtcNow - MapiUtils.LocalMDBRefreshInterval < MapiUtils.lastLocalMDBRefresh)
{
return(MapiUtils.localMDBs);
}
List <Guid> list = new List <Guid>();
MdbStatus[] mdbStatuses = null;
CommonUtils.ProcessKnownExceptions(delegate
{
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=MSExchangeMigration", null, null, null, null))
{
mdbStatuses = exRpcAdmin.ListMdbStatus(true);
}
}, delegate(Exception failure)
{
LocalizedString localizedString = CommonUtils.FullExceptionMessage(failure);
CommonUtils.LogEvent(MRSEventLogConstants.Tuple_UnableToDetermineHostedMdbsOnServer, new object[]
{
CommonUtils.LocalComputerName,
localizedString.ToString()
});
return(false);
});
if (mdbStatuses == null)
{
MrsTracer.Common.Debug("MapiUtils.GetDatabasesOnServer() returned null.", new object[0]);
return(list);
}
foreach (MdbStatus mdbStatus in mdbStatuses)
{
if (mdbStatus.Status.HasFlag(MdbStatusFlags.Online))
{
list.Add(mdbStatus.MdbGuid);
}
}
if (list.Count == 0)
{
MrsTracer.Common.Debug("MapiUtils.GetDatabasesOnServer() found {0} databases, but none of them are online.", new object[]
{
mdbStatuses.Length
});
}
foreach (Guid mdbGuid in list)
{
DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.AllowMissing);
if (!databaseInformation.IsMissing && !databaseInformation.IsOnThisServer)
{
databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.ForceRediscovery | FindServerFlags.AllowMissing);
}
}
MapiUtils.localMDBs = list;
MapiUtils.lastLocalMDBRefresh = DateTime.UtcNow;
return(list);
}
protected List <MdbStatus> GetOnlineMDBList()
{
List <MdbStatus> onlineMDBList;
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=Management", this.ExchangeServer.Name, null, null, null))
{
onlineMDBList = this.GetOnlineMDBList(exRpcAdmin);
}
return(onlineMDBList);
}
private void FillLastBackupTimes(ExRpcAdmin rpcAdmin, Database database)
{
DateTime value = default(DateTime);
DateTime value2 = default(DateTime);
DateTime value3 = default(DateTime);
DateTime value4 = default(DateTime);
bool? snapshotLastFullBackup = null;
bool? snapshotLastIncrementalBackup = null;
bool? snapshotLastDifferentialBackup = null;
bool? snapshotLastCopyBackup = null;
try
{
FaultInjectionUtils.FaultInjectionTracer.TraceTest(2321952061U);
rpcAdmin.GetLastBackupInfo(database.Guid, out value, out value2, out value3, out value4, out snapshotLastFullBackup, out snapshotLastIncrementalBackup, out snapshotLastDifferentialBackup, out snapshotLastCopyBackup);
if (value.ToFileTimeUtc() != 0L)
{
database.LastFullBackup = new DateTime?(value);
}
if (value2.ToFileTimeUtc() != 0L)
{
database.LastIncrementalBackup = new DateTime?(value2);
}
if (value3.ToFileTimeUtc() != 0L)
{
database.LastDifferentialBackup = new DateTime?(value3);
}
if (value4.ToFileTimeUtc() != 0L)
{
database.LastCopyBackup = new DateTime?(value4);
}
database.SnapshotLastFullBackup = snapshotLastFullBackup;
database.SnapshotLastIncrementalBackup = snapshotLastIncrementalBackup;
database.SnapshotLastDifferentialBackup = snapshotLastDifferentialBackup;
database.SnapshotLastCopyBackup = snapshotLastCopyBackup;
}
catch (MapiPermanentException ex)
{
TaskLogger.Trace(string.Format(CultureInfo.InvariantCulture, "GetDatabase.FillLastBackupTimes(Database '{0}') raises exception: {1}", new object[]
{
database.Identity.ToString(),
ex.Message
}), new object[0]);
this.WriteWarning(Strings.ErrorFailedToGetDatabaseLastBackupTimes(database.Identity.ToString()));
}
catch (MapiRetryableException ex2)
{
TaskLogger.Trace(string.Format(CultureInfo.InvariantCulture, "GetDatabase.FillLastBackupTimes(Database '{0}') raises exception: {1}", new object[]
{
database.Identity.ToString(),
ex2.Message
}), new object[0]);
this.WriteWarning(Strings.ErrorFailedToGetDatabaseLastBackupTimes(database.Identity.ToString()));
}
}
private static void ExecuteAdminRpc(Guid databaseGuid, Action <ExRpcAdmin, string> action, Task.TaskErrorLoggingDelegate writeError, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskVerboseLoggingDelegate writeVerbose)
{
ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance();
DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(databaseGuid);
string serverFqdn = serverForDatabase.ServerFqdn;
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=Management", serverFqdn, null, null, null))
{
action(exRpcAdmin, serverFqdn);
}
}
public override void RunNow(Guid mailboxGuid, string parameters)
{
StoreMailboxData mailboxData;
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=TBA", null, null, null, null))
{
try
{
PropValue[][] mailboxTableInfo = exRpcAdmin.GetMailboxTableInfo(base.DatabaseInfo.Guid, mailboxGuid, new PropTag[]
{
PropTag.MailboxType,
PropTag.PersistableTenantPartitionHint,
PropTag.LastLogonTime
});
if (mailboxTableInfo.Length != 1 || mailboxTableInfo[0].Length < 1)
{
throw new InvalidOperationException("Failed to get the mailbox property");
}
PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(mailboxTableInfo[0], PropTag.PersistableTenantPartitionHint);
TenantPartitionHint tenantPartitionHint = null;
if (mailboxProperty.PropTag == PropTag.PersistableTenantPartitionHint)
{
byte[] bytes = mailboxProperty.GetBytes();
if (bytes != null && bytes.Length != 0)
{
tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes);
}
}
if (string.IsNullOrEmpty(parameters))
{
MailboxInformation mailboxInformation = MailboxInformation.Create(mailboxGuid.ToByteArray(), base.DatabaseInfo.Guid, mailboxGuid.ToString(), ControlData.Empty, mailboxTableInfo[0], MailboxInformation.GetLastLogonTime(mailboxTableInfo[0]), tenantPartitionHint);
mailboxData = mailboxInformation.MailboxData;
}
else
{
mailboxData = new MailboxDataForDemandJob(mailboxGuid, base.DatabaseInfo.Guid, null, parameters, tenantPartitionHint);
}
}
catch (MapiExceptionNotFound arg)
{
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedStoreDatabaseDriver, MapiExceptionNotFound>((long)this.GetHashCode(), "{0}: Mailbox does not exist on the store: {1}", this, arg);
if (string.IsNullOrEmpty(parameters))
{
mailboxData = new StoreMailboxData(mailboxGuid, base.DatabaseInfo.Guid, mailboxGuid.ToString(), null);
}
else
{
mailboxData = new MailboxDataForDemandJob(mailboxGuid, base.DatabaseInfo.Guid, null, parameters);
}
}
}
ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedStoreDatabaseDriver, Guid>((long)this.GetHashCode(), "{0}: RunNow: about to start processing mailbox {1} on this database.", this, mailboxGuid);
base.RunNow(mailboxData);
}
public IEnumerable <MailboxTableEntry> GetMailboxTable(DirectoryDatabase database, Guid mailboxGuid, PropTag[] propertiesToLoad)
{
IEnumerable <MailboxTableEntry> result;
using (ExRpcAdmin exRpcAdminForDatabase = this.GetExRpcAdminForDatabase(database))
{
PropTag[] propTagsRequested = propertiesToLoad ?? MailboxTablePropertyDefinitions.MailboxTablePropertiesToLoad;
PropValue[][] mailboxTableInfo = exRpcAdminForDatabase.GetMailboxTableInfo(database.Guid, mailboxGuid, MailboxTableFlags.IncludeSoftDeletedMailbox, propTagsRequested);
result = mailboxTableInfo.Select(new Func <PropValue[], MailboxTableEntry>(MailboxTableEntry.FromValues));
}
return(result);
}
internal static void DoMaintenanceTask(PublicFolderDatabase publicStore, string domainController, Task.TaskWarningLoggingDelegate warningHandler)
{
Server server = publicStore.GetServer();
if (!server.IsExchange2007OrLater)
{
warningHandler(Strings.WarningSiteFolderCheckTaskNotAvailableOnTiServer(server.Name));
return;
}
string a = domainController;
try
{
a = SystemConfigurationTasksHelper.GetConfigurationDomainControllerFqdn(domainController);
}
catch (SocketException ex)
{
warningHandler(Strings.ErrorResolveFqdnForDomainController(domainController, ex.Message));
}
string configDC = ADSession.GetConfigDC(TopologyProvider.LocalForestFqdn, server.Name);
if (string.Equals(a, configDC, StringComparison.InvariantCultureIgnoreCase))
{
try
{
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=Management", server.Fqdn, null, null, null))
{
exRpcAdmin.DoMaintenanceTask(publicStore.Guid, MaintenanceTask.SiteFolderCheck);
}
return;
}
catch (MapiPermanentException ex2)
{
TaskLogger.Trace("Set/New-OfflineAddressBook.InternalProcessRecord raises exception while running site folder check task: {0}", new object[]
{
ex2.Message
});
warningHandler(Strings.ErrorFailedToRunSiteFolderCheckTask(server.Name, ex2.Message));
return;
}
catch (MapiRetryableException ex3)
{
TaskLogger.Trace("Set/New-OfflineAddressBook.InternalProcessRecord raises exception while running site folder check task: {0}", new object[]
{
ex3.Message
});
warningHandler(Strings.ErrorFailedToRunSiteFolderCheckTask(server.Name, ex3.Message));
return;
}
}
warningHandler(Strings.WarningOabSiteFolderCheckNotRun(server.Name));
}
private void FillDatabaseProcessInfo(ExRpcAdmin rpcAdmin, Database database)
{
try
{
PropValue[][] databaseProcessInfo = rpcAdmin.GetDatabaseProcessInfo(database.Guid, new PropTag[]
{
PropTag.WorkerProcessId,
PropTag.MailboxDatabaseVersion,
PropTag.RequestedDatabaseSchemaVersion
});
if (databaseProcessInfo.Length > 0)
{
PropValue[] array = databaseProcessInfo[0];
foreach (PropValue propValue in array)
{
if (propValue.PropTag == PropTag.WorkerProcessId && propValue.Value is int)
{
database.WorkerProcessId = new int?((int)propValue.Value);
}
if (propValue.PropTag == PropTag.MailboxDatabaseVersion && propValue.Value is int)
{
int num = (int)propValue.Value;
database.CurrentSchemaVersion = string.Format("{0}.{1}", num >> 16, num & 65535);
}
if (propValue.PropTag == PropTag.RequestedDatabaseSchemaVersion && propValue.Value is int)
{
int num2 = (int)propValue.Value;
database.RequestedSchemaVersion = string.Format("{0}.{1}", num2 >> 16, num2 & 65535);
}
}
}
}
catch (MapiPermanentException ex)
{
TaskLogger.Trace(string.Format(CultureInfo.InvariantCulture, "GetDatabase.FillDatabaseProcessInfo(Database '{0}') raises exception: {1}", new object[]
{
database.Identity.ToString(),
ex.Message
}), new object[0]);
this.WriteWarning(Strings.ErrorFailedToGetDatabaseProcessInfo(database.Identity.ToString()));
}
catch (MapiRetryableException ex2)
{
TaskLogger.Trace(string.Format(CultureInfo.InvariantCulture, "GetDatabase.FillDatabaseProcessInfo(Database '{0}') raises exception: {1}", new object[]
{
database.Identity.ToString(),
ex2.Message
}), new object[0]);
this.WriteWarning(Strings.ErrorFailedToGetDatabaseProcessInfo(database.Identity.ToString()));
}
}
protected List <MdbStatus> GetOnlineMDBList(ExRpcAdmin exrpcAdmin)
{
MdbStatus[] array = exrpcAdmin.ListMdbStatus(false);
List <MdbStatus> list = new List <MdbStatus>(array.Length);
foreach (MdbStatus mdbStatus in array)
{
if ((mdbStatus.Status & MdbStatusFlags.Online) == MdbStatusFlags.Online && StringComparer.OrdinalIgnoreCase.Equals(mdbStatus.VServerName, this.ExchangeServer.Name))
{
list.Add(mdbStatus);
}
}
return(list);
}
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);
}
void IDestinationMailbox.ForceLogRoll()
{
using (ExRpcAdmin rpcAdmin = base.GetRpcAdmin())
{
try
{
using (base.RHTracker.Start())
{
rpcAdmin.ForceNewLog(base.MdbGuid);
}
}
catch (MapiExceptionVersion)
{
}
}
}
private IList <Guid> FindLocalDatabasesFromAdminRPC()
{
IList <Guid> list = new List <Guid>();
try
{
Server localServer = null;
ADOperationResult adoperationResult = ADNotificationAdapter.TryRunADOperation(delegate()
{
localServer = this.GetLocalServer();
});
if (adoperationResult.ErrorCode != ADOperationErrorCode.Success || localServer == null)
{
return(list);
}
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=UnifiedPolicy", localServer.Name, null, null, null))
{
MdbStatus[] array = exRpcAdmin.ListMdbStatus(true);
if (array == null || array.Length == 0)
{
return(list);
}
foreach (MdbStatus mdbStatus in array)
{
bool flag = (mdbStatus.Status & MdbStatusFlags.Online) == MdbStatusFlags.Online;
if (flag)
{
list.Add(mdbStatus.MdbGuid);
}
else
{
this.logger.LogOneEntry("NotificationLoader", string.Empty, ExecutionLog.EventType.Verbose, string.Format("FindLocalDatabasesFromAdminRPC: skip offline database {0}", mdbStatus.MdbGuid), null);
}
}
}
}
catch (MapiPermanentException exception)
{
this.logger.LogOneEntry("NotificationLoader", string.Empty, ExecutionLog.EventType.Error, "FindLocalDatabasesFromAdminRPC: failed with MapiPermanentException", exception);
}
catch (MapiRetryableException exception2)
{
this.logger.LogOneEntry("NotificationLoader", string.Empty, ExecutionLog.EventType.Error, "FindLocalDatabasesFromAdminRPC: failed with MapiRetryableException", exception2);
}
this.logger.LogOneEntry("NotificationLoader", string.Empty, ExecutionLog.EventType.Verbose, string.Format("FindLocalDatabasesFromAdminRPC: found {0} database on local server", list.Count), null);
return(list);
}
protected bool IsMdbMounted(Database mdb, string fqdn)
{
string server = string.IsNullOrEmpty(fqdn) ? mdb.Server.Name : fqdn;
this.WriteVerbose(Strings.VerboseConnectionAdminRpcInterface(server));
bool result;
using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=Management", server, null, null, null))
{
MdbStatus[] array = exRpcAdmin.ListMdbStatus(new Guid[]
{
mdb.Guid
});
result = ((array[0].Status & MdbStatusFlags.Online) != MdbStatusFlags.Offline);
}
return(result);
}
// Token: 0x06000E77 RID: 3703 RVA: 0x00045448 File Offset: 0x00043648
public static ADRawEntry ReadUserInformationRecord(ADObjectId id, Guid mdbGuid, Guid mbxGuid, bool createReadOnly, IEnumerable <MbxPropertyDefinition> properties, List <ValidationError> errors)
{
PropTag[] array = MbxRecipientSession.PropTagsFromProperties(properties);
PropValue[] array4;
try
{
if (MbxRecipientSession.storeUserInformationReader != null)
{
uint[] array2 = array.Cast <uint>().ToArray <uint>();
object[] array3 = MbxRecipientSession.storeUserInformationReader.ReadUserInformation(mdbGuid, mbxGuid, array2);
if (array3.Length != array2.Length)
{
throw new ArgumentException("Number of returned property values doesn't match number of requested properties");
}
array4 = new PropValue[array2.Length];
for (int i = 0; i < array4.Length; i++)
{
if (array3[i] != null)
{
array4[i] = new PropValue((PropTag)array2[i], array3[i]);
}
else
{
array4[i] = new PropValue(PropTagHelper.ConvertToError((PropTag)array2[i]), -2147221233);
}
}
}
else
{
using (ExRpcAdmin exRpcAdminInstance = MbxRecipientSession.GetExRpcAdminInstance())
{
array4 = exRpcAdminInstance.ReadUserInfo(mdbGuid, mbxGuid, 0U, array);
}
}
}
catch (MapiPermanentException innerException)
{
throw new ADDriverStoreAccessPermanentException(innerException);
}
catch (MapiRetryableException innerException2)
{
throw new ADDriverStoreAccessTransientException(innerException2);
}
return(MbxRecipientSession.ADRawEntryFromPropValues(id, createReadOnly, array4, properties, errors));
}
