This is the multi-page printable view of this section. Click here to print.

Return to the regular view of this page.

Network Personal Video Recorder (esb3035)

Network Personal Video Recorder service for managing and streaming NPVR content

1 - Introduction

Introduction to ew-npvr

Overview

The service ew-npvr is a Network Personal Video Recorder (NPVR) solution that enables the management and streaming of recorded content. It provides a complete system for handling personal video recordings with reduced storage usage by reusing duplicated segments.

ew-npvr is designed to integrate with AgileTV Origin’s live ingest channels and provides capabilities for recording, storing, and streaming content to repackager.

Key Features

  • Content Management: RESTful API for managing NPVR recordings with CRUD operations
  • Streaming Service: Provides media streaming capabilities for recorded content
  • Channel Integration: Integrates with live ingest channels (ESB3003) for recording management
  • Thumbnail Generation: Automatic thumbnail generation for recorded content using OpenCV
  • Flexible Storage: Configurable storage locations with support for copy or hard-link behavior
  • Optional Database: PostgreSQL-backed metadata storage (optional - media streaming works without database)
  • Cursor-based Pagination: Efficient pagination for listing large numbers of recordings
  • Swagger Documentation: Interactive API documentation available at /swagger/
  • Rate Limiting: Configurable write rate limiting for file copy operations
  • Graceful Degradation: Media API continues to function even if database is unavailable

Architecture

ew-npvr consists of several key components:

  1. Management API: RESTful administrative interface for managing recordings (default port: 8099)
    • CRUD operations for NPVR entries
    • Health check endpoint
    • Swagger UI for API documentation
  2. Media API: Streaming interface for delivering recorded content (default: Unix socket)
    • Segment delivery
    • Content information retrieval
    • Segment timing information
  3. Job Controller: Manages recording jobs and channel synchronization
  4. Content Info Cache: High-performance in-memory caching layer for content metadata
  5. Database Layer: Optional PostgreSQL storage for recording metadata and state
  6. Channel Manager: Handles communication with live ingest channels via Unix socket

Recording States

NPVR entries progress through various states:

  • pending: Recording request created, waiting to start
  • ongoing: Recording is actively in progress
  • done: Recording completed successfully
  • error: Recording encountered an error
  • deleting: Entry is being deleted
  • updating: Entry metadata is being updated
  • update-ongoing: Update is in progress

Use Cases

  • Recording live channels for time-shifted viewing
  • Personal video library management
  • Catch-up TV services
  • Content archival and replay
  • Cloud DVR services

2 - Installation

Installing and running ew-npvr

Installation

The ew-npvr service is distributed as a CentOS/Red Hat RPM and is available as ew-npvr.service when installed. It works on Red Hat 8 and compatible versions.

To install version x.y.z, the rpm command can be used as follows:

dnf install ./ew-npvr-x.y.z-1.el8.x86_64.rpm

The service can be controlled with the standard systemctl commands:

systemctl start ew-npvr
systemctl stop ew-npvr
systemctl status ew-npvr

Logs from the service can be seen using journalctl -u ew-npvr.

The unit file is available in /usr/lib/systemd/system/ew-npvr.service.

When run as a service, ew-npvr reads its initial configuration from the AgileTV Origin configuration system.

To uninstall the service, do:

dnf remove ew-npvr

When uninstalling it is recommended to first stop the service.

Prerequisites

Before installing ew-npvr, ensure the following prerequisites are met:

  1. Database (Optional): PostgreSQL database server accessible from the ew-npvr host
    • Required for management API functionality
    • Not required if only using media streaming API
  2. Storage: Sufficient disk space for NPVR recordings at configured storage locations
  3. Live Ingest: AgileTV Origin live ingest service (ESB3003) if recording live channels
  4. Network: Network connectivity to database and channel sources

Note: The service operates in degraded mode if the database is unavailable - the media API will continue to function for streaming existing content, but the management API will not be available for creating or managing recordings.

Directory Structure

After installation, the following directories are created:

  • /var/log/edgeware/ew-npvr/: Log files directory
    • ew-npvr.log: General service logs
    • ew-npvr-streaming.log: Media streaming logs
    • ew-npvr-admin.log: Administration API logs
  • /var/run/edgeware/ew-npvr/: Runtime files (Unix sockets)
  • /etc/edgeware/ew-npvr/: Configuration files

