5 files changed, 228 insertions, 0 deletions

diff --git a/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PrecomputationListener.java b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PrecomputationListener.java
new file mode 100644
index 00000000..79a284db
--- /dev/null
+++ b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PrecomputationListener.java
@@ -0,0 +1,15 @@
+package tools.refinery.language.web.xtext.server.push;
+
+import org.eclipse.xtext.web.server.IServiceResult;
+
+import tools.refinery.language.web.xtext.server.ResponseHandlerException;
+
+@FunctionalInterface
+public interface PrecomputationListener {
+        void onPrecomputedServiceResult(String resourceId, String stateId, String serviceName, IServiceResult serviceResult)
+                        throws ResponseHandlerException;
+
+        default void onSubscribeToPrecomputationEvents(String resourceId, PushWebDocument document) {
+                // Nothing to handle by default.
+        }
+}
diff --git a/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushServiceDispatcher.java b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushServiceDispatcher.java
new file mode 100644
index 00000000..c7b8108d
--- /dev/null
+++ b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushServiceDispatcher.java
@@ -0,0 +1,23 @@
+package tools.refinery.language.web.xtext.server.push;
+
+import org.eclipse.xtext.web.server.IServiceContext;
+import org.eclipse.xtext.web.server.XtextServiceDispatcher;
+import org.eclipse.xtext.web.server.model.XtextWebDocument;
+
+import com.google.inject.Singleton;
+
+import tools.refinery.language.web.xtext.server.SubscribingServiceContext;
+
+@Singleton
+public class PushServiceDispatcher extends XtextServiceDispatcher {
+
+        @Override
+        protected XtextWebDocument getFullTextDocument(String fullText, String resourceId, IServiceContext context) {
+                var document = super.getFullTextDocument(fullText, resourceId, context);
+                if (document instanceof PushWebDocument pushWebDocument
+                                && context instanceof SubscribingServiceContext subscribingContext) {
+                        pushWebDocument.addPrecomputationListener(subscribingContext.subscriber());
+                }
+                return document;
+        }
+}
diff --git a/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java
new file mode 100644
index 00000000..906b9e30
--- /dev/null
+++ b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocument.java
@@ -0,0 +1,89 @@
+package tools.refinery.language.web.xtext.server.push;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.xtext.util.CancelIndicator;
+import org.eclipse.xtext.web.server.IServiceResult;
+import org.eclipse.xtext.web.server.model.AbstractCachedService;
+import org.eclipse.xtext.web.server.model.DocumentSynchronizer;
+import org.eclipse.xtext.web.server.model.XtextWebDocument;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.collect.ImmutableList;
+
+import tools.refinery.language.web.xtext.server.ResponseHandlerException;
+
+public class PushWebDocument extends XtextWebDocument {
+        private static final Logger LOG = LoggerFactory.getLogger(PushWebDocument.class);
+
+        private final List<PrecomputationListener> precomputationListeners = new ArrayList<>();
+
+        private final Map<Class<?>, IServiceResult> precomputedServices = new HashMap<>();
+
+        public PushWebDocument(String resourceId, DocumentSynchronizer synchronizer) {
+                super(resourceId, synchronizer);
+                if (resourceId == null) {
+                        throw new IllegalArgumentException("resourceId must not be null");
+                }
+        }
+
+        public boolean addPrecomputationListener(PrecomputationListener listener) {
+                synchronized (precomputationListeners) {
+                        if (precomputationListeners.contains(listener)) {
+                                return false;
+                        }
+                        precomputationListeners.add(listener);
+                        listener.onSubscribeToPrecomputationEvents(getResourceId(), this);
+                        return true;
+                }
+        }
+
+        public boolean removePrecomputationListener(PrecomputationListener listener) {
+                synchronized (precomputationListeners) {
+                        return precomputationListeners.remove(listener);
+                }
+        }
+
+        public <T extends IServiceResult> void precomputeServiceResult(AbstractCachedService<T> service, String serviceName,
+                        CancelIndicator cancelIndicator, boolean logCacheMiss) {
+                var result = getCachedServiceResult(service, cancelIndicator, logCacheMiss);
+                if (result == null) {
+                        LOG.error("{} service returned null result", serviceName);
+                        return;
+                }
+                var serviceClass = service.getClass();
+                var previousResult = precomputedServices.get(serviceClass);
+                if (previousResult != null && previousResult.equals(result)) {
+                        return;
+                }
+                precomputedServices.put(serviceClass, result);
+                notifyPrecomputationListeners(serviceName, result);
+        }
+
+        private <T extends IServiceResult> void notifyPrecomputationListeners(String serviceName, T result) {
+                var resourceId = getResourceId();
+                var stateId = getStateId();
+                List<PrecomputationListener> copyOfListeners;
+                synchronized (precomputationListeners) {
+                        copyOfListeners = ImmutableList.copyOf(precomputationListeners);
+                }
+                var toRemove = new ArrayList<PrecomputationListener>();
+                for (var listener : copyOfListeners) {
+                        try {
+                                listener.onPrecomputedServiceResult(resourceId, stateId, serviceName, result);
+                        } catch (ResponseHandlerException e) {
+                                LOG.error("Delivering precomputation push message failed", e);
+                                toRemove.add(listener);
+                        }
+                }
+                if (!toRemove.isEmpty()) {
+                        synchronized (precomputationListeners) {
+                                precomputationListeners.removeAll(toRemove);
+                        }
+                }
+        }
+}
diff --git a/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentAccess.java b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentAccess.java
new file mode 100644
index 00000000..b3666a86
--- /dev/null
+++ b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentAccess.java
@@ -0,0 +1,68 @@
+package tools.refinery.language.web.xtext.server.push;
+
+import org.eclipse.xtext.service.OperationCanceledManager;
+import org.eclipse.xtext.util.CancelIndicator;
+import org.eclipse.xtext.util.concurrent.CancelableUnitOfWork;
+import org.eclipse.xtext.web.server.IServiceResult;
+import org.eclipse.xtext.web.server.model.AbstractCachedService;
+import org.eclipse.xtext.web.server.model.IXtextWebDocument;
+import org.eclipse.xtext.web.server.model.PrecomputedServiceRegistry;
+import org.eclipse.xtext.web.server.model.XtextWebDocument;
+import org.eclipse.xtext.web.server.model.XtextWebDocumentAccess;
+import org.eclipse.xtext.web.server.syntaxcoloring.HighlightingService;
+import org.eclipse.xtext.web.server.validation.ValidationService;
+
+import com.google.inject.Inject;
+
+public class PushWebDocumentAccess extends XtextWebDocumentAccess {
+
+        @Inject
+        private PrecomputedServiceRegistry preComputedServiceRegistry;
+
+        @Inject
+        private OperationCanceledManager operationCanceledManager;
+
+        private PushWebDocument pushDocument;
+
+        @Override
+        protected void init(XtextWebDocument document, String requiredStateId, boolean skipAsyncWork) {
+                super.init(document, requiredStateId, skipAsyncWork);
+                if (document instanceof PushWebDocument newPushDocument) {
+                        pushDocument = newPushDocument;
+                }
+        }
+
+        @Override
+        protected void performPrecomputation(CancelIndicator cancelIndicator) {
+                if (pushDocument == null) {
+                        super.performPrecomputation(cancelIndicator);
+                        return;
+                }
+                for (AbstractCachedService<? extends IServiceResult> service : preComputedServiceRegistry
+                                .getPrecomputedServices()) {
+                        operationCanceledManager.checkCanceled(cancelIndicator);
+                        precomputeServiceResult(service, false);
+                }
+        }
+        
+        protected <T extends IServiceResult> void precomputeServiceResult(AbstractCachedService<T> service, boolean logCacheMiss) {
+                var serviceName = getPrecomputedServiceName(service);
+                readOnly(new CancelableUnitOfWork<Void, IXtextWebDocument>() {
+                        @Override
+                        public java.lang.Void exec(IXtextWebDocument d, CancelIndicator cancelIndicator) throws Exception {
+                                pushDocument.precomputeServiceResult(service, serviceName, cancelIndicator, logCacheMiss);
+                                return null;
+                        }
+                });
+        }
+        
+        protected String getPrecomputedServiceName(AbstractCachedService<? extends IServiceResult> service) {
+                if (service instanceof ValidationService) {
+                        return "validate";
+                }
+                if (service instanceof HighlightingService) {
+                        return "highlight";
+                }
+                throw new IllegalArgumentException("Unknown precomputed service: " + service);
+        }
+}
diff --git a/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentProvider.java b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentProvider.java
new file mode 100644
index 00000000..fc45f74a
--- /dev/null
+++ b/language-web/src/main/java/tools/refinery/language/web/xtext/server/push/PushWebDocumentProvider.java
@@ -0,0 +1,33 @@
+package tools.refinery.language.web.xtext.server.push;
+
+import org.eclipse.xtext.web.server.IServiceContext;
+import org.eclipse.xtext.web.server.model.DocumentSynchronizer;
+import org.eclipse.xtext.web.server.model.IWebDocumentProvider;
+import org.eclipse.xtext.web.server.model.XtextWebDocument;
+
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import com.google.inject.Singleton;
+
+/**
+ * Based on
+ * {@link org.eclipse.xtext.web.server.model.IWebDocumentProvider.DefaultImpl}.
+ * 
+ * @author Kristóf Marussy
+ */
+@Singleton
+public class PushWebDocumentProvider implements IWebDocumentProvider {
+        @Inject
+        private Provider<DocumentSynchronizer> synchronizerProvider;
+
+        @Override
+        public XtextWebDocument get(String resourceId, IServiceContext serviceContext) {
+                if (resourceId == null) {
+                        return new XtextWebDocument(resourceId, synchronizerProvider.get());
+                } else {
+                        // We only need to send push messages if a resourceId is specified.
+                        return new PushWebDocument(resourceId,
+                                        serviceContext.getSession().get(DocumentSynchronizer.class, () -> this.synchronizerProvider.get()));
+                }
+        }
+}