How 2-immerse/get-started works
Project type and purpose
• From the README and directory layout, this is an open-source, container-based platform for object-based multi-screen broadcasting (the “2-IMMERSE Object-based Broadcasting Platform”).
• It provides reusable components (microservices) orchestrated across cloud and client devices to render media, handle user interaction, and implement DMApp logic.
• The project includes build scripts (build/), deployment scripts for Docker Compose (deployment/), documentation (docs/), and example apps (examples/).
File structure
• Top level:
• build/ – build instructions & scripts that produce Docker images or binaries.
• deployment/ – Docker-Compose YAML (docker-compose-standalone.yml), HAProxy config, health check scripts.
• examples/ – sample DMApps, e.g., an EPG JSON config.
• No application source code in this repo, so the focus is on orchestration, deployment, and examples.
Readme insights
• Core stack: containerized microservices + HbbTV 2.0/HTML5 JavaScript clients.
• Deployment targets: any container orchestration (Docker-Compose shown as example).
• Clients fetch DMApps from the service platform and render them.
Main components
a. Build & CI pipeline
• Source repo → build scripts → container registry (private or public).
b. Deployment platform
• Docker-Compose (or Kubernetes cluster) hosting:
• API Gateway / Load Balancer (HAProxy)
• Microservices:
– Session Manager
– Device Registry
– Content Manager / Asset Service
– DMApp Orchestrator
– (Optional) Message Broker
• Data stores:
– Persistent DB (e.g., PostgreSQL, MongoDB)
– In-memory cache (e.g., Redis)
c. Clients
• HbbTV-compliant browsers on TVs, web browsers on second screen devices, mobile apps.
• They host HTML/CSS/JS DMApps.
d. Examples
• EPG configuration file (e.g., examples/epg/epg.json) that the platform loads to demonstrate scheduling.
Relationships and interactions
• Clients ←→ HAProxy/API Gateway (HTTPS)
• Gateway routes to appropriate microservice endpoints.
• Microservices communicate via HTTP/REST or message bus.
• Services read/write to databases or caches.
• Health checks (health.sh) feed status into the load balancer.
• Build pipeline pushes new images to registry; deploy scripts pull and launch updated containers.
Architectural patterns & design principles
• Microservices: each service handles a single responsibility (session, device, content, orchestration).
• Containerization: isolates services, consistent environment, easy scaling.
• API Gatekeeping: HAProxy as a reverse proxy and load balancer.
• Infrastructure as code: deployment described in YAML, scripts versioned in repo.
• Pluggability: example DMApps loaded via configuration, extensible with new apps.
Detail level
• Containers defined in docker-compose-standalone.yml.
• If the software-stack.svg lists additional components (message broker, CDN), include them.
• Ports, protocols (HTTP/HTTPS, AMQP), and any volume mounts (for persistence).
• Boundaries (e.g., “On-prem / Cloud”, “Private network”, “Public Internet”).
Final checklist for the principal software engineer
• [ ] Sketch Docker-Compose cluster with containers (load balancer, services, DB, cache).
• [ ] Illustrate clients pulling DMApps over HTTP.
• [ ] Capture health-check flows and auto-scaling points (if applicable).
• [ ] Reference the example EPG flow: config → Content Manager → client UI.