Initial Setup

  1. Configure the database connection in the AgileTV Origin configuration
  2. Set up NPVR storage locations
  3. Configure live ingest channels for NPVR integration
  4. Start the service: systemctl start ew-npvr
  5. Verify the service is running: systemctl status ew-npvr

Command Line Options

The ew-npvr service supports the following command-line options:

  • --print-schema: Print the embedded JSON schema for configuration and exit
  • --management-address <address>: Address for management API server (default: 0.0.0.0:8099)
  • --media-address <address>: Address for media API server (default: unix:///var/run/edgeware/ew-npvr/sock.sock)
    • Supports both TCP addresses (e.g., 0.0.0.0:8080) and Unix sockets (e.g., unix:///var/run/edgeware/ew-npvr/sock.sock)
  • --content-info-cache-size <size>: Maximum number of entries in content info cache (default: 1000, range: 1-65536)
  • --write-rate-limit <bytes>: Write rate limit in bytes per second when copying files (default: 0 = no limit)
    • Use this to prevent storage I/O saturation during recording operations
    • Example: --write-rate-limit 104857600 limits writes to 100 MB/s

These options can be configured in the systemd service file at /usr/lib/systemd/system/ew-npvr.service.

Accessing API Documentation

Once the service is running, Swagger API documentation is available at:

http://<management-address>/swagger/

For example, with default settings:

http://localhost:8099/swagger/

2.1 - Upgrades

Upgrading ew-npvr to newer versions

Upgrade Process

Standard Upgrade

To upgrade ew-npvr to a new version, follow these steps:

  1. Stop the service:

    systemctl stop ew-npvr

  2. Install the new version:

    dnf upgrade ./ew-npvr-x.y.z-1.el8.x86_64.rpm

  3. Review configuration changes:

  4. Start the service:

    systemctl start ew-npvr

  5. Verify the upgrade:

    systemctl status ew-npvr
journalctl -u ew-npvr -n 50

Database Schema Upgrades

Database schema migrations are handled automatically by the service on startup. When upgrading:

  1. Ensure database connection is configured and accessible
  2. The service will apply any necessary schema migrations on first start
  3. Monitor logs for migration status: journalctl -u ew-npvr -f

Backup Recommendation: Before upgrading, backup your PostgreSQL database:

pg_dump -h localhost -U npvr_user npvr_db > npvr_backup_$(date +%Y%m%d).sql

Rolling Back

If you need to roll back to a previous version:

  1. Stop the service:

    systemctl stop ew-npvr

  2. Downgrade the package:

    dnf downgrade ew-npvr-<previous-version>

  3. Restore database if needed:

    # Only if database schema changed
psql -h localhost -U npvr_user npvr_db < npvr_backup_YYYYMMDD.sql

  4. Start the service:

    systemctl start ew-npvr

Compatibility Notes

  • Database: Schema changes are forward-compatible but not backward-compatible. Always backup before upgrading.
  • Configuration: New configuration options have default values, so existing configurations remain valid.
  • API: The Management API maintains backward compatibility within major versions.
  • Storage: Recording storage format is backward-compatible.

Testing the Upgrade

After upgrading, verify functionality:

  1. Check service health:

    curl http://localhost:8099/

  2. List existing recordings:

    curl http://localhost:8099/api/v1/content?limit=10

  3. Create a test recording:

    curl -X POST http://localhost:8099/api/v1/content \
  -H "Content-Type: application/json" \
  -d '{
    "channelName": "test-channel",
    "title": "Upgrade Test",
    "startTime": '$(date +%s)',
    "stopTime": '$(( $(date +%s) + 3600 ))'
  }'

  4. Verify logs:

    journalctl -u ew-npvr -n 100 --no-pager

Common Upgrade Issues

Service fails to start:

  • Check logs: journalctl -u ew-npvr -n 50
  • Verify configuration syntax
  • Check file permissions
  • Ensure database is accessible

Database migration fails:

  • Check PostgreSQL connectivity
  • Verify user has schema modification permissions
  • Review migration logs in service output
  • Consider restoring backup and retrying

Recordings not accessible:

  • Verify storage paths haven’t changed
  • Check file permissions on storage locations
  • Review configuration for storage location names
  • Ensure media API is properly configured

Performance degradation:

  • Check content info cache size setting
  • Review write rate limit if enabled
  • Monitor database query performance
  • Verify disk I/O isn’t saturated

Version-Specific Notes

Check the release notes for version-specific upgrade instructions and breaking changes.

3 - Configuration

Configuring ew-npvr

Configuration Overview

ew-npvr is configured through the AgileTV Origin configuration system using a JSON schema, aka confd. The service monitors for configuration changes and adapts dynamically when possible.

Configuration Structure

The configuration is divided into two main sections:

  1. Services Configuration: Channel-level NPVR settings
  2. Storage Configuration: NPVR storage backend and database settings

Services Configuration

Live Ingest Channels

To enable NPVR recording for a live ingest channel, add the npvrLocation property to the channel configuration:

{
  "services": {
    "liveIngest": {
      "channels": [
        {
          "name": "channel-1",
          "state": "enabled",
          "npvrLocation": "storage-location-1"
        }
      ]
    }
  }
}

Parameters:

  • npvrLocation (string): Identifier for the NPVR storage location to use for this channel’s recordings. Must match a configured storage location name.
  • name (string): Channel name
  • state (string): Channel state (must be configured in live ingest)

Note: The channel must already be configured in the live ingest service (ESB3003) before NPVR can record from it.

Storage Configuration

NPVR Storage Locations

Configure one or more storage locations for NPVR recordings:

{
  "storage": {
    "npvr": {
      "locations": [
        {
          "name": "storage-location-1",
          "basePath": "/var/storage/npvr",
          "copyBehavior": "copy"
        }
      ]
    }
  }
}

Parameters:

  • name (string, required): Unique identifier for this storage location
  • basePath (string, required): Base path for NPVR storage on the filesystem
    • This directory must exist and be writable by the ew-npvr service
    • Ensure sufficient disk space for recordings
  • copyBehavior (string): File copy behavior for NPVR storage
    • copy: Copy files (default) - safer option, works across filesystems
    • hard-link: Create hard links instead of copying - more efficient but requires source and destination on same logical partition

Storage Layout:

Recordings are stored with the following directory structure:

<basePath>/<channelName>/<date>/<hour>/<minute>/...

Metadata is stored in:

<basePath>/<channelName>/metadata/<startTime>-<endTime>/...

Database Configuration

Configure the PostgreSQL database connection:

{
  "storage": {
    "npvr": {
      "database": {
        "address": "postgres://localhost:5432",
        "user": "npvr_user",
        "password": "secure_password",
        "databaseIndex": "npvr_db"
      }
    }
  }
}

Parameters:

  • address (string): Database address including port (default: “localhost”)
  • user (string): Username for database authentication
  • password (string): Password for database authentication
  • databaseIndex (string): Database name to use for NPVR

Important Notes:

  • External database configuration is optional

  • If database connection fails, the service will log a warning but continue running

  • Without database:

    • Management API will not be available
    • Media API will still function for streaming existing content
    • No ability to create, update, or delete recordings via API

  • PostgreSQL and MySQL are supported. To use MySQL, specify the scheme mysql for database address, for example:

confcli storage.npvr.database.address mysql://db.example.com:3306

Similarly, with PostgreSQL:

confcli storage.npvr.database.address postgres://db.example.com:5432

Log Level Configuration

Configure the logging verbosity:

{
  "storage": {
    "npvr": {
      "logLevel": "info"
    }
  }
}

Log Levels:

  • trace: Most verbose, includes all debug information
  • debug: Debug-level messages
  • info: Informational messages (default, recommended for production)
  • warn: Warning messages only
  • error: Error messages only
  • fatal: Fatal errors only
  • panic: Panic-level errors

Important: The log level can be changed dynamically and will take effect immediately without restarting the service.

Complete Configuration Example

{
  "services": {
    "liveIngest": {
      "channels": [
        {
          "name": "channel-1",
          "state": "enabled",
          "npvrLocation": "primary-storage"
        },
        {
          "name": "channel-2",
          "state": "enabled",
          "npvrLocation": "primary-storage"
        },
        {
          "name": "premium-channel",
          "state": "enabled",
          "npvrLocation": "backup-storage"
        }
      ]
    }
  },
  "storage": {
    "npvr": {
      "logLevel": "info",
      "locations": [
        {
          "name": "primary-storage",
          "basePath": "/mnt/npvr/storage1",
          "copyBehavior": "copy"
        },
        {
          "name": "backup-storage",
          "basePath": "/mnt/npvr/storage2",
          "copyBehavior": "hard-link"
        }
      ],
      "database": {
        "address": "postgresql://db.example.com:5432",
        "user": "npvr_service",
        "password": "secret_password",
        "databaseIndex": "npvr_production"
      }
    }
  }
}

Dynamic Configuration Updates

The service monitors configuration changes and applies them dynamically when possible:

  • Log Level: Applied immediately without restart
  • Storage Locations: Applied immediately without restart
  • Database Settings: Requires restart to take effect
  • Channel NPVR Locations: Applied immediately when channels are updated

Troubleshooting Configuration

Common configuration issues:

  1. Database connection fails: Service will continue in degraded mode - check logs for connection errors
  2. Storage path not writable: Check file permissions and disk space
  3. Hard-link fails: Verify source and destination are on same filesystem, or use copy instead

4 - Logging

Logging in ew-npvr

Log Files

ew-npvr maintains separate log files for different operational areas to facilitate troubleshooting and monitoring:

General Service Log

Location: /var/log/edgeware/ew-npvr/ew-npvr.log

Contains general service operational logs including:

  • Service startup and shutdown
  • Configuration changes
  • Database connection status
  • Job controller operations
  • Channel manager events
  • General errors and warnings

Streaming Log

Location: /var/log/edgeware/ew-npvr/ew-npvr-streaming.log

Contains logs specific to media streaming operations:

  • Media API requests
  • Content delivery events
  • Streaming errors
  • Cache operations
  • Thumbnail generation

Administration Log

Location: /var/log/edgeware/ew-npvr/ew-npvr-admin.log

Contains logs related to administrative operations:

  • Management API requests
  • Recording management operations
  • Channel configuration changes
  • Administrative actions

Log Rotation

Log files are rotated automatically using logrotate. The configuration is installed at:

/etc/logrotate.d/ew-npvr

The default rotation policy is:

  • Daily rotation
  • Keep 7 days of logs
  • Compress rotated logs
  • Create new log files with appropriate permissions

To manually rotate logs:

logrotate -f /etc/logrotate.d/ew-npvr

Viewing Logs

Using journalctl

View all service logs in real-time:

journalctl -u ew-npvr -f

View logs from the last hour:

journalctl -u ew-npvr --since "1 hour ago"

View logs with specific priority (error and above):

journalctl -u ew-npvr -p err

Using tail

Monitor the general log file:

tail -f /var/log/edgeware/ew-npvr/ew-npvr.log

Monitor the streaming log:

tail -f /var/log/edgeware/ew-npvr/ew-npvr-streaming.log

Monitor the administration log:

tail -f /var/log/edgeware/ew-npvr/ew-npvr-admin.log

Log Levels

The log level can be configured in the service configuration. Available levels:

  • trace: Most verbose, includes all debug information
  • debug: Detailed debugging information
  • info: Informational messages (default)
  • warn: Warning messages
  • error: Error messages
  • fatal: Fatal errors that cause service failure
  • panic: Panic-level errors

To change the log level, update the storage.npvr.logLevel configuration parameter. The change takes effect immediately without requiring a service restart.

Log Format

Logs are formatted as JSON for easy parsing and analysis. Each log entry contains:

  • time: Timestamp in RFC3339 format
  • level: Log level (trace, debug, info, warn, error, fatal, panic)
  • topic: Log topic (general, streaming, admin)
  • message: Log message
  • Additional contextual fields depending on the log entry

Example log entry:

{
  "time": "2026-04-16T10:30:45Z",
  "level": "info",
  "topic": "streaming",
  "message": "Media request processed",
  "channel": "channel-1",
  "duration_ms": 125
}

Troubleshooting

Common Log Locations to Check

  1. Service won’t start: Check general log and journalctl
  2. Streaming issues: Check streaming log
  3. API errors: Check administration log
  4. Database problems: Check general log for connection errors
  5. Configuration issues: Check general log for validation errors

5 - How-To Guides

Step-by-step guides for common ew-npvr tasks

Common Tasks

This section provides practical guides for common NPVR operations.

Creating a Recording

To create a new NPVR recording, send a POST request to the management API:

curl -X POST http://localhost:8099/api/v1/content \
  -H "Content-Type: application/json" \
  -d '{
    "channelName": "channel-1",
    "title": "Evening News",
    "startTime": 1713268800,
    "stopTime": 1713272400,
    "refID": "news-2026-04-16"
  }'

