Start services according to config

alephium · May 2, 2024 · e9ab6dc · e9ab6dc
1 parent f4d2ec9
commit e9ab6dc
Show file tree

Hide file tree

Showing 2 changed files with 23 additions and 20 deletions.
diff --git a/app/src/main/resources/application.conf b/app/src/main/resources/application.conf
@@ -24,26 +24,30 @@ explorer {
 
       mempool-sync = {
         enable = true,
+        enable = ${?EXPLORER_MEMPOOL_SYNC_ENABLE}
         # Sync interval for MempoolSyncService
         sync-period = 5 seconds
         sync-period = ${?EXPLORER_SYNC_PERIOD}
       }
 
       token-supply = {
         enable = true,
+        enable = ${?EXPLORER_TOKEN_SUPPLY_ENABLE}
         # Schedule time for TokenSupplyService
         schedule-time = "02:00"
         schedule-time = ${?EXPLORER_TOKEN_SUPPLY_SERVICE_SCHEDULE_TIME}
       }
 
       hashrate = {
+        enable = ${?EXPLORER_HASHRATE_ENABLE}
         enable = true,
         # Sync interval for HashRateService
         sync-period = 1 hours
         sync-period = ${?EXPLORER_HASH_RATE_SERVICE_SYNC_PERIOD}
       }
 
       tx-history = {
+        enable = ${?EXPLORER_TX_HISTORY_ENABLE}
         enable = true,
         # Sync interval for TransactionHistoryService
         sync-period = 15 minutes

diff --git a/app/src/main/scala/org/alephium/explorer/SyncServices.scala b/app/src/main/scala/org/alephium/explorer/SyncServices.scala
@@ -16,11 +16,8 @@
 
 package org.alephium.explorer
 
-import java.time.LocalTime
-
 import scala.collection.immutable.ArraySeq
 import scala.concurrent.{ExecutionContext, Future}
-import scala.concurrent.duration._
 import scala.util.{Failure, Success, Try}
 
 import com.typesafe.scalalogging.StrictLogging
@@ -62,11 +59,7 @@ object SyncServices extends StrictLogging {
         ) flatMap { peers =>
           startSyncServices(
             peers = peers,
-            syncPeriod = config.services.blockflowSync.syncPeriod,
-            tokenSupplyServiceScheduleTime = config.services.tokenSupply.scheduleTime,
-            hashRateServiceSyncPeriod = config.services.hashrate.syncPeriod,
-            finalizerServiceSyncPeriod = config.services.finalizer.syncPeriod,
-            transactionHistoryServiceSyncPeriod = config.services.txHistory.syncPeriod
+            config = config.services
           )
         }
     }
@@ -75,11 +68,7 @@ object SyncServices extends StrictLogging {
   // scalastyle:off
   def startSyncServices(
       peers: ArraySeq[Uri],
-      syncPeriod: FiniteDuration,
-      tokenSupplyServiceScheduleTime: LocalTime,
-      hashRateServiceSyncPeriod: FiniteDuration,
-      finalizerServiceSyncPeriod: FiniteDuration,
-      transactionHistoryServiceSyncPeriod: FiniteDuration
+      config: ExplorerConfig.Services
   )(implicit
       scheduler: Scheduler,
       ec: ExecutionContext,
@@ -93,13 +82,23 @@ object SyncServices extends StrictLogging {
         Future
           .sequence(
             ArraySeq(
-              BlockFlowSyncService.start(peers, syncPeriod),
-              MempoolSyncService.start(peers, syncPeriod),
-              TokenSupplyService.start(tokenSupplyServiceScheduleTime),
-              HashrateService.start(hashRateServiceSyncPeriod),
-              FinalizerService.start(finalizerServiceSyncPeriod),
-              TransactionHistoryService.start(transactionHistoryServiceSyncPeriod)
-            )
+              BlockFlowSyncService.start(peers, config.blockflowSync.syncPeriod),
+              FinalizerService.start(config.finalizer.syncPeriod)
+            ) ++
+              ArraySeq(
+                Option.when(config.mempoolSync.enable)(
+                  MempoolSyncService.start(peers, config.mempoolSync.syncPeriod)
+                ),
+                Option.when(config.tokenSupply.enable)(
+                  TokenSupplyService.start(config.tokenSupply.scheduleTime)
+                ),
+                Option.when(config.hashrate.enable)(
+                  HashrateService.start(config.hashrate.syncPeriod)
+                ),
+                Option.when(config.txHistory.enable)(
+                  TransactionHistoryService.start(config.txHistory.syncPeriod)
+                )
+              ).flatten
           )
           .onComplete {
             case Failure(error) =>