Merge pull request #25 from PySport/feat/add-cli-flag-to-disable-events

Add flag to CLI to disable EventBus

Author: koenvo

ingestify/application/loader.py

@@ -35,11 +35,8 @@ def collect_and_run(
         provider: Optional[str] = None,
         source: Optional[str] = None,
     ):
-        # First collect all selectors, before discovering datasets
-        selectors = {}
+        ingestion_plans = []
         for ingestion_plan in self.ingestion_plans:
-            logger.info(f"Determining selectors for {ingestion_plan}")
-
             if provider is not None:
                 if ingestion_plan.source.provider != provider:
                     logger.info(
@@ -54,6 +51,13 @@ def collect_and_run(
                     )
                     continue
 
+            ingestion_plans.append(ingestion_plan)
+
+        # First collect all selectors, before discovering datasets
+        selectors = {}
+        for ingestion_plan in ingestion_plans:
+            logger.info(f"Determining selectors for {ingestion_plan}")
+
             static_selectors = [
                 selector
                 for selector in ingestion_plan.selectors

ingestify/cmdline.py

@@ -88,16 +88,25 @@ def cli():
     help="Source - only run tasks for a single source",
     type=str,
 )
+@click.option(
+    "--disable-events",
+    "disable_events",
+    required=False,
+    help="Disable events - disable all event handlers",
+    is_flag=True,
+    type=bool,
+)
 def run(
     config_file: str,
     bucket: Optional[str],
     dry_run: Optional[bool],
     provider: Optional[str],
     source: Optional[str],
     debug: Optional[bool],
+    disable_events: Optional[bool],
 ):
     try:
-        engine = get_engine(config_file, bucket)
+        engine = get_engine(config_file, bucket, disable_events=disable_events)
     except ConfigurationError as e:
         if debug:
             raise

ingestify/domain/models/ingestion/ingestion_job.py

@@ -218,7 +218,7 @@ def execute(
         # Process all items in batches. Yield a IngestionJobSummary per batch
 
         logger.info("Finding metadata")
-        with ingestion_job_summary.record_timing("get_dataset_collection"):
+        with ingestion_job_summary.record_timing("get_dataset_collection_metadata"):
             dataset_collection_metadata = store.get_dataset_collection(
                 dataset_type=self.ingestion_plan.dataset_type,
                 provider=self.ingestion_plan.source.provider,
@@ -232,6 +232,7 @@ def execute(
         # 1. The discover_datasets returns a list, and the entire list can be processed at once
         # 2. The discover_datasets returns an iterator of batches, in this case we need to process each batch
         try:
+            logger.info(f"Finding datasets for selector={self.selector}")
             with ingestion_job_summary.record_timing("find_datasets"):
                 dataset_resources = self.ingestion_plan.source.find_datasets(
                     dataset_type=self.ingestion_plan.dataset_type,
@@ -249,6 +250,8 @@ def execute(
             yield ingestion_job_summary
             return
 
+        logger.info("Starting tasks")
+
         finish_task_timer = ingestion_job_summary.start_timing("tasks")
 
         while True:
@@ -273,13 +276,16 @@ def execute(
                 for dataset_resource in batch
             ]
 
-            # Load all available datasets based on the discovered dataset identifiers
-            dataset_collection = store.get_dataset_collection(
-                dataset_type=self.ingestion_plan.dataset_type,
-                # Assume all DatasetResources share the same provider
-                provider=batch[0].provider,
-                selector=dataset_identifiers,
-            )
+            logger.info(f"Searching for existing Datasets for DatasetResources")
+
+            with ingestion_job_summary.record_timing("get_dataset_collection"):
+                # Load all available datasets based on the discovered dataset identifiers
+                dataset_collection = store.get_dataset_collection(
+                    dataset_type=self.ingestion_plan.dataset_type,
+                    # Assume all DatasetResources share the same provider
+                    provider=batch[0].provider,
+                    selector=dataset_identifiers,
+                )
 
             skipped_datasets = 0
 

ingestify/domain/models/ingestion/ingestion_job_summary.py

@@ -66,7 +66,7 @@ def increase_skipped_datasets(self, skipped_datasets: int):
         self.skipped_datasets += skipped_datasets
 
     def task_count(self):
-        return len(self.task_summaries)
+        return len(self.task_summaries) + self.skipped_datasets
 
     def _set_ended(self):
         self.failed_tasks = len(
@@ -106,22 +106,22 @@ def output_report(self):
             f"\nIngestionJobSummary {self.state.value} in {format_duration(self.duration)}"
         )
         print("********************************")
-        print(f"*  - IngestionPlan:")
-        print(f"*        Source: {self.source_name}")
-        print(f"*        Provider: {self.provider}")
-        print(f"*        DatasetType: {self.dataset_type}")
-        print(f"*  - Selector: {self.selector}")
-        print(f"*  - Timings: ")
+        print(f" - IngestionPlan:")
+        print(f"       Source: {self.source_name}")
+        print(f"       Provider: {self.provider}")
+        print(f"       DatasetType: {self.dataset_type}")
+        print(f" - Selector: {self.selector}")
+        print(f" - Timings: ")
         for timing in self.timings:
-            print(f"*    - {timing.name}: {format_duration(timing.duration)}")
+            print(f"   - {timing.name}: {format_duration(timing.duration)}")
         print(
-            f"*  - Tasks: {len(self.task_summaries)} - {(len(self.task_summaries) / self.duration.total_seconds()):.1f} tasks/sec"
+            f" - Tasks: {len(self.task_summaries)} - {(len(self.task_summaries) / self.duration.total_seconds()):.1f} tasks/sec"
         )
 
-        print(f"*    - Failed tasks: {self.failed_tasks}")
-        print(f"*    - Successful tasks: {self.successful_tasks}")
-        print(f"*    - Successful ignored tasks: {self.ignored_successful_tasks}")
-        print(f"*    - Skipped datasets: {self.skipped_datasets}")
+        print(f"   - Failed tasks: {self.failed_tasks}")
+        print(f"   - Successful tasks: {self.successful_tasks}")
+        print(f"   - Successful ignored tasks: {self.ignored_successful_tasks}")
+        print(f"   - Skipped datasets: {self.skipped_datasets}")
         print("********************************")
 
     def __enter__(self):

ingestify/infra/store/dataset/sqlalchemy/repository.py

@@ -1,4 +1,5 @@
 import itertools
+import logging
 import uuid
 from typing import Optional, Union, List
 
@@ -17,7 +18,7 @@
 )
 from sqlalchemy.engine import make_url
 from sqlalchemy.exc import NoSuchModuleError
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Session, Query
 
 from ingestify.domain import File, Revision
 from ingestify.domain.models import (
@@ -42,6 +43,8 @@
     task_summary_table,
 )
 
+logger = logging.getLogger(__name__)
+
 
 def parse_value(v):
     try:
@@ -199,9 +202,6 @@ def _filter_query(
             if not selectors:
                 raise ValueError("Selectors must contain at least one item")
 
-            attribute_keys = selectors[
-                0
-            ].filtered_attributes.keys()  # Assume all selectors have the same keys
             attribute_sets = {
                 tuple(selector.filtered_attributes.items()) for selector in selectors
             }
@@ -303,6 +303,12 @@ def load_datasets(self, dataset_ids: list[str]) -> list[Dataset]:
             )
         return datasets
 
+    def _debug_query(self, q: Query):
+        text_ = q.statement.compile(
+            compile_kwargs={"literal_binds": True}, dialect=self.session.bind.dialect
+        )
+        logger.debug(f"Running query: {text_}")
+
     def get_dataset_collection(
         self,
         bucket: str,
@@ -326,18 +332,33 @@ def apply_query_filter(query):
             dataset_query = apply_query_filter(
                 self.session.query(dataset_table.c.dataset_id)
             )
+            self._debug_query(dataset_query)
             dataset_ids = [row.dataset_id for row in dataset_query]
             datasets = self.load_datasets(dataset_ids)
+
+            dataset_collection_metadata = DatasetCollectionMetadata(
+                last_modified=max(dataset.last_modified_at for dataset in datasets)
+                if datasets
+                else None,
+                row_count=len(datasets),
+            )
         else:
             datasets = []
 
-        metadata_result_row = apply_query_filter(
-            self.session.query(
-                func.max(dataset_table.c.last_modified_at).label("last_modified_at"),
-                func.count().label("row_count"),
+            metadata_result_query = apply_query_filter(
+                self.session.query(
+                    func.max(dataset_table.c.last_modified_at).label(
+                        "last_modified_at"
+                    ),
+                    func.count().label("row_count"),
+                )
+            )
+
+            self._debug_query(metadata_result_query)
+
+            dataset_collection_metadata = DatasetCollectionMetadata(
+                *metadata_result_query.first()
             )
-        ).first()
-        dataset_collection_metadata = DatasetCollectionMetadata(*metadata_result_row)
 
         return DatasetCollection(dataset_collection_metadata, datasets)
 

ingestify/main.py

@@ -182,7 +182,9 @@ def get_event_subscriber_cls(key: str) -> Type[Subscriber]:
     return import_cls(key)
 
 
-def get_engine(config_file, bucket: Optional[str] = None) -> IngestionEngine:
+def get_engine(
+    config_file, bucket: Optional[str] = None, disable_events: bool = False
+) -> IngestionEngine:
     config = parse_config(config_file, default_value="")
 
     logger.info("Initializing sources")
@@ -201,11 +203,16 @@ def get_engine(config_file, bucket: Optional[str] = None) -> IngestionEngine:
 
     # Setup an EventBus and wire some more components
     event_bus = EventBus()
-    publisher = Publisher()
-    for subscriber in config.get("event_subscribers", []):
-        cls = get_event_subscriber_cls(subscriber["type"])
-        publisher.add_subscriber(cls(store))
-    event_bus.register(publisher)
+    if not disable_events:
+        # When we disable all events we don't register any publishers
+        publisher = Publisher()
+        for subscriber in config.get("event_subscribers", []):
+            cls = get_event_subscriber_cls(subscriber["type"])
+            publisher.add_subscriber(cls(store))
+        event_bus.register(publisher)
+    else:
+        logger.info("Disabling all event handlers")
+
     store.set_event_bus(event_bus)
 
     ingestion_engine = IngestionEngine(