Response:

{
  "id": "01HP2Q3R4S5T6U7V8W9X0Y1Z2"
}

Save the returned id for future operations on this recording.

Listing Recordings

List all recordings:

curl http://localhost:8099/api/v1/content

List recordings for a specific channel:

curl "http://localhost:8099/api/v1/content?channel=channel-1"

List recordings in a time range:

curl "http://localhost:8099/api/v1/content?channel=channel-1&startTime=1713268800&stopTime=1713355200"

List with pagination:

# First page
curl "http://localhost:8099/api/v1/content?channel=channel-1&limit=100"

# Next page (use cursor from response)
curl "http://localhost:8099/api/v1/content?cursor=eyJjaGFubmVs..."

Getting Recording Details

By database ID:

curl "http://localhost:8099/api/v1/content/01HP2Q3R4S5T6U7V8W9X0Y1Z2"

By reference ID:

curl "http://localhost:8099/api/v1/content?id=news-2026-04-16"

Updating a Recording

To extend or shorten a recording, update its start and end times:

curl -X PUT http://localhost:8099/api/v1/content/01HP2Q3R4S5T6U7V8W9X0Y1Z2 \
  -H "Content-Type: application/json" \
  -d '{
    "id": "01HP2Q3R4S5T6U7V8W9X0Y1Z2",
    "startTime": 1713268800,
    "stopTime": 1713276000
  }'

