Merge branch 'fix-analytic-tests' of github.com:gchq/stroom into gh-4209_support_and_in_eval

Author: stroomdev66

stroom-app/src/test/java/stroom/analytics/AbstractAnalyticsTest.java

@@ -16,6 +16,7 @@
 
 package stroom.analytics;
 
+import stroom.analytics.impl.AnalyticHelper;
 import stroom.analytics.rule.impl.AnalyticRuleStore;
 import stroom.analytics.shared.AnalyticNotificationConfig;
 import stroom.analytics.shared.AnalyticNotificationDestinationType;
@@ -82,6 +83,8 @@ class AbstractAnalyticsTest extends StroomIntegrationTest {
     private AnalyticRuleStore analyticRuleStore;
     @Inject
     private AnalyticsDataSetup analyticsDataSetup;
+    @Inject
+    private AnalyticHelper analyticHelper;
 
     @BeforeEach
     final void setup() {
@@ -107,6 +110,8 @@ final void setup() {
         if (analyticsDataSetup.getDetections() == null) {
             throw new NullPointerException("Detections missing");
         }
+
+        assertThat(analyticHelper.getRules().size()).isZero();
     }
 
     @Override
@@ -125,6 +130,10 @@ protected DocRef writeRule(final AnalyticRuleDoc sample) {
                 .analyticNotificationConfig(sample.getAnalyticNotificationConfig())
                 .build();
         analyticRuleStore.writeDocument(analyticRuleDoc);
+
+        assertThat(analyticHelper.getRules().size()).isOne();
+        assertThat(analyticHelper.getRules().getFirst().getUuid()).isEqualTo(alertRuleDocRef.getUuid());
+
         return alertRuleDocRef;
     }
 

stroom-app/src/test/java/stroom/analytics/AnalyticsDataSetup.java

@@ -208,8 +208,6 @@ public void addNewData(final LocalDateTime localDateTime) {
                     .typeName(StreamTypeNames.RAW_EVENTS)
                     .build();
             try (final Target target = store.openTarget(metaProperties)) {
-                final Meta meta = target.getMeta();
-
                 try (final OutputStreamProvider outputStreamProvider = target.next()) {
                     try (final InputStream inputStream =
                             new ByteArrayInputStream(newData.getBytes(StandardCharsets.UTF_8));

stroom-index/stroom-index-impl/src/main/java/stroom/index/impl/IndexFieldCacheImpl.java

@@ -22,7 +22,7 @@
 import stroom.datasource.api.v2.IndexField;
 import stroom.docref.DocRef;
 import stroom.query.common.v2.IndexFieldCache;
-import stroom.query.common.v2.IndexFieldProvider;
+import stroom.query.common.v2.IndexFieldProviders;
 import stroom.security.api.SecurityContext;
 import stroom.security.shared.DocumentPermissionNames;
 import stroom.util.logging.LogUtil;
@@ -33,44 +33,33 @@
 import jakarta.inject.Provider;
 import jakarta.inject.Singleton;
 
-import java.util.HashMap;
-import java.util.Map;
 import java.util.Objects;
-import java.util.Set;
 
 @Singleton
 public class IndexFieldCacheImpl implements IndexFieldCache, Clearable {
 
     private static final String CACHE_NAME = "Index Field Cache";
 
-    private final Map<String, IndexFieldProvider> providers = new HashMap<>();
+    private final IndexFieldProviders indexFieldProviders;
     private final LoadingStroomCache<Key, IndexField> cache;
     private final SecurityContext securityContext;
 
     @Inject
     IndexFieldCacheImpl(final CacheManager cacheManager,
                         final Provider<IndexConfig> indexConfigProvider,
-                        final Set<IndexFieldProvider> indexFieldProviders,
+                        final IndexFieldProviders indexFieldProviders,
                         final SecurityContext securityContext) {
+        this.indexFieldProviders = indexFieldProviders;
         this.securityContext = securityContext;
-        for (final IndexFieldProvider provider : indexFieldProviders) {
-            providers.put(provider.getType(), provider);
-        }
         cache = cacheManager.createLoadingCache(
                 CACHE_NAME,
                 () -> indexConfigProvider.get().getIndexFieldCache(),
                 this::create);
     }
 
     private IndexField create(final Key key) {
-        return securityContext.asProcessingUserResult(() -> {
-            final IndexFieldProvider provider = providers.get(key.docRef.getType());
-            if (provider == null) {
-                throw new NullPointerException("No provider can be found for: " + key.docRef.getType());
-            }
-
-            return provider.getIndexField(key.docRef, key.fieldName);
-        });
+        return securityContext.asProcessingUserResult(() ->
+                indexFieldProviders.getIndexField(key.docRef, key.fieldName));
     }
 
     @Override

stroom-index/stroom-index-impl/src/main/java/stroom/index/impl/IndexFieldProvidersImpl.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2017 Crown Copyright
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package stroom.index.impl;
+
+import stroom.datasource.api.v2.IndexField;
+import stroom.docref.DocRef;
+import stroom.query.common.v2.IndexFieldProvider;
+import stroom.query.common.v2.IndexFieldProviders;
+import stroom.security.api.SecurityContext;
+import stroom.security.shared.DocumentPermissionNames;
+import stroom.util.logging.LogUtil;
+import stroom.util.shared.PermissionException;
+
+import jakarta.inject.Inject;
+import jakarta.inject.Singleton;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+@Singleton
+public class IndexFieldProvidersImpl implements IndexFieldProviders {
+
+    private final Map<String, IndexFieldProvider> providers = new HashMap<>();
+    private final SecurityContext securityContext;
+
+    @Inject
+    IndexFieldProvidersImpl(final Set<IndexFieldProvider> indexFieldProviders,
+                            final SecurityContext securityContext) {
+        this.securityContext = securityContext;
+        for (final IndexFieldProvider provider : indexFieldProviders) {
+            providers.put(provider.getType(), provider);
+        }
+    }
+
+    @Override
+    public IndexField getIndexField(final DocRef docRef, final String fieldName) {
+        Objects.requireNonNull(docRef, "Null DocRef supplied");
+        Objects.requireNonNull(docRef.getType(), "Null DocRef type supplied");
+        Objects.requireNonNull(fieldName, "Null field name supplied");
+
+        if (!securityContext.hasDocumentPermission(docRef, DocumentPermissionNames.USE)) {
+            throw new PermissionException(
+                    securityContext.getUserIdentityForAudit(),
+                    LogUtil.message("You are not authorised to read {}", docRef));
+        }
+        final IndexFieldProvider provider = providers.get(docRef.getType());
+        if (provider == null) {
+            throw new NullPointerException("No provider can be found for: " + docRef.getType());
+        }
+
+        return provider.getIndexField(docRef, fieldName);
+    }
+}

stroom-index/stroom-index-impl/src/main/java/stroom/index/impl/IndexModule.java

@@ -23,6 +23,7 @@
 import stroom.job.api.ScheduledJobsBinder;
 import stroom.lifecycle.api.LifecycleBinder;
 import stroom.query.common.v2.IndexFieldCache;
+import stroom.query.common.v2.IndexFieldProviders;
 import stroom.searchable.api.Searchable;
 import stroom.util.RunnableWrapper;
 import stroom.util.entityevent.EntityEvent;
@@ -45,6 +46,7 @@ protected void configure() {
 
         bind(IndexShardWriterCache.class).to(IndexShardWriterCacheImpl.class);
         bind(LuceneIndexDocCache.class).to(LuceneIndexDocCacheImpl.class);
+        bind(IndexFieldProviders.class).to(IndexFieldProvidersImpl.class);
         bind(IndexFieldCache.class).to(IndexFieldCacheImpl.class);
         bind(IndexStore.class).to(IndexStoreImpl.class);
         bind(IndexVolumeService.class).to(IndexVolumeServiceImpl.class);

stroom-index/stroom-index-mock/src/main/java/stroom/index/mock/MockIndexModule.java

@@ -20,6 +20,7 @@
 import stroom.importexport.api.ImportExportActionHandler;
 import stroom.index.impl.IndexElementModule;
 import stroom.index.impl.IndexFieldCacheImpl;
+import stroom.index.impl.IndexFieldProvidersImpl;
 import stroom.index.impl.IndexFieldService;
 import stroom.index.impl.IndexShardService;
 import stroom.index.impl.IndexShardWriterCache;
@@ -33,6 +34,7 @@
 import stroom.index.shared.LuceneIndexDoc;
 import stroom.query.common.v2.IndexFieldCache;
 import stroom.query.common.v2.IndexFieldProvider;
+import stroom.query.common.v2.IndexFieldProviders;
 import stroom.util.guice.GuiceUtil;
 
 import com.google.inject.AbstractModule;
@@ -45,6 +47,7 @@ protected void configure() {
 
         bind(IndexShardWriterCache.class).to(MockIndexShardWriterCache.class);
         bind(LuceneIndexDocCache.class).to(LuceneIndexDocCacheImpl.class);
+        bind(IndexFieldProviders.class).to(IndexFieldProvidersImpl.class);
         bind(IndexFieldCache.class).to(IndexFieldCacheImpl.class);
         bind(IndexStore.class).to(IndexStoreImpl.class);
         bind(IndexVolumeService.class).to(MockIndexVolumeService.class);

stroom-query/stroom-query-common/src/main/java/stroom/query/common/v2/IndexFieldProviders.java

@@ -0,0 +1,9 @@
+package stroom.query.common.v2;
+
+import stroom.datasource.api.v2.IndexField;
+import stroom.docref.DocRef;
+
+public interface IndexFieldProviders {
+
+    IndexField getIndexField(DocRef docRef, String fieldName);
+}

stroom-view/stroom-view-impl/src/main/java/stroom/view/impl/ViewSearchProvider.java

@@ -11,8 +11,8 @@
 import stroom.query.api.v2.SearchRequest;
 import stroom.query.api.v2.TableSettings;
 import stroom.query.common.v2.DataSourceProviderRegistry;
-import stroom.query.common.v2.IndexFieldCache;
 import stroom.query.common.v2.IndexFieldProvider;
+import stroom.query.common.v2.IndexFieldProviders;
 import stroom.query.common.v2.ResultStore;
 import stroom.query.common.v2.SearchProvider;
 import stroom.query.common.v2.StoreFactoryRegistry;
@@ -40,19 +40,19 @@ public class ViewSearchProvider implements SearchProvider, IndexFieldProvider {
     private final Provider<StoreFactoryRegistry> storeFactoryRegistryProvider;
     private final SecurityContext securityContext;
     private final Provider<DataSourceProviderRegistry> dataSourceProviderRegistry;
-    private final IndexFieldCache indexFieldCache;
+    private final IndexFieldProviders indexFieldProviders;
 
     @Inject
     public ViewSearchProvider(final ViewStore viewStore,
                               final Provider<StoreFactoryRegistry> storeFactoryRegistryProvider,
                               final SecurityContext securityContext,
                               final Provider<DataSourceProviderRegistry> dataSourceProviderRegistry,
-                              final IndexFieldCache indexFieldCache) {
+                              final IndexFieldProviders indexFieldProviders) {
         this.viewStore = viewStore;
         this.storeFactoryRegistryProvider = storeFactoryRegistryProvider;
         this.securityContext = securityContext;
         this.dataSourceProviderRegistry = dataSourceProviderRegistry;
-        this.indexFieldCache = indexFieldCache;
+        this.indexFieldProviders = indexFieldProviders;
     }
 
     private DocRef getReferencedDataSource(final DocRef viewDocRef) {
@@ -91,7 +91,7 @@ public ResultPage<QueryField> getFieldInfo(final FindFieldInfoCriteria criteria)
     public IndexField getIndexField(final DocRef viewDocRef, final String fieldName) {
         final DocRef docRef = getReferencedDataSource(viewDocRef);
         if (docRef != null) {
-            return indexFieldCache.get(docRef, fieldName);
+            return indexFieldProviders.getIndexField(docRef, fieldName);
         }
         return null;
     }