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); } }