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