A modern platform for visual, flexible, and extensible graph-based investigations. For cybersecurity analysts and investigators.
import asyncio
import uuid
from typing import Any, Dict, List, Optional
from celery import Task, states
from sqlalchemy.orm import Session
from flowsint_core.utils import to_json_serializable
from flowsint_enrichers import ENRICHER_REGISTRY, load_all_enrichers
from ..core.celery import celery
from ..core.enums import EventLevel
from ..core.logger import Logger
from ..core.models import Scan
from ..core.postgre_db import SessionLocal, get_db
from ..core.services import create_enricher_template_service, create_vault_service
from ..core.template_enricher import TemplateEnricher
from ..templates.types import Template
# Auto-discover and register all enrichers
load_all_enrichers()
db: Session = next(get_db())
@celery.task(name="run_enricher", bind=True)
def run_enricher(
self: Task,
enricher_name: str,
serialized_objects: List[dict],
sketch_id: str | None,
owner_id: Optional[str] = None,
params: Optional[dict] = None,
) -> Dict[str, Any]:
session = SessionLocal()
try:
scan_id = uuid.UUID(self.request.id)
scan = Scan(
id=scan_id,
status=EventLevel.PENDING,
sketch_id=uuid.UUID(sketch_id) if sketch_id else None,
)
session.add(scan)
session.commit()
# Create vault instance if owner_id is provided
vault = None
if owner_id:
try:
vault = create_vault_service(session).for_user(uuid.UUID(owner_id))
except Exception as e:
# Logger.error's signature omits None even though the column
# it writes is nullable and a sketch-less scan is legal here.
Logger.error(
sketch_id, # type: ignore[arg-type]
{"message": f"Failed to create vault: {str(e)}"},
)
if not ENRICHER_REGISTRY.enricher_exists(enricher_name):
raise ValueError(f"Enricher '{enricher_name}' not found in registry")
enricher = ENRICHER_REGISTRY.get_enricher(
name=enricher_name,
sketch_id=sketch_id,
scan_id=scan_id,
vault=vault,
params=params or {},
)
# Deserialize objects back into Pydantic models
# The preprocess method in Enricher will handle these already-parsed objects
results = asyncio.run(enricher.execute(values=serialized_objects))
scan.status = EventLevel.COMPLETED
scan.details = to_json_serializable(results)
session.commit()
return {"result": scan.details}
except Exception as ex:
session.rollback()
error_logs = f"An error occurred: {str(ex)}"
print(f"Error in task: {error_logs}")
failed_scan = (
session.query(Scan).filter(Scan.id == uuid.UUID(self.request.id)).first()
)
if failed_scan:
failed_scan.status = EventLevel.FAILED
# Scan.error is a legacy Column(), not Mapped[], so the stubs read
# it as Column[str] rather than str.
failed_scan.error = error_logs # type: ignore[assignment]
session.commit()
self.update_state(state=states.FAILURE)
raise ex
finally:
session.close()
@celery.task(name="run_template_enricher", bind=True)
def run_template_enricher(
self: Task,
template_name: str,
serialized_objects: List[dict],
sketch_id: str | None,
owner_id: str,
params: Optional[dict] = None,
) -> Dict[str, Any]:
"""Run an enricher defined by a YAML template stored in the database."""
session = SessionLocal()
try:
scan_id = uuid.UUID(self.request.id)
scan = Scan(
id=scan_id,
status=EventLevel.PENDING,
sketch_id=uuid.UUID(sketch_id) if sketch_id else None,
)
session.add(scan)
session.commit()
# Resolve vault for secrets
vault = None
try:
vault = create_vault_service(session).for_user(uuid.UUID(owner_id))
except Exception as e:
Logger.error(
sketch_id, # type: ignore[arg-type]
{"message": f"Failed to create vault: {str(e)}"},
)
# Load template from database
template_service = create_enricher_template_service(session)
db_template = template_service.find_by_name(template_name, uuid.UUID(owner_id))
if not db_template:
raise ValueError(
f"Template '{template_name}' not found for user {owner_id}"
)
template = Template(**db_template.content)
enricher = TemplateEnricher(
template=template,
sketch_id=sketch_id,
scan_id=str(scan_id),
vault=vault,
params=params or {},
)
results = asyncio.run(enricher.execute(values=serialized_objects))
scan.status = EventLevel.COMPLETED
scan.details = to_json_serializable(results)
session.commit()
return {"result": scan.details}
except Exception as ex:
session.rollback()
error_logs = f"An error occurred: {str(ex)}"
print(f"Error in template task: {error_logs}")
failed_scan = (
session.query(Scan).filter(Scan.id == uuid.UUID(self.request.id)).first()
)
if failed_scan:
failed_scan.status = EventLevel.FAILED
failed_scan.error = error_logs # type: ignore[assignment]
session.commit()
self.update_state(state=states.FAILURE)
raise ex
finally:
session.close()