Note: Recording can only be updated if it’s in an allowed state (pending, done, or error).

Deleting a Recording

curl -X DELETE "http://localhost:8099/api/v1/content/01HP2Q3R4S5T6U7V8W9X0Y1Z2"

The entry will be marked with state deleting and removed asynchronously.

Checking Recording State

After creating a recording, check its state periodically:

# Get recording details
curl "http://localhost:8099/api/v1/content/01HP2Q3R4S5T6U7V8W9X0Y1Z2" | jq '.entries[0].state'

Possible states:

  • pending: Waiting to start
  • ongoing: Recording in progress
  • done: Completed successfully
  • error: Failed with error
  • updating: Being updated
  • deleting: Being deleted

Working with Reference IDs

Reference IDs allow you to use your own identifiers instead of database-generated UUIDs.

Create with reference ID:

curl -X POST http://localhost:8099/api/v1/content \
  -H "Content-Type: application/json" \
  -d '{
    "channelName": "channel-1",
    "title": "My Show",
    "startTime": 1713268800,
    "stopTime": 1713272400,
    "refID": "show-s01e05"
  }'

Retrieve using reference ID:

curl "http://localhost:8099/api/v1/content?id=show-s01e05"

Note: Reference IDs must be unique across all recordings.

Monitoring Service Health

