Exemplo n.º 1
0
        public static bool RemoveFolder(AnchorContext context, MailboxSession mailboxSession, string folderName)
        {
            StoreObjectId defaultFolderId = mailboxSession.GetDefaultFolderId(DefaultFolderType.Root);
            StoreObjectId folderId        = AnchorFolder.GetFolderId(context, mailboxSession, defaultFolderId, folderName);

            if (folderId == null)
            {
                context.Logger.Log(MigrationEventType.Verbose, "couldn't find folder with name {0} treating as success", new object[]
                {
                    folderName
                });
                return(true);
            }
            using (Folder folder = Folder.Bind(mailboxSession, folderId, AnchorFolder.FolderIdPropertyDefinition))
            {
                context.Logger.Log(MigrationEventType.Information, "About to remove all messages & subfolders from {0} with id {1}", new object[]
                {
                    folderName,
                    folderId
                });
                GroupOperationResult groupOperationResult = folder.DeleteAllObjects(DeleteItemFlags.HardDelete, true);
                if (groupOperationResult.OperationResult != OperationResult.Succeeded)
                {
                    context.Logger.Log(MigrationEventType.Warning, "unsuccessfully removed messages & subfolders from {0} with id {1} with result {2}", new object[]
                    {
                        folderName,
                        folderId,
                        groupOperationResult
                    });
                    return(false);
                }
            }
            bool result;

            using (Folder folder2 = Folder.Bind(mailboxSession, defaultFolderId))
            {
                context.Logger.Log(MigrationEventType.Information, "About to remove folder {0} with id {1}", new object[]
                {
                    folderName,
                    folderId
                });
                AggregateOperationResult aggregateOperationResult = folder2.DeleteObjects(DeleteItemFlags.HardDelete, new StoreId[]
                {
                    folderId
                });
                if (aggregateOperationResult.OperationResult != OperationResult.Succeeded)
                {
                    context.Logger.Log(MigrationEventType.Warning, "unsuccessfully removed folder {0} with id {1} with result {2}", new object[]
                    {
                        folderName,
                        folderId,
                        aggregateOperationResult
                    });
                    result = false;
                }
                else
                {
                    result = true;
                }
            }
            return(result);
        }
Exemplo n.º 2
0
        // Token: 0x06000335 RID: 821 RVA: 0x00014474 File Offset: 0x00012674
        protected override void ExpireInBatches(List <ItemData> listToSend, ExpirationExecutor.Action retentionActionType, params StoreObjectId[] destinationFolderIds)
        {
            int             count           = listToSend.Count;
            int             i               = 0;
            int             num             = 0;
            OperationResult operationResult = OperationResult.Succeeded;
            bool            errorOccurred   = false;
            DateTime        dateTime        = DateTime.MinValue;

            try
            {
                while (i < count)
                {
                    base.ElcAssistant.ThrottleStoreCallAndCheckForShutdown(base.MailboxData.MailboxSession.MailboxOwner);
                    int           num2  = (count - i >= 100) ? 100 : (count - i);
                    VersionedId[] array = new VersionedId[num2];
                    num += base.CopyIdsToTmpArray(listToSend.ToArray(), i, array, num2);
                    i   += num2;
                    this.provisionedFolder.CurrentItems = array;
                    switch (retentionActionType)
                    {
                    case ExpirationExecutor.Action.MoveToFolder:
                    {
                        GroupOperationResult groupOperationResult = this.provisionedFolder.Folder.MoveItems(destinationFolderIds[0], array);
                        operationResult = groupOperationResult.OperationResult;
                        break;
                    }

                    case ExpirationExecutor.Action.MoveToFolderAndSet:
                    {
                        object[] values = new object[]
                        {
                            new CompositeProperty(Server.Exchange2007MajorVersion, base.MailboxData.Now).GetBytes()
                        };
                        GroupOperationResult groupOperationResult2 = this.provisionedFolder.Folder.UnsafeMoveItemsAndSetProperties(destinationFolderIds[0], array, new PropertyDefinition[]
                            {
                                ItemSchema.ElcMoveDate
                            }, values);
                        operationResult = groupOperationResult2.OperationResult;
                        break;
                    }

                    case ExpirationExecutor.Action.SoftDelete:
                    {
                        AggregateOperationResult aggregateOperationResult = this.provisionedFolder.Folder.DeleteObjects(DeleteItemFlags.SoftDelete, array);
                        operationResult = aggregateOperationResult.OperationResult;
                        break;
                    }

                    case ExpirationExecutor.Action.PermanentlyDelete:
                    {
                        AggregateOperationResult aggregateOperationResult2 = this.provisionedFolder.Folder.DeleteObjects(DeleteItemFlags.HardDelete, array);
                        operationResult = aggregateOperationResult2.OperationResult;
                        break;
                    }
                    }
                    if (operationResult == OperationResult.Failed || operationResult == OperationResult.PartiallySucceeded)
                    {
                        FolderExpirationExecutor.Tracer.TraceError((long)this.GetHashCode(), "{0}: An error occured when trying to expire a batch of {1} items. Expiration action is {2}. Result: {3}", new object[]
                        {
                            this,
                            num2,
                            retentionActionType,
                            operationResult
                        });
                        errorOccurred = true;
                        dateTime      = ((dateTime == DateTime.MinValue) ? listToSend[i - num2].MessageReceivedDate : dateTime);
                        base.MailboxData.ThrowIfErrorsOverLimit();
                    }
                }
                int num3 = this.ProcessItemsSuccessfullyExpired(listToSend, errorOccurred, dateTime);
                ELCPerfmon.TotalItemsExpired.IncrementBy((long)num3);
                ELCPerfmon.TotalSizeItemsExpired.IncrementBy((long)num);
                switch (retentionActionType)
                {
                case ExpirationExecutor.Action.MoveToFolder:
                case ExpirationExecutor.Action.MoveToFolderAndSet:
                    ELCPerfmon.TotalItemsMoved.IncrementBy((long)num3);
                    ELCPerfmon.TotalSizeItemsMoved.IncrementBy((long)num);
                    break;

                case ExpirationExecutor.Action.SoftDelete:
                    ELCPerfmon.TotalItemsSoftDeleted.IncrementBy((long)num3);
                    ELCPerfmon.TotalSizeItemsSoftDeleted.IncrementBy((long)num);
                    break;

                case ExpirationExecutor.Action.PermanentlyDelete:
                    ELCPerfmon.TotalItemsPermanentlyDeleted.IncrementBy((long)num3);
                    ELCPerfmon.TotalSizeItemsPermanentlyDeleted.IncrementBy((long)num);
                    break;
                }
            }
            catch (ObjectNotFoundException arg)
            {
                FolderExpirationExecutor.Tracer.TraceDebug <FolderExpirationExecutor, ExpirationExecutor.Action, ObjectNotFoundException>((long)this.GetHashCode(), "{0}: Either the source or the destination folder (if applicable) was not found. Skipping current action '{1}' for this folder. Exception: '{2}'", this, retentionActionType, arg);
            }
        }
