This is an automated email from the ASF dual-hosted git repository.
btellier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit f5de467dfa278121c713dd95bf654123993517f3
Author: Benoit Tellier <btell...@linagora.com>
AuthorDate: Mon Nov 11 12:21:21 2019 +0700
[Refactoring] AbstractMailboxProcessor response methods should accept IMAP
request
This limits the count of arguments
---
.../imap/processor/AbstractAuthProcessor.java | 26 ++++++++++------------
.../imap/processor/AbstractMailboxProcessor.java | 24 ++++++++++----------
.../processor/AbstractMessageRangeProcessor.java | 8 +++----
.../imap/processor/AbstractSelectionProcessor.java | 19 ++++++++--------
.../james/imap/processor/AppendProcessor.java | 24 +++++++++-----------
.../imap/processor/AuthenticateProcessor.java | 15 +++++++------
.../james/imap/processor/CapabilityProcessor.java | 2 +-
.../james/imap/processor/CheckProcessor.java | 2 +-
.../james/imap/processor/CloseProcessor.java | 4 ++--
.../james/imap/processor/CreateProcessor.java | 8 +++----
.../james/imap/processor/DeleteACLProcessor.java | 12 +++++-----
.../james/imap/processor/DeleteProcessor.java | 8 +++----
.../james/imap/processor/EnableProcessor.java | 4 ++--
.../james/imap/processor/ExpungeProcessor.java | 10 ++++-----
.../james/imap/processor/GetACLProcessor.java | 14 ++++++------
.../imap/processor/GetAnnotationProcessor.java | 17 +++++++-------
.../james/imap/processor/GetQuotaProcessor.java | 6 ++---
.../imap/processor/GetQuotaRootProcessor.java | 6 ++---
.../apache/james/imap/processor/IdleProcessor.java | 2 +-
.../apache/james/imap/processor/LSubProcessor.java | 4 ++--
.../apache/james/imap/processor/ListProcessor.java | 4 ++--
.../james/imap/processor/ListRightsProcessor.java | 10 ++++-----
.../james/imap/processor/LoginProcessor.java | 4 ++--
.../james/imap/processor/LogoutProcessor.java | 4 ++--
.../james/imap/processor/MyRightsProcessor.java | 8 +++----
.../james/imap/processor/NamespaceProcessor.java | 2 +-
.../apache/james/imap/processor/NoopProcessor.java | 2 +-
.../james/imap/processor/RenameProcessor.java | 10 ++++-----
.../james/imap/processor/SearchProcessor.java | 6 ++---
.../james/imap/processor/SetACLProcessor.java | 12 +++++-----
.../imap/processor/SetAnnotationProcessor.java | 8 +++----
.../james/imap/processor/SetQuotaProcessor.java | 2 +-
.../james/imap/processor/StatusProcessor.java | 5 +++--
.../james/imap/processor/StoreProcessor.java | 8 +++----
.../james/imap/processor/SubscribeProcessor.java | 4 ++--
.../james/imap/processor/UnselectProcessor.java | 4 ++--
.../james/imap/processor/UnsubscribeProcessor.java | 4 ++--
.../james/imap/processor/fetch/FetchProcessor.java | 10 ++++-----
38 files changed, 160 insertions(+), 162 deletions(-)
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractAuthProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractAuthProcessor.java
index 58a430b..94ccf20 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractAuthProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractAuthProcessor.java
@@ -20,9 +20,7 @@ package org.apache.james.imap.processor;
import java.util.Optional;
-import org.apache.james.imap.api.ImapCommand;
import org.apache.james.imap.api.ImapSessionUtils;
-import org.apache.james.imap.api.Tag;
import org.apache.james.imap.api.display.HumanReadableText;
import org.apache.james.imap.api.message.request.ImapRequest;
import org.apache.james.imap.api.message.response.StatusResponseFactory;
@@ -59,7 +57,7 @@ public abstract class AbstractAuthProcessor<M extends
ImapRequest> extends Abstr
super(acceptableClass, next, mailboxManager, factory, metricFactory);
}
- protected void doAuth(AuthenticationAttempt authenticationAttempt,
ImapSession session, Tag tag, ImapCommand command, Responder responder,
HumanReadableText failed) {
+ protected void doAuth(AuthenticationAttempt authenticationAttempt,
ImapSession session, ImapRequest request, Responder responder,
HumanReadableText failed) {
Preconditions.checkArgument(!authenticationAttempt.isDelegation());
try {
boolean authFailure = false;
@@ -74,21 +72,21 @@ public abstract class AbstractAuthProcessor<M extends
ImapRequest> extends Abstr
session.authenticated();
session.setAttribute(ImapSessionUtils.MAILBOX_SESSION_ATTRIBUTE_SESSION_KEY,
mailboxSession);
provisionInbox(session, mailboxManager, mailboxSession);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (BadCredentialsException e) {
authFailure = true;
}
}
if (authFailure) {
- manageFailureCount(session, tag, command, responder, failed);
+ manageFailureCount(session, request, responder, failed);
}
} catch (MailboxException e) {
LOGGER.error("Error encountered while login", e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
- protected void doAuthWithDelegation(AuthenticationAttempt
authenticationAttempt, ImapSession session, Tag tag, ImapCommand command,
Responder responder, HumanReadableText failed) {
+ protected void doAuthWithDelegation(AuthenticationAttempt
authenticationAttempt, ImapSession session, ImapRequest request, Responder
responder, HumanReadableText failed) {
Preconditions.checkArgument(authenticationAttempt.isDelegation());
try {
boolean authFailure = false;
@@ -104,23 +102,23 @@ public abstract class AbstractAuthProcessor<M extends
ImapRequest> extends Abstr
session.authenticated();
session.setAttribute(ImapSessionUtils.MAILBOX_SESSION_ATTRIBUTE_SESSION_KEY,
mailboxSession);
provisionInbox(session, mailboxManager, mailboxSession);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (BadCredentialsException e) {
authFailure = true;
}
}
if (authFailure) {
- manageFailureCount(session, tag, command, responder, failed);
+ manageFailureCount(session, request, responder, failed);
}
} catch (UserDoesNotExistException e) {
LOGGER.info("User {} does not exist",
authenticationAttempt.getAuthenticationId(), e);
- no(command, tag, responder, HumanReadableText.USER_DOES_NOT_EXIST);
+ no(request, responder, HumanReadableText.USER_DOES_NOT_EXIST);
} catch (NotAdminException e) {
LOGGER.info("User {} is not an admin",
authenticationAttempt.getDelegateUserName(), e);
- no(command, tag, responder, HumanReadableText.NOT_AN_ADMIN);
+ no(request, responder, HumanReadableText.NOT_AN_ADMIN);
} catch (MailboxException e) {
LOGGER.info("Login failed", e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
@@ -139,7 +137,7 @@ public abstract class AbstractAuthProcessor<M extends
ImapRequest> extends Abstr
}
}
- protected void manageFailureCount(ImapSession session, Tag tag,
ImapCommand command, Responder responder, HumanReadableText failed) {
+ protected void manageFailureCount(ImapSession session, ImapRequest
request, Responder responder, HumanReadableText failed) {
final Integer currentNumberOfFailures = (Integer)
session.getAttribute(ATTRIBUTE_NUMBER_OF_FAILURES);
final int failures;
if (currentNumberOfFailures == null) {
@@ -149,7 +147,7 @@ public abstract class AbstractAuthProcessor<M extends
ImapRequest> extends Abstr
}
if (failures < MAX_FAILURES) {
session.setAttribute(ATTRIBUTE_NUMBER_OF_FAILURES, failures);
- no(command, tag, responder, failed);
+ no(request, responder, failed);
} else {
LOGGER.info("Too many authentication failures. Closing
connection.");
bye(responder, HumanReadableText.TOO_MANY_FAILURES);
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMailboxProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMailboxProcessor.java
index 9134494..ffd20e6 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMailboxProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMailboxProcessor.java
@@ -115,10 +115,10 @@ public abstract class AbstractMailboxProcessor<M extends
ImapRequest> extends Ab
}
} catch (DeniedAccessOnSharedMailboxException e) {
- no(command, tag, responder,
HumanReadableText.DENIED_SHARED_MAILBOX);
+ no(message, responder, HumanReadableText.DENIED_SHARED_MAILBOX);
} catch (Exception unexpectedException) {
LOGGER.error("Unexpected error during IMAP processing",
unexpectedException);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
@@ -334,28 +334,28 @@ public abstract class AbstractMailboxProcessor<M extends
ImapRequest> extends Ab
responder.respond(response);
}
- protected void okComplete(ImapCommand command, Tag tag,
ImapProcessor.Responder responder) {
- final StatusResponse response = factory.taggedOk(tag, command,
HumanReadableText.COMPLETED);
+ protected void okComplete(ImapRequest request, ImapProcessor.Responder
responder) {
+ final StatusResponse response = factory.taggedOk(request.getTag(),
request.getCommand(), HumanReadableText.COMPLETED);
responder.respond(response);
}
- protected void okComplete(ImapCommand command, Tag tag, ResponseCode code,
ImapProcessor.Responder responder) {
- final StatusResponse response = factory.taggedOk(tag, command,
HumanReadableText.COMPLETED, code);
+ protected void okComplete(ImapRequest request, ResponseCode code,
ImapProcessor.Responder responder) {
+ final StatusResponse response = factory.taggedOk(request.getTag(),
request.getCommand(), HumanReadableText.COMPLETED, code);
responder.respond(response);
}
- protected void no(ImapCommand command, Tag tag, ImapProcessor.Responder
responder, HumanReadableText displayTextKey) {
- final StatusResponse response = factory.taggedNo(tag, command,
displayTextKey);
+ protected void no(ImapRequest request, ImapProcessor.Responder responder,
HumanReadableText displayTextKey) {
+ StatusResponse response = factory.taggedNo(request.getTag(),
request.getCommand(), displayTextKey);
responder.respond(response);
}
- protected void no(ImapCommand command, Tag tag, ImapProcessor.Responder
responder, HumanReadableText displayTextKey, StatusResponse.ResponseCode
responseCode) {
- final StatusResponse response = factory.taggedNo(tag, command,
displayTextKey, responseCode);
+ protected void no(ImapRequest request, ImapProcessor.Responder responder,
HumanReadableText displayTextKey, StatusResponse.ResponseCode responseCode) {
+ StatusResponse response = factory.taggedNo(request.getTag(),
request.getCommand(), displayTextKey, responseCode);
responder.respond(response);
}
- protected void taggedBad(ImapCommand command, Tag tag,
ImapProcessor.Responder responder, HumanReadableText e) {
- StatusResponse response = factory.taggedBad(tag, command, e);
+ protected void taggedBad(ImapRequest request, ImapProcessor.Responder
responder, HumanReadableText e) {
+ StatusResponse response = factory.taggedBad(request.getTag(),
request.getCommand(), e);
responder.respond(response);
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMessageRangeProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMessageRangeProcessor.java
index 919999e..c95afcf 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMessageRangeProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractMessageRangeProcessor.java
@@ -73,7 +73,7 @@ public abstract class AbstractMessageRangeProcessor<M extends
AbstractMessageRan
final boolean mailboxExists =
mailboxManager.mailboxExists(targetMailbox, mailboxSession);
if (!mailboxExists) {
- no(command, tag, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX,
StatusResponse.ResponseCode.tryCreate());
+ no(request, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX,
StatusResponse.ResponseCode.tryCreate());
} else {
final MessageManager mailbox =
mailboxManager.getMailbox(targetMailbox, mailboxSession);
@@ -104,16 +104,16 @@ public abstract class AbstractMessageRangeProcessor<M
extends AbstractMessageRan
Long uidValidity = mailbox.getMetaData(false, mailboxSession,
MessageManager.MetaData.FetchGroup.NO_UNSEEN).getUidValidity();
unsolicitedResponses(session, responder, useUids);
- okComplete(command, tag,
StatusResponse.ResponseCode.copyUid(uidValidity, idSet, resultUids), responder);
+ okComplete(request,
StatusResponse.ResponseCode.copyUid(uidValidity, idSet, resultUids), responder);
}
} catch (MessageRangeException e) {
LOGGER.debug("{} failed from mailbox {} to {} for invalid
sequence-set {}",
getOperationName(), currentMailbox.getMailboxId(),
targetMailbox, idSet, e);
- taggedBad(command, tag, responder,
HumanReadableText.INVALID_MESSAGESET);
+ taggedBad(request, responder,
HumanReadableText.INVALID_MESSAGESET);
} catch (MailboxException e) {
LOGGER.error("{} failed from mailbox {} to {} for sequence-set {}",
getOperationName(), currentMailbox.getMailboxId(),
targetMailbox, idSet, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractSelectionProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractSelectionProcessor.java
index af7d916..7f23302 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractSelectionProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AbstractSelectionProcessor.java
@@ -30,6 +30,7 @@ import org.apache.james.imap.api.Tag;
import org.apache.james.imap.api.display.HumanReadableText;
import org.apache.james.imap.api.message.IdRange;
import org.apache.james.imap.api.message.UidRange;
+import org.apache.james.imap.api.message.request.ImapRequest;
import org.apache.james.imap.api.message.response.StatusResponse;
import org.apache.james.imap.api.message.response.StatusResponse.ResponseCode;
import org.apache.james.imap.api.message.response.StatusResponseFactory;
@@ -83,7 +84,7 @@ abstract class AbstractSelectionProcessor<M extends
AbstractMailboxSelectionRequ
try {
final MailboxPath fullMailboxPath =
PathConverter.forSession(session).buildFullPath(mailboxName);
- respond(tag, command, session, fullMailboxPath, request,
responder);
+ respond(session, fullMailboxPath, request, responder);
} catch (MailboxNotFoundException e) {
@@ -91,11 +92,11 @@ abstract class AbstractSelectionProcessor<M extends
AbstractMailboxSelectionRequ
responder.respond(statusResponseFactory.taggedNo(tag, command,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX));
} catch (MailboxException e) {
LOGGER.error("Select failed for mailbox {}", mailboxName, e);
- no(command, tag, responder, HumanReadableText.SELECT);
+ no(request, responder, HumanReadableText.SELECT);
}
}
- private void respond(Tag tag, ImapCommand command, ImapSession session,
MailboxPath fullMailboxPath, AbstractMailboxSelectionRequest request, Responder
responder) throws MailboxException, MessageRangeException {
+ private void respond(ImapSession session, MailboxPath fullMailboxPath,
AbstractMailboxSelectionRequest request, Responder responder) throws
MailboxException, MessageRangeException {
Long lastKnownUidValidity = request.getLastKnownUidValidity();
Long modSeq = request.getKnownModSeq();
@@ -112,7 +113,7 @@ abstract class AbstractSelectionProcessor<M extends
AbstractMailboxSelectionRequ
// and the client hasn't issued "ENABLE QRESYNC" in the current
// connection.
if (lastKnownUidValidity != null &&
!EnableProcessor.getEnabledCapabilities(session).contains(ImapConstants.SUPPORTS_QRESYNC))
{
- taggedBad(command, tag, responder,
HumanReadableText.QRESYNC_NOT_ENABLED);
+ taggedBad(request, responder,
HumanReadableText.QRESYNC_NOT_ENABLED);
return;
}
@@ -299,13 +300,13 @@ abstract class AbstractSelectionProcessor<M extends
AbstractMailboxSelectionRequ
//
respondVanished(mailboxSession, mailbox, ranges, modSeq,
metaData, responder);
}
- taggedOk(responder, tag, command, metaData,
HumanReadableText.SELECT);
+ taggedOk(responder, request, metaData,
HumanReadableText.SELECT);
} else {
- taggedOk(responder, tag, command, metaData,
HumanReadableText.QRESYNC_UIDVALIDITY_MISMATCH);
+ taggedOk(responder, request, metaData,
HumanReadableText.QRESYNC_UIDVALIDITY_MISMATCH);
}
} else {
- taggedOk(responder, tag, command, metaData,
HumanReadableText.SELECT);
+ taggedOk(responder, request, metaData, HumanReadableText.SELECT);
}
// Reset the saved sequence-set after successful SELECT / EXAMINE
@@ -332,7 +333,7 @@ abstract class AbstractSelectionProcessor<M extends
AbstractMailboxSelectionRequ
responder.respond(untaggedOk);
}
- private void taggedOk(Responder responder, Tag tag, ImapCommand command,
MetaData metaData, HumanReadableText text) {
+ private void taggedOk(Responder responder, ImapRequest request, MetaData
metaData, HumanReadableText text) {
final boolean writeable = metaData.isWriteable() && !openReadOnly;
final ResponseCode code;
if (writeable) {
@@ -340,7 +341,7 @@ abstract class AbstractSelectionProcessor<M extends
AbstractMailboxSelectionRequ
} else {
code = ResponseCode.readOnly();
}
- final StatusResponse taggedOk = statusResponseFactory.taggedOk(tag,
command, text, code);
+ final StatusResponse taggedOk =
statusResponseFactory.taggedOk(request.getTag(), request.getCommand(), text,
code);
responder.respond(taggedOk);
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AppendProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AppendProcessor.java
index ccd6047..316ca10 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AppendProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AppendProcessor.java
@@ -75,7 +75,7 @@ public class AppendProcessor extends
AbstractMailboxProcessor<AppendRequest> {
final MailboxManager mailboxManager = getMailboxManager();
final MessageManager mailbox =
mailboxManager.getMailbox(mailboxPath,
ImapSessionUtils.getMailboxSession(session));
- appendToMailbox(messageIn, datetime, flags, session, tag, command,
mailbox, responder, mailboxPath);
+ appendToMailbox(messageIn, datetime, flags, session, request,
mailbox, responder, mailboxPath);
} catch (MailboxNotFoundException e) {
// consume message on exception
consume(messageIn);
@@ -84,7 +84,7 @@ public class AppendProcessor extends
AbstractMailboxProcessor<AppendRequest> {
// Indicates that the mailbox does not exist
// So TRY CREATE
- tryCreate(session, tag, command, responder, e);
+ tryCreate(request, responder, e);
} catch (MailboxException e) {
// consume message on exception
@@ -93,7 +93,7 @@ public class AppendProcessor extends
AbstractMailboxProcessor<AppendRequest> {
LOGGER.error("Append failed for mailbox {}", mailboxPath, e);
// Some other issue
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
@@ -112,24 +112,20 @@ public class AppendProcessor extends
AbstractMailboxProcessor<AppendRequest> {
/**
* Issues a TRY CREATE response.
*
- * @param session
- * not null
- * @param tag
- * not null
- * @param command
+ * @param request
* not null
* @param responder
* not null
* @param e
* not null
*/
- private void tryCreate(ImapSession session, Tag tag, ImapCommand command,
Responder responder, MailboxNotFoundException e) {
+ private void tryCreate(AppendRequest request, Responder responder,
MailboxNotFoundException e) {
LOGGER.debug("Cannot open mailbox: ", e);
- no(command, tag, responder, HumanReadableText.FAILURE_NO_SUCH_MAILBOX,
StatusResponse.ResponseCode.tryCreate());
+ no(request, responder, HumanReadableText.FAILURE_NO_SUCH_MAILBOX,
StatusResponse.ResponseCode.tryCreate());
}
- private void appendToMailbox(InputStream message, Date datetime, Flags
flagsToBeSet, ImapSession session, Tag tag, ImapCommand command, MessageManager
mailbox, Responder responder, MailboxPath mailboxPath) {
+ private void appendToMailbox(InputStream message, Date datetime, Flags
flagsToBeSet, ImapSession session, AppendRequest request, MessageManager
mailbox, Responder responder, MailboxPath mailboxPath) {
try {
final MailboxSession mailboxSession =
ImapSessionUtils.getMailboxSession(session);
final SelectedMailbox selectedMailbox = session.getSelected();
@@ -146,15 +142,15 @@ public class AppendProcessor extends
AbstractMailboxProcessor<AppendRequest> {
unsolicitedResponses(session, responder, false);
// in case of MULTIAPPEND support we will push more then one UID
here
- okComplete(command, tag, ResponseCode.appendUid(uidValidity, new
UidRange[] { new UidRange(messageId.getUid()) }), responder);
+ okComplete(request, ResponseCode.appendUid(uidValidity, new
UidRange[] { new UidRange(messageId.getUid()) }), responder);
} catch (MailboxNotFoundException e) {
// Indicates that the mailbox does not exist
// So TRY CREATE
- tryCreate(session, tag, command, responder, e);
+ tryCreate(request, responder, e);
} catch (MailboxException e) {
LOGGER.error("Unable to append message to mailbox {}",
mailboxPath, e);
// Some other issue
- no(command, tag, responder, HumanReadableText.SAVE_FAILED);
+ no(request, responder, HumanReadableText.SAVE_FAILED);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AuthenticateProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AuthenticateProcessor.java
index 2752674..b56fc44 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/AuthenticateProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/AuthenticateProcessor.java
@@ -29,6 +29,7 @@ import java.util.StringTokenizer;
import org.apache.james.imap.api.ImapCommand;
import org.apache.james.imap.api.Tag;
import org.apache.james.imap.api.display.HumanReadableText;
+import org.apache.james.imap.api.message.request.ImapRequest;
import org.apache.james.imap.api.message.response.StatusResponseFactory;
import org.apache.james.imap.api.process.ImapProcessor;
import org.apache.james.imap.api.process.ImapSession;
@@ -61,18 +62,18 @@ public class AuthenticateProcessor extends
AbstractAuthProcessor<AuthenticateReq
if (authType.equalsIgnoreCase(PLAIN)) {
// See if AUTH=PLAIN is allowed. See IMAP-304
if (session.isPlainAuthDisallowed() && session.isTLSActive() ==
false) {
- no(command, tag, responder, HumanReadableText.DISABLED_LOGIN);
+ no(request, responder, HumanReadableText.DISABLED_LOGIN);
} else {
if (request instanceof IRAuthenticateRequest) {
IRAuthenticateRequest irRequest = (IRAuthenticateRequest)
request;
- doPlainAuth(irRequest.getInitialClientResponse(), session,
tag, command, responder);
+ doPlainAuth(irRequest.getInitialClientResponse(), session,
request, responder);
} else {
responder.respond(new AuthenticateResponse());
session.pushLineHandler((requestSession, data) -> {
// cut of the CRLF
String initialClientResponse = new String(data, 0,
data.length - 2, Charset.forName("US-ASCII"));
- doPlainAuth(initialClientResponse, requestSession,
tag, command, responder);
+ doPlainAuth(initialClientResponse, requestSession,
request, responder);
// remove the handler now
requestSession.popLineHandler();
@@ -81,19 +82,19 @@ public class AuthenticateProcessor extends
AbstractAuthProcessor<AuthenticateReq
}
} else {
LOGGER.debug("Unsupported authentication mechanism '{}'",
authType);
- no(command, tag, responder,
HumanReadableText.UNSUPPORTED_AUTHENTICATION_MECHANISM);
+ no(request, responder,
HumanReadableText.UNSUPPORTED_AUTHENTICATION_MECHANISM);
}
}
/**
* Parse the initialClientResponse and do a PLAIN AUTH with it
*/
- protected void doPlainAuth(String initialClientResponse, ImapSession
session, Tag tag, ImapCommand command, Responder responder) {
+ protected void doPlainAuth(String initialClientResponse, ImapSession
session, ImapRequest request, Responder responder) {
AuthenticationAttempt authenticationAttempt =
parseDelegationAttempt(initialClientResponse);
if (authenticationAttempt.isDelegation()) {
- doAuthWithDelegation(authenticationAttempt, session, tag, command,
responder, HumanReadableText.AUTHENTICATION_FAILED);
+ doAuthWithDelegation(authenticationAttempt, session, request,
responder, HumanReadableText.AUTHENTICATION_FAILED);
} else {
- doAuth(authenticationAttempt, session, tag, command, responder,
HumanReadableText.AUTHENTICATION_FAILED);
+ doAuth(authenticationAttempt, session, request, responder,
HumanReadableText.AUTHENTICATION_FAILED);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/CapabilityProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/CapabilityProcessor.java
index 5054009..3642f35 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/CapabilityProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/CapabilityProcessor.java
@@ -84,7 +84,7 @@ public class CapabilityProcessor extends
AbstractMailboxProcessor<CapabilityRequ
final CapabilityResponse result = new
CapabilityResponse(getSupportedCapabilities(session));
responder.respond(result);
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
}
/**
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/CheckProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/CheckProcessor.java
index 12089b6..da80013 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/CheckProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/CheckProcessor.java
@@ -41,7 +41,7 @@ public class CheckProcessor extends
AbstractMailboxProcessor<CheckRequest> {
@Override
protected void doProcess(CheckRequest message, ImapSession session, Tag
tag, ImapCommand command, Responder responder) {
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(message, responder);
}
@Override
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/CloseProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/CloseProcessor.java
index 07cb7d7..110daf5 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/CloseProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/CloseProcessor.java
@@ -60,13 +60,13 @@ public class CloseProcessor extends
AbstractMailboxProcessor<CloseRequest> {
// Don't send HIGHESTMODSEQ when close. Like correct in the
ERRATA of RFC5162
//
// See http://www.rfc-editor.org/errata_search.php?rfc=5162
- okComplete(command, tag, responder);
+ okComplete(message, responder);
}
} catch (MailboxException e) {
LOGGER.error("Close failed for mailbox {}",
session.getSelected().getMailboxId(), e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/CreateProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/CreateProcessor.java
index 6d77247..c243440 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/CreateProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/CreateProcessor.java
@@ -55,16 +55,16 @@ public class CreateProcessor extends
AbstractMailboxProcessor<CreateRequest> {
final MailboxManager mailboxManager = getMailboxManager();
mailboxManager.createMailbox(mailboxPath,
ImapSessionUtils.getMailboxSession(session));
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (MailboxExistsException e) {
LOGGER.debug("Create failed for mailbox {} as it already exists",
mailboxPath, e);
- no(command, tag, responder, HumanReadableText.MAILBOX_EXISTS);
+ no(request, responder, HumanReadableText.MAILBOX_EXISTS);
} catch (TooLongMailboxNameException e) {
LOGGER.debug("The mailbox name length is over limit: {}",
mailboxPath.getName(), e);
- taggedBad(command, tag, responder,
HumanReadableText.FAILURE_MAILBOX_NAME);
+ taggedBad(request, responder,
HumanReadableText.FAILURE_MAILBOX_NAME);
} catch (MailboxException e) {
LOGGER.error("Create failed for mailbox {}", mailboxPath, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/DeleteACLProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/DeleteACLProcessor.java
index 04ff93e..8a631c2 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/DeleteACLProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/DeleteACLProcessor.java
@@ -83,7 +83,7 @@ public class DeleteACLProcessor extends
AbstractMailboxProcessor<DeleteACLReques
* existence information, much less the mailbox’s ACL.
*/
if (!mailboxManager.hasRight(mailboxPath, MailboxACL.Right.Lookup,
mailboxSession)) {
- no(command, tag, responder,
HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} else if (!mailboxManager.hasRight(mailboxPath,
MailboxACL.Right.Administer, mailboxSession)) {
/* RFC 4314 section 4. */
Object[] params = new Object[] {
@@ -92,7 +92,7 @@ public class DeleteACLProcessor extends
AbstractMailboxProcessor<DeleteACLReques
mailboxName
};
HumanReadableText text = new
HumanReadableText(HumanReadableText.UNSUFFICIENT_RIGHTS_KEY,
HumanReadableText.UNSUFFICIENT_RIGHTS_DEFAULT_VALUE, params);
- no(command, tag, responder, text);
+ no(message, responder, text);
} else {
EntryKey key = EntryKey.deserialize(identifier);
@@ -113,7 +113,7 @@ public class DeleteACLProcessor extends
AbstractMailboxProcessor<DeleteACLReques
mailboxSession
);
- okComplete(command, tag, responder);
+ okComplete(message, responder);
// FIXME should we send unsolicited responses here?
// unsolicitedResponses(session, responder, false);
}
@@ -126,12 +126,12 @@ public class DeleteACLProcessor extends
AbstractMailboxProcessor<DeleteACLReques
* */
Object[] params = new Object[] {e.getUnsupportedRight()};
HumanReadableText text = new
HumanReadableText(HumanReadableText.UNSUPPORTED_RIGHT_KEY,
HumanReadableText.UNSUPPORTED_RIGHT_DEFAULT_VALUE, params);
- taggedBad(command, tag, responder, text);
+ taggedBad(message, responder, text);
} catch (MailboxNotFoundException e) {
- no(command, tag, responder, HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} catch (MailboxException e) {
LOGGER.error("{} failed for mailbox {}", command.getName(),
mailboxName, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/DeleteProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/DeleteProcessor.java
index a80c1ff..d15eb6a 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/DeleteProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/DeleteProcessor.java
@@ -61,16 +61,16 @@ public class DeleteProcessor extends
AbstractMailboxProcessor<DeleteRequest> {
final MailboxManager mailboxManager = getMailboxManager();
mailboxManager.deleteMailbox(mailboxPath,
ImapSessionUtils.getMailboxSession(session));
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (MailboxNotFoundException e) {
LOGGER.debug("Delete failed for mailbox {} as it doesn't exist",
mailboxPath, e);
- no(command, tag, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX);
+ no(request, responder, HumanReadableText.FAILURE_NO_SUCH_MAILBOX);
} catch (TooLongMailboxNameException e) {
LOGGER.debug("The mailbox name length is over limit: {}",
mailboxPath.getName(), e);
- taggedBad(command, tag, responder,
HumanReadableText.FAILURE_MAILBOX_NAME);
+ taggedBad(request, responder,
HumanReadableText.FAILURE_MAILBOX_NAME);
} catch (MailboxException e) {
LOGGER.error("Delete failed for mailbox {}", mailboxPath, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/EnableProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/EnableProcessor.java
index 98c283c..f653a05 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/EnableProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/EnableProcessor.java
@@ -77,10 +77,10 @@ public class EnableProcessor extends
AbstractMailboxProcessor<EnableRequest> imp
responder.respond(new EnableResponse(enabledCaps));
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (EnableException e) {
LOGGER.info("Unable to enable extension", e);
- taggedBad(command, tag, responder, HumanReadableText.FAILED);
+ taggedBad(request, responder, HumanReadableText.FAILED);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/ExpungeProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/ExpungeProcessor.java
index 1f1e6b7..7d50868 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/ExpungeProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/ExpungeProcessor.java
@@ -71,7 +71,7 @@ public class ExpungeProcessor extends
AbstractMailboxProcessor<ExpungeRequest> i
MetaData mdata = mailbox.getMetaData(false, mailboxSession,
FetchGroup.NO_COUNT);
if (!mdata.isWriteable()) {
- no(command, tag, responder,
HumanReadableText.MAILBOX_IS_READ_ONLY);
+ no(request, responder, HumanReadableText.MAILBOX_IS_READ_ONLY);
} else {
IdRange[] ranges = request.getUidSet();
if (ranges == null) {
@@ -95,17 +95,17 @@ public class ExpungeProcessor extends
AbstractMailboxProcessor<ExpungeRequest> i
//
// See RFC5162 3.3 EXPUNGE Command 3.5. UID EXPUNGE Command
if
(EnableProcessor.getEnabledCapabilities(session).contains(ImapConstants.SUPPORTS_QRESYNC)
&& expunged > 0) {
- okComplete(command, tag,
ResponseCode.highestModSeq(mdata.getHighestModSeq()), responder);
+ okComplete(request,
ResponseCode.highestModSeq(mdata.getHighestModSeq()), responder);
} else {
- okComplete(command, tag, responder);
+ okComplete(request, responder);
}
}
} catch (MessageRangeException e) {
LOGGER.debug("Expunge failed", e);
- taggedBad(command, tag, responder,
HumanReadableText.INVALID_MESSAGESET);
+ taggedBad(request, responder,
HumanReadableText.INVALID_MESSAGESET);
} catch (MailboxException e) {
LOGGER.error("Expunge failed for mailbox {}",
session.getSelected().getMailboxId(), e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetACLProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetACLProcessor.java
index abdfeb7..ce61b5c 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetACLProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetACLProcessor.java
@@ -84,29 +84,29 @@ public class GetACLProcessor extends
AbstractMailboxProcessor<GetACLRequest> imp
* existence information, much less the mailbox’s ACL.
*/
if (!mailboxManager.hasRight(mailboxPath, MailboxACL.Right.Lookup,
mailboxSession)) {
- no(command, tag, responder,
HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} else if (!mailboxManager.hasRight(mailboxPath,
MailboxACL.Right.Administer, mailboxSession)) {
/* RFC 4314 section 4. */
Object[] params = new Object[] {
MailboxACL.Right.Administer.toString(),
- command.getName(),
+ message.getCommand().getName(),
mailboxName
};
HumanReadableText text = new
HumanReadableText(HumanReadableText.UNSUFFICIENT_RIGHTS_KEY,
HumanReadableText.UNSUFFICIENT_RIGHTS_DEFAULT_VALUE, params);
- no(command, tag, responder, text);
+ no(message, responder, text);
} else {
MetaData metaData = messageManager.getMetaData(false,
mailboxSession, FetchGroup.NO_COUNT);
ACLResponse aclResponse = new ACLResponse(mailboxName,
metaData.getACL());
responder.respond(aclResponse);
- okComplete(command, tag, responder);
+ okComplete(message, responder);
// FIXME should we send unsolicited responses here?
// unsolicitedResponses(session, responder, false);
}
} catch (MailboxNotFoundException e) {
- no(command, tag, responder, HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} catch (MailboxException e) {
- LOGGER.error("{} failed for mailbox {}", command.getName(),
mailboxName, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ LOGGER.error("{} failed for mailbox {}",
message.getCommand().getName(), mailboxName, e);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetAnnotationProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetAnnotationProcessor.java
index dcd843d..0cce69e 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetAnnotationProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetAnnotationProcessor.java
@@ -32,6 +32,7 @@ import org.apache.james.imap.api.ImapConstants;
import org.apache.james.imap.api.ImapSessionUtils;
import org.apache.james.imap.api.Tag;
import org.apache.james.imap.api.display.HumanReadableText;
+import org.apache.james.imap.api.message.request.ImapRequest;
import org.apache.james.imap.api.message.response.StatusResponse.ResponseCode;
import org.apache.james.imap.api.message.response.StatusResponseFactory;
import org.apache.james.imap.api.process.ImapProcessor;
@@ -72,17 +73,17 @@ public class GetAnnotationProcessor extends
AbstractMailboxProcessor<GetAnnotati
protected void doProcess(GetAnnotationRequest message, ImapSession
session, Tag tag, ImapCommand command,
Responder responder) {
try {
- proceed(message, session, tag, command, responder);
+ proceed(message, session, responder);
} catch (MailboxNotFoundException e) {
LOGGER.info("The command: {} is failed because not found mailbox
{}", command.getName(), message.getMailboxName());
- no(command, tag, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX, ResponseCode.tryCreate());
+ no(message, responder, HumanReadableText.FAILURE_NO_SUCH_MAILBOX,
ResponseCode.tryCreate());
} catch (MailboxException e) {
LOGGER.error("GetAnnotation on mailbox {} failed for user {}",
message.getMailboxName(), ImapSessionUtils.getUserName(session), e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
- private void proceed(GetAnnotationRequest message, ImapSession session,
Tag tag, ImapCommand command, Responder responder) throws MailboxException {
+ private void proceed(GetAnnotationRequest message, ImapSession session,
Responder responder) throws MailboxException {
String mailboxName = message.getMailboxName();
Optional<Integer> maxsize = message.getMaxsize();
MailboxPath mailboxPath =
PathConverter.forSession(session).buildFullPath(mailboxName);
@@ -90,17 +91,17 @@ public class GetAnnotationProcessor extends
AbstractMailboxProcessor<GetAnnotati
List<MailboxAnnotation> mailboxAnnotations =
getMailboxAnnotations(session, message.getKeys(), message.getDepth(),
mailboxPath);
Optional<Integer> maximumOversizedSize =
getMaxSizeValue(mailboxAnnotations, maxsize);
- respond(tag, command, responder, mailboxName, mailboxAnnotations,
maxsize, maximumOversizedSize);
+ respond(message, responder, mailboxName, mailboxAnnotations, maxsize,
maximumOversizedSize);
}
- private void respond(Tag tag, ImapCommand command, Responder responder,
String mailboxName,
+ private void respond(ImapRequest request, Responder responder, String
mailboxName,
List<MailboxAnnotation> mailboxAnnotations,
Optional<Integer> maxsize, Optional<Integer> maximumOversizedSize) {
if (maximumOversizedSize.isPresent()) {
responder.respond(new AnnotationResponse(mailboxName,
filterItemsBySize(mailboxAnnotations, maxsize)));
- okComplete(command, tag,
ResponseCode.longestMetadataEntry(maximumOversizedSize.get()), responder);
+ okComplete(request,
ResponseCode.longestMetadataEntry(maximumOversizedSize.get()), responder);
} else {
responder.respond(new AnnotationResponse(mailboxName,
mailboxAnnotations));
- okComplete(command, tag, responder);
+ okComplete(request, responder);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java
index 7ee3113..174cdbe 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaProcessor.java
@@ -83,7 +83,7 @@ public class GetQuotaProcessor extends
AbstractMailboxProcessor<GetQuotaRequest>
if (storageQuota.getLimit().isLimited()) {
responder.respond(new
QuotaResponse(ImapConstants.STORAGE_QUOTA_RESOURCE, quotaRoot.getValue(),
storageQuota));
}
- okComplete(command, tag, responder);
+ okComplete(message, responder);
} else {
Object[] params = new Object[]{
MailboxACL.Right.Read.toString(),
@@ -91,10 +91,10 @@ public class GetQuotaProcessor extends
AbstractMailboxProcessor<GetQuotaRequest>
"Any mailbox of this user USER"
};
HumanReadableText humanReadableText = new
HumanReadableText(HumanReadableText.UNSUFFICIENT_RIGHTS_KEY,
HumanReadableText.UNSUFFICIENT_RIGHTS_DEFAULT_VALUE, params);
- no(command, tag, responder, humanReadableText);
+ no(message, responder, humanReadableText);
}
} catch (MailboxException me) {
- taggedBad(command, tag, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX);
+ taggedBad(message, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java
index c7a2db2..f38832d 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/GetQuotaRootProcessor.java
@@ -91,7 +91,7 @@ public class GetQuotaRootProcessor extends
AbstractMailboxProcessor<GetQuotaRoot
if (storageQuota.getLimit().isLimited()) {
responder.respond(new
QuotaResponse(ImapConstants.STORAGE_QUOTA_RESOURCE, quotaRoot.getValue(),
storageQuota));
}
- okComplete(command, tag, responder);
+ okComplete(message, responder);
} else {
Object[] params = new Object[]{
MailboxACL.Right.Read.toString(),
@@ -99,10 +99,10 @@ public class GetQuotaRootProcessor extends
AbstractMailboxProcessor<GetQuotaRoot
message.getMailboxName()
};
HumanReadableText humanReadableText = new
HumanReadableText(HumanReadableText.UNSUFFICIENT_RIGHTS_KEY,
HumanReadableText.UNSUFFICIENT_RIGHTS_DEFAULT_VALUE, params);
- no(command, tag, responder, humanReadableText);
+ no(message, responder, humanReadableText);
}
} catch (MailboxException me) {
- taggedBad(command, tag, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX);
+ taggedBad(message, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/IdleProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/IdleProcessor.java
index a26dde5..1c0843f 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/IdleProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/IdleProcessor.java
@@ -115,7 +115,7 @@ public class IdleProcessor extends
AbstractMailboxProcessor<IdleRequest> impleme
StatusResponse response =
getStatusResponseFactory().taggedBad(tag, command,
HumanReadableText.INVALID_COMMAND);
responder.respond(response);
} else {
- okComplete(command, tag, responder);
+ okComplete(message, responder);
}
idleActive.set(false);
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java
index 6a138c7..ef7f299 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/LSubProcessor.java
@@ -61,10 +61,10 @@ public class LSubProcessor extends
AbstractSubscriptionProcessor<LsubRequest> {
try {
listSubscriptions(session, responder, referenceName,
mailboxPattern);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (MailboxException e) {
LOGGER.error("LSub failed for reference {} and pattern {}",
referenceName, mailboxPattern, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_LSUB_FAILURE);
+ no(request, responder, HumanReadableText.GENERIC_LSUB_FAILURE);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java
index eb6ad4d..7f05af7 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/ListProcessor.java
@@ -81,10 +81,10 @@ public class ListProcessor extends
AbstractMailboxProcessor<ListRequest> {
} else {
respondMailboxList(baseReferenceName, mailboxPatternString,
session, responder, mailboxSession);
}
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (MailboxException e) {
LOGGER.error("List failed for mailboxName {}",
mailboxPatternString, e);
- no(command, tag, responder, HumanReadableText.SEARCH_FAILED);
+ no(request, responder, HumanReadableText.SEARCH_FAILED);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/ListRightsProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/ListRightsProcessor.java
index f889fc9..8a6a5cf 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/ListRightsProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/ListRightsProcessor.java
@@ -85,7 +85,7 @@ public class ListRightsProcessor extends
AbstractMailboxProcessor<ListRightsRequ
* existence information, much less the mailbox’s ACL.
*/
if (!mailboxManager.hasRight(mailboxPath, MailboxACL.Right.Lookup,
mailboxSession)) {
- no(command, tag, responder,
HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} else if (!mailboxManager.hasRight(mailboxPath,
MailboxACL.Right.Administer, mailboxSession)) {
/* RFC 4314 section 4. */
Object[] params = new Object[] {
@@ -94,7 +94,7 @@ public class ListRightsProcessor extends
AbstractMailboxProcessor<ListRightsRequ
mailboxName
};
HumanReadableText text = new
HumanReadableText(HumanReadableText.UNSUFFICIENT_RIGHTS_KEY,
HumanReadableText.UNSUFFICIENT_RIGHTS_DEFAULT_VALUE, params);
- no(command, tag, responder, text);
+ no(message, responder, text);
} else {
EntryKey key = EntryKey.deserialize(identifier);
@@ -112,15 +112,15 @@ public class ListRightsProcessor extends
AbstractMailboxProcessor<ListRightsRequ
Rfc4314Rights[] rights =
mailboxManager.listRights(mailboxPath, key, mailboxSession);
ListRightsResponse aclResponse = new
ListRightsResponse(mailboxName, identifier, rights);
responder.respond(aclResponse);
- okComplete(command, tag, responder);
+ okComplete(message, responder);
// FIXME should we send unsolicited responses here?
// unsolicitedResponses(session, responder, false);
}
} catch (MailboxNotFoundException e) {
- no(command, tag, responder, HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} catch (MailboxException e) {
LOGGER.error("{} failed for mailbox {}", command.getName(),
mailboxName, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/LoginProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/LoginProcessor.java
index e7f960b..959fc15 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/LoginProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/LoginProcessor.java
@@ -52,10 +52,10 @@ public class LoginProcessor extends
AbstractAuthProcessor<LoginRequest> implemen
protected void doProcess(LoginRequest request, ImapSession session, Tag
tag, ImapCommand command, Responder responder) {
// check if the login is allowed with LOGIN command. See IMAP-304
if (session.isPlainAuthDisallowed() && session.isTLSActive() ==
false) {
- no(command, tag, responder, HumanReadableText.DISABLED_LOGIN);
+ no(request, responder, HumanReadableText.DISABLED_LOGIN);
} else {
doAuth(noDelegation(request.getUserid(),
request.getPassword()),
- session, tag, command, responder,
HumanReadableText.INVALID_LOGIN);
+ session, request, responder,
HumanReadableText.INVALID_LOGIN);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/LogoutProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/LogoutProcessor.java
index 8fcc486..b0bd7ce 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/LogoutProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/LogoutProcessor.java
@@ -52,10 +52,10 @@ public class LogoutProcessor extends
AbstractMailboxProcessor<LogoutRequest> {
getMailboxManager().logout(mailboxSession, false);
session.logout();
bye(responder);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (MailboxException e) {
LOGGER.error("Logout failed for user {}",
mailboxSession.getUser().asString(), e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/MyRightsProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/MyRightsProcessor.java
index 3eedf3b..01ecf51 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/MyRightsProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/MyRightsProcessor.java
@@ -91,19 +91,19 @@ public class MyRightsProcessor extends
AbstractMailboxProcessor<MyRightsRequest>
&& !myRights.contains(MailboxACL.Right.CreateMailbox)
&& !myRights.contains(MailboxACL.Right.DeleteMailbox)
&& !myRights.contains(MailboxACL.Right.Administer)) {
- no(command, tag, responder,
HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} else {
MyRightsResponse myRightsResponse = new
MyRightsResponse(mailboxName, myRights);
responder.respond(myRightsResponse);
- okComplete(command, tag, responder);
+ okComplete(message, responder);
// FIXME should we send unsolicited responses here?
// unsolicitedResponses(session, responder, false);
}
} catch (MailboxNotFoundException e) {
- no(command, tag, responder, HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} catch (MailboxException e) {
LOGGER.error("{} failed for mailbox {}", command.getName(),
mailboxName, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/NamespaceProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/NamespaceProcessor.java
index 30cac09..6c6457a 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/NamespaceProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/NamespaceProcessor.java
@@ -61,7 +61,7 @@ public class NamespaceProcessor extends
AbstractMailboxProcessor<NamespaceReques
final NamespaceResponse response = new
NamespaceResponse(personalNamespaces, otherUsersNamespaces, sharedNamespaces);
responder.respond(response);
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
}
/**
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/NoopProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/NoopProcessor.java
index ff8b404..b5e4ad4 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/NoopProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/NoopProcessor.java
@@ -42,7 +42,7 @@ public class NoopProcessor extends
AbstractMailboxProcessor<NoopRequest> {
protected void doProcess(NoopRequest message, ImapSession session, Tag
tag, ImapCommand command, Responder responder) {
// So, unsolicated responses are returned to check for new mail
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(message, responder);
}
@Override
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/RenameProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/RenameProcessor.java
index 62c932c..7b41df6 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/RenameProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/RenameProcessor.java
@@ -64,20 +64,20 @@ public class RenameProcessor extends
AbstractMailboxProcessor<RenameRequest> {
if
(existingPath.getName().equalsIgnoreCase(ImapConstants.INBOX_NAME) &&
!mailboxManager.mailboxExists(existingPath, mailboxsession)) {
mailboxManager.createMailbox(existingPath, mailboxsession);
}
- okComplete(command, tag, responder);
+ okComplete(request, responder);
unsolicitedResponses(session, responder, false);
} catch (MailboxExistsException e) {
LOGGER.debug("Rename from {} to {} failed because the target
mailbox exists", existingPath, newPath, e);
- no(command, tag, responder,
HumanReadableText.FAILURE_MAILBOX_EXISTS);
+ no(request, responder, HumanReadableText.FAILURE_MAILBOX_EXISTS);
} catch (MailboxNotFoundException e) {
LOGGER.debug("Rename from {} to {} failed because the source
mailbox doesn't exist", existingPath, newPath, e);
- no(command, tag, responder, HumanReadableText.MAILBOX_NOT_FOUND);
+ no(request, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} catch (TooLongMailboxNameException e) {
LOGGER.debug("The mailbox name length is over limit: {}",
newPath.getName(), e);
- taggedBad(command, tag, responder,
HumanReadableText.FAILURE_MAILBOX_NAME);
+ taggedBad(request, responder,
HumanReadableText.FAILURE_MAILBOX_NAME);
} catch (MailboxException e) {
LOGGER.error("Rename from {} to {} failed", existingPath, newPath,
e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(request, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SearchProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SearchProcessor.java
index 77a71ad..134218e 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SearchProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SearchProcessor.java
@@ -186,13 +186,13 @@ public class SearchProcessor extends
AbstractMailboxProcessor<SearchRequest> imp
boolean omitExpunged = (!useUids);
unsolicitedResponses(session, responder, omitExpunged, useUids);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (MessageRangeException e) {
LOGGER.debug("Search failed in mailbox {} because of an invalid
sequence-set ", session.getSelected().getMailboxId(), e);
- taggedBad(command, tag, responder,
HumanReadableText.INVALID_MESSAGESET);
+ taggedBad(request, responder,
HumanReadableText.INVALID_MESSAGESET);
} catch (MailboxException e) {
LOGGER.error("Search failed in mailbox {}",
session.getSelected().getMailboxId(), e);
- no(command, tag, responder, HumanReadableText.SEARCH_FAILED);
+ no(request, responder, HumanReadableText.SEARCH_FAILED);
if (resultOptions.contains(SearchResultOption.SAVE)) {
// Reset the saved sequence-set on a BAD response if the SAVE
option was used.
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SetACLProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SetACLProcessor.java
index ec4bdd7..b135f7f 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SetACLProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SetACLProcessor.java
@@ -102,7 +102,7 @@ public class SetACLProcessor extends
AbstractMailboxProcessor<SetACLRequest> imp
* existence information, much less the mailbox’s ACL.
*/
if (!mailboxManager.hasRight(mailboxPath, MailboxACL.Right.Lookup,
mailboxSession)) {
- no(command, tag, responder,
HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} else if (!mailboxManager.hasRight(mailboxPath,
MailboxACL.Right.Administer, mailboxSession)) {
/* RFC 4314 section 4. */
Object[] params = new Object[] {
@@ -111,7 +111,7 @@ public class SetACLProcessor extends
AbstractMailboxProcessor<SetACLRequest> imp
mailboxName
};
HumanReadableText text = new
HumanReadableText(HumanReadableText.UNSUFFICIENT_RIGHTS_KEY,
HumanReadableText.UNSUFFICIENT_RIGHTS_DEFAULT_VALUE, params);
- no(command, tag, responder, text);
+ no(message, responder, text);
} else {
EntryKey key = EntryKey.deserialize(identifier);
@@ -130,7 +130,7 @@ public class SetACLProcessor extends
AbstractMailboxProcessor<SetACLRequest> imp
MailboxACL.command().key(key).mode(editMode).rights(mailboxAclRights).build(),
mailboxSession);
- okComplete(command, tag, responder);
+ okComplete(message, responder);
// FIXME should we send unsolicited responses here?
// unsolicitedResponses(session, responder, false);
}
@@ -143,12 +143,12 @@ public class SetACLProcessor extends
AbstractMailboxProcessor<SetACLRequest> imp
* */
Object[] params = new Object[] {e.getUnsupportedRight()};
HumanReadableText text = new
HumanReadableText(HumanReadableText.UNSUPPORTED_RIGHT_KEY,
HumanReadableText.UNSUPPORTED_RIGHT_DEFAULT_VALUE, params);
- taggedBad(command, tag, responder, text);
+ taggedBad(message, responder, text);
} catch (MailboxNotFoundException e) {
- no(command, tag, responder, HumanReadableText.MAILBOX_NOT_FOUND);
+ no(message, responder, HumanReadableText.MAILBOX_NOT_FOUND);
} catch (MailboxException e) {
LOGGER.error("{} failed for mailbox {}", command.getName(),
mailboxName, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SetAnnotationProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SetAnnotationProcessor.java
index 1665e98..6c64145 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SetAnnotationProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SetAnnotationProcessor.java
@@ -70,16 +70,16 @@ public class SetAnnotationProcessor extends
AbstractMailboxProcessor<SetAnnotati
mailboxManager.updateAnnotations(mailboxPath, mailboxSession,
message.getMailboxAnnotations());
- okComplete(command, tag, responder);
+ okComplete(message, responder);
} catch (MailboxNotFoundException e) {
LOGGER.info("{} failed for mailbox {}", command.getName(),
mailboxName, e);
- no(command, tag, responder,
HumanReadableText.FAILURE_NO_SUCH_MAILBOX,
StatusResponse.ResponseCode.tryCreate());
+ no(message, responder, HumanReadableText.FAILURE_NO_SUCH_MAILBOX,
StatusResponse.ResponseCode.tryCreate());
} catch (AnnotationException e) {
LOGGER.info("{} failed for mailbox {}", command.getName(),
mailboxName, e);
- no(command, tag, responder, new
HumanReadableText(HumanReadableText.MAILBOX_ANNOTATION_KEY, e.getMessage()));
+ no(message, responder, new
HumanReadableText(HumanReadableText.MAILBOX_ANNOTATION_KEY, e.getMessage()));
} catch (MailboxException e) {
LOGGER.error("{} failed for mailbox {}", command.getName(),
mailboxName, e);
- no(command, tag, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
+ no(message, responder,
HumanReadableText.GENERIC_FAILURE_DURING_PROCESSING);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SetQuotaProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SetQuotaProcessor.java
index a871919..f8beffb 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SetQuotaProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SetQuotaProcessor.java
@@ -59,7 +59,7 @@ public class SetQuotaProcessor extends
AbstractMailboxProcessor<SetQuotaRequest>
"Can not perform SETQUOTA commands"
};
HumanReadableText humanReadableText = new
HumanReadableText(HumanReadableText.UNSUFFICIENT_RIGHTS_KEY,
HumanReadableText.UNSUFFICIENT_RIGHTS_DEFAULT_VALUE, params);
- no(command, tag, responder, humanReadableText);
+ no(message, responder, humanReadableText);
}
@Override
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/StatusProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/StatusProcessor.java
index 0486f36..6191d2c 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/StatusProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/StatusProcessor.java
@@ -69,10 +69,11 @@ public class StatusProcessor extends
AbstractMailboxProcessor<StatusRequest> {
}
responder.respond(response);
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+
+ okComplete(request, responder);
} catch (MailboxException e) {
LOGGER.error("Status failed for mailbox {}", mailboxPath, e);
- no(command, tag, responder, HumanReadableText.SEARCH_FAILED);
+ no(request, responder, HumanReadableText.SEARCH_FAILED);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/StoreProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/StoreProcessor.java
index 1e09e48..86c9af3 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/StoreProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/StoreProcessor.java
@@ -92,7 +92,7 @@ public class StoreProcessor extends
AbstractMailboxProcessor<StoreRequest> {
if (metaData.isModSeqPermanent() == false) {
// Check if the mailbox did not support modsequences. If
so return a tagged bad response.
// See RFC4551 3.1.2. NOMODSEQ Response Code
- taggedBad(command, tag, responder,
HumanReadableText.NO_MOD_SEQ);
+ taggedBad(request, responder,
HumanReadableText.NO_MOD_SEQ);
return;
} else if (unchangedSince == 0) {
Flags.Flag[] systemFlags = flags.getSystemFlags();
@@ -179,7 +179,7 @@ public class StoreProcessor extends
AbstractMailboxProcessor<StoreRequest> {
// check if we had some failed uids which didn't pass the
UNCHANGEDSINCE filter
if (failed.isEmpty() && failedMsns.isEmpty()) {
- okComplete(imapCommand, tag, responder);
+ okComplete(request, responder);
} else {
if (useUids) {
List<MessageRange> ranges = MessageRange.toRanges(failed);
@@ -211,10 +211,10 @@ public class StoreProcessor extends
AbstractMailboxProcessor<StoreRequest> {
}
} catch (MessageRangeException e) {
LOGGER.debug("Store failed for mailbox {} because of an invalid
sequence-set {}", session.getSelected().getMailboxId(), idSet, e);
- taggedBad(imapCommand, tag, responder,
HumanReadableText.INVALID_MESSAGESET);
+ taggedBad(request, responder,
HumanReadableText.INVALID_MESSAGESET);
} catch (MailboxException e) {
LOGGER.error("Store failed for mailbox {} and sequence-set {}",
session.getSelected().getMailboxId(), idSet, e);
- no(imapCommand, tag, responder, HumanReadableText.SAVE_FAILED);
+ no(request, responder, HumanReadableText.SAVE_FAILED);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SubscribeProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SubscribeProcessor.java
index 7c53735..b4a2797 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/SubscribeProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/SubscribeProcessor.java
@@ -54,12 +54,12 @@ public class SubscribeProcessor extends
AbstractSubscriptionProcessor<SubscribeR
getSubscriptionManager().subscribe(mailboxSession, mailboxName);
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (SubscriptionException e) {
LOGGER.info("Subscribe failed for mailbox {}", mailboxName, e);
unsolicitedResponses(session, responder, false);
- no(command, tag, responder,
HumanReadableText.GENERIC_SUBSCRIPTION_FAILURE);
+ no(request, responder,
HumanReadableText.GENERIC_SUBSCRIPTION_FAILURE);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/UnselectProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/UnselectProcessor.java
index 19dd80e..0edf0e7 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/UnselectProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/UnselectProcessor.java
@@ -52,9 +52,9 @@ public class UnselectProcessor extends
AbstractMailboxProcessor<UnselectRequest>
protected void doProcess(UnselectRequest message, ImapSession session, Tag
tag, ImapCommand command, Responder responder) {
if (session.getSelected() != null) {
session.deselect();
- okComplete(command, tag, responder);
+ okComplete(message, responder);
} else {
- taggedBad(command, tag, responder, HumanReadableText.UNSELECT);
+ taggedBad(message, responder, HumanReadableText.UNSELECT);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/UnsubscribeProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/UnsubscribeProcessor.java
index 853ff7f..17fdcb4 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/UnsubscribeProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/UnsubscribeProcessor.java
@@ -54,13 +54,13 @@ public class UnsubscribeProcessor extends
AbstractSubscriptionProcessor<Unsubscr
getSubscriptionManager().unsubscribe(mailboxSession, mailboxName);
unsolicitedResponses(session, responder, false);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (SubscriptionException e) {
LOGGER.info("Unsubscribe failed for mailbox {}", mailboxName, e);
unsolicitedResponses(session, responder, false);
- no(command, tag, responder,
HumanReadableText.GENERIC_SUBSCRIPTION_FAILURE);
+ no(request, responder,
HumanReadableText.GENERIC_SUBSCRIPTION_FAILURE);
}
}
diff --git
a/protocols/imap/src/main/java/org/apache/james/imap/processor/fetch/FetchProcessor.java
b/protocols/imap/src/main/java/org/apache/james/imap/processor/fetch/FetchProcessor.java
index fa26006..7aeb44d 100644
---
a/protocols/imap/src/main/java/org/apache/james/imap/processor/fetch/FetchProcessor.java
+++
b/protocols/imap/src/main/java/org/apache/james/imap/processor/fetch/FetchProcessor.java
@@ -81,12 +81,12 @@ public class FetchProcessor extends
AbstractMailboxProcessor<FetchRequest> {
final boolean vanished = fetch.getVanished();
if (vanished &&
!EnableProcessor.getEnabledCapabilities(session).contains(ImapConstants.SUPPORTS_QRESYNC))
{
- taggedBad(command, tag, responder,
HumanReadableText.QRESYNC_NOT_ENABLED);
+ taggedBad(request, responder,
HumanReadableText.QRESYNC_NOT_ENABLED);
return;
}
if (vanished && changedSince == -1) {
- taggedBad(command, tag, responder,
HumanReadableText.QRESYNC_VANISHED_WITHOUT_CHANGEDSINCE);
+ taggedBad(request, responder,
HumanReadableText.QRESYNC_VANISHED_WITHOUT_CHANGEDSINCE);
return;
}
final MailboxSession mailboxSession =
ImapSessionUtils.getMailboxSession(session);
@@ -124,13 +124,13 @@ public class FetchProcessor extends
AbstractMailboxProcessor<FetchRequest> {
// processor. See IMAP-284
final boolean omitExpunged = (!useUids);
unsolicitedResponses(session, responder, omitExpunged, useUids);
- okComplete(command, tag, responder);
+ okComplete(request, responder);
} catch (MessageRangeException e) {
LOGGER.debug("Fetch failed for mailbox {} because of invalid
sequence-set {}", session.getSelected().getMailboxId(), idSet, e);
- taggedBad(command, tag, responder,
HumanReadableText.INVALID_MESSAGESET);
+ taggedBad(request, responder,
HumanReadableText.INVALID_MESSAGESET);
} catch (MailboxException e) {
LOGGER.error("Fetch failed for mailbox {} and sequence-set {}",
session.getSelected().getMailboxId(), idSet, e);
- no(command, tag, responder, HumanReadableText.SEARCH_FAILED);
+ no(request, responder, HumanReadableText.SEARCH_FAILED);
}
}
---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscr...@james.apache.org
For additional commands, e-mail: server-dev-h...@james.apache.org
