Restore terminology and model resolver caches

common/src/main/java/org/opencds/cqf/common/config/FhirServerConfig.java

@@ -2,10 +2,22 @@
 
 import java.lang.reflect.InvocationTargetException;
 import java.sql.Driver;
+import java.time.Duration;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.github.benmanes.caffeine.cache.Cache;
+import com.github.benmanes.caffeine.cache.Caffeine;
 
 import org.apache.commons.dbcp2.BasicDataSource;
+import org.cqframework.cql.cql2elm.model.Model;
+import org.cqframework.cql.elm.execution.Library;
+import org.cqframework.cql.elm.execution.VersionedIdentifier;
+import org.hl7.fhir.instance.model.api.IIdType;
 import org.opencds.cqf.cds.providers.ProviderConfiguration;
 import org.opencds.cqf.cql.engine.fhir.searchparam.SearchParameterResolver;
+import org.opencds.cqf.cql.engine.runtime.Code;
 import org.springframework.beans.factory.annotation.Autowire;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
@@ -14,8 +26,12 @@
 
 import ca.uhn.fhir.context.FhirContext;
 import ca.uhn.fhir.jpa.api.config.DaoConfig;
+import ca.uhn.fhir.jpa.cache.IResourceChangeEvent;
+import ca.uhn.fhir.jpa.cache.IResourceChangeListener;
+import ca.uhn.fhir.jpa.cache.IResourceChangeListenerRegistry;
 import ca.uhn.fhir.jpa.model.config.PartitionSettings;
 import ca.uhn.fhir.jpa.model.entity.ModelConfig;
+import ca.uhn.fhir.jpa.searchparam.SearchParameterMap;
 import ca.uhn.fhir.rest.server.interceptor.LoggingInterceptor;
 import ca.uhn.fhir.rest.server.interceptor.ResponseHighlighterInterceptor;
 
@@ -143,4 +159,43 @@ public ProviderConfiguration providerConfiguration() {
     public SearchParameterResolver searchParameterResolver(FhirContext fhirContext) {
         return new SearchParameterResolver(fhirContext);
     }
+
+    @Bean
+    public IResourceChangeListener valueSetChangeListener(IResourceChangeListenerRegistry resourceChangeListenerRegistry, Map<String, Iterable<Code>> terminologyCache) {
+        IResourceChangeListener listener = new IResourceChangeListener(){
+
+            @Override
+            public void handleInit(Collection<IIdType> theResourceIds) {
+                // Intentionally empty
+            }
+
+            // TODO: Selectively clear by url. Requires a lookup on the resource
+            @Override
+            public void handleChange(IResourceChangeEvent theResourceChangeEvent) {
+                terminologyCache.clear();
+            }
+
+        };
+
+        resourceChangeListenerRegistry.registerResourceResourceChangeListener("ValueSet", SearchParameterMap.newSynchronous(), listener, 1000);
+
+        return listener;
+    }
+
+    @Bean
+    public Map<String, Iterable<Code>> terminologyCache() {
+        Cache<String, Iterable<Code>> cache = Caffeine.newBuilder().maximumSize(100).expireAfterAccess(Duration.ofMinutes(60)).build();
+        return cache.asMap();
+    }
+
+
+    @Bean(name="globalModelCache")
+	Map<VersionedIdentifier, Model> globalModelCache() {
+		return new ConcurrentHashMap<VersionedIdentifier, Model>();
+	}
+
+	@Bean(name="globalLibraryCache") 
+	Map<org.cqframework.cql.elm.execution.VersionedIdentifier, Library> globalLibraryCache() {
+		return new ConcurrentHashMap<org.cqframework.cql.elm.execution.VersionedIdentifier, Library>();
+	} 
 }

common/src/main/java/org/opencds/cqf/common/providers/CacheAwareTerminologyProvider.java