Exemplo n.º 3
0
        public bool Delete(StoreObjectId folderId, bool isPermanentDelete)
        {
            OperationResult          operationResult = OperationResult.Succeeded;
            AggregateOperationResult aggregateOperationResult;

            try
            {
                aggregateOperationResult = this.owaContext.UserContext.MailboxSession.Delete(isPermanentDelete ? DeleteItemFlags.HardDelete : DeleteItemFlags.MoveToDeletedItems, new StoreId[]
                {
                    folderId
                });
                operationResult = aggregateOperationResult.OperationResult;
            }
            catch (ObjectNotFoundException)
            {
                this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(2106120183, InfobarMessageType.Error);
                return(false);
            }
            catch (InvalidOperationException)
            {
                this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(1752827486, InfobarMessageType.Error);
                return(false);
            }
            catch (StoragePermanentException e)
            {
                InfobarMessage.PutExceptionInfoIntoContextInfobarMessage(e, this.owaContext);
                return(false);
            }
            catch (StorageTransientException e2)
            {
                InfobarMessage.PutExceptionInfoIntoContextInfobarMessage(e2, this.owaContext);
                return(false);
            }
            if (operationResult != OperationResult.Succeeded)
            {
                int i = 0;
                while (i < aggregateOperationResult.GroupOperationResults.Length)
                {
                    GroupOperationResult groupOperationResult = aggregateOperationResult.GroupOperationResults[i];
                    if (groupOperationResult.OperationResult != OperationResult.Succeeded)
                    {
                        if (groupOperationResult.Exception is ObjectNotFoundException)
                        {
                            this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(2106120183, InfobarMessageType.Error);
                            return(false);
                        }
                        if (groupOperationResult.Exception is ObjectExistedException)
                        {
                            this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(1041829989, InfobarMessageType.Error);
                            return(false);
                        }
                        if (groupOperationResult.Exception is CannotMoveDefaultFolderException)
                        {
                            this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(1752827486, InfobarMessageType.Error);
                            return(false);
                        }
                        if (groupOperationResult.Exception is PartialCompletionException)
                        {
                            this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(1752827486, InfobarMessageType.Error);
                            return(false);
                        }
                        InfobarMessage.PutExceptionInfoIntoContextInfobarMessage(aggregateOperationResult.GroupOperationResults[i].Exception, this.owaContext);
                        return(false);
                    }
                    else
                    {
                        i++;
                    }
                }
            }
            this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(-572096464, InfobarMessageType.Informational);
            return(true);
        }
        // Token: 0x06000A16 RID: 2582 RVA: 0x00042830 File Offset: 0x00040A30
        internal bool MoveCalendarNotificationSettingsToSettingsFolder()
        {
            bool result;

            lock (this.systemMailboxMutex)
            {
                if (this.isDisposed)
                {
                    result = false;
                }
                else
                {
                    this.ConnectSystemMailboxSession();
                    try
                    {
                        StoreObjectId defaultFolderId = this.systemMailboxSession.GetDefaultFolderId(DefaultFolderType.Configuration);
                        using (Folder folder = Folder.Bind(this.systemMailboxSession, defaultFolderId))
                        {
                            using (QueryResult queryResult = folder.ItemQuery(ItemQueryType.None, null, SystemMailbox.SortByItemClass, SystemMailbox.updatingUserSettingsProperties))
                            {
                                List <VersionedId> list = new List <VersionedId>();
                                if (queryResult.SeekToCondition(SeekReference.OriginBeginning, SystemMailbox.SettingsItemClassFilter))
                                {
                                    bool flag2 = false;
                                    do
                                    {
                                        IStorePropertyBag[] propertyBags = queryResult.GetPropertyBags(10000);
                                        if (propertyBags.Length <= 0)
                                        {
                                            break;
                                        }
                                        foreach (IStorePropertyBag storePropertyBag in propertyBags)
                                        {
                                            if (!string.Equals(storePropertyBag.TryGetProperty(StoreObjectSchema.ItemClass) as string, "IPM.Configuration.UserCalendarNotification", StringComparison.OrdinalIgnoreCase))
                                            {
                                                flag2 = true;
                                                break;
                                            }
                                            list.Add((VersionedId)storePropertyBag.TryGetProperty(ItemSchema.Id));
                                        }
                                    }while (!flag2);
                                }
                                if (list.Count == 0)
                                {
                                    result = false;
                                }
                                else
                                {
                                    GroupOperationResult groupOperationResult = folder.MoveItems(this.TextSettingsFolderId, list.ToArray());
                                    if (groupOperationResult.OperationResult != OperationResult.Succeeded)
                                    {
                                        result = false;
                                    }
                                    else
                                    {
                                        result = true;
                                    }
                                }
                            }
                        }
                    }
                    finally
                    {
                        this.DisconnectSystemMailboxSession();
                    }
                }
            }
            return(result);
        }
 public static bool TryCreate(MailboxSession mailboxSession, FolderChangeOperation operation, FolderChangeOperationFlags flags, GroupOperationResult result, StoreObjectId sourceFolderId, StoreObjectId destinationFolderId, out UserMoveActionHandler handler)
 {
     handler = null;
     if (operation == FolderChangeOperation.Move && result != null && result.OperationResult != OperationResult.Failed && result.ResultObjectIds != null && result.ResultObjectIds.Count > 0 && ClutterUtilities.IsClutterEnabled(mailboxSession, mailboxSession.MailboxOwner.GetConfiguration()) && sourceFolderId != null && destinationFolderId != null && !sourceFolderId.Equals(destinationFolderId))
     {
         bool flag = mailboxSession.LogonType == LogonType.Owner || flags.HasFlag(FolderChangeOperationFlags.ClutterActionByUserOverride);
         handler = new UserMoveActionHandler(mailboxSession, sourceFolderId, destinationFolderId, result.ResultObjectIds, flag);
         return(true);
     }
     return(false);
 }
