Driven by the configurable {@code open-elements.content.refresh-cron} (default hourly). A tick is + * a no-op while the content pipeline is disabled or Meilisearch is still bootstrapping, and runs never + * overlap — if a refresh is still in progress when the next tick fires, that tick is skipped. A source + * that fails to index is logged and does not stop the others. + * + *
Only created when the Meilisearch stack is enabled (it depends on {@link ContentIndexer}).
+ */
+@Component
+@ConditionalOnProperty(prefix = "openelements.meilisearch", name = "enabled", havingValue = "true")
+public class ContentRefreshScheduler {
+
+ private static final Logger log = LoggerFactory.getLogger(ContentRefreshScheduler.class);
+
+ private final ContentSourceProperties properties;
+ private final ContentIndexer indexer;
+ private final SearchReadinessState readinessState;
+ private final AtomicBoolean running = new AtomicBoolean(false);
+
+ public ContentRefreshScheduler(ContentSourceProperties properties, ContentIndexer indexer,
+ SearchReadinessState readinessState) {
+ this.properties = properties;
+ this.indexer = indexer;
+ this.readinessState = readinessState;
+ }
+
+ /**
+ * Refreshes every enabled source once. Bound to the {@code refresh-cron} property (default hourly).
+ */
+ @Scheduled(cron = "${open-elements.content.refresh-cron:0 0 * * * *}")
+ public void refresh() {
+ if (!properties.enabled()) {
+ log.debug("Content pipeline disabled; skipping refresh");
+ return;
+ }
+ if (readinessState.isBootstrapping()) {
+ log.debug("Bootstrap in progress; skipping refresh");
+ return;
+ }
+ if (!running.compareAndSet(false, true)) {
+ log.info("Previous refresh still running; skipping this tick");
+ return;
+ }
+ try {
+ for (ContentSource source : properties.sources()) {
+ if (!source.enabled()) {
+ continue;
+ }
+ try {
+ IndexReport report = indexer.indexSource(source);
+ log.info("Refreshed source {}: {}", source.id(), report);
+ } catch (Exception e) {
+ log.warn("Refresh failed for source {}: {}", source.id(), e.toString());
+ }
+ }
+ } finally {
+ running.set(false);
+ }
+ }
+}
diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml
index 14043b6..1642ac2 100644
--- a/src/main/resources/application.yaml
+++ b/src/main/resources/application.yaml
@@ -6,7 +6,7 @@ spring:
# server depends on. The content MCP keeps no relational state of its own; this in-memory H2
# instance backs only the library's tables. Override with a persistent DB for production if the
# library's api-key/user data must survive restarts.
- url: ${SPRING_DATASOURCE_URL:jdbc:h2:mem:content-mcp;DB_CLOSE_DELAY=-1;MODE=PostgreSQL}
+ url: ${SPRING_DATASOURCE_URL:jdbc:h2:mem:content-mcp;DB_CLOSE_DELAY=-1;MODE=PostgreSQL;INIT=CREATE SCHEMA IF NOT EXISTS OE_SPRING_SERVICES}
username: ${SPRING_DATASOURCE_USERNAME:sa}
password: ${SPRING_DATASOURCE_PASSWORD:}
driver-class-name: org.h2.Driver
@@ -14,6 +14,13 @@ spring:
hibernate:
ddl-auto: update
open-in-view: false
+ properties:
+ hibernate:
+ # spring-services' entities live in the OE_SPRING_SERVICES schema; without this Hibernate
+ # tries to CREATE TABLE in a schema it never created (fails on a fresh H2). This makes it
+ # create entity-declared schemas first.
+ hbm2ddl:
+ create_namespaces: true
security:
oauth2:
resourceserver:
diff --git a/src/test/java/com/openelements/content/ContentRefreshSchedulerTest.java b/src/test/java/com/openelements/content/ContentRefreshSchedulerTest.java
new file mode 100644
index 0000000..df01fb9
--- /dev/null
+++ b/src/test/java/com/openelements/content/ContentRefreshSchedulerTest.java
@@ -0,0 +1,209 @@
+package com.openelements.content;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.openelements.spring.base.services.search.SearchReadinessState;
+import java.lang.reflect.Method;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.BiFunction;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.util.unit.DataSize;
+
+/**
+ * Unit tests for {@link ContentRefreshScheduler} using a real {@link ContentIndexer} driven by a
+ * test-double strategy and an in-memory store, plus a real {@link SearchReadinessState}. No mocks or
+ * live Meilisearch; non-overlap is verified deterministically via re-entrancy rather than threads.
+ */
+@DisplayName("Content refresh scheduler")
+class ContentRefreshSchedulerTest {
+
+ private final StubStrategy strategy = new StubStrategy();
+ private final InMemoryContentIndexStore store = new InMemoryContentIndexStore();
+ private final ContentIndexer indexer =
+ new ContentIndexer(new SourceStrategyRegistry(List.of(strategy)), store);
+ private final SearchReadinessState readiness = new SearchReadinessState();
+
+ @BeforeEach
+ void markBootstrapComplete() {
+ // A fresh SearchReadinessState reports isBootstrapping()==true until bootstrap finishes;
+ // simulate a completed startup bootstrap so scheduled refreshes are allowed to run.
+ readiness.markBootstrappingFinished();
+ }
+
+ private static ContentSource source(String id, boolean enabled) {
+ return new ContentSource(
+ id, SourceType.WEBSITE, "https://ex.com", List.of(), List.of("/**"), List.of(), "article", List.of(), enabled);
+ }
+
+ private static ContentSourceProperties properties(boolean enabled, ContentSource... sources) {
+ return new ContentSourceProperties(
+ enabled, null, "UA", 2.0, Duration.ofSeconds(10), DataSize.ofMegabytes(5), List.of(sources));
+ }
+
+ private ContentRefreshScheduler scheduler(ContentSourceProperties properties) {
+ return new ContentRefreshScheduler(properties, indexer, readiness);
+ }
+
+ private static ContentDocument document(String source, String url, String lastmod) {
+ return new ContentDocument(
+ ContentDocument.id(source, url), source, "en", url, "T", "E", "body", "a",
+ List.of(), "2026-01-01", lastmod, null);
+ }
+
+ @Test
+ @DisplayName("each enabled source is indexed on a tick")
+ void runsEachEnabledSource() {
+ scheduler(properties(true, source("a", true), source("b", true))).refresh();
+
+ assertThat(strategy.discoveredSources).containsExactly("a", "b");
+ }
+
+ @Test
+ @DisplayName("a disabled source is skipped")
+ void disabledSourceIsSkipped() {
+ scheduler(properties(true, source("a", true), source("b", false))).refresh();
+
+ assertThat(strategy.discoveredSources).containsExactly("a");
+ }
+
+ @Test
+ @DisplayName("refresh is skipped while bootstrapping")
+ void skipsWhileBootstrapping() {
+ readiness.markBootstrappingStarted();
+
+ scheduler(properties(true, source("a", true))).refresh();
+
+ assertThat(strategy.discoveredSources).isEmpty();
+ }
+
+ @Test
+ @DisplayName("refresh does nothing when the pipeline is globally disabled")
+ void skipsWhenGloballyDisabled() {
+ scheduler(properties(false, source("a", true))).refresh();
+
+ assertThat(strategy.discoveredSources).isEmpty();
+ }
+
+ @Test
+ @DisplayName("a re-entrant tick does not overlap a running refresh")
+ void nonOverlappingRuns() {
+ ContentRefreshScheduler scheduler = scheduler(properties(true, source("a", true), source("b", true)));
+ strategy.reentrantOnce = scheduler::refresh; // fired during the first discover of the outer run
+
+ scheduler.refresh();
+
+ // The re-entrant call is skipped, so each source is discovered exactly once.
+ assertThat(strategy.discoveredSources).containsExactly("a", "b");
+ }
+
+ @Test
+ @DisplayName("one source failing does not stop the others")
+ void oneSourceFailingDoesNotStopOthers() {
+ strategy.throwOnDiscover.add("a");
+
+ scheduler(properties(true, source("a", true), source("b", true))).refresh();
+
+ assertThat(strategy.discoveredSources).containsExactly("a", "b");
+ }
+
+ @Test
+ @DisplayName("the cron expression is externalized with an hourly default")
+ void cronIsExternallyConfigurable() throws Exception {
+ Method refresh = ContentRefreshScheduler.class.getMethod("refresh");
+ Scheduled scheduled = refresh.getAnnotation(Scheduled.class);
+
+ assertThat(scheduled).isNotNull();
+ assertThat(scheduled.cron()).isEqualTo("${open-elements.content.refresh-cron:0 0 * * * *}");
+ }
+
+ @Test
+ @DisplayName("a new page is added to the index on refresh")
+ void newPageIsAdded() {
+ strategy.itemsBySource.put("a", List.of(new DiscoveredItem("https://ex.com/a", "L")));
+
+ scheduler(properties(true, source("a", true))).refresh();
+
+ assertThat(store.loadState("a")).containsKey(ContentDocument.id("a", "https://ex.com/a"));
+ }
+
+ @Test
+ @DisplayName("a vanished page is deleted from the index on refresh")
+ void deletedPageIsRemoved() {
+ store.upsert(List.of(document("a", "https://ex.com/gone", "L").toMap()));
+ strategy.itemsBySource.put("a", List.of()); // no longer discovered
+
+ scheduler(properties(true, source("a", true))).refresh();
+
+ assertThat(store.loadState("a")).isEmpty();
+ }
+
+ /** Test-double strategy: records discovered sources, can throw or fire a one-shot re-entrant action. */
+ private static final class StubStrategy implements ContentSourceStrategy {
+ private final List