private bool MatchesFilter(RequestIndexEntryQueryFilter requestIndexEntryQueryFilter)
{
if (requestIndexEntryQueryFilter == null)
{
return(true);
}
if (requestIndexEntryQueryFilter.RequestType != base.Type)
{
return(false);
}
if (requestIndexEntryQueryFilter.RequestGuid != Guid.Empty && requestIndexEntryQueryFilter.RequestGuid != base.RequestGuid)
{
return(false);
}
if (requestIndexEntryQueryFilter.SourceMailbox != null && requestIndexEntryQueryFilter.SourceMailbox.ObjectGuid != ((base.SourceUserId == null) ? Guid.Empty : base.SourceUserId.ObjectGuid))
{
return(false);
}
if (requestIndexEntryQueryFilter.TargetMailbox != null && requestIndexEntryQueryFilter.TargetMailbox.ObjectGuid != ((base.TargetUserId == null) ? Guid.Empty : base.TargetUserId.ObjectGuid))
{
return(false);
}
if (requestIndexEntryQueryFilter.SourceDatabase != null && requestIndexEntryQueryFilter.SourceDatabase.ObjectGuid != ((base.SourceMDB == null) ? Guid.Empty : base.SourceMDB.ObjectGuid))
{
return(false);
}
if (requestIndexEntryQueryFilter.TargetDatabase != null && requestIndexEntryQueryFilter.TargetDatabase.ObjectGuid != ((base.TargetMDB == null) ? Guid.Empty : base.TargetMDB.ObjectGuid))
{
return(false);
}
if (requestIndexEntryQueryFilter.Status != RequestStatus.None && requestIndexEntryQueryFilter.Status != base.Status)
{
return(false);
}
if (requestIndexEntryQueryFilter.Flags != RequestFlags.None && (requestIndexEntryQueryFilter.Flags & base.Flags) != requestIndexEntryQueryFilter.Flags)
{
return(false);
}
if (requestIndexEntryQueryFilter.NotFlags != RequestFlags.None && (~requestIndexEntryQueryFilter.NotFlags & base.Flags) != base.Flags)
{
return(false);
}
if (!string.IsNullOrEmpty(requestIndexEntryQueryFilter.BatchName) && requestIndexEntryQueryFilter.BatchName.Equals(base.BatchName, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
string text = requestIndexEntryQueryFilter.WildcardedNameSearch ? Wildcard.ConvertToRegexPattern(requestIndexEntryQueryFilter.RequestName) : requestIndexEntryQueryFilter.RequestName;
return(string.IsNullOrEmpty(text) || !(requestIndexEntryQueryFilter.WildcardedNameSearch ? (!Regex.IsMatch(base.Name, text, RegexOptions.IgnoreCase)) : (!base.Name.Equals(text, StringComparison.OrdinalIgnoreCase))));
}
private static Type ValidateQueryFilter <T>(QueryFilter filter) where T : IConfigurable
{
RequestIndexEntryQueryFilter requestIndexEntryQueryFilter = filter as RequestIndexEntryQueryFilter;
if (filter != null && requestIndexEntryQueryFilter == null)
{
throw new ArgumentException("This provider only supports RequestIndexEntryQueryFilters", "filter");
}
Type result = typeof(T);
if (requestIndexEntryQueryFilter != null)
{
result = requestIndexEntryQueryFilter.IndexId.RequestIndexEntryType;
}
return(result);
}
public override IEnumerable <MRSRequestMailboxEntry> FindPaged(RequestIndexEntryProvider requestIndexEntryProvider, QueryFilter filter, ObjectId rootId, bool deepSearch, SortBy sortBy, int pageSize)
{
RequestIndexEntryQueryFilter requestIndexEntryQueryFilter = filter as RequestIndexEntryQueryFilter;
ADUser aduser = requestIndexEntryProvider.ReadADUser(requestIndexEntryQueryFilter.MailboxId, Guid.Empty);
if (aduser == null)
{
return(null);
}
List <MRSRequestMailboxEntry> list = new List <MRSRequestMailboxEntry>(MailboxRequestIndexEntryHandler.GetRequestIndexEntries(aduser, requestIndexEntryQueryFilter));
foreach (MRSRequestMailboxEntry mrsrequestMailboxEntry in list)
{
mrsrequestMailboxEntry.RequestIndexId = new RequestIndexId(requestIndexEntryQueryFilter.MailboxId);
mrsrequestMailboxEntry.OrganizationId = aduser.OrganizationId;
}
return(list);
}
internal IEnumerable <T> InternalGetObjects <T>(ObjectId rootId, IConfigDataProvider session, OptionalIdentityData optionalData, out LocalizedString?notFoundReason) where T : IConfigurable, new()
{
if (session == null)
{
throw new ArgumentNullException("session");
}
RequestIndexEntryProvider requestIndexEntryProvider = session as RequestIndexEntryProvider;
if (requestIndexEntryProvider == null)
{
throw new ArgumentException(MrsStrings.MustProvideValidSessionForFindingRequests);
}
if (this.requestGuid != Guid.Empty && this.indexToUse != null)
{
List <T> list = new List <T>(1);
RequestIndexEntryObjectId identity = new RequestIndexEntryObjectId(this.requestGuid, this.RequestType, this.OrganizationId, this.indexToUse, null);
T t = (T)((object)requestIndexEntryProvider.Read <T>(identity));
if (t != null)
{
list.Add(t);
notFoundReason = null;
}
else
{
notFoundReason = new LocalizedString?(MrsStrings.NoSuchRequestInSpecifiedIndex);
}
return(list);
}
if (string.IsNullOrEmpty(this.requestName) || this.indexToUse == null)
{
notFoundReason = new LocalizedString?(MrsStrings.NotEnoughInformationSupplied);
return(new List <T>(0));
}
if (this.mailboxId != null)
{
QueryFilter filter = new RequestIndexEntryQueryFilter(this.requestName, this.mailboxId, this.RequestType, this.indexToUse, true);
notFoundReason = new LocalizedString?(MrsStrings.NoSuchRequestInSpecifiedIndex);
return(requestIndexEntryProvider.FindPaged <T>(filter, rootId, true, null, 2));
}
QueryFilter filter2 = new RequestIndexEntryQueryFilter(this.requestName, null, this.RequestType, this.indexToUse, false);
notFoundReason = new LocalizedString?(MrsStrings.NoSuchRequestInSpecifiedIndex);
return(requestIndexEntryProvider.FindPaged <T>(filter2, rootId, true, null, 2));
}
private static QueryFilter ConvertFilter(QueryFilter filter)
{
QueryFilter result = null;
if (filter != null)
{
List <QueryFilter> list = new List <QueryFilter>();
if (!(filter is RequestIndexEntryQueryFilter))
{
throw new ArgumentException("This provider only supports RequestIndexEntryQueryFilters", "filter");
}
RequestIndexEntryQueryFilter requestIndexEntryQueryFilter = (RequestIndexEntryQueryFilter)filter;
if (requestIndexEntryQueryFilter.IndexId.Location != RequestIndexLocation.AD)
{
throw new ArgumentException("ADHandler only supports objects in the location \"AD\".");
}
if (requestIndexEntryQueryFilter.RequestGuid != Guid.Empty)
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveRequestGuid, requestIndexEntryQueryFilter.RequestGuid));
}
if (requestIndexEntryQueryFilter.RequestQueueId != null)
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveStorageMDB, requestIndexEntryQueryFilter.RequestQueueId));
}
if (requestIndexEntryQueryFilter.RequestType != MRSRequestType.Move)
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MRSRequestType, requestIndexEntryQueryFilter.RequestType));
}
if (requestIndexEntryQueryFilter.RequestName != null)
{
if (requestIndexEntryQueryFilter.RequestName.Equals(string.Empty))
{
list.Add(new NotFilter(new ExistsFilter(MRSRequestSchema.DisplayName)));
}
else if (requestIndexEntryQueryFilter.WildcardedNameSearch)
{
list.Add(new TextFilter(MRSRequestSchema.DisplayName, requestIndexEntryQueryFilter.RequestName, MatchOptions.WildcardString, MatchFlags.IgnoreCase));
}
else
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.DisplayName, requestIndexEntryQueryFilter.RequestName));
}
}
if (requestIndexEntryQueryFilter.MailboxId != null)
{
if (requestIndexEntryQueryFilter.LooseMailboxSearch)
{
list.Add(QueryFilter.OrTogether(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveSourceUser, requestIndexEntryQueryFilter.MailboxId),
new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveTargetUser, requestIndexEntryQueryFilter.MailboxId)
}));
}
else
{
list.Add(QueryFilter.OrTogether(new QueryFilter[]
{
QueryFilter.AndTogether(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveSourceUser, requestIndexEntryQueryFilter.MailboxId),
new BitMaskAndFilter(MRSRequestSchema.MailboxMoveFlags, 4UL)
}),
QueryFilter.AndTogether(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveTargetUser, requestIndexEntryQueryFilter.MailboxId),
new BitMaskAndFilter(MRSRequestSchema.MailboxMoveFlags, 8UL)
})
}));
}
}
if (requestIndexEntryQueryFilter.DBId != null)
{
if (requestIndexEntryQueryFilter.LooseMailboxSearch)
{
list.Add(QueryFilter.OrTogether(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveSourceMDB, requestIndexEntryQueryFilter.DBId),
new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveTargetMDB, requestIndexEntryQueryFilter.DBId)
}));
}
else
{
list.Add(QueryFilter.OrTogether(new QueryFilter[]
{
QueryFilter.AndTogether(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveSourceMDB, requestIndexEntryQueryFilter.DBId),
new BitMaskAndFilter(MRSRequestSchema.MailboxMoveFlags, 4UL)
}),
QueryFilter.AndTogether(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveTargetMDB, requestIndexEntryQueryFilter.DBId),
new BitMaskAndFilter(MRSRequestSchema.MailboxMoveFlags, 8UL)
})
}));
}
}
if (requestIndexEntryQueryFilter.BatchName != null)
{
if (requestIndexEntryQueryFilter.BatchName.Equals(string.Empty))
{
list.Add(new NotFilter(new ExistsFilter(MRSRequestSchema.MailboxMoveBatchName)));
}
else
{
list.Add(new TextFilter(MRSRequestSchema.MailboxMoveBatchName, requestIndexEntryQueryFilter.BatchName, MatchOptions.WildcardString, MatchFlags.IgnoreCase));
}
}
if (requestIndexEntryQueryFilter.SourceMailbox != null)
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveSourceUser, requestIndexEntryQueryFilter.SourceMailbox));
}
if (requestIndexEntryQueryFilter.TargetMailbox != null)
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveTargetUser, requestIndexEntryQueryFilter.TargetMailbox));
}
if (requestIndexEntryQueryFilter.SourceDatabase != null)
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveSourceMDB, requestIndexEntryQueryFilter.SourceDatabase));
}
if (requestIndexEntryQueryFilter.TargetDatabase != null)
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveTargetMDB, requestIndexEntryQueryFilter.TargetDatabase));
}
if (requestIndexEntryQueryFilter.Status != RequestStatus.None)
{
list.Add(new ComparisonFilter(ComparisonOperator.Equal, MRSRequestSchema.MailboxMoveStatus, requestIndexEntryQueryFilter.Status));
}
if (requestIndexEntryQueryFilter.Flags != RequestFlags.None)
{
list.Add(new BitMaskAndFilter(MRSRequestSchema.MailboxMoveFlags, (ulong)((long)requestIndexEntryQueryFilter.Flags)));
}
if (requestIndexEntryQueryFilter.NotFlags != RequestFlags.None)
{
list.Add(new NotFilter(new BitMaskAndFilter(MRSRequestSchema.MailboxMoveFlags, (ulong)((long)requestIndexEntryQueryFilter.NotFlags))));
}
if (list.Count > 1)
{
result = QueryFilter.AndTogether(list.ToArray());
}
else if (list.Count == 1)
{
result = list[0];
}
}
return(result);
}
public static ICollection <MRSRequestMailboxEntry> Read(MailboxSession mailboxSession, RequestIndexEntryQueryFilter requestIndexEntryQueryFilter = null)
{
List <MRSRequestMailboxEntry> list = new List <MRSRequestMailboxEntry>();
ICollection <UserConfiguration> collection = mailboxSession.UserConfigurationManager.FindMailboxConfigurations("MRSRequest", UserConfigurationSearchFlags.Prefix);
try
{
foreach (UserConfiguration userConfiguration in collection)
{
MRSRequestMailboxEntry mrsrequestMailboxEntry = new MRSRequestMailboxEntry(userConfiguration);
if (mrsrequestMailboxEntry.MatchesFilter(requestIndexEntryQueryFilter))
{
list.Add(mrsrequestMailboxEntry);
}
}
}
finally
{
foreach (UserConfiguration userConfiguration2 in collection)
{
userConfiguration2.Dispose();
}
}
return(list);
}
private static IEnumerable <MRSRequestMailboxEntry> GetRequestIndexEntries(ADUser user, RequestIndexEntryQueryFilter requestIndexEntryQueryFilter)
{
ExchangePrincipal mailboxOwner = ExchangePrincipal.FromADUser(user, RemotingOptions.AllowCrossSite);
IEnumerable <MRSRequestMailboxEntry> result;
using (MailboxSession mailboxSession = MailboxSession.OpenAsAdmin(mailboxOwner, CultureInfo.InvariantCulture, "Client=MSExchangeMigration"))
{
result = MRSRequestMailboxEntry.Read(mailboxSession, requestIndexEntryQueryFilter);
}
return(result);
}
private static void CleanADOrphanAndInconsistencyForNonMoves(IConfigurationSession configSession, MRSRequestType requestType, RequestJobProvider rjProvider, Guid dbGuid)
{
ADObjectId requestQueueId = new ADObjectId(dbGuid);
RequestIndexEntryQueryFilter requestIndexEntryQueryFilter = new RequestIndexEntryQueryFilter();
requestIndexEntryQueryFilter.IndexId = new RequestIndexId(RequestIndexLocation.AD);
requestIndexEntryQueryFilter.RequestType = requestType;
requestIndexEntryQueryFilter.RequestQueueId = requestQueueId;
MRSRequestWrapper[] array = ADHandler.Find(configSession, requestIndexEntryQueryFilter, null, true, null);
if (array != null && array.Length > 0)
{
bool needUpdateAD = false;
MRSRequestWrapper[] array2 = array;
for (int i = 0; i < array2.Length; i++)
{
MRSRequestWrapper request = array2[i];
CommonUtils.CatchKnownExceptions(delegate
{
needUpdateAD = false;
if (request.Status != RequestStatus.None)
{
RequestStatisticsBase requestStatisticsBase = (RequestStatisticsBase)rjProvider.Read <RequestStatisticsBase>(new RequestJobObjectId(request.RequestGuid, dbGuid, null));
if (requestStatisticsBase == null || (!requestStatisticsBase.IsFake && requestStatisticsBase.Status == RequestStatus.None))
{
MrsTracer.Service.Debug("CleanADOrphanAndInconsistencyForRequests():AD orphan {0} found for DB {1}", new object[]
{
request.RequestGuid,
dbGuid
});
ADHandler.Delete(configSession, request);
return;
}
if (requestStatisticsBase.IsFake)
{
MrsTracer.Service.Debug("CleanADOrphanAndInconsistencyForRequests():request {0} is uplevel/Fake, ignoring it", new object[]
{
request.RequestGuid
});
return;
}
if (requestStatisticsBase.IndexEntries == null || requestStatisticsBase.IndexEntries.Count == 0)
{
MrsTracer.Service.Debug("CleanADOrphanAndInconsistencyForRequests():request {0} has been removed from AD, ignoring it", new object[]
{
request.RequestGuid
});
return;
}
if (requestStatisticsBase.TimeTracker.GetCurrentDurationChunk() > ADInconsistencyCheck.updateLatencyThreshhold)
{
if (requestStatisticsBase.Status != requestStatisticsBase.IndexEntries[0].Status)
{
MrsTracer.Service.Debug("CleanADOrphanAndInconsistencyForRequests():AD inconsistency {0} found for DB {1}, AD status is {2} but store status is {3}", new object[]
{
request.RequestGuid,
dbGuid,
request.Status,
requestStatisticsBase.Status
});
request.Status = requestStatisticsBase.Status;
needUpdateAD = true;
}
if (requestStatisticsBase.Flags != requestStatisticsBase.IndexEntries[0].Flags)
{
MrsTracer.Service.Debug("CleanADOrphanAndInconsistencyForRequests():AD inconsistency {0} found for DB {1}, AD flags is {2} but store flags is {3}", new object[]
{
request.RequestGuid,
dbGuid,
request.Flags,
requestStatisticsBase.Flags
});
request.Flags = requestStatisticsBase.Flags;
needUpdateAD = true;
}
if (needUpdateAD)
{
ADHandler.Save(configSession, request);
return;
}
}
}
else
{
MrsTracer.Service.Debug("CleanADOrphanAndInconsistencyForRequests():request {0} for {1} has been removed from AD, store orphan will be handled by MRS pick up job logic", new object[]
{
request.RequestGuid,
dbGuid
});
}
}, delegate(Exception f)
{
MrsTracer.Service.Error("CleanADOrphanAndInconsistencyForRequests() failed for DB {0}. Request type {1} Request guid {2} Error: {3}", new object[]
{
dbGuid,
requestType.ToString(),
request.RequestGuid,
CommonUtils.FullExceptionMessage(f, true)
});
MRSService.LogEvent(MRSEventLogConstants.Tuple_ScanADInconsistencyRequestFailEvent, new object[]
{
dbGuid,
requestType.ToString(),
request.RequestGuid,
CommonUtils.FullExceptionMessage(f, true)
});
});
}
return;
}
MrsTracer.Service.Debug("CleanADOrphanAndInconsistencyForRequests(): No {0} requests found for DB {1}", new object[]
{
requestType,
dbGuid
});
}