@@ -0,0 +1,56 @@
+package org.opencds.cqf.common.providers;
+
+import java.util.Map;
+import org.opencds.cqf.cql.engine.runtime.Code;
+import org.opencds.cqf.cql.engine.terminology.CodeSystemInfo;
+import org.opencds.cqf.cql.engine.terminology.TerminologyProvider;
+import org.opencds.cqf.cql.engine.terminology.ValueSetInfo;
+
+public class CacheAwareTerminologyProvider implements TerminologyProvider {
+
+    private TerminologyProvider innerTerminologyProvider;
+
+    private Map<String, Iterable<Code>> globalCodeCacheByUrl;
+
+    public CacheAwareTerminologyProvider(Map<String, Iterable<Code>> globalCodeCacheByUrl, TerminologyProvider innerTerminologyProvider) {
+        this.globalCodeCacheByUrl = globalCodeCacheByUrl;
+        this.innerTerminologyProvider = innerTerminologyProvider;
+    }
+
+    @Override
+    public boolean in(Code code, ValueSetInfo valueSet) {
+        Iterable<Code> codes = this.expand(valueSet);
+        if (codes == null) {
+            return false;
+        }
+
+        for (Code c : codes) {
+            if (c.equivalent(code)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public Iterable<Code> expand(ValueSetInfo valueSet) {
+        if (this.globalCodeCacheByUrl.containsKey(valueSet.getId())) {
+            return this.globalCodeCacheByUrl.get(valueSet.getId());
+        }
+
+        Iterable<Code> codes = this.innerTerminologyProvider.expand(valueSet);
+
+        if (codes != null) {
+            this.globalCodeCacheByUrl.put(valueSet.getId(), codes);
+        }
+
+        return codes;
+    }
+
+    @Override
+    public Code lookup(Code code, CodeSystemInfo codeSystem) {
+        return this.innerTerminologyProvider.lookup(code, codeSystem);
+    }
+
+}

common/src/main/java/org/opencds/cqf/common/providers/InMemoryLibraryResourceProvider.java

@@ -7,6 +7,8 @@
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
+import ca.uhn.fhir.cql.common.provider.LibraryResolutionProvider;
+
 public class InMemoryLibraryResourceProvider<LibraryType> implements LibraryResolutionProvider<LibraryType> {
 
     private Map<String, LibraryType> libraries = new HashMap<>();

common/src/main/java/org/opencds/cqf/common/providers/LibrarySourceProvider.java → common/src/main/java/org/opencds/cqf/common/providers/LibraryContentProvider.java

@@ -6,20 +6,23 @@
 
 import org.cqframework.cql.cql2elm.FhirLibrarySourceProvider;
 import org.hl7.elm.r1.VersionedIdentifier;
+import org.opencds.cqf.cql.evaluator.cql2elm.content.LibraryContentType;
+
+import ca.uhn.fhir.cql.common.provider.LibraryResolutionProvider;
 
 /**
  * Created by Christopher on 1/12/2017.
  */
-public class LibrarySourceProvider<LibraryType, AttachmentType>
-        implements org.cqframework.cql.cql2elm.LibrarySourceProvider {
+public class LibraryContentProvider<LibraryType, AttachmentType>
+        implements org.opencds.cqf.cql.evaluator.cql2elm.content.LibraryContentProvider {
 
     private FhirLibrarySourceProvider innerProvider;
     private LibraryResolutionProvider<LibraryType> provider;
     private Function<LibraryType, Iterable<AttachmentType>> getAttachments;
     private Function<AttachmentType, String> getContentType;
     private Function<AttachmentType, byte[]> getContent;
 
-    public LibrarySourceProvider(LibraryResolutionProvider<LibraryType> provider,
+    public LibraryContentProvider(LibraryResolutionProvider<LibraryType> provider,
             Function<LibraryType, Iterable<AttachmentType>> getAttachments,
             Function<AttachmentType, String> getContentType, Function<AttachmentType, byte[]> getContent) {
 
@@ -46,4 +49,14 @@ public InputStream getLibrarySource(VersionedIdentifier versionedIdentifier) {
 
         return this.innerProvider.getLibrarySource(versionedIdentifier);
     }
+
+    @Override
+    public InputStream getLibraryContent(VersionedIdentifier libraryIdentifier, LibraryContentType libraryContentType) {
+
+        if (libraryContentType == LibraryContentType.CQL) {
+            return this.getLibrarySource(libraryIdentifier);
+        }
+
+        return null;
+    }
 }