Check management API health:

curl http://localhost:8099/

Check media API health (if using TCP):

curl http://localhost:8080/

View service logs:

# General logs
tail -f /var/log/edgeware/ew-npvr/ew-npvr.log

# Streaming logs
tail -f /var/log/edgeware/ew-npvr/ew-npvr-streaming.log

# Admin logs
tail -f /var/log/edgeware/ew-npvr/ew-npvr-admin.log

# System journal
journalctl -u ew-npvr -f

Using the Swagger UI

Interactive API documentation is available at:

http://localhost:8099/swagger/

This provides:

  • Complete API reference
  • Try-it-out functionality
  • Request/response examples
  • Schema definitions

Configuring Storage Locations

Add a new storage location in the configuration:

{
  "storage": {
    "npvr": {
      "locations": [
        {
          "name": "fast-storage",
          "basePath": "/mnt/ssd/npvr",
          "copyBehavior": "copy"
        },
        {
          "name": "archive-storage",
          "basePath": "/mnt/hdd/npvr",
          "copyBehavior": "hard-link"
        }
      ]
    }
  }
}

Then assign channels to storage locations:

{
  "services": {
    "liveIngest": {
      "channels": [
        {
          "name": "news-channel",
          "npvrLocation": "fast-storage"
        },
        {
          "name": "movies-channel",
          "npvrLocation": "archive-storage"
        }
      ]
    }
  }
}

