You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@james.apache.org by rc...@apache.org on 2020/09/03 03:23:55 UTC
[james-project] 13/13: JAMES−3365 Make ProcessingContext immutable
This is an automated email from the ASF dual-hosted git repository.
rcordier pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/james-project.git
commit 6a528931a40dafd2c1ae685b90a3c4ce4fd31602
Author: Rémi KOWALSKI <rk...@linagora.com>
AuthorDate: Wed Aug 26 11:22:46 2020 +0200
JAMES−3365 Make ProcessingContext immutable
---
.../apache/james/jmap/method/CoreEchoMethod.scala | 2 +-
.../james/jmap/method/MailboxGetMethod.scala | 6 +--
.../james/jmap/method/MailboxSetMethod.scala | 35 +++++++++---------
.../org/apache/james/jmap/method/Method.scala | 2 +-
.../jmap/method/VacationResponseGetMethod.scala | 7 ++--
.../apache/james/jmap/routes/JMAPApiRoutes.scala | 43 ++++++++++++++--------
.../james/jmap/routes/ProcessingContext.scala | 8 ++--
.../james/jmap/method/CoreEchoMethodTest.scala | 8 ++--
8 files changed, 62 insertions(+), 49 deletions(-)
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/CoreEchoMethod.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/CoreEchoMethod.scala
index 9e9c432..c98df4a 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/CoreEchoMethod.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/CoreEchoMethod.scala
@@ -31,5 +31,5 @@ import reactor.core.scala.publisher.SMono
class CoreEchoMethod extends Method {
override val methodName = MethodName("Core/echo")
- override def process(capabilities: Set[CapabilityIdentifier], invocation: Invocation, mailboxSession: MailboxSession, processingContext: ProcessingContext): Publisher[Invocation] = SMono.just(invocation)
+ override def process(capabilities: Set[CapabilityIdentifier], invocation: Invocation, mailboxSession: MailboxSession, processingContext: ProcessingContext): Publisher[(Invocation, ProcessingContext)] = SMono.just((invocation, processingContext))
}
\ No newline at end of file
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/MailboxGetMethod.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/MailboxGetMethod.scala
index c993441..8572bde 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/MailboxGetMethod.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/MailboxGetMethod.scala
@@ -72,7 +72,7 @@ class MailboxGetMethod @Inject() (serializer: Serializer,
override def process(capabilities: Set[CapabilityIdentifier],
invocation: Invocation,
mailboxSession: MailboxSession,
- processingContext: ProcessingContext): Publisher[Invocation] = {
+ processingContext: ProcessingContext): Publisher[(Invocation, ProcessingContext)] = {
metricFactory.decoratePublisherWithTimerMetricLogP99(JMAP_RFC8621_PREFIX + methodName.value,
asMailboxGetRequest(invocation.arguments)
.flatMap(mailboxGetRequest => {
@@ -90,8 +90,8 @@ class MailboxGetMethod @Inject() (serializer: Serializer,
description = s"The following properties [${invalidProperties.format()}] do not exist.",
methodCallId = invocation.methodCallId))
}
- }
- ))
+ })
+ .map((_, processingContext)))
}
private def asMailboxGetRequest(arguments: Arguments): SMono[MailboxGetRequest] = {
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/MailboxSetMethod.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/MailboxSetMethod.scala
index 70784f2..2c1dcb0 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/MailboxSetMethod.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/MailboxSetMethod.scala
@@ -147,15 +147,15 @@ class MailboxSetMethod @Inject()(serializer: Serializer,
metricFactory: MetricFactory) extends Method {
override val methodName: MethodName = MethodName("Mailbox/set")
- override def process(capabilities: Set[CapabilityIdentifier], invocation: Invocation, mailboxSession: MailboxSession, processingContext: ProcessingContext): Publisher[Invocation] = {
+ override def process(capabilities: Set[CapabilityIdentifier], invocation: Invocation, mailboxSession: MailboxSession, processingContext: ProcessingContext): Publisher[(Invocation, ProcessingContext)] = {
metricFactory.decoratePublisherWithTimerMetricLogP99(JMAP_RFC8621_PREFIX + methodName.value,
asMailboxSetRequest(invocation.arguments)
.flatMap(mailboxSetRequest => {
for {
- creationResults <- createMailboxes(mailboxSession, mailboxSetRequest, processingContext)
+ creationResultsWithUpdatedProcessingContext <- createMailboxes(mailboxSession, mailboxSetRequest, processingContext)
deletionResults <- deleteMailboxes(mailboxSession, mailboxSetRequest, processingContext)
updateResults <- updateMailboxes(mailboxSession, mailboxSetRequest, processingContext, capabilities)
- } yield createResponse(capabilities, invocation, mailboxSetRequest, creationResults, deletionResults, updateResults)
+ } yield (createResponse(capabilities, invocation, mailboxSetRequest, creationResultsWithUpdatedProcessingContext._1, deletionResults, updateResults), creationResultsWithUpdatedProcessingContext._2)
}))
}
@@ -339,33 +339,34 @@ class MailboxSetMethod @Inject()(serializer: Serializer,
private def createMailboxes(mailboxSession: MailboxSession,
mailboxSetRequest: MailboxSetRequest,
- processingContext: ProcessingContext): SMono[CreationResults] = {
+ processingContext: ProcessingContext): SMono[(CreationResults, ProcessingContext)] = {
SFlux.fromIterable(mailboxSetRequest.create
.getOrElse(Map.empty)
.view)
- .flatMap {
- case (mailboxCreationId: MailboxCreationId, jsObject: JsObject) =>
- SMono.fromCallable(() => {
- createMailbox(mailboxSession, mailboxCreationId, jsObject, processingContext)
- }).subscribeOn(Schedulers.elastic())
+ .foldLeft((CreationResults(Nil), processingContext)){
+ (acc : (CreationResults, ProcessingContext), elem: (MailboxCreationId, JsObject)) => {
+ val (mailboxCreationId, jsObject) = elem
+ val (creationResult, updatedProcessingContext) = createMailbox(mailboxSession, mailboxCreationId, jsObject, acc._2)
+ (CreationResults(acc._1.created :+ creationResult), updatedProcessingContext)
+ }
}
- .collectSeq()
- .map(CreationResults)
+ .subscribeOn(Schedulers.elastic())
}
private def createMailbox(mailboxSession: MailboxSession,
mailboxCreationId: MailboxCreationId,
jsObject: JsObject,
- processingContext: ProcessingContext): CreationResult = {
+ processingContext: ProcessingContext): (CreationResult, ProcessingContext) = {
parseCreate(jsObject)
.flatMap(mailboxCreationRequest => resolvePath(mailboxSession, mailboxCreationRequest, processingContext)
.flatMap(path => createMailbox(mailboxSession = mailboxSession,
path = path,
mailboxCreationRequest = mailboxCreationRequest)))
- .fold(e => CreationFailure(mailboxCreationId, e),
- creationResponse => {
- recordCreationIdInProcessingContext(mailboxCreationId, processingContext, creationResponse.id)
- CreationSuccess(mailboxCreationId, creationResponse)
+ .flatMap(creationResponse => recordCreationIdInProcessingContext(mailboxCreationId, processingContext, creationResponse.id)
+ .map(context => (creationResponse, context)))
+ .fold(e => (CreationFailure(mailboxCreationId, e), processingContext),
+ creationResponseWithUpdatedContext => {
+ (CreationSuccess(mailboxCreationId, creationResponseWithUpdatedContext._1), creationResponseWithUpdatedContext._2)
})
}
@@ -425,7 +426,7 @@ class MailboxSetMethod @Inject()(serializer: Serializer,
private def recordCreationIdInProcessingContext(mailboxCreationId: MailboxCreationId,
processingContext: ProcessingContext,
- mailboxId: MailboxId): Unit = {
+ mailboxId: MailboxId): Either[IllegalArgumentException, ProcessingContext] = {
for {
creationId <- Id.validate(mailboxCreationId)
serverAssignedId <- Id.validate(mailboxId.serialize())
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/Method.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/Method.scala
index 937112b..2b2b29e 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/Method.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/Method.scala
@@ -31,6 +31,6 @@ trait Method {
val methodName: MethodName
- def process(capabilities: Set[CapabilityIdentifier], invocation: Invocation, mailboxSession: MailboxSession, processingContext: ProcessingContext): Publisher[Invocation]
+ def process(capabilities: Set[CapabilityIdentifier], invocation: Invocation, mailboxSession: MailboxSession, processingContext: ProcessingContext): Publisher[(Invocation, ProcessingContext)]
}
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/VacationResponseGetMethod.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/VacationResponseGetMethod.scala
index ee84a05..c5e4ca4 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/VacationResponseGetMethod.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/method/VacationResponseGetMethod.scala
@@ -64,7 +64,7 @@ class VacationResponseGetMethod @Inject() (serializer: Serializer,
override def process(capabilities: Set[CapabilityIdentifier],
invocation: Invocation,
mailboxSession: MailboxSession,
- processingContext: ProcessingContext): Publisher[Invocation] = {
+ processingContext: ProcessingContext): Publisher[(Invocation, ProcessingContext)] = {
metricFactory.decoratePublisherWithTimerMetricLogP99(JMAP_RFC8621_PREFIX + methodName.value,
validate(capabilities)
.flatMap(_ => asVacationResponseGetRequest(invocation.arguments))
@@ -76,7 +76,8 @@ class VacationResponseGetMethod @Inject() (serializer: Serializer,
.map(vacationResponseGetResponse => Invocation(
methodName = methodName,
arguments = Arguments(serializer.serialize(vacationResponseGetResponse).as[JsObject]),
- methodCallId = invocation.methodCallId))))
+ methodCallId = invocation.methodCallId)))
+ .map((_, processingContext)))
}
private def validate(capabilities: Set[CapabilityIdentifier]): Either[MissingCapabilityException, Unit] =
@@ -92,7 +93,7 @@ class VacationResponseGetMethod @Inject() (serializer: Serializer,
case errors: JsError => Left(new IllegalArgumentException(serializer.serialize(errors).toString))
}
- private def handleRequestValidationErrors(exception: Exception, methodCallId: MethodCallId): Publisher[Invocation] = exception match {
+ private def handleRequestValidationErrors(exception: Exception, methodCallId: MethodCallId): SMono[Invocation] = exception match {
case _: MissingCapabilityException => SMono.just(Invocation.error(ErrorCode.UnknownMethod, methodCallId))
case e: IllegalArgumentException => SMono.just(Invocation.error(ErrorCode.InvalidArguments, e.getMessage, methodCallId))
}
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/routes/JMAPApiRoutes.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/routes/JMAPApiRoutes.scala
index 4f4683a..2889689 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/routes/JMAPApiRoutes.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/routes/JMAPApiRoutes.scala
@@ -112,48 +112,61 @@ class JMAPApiRoutes (val authenticator: Authenticator,
private def process(requestObject: RequestObject,
httpServerResponse: HttpServerResponse,
mailboxSession: MailboxSession): SMono[Void] = {
- val processingContext: ProcessingContext = new ProcessingContext
+ val processingContext: ProcessingContext = ProcessingContext(Map.empty, Map.empty)
val unsupportedCapabilities = requestObject.using.toSet -- DefaultCapabilities.SUPPORTED.ids
val capabilities: Set[CapabilityIdentifier] = requestObject.using.toSet
if (unsupportedCapabilities.nonEmpty) {
SMono.raiseError(UnsupportedCapabilitiesException(unsupportedCapabilities))
} else {
- requestObject
- .methodCalls
- .map(invocation => process(capabilities, mailboxSession, processingContext, invocation))
- .foldLeft(SFlux.empty[Invocation]) { (flux: SFlux[Invocation], mono: SMono[Invocation]) => flux.concatWith(mono) }
- .collectSeq()
- .flatMap((invocations: Seq[Invocation]) =>
+ processSequentiallyAndUpdateContext(requestObject, mailboxSession, processingContext, capabilities)
+ .flatMap((invocations : Seq[(Invocation, ProcessingContext)]) =>
SMono.fromPublisher(httpServerResponse.status(OK)
.header(CONTENT_TYPE, JSON_CONTENT_TYPE)
.sendString(
SMono.fromCallable(() =>
- serializer.serialize(ResponseObject(ResponseObject.SESSION_STATE, invocations)).toString),
+ serializer.serialize(ResponseObject(ResponseObject.SESSION_STATE, invocations.map(_._1))).toString),
StandardCharsets.UTF_8)
.`then`())
)
}
}
- private def process(capabilities: Set[CapabilityIdentifier], mailboxSession: MailboxSession, processingContext: ProcessingContext, invocation: Invocation) = {
+ private def processSequentiallyAndUpdateContext(requestObject: RequestObject, mailboxSession: MailboxSession, processingContext: ProcessingContext, capabilities: Set[CapabilityIdentifier]): SMono[Seq[(Invocation, ProcessingContext)]] = {
+ SFlux.fromIterable(requestObject.methodCalls)
+ .foldLeft(List[SMono[(Invocation, ProcessingContext)]]())((acc, elem) => {
+ val lastProcessingContext: SMono[ProcessingContext] = acc.headOption
+ .map(last => last.map(_._2))
+ .getOrElse(SMono.just(processingContext))
+ val invocation: SMono[(Invocation, ProcessingContext)] = lastProcessingContext.flatMap(context => process(capabilities, mailboxSession, context, elem))
+ invocation.cache() :: acc
+ })
+ .map(_.reverse)
+ .flatMap(list => SFlux.fromIterable(list)
+ .concatMap(e => e)
+ .collectSeq())
+ }
+
+ private def process(capabilities: Set[CapabilityIdentifier], mailboxSession: MailboxSession, processingContext: ProcessingContext, invocation: Invocation) : SMono[(Invocation, ProcessingContext)] = {
SMono.defer(() => {
processingContext.resolveBackReferences(serializer, invocation) match {
- case Left(e) => SMono.just(Invocation.error(
+ case Left(e) => SMono.just((Invocation.error(
errorCode = ErrorCode.InvalidResultReference,
description = s"Failed resolving back-reference: ${e.message}",
- methodCallId = invocation.methodCallId))
+ methodCallId = invocation.methodCallId), processingContext))
case Right(resolvedInvocation) => processMethodWithMatchName(capabilities, resolvedInvocation, mailboxSession, processingContext)
- .doOnNext(invocationResult => processingContext.recordInvocation(invocationResult))
+ .map {
+ case (invocation: Invocation, updatedProcessingContext: ProcessingContext) => (invocation, updatedProcessingContext.recordInvocation(invocation))
+ }
}
})
}
- private def processMethodWithMatchName(capabilities: Set[CapabilityIdentifier], invocation: Invocation, mailboxSession: MailboxSession, processingContext: ProcessingContext): SMono[Invocation] =
+ private def processMethodWithMatchName(capabilities: Set[CapabilityIdentifier], invocation: Invocation, mailboxSession: MailboxSession, processingContext: ProcessingContext): SMono[(Invocation, ProcessingContext)] =
SMono.justOrEmpty(methodsByName.get(invocation.methodName))
.flatMap(method => SMono.fromPublisher(method.process(capabilities, invocation, mailboxSession, processingContext)))
- .onErrorResume(throwable => SMono.just(Invocation.error(ErrorCode.ServerFail, throwable.getMessage, invocation.methodCallId)))
- .switchIfEmpty(SMono.just(Invocation.error(ErrorCode.UnknownMethod, invocation.methodCallId)))
+ .onErrorResume(throwable => SMono.just((Invocation.error(ErrorCode.ServerFail, throwable.getMessage, invocation.methodCallId), processingContext)))
+ .switchIfEmpty(SMono.just((Invocation.error(ErrorCode.UnknownMethod, invocation.methodCallId), processingContext)))
private def handleError(throwable: Throwable, httpServerResponse: HttpServerResponse): SMono[Void] = throwable match {
case exception: IllegalArgumentException => respondDetails(httpServerResponse,
diff --git a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/routes/ProcessingContext.scala b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/routes/ProcessingContext.scala
index 64072d8..3505032 100644
--- a/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/routes/ProcessingContext.scala
+++ b/server/protocols/jmap-rfc-8621/src/main/scala/org/apache/james/jmap/routes/ProcessingContext.scala
@@ -90,14 +90,12 @@ case class BackReference(name: MethodName, path: JsonPath, resultOf: MethodCallI
case class InvalidResultReferenceException(message: String) extends IllegalArgumentException
-class ProcessingContext {
- private val creationIds: mutable.Map[ClientId, ServerId] = mutable.Map()
- private val invocations: mutable.Map[MethodCallId, Invocation] = mutable.Map()
+case class ProcessingContext(private val creationIds: Map[ClientId, ServerId], private val invocations: Map[MethodCallId, Invocation]) {
- def recordCreatedId(clientId: ClientId, serverId: ServerId): Unit = creationIds.put(clientId, serverId)
+ def recordCreatedId(clientId: ClientId, serverId: ServerId): ProcessingContext = ProcessingContext(creationIds + (clientId -> serverId), invocations)
private def retrieveServerId(clientId: ClientId): Option[ServerId] = creationIds.get(clientId)
- def recordInvocation(invocation: Invocation): Unit = invocations.put(invocation.methodCallId, invocation)
+ def recordInvocation(invocation: Invocation): ProcessingContext = ProcessingContext(creationIds, invocations + (invocation.methodCallId -> invocation))
def resolveBackReferences(serializer: Serializer, invocation: Invocation): Either[InvalidResultReferenceException, Invocation] =
backReferenceResolver(serializer).reads(invocation.arguments.value) match {
diff --git a/server/protocols/jmap-rfc-8621/src/test/scala/org/apache/james/jmap/method/CoreEchoMethodTest.scala b/server/protocols/jmap-rfc-8621/src/test/scala/org/apache/james/jmap/method/CoreEchoMethodTest.scala
index 1f7d859..ff24174 100644
--- a/server/protocols/jmap-rfc-8621/src/test/scala/org/apache/james/jmap/method/CoreEchoMethodTest.scala
+++ b/server/protocols/jmap-rfc-8621/src/test/scala/org/apache/james/jmap/method/CoreEchoMethodTest.scala
@@ -36,15 +36,15 @@ class CoreEchoMethodTest extends AnyWordSpec with Matchers {
"CoreEcho" should {
"Process" should {
"success and return the same with parameters as the invocation request" in {
- val expectedResponse: Invocation = invocation1
- val dataResponse = SMono.fromPublisher(echoMethod.process(capabilities, invocation1, mockedSession, new ProcessingContext)).block()
+ val expectedResponse: (Invocation, ProcessingContext) = (invocation1, ProcessingContext(Map.empty, Map.empty))
+ val dataResponse = SMono.fromPublisher(echoMethod.process(capabilities, invocation1, mockedSession, ProcessingContext(Map.empty, Map.empty))).block()
dataResponse shouldBe expectedResponse
}
"success and not return anything else different than the original invocation" in {
- val wrongExpected: Invocation = invocation2
- val dataResponse = SMono.fromPublisher(echoMethod.process(capabilities, invocation1, mockedSession, new ProcessingContext)).block()
+ val wrongExpected: (Invocation, ProcessingContext) = (invocation2, ProcessingContext(Map.empty, Map.empty))
+ val dataResponse = SMono.fromPublisher(echoMethod.process(capabilities, invocation1, mockedSession, ProcessingContext(Map.empty, Map.empty))).block()
dataResponse should not be(wrongExpected)
}
---------------------------------------------------------------------
To unsubscribe, e-mail: notifications-unsubscribe@james.apache.org
For additional commands, e-mail: notifications-help@james.apache.org