Exemplo n.º 6
0
        public bool Move(StoreObjectId sourceId, StoreObjectId destinationId)
        {
            OperationResult          operationResult = OperationResult.Succeeded;
            string                   arg             = string.Empty;
            AggregateOperationResult aggregateOperationResult;

            try
            {
                using (Folder folder = Folder.Bind(this.owaContext.UserContext.MailboxSession, sourceId, new PropertyDefinition[]
                {
                    FolderSchema.DisplayName
                }))
                {
                    arg = folder.DisplayName;
                }
                aggregateOperationResult = this.owaContext.UserContext.MailboxSession.Move(destinationId, new StoreId[]
                {
                    sourceId
                });
                operationResult = aggregateOperationResult.OperationResult;
            }
            catch (ObjectNotFoundException)
            {
                this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(2106120183, InfobarMessageType.Error);
                return(false);
            }
            catch (InvalidOperationException)
            {
                this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(442250020, InfobarMessageType.Error);
                return(false);
            }
            catch (StoragePermanentException e)
            {
                InfobarMessage.PutExceptionInfoIntoContextInfobarMessage(e, this.owaContext);
                return(false);
            }
            catch (StorageTransientException e2)
            {
                InfobarMessage.PutExceptionInfoIntoContextInfobarMessage(e2, this.owaContext);
                return(false);
            }
            if (operationResult == OperationResult.Failed)
            {
                int i = 0;
                while (i < aggregateOperationResult.GroupOperationResults.Length)
                {
                    GroupOperationResult groupOperationResult = aggregateOperationResult.GroupOperationResults[i];
                    if (groupOperationResult.OperationResult != OperationResult.Succeeded)
                    {
                        if (groupOperationResult.Exception is CannotMoveDefaultFolderException)
                        {
                            this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(442250020, InfobarMessageType.Error);
                            return(false);
                        }
                        if (groupOperationResult.Exception is ObjectExistedException)
                        {
                            this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(896702607, InfobarMessageType.Error);
                            return(false);
                        }
                        InfobarMessage.PutExceptionInfoIntoContextInfobarMessage(aggregateOperationResult.GroupOperationResults[i].Exception, this.owaContext);
                        return(false);
                    }
                    else
                    {
                        i++;
                    }
                }
            }
            else if (operationResult == OperationResult.PartiallySucceeded)
            {
                this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateLocalized(-1093060331, InfobarMessageType.Error);
                return(false);
            }
            this.owaContext[OwaContextProperty.InfobarMessage] = InfobarMessage.CreateText(string.Format(LocalizedStrings.GetNonEncoded(2053728082), arg), InfobarMessageType.Informational);
            return(true);
        }
