private T ReadFolderData <T>(Func <T> getDataDelegate, Action <List <BadMessageRec> > reportBadItemsDelegate, Func <byte[], IFolder> openFolderDelegate) where T : class
{
T result = default(T);
CommonUtils.ProcessKnownExceptions(delegate
{
CommonUtils.TreatMissingFolderAsTransient(delegate
{
result = getDataDelegate();
}, this.EntryId, openFolderDelegate);
}, delegate(Exception ex)
{
if (reportBadItemsDelegate != null && CommonUtils.ExceptionIsAny(ex, new WellKnownException[]
{
WellKnownException.DataProviderPermanent,
WellKnownException.CorruptData,
WellKnownException.NonCanonicalACL
}))
{
List <BadMessageRec> list = new List <BadMessageRec>(1);
list.Add(BadMessageRec.Folder(this.FolderRec, BadItemKind.CorruptFolderACL, ex));
reportBadItemsDelegate(list);
return(true);
}
return(false);
});
return(result);
}
public void WriteRules(IDestinationFolder targetFolder, Action <List <BadMessageRec> > reportBadItemsDelegate)
{
if (this.FolderType == FolderType.Search)
{
return;
}
CommonUtils.ProcessKnownExceptions(delegate
{
targetFolder.SetRules(this.Rules);
}, delegate(Exception ex)
{
if (reportBadItemsDelegate != null && CommonUtils.ExceptionIsAny(ex, new WellKnownException[]
{
WellKnownException.DataProviderPermanent,
WellKnownException.MapiNotEnoughMemory
}))
{
List <BadMessageRec> list = new List <BadMessageRec>(1);
list.Add(BadMessageRec.Folder(this.FolderRec, BadItemKind.CorruptFolderRule, ex));
reportBadItemsDelegate(list);
return(true);
}
return(false);
});
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && message.RawFailure != null && message.Failure != null && message.Failure.Message != null && CommonUtils.ExceptionIs(message.RawFailure, new WellKnownException[]
{
WellKnownException.CorruptData
}) && message.Failure.Message.Contains("[String]") && (message.Failure.Message.Contains("[{00062008-0000-0000-c000-000000000046}:0x853a]") || message.Failure.Message.Contains("[{00020329-0000-0000-c000-000000000046}:'Keywords']")));
}
public void EnumerateRestriction(FolderRec folderRec, BadItemKind badItemKind, RestrictionData rest)
{
if (rest != null)
{
CommonUtils.ProcessKnownExceptions(delegate
{
rest.EnumeratePropTags(new CommonUtils.EnumPropTagDelegate(this.EnumeratePtag));
}, delegate(Exception ex)
{
if (this.reportBadItemsDelegate != null && CommonUtils.ExceptionIsAny(ex, new WellKnownException[]
{
WellKnownException.DataProviderPermanent,
WellKnownException.CorruptData
}))
{
List <BadMessageRec> list = new List <BadMessageRec>(1);
list.Add(BadMessageRec.Folder(folderRec, badItemKind, ex));
this.reportBadItemsDelegate(list);
return(true);
}
return(false);
});
this.hasUnresolvedMappings = true;
}
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && message.RawFailure != null && CommonUtils.ExceptionIs(message.RawFailure, new WellKnownException[]
{
WellKnownException.NonCanonicalACL
}));
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && message.RawFailure != null && CommonUtils.ExceptionIs(message.RawFailure, new WellKnownException[]
{
WellKnownException.CorruptRecipient
}) && message.MessageClass == "IPM.Note.Microsoft.CDR.UM");
}
private void AccountBadItem(BadMessageRec item)
{
switch (item.Kind)
{
case BadItemKind.MissingItem:
this.MissingCount++;
break;
case BadItemKind.CorruptItem:
this.CorruptCount++;
break;
case BadItemKind.LargeItem:
this.LargeCount++;
break;
default:
this.OtherCount++;
break;
}
SkippedItemCounts.CategoryKey key = new SkippedItemCounts.CategoryKey
{
Kind = item.Kind,
Category = item.Category
};
int num;
if (!this.counts.TryGetValue(key, out num))
{
num = 0;
}
this.counts[key] = num + 1;
}
internal BadItemMarker(BadMessageRec badItem)
{
this.Kind = badItem.Kind;
this.EntryId = badItem.EntryId;
this.MessageSize = badItem.MessageSize;
this.Category = badItem.Category;
}
internal static BadMessageRec Item(MessageRec msgData, FolderRec folderRec, Exception exception)
{
BadMessageRec badMessageRec = new BadMessageRec();
if (exception == null)
{
badMessageRec.Kind = BadItemKind.MissingItem;
}
else if (CommonUtils.ExceptionIs(exception, new WellKnownException[]
{
WellKnownException.MapiMaxSubmissionExceeded
}))
{
badMessageRec.Kind = BadItemKind.LargeItem;
}
else
{
badMessageRec.Kind = BadItemKind.CorruptItem;
}
badMessageRec.EntryId = msgData.EntryId;
badMessageRec.Sender = (msgData[PropTag.SenderName] as string);
badMessageRec.Recipient = (msgData[PropTag.ReceivedByName] as string);
badMessageRec.Subject = (msgData[PropTag.Subject] as string);
badMessageRec.MessageClass = (msgData[PropTag.MessageClass] as string);
badMessageRec.MessageSize = (int?)msgData[PropTag.MessageSize];
badMessageRec.DateSent = (DateTime?)msgData[PropTag.ClientSubmitTime];
badMessageRec.DateReceived = (DateTime?)msgData[PropTag.MessageDeliveryTime];
badMessageRec.FolderId = msgData.FolderId;
badMessageRec.FolderName = folderRec.FolderName;
badMessageRec.Failure = FailureRec.Create(exception);
badMessageRec.RawFailure = exception;
return(badMessageRec);
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && message.RawFailure != null && CommonUtils.ExceptionIs(message.RawFailure, new WellKnownException[]
{
WellKnownException.ConflictEntryIdCorruption
}));
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && message.RawFailure != null && CommonUtils.ExceptionIs(message.RawFailure, new WellKnownException[]
{
WellKnownException.InvalidMultivalueElement
}));
}
public void Append(LocalizedString msg, BadMessageRec badItem)
{
this.Append(new ReportEntry(msg)
{
BadItem = badItem,
Failure = badItem.Failure,
Flags = (ReportEntryFlags.BadItem | ReportEntryFlags.Failure)
});
}
internal static BadMessageRec MissingItem(Exception ex)
{
return(new BadMessageRec
{
Kind = BadItemKind.MissingItem,
Failure = FailureRec.Create(ex),
EntryId = BadMessageRec.ComputeKey(BitConverter.GetBytes(ex.GetHashCode()), BadItemKind.MissingItem)
});
}
internal static BadMessageRec MisplacedFolder(FolderRec folderRec, string folderPath, WellKnownFolderType wkfType, byte[] destParentId)
{
return(new BadMessageRec
{
Kind = BadItemKind.MisplacedFolder,
EntryId = BadMessageRec.ComputeKey(folderRec.EntryId, BadItemKind.MisplacedFolder),
FolderId = folderRec.EntryId,
FolderName = folderPath,
WellKnownFolderType = wkfType
});
}
public void Classify(BadMessageRec item, TestIntegration testIntegration)
{
foreach (BadItemCategory badItemCategory in BadItemClassifier.categories)
{
if (badItemCategory.IsMatch(item, testIntegration))
{
item.Category = badItemCategory.Name;
break;
}
}
}
internal static BadMessageRec Folder(FolderRec folderRec, BadItemKind kind, Exception failure)
{
return(new BadMessageRec
{
Kind = kind,
EntryId = BadMessageRec.ComputeKey(folderRec.EntryId, kind),
FolderId = folderRec.EntryId,
FolderName = folderRec.FolderName,
Failure = FailureRec.Create(failure),
RawFailure = failure
});
}
internal static BadMessageRec FolderProperty(FolderRec folderRec, PropTag propTag, string sourceValue, string destValue)
{
BadMessageRec badMessageRec = new BadMessageRec();
badMessageRec.FolderId = folderRec.EntryId;
badMessageRec.FolderName = folderRec.FolderName;
badMessageRec.Kind = BadItemKind.FolderPropertyMismatch;
badMessageRec.EntryId = BadMessageRec.ComputeKey(folderRec.EntryId, badMessageRec.Kind, propTag);
PropertyMismatchException ex = new PropertyMismatchException((uint)propTag, sourceValue, destValue);
badMessageRec.Failure = FailureRec.Create(ex);
badMessageRec.RawFailure = ex;
return(badMessageRec);
}
private void SetMailboxSettings()
{
List <ItemPropertiesBase> mailboxSettings = base.MailboxMerger.SourceMailbox.GetMailboxSettings(GetMailboxSettingsFlags.Finalize);
if (mailboxSettings != null)
{
List <BadMessageRec> badItems = new List <BadMessageRec>();
using (List <ItemPropertiesBase> .Enumerator enumerator = mailboxSettings.GetEnumerator())
{
while (enumerator.MoveNext())
{
ItemPropertiesBase item = enumerator.Current;
if (!base.MailboxMerger.SyncState.BadItems.ContainsKey(item.GetId()))
{
CommonUtils.ProcessKnownExceptions(delegate
{
ExecutionContext.Create(new DataContext[]
{
new ItemPropertiesDataContext(item)
}).Execute(delegate
{
this.MailboxMerger.DestMailbox.SetMailboxSettings(item);
});
}, delegate(Exception failure)
{
if (MapiUtils.IsBadItemIndicator(failure))
{
badItems.Add(BadMessageRec.MailboxSetting(failure, item));
return(true);
}
return(false);
});
}
}
}
if (badItems != null && badItems.Count > 0)
{
base.MailboxMerger.ReportBadItems(badItems);
}
}
base.ScheduleWorkItem(new Action(this.MservSwitchOver), WorkloadType.Unknown);
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
if (message == null)
{
return(false);
}
bool result = true;
if (this.badItemKind != null && message.Kind != this.badItemKind.Value)
{
result = false;
}
if (this.wke != null && !CommonUtils.ExceptionIs(message.RawFailure, new WellKnownException[]
{
this.wke.Value
}))
{
result = false;
}
return(result);
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && message.MessageClass != null && ObjectClass.IsDistributionList(message.MessageClass));
}
public abstract bool IsMatch(BadMessageRec message, TestIntegration testIntegration);
public static void Write(Guid requestGuid, BadMessageRec item)
{
BadItemData objectToLog = new BadItemData(requestGuid, item);
BadItemLog.instance.LogObject(objectToLog);
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(true);
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && (message.MessageClass == null || !ObjectClass.IsContact(message.MessageClass)) && message.DateSent != null && message.DateSent.Value < DateTime.UtcNow - this.ageLimit);
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && FolderFilterParser.IsDumpster(message.WellKnownFolderType));
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && message.Failure != null && message.Failure.DataContext != null && message.Failure.Message != null && message.Failure.FailureSideInt == 2 && !(message.Failure.FailureType != "ObjectValidationException") && message.Failure.DataContext.Contains("ISourceMailbox.ExportMessages") && message.Failure.Message.Contains("Microsoft.Exchange.Data.Storage.RecurrenceBlobConstraint"));
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message.Failure != null && message.Failure.DataContext != null && message.Failure.Message != null && message.Failure.FailureSideInt == 2 && !(message.Failure.FailureType != "ObjectValidationException") && message.Failure.DataContext.Contains("ISourceMailbox.ExportMessages") && message.Failure.Message.Contains(this.failureSignature));
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(testIntegration.ClassifyBadItemFaults && (message != null && message.Failure != null && message.Failure.Message != null) && message.Failure.Message.Contains("Lid: 48184 StoreEc: 0x8000400"));
}
public override bool IsMatch(BadMessageRec message, TestIntegration testIntegration)
{
return(message != null && message.Failure != null && message.Failure.Message != null && message.Failure.Message.Contains("Lid: 37736 dwParam: 0x") && message.Failure.Message.Contains("Lid: 55288 StoreEc: 0x80040117"));
}
public void FinalSyncCopyMailboxData()
{
if (base.MRSJob.TestIntegration.RemoteExchangeGuidOverride == Guid.Empty)
{
using (IFxProxy fxProxy = base.DestMailbox.GetFxProxy())
{
using (IFxProxy fxProxy2 = base.CreateFxProxyTransmissionPipeline(fxProxy))
{
base.SourceMailbox.CopyTo(fxProxy2, new PropTag[]
{
PropTag.ContainerHierarchy,
PropTag.ContainerContents
});
}
}
if (this.ServerSupportsInferencePropertiesMove(base.SourceMailboxWrapper.MailboxVersion) && this.ServerSupportsInferencePropertiesMove(base.DestMailboxWrapper.MailboxVersion) && base.MRSJob.GetConfig <bool>("CopyInferenceProperties"))
{
byte[] badItemId = BitConverter.GetBytes(base.SourceMailbox.GetHashCode());
CommonUtils.ProcessKnownExceptions(delegate
{
List <PropValueData> list = new List <PropValueData>(2);
foreach (PropValueData propValueData in this.SourceMailbox.GetProps(MailboxMover.inferencePropertiesToMove))
{
if (((PropTag)propValueData.PropTag).ValueType() != PropType.Error)
{
list.Add(propValueData);
}
}
badItemId = BadMessageRec.ComputeKey(list.ToArray());
if (!this.SyncState.BadItems.ContainsKey(badItemId))
{
this.DestMailbox.SetProps(list.ToArray());
}
}, delegate(Exception failure)
{
if (MapiUtils.IsBadItemIndicator(failure))
{
List <BadMessageRec> list = new List <BadMessageRec>(1);
list.Add(BadMessageRec.InferenceData(failure, badItemId));
this.ReportBadItems(list);
return(true);
}
return(false);
});
}
}
if (base.SupportsPerUserReadUnreadDataTransfer)
{
base.Report.Append(MrsStrings.ReportCopyPerUserReadUnreadDataStarted);
using (ISourceFolder folder = base.SourceMailbox.GetFolder(null))
{
using (IDestinationFolder folder2 = base.DestMailbox.GetFolder(null))
{
using (IFxProxy fxProxy3 = folder2.GetFxProxy(FastTransferFlags.PassThrough))
{
using (IFxProxy fxProxy4 = base.CreateFxProxyTransmissionPipeline(fxProxy3))
{
folder.CopyTo(fxProxy4, CopyPropertiesFlags.CopyMailboxPerUserData, Array <PropTag> .Empty);
}
}
}
}
base.Report.Append(MrsStrings.ReportCopyPerUserReadUnreadDataCompleted);
}
}
