private static SmtpResponse GetExceptionSmtpResponse(IMessageConverter converter, Exception exception, string exceptionName, bool isPermanent)
        {
            SmtpResponse smtpResponse = SmtpResponse.Empty;

            if (exceptionName != null)
            {
                if (!(exceptionName == "MapiExceptionRpcServerTooBusy"))
                {
                    if (!(exceptionName == "MapiExceptionSessionLimit"))
                    {
                        if (exceptionName == "MapiExceptionNotEnoughMemory")
                        {
                            smtpResponse = AckReason.MailboxServerNotEnoughMemory;
                        }
                    }
                    else
                    {
                        smtpResponse = AckReason.MailboxMapiSessionLimit;
                    }
                }
                else
                {
                    smtpResponse = AckReason.MailboxServerTooBusy;
                }
            }
            return(StorageExceptionHandler.GetExceptionSmtpResponse(converter, exception, isPermanent, smtpResponse.StatusCode, smtpResponse.EnhancedStatusCode, smtpResponse.StatusText[0], true));
        }
        private static MessageStatus GetMessageStatus(IMessageConverter converter, ADTransientException unavailableException)
        {
            StorageExceptionHandler.LogException(converter, unavailableException);
            SmtpResponse exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, unavailableException, false);

            return(new MessageStatus(MessageAction.Retry, exceptionSmtpResponse, unavailableException));
        }
        private static MessageStatus GetMessageStatus(IMessageConverter converter, ConversionFailedException exception)
        {
            StorageExceptionHandler.LogException(converter, exception);
            SmtpResponse exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, exception, true, "554", (ConversionFailureReason.ExceedsLimit == exception.ConversionFailureReason) ? "5.3.4" : "5.6.0", StorageExceptionHandler.GetReasonDescription(exception.ConversionFailureReason), true);

            return(new MessageStatus(MessageAction.NDR, exceptionSmtpResponse, exception, true));
        }
        private static MessageStatus GetMessageStatus(IMessageConverter converter, DataValidationException invalidDataException)
        {
            StorageExceptionHandler.LogException(converter, invalidDataException);
            SmtpResponse exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, invalidDataException, true, converter.IsOutbound ? AckReason.OutboundInvalidDirectoryData : AckReason.InboundInvalidDirectoryData);

            return(new MessageStatus(MessageAction.NDR, exceptionSmtpResponse, invalidDataException));
        }
