How openutm/flight-blender works
Main Components Identification
• Core Backend Server (Flight Blender)
• Central Django application (flight_blender folder) which ties together the system.
• Central “API” layer (see the api folder with the API spec YAML and Postman collection), indicating how external clients (or even internal modules) interact via HTTP endpoints.
• Modular Sub-Applications:
• Create distinct blocks for each major module—such as auth_helper, conformance_monitoring_operations, flight_declaration_operations, flight_feed_operations, geo_fence_operations, notification_operations, rid_operations, scd_operations, uss_operations, utm_adapter, and weather_monitoring_operations.
• Each of these should be shown as distinct components (often implemented as Django apps) that encapsulate specific business logic.
• Background Task Processing:
• A Celery worker component (noted by flight_blender/celery.py) which handles asynchronous tasks across modules (e.g., sending notifications, processing flight data feeds, etc.).
• Data Stores and Caching:
• Databases (implicit from the migrations in each module) and specify a caching/backend store such as Redis (config/redis.conf), which supports performance and state management.
• Containerization and Deployment:
• Deployment layer using Docker – include Dockerfile, docker-compose, and entrypoint scripts (found in the entrypoints folder) that delineate production vs. non-database startup flows.
• External Interfaces & Integrations:
• Integration with DSS and interoperability components (e.g., auth_helper/dss_auth_helper.py, and DSS connectivity modules mentioned in the README).
• Mention AMQP or messaging queues indicated by the “Operator Notifications” functionality.
• Indication of front-end components (Flight Spotlight display) that are external client applications consuming data from this backend.
Relationships and Interactions
• From external data sources (flight tracking feeds, geofence inputs, flight declarations) entering the system via API endpoints.
• Between the core flight_blender server and modular apps (each handling a specific piece of data or processing).
• From the core server and modules to the task queue (Celery) and then to background processing workers.
• Between the application and external systems (DSS, external APIs, and messaging systems).
• That the modules communicate indirectly through shared data stores (databases and caches) and via scheduled jobs or event signals (for instance, conformance monitoring tasks or operator notifications).
Architectural Patterns and Design Principles
• That the project follows a modular monolith architecture where each major domain (e.g., flight declaration, flight feed, geo-fence) is implemented as an independent Django app, facilitating separation of concerns.
• Use of asynchronous task processing (Celery) to decouple heavy or long-running processes from the synchronous request–response cycle.
• Containerization (with Docker and docker-compose) which facilitates consistent deployment and scaling.
Relevant Technologies, Frameworks, and Tools
• Django as the web framework.
• Celery for task processing.
• Redis for caching and potentially as a Celery broker.
• Docker (Dockerfile, docker-compose, entrypoint scripts) for containerization and orchestration.
• Deployment-specific configurations (Procfile, configuration files in .vscode, pre-commit configuration, and GitHub workflows).