For #5890: support for about to expire listeners

Author: avernet

xforms-client-server/src/main/scala/org/orbeon/xforms/rpc/definitions.scala

@@ -64,8 +64,8 @@ case class WireAjaxEventWithoutTarget(
 ) extends WireAjaxEvent
 
 case class ConfigurationProperties(
-  sessionHeartbeat                : Boolean,
-  sessionHeartbeatDelay           : Long,
+  sessionHeartbeatEnabled         : Boolean,
+  maxInactiveIntervalMillis       : Long,
   revisitHandling                 : String,
   delayBeforeIncrementalRequest   : Int,
   delayBeforeAjaxTimeout          : Long,

xforms-runtime/shared/src/main/scala/org/orbeon/oxf/xforms/XFormsContainingDocumentSupport.scala

@@ -822,12 +822,12 @@ trait ContainingDocumentClientState {
 
     val jsonInitializationData =
       ScriptBuilder.buildJsonInitializationData(
-        containingDocument   = this,
-        rewriteResource      = response.rewriteResourceURL(_: String, UrlRewriteMode.AbsolutePathOrRelative),
-        rewriteAction        = response.rewriteActionURL,
-        controlsToInitialize = controls.getCurrentControlTree.rootOpt map (ScriptBuilder.gatherJavaScriptInitializations(_, includeValue = true)) getOrElse Nil,
-        versionedResources   = URLRewriterUtils.isResourcesVersioned,
-        heartbeatDelay       = XFormsStateManager.getHeartbeatDelay(this, externalContext)
+        containingDocument        = this,
+        rewriteResource           = response.rewriteResourceURL(_: String, UrlRewriteMode.AbsolutePathOrRelative),
+        rewriteAction             = response.rewriteActionURL,
+        controlsToInitialize      = controls.getCurrentControlTree.rootOpt map (ScriptBuilder.gatherJavaScriptInitializations(_, includeValue = true)) getOrElse Nil,
+        versionedResources        = URLRewriterUtils.isResourcesVersioned,
+        maxInactiveIntervalMillis = XFormsStateManager.getMaxInactiveIntervalMillis(this, externalContext)
       )
 
     _initializationData = (initializationScripts, jsonInitializationData).some

xforms-runtime/shared/src/main/scala/org/orbeon/oxf/xforms/processor/ScriptBuilder.scala

@@ -87,9 +87,9 @@ object ScriptBuilder {
   }
 
   private def findConfigurationProperties(
-    containingDocument : XFormsContainingDocument,
-    versionedResources : Boolean,
-    heartbeatDelay     : Long
+    containingDocument       : XFormsContainingDocument,
+    versionedResources       : Boolean,
+    maxInactiveIntervalMillis : Long
   ): ConfigurationProperties = {
 
     val staticState = containingDocument.staticState
@@ -104,8 +104,8 @@ object ScriptBuilder {
       versionedResources flatOption CoreCrossPlatformSupport.getApplicationResourceVersion
 
     ConfigurationProperties(
-      sessionHeartbeat                 = staticState.staticBooleanProperty(SessionHeartbeatProperty),                     // static
-      sessionHeartbeatDelay            = heartbeatDelay,                                                                  // dynamic
+      sessionHeartbeatEnabled          = staticState.staticBooleanProperty(SessionHeartbeatProperty),                     // static
+      maxInactiveIntervalMillis        = maxInactiveIntervalMillis,                                                                  // dynamic
       revisitHandling                  = staticState.staticStringProperty(RevisitHandlingProperty),                       // static
       delayBeforeIncrementalRequest    = staticState.staticIntProperty(DelayBeforeIncrementalRequestProperty),            // static
       delayBeforeAjaxTimeout           = getAjaxTimeout,                                                                  // global
@@ -127,12 +127,12 @@ object ScriptBuilder {
   }
 
   def buildJsonInitializationData(
-    containingDocument   : XFormsContainingDocument,
-    rewriteResource      : String => String,
-    rewriteAction        : String => String,
-    controlsToInitialize : List[(String, Option[String])],
-    versionedResources   : Boolean,
-    heartbeatDelay       : Long
+    containingDocument        : XFormsContainingDocument,
+    rewriteResource           : String => String,
+    rewriteAction             : String => String,
+    controlsToInitialize      : List[(String, Option[String])],
+    versionedResources        : Boolean,
+    maxInactiveIntervalMillis : Long
   ): String = {
 
     val currentTime = System.currentTimeMillis
@@ -204,7 +204,7 @@ object ScriptBuilder {
             formId  = containingDocument.getNamespacedFormId
           ),
       configuration =
-        findConfigurationProperties(containingDocument, versionedResources, heartbeatDelay),
+        findConfigurationProperties(containingDocument, versionedResources, maxInactiveIntervalMillis),
     ).asJson.noSpaces
   }
 

xforms-runtime/shared/src/main/scala/org/orbeon/oxf/xforms/processor/handlers/xhtml/XHTMLHeadHandler.scala

@@ -143,12 +143,12 @@ class XHTMLHeadHandler(
         writeContent(
           ScriptBuilder.buildInitializationCall(
             jsonInitialization = buildJsonInitializationData(
-              containingDocument   = containingDocument,
-              rewriteResource      = externalContext.getResponse.rewriteResourceURL(_: String, UrlRewriteMode.AbsolutePathOrRelative),
-              rewriteAction        = externalContext.getResponse.rewriteActionURL,
-              controlsToInitialize = containingDocument.controls.getCurrentControlTree.rootOpt map (gatherJavaScriptInitializations(_, includeValue = true)) getOrElse Nil,
-              versionedResources   = isVersionedResources,
-              heartbeatDelay       = XFormsStateManager.getHeartbeatDelay(containingDocument, handlerContext.externalContext)
+              containingDocument        = containingDocument,
+              rewriteResource           = externalContext.getResponse.rewriteResourceURL(_: String, UrlRewriteMode.AbsolutePathOrRelative),
+              rewriteAction             = externalContext.getResponse.rewriteActionURL,
+              controlsToInitialize      = containingDocument.controls.getCurrentControlTree.rootOpt map (gatherJavaScriptInitializations(_, includeValue = true)) getOrElse Nil,
+              versionedResources        = isVersionedResources,
+              maxInactiveIntervalMillis = XFormsStateManager.getMaxInactiveIntervalMillis(containingDocument, handlerContext.externalContext)
             ),
             contextPathOpt = externalContext.getRequest.getFirstParamAsString(Constants.EmbeddingContextParameter),
             namespaceOpt   = externalContext.getRequest.getFirstParamAsString(Constants.EmbeddingNamespaceParameter)

xforms-runtime/shared/src/main/scala/org/orbeon/oxf/xforms/state/XFormsStateManagerTrait.scala

@@ -102,12 +102,11 @@ trait XFormsStateManagerTrait extends XFormsStateLifecycle {
     *
     * @return delay in ms, or -1 is not applicable
     */
-  def getHeartbeatDelay(containingDocument: XFormsContainingDocument, externalContext: ExternalContext): Long =
-    if (containingDocument.staticState.isClientStateHandling || ! containingDocument.isSessionHeartbeat) {
+  def getMaxInactiveIntervalMillis(containingDocument: XFormsContainingDocument, externalContext: ExternalContext): Long =
+    if (containingDocument.staticState.isClientStateHandling) {
       -1L
     } else {
-      // 80% of session expiration time, in ms
-      externalContext.getRequest.getSession(ForceSessionCreation).getMaxInactiveInterval * 800
+      externalContext.getRequest.getSession(ForceSessionCreation).getMaxInactiveInterval * 1000
     }
 
   // Ideally we wouldn't want to force session creation, but it's hard to implement the more elaborate expiration

xforms-web/src/main/scala/org/orbeon/xforms/AjaxClient.scala

@@ -289,16 +289,17 @@ object AjaxClient {
       ErrorPanel.showError(Page.getXFormsFormFromNamespacedIdOrThrow(formId), detailsString)
   }
 
+  def newestEventTime: Long = EventQueue.newestEventTime
+
   // Sending a heartbeat event if no event has been sent to server in the last time interval
   // determined by the `session-heartbeat-delay` property.
-  def sendHeartBeatIfNeeded(heartBeatDelay: Long): Unit =
-    if ((System.currentTimeMillis() - EventQueue.newestEventTime) >= heartBeatDelay)
-      AjaxClient.fireEvent(
-        AjaxEvent(
-          eventName = EventNames.XXFormsSessionHeartbeat,
-          form      = Support.getFirstForm
-        )
+  def sendHeartBeat(): Unit =
+    AjaxClient.fireEvent(
+      AjaxEvent(
+        eventName = EventNames.XXFormsSessionHeartbeat,
+        form      = Support.getFirstForm
       )
+    )
 
   private object EventQueue extends AjaxEventQueue[AjaxEvent] {
 

xforms-web/src/main/scala/org/orbeon/xforms/InitSupport.scala

@@ -27,6 +27,7 @@ import org.orbeon.web.DomEventNames
 import org.orbeon.wsrp.WSRPSupport
 import org.orbeon.xforms
 import org.orbeon.xforms.EventNames.{KeyModifiersPropertyName, KeyTextPropertyName}
+import org.orbeon.xforms.Page.AboutToExpire
 import org.orbeon.xforms.StateHandling.StateResult
 import org.orbeon.xforms.facade._
 import org.orbeon.xforms.rpc.Initializations
@@ -319,14 +320,23 @@ object InitSupport {
     // The heartbeat is per servlet session and we only need one. But see https://github.com/orbeon/orbeon-forms/issues/2014.
     def initializeHeartBeatIfNeeded(configuration: rpc.ConfigurationProperties): Unit =
       if (! heartBeatInitialized) {
-        if (configuration.sessionHeartbeat) {
+        if (configuration.sessionHeartbeatEnabled) {
           // Say session is 60 minutes: heartbeat must come after 48 minutes and we check every 4.8 minutes
-          val heartBeatDelay      = configuration.sessionHeartbeatDelay
-          val heartBeatCheckDelay = heartBeatDelay / 10
-          if (heartBeatCheckDelay > 0) {
-            logger.debug(s"setting heartbeat check every $heartBeatCheckDelay ms")
-            js.timers.setInterval(heartBeatCheckDelay) {
-              AjaxClient.sendHeartBeatIfNeeded(heartBeatDelay)
+          val reactAfterMillis = (configuration.maxInactiveIntervalMillis * 0.8).toLong
+          val checkEveryMillis = reactAfterMillis / 10
+          if (checkEveryMillis > 0) {
+            logger.debug(s"checking if getting close to session expiration every $checkEveryMillis ms")
+            js.timers.setInterval(checkEveryMillis) {
+              val elapsedMillisSinceLastEvent = System.currentTimeMillis() - AjaxClient.newestEventTime
+              if (elapsedMillisSinceLastEvent >= reactAfterMillis) {
+                if (configuration.sessionHeartbeatEnabled)
+                  AjaxClient.sendHeartBeat()
+                val approxSessionExpiredTimeMillis = AjaxClient.newestEventTime + configuration.maxInactiveIntervalMillis
+                Page.fireSessionAboutToExpire(AboutToExpire(
+                  configuration.sessionHeartbeatEnabled,
+                  approxSessionExpiredTimeMillis
+                ))
+              }
             }
           }
         }

xforms-web/src/main/scala/org/orbeon/xforms/Page.scala

@@ -15,11 +15,14 @@ package org.orbeon.xforms
 
 
 import org.orbeon.oxf.util.StringUtils._
+import org.orbeon.oxf.externalcontext.ExternalContext.Scope.Session
 import org.orbeon.xforms
 import org.orbeon.xforms.Constants.FormClass
 import org.scalajs.dom.html
 
 import scala.scalajs.js
+import scala.collection.mutable
+import scala.scalajs.js.Date
 import scala.scalajs.js.annotation.{JSExport, JSExportTopLevel}
 
 
@@ -130,12 +133,24 @@ object Page {
     }
   }
 
+  type AboutToExpireListener = AboutToExpire => Unit
+  case class AboutToExpire(
+    sessionHeartbeatEnabled        : Boolean,
+    approxSessionExpiredTimeMillis : Long
+  )
+
+  def addSessionAboutToExpireListener   (listener: AboutToExpireListener): Unit = sessionAboutToExpireListeners += listener
+  def removeSessionAboutToExpireListener(listener: AboutToExpireListener): Unit = sessionAboutToExpireListeners -= listener
+  def fireSessionAboutToExpire(aboutToExpire: AboutToExpire)             : Unit = sessionAboutToExpireListeners.foreach(_(aboutToExpire))
+
   // NOTE: This mechanism is deprecated by XBL and only used for the native `Upload` as of 2019-05-13.
   def registerControlConstructor(controlConstructor: () => Upload, predicate: html.Element => Boolean): Unit =
     controlConstructors ::= ConstructorPredicate(controlConstructor, predicate)
 
   private object Private {
 
+    val sessionAboutToExpireListeners: mutable.ListBuffer[AboutToExpireListener] = mutable.ListBuffer.empty
+
     case class ConstructorPredicate(controlConstructor: () => Upload, predicate: html.Element => Boolean)
 
     lazy val loadingIndicator        = new LoadingIndicator