Esempio n. 5
0
        public MessageStatus CreateStatus(Exception exception, Exception exceptionAssociatedWithHandler, IMessageConverter converter, TimeSpan fastRetryInterval, TimeSpan quarantineRetryInterval)
        {
            SmtpResponse  exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, exception, this.Category == Category.Permanent, this.GetEffectiveStatusCode(), this.GetEffectiveEnhancedStatusCode(exceptionAssociatedWithHandler), this.GetEffectivePrimaryStatusText(exceptionAssociatedWithHandler), this.IncludeDiagnosticStatusText);
            MessageStatus messageStatus         = new MessageStatus(this.Action, exceptionSmtpResponse, exception, this.AppliesToAllRecipients);

            if (this.SpecifiedRetryInterval != null)
            {
                messageStatus.RetryInterval = new TimeSpan?(this.SpecifiedRetryInterval.Value);
            }
            else if (this.RetryInterval != RetryInterval.None)
            {
                if (this.RetryInterval == RetryInterval.QuarantinedRetry)
                {
                    messageStatus.RetryInterval = new TimeSpan?(quarantineRetryInterval);
                }
                else
                {
                    messageStatus.RetryInterval = new TimeSpan?(fastRetryInterval);
                }
            }
            if (this.CustomizeStatusCallback != null)
            {
                this.CustomizeStatusCallback(exceptionAssociatedWithHandler, converter, messageStatus);
            }
            return(messageStatus);
        }
 private static MessageStatus GetMessageStatus(IMessageConverter converter, DataSourceOperationException dataSourceOperationException)
 {
     if (dataSourceOperationException is ADInvalidCredentialException)
     {
         ADTransientException unavailableException = new ADTransientException(dataSourceOperationException.LocalizedString, dataSourceOperationException);
         return(StorageExceptionHandler.GetMessageStatus(converter, unavailableException));
     }
     StorageExceptionHandler.LogException(converter, dataSourceOperationException);
     return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, dataSourceOperationException, true), dataSourceOperationException));
 }
        private static MessageStatus GetMessageStatus(IMessageConverter converter, IOException e)
        {
            StorageExceptionHandler.LogException(converter, e);
            SmtpResponse exceptionSmtpResponse = StorageExceptionHandler.GetExceptionSmtpResponse(converter, e, true, AckReason.DiskFull);

            if (ExceptionHelper.IsDiskFullException(e))
            {
                return(new MessageStatus(converter.IsOutbound ? MessageAction.RetryMailboxServer : MessageAction.RetryQueue, exceptionSmtpResponse, e));
            }
            return(new MessageStatus(MessageAction.Throw, exceptionSmtpResponse, e));
        }
 private static MessageStatus GetMessageStatus(IMessageConverter converter, StorageTransientException storageException)
 {
     StorageExceptionHandler.LogException(converter, storageException);
     if (storageException is MailboxInSiteFailoverException)
     {
         return(new MessageStatus(converter.IsOutbound ? MessageAction.Skip : MessageAction.Reroute, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));
     }
     if (storageException.InnerException != null)
     {
         MapiPermanentException ex = storageException.InnerException as MapiPermanentException;
         if (ex != null)
         {
             return(StorageExceptionHandler.GetMessageStatus <StorageTransientException>(converter, ex, storageException));
         }
         MapiRetryableException ex2 = storageException.InnerException as MapiRetryableException;
         if (ex2 != null)
         {
             return(StorageExceptionHandler.GetMessageStatus <StorageTransientException>(converter, ex2, storageException));
         }
     }
     return(new MessageStatus(MessageAction.Retry, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));
 }
        private static MessageStatus GetMessageStatus(IMessageConverter converter, StoragePermanentException storageException)
        {
            StorageExceptionHandler.LogException(converter, storageException);
            ConversionFailedException ex = storageException as ConversionFailedException;

            if (ex != null)
            {
                return(StorageExceptionHandler.GetMessageStatus(converter, ex));
            }
            if (storageException is MailboxCrossSiteFailoverException || storageException is MailboxInfoStaleException)
            {
                return(new MessageStatus(converter.IsOutbound ? MessageAction.Skip : MessageAction.Reroute, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException));
            }
            if (storageException is UnableToFindServerForDatabaseException || storageException is IllegalCrossServerConnectionException)
            {
                return(new MessageStatus(converter.IsOutbound ? MessageAction.Skip : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));
            }
            if (storageException.InnerException is CannotGetSiteInfoException)
            {
                return(new MessageStatus(converter.IsOutbound ? MessageAction.RetryMailboxServer : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException.InnerException, true), storageException));
            }
            if (storageException.InnerException != null)
            {
                MapiPermanentException ex2 = storageException.InnerException as MapiPermanentException;
                if (ex2 != null)
                {
                    return(StorageExceptionHandler.GetMessageStatus <StoragePermanentException>(converter, ex2, storageException));
                }
                MapiRetryableException ex3 = storageException.InnerException as MapiRetryableException;
                if (ex3 != null)
                {
                    return(StorageExceptionHandler.GetMessageStatus <StoragePermanentException>(converter, ex3, storageException));
                }
            }
            return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException));
        }
        private static MessageStatus GetMessageStatus <T>(IMessageConverter converter, MapiRetryableException mapiException, T storageException) where T : Exception
        {
            string        name = mapiException.GetType().Name;
            string        key;
            MessageStatus messageStatus;

            switch (key = name)
            {
            case "MapiExceptionMailboxInTransit":
            case "MapiExceptionServerPaused":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.Skip : MessageAction.Reroute, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));

            case "MapiExceptionDismountInProgress":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.RetryQueue : MessageAction.Reroute, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));

            case "MapiExceptionLogonFailed":
                return(new MessageStatus(MessageAction.Retry, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.LogonFailure), storageException));

            case "MapiExceptionJetErrorLogWriteFail":
            case "MapiExceptionJetErrorDiskIO":
            case "MapiExceptionJetErrorCheckpointDepthTooDeep":
                return(new MessageStatus(MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.MailboxIOError), storageException));

            case "MapiExceptionJetErrorInstanceUnavailable":
                return(new MessageStatus(MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.MailboxIOError), storageException));

            case "MapiExceptionNetworkError":
                messageStatus = new MessageStatus(MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.MailboxServerOffline), storageException);
                messageStatus.RetryInterval = new TimeSpan?(StorageExceptionHandler.MailboxDeliveryFastQueueRetryInterval);
                return(messageStatus);

            case "MapiExceptionRpcServerTooBusy":
            case "MapiExceptionSessionLimit":
            case "MapiExceptionNotEnoughMemory":
                messageStatus = new MessageStatus(converter.IsOutbound ? MessageAction.RetryMailboxServer : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, name, false), storageException);
                messageStatus.RetryInterval = new TimeSpan?(StorageExceptionHandler.MailboxDeliveryFastQueueRetryInterval);
                return(messageStatus);

            case "MapiExceptionMaxThreadsPerMdbExceeded":
                messageStatus = new MessageStatus(MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.MailboxServerMaxThreadsPerMdbExceeded), storageException);
                messageStatus.RetryInterval = new TimeSpan?(StorageExceptionHandler.MailboxDeliveryFastQueueRetryInterval);
                return(messageStatus);

            case "MapiExceptionMaxThreadsPerSCTExceeded":
                messageStatus = new MessageStatus(converter.IsOutbound ? MessageAction.Retry : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.MapiExceptionMaxThreadsPerSCTExceeded), storageException);
                messageStatus.RetryInterval = new TimeSpan?(StorageExceptionHandler.MailboxDeliveryFastQueueRetryInterval);
                return(messageStatus);

            case "MapiExceptionRpcOutOfMemory":
            case "MapiExceptionRpcOutOfResources":
            case "MapiExceptionRpcServerOutOfMemory":
            case "MapiExceptionVersionStoreBusy":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.Retry : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));

            case "MapiExceptionSubsystemStopping":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.RetryMailboxServer : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));

            case "MapiExceptionLowDatabaseDiskSpace":
            case "MapiExceptionLowDatabaseLogDiskSpace":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.Retry : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.MailboxDiskFull), storageException));

            case "MapiExceptionADNotFound":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.RetryMailboxServer : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.MailboxDiskFull), storageException));

            case "MapiExceptionMailboxQuarantined":
                if (converter.IsOutbound)
                {
                    return(new MessageStatus(MessageAction.Skip, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException));
                }
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, AckReason.RecipientMailboxQuarantined), storageException));

            case "MapiExceptionRetryableImportFailure":
            case "MapiExceptionBusy":
            case "MapiExceptionDiskError":
            case "MapiExceptionJetErrorOutOfBuffers":
            case "MapiExceptionJetErrorOutOfCursors":
            case "MapiExceptionJetErrorOutOfMemory":
            case "MapiExceptionJetErrorOutOfSessions":
            case "MapiExceptionJetErrorTooManyOpenTables":
            case "MapiExceptionJetErrorTooManyOpenTablesAndCleanupTimedOut":
            case "MapiExceptionJetErrorVersionStoreOutOfMemory":
            case "MapiExceptionJetErrorVersionStoreOutOfMemoryAndCleanupTimedOut":
            case "MapiExceptionNoFreeJses":
            case "MapiExceptionNotEnoughDisk":
            case "MapiExceptionTimeout":
            case "MapiExceptionWait":
            case "MapiExceptionCollision":
                return(new MessageStatus(MessageAction.Retry, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));
            }
            messageStatus = new MessageStatus(MessageAction.Retry, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException);
            return(messageStatus);
        }
        private static MessageStatus GetMessageStatus <T>(IMessageConverter converter, MapiPermanentException mapiException, T storageException) where T : Exception
        {
            string        name = mapiException.GetType().Name;
            string        key;
            MessageStatus messageStatus;

            switch (key = name)
            {
            case "MapiExceptionJetErrorLogDiskFull":
                return(new MessageStatus(MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, AckReason.MailboxDiskFull), storageException));

            case "MapiExceptionADDuplicateEntry":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.RetryMailboxServer : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, "Duplicated AD entries found"), storageException));

            case "MapiExceptionNoMoreConnections":
                messageStatus = new MessageStatus(converter.IsOutbound ? MessageAction.RetryMailboxServer : MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, SmtpResponse.TooManyConnectionsPerSource), storageException);
                messageStatus.RetryInterval = new TimeSpan?(StorageExceptionHandler.MailboxDeliveryFastQueueRetryInterval);
                return(messageStatus);

            case "MapiExceptionUnknownUser":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.Retry : MessageAction.Reroute, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException));

            case "MapiExceptionNoReplicaHere":
            case "MapiExceptionWrongServer":
            case "MapiExceptionWrongMailbox":
                return(new MessageStatus(converter.IsOutbound ? MessageAction.Skip : MessageAction.Reroute, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException));

            case "MapiExceptionClientVersionDisallowed":
                return(new MessageStatus(MessageAction.Reroute, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException));

            case "MapiExceptionDuplicateDelivery":
                return(new MessageStatus(MessageAction.LogDuplicate, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException));

            case "MapiExceptionMaxTimeExpired":
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, null, "4.4.1", "connection timed out", true), storageException));

            case "MapiExceptionUnableToComplete":
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, null, "4.4.1", "connection timed out", true), storageException));

            case "MapiExceptionMessageTooBig":
            case "MapiExceptionTooComplex":
            case "MapiExceptionTooBig":
            case "MapiExceptionMaxAttachmentExceeded":
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, null, "5.3.4", "message exceeds fixed system limits", true), storageException));

            case "MapiExceptionTooManyRecips":
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, null, "5.3.3", "too many recipients", true), storageException));

            case "MapiExceptionQuotaExceeded":
            case "MapiExceptionShutoffQuotaExceeded":
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, null, "5.2.2", "mailbox full", true), storageException));

            case "MapiExceptionNoReplicaAvailable":
            case "MapiExceptionFolderDisabled":
            case "MapiExceptionMailboxDisabled":
            case "MapiExceptionAccountDisabled":
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, null, "5.2.1", "mailbox disabled", true), storageException));

            case "MapiExceptionMdbOffline":
                return(new MessageStatus(MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, AckReason.MDBOffline), storageException));

            case "MapiExceptionMaxObjsExceeded":
            case "MapiExceptionRpcBufferTooSmall":
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, null, "4.3.2", "mailbox busy", true), storageException));

            case "MapiExceptionNoAccess":
                return(new MessageStatus(MessageAction.Retry, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false, AckReason.MapiNoAccessFailure), storageException));

            case "MapiExceptionJetErrorPageNotInitialized":
                return(new MessageStatus(MessageAction.RetryQueue, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true, "Database page not initialized"), storageException));

            case "MapiExceptionOutOfMemory":
            case "MapiExceptionTooManyMountedDatabases":
                return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException));

            case "MapiExceptionUnconfigured":
                return(new MessageStatus(MessageAction.Retry, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, false), storageException));
            }
            messageStatus = new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, storageException, true), storageException);
            return(messageStatus);
        }
 private static MessageStatus GetMessageStatus(IMessageConverter converter, ExchangeDataException dataException)
 {
     StorageExceptionHandler.LogException(converter, dataException);
     return(new MessageStatus(MessageAction.NDR, StorageExceptionHandler.GetExceptionSmtpResponse(converter, dataException, true), dataException));
 }
 internal static SmtpResponse GetExceptionSmtpResponse(IMessageConverter converter, Exception exception, bool isPermanent, string primaryStatusText)
 {
     return(StorageExceptionHandler.GetExceptionSmtpResponse(converter, exception, isPermanent, null, null, primaryStatusText, true));
 }
 internal static SmtpResponse GetExceptionSmtpResponse(IMessageConverter converter, Exception exception, bool isPermanent, SmtpResponse smtpResponse)
 {
     return(StorageExceptionHandler.GetExceptionSmtpResponse(converter, exception, isPermanent, smtpResponse.StatusCode, smtpResponse.EnhancedStatusCode, smtpResponse.StatusText[0], true));
 }