Troubleshooting

Recording stays in “pending” state:

  • Check that the channel exists and is running in live ingest
  • Verify the start time hasn’t already passed
  • Check channel configuration and NPVR location assignment
  • Review logs: journalctl -u ew-npvr -n 100

Recording in “error” state:

  • Check available disk space on storage location
  • Verify source segments are available from live ingest
  • Review logs for specific error messages
  • Check file permissions on storage path

Cannot create recording (424 error):

  • Verify channel is producing segments
  • Check that requested time range has available segments
  • Ensure live ingest is running and accessible

Database connection fails:

  • Service continues in degraded mode
  • Management API will not be available
  • Media API still works for existing content
  • Check PostgreSQL connectivity and credentials

Playable remains false:

  • Recording may still be processing
  • Check storage path for actual files
  • Wait for state to change to “done”
  • Review logs for processing errors

6 - API Reference

API documentation for ew-npvr

Overview

ew-npvr provides two separate APIs:

  1. Management API: RESTful HTTP API for managing NPVR entries (port 8099)
  2. Media API: Streaming API for content delivery (Unix socket by default)

Management API

The Management API provides CRUD operations for NPVR recordings. Interactive documentation is available via Swagger UI at http://<management-address>/swagger/.

Base URL

http://<management-address>/api/v1

Default: http://localhost:8099/api/v1

Endpoints

Health Check

GET /

Returns service health status.

Response: 200 OK with body "OK"

Create NPVR Entry

POST /content

Creates a new NPVR recording entry.

Request Body:

{
  "channelName": "channel-1",
  "title": "My Recording",
  "startTime": 1713254400,
  "stopTime": 1713258000,
  "refID": "optional-reference-id"
}

Parameters:

  • channelName (string, required): Name of the channel to record
  • title (string, required): Title of the recording
  • startTime (integer, required): Start time in epoch seconds
  • stopTime (integer, required): End time in epoch seconds
  • refID (string, optional): Optional reference ID for external systems

Response: 200 OK

{
  "id": "01HP2Q3R4S5T6U7V8W9X0Y1Z2"
}

Error Responses:

  • 400 Bad Request: Invalid request parameters
  • 409 Conflict: Entry with same refID already exists
  • 424 Failed Dependency: Unable to verify segment availability
  • 500 Internal Server Error: Server error

Get NPVR Entries

GET /content
GET /content/{id}

Retrieves NPVR entries by ID or by search criteria.

Query Parameters:

  • id (string): Specific entry ID or refID
  • channel (string): Filter by channel name
  • startTime (integer): Filter entries starting after this epoch time
  • stopTime (integer): Filter entries ending before this epoch time
  • cursor (string): Pagination cursor for next page
  • limit (integer): Maximum entries to return (1-10000, default: 10000)

Response: 200 OK

{
  "cursor": {
    "nextCursor": "base64-encoded-cursor",
    "limit": 100
  },
  "entries": [
    {
      "id": "01HP2Q3R4S5T6U7V8W9X0Y1Z2",
      "refID": "optional-reference-id",
      "timeCreated": 1713254000,
      "timeModified": 1713254100,
      "channelName": "channel-1",
      "title": "My Recording",
      "startTime": 1713254400,
      "endTime": 1713258000,
      "state": "done",
      "playable": true
    }
  ]
}

NPVR Entry Fields:

  • id (string): Unique time-ordered UUID
  • refID (string): Optional user-provided reference ID
  • timeCreated (integer): Creation timestamp (epoch seconds)
  • timeModified (integer): Last modification timestamp (epoch seconds)
  • channelName (string): Channel name
  • title (string): Recording title
  • startTime (integer): Recording start time (epoch seconds)
  • endTime (integer): Recording end time (epoch seconds)
  • state (string): Current state (pending, ongoing, done, error, deleting, updating, update-ongoing)
  • playable (boolean): Whether the content is ready for playback

