StreamPulse v2.2 – MQTT Integration Release

StreamPulse v2.2 introduces a major capability upgrade by adding a third microservice: an MQTT status publisher designed for IoT dashboards, automation systems, and cloud integrations. This release focuses on reliability, configurability, and fully Dockerized orchestration.

Key Highlights

• New mqtt_service.py running under Supervisor
• Publishes full heartbeat JSON data to MQTT at configurable intervals
• Supports TCP, WebSocket, TLS, and authenticated brokers (Mosquitto, HiveMQ, EMQX, etc.)
• Live reload of MQTT settings from config.yaml
• Updated Web GUI with MQTT configuration panel and toggles
• Clean reconnect logic with exponential backoff
• Graceful shutdown and fault-tolerant operation
• Three-service architecture (monitor + web gui + mqtt publisher)
• Optional mqtt_test_subscriber.py for testing MQTT output

Improvements

• Refactored Dockerfile and Supervisor orchestration
• More stable initialization logic for config and DB
• Improved logging and error visibility for production debugging
• Backward-compatible with v2.1 persistent volume structure

Upgrading From v2.1

• Fully compatible; no breaking changes
• Existing config.yaml remains valid
• MQTT block auto-generated if missing
• Same host volume mapping: /host/config.yaml and /host/streams.db

Docker Images

Docker Hub Repository:
https://hub.docker.com/r/devprincekumar/streampulse

Available tags:

• 2.2 – Latest feature release
• 2.1 – Stable release

StreamPulse v2.1 - Production-Ready Dockerized Release

StreamPulse v2.1 – Release Notes

Release Type: Major Release

Status: Stable / Production-Ready

Distribution: devprincekumar/streampulse:2.1

---

Highlights

StreamPulse v2.1 evolves the entire system into a fully Dockerized, persistent, and supervisor-managed microservice, ideal for real-world deployments across IoT networks, edge devices, Raspberry Pi, cloud VMs, and mixed RTSP/MJPEG camera setups.

---

Major Changes

1. Fully Containerized Architecture

• Migrated to a clean, lightweight Docker image (Python 3.11-slim)
• Reproducible and platform-consistent deployment

2. Supervisor-Based Dual Process Management

Now runs:

• monitor.py
• webgui.py
  under supervisord for:
• Crash recovery
• Automatic restarts
• Stable parallel execution

3. Host-Persistent Configuration & Database

New persistent storage model:

StreamPulse-v2.1/
 ├── config.yaml
 └── streams.db

Both survive:

• restarts
• rebuilds
• updates

4. Live Sync Between Host ↔ Container

Symlinks ensure real-time sync:

/app/config.yaml  → /host/config.yaml  
/app/streams.db   → /host/streams.db

This eliminates:

• Docker mount conflicts
• "file vs directory" issues
• Windows overlayfs bugs

5. Auto-Creation of Missing DB Tables

• Eliminates “no table found” errors
• Ensures DB stays current with configured streams

6. Updated Port Mapping

• API → 6868
• GUI → 6969
  (Internal ports 7000 / 8000)

---

Fixes & Improvements

• Fixed path & mount issues across Windows/Linux/macOS
• Resolved config/db overwriting and initialization issues
• Supervisor log rotation disabled to prevent “illegal seek” errors
• More reliable startup routines
• Smooth config reloads and GUI updates
• Stable repeat runs (compose down → compose up)
• Zero data loss across rebuilds

---

New Host Folder Layout

StreamPulse-v2.1/
 ├── config.yaml     <-- Persistent configuration
 └── streams.db      <-- Persistent heartbeat logs

---

Recommended Docker Compose

services:
  streampulse:
    image: devprincekumar/streampulse:2.1
    container_name: StreamPulse-v2.1
    restart: unless-stopped
    ports:
      - "6868:7000"
      - "6969:8000"
    volumes:
      - ./StreamPulse-v2.1:/host

Run:

docker compose up -d

---

Access Endpoints

• GUI: http://localhost:6969
• API: http://localhost:6868/api/status
• Default Credentials: admin / admin123

---

Notes

• v2.1 does not break compatibility with older config formats.
• Legacy versions remain available for reference.
• This release is recommended for all new deployments.

---

Summary

StreamPulse v2.1 delivers:

• A production-grade containerized runtime
• Full persistence
• Live host-container sync
• Reliable multi-process execution
• Cross-platform stability

This is the most robust and deployment-ready version of StreamPulse to date.

---

StreamPulse v2.0 – Hybrid Async & Secure Architecture

StreamPulse v2.0 – Hybrid Async & Secure Architecture

This release introduces the new architecture of StreamPulse — optimized for scalability, reliability, and real-time camera monitoring across hundreds of heterogeneous IP camera nodes.