Exemplo n.º 7
0
 public GroupOperationAuditEvent(MailboxSession session, MailboxAuditOperations operation, COWSettings settings, LogonType logonType, bool externalAccess, StoreSession destinationSession, StoreObjectId destinationFolderId, StoreObjectId[] itemIds, GroupOperationResult result, IDictionary <StoreObjectId, FolderAuditInfo> folderAuditInfo, IDictionary <StoreObjectId, ItemAuditInfo> itemAuditInfo, IDictionary <StoreObjectId, FolderAuditInfo> parentFolders) : base(session, operation, settings, (result == null) ? OperationResult.Failed : result.OperationResult, logonType, externalAccess)
 {
     this.destinationSession  = destinationSession;
     this.destinationFolderId = destinationFolderId;
     this.folderAuditInfo     = folderAuditInfo;
     this.itemAuditInfo       = itemAuditInfo;
     this.parentFolders       = parentFolders;
 }
        public override void PerformBatchOperation(object[][] batchedItemBuffer, int fetchedItemCount, StoreId currentFolderId, MailboxSession sourceMailbox, MailboxSession targetMailbox, Dictionary <StoreId, FolderNode> folderNodeMap, SearchResultProcessor processor)
        {
            processor.CheckTargetMailboxAvailableSpace();
            StoreId[] array = new StoreId[fetchedItemCount];
            for (int i = 0; i < fetchedItemCount; i++)
            {
                array[i] = (StoreId)batchedItemBuffer[i][0];
            }
            FolderNode folderNode = folderNodeMap[currentFolderId];

            using (Folder folder = Folder.Bind(sourceMailbox, currentFolderId))
            {
                processor.BackOffFromSourceStore();
                processor.BackOffFromTargetStore();
                try
                {
                    GroupOperationResult groupOperationResult = null;
                    lock (targetMailbox)
                    {
                        if (processor.IsAborted())
                        {
                            return;
                        }
                        if (folderNode.TargetFolderId == null)
                        {
                            this.CreateTargetFolder(targetMailbox, folderNode);
                        }
                        groupOperationResult = folder.CopyItems(targetMailbox, folderNode.TargetFolderId, false, array);
                    }
                    if (groupOperationResult.OperationResult != OperationResult.Succeeded)
                    {
                        SearchMailboxAction.Tracer.TraceError <OperationResult, LocalizedException>((long)this.GetHashCode(), "DeleteItems operation failed with operation result: {0} and exception: {1}", groupOperationResult.OperationResult, groupOperationResult.Exception);
                        if (groupOperationResult.Exception.GetType() == typeof(MapiExceptionPartialCompletion) || groupOperationResult.Exception.GetType() == typeof(PartialCompletionException))
                        {
                            StoragePermanentException e = new StoragePermanentException(Strings.CopyItemsFailed, groupOperationResult.Exception);
                            processor.ReportActionException(e);
                        }
                        else
                        {
                            SearchMailboxException e2 = new SearchMailboxException(Strings.CopyItemsFailed, groupOperationResult.Exception);
                            processor.ReportActionException(e2);
                        }
                    }
                    else
                    {
                        SearchMailboxAction.Tracer.TraceDebug <int, string>((long)this.GetHashCode(), "SearchMailboxWoker progressed with {0} message deletes on mailbox {1}", array.Length, processor.GetSourceUserName());
                    }
                }
                catch (ArgumentException ex)
                {
                    SearchMailboxAction.Tracer.TraceError <ArgumentException>((long)this.GetHashCode(), "CopyItems operation failed due to item validation failed, exception: {0}", ex);
                    SearchMailboxException e3 = new SearchMailboxException(Strings.CopyItemsFailed, ex);
                    processor.ReportActionException(e3);
                }
                catch (MapiExceptionPartialCompletion mapiExceptionPartialCompletion)
                {
                    SearchMailboxAction.Tracer.TraceError <MapiExceptionPartialCompletion>((long)this.GetHashCode(), "CopyItems operation failed due to insufficient space in target mailbox, exception: {0}", mapiExceptionPartialCompletion);
                    StoragePermanentException e4 = new StoragePermanentException(Strings.CopyItemsFailed, mapiExceptionPartialCompletion);
                    processor.ReportActionException(e4);
                }
                catch (PartialCompletionException ex2)
                {
                    SearchMailboxAction.Tracer.TraceError <PartialCompletionException>((long)this.GetHashCode(), "CopyItems operation failed due to insufficient space in target mailbox, exception: {0}", ex2);
                    StoragePermanentException e5 = new StoragePermanentException(Strings.CopyItemsFailed, ex2);
                    processor.ReportActionException(e5);
                }
            }
        }
