FolderChangesManifest ISourceFolder.EnumerateChanges(EnumerateContentChangesFlags flags, int maxChanges)
{
if (!base.Folder.IsContentAvailable)
{
return(new FolderChangesManifest(base.FolderId));
}
SyncContentsManifestState syncState = ((MapiSourceMailbox)base.Mailbox).SyncState[base.FolderId];
bool flag = maxChanges != 0;
if (!flag || flags.HasFlag(EnumerateContentChangesFlags.FirstPage))
{
MapiStore mapiStore = base.Mailbox.MapiStore;
int[] array = new int[4];
array[0] = 8;
if (mapiStore.IsVersionGreaterOrEqualThan(array))
{
this.contentChangesFetcher = new ManifestContentChangesFetcher(this, base.Folder, base.Mailbox, flag);
}
else
{
this.contentChangesFetcher = new TitaniumContentChangesFetcher(this, base.Folder, base.Mailbox);
}
}
return(this.contentChangesFetcher.EnumerateContentChanges(syncState, flags, maxChanges));
}
private byte[] GetDestinationSpecificEntryId(MapiStore hierarchyStore, StoreId folderId)
{
StoreSession storeSession = null;
object thisObject = null;
bool flag = false;
byte[] result;
try
{
if (storeSession != null)
{
storeSession.BeginMapiCall();
storeSession.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
result = hierarchyStore.CreateEntryId(hierarchyStore.GetFidFromEntryId(StoreId.GetStoreObjectId(folderId).ProviderLevelItemId));
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotCreateEntryIdFromShortTermId, ex, storeSession, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("RPCPrimaryHierarchyProvider.GetDestinationSpecificEntryId : folderId = {0}", folderId),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotCreateEntryIdFromShortTermId, ex2, storeSession, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("RPCPrimaryHierarchyProvider.GetDestinationSpecificEntryId : folderId = {0}", folderId),
ex2
});
}
finally
{
try
{
if (storeSession != null)
{
storeSession.EndMapiCall();
if (flag)
{
storeSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
return(result);
}
public RequestJobProvider(Guid mdbGuid, MapiStore mdbSession)
{
this.MdbGuid = mdbGuid;
this.store = mdbSession;
this.ownsStore = (mdbSession == null);
this.IndexProvider = new RequestIndexEntryProvider();
}
public LightJobBase(Guid requestGuid, Guid requestQueueGuid, MapiStore systemMailbox, byte[] messageId)
{
this.RequestGuid = requestGuid;
this.RequestQueueGuid = requestQueueGuid;
this.SystemMailbox = systemMailbox;
this.MessageId = messageId;
}
internal static MapiFolder GetFolderByPath(MapiStore mapiStore, MapiFolder parentFolder, MapiFolderPath folderPath)
{
if (null == folderPath)
{
throw new ArgumentNullException("folderPath");
}
if (folderPath.IsSubtreeRoot)
{
if (mapiStore == null)
{
throw new ArgumentNullException("mapiStore");
}
if (!folderPath.IsIpmPath)
{
return(mapiStore.GetNonIpmSubtreeFolder());
}
return(mapiStore.GetIpmSubtreeFolder());
}
else
{
if (parentFolder == null)
{
throw new ArgumentNullException("parentFolder");
}
return(parentFolder.OpenSubFolderByName(folderPath[folderPath.Depth - 1]));
}
}
internal void SaveToMailbox(MapiStore mailbox, int maxMoveHistoryLength)
{
MrsTracer.Common.Function("MoveHistoryEntryInternal.SaveToMailbox(maxHistoryLength={0})", new object[]
{
maxMoveHistoryLength
});
List <byte[]> list = new List <byte[]>();
using (MapiFolder folder = MapiUtils.OpenFolderUnderRoot(mailbox, MoveHistoryEntryInternal.MHEFolderName, true))
{
using (MapiTable contentsTable = folder.GetContentsTable(ContentsTableFlags.DeferredErrors))
{
contentsTable.SortTable(new SortOrder(PropTag.LastModificationTime, SortFlags.Ascend), SortTableFlags.None);
PropValue[][] array = MapiUtils.QueryAllRows(contentsTable, null, new PropTag[]
{
PropTag.EntryId
});
foreach (PropValue[] array3 in array)
{
list.Add(array3[0].GetBytes());
}
}
MrsTracer.Common.Debug("Move history contains {0} items.", new object[]
{
list.Count
});
List <byte[]> list2 = new List <byte[]>();
while (list.Count >= maxMoveHistoryLength && list.Count > 0)
{
list2.Add(list[0]);
list.RemoveAt(0);
}
if (list2.Count > 0)
{
MrsTracer.Common.Debug("Clearing {0} entries from move history", new object[]
{
list2.Count
});
MapiUtils.ProcessMapiCallInBatches <byte[]>(list2.ToArray(), delegate(byte[][] batch)
{
folder.DeleteMessages(DeleteMessagesFlags.ForceHardDelete, batch);
});
}
}
if (maxMoveHistoryLength <= 0)
{
MrsTracer.Common.Debug("Move history saving is disabled.", new object[0]);
return;
}
DateTime dateTime = this.TimeTracker.GetTimestamp(RequestJobTimestamp.Creation) ?? DateTime.MinValue;
string subject = string.Format("MoveHistoryEntry {0}", dateTime.ToString());
byte[] bytes = BitConverter.GetBytes(dateTime.ToBinary());
MoveObjectInfo <MoveHistoryEntryInternal> moveObjectInfo = new MoveObjectInfo <MoveHistoryEntryInternal>(Guid.Empty, mailbox, null, MoveHistoryEntryInternal.MHEFolderName, MoveHistoryEntryInternal.MHEMessageClass, subject, bytes);
using (moveObjectInfo)
{
moveObjectInfo.SaveObject(this);
}
}
internal override void Read(bool keepUnmanagedResources)
{
if (base.ObjectState != ObjectState.New)
{
throw new MapiInvalidOperationException(Strings.ExceptionObjectStateInvalid(base.ObjectState.ToString()));
}
Folder.CheckRequirementsToContinue(this.Identity, base.MapiSession);
bool flag = false;
ExTraceGlobals.FolderTracer.TraceDebug <FolderId, string>((long)this.GetHashCode(), "To Read Folder '{0}' from server '{1}'.", this.Identity, base.MapiSession.ServerName);
base.EnableDisposeTracking();
using (MapiStore messageStore = this.GetMessageStore())
{
using (MapiFolder mapiFolder = this.GetMapiFolder(messageStore))
{
try
{
base.Instantiate(mapiFolder.GetProps(base.GetPropertyTagsToRead()));
this.UpdateIdentity(this.UpdateIdentityFlagsForReading);
flag = true;
}
finally
{
if (!keepUnmanagedResources || !flag)
{
base.Dispose();
}
}
}
}
base.ResetChangeTrackingAndObjectState();
}
private bool TryOpenHistoryFolder()
{
bool result;
try
{
MapiStore mapiStore = this.context.StoreSession.Mailbox.MapiStore;
using (MapiFolder nonIpmSubtreeFolder = mapiStore.GetNonIpmSubtreeFolder())
{
this.oofHistoryFolder = nonIpmSubtreeFolder.OpenSubFolderByName("Freebusy Data");
}
this.Trace("OOF history folder opened.");
result = true;
}
catch (MapiExceptionNotFound mapiExceptionNotFound)
{
this.context.TraceError <string>("Unable to open the OOF history folder {0}, OOF history operation skipped.", "Freebusy Data");
this.context.LogEvent(this.context.OofHistoryFolderMissing, mapiExceptionNotFound.GetType().ToString(), new object[]
{
((MailboxSession)this.context.StoreSession).MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString()
});
result = false;
}
return(result);
}
internal override void InternalProcessRecord()
{
base.InternalProcessRecord();
if (!this.sourceServerHasMdb)
{
base.AddSuccessMonitoringEvent(1000, Strings.TestMailflowSucceededNoDatabaseOnSourceServer(base.SourceMailboxServer.Name));
base.Task.WriteWarning(Strings.TestMailflowServerWithoutMdbs(base.SourceMailboxServer.Name));
return;
}
if (!this.targetServerHasMdb)
{
base.AddSuccessMonitoringEvent(1000, Strings.TestMailflowSucceededNoDatabaseOnTargetServer(base.Task.TargetMailboxServer.ToString()));
base.Task.WriteWarning(Strings.TestMailflowServerWithoutMdbs(base.Task.TargetMailboxServer.ToString()));
return;
}
using (MapiStore mapiStore = MapiStore.OpenMailbox(base.SourceMailboxServer.Fqdn, base.SourceSystemMailbox.LegacyExchangeDN, base.SourceSystemMailbox.ExchangeGuid, base.SourceSystemMailbox.Database.ObjectGuid, base.SourceSystemMailbox.Name, null, null, ConnectFlag.UseAdminPrivilege | ConnectFlag.UseSeparateConnection, OpenStoreFlag.UseAdminPrivilege | OpenStoreFlag.TakeOwnership | OpenStoreFlag.MailboxGuid, CultureInfo.InvariantCulture, null, "Client=Management;Action=LegacyTestMailFlow", null))
{
using (MapiFolder outboxFolder = mapiStore.GetOutboxFolder())
{
using (MapiFolder inboxFolder = mapiStore.GetInboxFolder())
{
LegacyTestMailFlowHelper.CleanUpInbox(inboxFolder);
string subject = string.Format("Test-Mailflow {0} {1}", Guid.NewGuid(), "66c7004a-6860-44b2-983a-327aa3c9cfec");
TestMailFlowHelper.CreateAndSubmitMessage(outboxFolder, base.SourceSystemMailbox.Name, this.targetMailboxAddress, subject, true);
this.WaitAndProcessDeliveryReceipt(inboxFolder, subject, this.friendlySourceAddress, this.friendlyTargetAddress, this.GetPerfInstanceName());
}
}
}
}
private MapiStore GetHierarchyStore()
{
StoreSession storeSession = null;
object thisObject = null;
bool flag = false;
MapiStore result;
try
{
if (storeSession != null)
{
storeSession.BeginMapiCall();
storeSession.BeginServerHealthCall();
flag = true;
}
if (StorageGlobals.MapiTestHookBeforeCall != null)
{
StorageGlobals.MapiTestHookBeforeCall(MethodBase.GetCurrentMethod());
}
result = MapiStore.OpenPublicStore(this.getLegacyDN(this.PrimaryHierarchyMailboxPrincipal).ToString(), this.userDn, null, null, null, string.Format("{0}:{1}", this.PrimaryHierarchyMailboxPrincipal.MailboxInfo.Location.ServerFqdn, 81), ConnectFlag.UseDelegatedAuthPrivilege | ConnectFlag.UseNTLM | ConnectFlag.ConnectToExchangeRpcServerOnly, OpenStoreFlag.Public, CultureInfo.CurrentCulture, PublicFolderSession.FromClientSecurityContext(this.organizationId, this.clientSecurityContext), "Client=MSExchangeRPC");
}
catch (MapiPermanentException ex)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenMailbox(this.PrimaryHierarchyMailboxPrincipal.LegacyDn), ex, storeSession, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("PublicFolderRPCHierarchyProvider.GetHierarchyStore : ServerFullyQualifiedDomainName = {0}, UserLegacyDN = {1}.", this.PrimaryHierarchyMailboxPrincipal.MailboxInfo.Location.ServerFqdn, this.userDn),
ex
});
}
catch (MapiRetryableException ex2)
{
throw StorageGlobals.TranslateMapiException(ServerStrings.MapiCannotOpenMailbox(this.PrimaryHierarchyMailboxPrincipal.LegacyDn), ex2, storeSession, thisObject, "{0}. MapiException = {1}.", new object[]
{
string.Format("PublicFolderRPCHierarchyProvider.GetHierarchyStore : ServerFullyQualifiedDomainName = {0}, UserLegacyDN = {1}.", this.PrimaryHierarchyMailboxPrincipal.MailboxInfo.Location.ServerFqdn, this.userDn),
ex2
});
}
finally
{
try
{
if (storeSession != null)
{
storeSession.EndMapiCall();
if (flag)
{
storeSession.EndServerHealthCall();
}
}
}
finally
{
if (StorageGlobals.MapiTestHookAfterCall != null)
{
StorageGlobals.MapiTestHookAfterCall(MethodBase.GetCurrentMethod());
}
}
}
return(result);
}
internal static bool IsMessageTypeSupported(MapiMessage message, MapiStore store)
{
RequestJobNamedPropertySet requestJobNamedPropertySet = RequestJobNamedPropertySet.Get(store);
PropValue prop = message.GetProp(requestJobNamedPropertySet.PropTags[9]);
MRSJobType value = MapiUtils.GetValue <MRSJobType>(prop, MRSJobType.RequestJobE14R3);
return(RequestJobXML.IsKnownJobType(value));
}
public SyncContentsManifestState()
{
uint idsGivenPropTag = FastTransferIcsState.IdsetGiven;
this.folderId = null;
this.data = null;
this.idSetGiven = new Lazy <IdSet>(() => MapiStore.GetIdSetFromMapiManifestBlob((PropTag)idsGivenPropTag, this.Data));
}
public static byte[] GetSignatureBytes(MapiStore systemMailbox)
{
byte[] result = null;
using (MapiFolder rootFolder = systemMailbox.GetRootFolder())
{
result = (rootFolder.GetProp(PropTag.MappingSignature).Value as byte[]);
}
return(result);
}
protected override void ProcessJobs(MapiStore systemMbx, MapiTable contentsTable, RequestJobNamedPropertySet nps)
{
SortOrder sortOrder = new SortOrder(nps.PropTags[17], SortFlags.Descend);
sortOrder.Add(nps.PropTags[7], SortFlags.Ascend);
MrsTracer.Service.Debug("Searching for MRs to Rehome...", new object[0]);
Restriction restriction = Restriction.And(new Restriction[]
{
Restriction.EQ(nps.PropTags[4], false),
Restriction.EQ(nps.PropTags[20], true)
});
MrsTracer.Service.Debug("Searching for MRs to Suspend...", new object[0]);
base.ProcessJobsInBatches(restriction, false, sortOrder, contentsTable, systemMbx, null);
Restriction restriction2 = Restriction.And(new Restriction[]
{
Restriction.BitMaskNonZero(nps.PropTags[10], 256),
Restriction.EQ(nps.PropTags[4], false),
Restriction.EQ(nps.PropTags[20], false),
Restriction.NE(nps.PropTags[0], RequestStatus.Failed),
Restriction.NE(nps.PropTags[0], RequestStatus.Suspended),
Restriction.NE(nps.PropTags[0], RequestStatus.AutoSuspended),
Restriction.NE(nps.PropTags[0], RequestStatus.Completed),
Restriction.NE(nps.PropTags[0], RequestStatus.CompletedWithWarning)
});
base.ProcessJobsInBatches(restriction2, false, sortOrder, contentsTable, systemMbx, null);
MrsTracer.Service.Debug("Searching for MRs to Resume...", new object[0]);
Restriction restriction3 = Restriction.And(new Restriction[]
{
Restriction.BitMaskZero(nps.PropTags[10], 256),
Restriction.EQ(nps.PropTags[4], false),
Restriction.EQ(nps.PropTags[20], false),
Restriction.Or(new Restriction[]
{
Restriction.EQ(nps.PropTags[0], RequestStatus.Failed),
Restriction.EQ(nps.PropTags[0], RequestStatus.Suspended),
Restriction.EQ(nps.PropTags[0], RequestStatus.AutoSuspended)
})
});
base.ProcessJobsInBatches(restriction3, false, sortOrder, contentsTable, systemMbx, null);
SortOrder sort = new SortOrder(nps.PropTags[13], SortFlags.Ascend);
DateTime utcNow = DateTime.UtcNow;
MrsTracer.Service.Debug("Searching for Completed MRs to clean up...", new object[0]);
Restriction restriction4 = Restriction.And(new Restriction[]
{
Restriction.EQ(nps.PropTags[20], false),
Restriction.EQ(nps.PropTags[4], false),
Restriction.EQ(nps.PropTags[0], RequestStatus.Completed),
Restriction.NE(nps.PropTags[13], SystemMailboxLightJobs.defaultDoNotPickUntil)
});
base.ProcessJobsInBatches(restriction4, false, sort, contentsTable, systemMbx, (MoveJob moveJob) => moveJob.DoNotPickUntilTimestamp > utcNow);
}
internal static List <MoveHistoryEntryInternal> LoadMoveHistory(MapiStore mailbox)
{
MrsTracer.Common.Function("MoveHistoryEntryInternal.LoadMoveHistory", new object[0]);
List <MoveHistoryEntryInternal> list = new List <MoveHistoryEntryInternal>();
using (MapiFolder mapiFolder = MapiUtils.OpenFolderUnderRoot(mailbox, MoveHistoryEntryInternal.MHEFolderName, false))
{
if (mapiFolder == null)
{
return(list);
}
using (MapiTable contentsTable = mapiFolder.GetContentsTable(ContentsTableFlags.DeferredErrors))
{
PropValue[][] array = MapiUtils.QueryAllRows(contentsTable, null, new PropTag[]
{
PropTag.EntryId
});
foreach (PropValue[] array3 in array)
{
byte[] bytes = array3[0].GetBytes();
string subject = string.Format("MoveHistoryEntry {0}", TraceUtils.DumpEntryId(bytes));
MoveObjectInfo <MoveHistoryEntryInternal> moveObjectInfo = new MoveObjectInfo <MoveHistoryEntryInternal>(Guid.Empty, mailbox, bytes, MoveHistoryEntryInternal.MHEFolderName, MoveHistoryEntryInternal.MHEMessageClass, subject, null);
using (moveObjectInfo)
{
MoveHistoryEntryInternal moveHistoryEntryInternal = null;
try
{
moveHistoryEntryInternal = moveObjectInfo.ReadObject(ReadObjectFlags.DontThrowOnCorruptData);
}
catch (MailboxReplicationPermanentException ex)
{
MrsTracer.Common.Warning("Failed to read move history entry: {0}", new object[]
{
ex.ToString()
});
}
if (moveHistoryEntryInternal != null)
{
list.Add(moveHistoryEntryInternal);
}
else if (moveObjectInfo.CreationTimestamp < DateTime.UtcNow - TimeSpan.FromDays(365.0))
{
MrsTracer.Common.Warning("Removing old corrupt MHEI entry {0}", new object[]
{
TraceUtils.DumpEntryId(bytes)
});
moveObjectInfo.DeleteMessage();
}
}
}
}
}
list.Sort();
return(list);
}
internal override void InternalProcessRecord()
{
base.InternalProcessRecord();
if (base.Task.MonitoringContext && !this.IsFirstActiveMdbLocallyMounted())
{
base.AddInformationMonitoringEvent(2004, Strings.CrossPremiseServerNotSelected(base.SourceMailboxServer.Name));
return;
}
List <SmtpAddress> siteEgressTargets = this.GetSiteEgressTargets();
if (siteEgressTargets.Count <SmtpAddress>() == 0)
{
base.AddWarningMonitoringEvent(2003, Strings.CrossPremiseNoEgressTargets(base.SourceMailboxServer.Name));
base.Task.WriteWarning(Strings.CrossPremiseNoEgressTargets(base.SourceMailboxServer.Name));
return;
}
ADSystemMailbox adsystemMailbox = this.localSystemMailbox as ADSystemMailbox;
using (MapiStore mapiStore = MapiStore.OpenMailbox(base.SourceMailboxServer.Fqdn, this.localSystemMailbox.LegacyExchangeDN, adsystemMailbox.ExchangeGuid, adsystemMailbox.Database.ObjectGuid, this.localSystemMailbox.Name, null, null, ConnectFlag.UseAdminPrivilege | ConnectFlag.UseSeparateConnection, OpenStoreFlag.UseAdminPrivilege | OpenStoreFlag.TakeOwnership | OpenStoreFlag.MailboxGuid, CultureInfo.InvariantCulture, null, "Client=Management;Action=CrossPremiseTestMailFlow", null))
{
using (MapiFolder rootFolder = mapiStore.GetRootFolder())
{
using (MapiFolder inboxFolder = mapiStore.GetInboxFolder())
{
using (MapiFolder mapiFolder = rootFolder.CreateFolder("Cross Premise", "The folder for cross premise mailflow monitoring.", true))
{
if (base.Task.MonitoringContext)
{
this.MatchCrossPremiseMessages(inboxFolder, mapiFolder, this.localSystemMailbox.WindowsEmailAddress, siteEgressTargets);
using (List <SmtpAddress> .Enumerator enumerator = siteEgressTargets.GetEnumerator())
{
while (enumerator.MoveNext())
{
SmtpAddress smtpAddress = enumerator.Current;
string subject = string.Format("{0}{{{1}}}", "CrossPremiseMailFlowMonitoring-", Guid.NewGuid());
TestMailFlowHelper.CreateAndSubmitMessage(mapiFolder, this.localSystemMailbox.Name, smtpAddress.ToString(), subject, false);
}
goto IL_238;
}
}
Dictionary <string, string> dictionary = new Dictionary <string, string>();
ExDateTime utcNow = ExDateTime.UtcNow;
foreach (SmtpAddress smtpAddress2 in siteEgressTargets)
{
string text = string.Format("{0}{{{1}}}", "CrossPremiseMailFlowMonitoring-", Guid.NewGuid());
TestMailFlowHelper.CreateAndSubmitMessage(mapiFolder, this.localSystemMailbox.Name, smtpAddress2.ToString(), text, true);
dictionary[text] = smtpAddress2.ToString();
}
this.WaitAndProcessProbeResponses(inboxFolder, this.localSystemMailbox.Name, dictionary, utcNow);
IL_238 :;
}
}
}
}
}
private MessageSearcher CreateMessageSearcher(SearchTestResult result)
{
if (result == null)
{
throw new ArgumentNullException("result");
}
Exception ex = null;
MessageSearcher result2 = null;
try
{
this.monitor.AddMonitoringEvent(result, Strings.TestSearchGetMapiStore(result.Mailbox));
MapiStore mapiStore = MapiStore.OpenMailbox(result.Server, result.UserLegacyExchangeDN, result.MailboxGuid, result.DatabaseGuid, null, null, null, ConnectFlag.UseAdminPrivilege | ConnectFlag.UseSeparateConnection, OpenStoreFlag.UseAdminPrivilege | OpenStoreFlag.TakeOwnership | OpenStoreFlag.MailboxGuid, CultureInfo.InvariantCulture, null, "Client=Management;Action=Test-Search", null);
if (mapiStore != null)
{
result2 = new MessageSearcher(mapiStore, result, this.monitor, this.threadExit);
}
else
{
result.SetErrorTestResult(EventId.MapiStoreError, Strings.TestSearchMapiStoreError(result.Mailbox, result.Database));
}
}
catch (ADTransientException ex2)
{
ex = ex2;
}
catch (ADExternalException ex3)
{
ex = ex3;
}
catch (MapiExceptionNotFound mapiExceptionNotFound)
{
ex = mapiExceptionNotFound;
}
catch (MapiPermanentException ex4)
{
ex = ex4;
}
catch (MapiRetryableException ex5)
{
ex = ex5;
}
finally
{
if (ex is ADTransientException || ex is ADExternalException)
{
result.SetErrorTestResult(EventId.ADError, Strings.TestSearchADError(ex.Message));
}
if (ex is MapiExceptionNotFound || ex is MapiPermanentException || ex is MapiRetryableException)
{
this.HandleExceptionInTestThread(result.DatabaseGuid, EventId.MapiError, result, ex);
}
}
return(result2);
}
public MoveObjectInfo(Guid mdbGuid, MapiStore store, byte[] messageId, string folderName, string messageClass, string subject, byte[] searchKey)
{
this.store = store;
this.MessageId = messageId;
this.FolderId = null;
this.message = null;
this.folderName = folderName;
this.messageClass = messageClass;
this.searchKey = searchKey;
this.subject = subject;
}
private static void PerformLightJobAction(MapiStore systemMailbox, RequestStatisticsBase requestJobStats)
{
CommonUtils.CatchKnownExceptions(delegate
{
bool flag = false;
LightJobBase lightJobBase;
if (QuarantinedJobs.Contains(requestJobStats.IdentifyingGuid))
{
lightJobBase = new QuarantineJob(requestJobStats.IdentifyingGuid, requestJobStats.WorkItemQueueMdb.ObjectGuid, systemMailbox, requestJobStats.MessageId);
}
else if (requestJobStats.ShouldRehomeRequest)
{
lightJobBase = new RehomeJob(requestJobStats.IdentifyingGuid, requestJobStats.RequestQueue, requestJobStats.OptimalRequestQueue, systemMailbox, requestJobStats.MessageId);
}
else if (requestJobStats.ShouldClearRehomeRequest)
{
lightJobBase = new ClearRehomeJob(requestJobStats.IdentifyingGuid, requestJobStats.WorkItemQueueMdb.ObjectGuid, systemMailbox, requestJobStats.MessageId);
}
else if (requestJobStats.ShouldSuspendRequest)
{
lightJobBase = new SuspendJob(requestJobStats.IdentifyingGuid, requestJobStats.WorkItemQueueMdb.ObjectGuid, systemMailbox, requestJobStats.MessageId);
}
else
{
lightJobBase = new ResumeJob(requestJobStats.IdentifyingGuid, requestJobStats.WorkItemQueueMdb.ObjectGuid, systemMailbox, requestJobStats.MessageId);
flag = true;
}
using (lightJobBase)
{
lightJobBase.Run();
if (flag)
{
MRSService.Tickle(requestJobStats.IdentifyingGuid, requestJobStats.WorkItemQueueMdb.ObjectGuid, MoveRequestNotification.Created);
}
}
}, delegate(Exception failure)
{
LocalizedString localizedString = CommonUtils.FullExceptionMessage(failure);
MrsTracer.Service.Debug("Unexpected failure occurred trying to perform a light pipe action on MoveJob '{0}' from queue '{1}', skipping it. {2}", new object[]
{
requestJobStats.RequestGuid,
requestJobStats.RequestQueue,
localizedString
});
MailboxReplicationService.LogEvent(MRSEventLogConstants.Tuple_UnableToProcessRequest, new object[]
{
requestJobStats.RequestGuid.ToString(),
requestJobStats.WorkItemQueueMdb.ObjectGuid.ToString(),
localizedString
});
});
}
void IReportHelper.Load(ReportData report, MapiStore storeToUse)
{
using (MoveObjectInfo <T> moveObjectInfo = new MoveObjectInfo <T>(Guid.Empty, storeToUse, report.MessageId, this.reportFolderName, this.reportMessageClass, this.CreateMessageSubject(report), this.CreateMessageSearchKey(report)))
{
if (!moveObjectInfo.OpenMessage())
{
report.Entries = null;
}
else
{
report.MessageId = moveObjectInfo.MessageId;
report.Entries = this.DeserializeEntries(moveObjectInfo, false);
}
}
}
void IReportHelper.Delete(ReportData report, MapiStore storeToUse)
{
MapiUtils.RetryOnObjectChanged(delegate
{
using (MoveObjectInfo <T> moveObjectInfo = new MoveObjectInfo <T>(Guid.Empty, storeToUse, report.MessageId, this.reportFolderName, this.reportMessageClass, this.CreateMessageSubject(report), this.CreateMessageSearchKey(report)))
{
moveObjectInfo.OpenMessage();
if (moveObjectInfo.MessageFound)
{
moveObjectInfo.DeleteMessage();
}
}
});
report.MessageId = null;
}
protected override ICollection <ServiceIssue> RunFullIssueScan()
{
ICollection <ServiceIssue> collection = new List <ServiceIssue>();
foreach (Guid mdbGuid in MapiUtils.GetDatabasesOnThisServer())
{
using (new DatabaseSettingsContext(mdbGuid, null).Activate())
{
try
{
DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.None);
string databaseName = databaseInformation.DatabaseName;
if (!databaseInformation.IsOnThisServer)
{
return(null);
}
using (MapiStore systemMailbox = MapiUtils.GetSystemMailbox(mdbGuid, false))
{
using (MapiFolder requestJobsFolder = RequestJobXML.GetRequestJobsFolder(systemMailbox))
{
using (MapiTable contentsTable = requestJobsFolder.GetContentsTable(ContentsTableFlags.DeferredErrors))
{
if (contentsTable.GetRowCount() > 0)
{
RequestJobNamedPropertySet requestJobNamedPropertySet = RequestJobNamedPropertySet.Get(systemMailbox);
contentsTable.SetColumns(requestJobNamedPropertySet.PropTags);
Restriction restriction = Restriction.GT(requestJobNamedPropertySet.PropTags[23], ConfigBase <MRSConfigSchema> .GetConfig <int>("PoisonLimit"));
List <MoveJob> allMoveJobs = SystemMailboxJobs.GetAllMoveJobs(restriction, null, contentsTable, mdbGuid, null);
if (allMoveJobs != null)
{
foreach (MoveJob job in allMoveJobs)
{
collection.Add(new MRSPoisonedJobIssue(job));
}
}
}
}
}
}
}
catch (LocalizedException lastScanError)
{
base.LastScanError = lastScanError;
}
}
}
return(collection);
}
internal override void Delete()
{
if (ObjectState.Deleted == base.ObjectState)
{
throw new MapiInvalidOperationException(Strings.ExceptionObjectStateInvalid(base.ObjectState.ToString()));
}
if (base.ObjectState == ObjectState.New)
{
base.MarkAsDeleted();
return;
}
Folder.CheckRequirementsToContinue(this.Identity, base.MapiSession);
ExTraceGlobals.FolderTracer.TraceDebug <FolderId, string>((long)this.GetHashCode(), "To Delete Folder '{0}' on server '{1}'.", this.Identity, base.MapiSession.ServerName);
base.EnableDisposeTracking();
using (MapiStore messageStore = this.GetMessageStore())
{
using (MapiFolder mapiFolder = this.GetMapiFolder(messageStore))
{
try
{
this.DetectDisallowedModification(messageStore);
bool flag = false;
this.TryTestHasSubFolders(mapiFolder, out flag);
try
{
using (MapiFolder parentFolder = this.GetParentFolder(messageStore))
{
parentFolder.DeleteFolder((byte[])this.Identity.MapiEntryId);
}
}
catch (MapiExceptionPartialCompletion innerException)
{
if (flag)
{
throw new MapiPartialCompletionException(Strings.ErrorRemovalPartialCompleted(this.Identity.ToString()), innerException);
}
throw;
}
}
finally
{
base.Dispose();
}
}
}
base.ResetChangeTracking();
base.MarkAsDeleted();
}
public static FolderHierarchyChangeDetector.MailboxChangesManifest RunICSManifestSync(bool catchup, FolderHierarchyChangeDetector.SyncHierarchyManifestState hierState, MailboxSession mailboxSession, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
syncLogger.TraceDebug <SmtpAddress, bool>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderHierarchyChangeDetector.RunICSManifestSync] Checking for folder hierarhcy changes for Mailbox: {0}. Catchup? {1}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, catchup);
MapiStore _ContainedMapiStore = mailboxSession.__ContainedMapiStore;
FolderHierarchyChangeDetector.MailboxChangesManifest mailboxChangesManifest = new FolderHierarchyChangeDetector.MailboxChangesManifest();
FolderHierarchyChangeDetector.ManifestHierarchyCallback iMapiManifestCallback = new FolderHierarchyChangeDetector.ManifestHierarchyCallback(catchup, mailboxChangesManifest);
try
{
using (MapiFolder ipmSubtreeFolder = _ContainedMapiStore.GetIpmSubtreeFolder())
{
SyncConfigFlags syncConfigFlags = SyncConfigFlags.ManifestHierReturnDeletedEntryIds;
int serverVersion = mailboxSession.MailboxOwner.MailboxInfo.Location.ServerVersion;
if ((serverVersion >= Server.E14MinVersion && serverVersion < Server.E15MinVersion) || (long)serverVersion >= FolderHierarchyChangeDetector.E15MinVersionSupportsOnlySpecifiedPropsForHierarchy)
{
syncConfigFlags |= SyncConfigFlags.OnlySpecifiedProps;
}
using (MapiHierarchyManifestEx mapiHierarchyManifestEx = ipmSubtreeFolder.CreateExportHierarchyManifestEx(syncConfigFlags, hierState.IdsetGiven, hierState.CnsetSeen, iMapiManifestCallback, FolderHierarchyChangeDetector.PropsToFetch, null))
{
while (mapiHierarchyManifestEx.Synchronize() != ManifestStatus.Done)
{
}
byte[] idSetGiven;
byte[] cnetSeen;
mapiHierarchyManifestEx.GetState(out idSetGiven, out cnetSeen);
syncLogger.TraceDebug <SmtpAddress, int, int>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderHierarchyChangeDetector.RunICSManifestSync] Updating ICS state for mailbox: '{0}'. Change Count: {1}, Delete Count: {2}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, mailboxChangesManifest.ChangedFolders.Count, mailboxChangesManifest.DeletedFolders.Count);
hierState.Update(idSetGiven, cnetSeen);
}
}
}
catch (MapiPermanentException arg)
{
syncLogger.TraceDebug <SmtpAddress, MapiPermanentException>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderHierarchyChangeDetector.RunICSManifestSync] Caught MapiPermanentException when determining folder ICS changes for mailbox: {0}. Exception: {1}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, arg);
return(null);
}
catch (MapiRetryableException arg2)
{
syncLogger.TraceDebug <SmtpAddress, MapiRetryableException>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderHierarchyChangeDetector.RunICSManifestSync] Caught MapiRetryableException when determining folder ICS changes for mailbox: {0}. Exception: {1}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, arg2);
return(null);
}
return(mailboxChangesManifest);
}
internal static List <MoveHistoryEntryInternal> LoadMoveHistory(Guid mailboxGuid, Guid mdbGuid, UserMailboxFlags flags)
{
List <MoveHistoryEntryInternal> result;
using (MapiStore userMailbox = MapiUtils.GetUserMailbox(mailboxGuid, mdbGuid, flags))
{
if (userMailbox == null)
{
result = null;
}
else
{
result = MoveHistoryEntryInternal.LoadMoveHistory(userMailbox);
}
}
return(result);
}
public static MapiFolder OpenFolderUnderRoot(MapiStore mailbox, string folderName, bool createIfMissing)
{
MapiFolder result;
using (MapiFolder nonIpmSubtreeFolder = mailbox.GetNonIpmSubtreeFolder())
{
MapiFolder mapiFolder = null;
try
{
mapiFolder = nonIpmSubtreeFolder.OpenSubFolderByName(folderName);
}
catch (MapiExceptionNotFound)
{
}
if (mapiFolder == null && createIfMissing)
{
MrsTracer.Common.Debug("Folder '{0}' does not exist, creating it.", new object[]
{
folderName
});
try
{
mapiFolder = nonIpmSubtreeFolder.CreateFolder(folderName, null, false);
MrsTracer.Common.Debug("Created '{0}' folder.", new object[]
{
folderName
});
}
catch (MapiExceptionCollision)
{
MrsTracer.Common.Debug("Somebody beat us to creating the folder. Will attempt to open it.", new object[0]);
}
if (mapiFolder == null)
{
mapiFolder = nonIpmSubtreeFolder.OpenSubFolderByName(folderName);
MrsTracer.Common.Debug("Opened '{0}' folder.", new object[]
{
folderName
});
}
}
result = mapiFolder;
}
return(result);
}
internal static MapiFolder GetFolderByPath(MapiStore mapiStore, MapiFolderPath folderPath)
{
MapiFolder mapiFolder = null;
MapiFolder folderByPath;
try
{
folderByPath = Folder.GetFolderByPath(mapiStore, folderPath, out mapiFolder);
}
finally
{
if (mapiFolder != null)
{
mapiFolder.Dispose();
}
}
return(folderByPath);
}
internal MessageSearcher(MapiStore store, SearchTestResult searchResult, MonitorHelper monitor, StopClass threadExit)
{
if (store == null)
{
throw new ArgumentNullException("store");
}
if (searchResult == null)
{
throw new ArgumentNullException("searchResult");
}
this.store = store;
this.searchResult = searchResult;
this.databaseGuid = searchResult.DatabaseGuid;
this.searchString = DateTime.UtcNow.Ticks.ToString();
this.monitor = monitor;
this.threadExit = threadExit;
this.ReadSleepTestHook();
}
internal static MapiFolder RetrieveMapiFolder(MapiStore store, FolderId identity)
{
MapiFolder mapiFolder = null;
MapiFolder result;
try
{
FolderId folderId = null;
result = Folder.RetrieveMapiFolder(store, identity, ref mapiFolder, null, out folderId);
}
finally
{
if (mapiFolder != null)
{
mapiFolder.Dispose();
}
}
return(result);
}
public static void StartMapiDeadSessionChecking(MapiStore store, string mailboxId)
{
if (store == null)
{
return;
}
CommonUtils.ProcessKnownExceptions(delegate
{
store.Advise(null, AdviseFlags.Extended, new MapiNotificationHandler(MapiUtils.OnDroppedMapiSessionNotify), NotificationCallbackMode.Async, MapiNotificationClientFlags.AutoDisposeNotificationHandles);
store.Advise(null, AdviseFlags.ConnectionDropped, new MapiNotificationHandler(MapiUtils.OnDroppedMapiSessionNotify), NotificationCallbackMode.Async, MapiNotificationClientFlags.AutoDisposeNotificationHandles);
}, delegate(Exception ex)
{
MrsTracer.Provider.Warning("Failed to subscribe to Store session dead notification for {0}. Failure: {1}.", new object[]
{
mailboxId,
CommonUtils.FullExceptionMessage(ex)
});
return(true);
});
}