---

What's New

• Hybrid Async + Threaded Engine for parallel RTSP/MJPEG stream monitoring
• Separate RTSP and MJPEG lanes with adaptive scheduling
• Auto NTP sync + timezone detection for precise timestamping
• Secure login system (admin-managed credentials, password stored in DB)
• Responsive GUI with dark/light toggle, real-time dashboard updates
• Stream history viewer + 5-second live preview
• CSV export feature for external analysis
• Optimized Alpine-based Dockerfile

---

Folder Structure

• version-2/ → Latest stable build (this release)
• version-1/ → Archived initial GUI build (v1.1)
• legacy-prototypes/ → Early standalone scripts and experiments

---

🐳 Docker Deployment

Run instantly:

docker pull devprincekumar/streampulse:2.0
docker run -d -p 8000:8000 -v $(pwd)/data:/data devprincekumar/streampulse:2.0

Or using Docker Compose:

docker compose up -d

Access the web GUI at: http://localhost:8000/ -> Default Credentials: admin / admin123

Persistent data (DB + config) is stored under /data on host.

---

Summary

This version is built for IoT-scale camera networks, tested with up to 1,000 streams (RTSP + MJPEG) using adaptive heartbeat intervals and fault-tolerant scheduling.

• Timeline: Legacy (2024) → v1 (Stable GUI) → v2 (Hybrid Async & Secure)
• Docker Image: devprincekumar/streampulse:2.0

StreamPulse v1.1 – Docker Deployment Release

This release adds official Docker support for StreamPulse.

🐳 What's New:

• Added Dockerfile (Debian Slim base)
• Added docker-compose.yml
• Preloaded with a public camera stream for testing
• Persistent data volume for SQLite/config
• Published image: devprincekumar/streampulse:1.1

Run instantly:
docker pull devprincekumar/streampulse:1.1
docker run -d -p 8000:8000 -v $(pwd)/data:/data devprincekumar/streampulse:1.1

StreamPulse Origins – The Prototypes That Started It All

StreamPulse Origins – The Journey from Raw Scripts to a Microservice

Before StreamPulse became a fully functional microservice with a Flask GUI and SQLite backend, it began as a collection of experimental scripts designed to test real-world RTSP and MJPEG camera health monitoring.

These early prototypes, now available in the legacy_prototypes/ folder, capture the project's evolution step by step — from low-level OpenCV-based testing to multi-threaded heartbeats and data logging.

What These Versions Explored

• RTSP frame capture & timestamp validation
• MJPEG continuous stream handling
• CPU, memory, and network load monitoring
• Latency & jitter calculation
• Multi-camera parallel testing

📂 Included Prototypes

File	Focus
1-working-rtsp-log-(cv).py	Early OpenCV-based RTSP frame capture & CSV logging
2-me-stream-receive.py	MJPEG stream receiver with system performance tracking
3-rtsp_sender_logger.py	Simulated RTSP camera sender using FFmpeg
3-rtsp_receiver_logger.py	Receiver-side latency and frame drop analysis
4-rtsp_heartbest.py	Multi-threaded RTSP heartbeat system – the direct ancestor of StreamPulse

Outcome

These experiments helped identify:

• Optimal interval timing for heartbeat checks
• Tradeoffs between OpenCV and FFmpeg performance
• The need for async scheduling over threading
• Why SQLite was chosen for persistent, lightweight logging

Legacy → v1 Transition

All learnings from these prototypes were integrated into StreamPulse v1,
which unified the health monitoring logic, time synchronization, and logging into one stable service.

Timeline: 2024 → Early 2025

License: MIT (same as StreamPulse)

StreamPulse v1.0

StreamPulse is a minimal Python-based microservice for monitoring the operational health of heterogeneous IP camera networks.

It was designed during the expansion of a mixed-infrastructure deployment consisting of low-cost consumer cameras (such as TP-Link Tapo) and custom Raspberry Pi camera nodes running MotionEye. As the number of independent devices increased, conventional NVR monitoring and simple ping checks became insufficient to confirm real video availability or client accessibility.

To address this, StreamPulse implements a two-part architecture:

Monitor Service – periodically connects to configured RTSP and MJPEG endpoints, captures a frame, and records the success or failure as a heartbeat log in an SQLite database.
Web GUI Service – provides a Flask-based dashboard for configuration, visualization, and on-demand live frame verification.
A simple YAML configuration defines each stream’s name and URL. Both the monitor and the GUI read from this configuration, ensuring lightweight synchronization without external dependencies.

SQLite is used as the database to minimize hardware requirements and enable deployment on single-board computers (Raspberry Pi, Orange Pi, etc.).