Exemplo n.º 9
0
        // Token: 0x06000391 RID: 913 RVA: 0x00019028 File Offset: 0x00017228
        private void InternalExpireInBatches(List <ItemData> listToSend, ExpirationExecutor.Action retentionActionType, Folder sourcefolder, Folder targetFolder)
        {
            int             count           = listToSend.Count;
            int             num             = 0;
            int             i               = 0;
            int             num2            = 0;
            long            num3            = 0L;
            int             num4            = 0;
            int             num5            = 0;
            int             num6            = 0;
            int             num7            = 0;
            int             num8            = 0;
            int             num9            = 0;
            int             num10           = 0;
            int             num11           = 0;
            int             num12           = 0;
            OperationResult operationResult = OperationResult.Succeeded;
            Exception       ex              = null;

            ItemData[] sourceArray = listToSend.ToArray();
            int        num13       = 0;
            int        num14       = 0;

            try
            {
                while (i < count)
                {
                    base.ElcAssistant.ThrottleStoreCallAndCheckForShutdown(base.MailboxData.MailboxSession.MailboxOwner);
                    int num15 = (count - i >= 100) ? 100 : (count - i);
                    switch (retentionActionType)
                    {
                    case ExpirationExecutor.Action.SoftDelete:
                    case ExpirationExecutor.Action.PermanentlyDelete:
                    {
                        VersionedId[] array = new VersionedId[num15];
                        num3 += (long)base.CopyIdsToTmpArray(sourceArray, i, array, num15);
                        num2  = num15;
                        Dictionary <ItemData.EnforcerType, int> numberOfItemsProcessedByEachEnforcer = ItemData.GetNumberOfItemsProcessedByEachEnforcer(sourceArray, i, num15);
                        AggregateOperationResult aggregateOperationResult;
                        if (retentionActionType == ExpirationExecutor.Action.SoftDelete)
                        {
                            num8 = (numberOfItemsProcessedByEachEnforcer.ContainsKey(ItemData.EnforcerType.ExpirationTagEnforcer) ? numberOfItemsProcessedByEachEnforcer[ItemData.EnforcerType.ExpirationTagEnforcer] : 0);
                            aggregateOperationResult = base.MailboxData.MailboxSession.Delete(DeleteItemFlags.SoftDelete | DeleteItemFlags.SuppressReadReceipt, array);
                        }
                        else
                        {
                            num11 = (numberOfItemsProcessedByEachEnforcer.ContainsKey(ItemData.EnforcerType.DiscoveryHoldEnforcer) ? numberOfItemsProcessedByEachEnforcer[ItemData.EnforcerType.DiscoveryHoldEnforcer] : 0);
                            num9  = (numberOfItemsProcessedByEachEnforcer.ContainsKey(ItemData.EnforcerType.DumpsterExpirationEnforcer) ? numberOfItemsProcessedByEachEnforcer[ItemData.EnforcerType.DumpsterExpirationEnforcer] : 0);
                            num10 = (numberOfItemsProcessedByEachEnforcer.ContainsKey(ItemData.EnforcerType.DumpsterQuotaEnforcer) ? numberOfItemsProcessedByEachEnforcer[ItemData.EnforcerType.DumpsterQuotaEnforcer] : 0);
                            num8  = (numberOfItemsProcessedByEachEnforcer.ContainsKey(ItemData.EnforcerType.ExpirationTagEnforcer) ? numberOfItemsProcessedByEachEnforcer[ItemData.EnforcerType.ExpirationTagEnforcer] : 0);
                            aggregateOperationResult = base.MailboxData.MailboxSession.Delete(DeleteItemFlags.HardDelete | DeleteItemFlags.SuppressReadReceipt, array);
                        }
                        operationResult = aggregateOperationResult.OperationResult;
                        ex = ElcExceptionHelper.ExtractExceptionsFromAggregateOperationResult(aggregateOperationResult);
                        break;
                    }

                    case ExpirationExecutor.Action.MoveToDiscoveryHolds:
                    case ExpirationExecutor.Action.MoveToMigratedMessages:
                    case ExpirationExecutor.Action.MoveToPurges:
                    {
                        VersionedId[] array2 = new VersionedId[num15];
                        num3 += (long)base.CopyIdsToTmpArray(sourceArray, i, array2, num15);
                        num2  = num15;
                        Dictionary <ItemData.EnforcerType, int> numberOfItemsProcessedByEachEnforcer2 = ItemData.GetNumberOfItemsProcessedByEachEnforcer(sourceArray, i, num15);
                        if (num2 > 0)
                        {
                            if (sourcefolder != null)
                            {
                                StoreObjectId destinationFolderId;
                                if (ExpirationExecutor.Action.MoveToPurges == retentionActionType)
                                {
                                    num13 = (numberOfItemsProcessedByEachEnforcer2.ContainsKey(ItemData.EnforcerType.DumpsterExpirationEnforcer) ? numberOfItemsProcessedByEachEnforcer2[ItemData.EnforcerType.DumpsterExpirationEnforcer] : 0);
                                    destinationFolderId = base.MailboxData.MailboxSession.GetDefaultFolderId(DefaultFolderType.RecoverableItemsPurges);
                                }
                                else if (ExpirationExecutor.Action.MoveToDiscoveryHolds == retentionActionType)
                                {
                                    num9  = (numberOfItemsProcessedByEachEnforcer2.ContainsKey(ItemData.EnforcerType.DumpsterExpirationEnforcer) ? numberOfItemsProcessedByEachEnforcer2[ItemData.EnforcerType.DumpsterExpirationEnforcer] : 0);
                                    num10 = (numberOfItemsProcessedByEachEnforcer2.ContainsKey(ItemData.EnforcerType.DumpsterQuotaEnforcer) ? numberOfItemsProcessedByEachEnforcer2[ItemData.EnforcerType.DumpsterQuotaEnforcer] : 0);
                                    destinationFolderId = base.MailboxData.MailboxSession.CowSession.CheckAndCreateDiscoveryHoldsFolder(base.MailboxData.MailboxSession);
                                }
                                else
                                {
                                    destinationFolderId = base.MailboxData.MailboxSession.CowSession.CheckAndCreateMigratedMessagesFolder();
                                }
                                if (this.IsMoveClearNrnFlightingEnabled())
                                {
                                    sourcefolder.ClearNotReadNotificationPending(array2);
                                }
                                GroupOperationResult groupOperationResult = sourcefolder.MoveItems(destinationFolderId, array2);
                                if (groupOperationResult.OperationResult == OperationResult.Succeeded)
                                {
                                    TagExpirationExecutor.Tracer.TraceDebug <TagExpirationExecutor, string, int>((long)this.GetHashCode(), "{0}: Moved to {1} batch of {2} items.", this, retentionActionType.ToString(), num2);
                                }
                                else
                                {
                                    operationResult = groupOperationResult.OperationResult;
                                    ex = groupOperationResult.Exception;
                                }
                            }
                        }
                        else
                        {
                            TagExpirationExecutor.Tracer.TraceDebug <TagExpirationExecutor>((long)this.GetHashCode(), "{0}: The tmpList was empty during this loop. Nothing to send, don't do anything.", this);
                        }
                        break;
                    }
                    }
                    i   += num15;
                    num += num2;
                    if (operationResult == OperationResult.Failed || operationResult == OperationResult.PartiallySucceeded)
                    {
                        TagExpirationExecutor.Tracer.TraceError((long)this.GetHashCode(), "{0}: An error occured when trying to expire a batch of {1} items. Expiration action is {2}. Result: {3}", new object[]
                        {
                            this,
                            num2,
                            retentionActionType,
                            operationResult
                        });
                        Globals.Logger.LogEvent(InfoWorkerEventLogConstants.Tuple_ExpirationOfCurrentBatchFailed, null, new object[]
                        {
                            base.MailboxData.MailboxSession.MailboxOwner,
                            retentionActionType.ToString(),
                            (sourcefolder == null) ? string.Empty : sourcefolder.DisplayName,
                            (targetFolder == null) ? string.Empty : targetFolder.DisplayName,
                            (sourcefolder == null) ? string.Empty : sourcefolder.Id.ObjectId.ToHexEntryId(),
                            (targetFolder == null) ? string.Empty : targetFolder.Id.ObjectId.ToHexEntryId(),
                            (ex == null) ? string.Empty : ex.ToString()
                        });
                        num12++;
                        base.MailboxData.ThrowIfErrorsOverLimit(ex);
                    }
                    else
                    {
                        num7  += num11;
                        num5  += num9;
                        num6  += num10;
                        num4  += num8;
                        num14 += num13;
                    }
                }
            }
            finally
            {
                ELCPerfmon.TotalItemsExpired.IncrementBy((long)num);
                ELCPerfmon.TotalSizeItemsExpired.IncrementBy(num3);
                switch (retentionActionType)
                {
                case ExpirationExecutor.Action.SoftDelete:
                    ELCPerfmon.TotalItemsSoftDeleted.IncrementBy((long)num);
                    ELCPerfmon.TotalSizeItemsSoftDeleted.IncrementBy(num3);
                    break;

                case ExpirationExecutor.Action.PermanentlyDelete:
                    ELCPerfmon.TotalItemsPermanentlyDeleted.IncrementBy((long)num);
                    ELCPerfmon.TotalSizeItemsPermanentlyDeleted.IncrementBy(num3);
                    break;

                case ExpirationExecutor.Action.MoveToDiscoveryHolds:
                    ELCPerfmon.TotalItemsMovedToDiscoveryHolds.IncrementBy((long)num);
                    ELCPerfmon.TotalSizeItemsMovedToDiscoveryHolds.IncrementBy(num3);
                    break;
                }
                base.MailboxData.StatisticsLogEntry.NumberOfItemsActuallyDeletedByDiscoveryHoldEnforcer      += (long)num7;
                base.MailboxData.StatisticsLogEntry.NumberOfItemsActuallyDeletedByDumpsterExpirationEnforcer += (long)num5;
                base.MailboxData.StatisticsLogEntry.NumberOfItemsActuallyDeletedByDumpsterQuotaEnforcer      += (long)num6;
                base.MailboxData.StatisticsLogEntry.NumberOfItemsActuallyDeletedByTag += (long)num4;
                base.MailboxData.StatisticsLogEntry.NumberOfBatchesFailedToExpireInExpirationExecutor += (long)num12;
                base.MailboxData.StatisticsLogEntry.NumberOfItemsActuallyMovedToPurgesByDumpsterExpirationEnforcer += (long)num14;
            }
        }
        // Token: 0x0600050E RID: 1294 RVA: 0x00026080 File Offset: 0x00024280
        private void ExpireInBatches(List <ItemData> listToSend, Folder sourceFolder, Folder targetFolder, ElcSubAssistant elcSubAssistant, ExpirationExecutor.Action retentionActionType, int totalFailuresSoFar, ref List <Exception> allExceptionsSoFar, out List <string> foldersWithErrors, out int newMoveErrorsTotal)
        {
            int             count           = listToSend.Count;
            int             num             = 0;
            int             i               = 0;
            int             num2            = 0;
            int             num3            = 0;
            long            num4            = 0L;
            int             num5            = 0;
            int             num6            = 0;
            int             num7            = 0;
            int             num8            = 0;
            OperationResult operationResult = OperationResult.Succeeded;
            Exception       ex              = null;

            ItemData[] sourceArray = listToSend.ToArray();
            foldersWithErrors  = new List <string>();
            newMoveErrorsTotal = 0;
            try
            {
                while (i < count)
                {
                    elcSubAssistant.ThrottleStoreCallAndCheckForShutdown(this.archiveMailboxSession.MailboxOwner, ELCHealthMonitor.GetArchiveResourceHealthMonitorKeys(this.archiveMailboxSession, this.primaryMailboxSession));
                    num2 = ((count - i >= 100) ? 100 : (count - i));
                    List <VersionedId> list;
                    bool flag;
                    int  num9;
                    Dictionary <ItemData.EnforcerType, int> dictionary;
                    num4 += (long)LocalArchiveProcessor.CopyIdsToTmpArray(sourceArray, i, num2, this.MaxMessageSizeInArchive, out list, out flag, out num9, out dictionary);
                    num7 += num9;
                    num3  = list.Count;
                    if (flag)
                    {
                        foldersWithErrors.Add(sourceFolder.DisplayName);
                        LocalArchiveProcessor.Tracer.TraceDebug <LocalArchiveProcessor, string>((long)this.GetHashCode(), "{0}: Added folder {1} to the list of bad folders to be event logged.", this, sourceFolder.DisplayName);
                    }
                    if (num3 > 0)
                    {
                        GroupOperationResult groupOperationResult = sourceFolder.CopyItems(this.archiveMailboxSession, targetFolder.Id, list.ToArray());
                        if (groupOperationResult.OperationResult == OperationResult.Succeeded)
                        {
                            LocalArchiveProcessor.Tracer.TraceDebug <LocalArchiveProcessor, int>((long)this.GetHashCode(), "{0}: Copied to archive batch of {1} items. Will proceed to hard delete the batch.", this, num3);
                            try
                            {
                                this.primaryMailboxSession.COWSettings.TemporaryDisableHold = true;
                                AggregateOperationResult aggregateOperationResult = this.primaryMailboxSession.Delete(DeleteItemFlags.HardDelete | DeleteItemFlags.SuppressReadReceipt, list.ToArray());
                                operationResult = aggregateOperationResult.OperationResult;
                                ex = ElcExceptionHelper.ExtractExceptionsFromAggregateOperationResult(aggregateOperationResult);
                                goto IL_18E;
                            }
                            finally
                            {
                                this.primaryMailboxSession.COWSettings.TemporaryDisableHold = false;
                            }
                        }
                        operationResult = groupOperationResult.OperationResult;
                        ex = groupOperationResult.Exception;
                    }
                    else
                    {
                        LocalArchiveProcessor.Tracer.TraceDebug <LocalArchiveProcessor>((long)this.GetHashCode(), "{0}: The tmpList was empty during this loop. Nothing to send, don't do anything.", this);
                    }
IL_18E:
                    i   += num2;
                    num += num3;
                    if (operationResult == OperationResult.Failed || operationResult == OperationResult.PartiallySucceeded)
                    {
                        LocalArchiveProcessor.Tracer.TraceError((long)this.GetHashCode(), "{0}: An error occured when trying to expire a batch of {1} items. Expiration action is {2}. Result: {3}", new object[]
                        {
                            this,
                            num3,
                            retentionActionType.ToString(),
                            operationResult
                        });
                        Globals.Logger.LogEvent(InfoWorkerEventLogConstants.Tuple_ExpirationOfCurrentBatchFailed, null, new object[]
                        {
                            this.primaryMailboxSession.MailboxOwner,
                            retentionActionType.ToString(),
                            (sourceFolder == null) ? string.Empty : sourceFolder.DisplayName,
                            (targetFolder == null) ? string.Empty : targetFolder.DisplayName,
                            (sourceFolder == null) ? string.Empty : sourceFolder.Id.ObjectId.ToHexEntryId(),
                            (targetFolder == null) ? string.Empty : targetFolder.Id.ObjectId.ToHexEntryId(),
                            (ex == null) ? string.Empty : ex.ToString()
                        });
                        newMoveErrorsTotal++;
                        num8++;
                        if (ex != null)
                        {
                            allExceptionsSoFar.Add(ex);
                        }
                        if (totalFailuresSoFar + newMoveErrorsTotal > MailboxData.MaxErrorsAllowed)
                        {
                            throw new TransientMailboxException(Strings.descELCEnforcerTooManyErrors(this.primaryMailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString(), MailboxData.MaxErrorsAllowed), new AggregateException(allExceptionsSoFar), null);
                        }
                    }
                    else
                    {
                        num5 += (dictionary.ContainsKey(ItemData.EnforcerType.DumpsterExpirationEnforcer) ? dictionary[ItemData.EnforcerType.DumpsterExpirationEnforcer] : 0);
                        num6 += (dictionary.ContainsKey(ItemData.EnforcerType.ExpirationTagEnforcer) ? dictionary[ItemData.EnforcerType.ExpirationTagEnforcer] : 0);
                    }
                }
            }
            finally
            {
                ELCPerfmon.TotalItemsExpired.IncrementBy((long)num);
                ELCPerfmon.TotalSizeItemsExpired.IncrementBy(num4);
                ELCPerfmon.TotalItemsMoved.IncrementBy((long)num);
                ELCPerfmon.TotalSizeItemsMoved.IncrementBy(num4);
                if (this.statisticsLogEntry != null)
                {
                    this.statisticsLogEntry.NumberOfItemsActuallyArchivedByDumpsterExpirationEnforcer += (long)num5;
                    this.statisticsLogEntry.NumberOfItemsActuallyArchivedByTag += (long)num6;
                    this.statisticsLogEntry.NumberOfItemsSkippedDueToSizeRestrictionInArchiveProcessor += (long)num7;
                    this.statisticsLogEntry.NumberOfBatchesFailedToMoveInArchiveProcessor += (long)num8;
                }
            }
        }