Error Responses:

  • 400 Bad Request: Invalid parameters
  • 404 Not Found: Entry not found
  • 500 Internal Server Error: Server error

Update NPVR Entry

PUT /content
PUT /content/{id}

Updates the start and end times of an existing NPVR entry.

Request Body:

{
  "id": "01HP2Q3R4S5T6U7V8W9X0Y1Z2",
  "startTime": 1713254400,
  "stopTime": 1713260000
}

Parameters:

  • id (string, required): Entry ID (can be in URL path or request body)
  • startTime (integer, required): New start time
  • stopTime (integer, required): New end time

Response: 200 OK

Error Responses:

  • 400 Bad Request: Invalid parameters
  • 404 Not Found: Entry not found
  • 423 Locked: Entry cannot be updated in its current state
  • 424 Failed Dependency: Unable to verify new segment availability
  • 500 Internal Server Error: Server error

Delete NPVR Entry

DELETE /content?id={id}
DELETE /content/{id}

Marks an NPVR entry for deletion.

Parameters:

  • id (string, required): Entry ID (in URL path or query parameter)

Response: 200 OK or 204 No Content

Error Responses:

  • 400 Bad Request: Missing ID parameter
  • 423 Locked: Entry cannot be deleted in its current state
  • 500 Internal Server Error: Server error

Media API

The Media API provides access to recorded content segments and metadata for streaming.

Endpoints

Get Segment Times

GET /{channel}/segment_times.json?startTime={startTime}&stopTime={stopTime}

Returns segment timing information for a recording.

Parameters:

  • channel (string): Channel name
  • startTime (integer): Recording start time (epoch seconds)
  • stopTime (integer): Recording end time (epoch seconds)

Response: JSON file containing segment timing metadata

Get Content Info

GET /{channel}/{configId}/content_info.json

Returns content information for a specific channel configuration.

Parameters:

  • channel (string): Channel name
  • configId (integer): Configuration ID

Response: JSON containing content metadata (codec information, track details, etc.)

Get Segment

GET /{channel}/{configId}/{track}/{segment}

Retrieves a media segment file.

Parameters:

  • channel (string): Channel name
  • configId (integer): Configuration ID
  • track (string): Track identifier
  • segment (string): Segment filename (e.g., `12345.cmfv)

Response: Binary media segment data

Special Features:

  • Supports thumbnail generation with thumbnail query parameter
  • Returns appropriate Content-Type headers
  • Includes Edgeware-CBM: 1.44.4 header for compatibility

Pagination

The Management API uses cursor-based pagination for efficient handling of large result sets.

First Request:

GET /api/v1/content?channel=channel-1&limit=100

Response:

{
  "cursor": {
    "nextCursor": "eyJjaGFubmVsIjoiY2hhbm5lbC0xIiwic3RhcnRUaW1lIjoxNzEzMjU4MDAwfQ==",
    "limit": 100
  },
  "entries": [ ... ]
}

Next Page:

GET /api/v1/content?cursor=eyJjaGFubmVsIjoiY2hhbm5lbC0xIiwic3RhcnRUaW1lIjoxNzEzMjU4MDAwfQ==

Error Handling

All APIs use standard HTTP status codes:

  • 200 OK: Successful request
  • 204 No Content: Successful request with no response body
  • 400 Bad Request: Invalid request parameters
  • 404 Not Found: Resource not found
  • 409 Conflict: Resource conflict (e.g., duplicate refID)
  • 423 Locked: Resource locked (cannot perform operation in current state)
  • 424 Failed Dependency: Dependent operation failed
  • 500 Internal Server Error: Server error

Error responses include descriptive text in the response body.

7 - Releases

ESB3035 - ew-npvr releases

7.1 - Release 1.0.0

Initial release

Change log

Initial release

Compatibility has been verified with the following products:

  • Sw Repackager: 1.58.1
  • Sw Live Ingest: 1.48.3

Release information

  • Date: 2026-04-17
  • Type: Production release