Exemplo n.º 11
0
        public static ExchangeMailboxAuditGroupRecord CreateMailboxGroupRecord(MailboxSession mailboxSession, MailboxAuditOperations operation, COWSettings settings, LogonType effectiveLogonType, bool externalAccess, StoreSession destinationSession, StoreObjectId destinationFolderId, StoreObjectId[] itemIds, GroupOperationResult result, IDictionary <StoreObjectId, FolderAuditInfo> folders, IDictionary <StoreObjectId, ItemAuditInfo> items, IDictionary <StoreObjectId, FolderAuditInfo> parentFolders)
        {
            Util.ThrowOnNullArgument(settings, "settings");
            ExchangeMailboxAuditGroupRecord exchangeMailboxAuditGroupRecord = new ExchangeMailboxAuditGroupRecord();

            AuditRecordFactory.Fill(exchangeMailboxAuditGroupRecord, mailboxSession, operation, (result == null) ? OperationResult.Failed : result.OperationResult, effectiveLogonType, externalAccess);
            if (settings.CurrentFolderId != null)
            {
                exchangeMailboxAuditGroupRecord.Folder    = (exchangeMailboxAuditGroupRecord.Folder ?? new ExchangeFolder());
                exchangeMailboxAuditGroupRecord.Folder.Id = string.Format(CultureInfo.InvariantCulture, "{0}", new object[]
                {
                    settings.CurrentFolderId
                });
                FolderAuditInfo folderAuditInfo;
                parentFolders.TryGetValue(settings.CurrentFolderId, out folderAuditInfo);
                exchangeMailboxAuditGroupRecord.Folder.PathName = ((folderAuditInfo != null) ? folderAuditInfo.PathName : AuditRecordFactory.GetCurrentFolderPathName(mailboxSession, settings));
            }
            bool flag = destinationSession != null && mailboxSession != destinationSession;

            exchangeMailboxAuditGroupRecord.CrossMailboxOperation = new bool?(flag);
            MailboxSession mailboxSession2 = mailboxSession;

            if (flag && destinationSession is MailboxSession)
            {
                mailboxSession2 = (destinationSession as MailboxSession);
                exchangeMailboxAuditGroupRecord.DestMailboxGuid     = new Guid?(mailboxSession2.MailboxOwner.MailboxInfo.MailboxGuid);
                exchangeMailboxAuditGroupRecord.DestMailboxOwnerUPN = string.Format(CultureInfo.InvariantCulture, "{0}", new object[]
                {
                    mailboxSession2.MailboxOwner.MailboxInfo.PrimarySmtpAddress
                });
                if (mailboxSession2.MailboxOwner.Sid != null)
                {
                    exchangeMailboxAuditGroupRecord.DestMailboxOwnerSid = string.Format(CultureInfo.InvariantCulture, "{0}", new object[]
                    {
                        mailboxSession2.MailboxOwner.Sid
                    });
                    if (mailboxSession2.MailboxOwner.MasterAccountSid != null)
                    {
                        exchangeMailboxAuditGroupRecord.DestMailboxOwnerMasterAccountSid = string.Format(CultureInfo.InvariantCulture, "{0}", new object[]
                        {
                            mailboxSession2.MailboxOwner.MasterAccountSid
                        });
                    }
                }
            }
            if (destinationFolderId != null)
            {
                exchangeMailboxAuditGroupRecord.DestFolder    = (exchangeMailboxAuditGroupRecord.DestFolder ?? new ExchangeFolder());
                exchangeMailboxAuditGroupRecord.DestFolder.Id = string.Format(CultureInfo.InvariantCulture, "{0}", new object[]
                {
                    destinationFolderId
                });
                string    text = null;
                Exception ex   = null;
                try
                {
                    using (Folder folder = Folder.Bind(mailboxSession2, destinationFolderId, new PropertyDefinition[]
                    {
                        FolderSchema.FolderPathName
                    }))
                    {
                        if (folder != null)
                        {
                            text = (folder.TryGetProperty(FolderSchema.FolderPathName) as string);
                            if (text != null)
                            {
                                text = text.Replace(COWSettings.StoreIdSeparator, '\\');
                            }
                        }
                    }
                }
                catch (StorageTransientException ex2)
                {
                    ex = ex2;
                }
                catch (StoragePermanentException ex3)
                {
                    ex = ex3;
                }
                if (ex != null)
                {
                    ExTraceGlobals.SessionTracer.TraceError <StoreObjectId, Exception>((long)mailboxSession.GetHashCode(), "[GroupOperationAuditEventRecordAdapter::ToString] failed to get FolderPathName property of destination folder {0}. Exception: {1}", destinationFolderId, ex);
                }
                if (text != null)
                {
                    exchangeMailboxAuditGroupRecord.DestFolder.PathName = text;
                }
            }
            foreach (KeyValuePair <StoreObjectId, FolderAuditInfo> keyValuePair in folders)
            {
                StoreObjectId   key   = keyValuePair.Key;
                FolderAuditInfo value = keyValuePair.Value;
                if (settings.CurrentFolderId == null || !key.Equals(settings.CurrentFolderId))
                {
                    exchangeMailboxAuditGroupRecord.Folders = (exchangeMailboxAuditGroupRecord.Folders ?? new List <ExchangeFolder>(folders.Count));
                    ExchangeFolder exchangeFolder = new ExchangeFolder();
                    exchangeMailboxAuditGroupRecord.Folders.Add(exchangeFolder);
                    exchangeFolder.Id = string.Format(CultureInfo.InvariantCulture, "{0}", new object[]
                    {
                        key
                    });
                    if (value.PathName != null)
                    {
                        exchangeFolder.PathName = value.PathName;
                    }
                }
            }
            foreach (KeyValuePair <StoreObjectId, ItemAuditInfo> keyValuePair2 in items)
            {
                StoreObjectId key2   = keyValuePair2.Key;
                ItemAuditInfo value2 = keyValuePair2.Value;
                exchangeMailboxAuditGroupRecord.SourceItems = (exchangeMailboxAuditGroupRecord.SourceItems ?? new List <ExchangeItem>(items.Count));
                ExchangeItem exchangeItem = new ExchangeItem();
                exchangeMailboxAuditGroupRecord.SourceItems.Add(exchangeItem);
                exchangeItem.Id = string.Format(CultureInfo.InvariantCulture, "{0}", new object[]
                {
                    key2
                });
                if (value2.Subject != null)
                {
                    exchangeItem.Subject = value2.Subject;
                }
                FolderAuditInfo folderAuditInfo2;
                if (value2.ParentFolderId != null && parentFolders.TryGetValue(value2.ParentFolderId, out folderAuditInfo2))
                {
                    exchangeItem.ParentFolder          = (exchangeItem.ParentFolder ?? new ExchangeFolder());
                    exchangeItem.ParentFolder.PathName = folderAuditInfo2.PathName;
                }
            }
            return(exchangeMailboxAuditGroupRecord);
        }