Compare commits

..
Author SHA1 Message Date
Kilian Boute 0347c91ae8 feat: add external frame processing 2026-09-15 15:17:07 +00:00
75 changed files with 2311 additions and 6175 deletions
+1 -1
View File
@@ -18,7 +18,7 @@
}, },
"forwardPorts": [ "forwardPorts": [
3000, 3000,
8082 8080
], ],
"postCreateCommand": "cd ui && yarn install && yarn build && cd ../machinery && go mod download && bash ./verify-moq-devcontainer.sh" "postCreateCommand": "cd ui && yarn install && yarn build && cd ../machinery && go mod download && bash ./verify-moq-devcontainer.sh"
} }
+6 -1
View File
@@ -10,7 +10,7 @@ jobs:
build: build:
runs-on: ${{ matrix.runner }} runs-on: ${{ matrix.runner }}
permissions: permissions:
contents: read contents: write
strategy: strategy:
matrix: matrix:
include: include:
@@ -21,6 +21,11 @@ jobs:
steps: steps:
- name: Checkout - name: Checkout
uses: actions/checkout@v4 uses: actions/checkout@v4
- name: Login to DockerHub
uses: docker/login-action@v3
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Run Build - name: Run Build
run: | run: |
docker build --build-arg VERSION=$(echo "${{ github.event.pull_request.head.sha }}" | cut -c1-7) -t ${{ matrix.architecture }} . docker build --build-arg VERSION=$(echo "${{ github.event.pull_request.head.sha }}" | cut -c1-7) -t ${{ matrix.architecture }} .
+1 -1
View File
@@ -14,7 +14,7 @@
"-action", "-action",
"run", "run",
"-port", "-port",
"8082" "8080"
], ],
"envFile": "${workspaceFolder}/machinery/.env.local", "envFile": "${workspaceFolder}/machinery/.env.local",
"buildFlags": "--tags dynamic,moq", "buildFlags": "--tags dynamic,moq",
+17 -167
View File
@@ -76,60 +76,6 @@ There are a myriad of cameras out there (USB, IP and other cameras), and it migh
1. [What is new?](#what-is-new) 1. [What is new?](#what-is-new)
1. [Contributors](#contributors) 1. [Contributors](#contributors)
### Direct S3 recording layout
Direct S3 uploads store recordings as
`<s3.username>/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4`. The timestamp is the
recording's Unix timestamp in milliseconds, and the date is its UTC date, not the upload
date. Timestamp and device key come from the recording's `.metadata` upload
checkpoint, which stores the timestamp in milliseconds. The uploader also
preserves checkpoint duration, FPS (when available), and encryption status as S3
object metadata. The device key must be non-empty and contain no path separators.
Retried uploads use the same object key, even after midnight. Millisecond
precision keeps recordings starting within the same second distinct.
This replaces the previous `<s3.username>/<filename>.mp4` layout for new uploads.
Existing objects are not moved; consumers of direct S3 uploads must support both
layouts when reading historical recordings. Updated Kerberos Vault deployments
use the same filename and dated layout under the authenticated account directory
for both direct Vault uploads and Hub-proxied uploads.
Only historical recordings with missing, empty, or FPS-only queue markers fall
back to the legacy filename format and configured Agent key. A structured
checkpoint takes precedence over both the filename and current configured key;
an invalid or unreadable checkpoint is reported as an upload error, not silently
replaced with filename-derived values.
For older structured checkpoints, missing camera name, region, and change count
are recovered from a validated legacy filename. Populated checkpoint fields
take precedence, and the checkpoint timestamp and device key remain authoritative.
The shorter filename cannot be decoded by legacy filename-only consumers.
Integrations must preserve structured recording metadata, including the device
key (`productid`) and recording timestamp (`event-timestamp`), as well as the full
object key.
### Local recording layout
New local recordings are stored under
`data/recordings/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4`, using the recording's UTC
start date and Unix-millisecond timestamp. For example:
`data/recordings/2026/01/02/1767355200123-device-key.mp4`.
The filename no longer embeds the camera name, region, change count, or duration,
and it does not change when the recording is finalized.
Those attributes, together with FPS and encryption status, are captured in the
`.metadata` upload checkpoint and sent as structured HTTP/tus metadata.
Existing flat recordings and dated recordings with older long filenames remain
supported without a migration. Recording lists, day filters, playback, uploaders,
and automatic cleanup handle both filename formats and layouts. Upload queue
checkpoints remain flat in `data/cloud/`. Successful-upload removal also resolves
both local layouts. Deploy the updated Vault alongside Agent for canonical
`<account-directory>/yyyy/mm/dd/<timestamp>-<deviceKey>.mp4` storage keys and
metadata-driven Hub integration events.
Directory decryption also processes dated subdirectories and writes each output
to a sibling `decrypted/` directory; those outputs are excluded from recording
lists and automatic cleanup.
## Quickstart - Docker ## Quickstart - Docker
The easiest way to get your Kerberos Agent up and running is to use our public image on [Docker hub](https://hub.docker.com/r/kerberos/agent). Once you have selected a specific tag, run `docker` command below, which will open the web interface of your Kerberos agent on port `80`, and off you go. For a more configurable and persistent deployment have a look at [Running and automating a Kerberos Agent](#running-and-automating-a-kerberos-agent). The easiest way to get your Kerberos Agent up and running is to use our public image on [Docker hub](https://hub.docker.com/r/kerberos/agent). Once you have selected a specific tag, run `docker` command below, which will open the web interface of your Kerberos agent on port `80`, and off you go. For a more configurable and persistent deployment have a look at [Running and automating a Kerberos Agent](#running-and-automating-a-kerberos-agent).
@@ -384,7 +330,6 @@ See [RTSPS and TLS certificates](README-RTSPS-TLS.md) for the complete Bosch UI,
| `AGENT_CAPTURE_IPCAMERA_ONVIF_XADDR` | ONVIF endpoint/address running on the camera. | "" | | `AGENT_CAPTURE_IPCAMERA_ONVIF_XADDR` | ONVIF endpoint/address running on the camera. | "" |
| `AGENT_CAPTURE_IPCAMERA_ONVIF_USERNAME` | ONVIF username to authenticate against. | "" | | `AGENT_CAPTURE_IPCAMERA_ONVIF_USERNAME` | ONVIF username to authenticate against. | "" |
| `AGENT_CAPTURE_IPCAMERA_ONVIF_PASSWORD` | ONVIF password to authenticate against. | "" | | `AGENT_CAPTURE_IPCAMERA_ONVIF_PASSWORD` | ONVIF password to authenticate against. | "" |
| `AGENT_CAPTURE_IPCAMERA_ONVIF_CHANNEL` | 1-based channel on multi-channel ONVIF devices (encoders, NVRs) used for PTZ, presets and focus. | "0" (first profile) |
| `AGENT_CAPTURE_MOTION` | Toggle for enabling or disabling motion. | "true" | | `AGENT_CAPTURE_MOTION` | Toggle for enabling or disabling motion. | "true" |
| `AGENT_CAPTURE_LIVEVIEW` | Toggle for enabling or disabling liveview. | "true" | | `AGENT_CAPTURE_LIVEVIEW` | Toggle for enabling or disabling liveview. | "true" |
| `AGENT_CAPTURE_SNAPSHOTS` | Toggle for enabling or disabling snapshot generation. | "true" | | `AGENT_CAPTURE_SNAPSHOTS` | Toggle for enabling or disabling snapshot generation. | "true" |
@@ -402,6 +347,20 @@ See [RTSPS and TLS certificates](README-RTSPS-TLS.md) for the complete Bosch UI,
| `AGENT_REMOTE_ACCESS_ENABLED` | Allow encrypted Hub MQTT sessions to stream Agent logs and open an interactive shell. Enable only for trusted deployments. | "false" | | `AGENT_REMOTE_ACCESS_ENABLED` | Allow encrypted Hub MQTT sessions to stream Agent logs and open an interactive shell. Enable only for trusted deployments. | "false" |
| `AGENT_REALTIME_PROCESSING` | If `AGENT_REALTIME_PROCESSING` set to `true`, the agent will send key frames to the topic | "" | | `AGENT_REALTIME_PROCESSING` | If `AGENT_REALTIME_PROCESSING` set to `true`, the agent will send key frames to the topic | "" |
| `AGENT_REALTIME_PROCESSING_TOPIC` | The topic to which keyframes will be sent in base64 encoded format. | "" | | `AGENT_REALTIME_PROCESSING_TOPIC` | The topic to which keyframes will be sent in base64 encoded format. | "" |
| `AGENT_FRAME_PROCESSING_ENABLED` | Send keyframe-aligned JPEGs to an external Frame Processor over HTTP. | "false" |
| `AGENT_FRAME_PROCESSING_ENDPOINT` | Full Frame Processor HTTP endpoint, including `/v1/frames`. | "" |
| `AGENT_FRAME_PROCESSING_TOKEN` | Environment-only bearer token used to authenticate frame submissions; never returned by config APIs. | "" |
| `AGENT_FRAME_PROCESSING_PROFILE` | Processing profile included with each frame. | "never-trigger" |
| `AGENT_FRAME_PROCESSING_ALLOW_REQUESTED_FRAMES` | Allow authenticated MQTT `capture-frame` commands; frame bytes are still submitted over HTTP. | "false" |
| `AGENT_FRAME_PROCESSING_STREAM` | Source stream: `auto`, `main`, or `sub`; `auto` prefers the substream when available. | "auto" |
| `AGENT_FRAME_PROCESSING_INTERVAL_SECONDS` | Target period between submissions; the first keyframe at or after each deadline is selected. | "10" |
| `AGENT_FRAME_PROCESSING_WIDTH` | Output JPEG width; aspect ratio is preserved when height is `0`. | "640" |
| `AGENT_FRAME_PROCESSING_HEIGHT` | Output JPEG height; `0` derives it from the source aspect ratio. | "0" |
| `AGENT_FRAME_PROCESSING_JPEG_QUALITY` | JPEG quality from 1 through 100. | "70" |
| `AGENT_FRAME_PROCESSING_REQUEST_TIMEOUT_SECONDS` | Maximum duration of one HTTP submission. | "5" |
| `AGENT_FRAME_PROCESSING_FRAME_TTL_SECONDS` | Time after capture during which the Frame Processor may accept the frame. | "30" |
| `AGENT_FRAME_PROCESSING_MAX_FRAME_BYTES` | Maximum encoded JPEG size; values above 16 MiB are rejected. | "4194304" |
| `AGENT_FRAME_PROCESSING_PERIODIC_QUEUE_CAPACITY` | Bounded latest-wins periodic frame queue capacity, from 1 through 64. | "1" |
| `AGENT_STUN_URI` | When using WebRTC, you'll need to provide a STUN server. | "stun:turn-fra1.kerberos.io:3478"| | `AGENT_STUN_URI` | When using WebRTC, you'll need to provide a STUN server. | "stun:turn-fra1.kerberos.io:3478"|
| `AGENT_FORCE_TURN` | Force using a TURN server, by generating relay candidates only. | "false" | | `AGENT_FORCE_TURN` | Force using a TURN server, by generating relay candidates only. | "false" |
| `AGENT_TURN_URI` | When using WebRTC, you'll need to provide a TURN server. | "turn:turn-fra1.kerberos.io:3478"| | `AGENT_TURN_URI` | When using WebRTC, you'll need to provide a TURN server. | "turn:turn-fra1.kerberos.io:3478"|
@@ -420,13 +379,11 @@ See [RTSPS and TLS certificates](README-RTSPS-TLS.md) for the complete Bosch UI,
| `AGENT_KERBEROSVAULT_SECRET_KEY` | The secret key of a Kerberos Vault account. | "" | | `AGENT_KERBEROSVAULT_SECRET_KEY` | The secret key of a Kerberos Vault account. | "" |
| `AGENT_KERBEROSVAULT_PROVIDER` | A Kerberos Vault provider you have created (optional). | "" | | `AGENT_KERBEROSVAULT_PROVIDER` | A Kerberos Vault provider you have created (optional). | "" |
| `AGENT_KERBEROSVAULT_DIRECTORY` | The directory, in the Kerberos vault, where the recordings will be stored. | "" | | `AGENT_KERBEROSVAULT_DIRECTORY` | The directory, in the Kerberos vault, where the recordings will be stored. | "" |
| `AGENT_KERBEROSVAULT_CUSTOM_HEADERS` | JSON object of custom upload headers that Vault includes as integration metadata. | `{"site_id":"site-1"}` |
| `AGENT_KERBEROSVAULT_SECONDARY_URI` | The Kerberos Vault API url. | "https://vault.domain.com/api" | | `AGENT_KERBEROSVAULT_SECONDARY_URI` | The Kerberos Vault API url. | "https://vault.domain.com/api" |
| `AGENT_KERBEROSVAULT_SECONDARY_ACCESS_KEY` | The access key of a secondary Kerberos Vault account. | "" | | `AGENT_KERBEROSVAULT_SECONDARY_ACCESS_KEY` | The access key of a secondary Kerberos Vault account. | "" |
| `AGENT_KERBEROSVAULT_SECONDARY_SECRET_KEY` | The secret key of a secondary Kerberos Vault account. | "" | | `AGENT_KERBEROSVAULT_SECONDARY_SECRET_KEY` | The secret key of a secondary Kerberos Vault account. | "" |
| `AGENT_KERBEROSVAULT_SECONDARY_PROVIDER` | A secondary Kerberos Vault provider you have created (optional). | "" | | `AGENT_KERBEROSVAULT_SECONDARY_PROVIDER` | A secondary Kerberos Vault provider you have created (optional). | "" |
| `AGENT_KERBEROSVAULT_SECONDARY_DIRECTORY` | The directory, in the secondary Kerberos vault, where the recordings will be stored. | "" | | `AGENT_KERBEROSVAULT_SECONDARY_DIRECTORY` | The directory, in the secondary Kerberos vault, where the recordings will be stored. | "" |
| `AGENT_KERBEROSVAULT_SECONDARY_CUSTOM_HEADERS` | JSON object of custom upload headers for the secondary Vault. | `{"site_id":"site-1"}` |
| `AGENT_DROPBOX_ACCESS_TOKEN` | The Access Token from your Dropbox app, that is used to leverage the Dropbox SDK. | "" | | `AGENT_DROPBOX_ACCESS_TOKEN` | The Access Token from your Dropbox app, that is used to leverage the Dropbox SDK. | "" |
| `AGENT_DROPBOX_DIRECTORY` | The directory, in Dropbox, where the recordings will be stored. | "" | | `AGENT_DROPBOX_DIRECTORY` | The directory, in Dropbox, where the recordings will be stored. | "" |
| `AGENT_ENCRYPTION` | Enable 'true' or disable 'false' end-to-end encryption for MQTT messages. | "false" | | `AGENT_ENCRYPTION` | Enable 'true' or disable 'false' end-to-end encryption for MQTT messages. | "false" |
@@ -465,105 +422,6 @@ Smaller chunks provide more frequent resumable checkpoints but create more HTTP
requests. Larger chunks reduce request overhead but require more data to be requests. Larger chunks reduce request overhead but require more data to be
retransmitted when a request fails. retransmitted when a request fails.
An HTTP 500 during resumable creation is a server/provider failure, not proof
that the recording filename is invalid. Creation errors include up to 4 KiB of
the server response, and the final retry error retains the latest failure cause.
Created upload sessions remain usable if only the optional creation response
body is interrupted; the successful response's `Location` is retained.
Check the corresponding Hub/Vault logs and storage-provider configuration.
As a temporary diagnostic workaround, set `AGENT_DISABLE_RESUMABLE_UPLOAD=true`
and restart Agent to use ordinary uploads. This does not change the recording
filename or remove its structured metadata, but interrupted uploads restart
from the beginning. Remove the override after fixing the provider issue.
### Custom metadata headers for Kerberos Vault
Use `AGENT_KERBEROSVAULT_CUSTOM_HEADERS` to attach your own metadata (for
example a site, line, or equipment identifier) to every recording uploaded to
Kerberos Vault. The value is a JSON object whose keys are header names and whose
values are strings. The Agent sends these as HTTP headers on every upload, and
Vault adds them to the `metadata` object of its integration messages (Kafka,
MQTT, SQS, RabbitMQ, etc.):
```json
{
"timestamp": "2026-09-24T15:06:45Z",
"key": "agent1/1790262405_3-425_agent1_0-0-0-0_-1_10000.mp4",
"device": "agent1",
"metadata": {
"site_id": "site-1",
"line_id": "line-2",
"equipment_id": "equipment-3"
}
}
```
The value must be valid JSON on a single line, so wrap it in single quotes in a
shell:
```bash
docker run -p 80:80 --name mycamera \
-e AGENT_CLOUD=kstorage \
-e AGENT_KERBEROSVAULT_URI=https://vault.domain.com/api \
-e AGENT_KERBEROSVAULT_ACCESS_KEY=xxx \
-e AGENT_KERBEROSVAULT_SECRET_KEY=xxx \
-e AGENT_KERBEROSVAULT_DIRECTORY=agent1 \
-e AGENT_KERBEROSVAULT_CUSTOM_HEADERS='{"site_id":"site-1","line_id":"line-2","equipment_id":"equipment-3"}' \
-d --restart=always kerberos/agent:latest
```
In `docker compose` or an `.env` file:
```yaml
services:
agent:
image: kerberos/agent:latest
environment:
AGENT_CLOUD: kstorage
AGENT_KERBEROSVAULT_CUSTOM_HEADERS: '{"site_id":"site-1","line_id":"line-2","equipment_id":"equipment-3"}'
```
```dotenv
AGENT_KERBEROSVAULT_CUSTOM_HEADERS={"site_id":"site-1","line_id":"line-2","equipment_id":"equipment-3"}
```
In Kubernetes, quote the value so YAML keeps it as a string:
```yaml
env:
- name: AGENT_KERBEROSVAULT_CUSTOM_HEADERS
value: '{"site_id":"site-1","line_id":"line-2","equipment_id":"equipment-3"}'
```
Use `AGENT_KERBEROSVAULT_SECONDARY_CUSTOM_HEADERS` for the secondary Vault. In
ConfigMap deployments you can set shared defaults with the `GLOBAL_` prefix
(for example `GLOBAL_AGENT_KERBEROSVAULT_CUSTOM_HEADERS`) and override them per
agent with `AGENT_KERBEROSVAULT_CUSTOM_HEADERS`. You can also set the same JSON
under **Settings → Persistence → Custom upload headers** in the Agent UI, which
stores it as `kstorage.custom_headers` in `config.json`.
The rules for this value are:
- It must be a JSON object with string values. Numbers, `null`, arrays, and
nested objects are rejected.
- It can contain up to 32 headers, with names up to 128 characters and values
up to 4096 bytes.
- Header names must be valid HTTP tokens (letters, digits, and ``!#$%&'*+-.^_`|~``).
Keys are matched case-insensitively, so `site_id` and `SITE_ID` cannot both
be used.
- Reserved names are rejected: anything starting with `X-Kerberos-`,
`Authorization`, `Cookie`, `Host`, `Content-Type`, `Content-Length`,
`Trace-Id`, tus protocol headers (`Tus-Resumable`, `Upload-*`), and
hop-by-hop headers.
- Values cannot contain line breaks, tabs, or other control characters.
If the value is invalid, the Agent logs an error and does not upload to that
Vault until the configuration is fixed. The recording stays queued, so it will
upload once the value is corrected. Header names reach Vault unchanged, but
proxies may normalise their casing. If Vault redirects an upload to another
host, the Agent removes the custom headers and Vault credentials before
following the redirect.
## Encryption ## Encryption
@@ -668,10 +526,7 @@ The `web` is a **React** project which is the main entry point for an end user t
cd ui cd ui
yarn start yarn start
This starts the web app on port `3000`. In development, the UI connects to the This will start a webserver and launches the web app on port `3000`.
Agent API on port `8082`. Override that port when needed:
REACT_APP_AGENT_API_PORT=9090 yarn start
![login-agent](./assets/img/agent-login.gif) ![login-agent](./assets/img/agent-login.gif)
@@ -687,14 +542,9 @@ You can simply run the `machinery` using following commands.
git clone https://github.com/kerberos-io/agent git clone https://github.com/kerberos-io/agent
cd machinery cd machinery
go run main.go -action run -port 8082 go run main.go -action run -port 80
This will launch the Kerberos Agent and run a webserver on port `8082`, matching This will launch the Kerberos Agent and run a webserver on port `80`. You can change the port by your own preference. We strongly support the usage of [Goland](https://www.jetbrains.com/go/) or [Visual Studio Code](https://code.visualstudio.com/), as it comes with all the debugging and linting features built in.
the UI development default. You can change the port together with
`REACT_APP_AGENT_API_PORT`. We strongly support the usage of
[Goland](https://www.jetbrains.com/go/) or
[Visual Studio Code](https://code.visualstudio.com/), as it comes with all the
debugging and linting features built in.
![VSCode desktop](./assets/img/vscode-desktop.png) ![VSCode desktop](./assets/img/vscode-desktop.png)
-25
View File
@@ -26,28 +26,3 @@ Kerberos Open source (v3) is a cutting edge video surveillance management system
## Security reporting ## Security reporting
For sensitive vulnerabilities, use private disclosure channels documented in [../SECURITY.md](../SECURITY.md). For sensitive vulnerabilities, use private disclosure channels documented in [../SECURITY.md](../SECURITY.md).
## WebRTC startup and keyframe recovery
Each H264 viewer waits until its WebRTC transport is connected and a fresh IDR
arrives before receiving video. Reconnects, viewer PLI/FIR feedback, and a full
per-viewer sample buffer reset that viewer's keyframe gate without stalling
other viewers. Audio continues to use the existing independent sample queues.
Each viewer's skipped and discarded video durations advance its RTP clock before
recovery, without sending filler packets, so an IDR wait does not compress the
video timeline relative to audio.
The main and sub streams request keyframes from their own RTSP sources. Viewer
PLI and FIR feedback is translated into an RTSP PLI using the camera session's
SSRCs, never forwarded with the browser's SSRCs. Requests are coalesced and
limited to one per second per broadcaster, retrying while connected viewers
still need an IDR. Requests stop once all waiting viewers receive an IDR or
the broadcaster closes.
Camera support for RTCP PLI varies. Unsupported sources, cameras that ignore
feedback, and failed requests fall back to the next periodic IDR; failures are
logged as `keyframe_request_failed`. No encoder settings are changed. A camera
with a long GOP can therefore still start slowly; configure a shorter IDR
interval (for example 1-2 seconds) when camera feedback is unavailable, accounting
for the bandwidth tradeoff. An isolated cached IDR must not be replayed followed
by arbitrary live P-frames: the dependent reference chain would be incomplete.
+15
View File
@@ -120,6 +120,21 @@
"condition_uri": "", "condition_uri": "",
"encryption": {}, "encryption": {},
"signing": {}, "signing": {},
"frameProcessing": {
"enabled": "false",
"endpoint": "",
"profile": "never-trigger",
"allowRequestedFrames": "false",
"stream": "auto",
"intervalSeconds": 10,
"width": 640,
"height": 0,
"jpegQuality": 70,
"requestTimeoutSeconds": 5,
"frameTtlSeconds": 30,
"maxFrameBytes": 4194304,
"periodicQueueCapacity": 1
},
"realtimeprocessing": "false", "realtimeprocessing": "false",
"realtimeprocessing_topic": "" "realtimeprocessing_topic": ""
} }
-3
View File
@@ -1296,9 +1296,6 @@ const docTemplate = `{
"description": "old way, remove this", "description": "old way, remove this",
"type": "string" "type": "string"
}, },
"custom_headers": {
"type": "string"
},
"directory": { "directory": {
"type": "string" "type": "string"
}, },
-3
View File
@@ -1289,9 +1289,6 @@
"description": "old way, remove this", "description": "old way, remove this",
"type": "string" "type": "string"
}, },
"custom_headers": {
"type": "string"
},
"directory": { "directory": {
"type": "string" "type": "string"
}, },
+2 -2
View File
@@ -25,12 +25,11 @@ require (
github.com/gorilla/websocket v1.5.3 github.com/gorilla/websocket v1.5.3
github.com/kellydunn/golang-geo v0.7.0 github.com/kellydunn/golang-geo v0.7.0
github.com/kerberos-io/joy4 v1.0.64 github.com/kerberos-io/joy4 v1.0.64
github.com/kerberos-io/onvif v1.2.3 github.com/kerberos-io/onvif v1.2.2
github.com/minio/minio-go/v6 v6.0.57 github.com/minio/minio-go/v6 v6.0.57
github.com/moq-dev/moq-go v0.5.7 github.com/moq-dev/moq-go v0.5.7
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
github.com/pion/interceptor v0.1.47 github.com/pion/interceptor v0.1.47
github.com/pion/rtcp v1.2.17
github.com/pion/rtp v1.10.5 github.com/pion/rtp v1.10.5
github.com/pion/webrtc/v4 v4.2.18 github.com/pion/webrtc/v4 v4.2.18
github.com/sirupsen/logrus v1.9.3 github.com/sirupsen/logrus v1.9.3
@@ -105,6 +104,7 @@ require (
github.com/pion/logging v0.2.4 // indirect github.com/pion/logging v0.2.4 // indirect
github.com/pion/mdns/v2 v2.1.0 // indirect github.com/pion/mdns/v2 v2.1.0 // indirect
github.com/pion/randutil v0.1.0 // indirect github.com/pion/randutil v0.1.0 // indirect
github.com/pion/rtcp v1.2.17 // indirect
github.com/pion/sctp v1.11.1 // indirect github.com/pion/sctp v1.11.1 // indirect
github.com/pion/sdp/v3 v3.0.19 // indirect github.com/pion/sdp/v3 v3.0.19 // indirect
github.com/pion/srtp/v3 v3.0.12 // indirect github.com/pion/srtp/v3 v3.0.12 // indirect
+2 -2
View File
@@ -776,8 +776,8 @@ github.com/kellydunn/golang-geo v0.7.0 h1:A5j0/BvNgGwY6Yb6inXQxzYwlPHc6WVZR+Mrar
github.com/kellydunn/golang-geo v0.7.0/go.mod h1:YYlQPJ+DPEzrHx8kT3oPHC/NjyvCCXE+IuKGKdrjrcU= github.com/kellydunn/golang-geo v0.7.0/go.mod h1:YYlQPJ+DPEzrHx8kT3oPHC/NjyvCCXE+IuKGKdrjrcU=
github.com/kerberos-io/joy4 v1.0.64 h1:gTUSotHSOhp9mNqEecgq88tQHvpj7TjmrvPUsPm0idg= github.com/kerberos-io/joy4 v1.0.64 h1:gTUSotHSOhp9mNqEecgq88tQHvpj7TjmrvPUsPm0idg=
github.com/kerberos-io/joy4 v1.0.64/go.mod h1:nZp4AjvKvTOXRrmDyAIOw+Da+JA5OcSo/JundGfOlFU= github.com/kerberos-io/joy4 v1.0.64/go.mod h1:nZp4AjvKvTOXRrmDyAIOw+Da+JA5OcSo/JundGfOlFU=
github.com/kerberos-io/onvif v1.2.3 h1:RDnDvLBd92VCgFOrlbGavzCVN9lQA/qs9novdNFIAOU= github.com/kerberos-io/onvif v1.2.2 h1:QnxITps7xvAVD2abWRsa3+p9QexjKESQQldUFMx/mYA=
github.com/kerberos-io/onvif v1.2.3/go.mod h1:XSgEQXmEDjUQTbdXvsaRJt6Az8YPGj7L+j5iXKEGijU= github.com/kerberos-io/onvif v1.2.2/go.mod h1:XSgEQXmEDjUQTbdXvsaRJt6Az8YPGj7L+j5iXKEGijU=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE= github.com/klauspost/asmfmt v1.3.2/go.mod h1:AG8TuvYojzulgDAMCnYn50l/5QV3Bs/tp6j0HLHbNSE=
-47
View File
@@ -10,58 +10,11 @@ import (
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
) )
func TestPickRecordingToCleanupAcrossDatedDirectories(t *testing.T) {
for _, legacyMarker := range []bool{false, true} {
t.Run(map[bool]string{false: "metadata", true: "legacy"}[legacyMarker], func(t *testing.T) {
recordingsDir, cloudDir := newCleanupDirs(t)
pendingName := "2026/01/01/oldest_pending.mp4"
safeName := "2026/01/02/uploaded.mp4"
writeRecording(t, recordingsDir, pendingName, 30)
if legacyMarker {
if err := os.WriteFile(filepath.Join(cloudDir, filepath.Base(pendingName)), nil, 0o644); err != nil {
t.Fatal(err)
}
} else {
markPending(t, cloudDir, pendingName)
}
writeRecording(t, recordingsDir, safeName, 20)
writeRecording(t, recordingsDir, "flat_uploaded.mp4", 10)
name, pending, err := pickRecordingToCleanup(recordingsDir, cloudDir)
if err != nil || pending || name != safeName {
t.Fatalf("cleanup = (%q, %v, %v), want (%q, false, nil)", name, pending, err, safeName)
}
})
}
}
func TestCleanupDatedPendingRecordingRemovesFlatMarker(t *testing.T) {
recordingsDir, cloudDir := newCleanupDirs(t)
name := "2026/01/01/pending.mp4"
if err := os.MkdirAll(filepath.Dir(filepath.Join(recordingsDir, name)), 0o755); err != nil {
t.Fatal(err)
}
writeSizedRecording(t, recordingsDir, name, 2*1000*1000)
markPending(t, cloudDir, name)
config := &models.Configuration{Config: models.Config{AutoClean: "true", MaxDirectorySize: 1}}
CleanupRecordingDirectory(filepath.Dir(filepath.Dir(recordingsDir)), config)
for _, filePath := range []string{
filepath.Join(recordingsDir, name),
filepath.Join(cloudDir, models.RecordingUploadMetadataFileName(name)),
} {
if _, err := os.Stat(filePath); !os.IsNotExist(err) {
t.Fatalf("expected %s to be removed, got %v", filePath, err)
}
}
}
// writeRecording creates a file under recordingsDir and sets its modtime so the // writeRecording creates a file under recordingsDir and sets its modtime so the
// tests can control the "oldest" ordering deterministically. // tests can control the "oldest" ordering deterministically.
func writeRecording(t *testing.T, recordingsDir, name string, ageMinutes int) { func writeRecording(t *testing.T, recordingsDir, name string, ageMinutes int) {
t.Helper() t.Helper()
full := filepath.Join(recordingsDir, name) full := filepath.Join(recordingsDir, name)
if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
t.Fatalf("mkdir recording directory: %v", err)
}
if err := os.WriteFile(full, []byte("data"), 0o644); err != nil { if err := os.WriteFile(full, []byte("data"), 0o644); err != nil {
t.Fatalf("write recording %s: %v", name, err) t.Fatalf("write recording %s: %v", name, err)
} }
+13 -258
View File
@@ -32,7 +32,6 @@ import (
"github.com/bluenviron/gortsplib/v5/pkg/format/rtplpcm" "github.com/bluenviron/gortsplib/v5/pkg/format/rtplpcm"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg4audio" "github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg4audio"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpsimpleaudio" "github.com/bluenviron/gortsplib/v5/pkg/format/rtpsimpleaudio"
"github.com/bluenviron/mediacommon/pkg/bits"
"github.com/bluenviron/mediacommon/pkg/codecs/h264" "github.com/bluenviron/mediacommon/pkg/codecs/h264"
"github.com/bluenviron/mediacommon/pkg/codecs/h265" "github.com/bluenviron/mediacommon/pkg/codecs/h265"
"github.com/bluenviron/mediacommon/pkg/codecs/mpeg4audio" "github.com/bluenviron/mediacommon/pkg/codecs/mpeg4audio"
@@ -101,8 +100,6 @@ type Golibrtsp struct {
Client gortsplib.Client Client gortsplib.Client
clientStarted bool clientStarted bool
VideoDecoderMutex *sync.Mutex VideoDecoderMutex *sync.Mutex
keyframeMu sync.Mutex
keyframeReady bool
VideoH264Index int8 VideoH264Index int8
VideoH264Media *description.Media VideoH264Media *description.Media
@@ -162,10 +159,13 @@ type Golibrtsp struct {
} }
// streamHealth instruments the RTSP read path. gortsplib delivers every RTP // streamHealth instruments the RTSP read path. gortsplib delivers every RTP
// packet on a single read goroutine, so prolonged queue lock contention or // packet on a single read goroutine; queue.WritePacket() is synchronous, so if
// process starvation can delay socket reads. Queue consumers process packets // a downstream consumer (recording, muxing, WebRTC) is slow or the process is
// after releasing the lock; a slow recorder therefore falls behind its cursor // CPU-starved, WritePacket() blocks, the TCP socket is not drained, and the
// instead of directly blocking WritePacket. // camera advances RTP sequence numbers -> "RTP packets lost". This type makes
// the two failure modes distinguishable:
// - large writeMax / writeAvg => downstream back-pressure (our side).
// - large gapMax with fast writes => upstream network / camera stall.
type streamHealth struct { type streamHealth struct {
mu sync.Mutex mu sync.Mutex
windowStart time.Time windowStart time.Time
@@ -178,152 +178,6 @@ type streamHealth struct {
decodeErrs int64 decodeErrs int64
} }
type videoReferenceState struct {
haveSequence bool
lastSequence uint16
valid bool
droppedAccessUnits uint64
}
type h264FrameNumTracker struct {
sps *h264.SPS
haveFrameNum bool
lastFrameNum uint32
}
const maxH264SliceHeaderBytes = 64
func (t *h264FrameNumTracker) setSPS(sps *h264.SPS) {
if sps == nil {
return
}
if t.sps == nil ||
t.sps.Log2MaxFrameNumMinus4 != sps.Log2MaxFrameNumMinus4 ||
t.sps.SeparateColourPlaneFlag != sps.SeparateColourPlaneFlag ||
t.sps.FrameMbsOnlyFlag != sps.FrameMbsOnlyFlag {
t.haveFrameNum = false
}
copy := *sps
t.sps = &copy
}
func (t *h264FrameNumTracker) observe(au [][]byte) (uint32, uint32, bool, bool) {
if t.sps == nil || !t.sps.FrameMbsOnlyFlag {
return 0, 0, false, false
}
for _, nalu := range au {
if len(nalu) == 0 {
continue
}
naluType := h264.NALUType(nalu[0] & 0x1F)
if naluType != h264.NALUTypeIDR && naluType != h264.NALUTypeNonIDR {
continue
}
frameNum, err := h264SliceFrameNum(nalu, t.sps)
if err != nil {
return 0, 0, false, false
}
if naluType == h264.NALUTypeIDR {
t.haveFrameNum = true
t.lastFrameNum = frameNum
return frameNum, frameNum, false, true
}
// Non-reference pictures do not advance the reference-picture frame_num
// sequence and therefore cannot prove that a reference picture is missing.
if (nalu[0]>>5)&0x03 == 0 {
return frameNum, frameNum, false, true
}
if !t.haveFrameNum {
t.haveFrameNum = true
t.lastFrameNum = frameNum
return frameNum, frameNum, false, true
}
frameNumBits := t.sps.Log2MaxFrameNumMinus4 + 4
if frameNumBits > 16 {
return 0, 0, false, false
}
maxFrameNum := uint32(1) << frameNumBits
expected := (t.lastFrameNum + 1) & (maxFrameNum - 1)
// When the SPS permits frame_num gaps, the decoder is required to
// synthesize non-existing pictures and the discontinuity is not evidence
// of transport loss. RTP/depacketizer errors still invalidate references.
gap := frameNum != expected && !t.sps.GapsInFrameNumValueAllowedFlag
t.lastFrameNum = frameNum
return expected, frameNum, gap, true
}
return 0, 0, false, false
}
func h264SliceFrameNum(nalu []byte, sps *h264.SPS) (uint32, error) {
if len(nalu) < 2 || sps == nil {
return 0, errors.New("H264 slice or SPS is missing")
}
frameNumBits := sps.Log2MaxFrameNumMinus4 + 4
if frameNumBits > 16 {
return 0, fmt.Errorf("invalid H264 frame_num width: %d", frameNumBits)
}
header := nalu[1:]
if len(header) > maxH264SliceHeaderBytes {
header = header[:maxH264SliceHeaderBytes]
}
header = h264.EmulationPreventionRemove(header)
pos := 0
for range 3 {
if _, err := bits.ReadGolombUnsigned(header, &pos); err != nil {
return 0, fmt.Errorf("read H264 slice header: %w", err)
}
}
if sps.SeparateColourPlaneFlag {
if _, err := bits.ReadBits(header, &pos, 2); err != nil {
return 0, fmt.Errorf("read H264 colour plane: %w", err)
}
}
frameNum, err := bits.ReadBits(header, &pos, int(frameNumBits))
if err != nil {
return 0, fmt.Errorf("read H264 frame_num: %w", err)
}
return uint32(frameNum), nil
}
func (s *videoReferenceState) observeSequence(sequence uint16) (uint16, bool) {
expected := sequence
gap := false
if s.haveSequence {
expected = s.lastSequence + 1
gap = sequence != expected
if gap {
s.valid = false
}
}
s.haveSequence = true
s.lastSequence = sequence
return expected, gap
}
func (s *videoReferenceState) invalidate() {
s.valid = false
}
func (s *videoReferenceState) accept(randomAccess bool) (bool, uint64) {
if randomAccess {
dropped := s.droppedAccessUnits
s.droppedAccessUnits = 0
s.valid = true
return true, dropped
}
if !s.valid {
s.droppedAccessUnits++
return false, 0
}
return true, 0
}
const ( const (
streamHealthWindow = 10 * time.Second streamHealthWindow = 10 * time.Second
streamHealthWriteWarn = 150 * time.Millisecond streamHealthWriteWarn = 150 * time.Millisecond
@@ -336,9 +190,9 @@ func newStreamHealth() *streamHealth {
} }
// observePacket records one processed video frame: the wall-clock gap since the // observePacket records one processed video frame: the wall-clock gap since the
// previous frame and how long WritePacket spent acquiring and updating the // previous frame (arrival cadence) and how long WritePacket() blocked
// queue. It emits an immediate warning when either side stalls and a periodic // (back-pressure). It emits an immediate warning when either side stalls and a
// summary every streamHealthWindow. // periodic summary every streamHealthWindow.
func (h *streamHealth) observePacket(streamType string, writeDur time.Duration) { func (h *streamHealth) observePacket(streamType string, writeDur time.Duration) {
if h == nil { if h == nil {
return return
@@ -410,9 +264,9 @@ func (h *streamHealth) observePacket(streamType string, writeDur time.Duration)
} }
} }
// observeLost is invoked by gortsplib when RTP sequence numbers skip. With the // observeLost is invoked by gortsplib when RTP sequence numbers skip. On a TCP
// configured TCP transport, the sender or an upstream RTSP component omitted // transport this means the sender (camera) dropped packets because we were not
// those packets; sender-side pressure is one possible cause. // reading fast enough, not loss on the wire.
func (h *streamHealth) observeLost(streamType string, lost uint64) { func (h *streamHealth) observeLost(streamType string, lost uint64) {
if h == nil { if h == nil {
return return
@@ -815,10 +669,6 @@ func (g *Golibrtsp) Connect(ctx context.Context, ctxOtel context.Context) (err e
} }
} }
g.keyframeMu.Lock()
g.keyframeReady = err == nil && g.VideoH264Media != nil && g.VideoH264Decoder != nil
g.keyframeMu.Unlock()
return return
} }
@@ -1037,14 +887,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
// called when a video RTP packet arrives for H264 // called when a video RTP packet arrives for H264
var filteredAU [][]byte var filteredAU [][]byte
if g.VideoH264Media != nil && g.VideoH264Forma != nil { if g.VideoH264Media != nil && g.VideoH264Forma != nil {
referenceState := &videoReferenceState{}
frameNumTracker := &h264FrameNumTracker{}
if len(g.VideoH264Forma.SPS) > 0 {
var sps h264.SPS
if sps.Unmarshal(g.VideoH264Forma.SPS) == nil {
frameNumTracker.setSPS(&sps)
}
}
// Extracts DTS from the bitstream to support B-frame H264 streams. // Extracts DTS from the bitstream to support B-frame H264 streams.
// Created once per stream (tracks reorder state across access units). // Created once per stream (tracks reorder state across access units).
@@ -1060,16 +902,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
default: default:
} }
if expected, gap := referenceState.observeSequence(rtppkt.SequenceNumber); gap {
log.WithFields(log.Fields{
"component": "capture",
"event": "video_rtp_sequence_gap",
"expected_sequence_number": expected,
"received_sequence_number": rtppkt.SequenceNumber,
"stream": streamType,
}).Warn("RTP sequence gap invalidated video reference chain")
}
if len(rtppkt.Payload) > 0 { if len(rtppkt.Payload) > 0 {
// decode timestamps — validate each call separately // decode timestamps — validate each call separately
@@ -1085,9 +917,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
// this is a keyframe. // this is a keyframe.
au, errDecode := g.VideoH264Decoder.Decode(rtppkt) au, errDecode := g.VideoH264Decoder.Decode(rtppkt)
if errDecode != nil { if errDecode != nil {
if errDecode != rtph264.ErrMorePacketsNeeded {
referenceState.invalidate()
}
if errDecode != rtph264.ErrNonStartingPacketAndNoPrevious && errDecode != rtph264.ErrMorePacketsNeeded { if errDecode != rtph264.ErrNonStartingPacketAndNoPrevious && errDecode != rtph264.ErrMorePacketsNeeded {
log.Error("capture.golibrtsp.Start(): " + errDecode.Error()) log.Error("capture.golibrtsp.Start(): " + errDecode.Error())
} }
@@ -1132,7 +961,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
if errSPS == nil { if errSPS == nil {
// Debug SPS information // Debug SPS information
g.debugSPSInfo(&sps, streamType) g.debugSPSInfo(&sps, streamType)
frameNumTracker.setSPS(&sps)
// Get width // Get width
g.Streams[g.VideoH264Index].Width = sps.Width() g.Streams[g.VideoH264Index].Width = sps.Width()
@@ -1194,39 +1022,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
return return
} }
if expected, received, gap, ok := frameNumTracker.observe(au); ok && gap {
referenceState.invalidate()
log.WithFields(log.Fields{
"component": "capture",
"event": "h264_frame_num_gap",
"expected_frame_num": expected,
"received_frame_num": received,
"stream": streamType,
}).Warn("H264 frame_num gap invalidated video reference chain")
}
accepted, recoveredDropped := referenceState.accept(idrPresent)
if !accepted {
if referenceState.droppedAccessUnits == 1 {
log.WithFields(log.Fields{
"codec": "H264",
"component": "capture",
"event": "dependent_access_units_dropped",
"stream": streamType,
}).Warn("Dropping dependent video frames until the next IDR")
}
return
}
if recoveredDropped > 0 {
log.WithFields(log.Fields{
"codec": "H264",
"component": "capture",
"dropped_access_units": recoveredDropped,
"event": "video_reference_chain_recovered",
"stream": streamType,
}).Info("Video reference chain recovered at IDR")
}
if idrPresent { if idrPresent {
log.WithFields(log.Fields{ log.WithFields(log.Fields{
"component": "capture", "component": "capture",
@@ -1370,7 +1165,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
// called when a video RTP packet arrives for H265 // called when a video RTP packet arrives for H265
if g.VideoH265Media != nil && g.VideoH265Forma != nil { if g.VideoH265Media != nil && g.VideoH265Forma != nil {
referenceState := &videoReferenceState{}
// Extracts DTS from the bitstream to support B-frame H265 streams. // Extracts DTS from the bitstream to support B-frame H265 streams.
// Created once per stream (tracks reorder state across access units). // Created once per stream (tracks reorder state across access units).
@@ -1386,16 +1180,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
default: default:
} }
if expected, gap := referenceState.observeSequence(rtppkt.SequenceNumber); gap {
log.WithFields(log.Fields{
"component": "capture",
"event": "video_rtp_sequence_gap",
"expected_sequence_number": expected,
"received_sequence_number": rtppkt.SequenceNumber,
"stream": streamType,
}).Warn("RTP sequence gap invalidated video reference chain")
}
if len(rtppkt.Payload) > 0 { if len(rtppkt.Payload) > 0 {
// decode timestamps — validate each call separately // decode timestamps — validate each call separately
@@ -1411,9 +1195,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
// this is a keyframe. // this is a keyframe.
au, errDecode := g.VideoH265Decoder.Decode(rtppkt) au, errDecode := g.VideoH265Decoder.Decode(rtppkt)
if errDecode != nil { if errDecode != nil {
if errDecode != rtph265.ErrMorePacketsNeeded {
referenceState.invalidate()
}
if errDecode != rtph265.ErrNonStartingPacketAndNoPrevious && errDecode != rtph265.ErrMorePacketsNeeded { if errDecode != rtph265.ErrNonStartingPacketAndNoPrevious && errDecode != rtph265.ErrMorePacketsNeeded {
log.Error("capture.golibrtsp.Start(): " + errDecode.Error()) log.Error("capture.golibrtsp.Start(): " + errDecode.Error())
} }
@@ -1463,28 +1244,6 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
return return
} }
accepted, recoveredDropped := referenceState.accept(isRandomAccess)
if !accepted {
if referenceState.droppedAccessUnits == 1 {
log.WithFields(log.Fields{
"codec": "H265",
"component": "capture",
"event": "dependent_access_units_dropped",
"stream": streamType,
}).Warn("Dropping dependent video frames until the next random-access frame")
}
return
}
if recoveredDropped > 0 {
log.WithFields(log.Fields{
"codec": "H265",
"component": "capture",
"dropped_access_units": recoveredDropped,
"event": "video_reference_chain_recovered",
"stream": streamType,
}).Info("Video reference chain recovered at random-access frame")
}
// add VPS, SPS and PPS before random access access unit // add VPS, SPS and PPS before random access access unit
if isRandomAccess { if isRandomAccess {
au = append([][]byte{ au = append([][]byte{
@@ -1719,10 +1478,6 @@ func (g *Golibrtsp) Close(ctxOtel context.Context) error {
_, span := tracer.Start(ctxOtel, "Close") _, span := tracer.Start(ctxOtel, "Close")
defer span.End() defer span.End()
g.keyframeMu.Lock()
g.keyframeReady = false
g.keyframeMu.Unlock()
if !g.clientStarted { if !g.clientStarted {
return nil return nil
} }
-113
View File
@@ -11,8 +11,6 @@ import (
"path/filepath" "path/filepath"
"strings" "strings"
"testing" "testing"
"github.com/bluenviron/mediacommon/pkg/codecs/h264"
) )
func TestPreRecordingGOPCount(t *testing.T) { func TestPreRecordingGOPCount(t *testing.T) {
@@ -136,114 +134,3 @@ func TestRTSPSTLSConfig(t *testing.T) {
} }
}) })
} }
func TestVideoReferenceStateDropsDependentFramesUntilRandomAccess(t *testing.T) {
state := &videoReferenceState{}
accepted, recovered := state.accept(false)
if accepted || recovered != 0 || state.droppedAccessUnits != 1 {
t.Fatalf("initial dependent frame = (accepted=%t, recovered=%d, dropped=%d), want (false, 0, 1)",
accepted, recovered, state.droppedAccessUnits)
}
accepted, recovered = state.accept(true)
if !accepted || recovered != 1 || !state.valid {
t.Fatalf("random-access recovery = (accepted=%t, recovered=%d, valid=%t), want (true, 1, true)",
accepted, recovered, state.valid)
}
if expected, gap := state.observeSequence(100); gap || expected != 100 {
t.Fatalf("first sequence observation = (expected=%d, gap=%t), want (100, false)", expected, gap)
}
if expected, gap := state.observeSequence(102); !gap || expected != 101 || state.valid {
t.Fatalf("sequence gap = (expected=%d, gap=%t, valid=%t), want (101, true, false)",
expected, gap, state.valid)
}
accepted, recovered = state.accept(false)
if accepted || recovered != 0 || state.droppedAccessUnits != 1 {
t.Fatalf("post-loss dependent frame = (accepted=%t, recovered=%d, dropped=%d), want (false, 0, 1)",
accepted, recovered, state.droppedAccessUnits)
}
accepted, recovered = state.accept(true)
if !accepted || recovered != 1 || !state.valid {
t.Fatalf("post-loss recovery = (accepted=%t, recovered=%d, valid=%t), want (true, 1, true)",
accepted, recovered, state.valid)
}
}
func TestVideoReferenceStateAcceptsSequenceWraparound(t *testing.T) {
state := &videoReferenceState{valid: true}
if _, gap := state.observeSequence(^uint16(0)); gap {
t.Fatal("first sequence observation reported a gap")
}
if expected, gap := state.observeSequence(0); gap || expected != 0 || !state.valid {
t.Fatalf("sequence wraparound = (expected=%d, gap=%t, valid=%t), want (0, false, true)",
expected, gap, state.valid)
}
}
func TestH264FrameNumTrackerDetectsMissingIDR(t *testing.T) {
tracker := &h264FrameNumTracker{}
tracker.setSPS(&h264.SPS{
Log2MaxFrameNumMinus4: 1,
FrameMbsOnlyFlag: true,
})
if _, _, gap, ok := tracker.observe([][]byte{testH264Slice(h264.NALUTypeIDR, 0)}); !ok || gap {
t.Fatalf("initial IDR observation = (ok=%t, gap=%t), want (true, false)", ok, gap)
}
for frameNum := uint32(1); frameNum <= 24; frameNum++ {
if expected, received, gap, ok := tracker.observe([][]byte{testH264Slice(h264.NALUTypeNonIDR, frameNum)}); !ok || gap {
t.Fatalf("frame_num %d observation = (expected=%d, received=%d, ok=%t, gap=%t), want no gap",
frameNum, expected, received, ok, gap)
}
}
expected, received, gap, ok := tracker.observe([][]byte{testH264Slice(h264.NALUTypeNonIDR, 1)})
if !ok || !gap || expected != 25 || received != 1 {
t.Fatalf("missing IDR transition = (expected=%d, received=%d, ok=%t, gap=%t), want (25, 1, true, true)",
expected, received, ok, gap)
}
}
func TestH264FrameNumTrackerResetsAtIDR(t *testing.T) {
tracker := &h264FrameNumTracker{}
tracker.setSPS(&h264.SPS{
Log2MaxFrameNumMinus4: 1,
FrameMbsOnlyFlag: true,
})
tracker.observe([][]byte{testH264Slice(h264.NALUTypeIDR, 0)})
tracker.observe([][]byte{testH264Slice(h264.NALUTypeNonIDR, 1)})
if expected, received, gap, ok := tracker.observe([][]byte{testH264Slice(h264.NALUTypeIDR, 0)}); !ok || gap {
t.Fatalf("IDR reset = (expected=%d, received=%d, ok=%t, gap=%t), want no gap",
expected, received, ok, gap)
}
if expected, received, gap, ok := tracker.observe([][]byte{testH264Slice(h264.NALUTypeNonIDR, 1)}); !ok || gap || expected != 1 || received != 1 {
t.Fatalf("post-IDR frame = (expected=%d, received=%d, ok=%t, gap=%t), want (1, 1, true, false)",
expected, received, ok, gap)
}
}
func TestH264FrameNumTrackerHonorsPermittedGaps(t *testing.T) {
tracker := &h264FrameNumTracker{}
tracker.setSPS(&h264.SPS{
Log2MaxFrameNumMinus4: 1,
FrameMbsOnlyFlag: true,
GapsInFrameNumValueAllowedFlag: true,
})
tracker.observe([][]byte{testH264Slice(h264.NALUTypeIDR, 0)})
expected, received, gap, ok := tracker.observe([][]byte{testH264Slice(h264.NALUTypeNonIDR, 2)})
if !ok || gap || expected != 1 || received != 2 {
t.Fatalf("permitted frame_num gap = (expected=%d, received=%d, ok=%t, gap=%t), want (1, 2, true, false)",
expected, received, ok, gap)
}
}
func testH264Slice(naluType h264.NALUType, frameNum uint32) []byte {
return []byte{0x60 | byte(naluType), 0xE0 | byte(frameNum&0x1F)}
}
-35
View File
@@ -1,35 +0,0 @@
package capture
import (
"errors"
"fmt"
"github.com/pion/rtcp"
)
func (g *Golibrtsp) RequestKeyframe() error {
g.keyframeMu.Lock()
defer g.keyframeMu.Unlock()
if !g.keyframeReady {
return errors.New("RTSP H264 keyframe requests are unavailable")
}
media, ok := g.Client.Stats().Session.Medias[g.VideoH264Media]
if !ok {
return errors.New("RTSP video media is not set up")
}
video, ok := media.Formats[g.VideoH264Forma]
if !ok || video.InboundRTPPackets == 0 {
return errors.New("RTSP video RTP has not arrived yet")
}
// Browser and camera SSRCs differ: originate feedback on the RTSP session.
if err := g.Client.WritePacketRTCP(g.VideoH264Media, &rtcp.PictureLossIndication{
SenderSSRC: video.LocalSSRC,
MediaSSRC: video.RemoteSSRC,
}); err != nil {
return fmt.Errorf("request camera keyframe: %w", err)
}
return nil
}
-164
View File
@@ -1,164 +0,0 @@
package capture
import (
"context"
"net"
"sync"
"testing"
"time"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/base"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/format"
"github.com/pion/rtcp"
"github.com/pion/rtp"
)
type keyframeCamera struct {
stream *gortsplib.ServerStream
feedback chan rtcp.Packet
}
func (c *keyframeCamera) OnDescribe(*gortsplib.ServerHandlerOnDescribeCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{StatusCode: base.StatusOK}, c.stream, nil
}
func (c *keyframeCamera) OnSetup(*gortsplib.ServerHandlerOnSetupCtx) (*base.Response, *gortsplib.ServerStream, error) {
return &base.Response{StatusCode: base.StatusOK}, c.stream, nil
}
func (c *keyframeCamera) OnPlay(ctx *gortsplib.ServerHandlerOnPlayCtx) (*base.Response, error) {
ctx.Session.OnPacketRTCPAny(func(_ *description.Media, pkt rtcp.Packet) {
c.feedback <- pkt
})
return &base.Response{StatusCode: base.StatusOK}, nil
}
func connectedKeyframeCamera(t *testing.T) (*Golibrtsp, *keyframeCamera) {
t.Helper()
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { listener.Close() })
camera := &keyframeCamera{feedback: make(chan rtcp.Packet, 32)}
server := &gortsplib.Server{
RTSPAddress: "127.0.0.1:0",
Handler: camera,
Listen: func(string, string) (net.Listener, error) {
return listener, nil
},
}
if err := server.Start(); err != nil {
t.Fatal(err)
}
t.Cleanup(server.Close)
media := &description.Media{
Type: description.MediaTypeVideo,
Formats: []format.Format{&format.H264{
PayloadTyp: 96,
PacketizationMode: 1,
}},
}
camera.stream = &gortsplib.ServerStream{
Server: server,
Desc: &description.Session{Medias: []*description.Media{media}},
}
if err := camera.stream.Initialize(); err != nil {
t.Fatal(err)
}
t.Cleanup(camera.stream.Close)
client := &Golibrtsp{Url: "rtsp://" + listener.Addr().String() + "/camera"}
t.Cleanup(func() {
if err := client.Close(context.Background()); err != nil {
t.Error(err)
}
})
if err := client.Connect(context.Background(), context.Background()); err != nil {
t.Fatal(err)
}
if err := client.RequestKeyframe(); err == nil {
t.Fatal("requested a keyframe before the camera SSRC was known")
}
received := make(chan struct{}, 1)
client.Client.OnPacketRTP(client.VideoH264Media, client.VideoH264Forma, func(*rtp.Packet) {
received <- struct{}{}
})
if _, err := client.Client.Play(nil); err != nil {
t.Fatal(err)
}
if err := camera.stream.WritePacketRTP(media, &rtp.Packet{
Header: rtp.Header{
Version: 2,
PayloadType: 96,
SSRC: 0x12345678,
SequenceNumber: 1,
Timestamp: 90000,
Marker: true,
},
Payload: []byte{0x65, 0x88, 0x84},
}); err != nil {
t.Fatal(err)
}
select {
case <-received:
case <-time.After(3 * time.Second):
t.Fatal("test camera RTP did not arrive")
}
return client, camera
}
func TestRTSPKeyframeRequestUsesCameraSessionSSRCs(t *testing.T) {
client, camera := connectedKeyframeCamera(t)
want := client.Client.Stats().Session.Medias[client.VideoH264Media].Formats[client.VideoH264Forma]
if err := client.RequestKeyframe(); err != nil {
t.Fatal(err)
}
select {
case pkt := <-camera.feedback:
pli, ok := pkt.(*rtcp.PictureLossIndication)
if !ok {
t.Fatalf("camera received %T, want PLI", pkt)
}
if pli.MediaSSRC != want.RemoteSSRC || pli.SenderSSRC != want.LocalSSRC {
t.Fatalf("camera PLI SSRCs = sender %x media %x, want sender %x media %x",
pli.SenderSSRC, pli.MediaSSRC, want.LocalSSRC, want.RemoteSSRC)
}
case <-time.After(3 * time.Second):
t.Fatal("camera did not receive RTCP PLI")
}
}
func TestRTSPKeyframeRequestUnavailableBeforeConnectAndAfterClose(t *testing.T) {
if err := (&Golibrtsp{}).RequestKeyframe(); err == nil {
t.Fatal("uninitialized client accepted a keyframe request")
}
client, _ := connectedKeyframeCamera(t)
if err := client.Close(context.Background()); err != nil {
t.Fatal(err)
}
if err := client.RequestKeyframe(); err == nil {
t.Fatal("closed client accepted a keyframe request")
}
}
func TestRTSPKeyframeRequestConcurrentWithClose(t *testing.T) {
client, _ := connectedKeyframeCamera(t)
var wg sync.WaitGroup
for range 4 {
wg.Add(1)
go func() {
defer wg.Done()
for range 5 {
// Requests may race with Close and legitimately become unavailable.
_ = client.RequestKeyframe()
}
}()
}
if err := client.Close(context.Background()); err != nil {
t.Fatal(err)
}
wg.Wait()
}
+161 -43
View File
@@ -53,16 +53,13 @@ func publishRecordingState(mqttClient mqtt.Client, hubKey string, configuration
} }
} }
func recordingUploadMetadata(name string, config models.Config, timestamp int64, mp4Video *video.MP4, encrypted bool, coordinates string, changes int) models.RecordingUploadMetadata { func recordingUploadMetadata(name, deviceKey string, timestamp int64, mp4Video *video.MP4, encrypted bool) models.RecordingUploadMetadata {
metadata := models.RecordingUploadMetadata{ metadata := models.RecordingUploadMetadata{
FileName: filepath.Base(name), FileName: filepath.Base(name),
DeviceKey: config.Key, DeviceKey: deviceKey,
Timestamp: timestamp, Timestamp: timestamp,
Duration: mp4Video.VideoTotalDuration, Duration: mp4Video.VideoTotalDuration,
Encrypted: encrypted, Encrypted: encrypted,
DeviceName: config.Name,
RegionCoordinates: coordinates,
NumberOfChanges: strconv.Itoa(changes),
} }
value := mp4Video.AverageFPS() value := mp4Video.AverageFPS()
if value > 0 && value <= 240 && !math.IsInf(value, 0) && !math.IsNaN(value) { if value > 0 && value <= 240 && !math.IsInf(value, 0) && !math.IsNaN(value) {
@@ -193,7 +190,7 @@ func CleanupRecordingDirectory(configDirectory string, configuration *models.Con
return return
} }
if err := utils.RemoveRecording(recordingsDirectory, name); err != nil { if err := os.Remove(recordingsDirectory + "/" + name); err != nil {
log.Info("HandleRecordStream: something went wrong, " + err.Error()) log.Info("HandleRecordStream: something went wrong, " + err.Error())
return return
} }
@@ -278,7 +275,7 @@ func defaultReserveMB(totalMB int64) int64 {
// overall with pending=true, signalling the caller that it is about to drop an // overall with pending=true, signalling the caller that it is about to drop an
// un-uploaded recording as a last resort. // un-uploaded recording as a last resort.
func pickRecordingToCleanup(recordingsDirectory, cloudDirectory string) (string, bool, error) { func pickRecordingToCleanup(recordingsDirectory, cloudDirectory string) (string, bool, error) {
entries, err := utils.ReadRecordingDirectory(recordingsDirectory) entries, err := os.ReadDir(recordingsDirectory)
if err != nil { if err != nil {
return "", false, err return "", false, err
} }
@@ -287,7 +284,14 @@ func pickRecordingToCleanup(recordingsDirectory, cloudDirectory string) (string,
var oldestSafeTime, oldestAnyTime time.Time var oldestSafeTime, oldestAnyTime time.Time
for _, entry := range entries { for _, entry := range entries {
modTime := entry.ModTime() if entry.IsDir() {
continue
}
info, err := entry.Info()
if err != nil || !info.Mode().IsRegular() {
continue
}
modTime := info.ModTime()
if oldestAnyName == "" || modTime.Before(oldestAnyTime) { if oldestAnyName == "" || modTime.Before(oldestAnyTime) {
oldestAnyName = entry.Name() oldestAnyName = entry.Name()
@@ -445,6 +449,39 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
// Cleanup muxer // Cleanup muxer
start = false start = false
// Update the name of the recording with the duration.
// We will update the name of the recording with the duration in milliseconds.
if mp4Video.VideoTotalDuration > 0 {
duration := mp4Video.VideoTotalDuration
// Update the name with the duration in milliseconds.
startRecordingSeconds := startRecording / 1000 // convert to seconds
startRecordingMilliseconds := startRecording % 1000 // convert to milliseconds
s := strconv.FormatInt(startRecordingSeconds, 10) + "_" +
strconv.Itoa(len(strconv.FormatInt(startRecordingMilliseconds, 10))) + "-" +
strconv.FormatInt(startRecordingMilliseconds, 10) + "_" +
config.Name + "_" +
"0-0-0-0" + "_" + // region coordinates, we
"-1" + "_" + // token
strconv.FormatInt(int64(duration), 10) // + "_" + // duration of recording
//utils.VERSION // version of the agent
oldName := name
name = s + ".mp4"
fullName = configDirectory + "/data/recordings/" + name
log.Info("capture.main.HandleRecordStream(motiondetection): renamed file from: " + oldName + " to: " + name)
// Rename the file to the new name.
err := os.Rename(
configDirectory+"/data/recordings/"+oldName,
configDirectory+"/data/recordings/"+s+".mp4")
if err != nil {
log.Error("capture.main.HandleRecordStream(motiondetection): error renaming file: " + err.Error())
}
} else {
log.Info("capture.main.HandleRecordStream(continuous): no video data recorded, not renaming file.")
}
encrypted := false encrypted := false
// Check if we need to encrypt the recording. // Check if we need to encrypt the recording.
if config.Encryption != nil && config.Encryption.Enabled == "true" && config.Encryption.Recordings == "true" && config.Encryption.SymmetricKey != "" { if config.Encryption != nil && config.Encryption.Enabled == "true" && config.Encryption.Recordings == "true" && config.Encryption.SymmetricKey != "" {
@@ -469,7 +506,7 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
} }
} }
queueRecordingForUpload(configDirectory, recordingUploadMetadata(name, config, startRecording, mp4Video, encrypted, "0-0-0-0", -1)) queueRecordingForUpload(configDirectory, recordingUploadMetadata(name, config.Key, startRecording, mp4Video, encrypted))
recordingStatus = "idle" recordingStatus = "idle"
@@ -494,17 +531,29 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
start = true start = true
// timestamp_microseconds_instanceName_regionCoordinates_numberOfChanges_token
// 1564859471_6-474162_oprit_577-283-727-375_1153_27.mp4
// - Timestamp
// - Size + - + microseconds
// - device
// - Region
// - Number of changes
// - Token
startRecording = pkt.CurrentTime startRecording = pkt.CurrentTime
name, err = utils.RecordingFileName(startRecording, config.Key) startRecordingSeconds := startRecording / 1000 // convert to seconds
if err == nil { startRecordingMilliseconds := startRecording % 1000 // convert to milliseconds
fullName, err = utils.CreateRecordingPath(configDirectory+"/data/recordings", name, time.UnixMilli(startRecording)) s := strconv.FormatInt(startRecordingSeconds, 10) + "_" + // start timestamp in seconds
} strconv.Itoa(len(strconv.FormatInt(startRecordingMilliseconds, 10))) + "-" + // length of milliseconds
if err != nil { strconv.FormatInt(startRecordingMilliseconds, 10) + "_" + // milliseconds
log.WithError(err).Error("capture: could not create continuous recording path") config.Name + "_" + // device name
start = false "0-0-0-0" + "_" + // region coordinates, we will not use this for continuous recording
pkt = nextPkt "0" + "_" + // token
continue "0" + "_" //+ // duration of recording in milliseconds
} //utils.VERSION // version of the agent
name = s + ".mp4"
fullName = configDirectory + "/data/recordings/" + name
// Running... // Running...
log.Info("capture.main.HandleRecordStream(continuous): recording started") log.Info("capture.main.HandleRecordStream(continuous): recording started")
@@ -560,6 +609,39 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
// Cleanup muxer // Cleanup muxer
start = false start = false
// Update the name of the recording with the duration.
// We will update the name of the recording with the duration in milliseconds.
if mp4Video.VideoTotalDuration > 0 {
duration := mp4Video.VideoTotalDuration
// Update the name with the duration in milliseconds.
startRecordingSeconds := startRecording / 1000 // convert to seconds
startRecordingMilliseconds := startRecording % 1000 // convert to milliseconds
s := strconv.FormatInt(startRecordingSeconds, 10) + "_" +
strconv.Itoa(len(strconv.FormatInt(startRecordingMilliseconds, 10))) + "-" +
strconv.FormatInt(startRecordingMilliseconds, 10) + "_" +
config.Name + "_" +
"0-0-0-0" + "_" + // region coordinates, we
"-1" + "_" + // token
strconv.FormatInt(int64(duration), 10) // + "_" + // duration of recording
//utils.VERSION // version of the agent
oldName := name
name = s + ".mp4"
fullName = configDirectory + "/data/recordings/" + name
log.Info("capture.main.HandleRecordStream(motiondetection): renamed file from: " + oldName + " to: " + name)
// Rename the file to the new name.
err := os.Rename(
configDirectory+"/data/recordings/"+oldName,
configDirectory+"/data/recordings/"+s+".mp4")
if err != nil {
log.Error("capture.main.HandleRecordStream(motiondetection): error renaming file: " + err.Error())
}
} else {
log.Info("capture.main.HandleRecordStream(continuous): no video data recorded, not renaming file.")
}
encrypted := false encrypted := false
// Check if we need to encrypt the recording. // Check if we need to encrypt the recording.
if config.Encryption != nil && config.Encryption.Enabled == "true" && config.Encryption.Recordings == "true" && config.Encryption.SymmetricKey != "" { if config.Encryption != nil && config.Encryption.Enabled == "true" && config.Encryption.Recordings == "true" && config.Encryption.SymmetricKey != "" {
@@ -584,7 +666,7 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
} }
} }
queueRecordingForUpload(configDirectory, recordingUploadMetadata(name, config, startRecording, mp4Video, encrypted, "0-0-0-0", -1)) queueRecordingForUpload(configDirectory, recordingUploadMetadata(name, config.Key, startRecording, mp4Video, encrypted))
recordingStatus = "idle" recordingStatus = "idle"
@@ -639,7 +721,17 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
continue continue
} }
displayTimeSeconds := displayTime / 1000 // timestamp_microseconds_instanceName_regionCoordinates_numberOfChanges_token
// 1564859471_6-474162_oprit_577-283-727-375_1153_27.mp4
// - Timestamp
// - Size + - + microseconds
// - device
// - Region
// - Number of changes
// - Token
displayTimeSeconds := displayTime / 1000 // convert to seconds
displayTimeMilliseconds := displayTime % 1000 // convert to milliseconds
motionRectangleString := "0-0-0-0" motionRectangleString := "0-0-0-0"
if motion.Rectangle.X != 0 || motion.Rectangle.Y != 0 || if motion.Rectangle.X != 0 || motion.Rectangle.Y != 0 ||
motion.Rectangle.Width != 0 || motion.Rectangle.Height != 0 { motion.Rectangle.Width != 0 || motion.Rectangle.Height != 0 {
@@ -650,15 +742,17 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
// Get the number of changes from the motion detection. // Get the number of changes from the motion detection.
numberOfChanges := motion.NumberOfChanges numberOfChanges := motion.NumberOfChanges
name, err := utils.RecordingFileName(displayTime, config.Key) s := strconv.FormatInt(displayTimeSeconds, 10) + "_" + // start timestamp in seconds
var fullName string strconv.Itoa(len(strconv.FormatInt(displayTimeMilliseconds, 10))) + "-" + // length of milliseconds
if err == nil { strconv.FormatInt(displayTimeMilliseconds, 10) + "_" + // milliseconds
fullName, err = utils.CreateRecordingPath(configDirectory+"/data/recordings", name, time.UnixMilli(displayTime)) config.Name + "_" + // device name
} motionRectangleString + "_" + // region coordinates, we will not use this for continuous recording
if err != nil { strconv.Itoa(numberOfChanges) + "_" + // number of changes
log.WithError(err).Error("capture: could not create motion recording path") "0" // + "_" + // duration of recording in milliseconds
continue //utils.VERSION // version of the agent
}
name := s + ".mp4"
fullName := configDirectory + "/data/recordings/" + name
// Running... // Running...
log.Info("capture.main.HandleRecordStream(motiondetection): recording started (" + name + ")" + " at " + strconv.FormatInt(displayTimeSeconds, 10) + " unix") log.Info("capture.main.HandleRecordStream(motiondetection): recording started (" + name + ")" + " at " + strconv.FormatInt(displayTimeSeconds, 10) + " unix")
@@ -786,6 +880,38 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
communication.TrySendMotion(models.MotionDataPartial{Timestamp: time.Now().Unix(), NumberOfChanges: 100000000}) communication.TrySendMotion(models.MotionDataPartial{Timestamp: time.Now().Unix(), NumberOfChanges: 100000000})
} }
// Update the name of the recording with the duration.
// We will update the name of the recording with the duration in milliseconds.
if mp4Video.VideoTotalDuration > 0 {
duration := mp4Video.VideoTotalDuration
// Update the name with the duration in milliseconds.
s := strconv.FormatInt(displayTimeSeconds, 10) + "_" +
strconv.Itoa(len(strconv.FormatInt(displayTimeMilliseconds, 10))) + "-" +
strconv.FormatInt(displayTimeMilliseconds, 10) + "_" +
config.Name + "_" +
motionRectangleString + "_" +
strconv.Itoa(numberOfChanges) + "_" + // number of changes
strconv.FormatInt(int64(duration), 10) // + "_" + // duration of recording in milliseconds
//utils.VERSION // version of the agent
oldName := name
name = s + ".mp4"
fullName = configDirectory + "/data/recordings/" + name
log.Info("capture.main.HandleRecordStream(motiondetection): renamed file from: " + oldName + " to: " + name)
// Rename the file to the new name.
err := os.Rename(
configDirectory+"/data/recordings/"+oldName,
configDirectory+"/data/recordings/"+s+".mp4")
if err != nil {
log.Error("capture.main.HandleRecordStream(motiondetection): error renaming file: " + err.Error())
}
} else {
log.Info("capture.main.HandleRecordStream(motiondetection): no video data recorded, not renaming file.")
}
encrypted := false encrypted := false
// Check if we need to encrypt the recording. // Check if we need to encrypt the recording.
if config.Encryption != nil && config.Encryption.Enabled == "true" && config.Encryption.Recordings == "true" && config.Encryption.SymmetricKey != "" { if config.Encryption != nil && config.Encryption.Enabled == "true" && config.Encryption.Recordings == "true" && config.Encryption.SymmetricKey != "" {
@@ -810,7 +936,7 @@ func HandleRecordStream(queue *packets.Queue, configDirectory string, configurat
} }
} }
queueRecordingForUpload(configDirectory, recordingUploadMetadata(name, config, displayTime, mp4Video, encrypted, motionRectangleString, numberOfChanges)) queueRecordingForUpload(configDirectory, recordingUploadMetadata(name, config.Key, displayTime, mp4Video, encrypted))
// Clean up the recording directory if necessary. // Clean up the recording directory if necessary.
CleanupRecordingDirectory(configDirectory, configuration) CleanupRecordingDirectory(configDirectory, configuration)
@@ -944,10 +1070,6 @@ func Base64Image(captureDevice *Capture, communication *models.Communication, co
count++ count++
continue continue
} }
} else {
// A stopped run closes this queue permanently. Retrying its
// cursor would spin on EOF even after the HTTP client leaves.
break
} }
} else { } else {
break break
@@ -991,10 +1113,6 @@ func JpegImage(captureDevice *Capture, communication *models.Communication) imag
} else { } else {
break break
} }
} else {
// A stopped run closes this queue permanently. Retrying its
// cursor would spin on EOF even after the HTTP client leaves.
break
} }
} else { } else {
break break
+3 -5
View File
@@ -42,11 +42,10 @@ func TestQueueRecordingForUploadStoresFinalizedMetadata(t *testing.T) {
} }
mp4Video := &video.MP4{VideoTotalDuration: 20452, SampleCount: 613} mp4Video := &video.MP4{VideoTotalDuration: 20452, SampleCount: 613}
config := models.Config{Key: "device-key", Name: "camera-name"} metadata := recordingUploadMetadata("recording.mp4", "device-key", 1785934709414, mp4Video, true)
metadata := recordingUploadMetadata("1785934709414-device-key.mp4", config, 1785934709414, mp4Video, true, "1-2-3-4", 57)
queueRecordingForUpload(configDirectory, metadata) queueRecordingForUpload(configDirectory, metadata)
got, err := os.ReadFile(filepath.Join(configDirectory, "data", "cloud", "1785934709414-device-key.metadata")) got, err := os.ReadFile(filepath.Join(configDirectory, "data", "cloud", "recording.metadata"))
if err != nil { if err != nil {
t.Fatalf("read upload marker: %v", err) t.Fatalf("read upload marker: %v", err)
} }
@@ -55,8 +54,7 @@ func TestQueueRecordingForUploadStoresFinalizedMetadata(t *testing.T) {
t.Fatalf("decode upload marker: %v", err) t.Fatalf("decode upload marker: %v", err)
} }
expectedFPS := mp4Video.AverageFPS() expectedFPS := mp4Video.AverageFPS()
if stored.FileName != "1785934709414-device-key.mp4" || stored.DeviceKey != "device-key" || stored.Timestamp != 1785934709414 || stored.Duration != 20452 || math.Abs(stored.FPS-expectedFPS) > 1e-9 || !stored.Encrypted || if stored.FileName != "recording.mp4" || stored.DeviceKey != "device-key" || stored.Timestamp != 1785934709414 || stored.Duration != 20452 || math.Abs(stored.FPS-expectedFPS) > 1e-9 || !stored.Encrypted {
stored.DeviceName != "camera-name" || stored.RegionCoordinates != "1-2-3-4" || stored.NumberOfChanges != "57" {
t.Fatalf("upload marker = %+v", stored) t.Fatalf("upload marker = %+v", stored)
} }
if stored.FPS == math.Floor(stored.FPS) { if stored.FPS == math.Floor(stored.FPS) {
-4
View File
@@ -72,10 +72,6 @@ func (c *Capture) ClearClients(main, sub, backchannel *Golibrtsp) {
} }
} }
type KeyframeRequester interface {
RequestKeyframe() error
}
// RTSPClient is a interface that abstracts the RTSP client implementation. // RTSPClient is a interface that abstracts the RTSP client implementation.
type RTSPClient interface { type RTSPClient interface {
// Connect to the RTSP server. // Connect to the RTSP server.
-68
View File
@@ -1,68 +0,0 @@
package capture
import (
"context"
"testing"
"time"
"github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/packets"
)
func TestSnapshotReturnsAfterQueueClosure(t *testing.T) {
for _, stream := range []string{"main", "sub"} {
for _, format := range []string{"jpeg", "base64"} {
for _, alreadyClosed := range []bool{true, false} {
name := stream + "/" + format + "/closed_during_read"
if alreadyClosed {
name = stream + "/" + format + "/already_closed"
}
t.Run(name, func(t *testing.T) {
communication := &models.Communication{}
run := models.NewAgentRun(context.Background(), communication, false)
queue := packets.NewQueue()
captureDevice := &Capture{}
if stream == "main" {
captureDevice.SetMainClient("rtsp://unused.invalid/main")
run.SetMainQueue(queue)
} else {
captureDevice.SetSubClient("rtsp://unused.invalid/sub")
run.SetSubQueue(queue)
}
if err := run.Activate(); err != nil {
t.Fatal(err)
}
defer queue.Close()
if alreadyClosed {
queue.Close()
}
done := make(chan bool, 1)
go func() {
if format == "jpeg" {
image := JpegImage(captureDevice, communication)
done <- image.Rect.Empty()
} else {
done <- Base64Image(captureDevice, communication, &models.Configuration{}) == ""
}
}()
if !alreadyClosed {
select {
case <-done:
t.Fatal("snapshot returned before a frame or queue closure")
case <-time.After(10 * time.Millisecond):
}
queue.Close()
}
select {
case empty := <-done:
if !empty {
t.Fatal("closed empty queue produced a snapshot")
}
case <-time.After(time.Second):
t.Fatal("snapshot did not return after its packet queue closed")
}
})
}
}
}
}
+27 -80
View File
@@ -125,7 +125,7 @@ func HandleUpload(configDirectory string, configuration *models.Configuration, c
// Check if we need to remove the original recording // Check if we need to remove the original recording
// removeAfterUpload is set to false by default // removeAfterUpload is set to false by default
if config.RemoveAfterUpload != "false" { if config.RemoveAfterUpload != "false" {
err := utils.RemoveRecording(configDirectory+"/data/recordings", fileName) err := os.Remove(configDirectory + "/data/recordings/" + fileName)
if err != nil { if err != nil {
log.Error("HandleUpload: " + err.Error()) log.Error("HandleUpload: " + err.Error())
} }
@@ -319,7 +319,6 @@ func heartbeatONVIFCameraKey(camera models.IPCamera) string {
camera.ONVIFXAddr, camera.ONVIFXAddr,
camera.ONVIFUsername, camera.ONVIFUsername,
camera.ONVIFPassword, camera.ONVIFPassword,
strconv.Itoa(camera.ONVIFChannel),
}, "\x00") }, "\x00")
} }
@@ -414,7 +413,7 @@ func (state *heartbeatONVIFState) refreshStaticPayload(device *goonvif.Device) h
payload.panTilt = "true" payload.panTilt = "true"
} }
presets, err := heartbeatGetPresetsFromDevice(device, state.cameraConfiguration.ONVIFChannel) presets, err := heartbeatGetPresetsFromDevice(device)
if err == nil && len(presets) > 0 { if err == nil && len(presets) > 0 {
payload.presets = "true" payload.presets = "true"
presetsList, marshalErr := json.Marshal(presets) presetsList, marshalErr := json.Marshal(presets)
@@ -542,23 +541,13 @@ func (state *heartbeatONVIFState) fetchEvents(device *goonvif.Device) ([]byte, b
} }
} }
// Fall back to querying the relay outputs and digital inputs directly when if !initialStateSubscriptionCreated && state.loopPullPoint == "" {
// no subscription could be created, and also when the subscriptions
// produced no I/O events: some devices accept the subscription but reject
// the pulls, or never publish the initial I/O state.
noSubscription := !initialStateSubscriptionCreated && state.loopPullPoint == ""
if noSubscription || heartbeatEventsListEmpty(onvifEventsList) {
return state.fallbackEvents(device), operationFailed return state.fallbackEvents(device), operationFailed
} }
return onvifEventsList, operationFailed return onvifEventsList, operationFailed
} }
func heartbeatEventsListEmpty(eventsList []byte) bool {
trimmed := strings.TrimSpace(string(eventsList))
return trimmed == "" || trimmed == "[]" || trimmed == "null"
}
func getHeartbeatONVIFPayload(camera models.IPCamera, state *heartbeatONVIFState) heartbeatONVIFPayload { func getHeartbeatONVIFPayload(camera models.IPCamera, state *heartbeatONVIFState) heartbeatONVIFPayload {
if state == nil { if state == nil {
state = newHeartbeatONVIFState() state = newHeartbeatONVIFState()
@@ -1285,7 +1274,7 @@ func HandleLiveStreamHD(
// viewer can pick the resolution it needs per peer connection without // viewer can pick the resolution it needs per peer connection without
// the agent re-negotiating the RTSP source. // the agent re-negotiating the RTSP source.
mainStreams, _ := rtspClient.GetStreams() mainStreams, _ := rtspClient.GetStreams()
mainVideoBroadcaster := webrtc.NewVideoBroadcaster(mainStreams, rtspClient) mainVideoBroadcaster := webrtc.NewVideoBroadcaster(mainStreams)
mainAudioBroadcaster := webrtc.NewAudioBroadcaster(mainStreams) mainAudioBroadcaster := webrtc.NewAudioBroadcaster(mainStreams)
if mainVideoBroadcaster == nil && mainAudioBroadcaster == nil { if mainVideoBroadcaster == nil && mainAudioBroadcaster == nil {
@@ -1316,7 +1305,7 @@ func HandleLiveStreamHD(
var subAudioBroadcaster *webrtc.TrackBroadcaster var subAudioBroadcaster *webrtc.TrackBroadcaster
if subStreamEnabled && rtspSubClient != nil && subQueue != nil { if subStreamEnabled && rtspSubClient != nil && subQueue != nil {
subStreams, _ := rtspSubClient.GetStreams() subStreams, _ := rtspSubClient.GetStreams()
subVideoBroadcaster = webrtc.NewVideoBroadcaster(subStreams, rtspSubClient) subVideoBroadcaster = webrtc.NewVideoBroadcaster(subStreams)
subAudioBroadcaster = webrtc.NewAudioBroadcaster(subStreams) subAudioBroadcaster = webrtc.NewAudioBroadcaster(subStreams)
defer func() { defer func() {
if subVideoBroadcaster != nil { if subVideoBroadcaster != nil {
@@ -1380,10 +1369,6 @@ func HandleRealtimeProcessing(processingCursor *packets.QueueCursor, configurati
// Check if we need to enable the realtime processing // Check if we need to enable the realtime processing
if config.RealtimeProcessing == "true" { if config.RealtimeProcessing == "true" {
if mqttClient == nil {
log.Warn("cloud.RealtimeProcessing(): stopping as MQTT client is not configured.")
return
}
hubKey := "" hubKey := ""
if config.Cloud == "s3" && config.S3 != nil && config.S3.Publickey != "" { if config.Cloud == "s3" && config.S3 != nil && config.S3.Publickey != "" {
@@ -1459,19 +1444,13 @@ func HandleRealtimeProcessing(processingCursor *packets.QueueCursor, configurati
// @Summary Will verify the hub connectivity. // @Summary Will verify the hub connectivity.
// @Description Will verify the hub connectivity. // @Description Will verify the hub connectivity.
// @Success 200 {object} models.APIResponse // @Success 200 {object} models.APIResponse
func VerifyHub(c *gin.Context, configuredHubURI string) { func VerifyHub(c *gin.Context) {
var config models.Config var config models.Config
err := c.BindJSON(&config) err := c.BindJSON(&config)
if err == nil { if err == nil {
hubURI, err := configuredHubVerificationURI(config.HubURI, configuredHubURI) hubURI := config.HubURI
if err != nil {
c.JSON(http.StatusBadRequest, models.APIResponse{
Data: "cloud.VerifyHub(): " + err.Error(),
})
return
}
publicKey := config.HubKey publicKey := config.HubKey
privateKey := config.HubPrivateKey privateKey := config.HubPrivateKey
@@ -1484,9 +1463,9 @@ func VerifyHub(c *gin.Context, configuredHubURI string) {
tr := &http.Transport{ tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
} }
client = &http.Client{Transport: tr, CheckRedirect: rejectHubVerificationRedirect} client = &http.Client{Transport: tr}
} else { } else {
client = &http.Client{CheckRedirect: rejectHubVerificationRedirect} client = &http.Client{}
} }
resp, err := client.Do(req) resp, err := client.Do(req)
@@ -1535,7 +1514,7 @@ func VerifyHub(c *gin.Context, configuredHubURI string) {
// @Summary Will verify the persistence. // @Summary Will verify the persistence.
// @Description Will verify the persistence. // @Description Will verify the persistence.
// @Success 200 {object} models.APIResponse // @Success 200 {object} models.APIResponse
func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string) { func VerifyPersistence(c *gin.Context, configDirectory string) {
var config models.Config var config models.Config
err := c.BindJSON(&config) err := c.BindJSON(&config)
@@ -1548,7 +1527,6 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
if config.HubURI == "" || if config.HubURI == "" ||
config.HubKey == "" || config.HubKey == "" ||
config.HubPrivateKey == "" || config.HubPrivateKey == "" ||
config.S3 == nil ||
config.S3.Region == "" { config.S3.Region == "" {
msg := "cloud.VerifyPersistence(kerberoshub): Kerberos Hub not properly configured." msg := "cloud.VerifyPersistence(kerberoshub): Kerberos Hub not properly configured."
log.Error(msg) log.Error(msg)
@@ -1556,24 +1534,25 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
Data: msg, Data: msg,
}) })
} else { } else {
hubURI, err := configuredHubVerificationURI(config.HubURI, configuredHubURI)
if err != nil {
msg := "cloud.VerifyPersistence(kerberoshub): " + err.Error()
log.Error(msg)
c.JSON(http.StatusBadRequest, models.APIResponse{
Data: msg,
})
return
}
req, err := http.NewRequest(http.MethodHead, hubURI+"/storage/upload", nil) // Open test-480p.mp4
file, err := os.Open(configDirectory + "/data/test-480p.mp4")
if err != nil { if err != nil {
msg := "cloud.VerifyPersistence(kerberoshub): error creating Kerberos Hub upload authorization request: " + err.Error() msg := "cloud.VerifyPersistence(kerberoshub): error reading test-480p.mp4: " + err.Error()
log.Error(msg)
c.JSON(400, models.APIResponse{
Data: msg,
})
}
defer file.Close()
req, err := http.NewRequest("POST", config.HubURI+"/storage/upload", file)
if err != nil {
msg := "cloud.VerifyPersistence(kerberoshub): error reading Kerberos Hub HEAD request, " + config.HubURI + "/storage: " + err.Error()
log.Error(msg) log.Error(msg)
c.JSON(400, models.APIResponse{ c.JSON(400, models.APIResponse{
Data: msg, Data: msg,
}) })
return
} }
timestamp := time.Now().Unix() timestamp := time.Now().Unix()
@@ -1591,9 +1570,9 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
tr := &http.Transport{ tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
} }
client = &http.Client{Transport: tr, CheckRedirect: rejectHubVerificationRedirect} client = &http.Client{Transport: tr}
} else { } else {
client = &http.Client{CheckRedirect: rejectHubVerificationRedirect} client = &http.Client{}
} }
resp, err := client.Do(req) resp, err := client.Do(req)
@@ -1609,17 +1588,14 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
Data: msg, Data: msg,
}) })
} else { } else {
msg := hubPersistenceVerificationError(resp.StatusCode) msg := "cloud.VerifyPersistence(kerberoshub): upload not allowed using the configured credentials"
log.Error(msg) log.Error(msg)
c.JSON(400, models.APIResponse{ c.JSON(400, models.APIResponse{
Data: msg, Data: msg,
}) })
} }
} else { } else {
msg := "cloud.VerifyPersistence(kerberoshub): Kerberos Hub upload authorization request failed" msg := "cloud.VerifyPersistence(kerberoshub): Error creating Kerberos Hub request"
if err != nil {
msg += ": " + err.Error()
}
log.Error(msg) log.Error(msg)
c.JSON(400, models.APIResponse{ c.JSON(400, models.APIResponse{
Data: msg, Data: msg,
@@ -1788,35 +1764,6 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
} }
} }
func configuredHubVerificationURI(requested, configured string) (string, error) {
requested = strings.TrimRight(strings.TrimSpace(requested), "/")
configured = strings.TrimRight(strings.TrimSpace(configured), "/")
if configured == "" {
return "", errors.New("save the Hub URI before verifying it")
}
if requested != configured {
return "", errors.New("the Hub URI does not match the saved configuration; save it before verifying")
}
return configured, nil
}
func rejectHubVerificationRedirect(_ *http.Request, _ []*http.Request) error {
return http.ErrUseLastResponse
}
func hubPersistenceVerificationError(statusCode int) string {
reason := "Kerberos Hub rejected upload authorization"
switch statusCode {
case http.StatusBadRequest:
reason += ": the credentials or device/project assignment are invalid, or the storage limit was reached"
case http.StatusUnauthorized:
reason += ": the account has no active subscription or the subscription expired"
case http.StatusForbidden:
reason += ": the device is muted"
}
return "cloud.VerifyPersistence(kerberoshub): " + reason + " (HTTP " + strconv.Itoa(statusCode) + ")"
}
// VerifySecondaryPersistence godoc // VerifySecondaryPersistence godoc
// @Router /api/persistence/secondary/verify [post] // @Router /api/persistence/secondary/verify [post]
// @ID verify-secondary-persistence // @ID verify-secondary-persistence
+4 -261
View File
@@ -1,222 +1,22 @@
package cloud package cloud
import ( import (
"bytes"
"encoding/json" "encoding/json"
"errors" "errors"
"fmt" "fmt"
"io" "io"
"net/http" "net/http"
"net/http/httptest"
"strings" "strings"
"testing" "testing"
"time" "time"
"github.com/gin-gonic/gin"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
agentonvif "github.com/kerberos-io/agent/machinery/src/onvif" agentonvif "github.com/kerberos-io/agent/machinery/src/onvif"
goonvif "github.com/kerberos-io/onvif" goonvif "github.com/kerberos-io/onvif"
goonvifdevice "github.com/kerberos-io/onvif/device" goonvifdevice "github.com/kerberos-io/onvif/device"
goonvifptz "github.com/kerberos-io/onvif/ptz" goonvifptz "github.com/kerberos-io/onvif/ptz"
goonvifxsd "github.com/kerberos-io/onvif/xsd/onvif"
) )
func TestVerifyPersistenceKerberosHubUsesAuthorizationHead(t *testing.T) {
var requestMethod string
var requestBody []byte
var requestHeaders http.Header
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requestMethod = r.Method
requestHeaders = r.Header.Clone()
requestBody, _ = io.ReadAll(r.Body)
w.WriteHeader(http.StatusOK)
}))
defer server.Close()
config := models.Config{
Cloud: "kerberoshub",
Key: "camera-1",
Name: "front-door",
HubURI: server.URL,
HubKey: "project-public",
HubPrivateKey: "project-private",
S3: &models.S3{Region: "eu"},
}
payload, err := json.Marshal(config)
if err != nil {
t.Fatalf("json.Marshal() error = %v", err)
}
gin.SetMode(gin.TestMode)
recorder := httptest.NewRecorder()
ctx, _ := gin.CreateTestContext(recorder)
ctx.Request = httptest.NewRequest(http.MethodPost, "/api/persistence/verify", bytes.NewReader(payload))
ctx.Request.Header.Set("Content-Type", "application/json")
VerifyPersistence(ctx, t.TempDir(), server.URL)
if recorder.Code != http.StatusOK {
t.Fatalf("status = %d, body = %s", recorder.Code, recorder.Body.String())
}
if requestMethod != http.MethodHead {
t.Fatalf("Hub request method = %q, want HEAD", requestMethod)
}
if len(requestBody) != 0 {
t.Fatalf("Hub request body has %d bytes, want none", len(requestBody))
}
for header, want := range map[string]string{
"X-Kerberos-Storage-Device": "camera-1",
"X-Kerberos-Hub-PublicKey": "project-public",
"X-Kerberos-Hub-PrivateKey": "project-private",
"X-Kerberos-Hub-Region": "eu",
"X-Kerberos-Storage-Capture": "IPCamera",
} {
if got := requestHeaders.Get(header); got != want {
t.Errorf("%s = %q, want %q", header, got, want)
}
}
}
func TestVerifyPersistenceKerberosHubRejectsCrossHostRedirect(t *testing.T) {
var redirectedHeaders http.Header
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
redirectedHeaders = r.Header.Clone()
w.WriteHeader(http.StatusOK)
}))
defer target.Close()
var originalHeaders http.Header
hub := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
originalHeaders = r.Header.Clone()
http.Redirect(w, r, target.URL+"/storage/upload", http.StatusTemporaryRedirect)
}))
defer hub.Close()
config := models.Config{
Cloud: "kerberoshub",
Key: "camera-1",
Name: "front-door",
HubURI: hub.URL,
HubKey: "project-public",
HubPrivateKey: "project-private",
S3: &models.S3{Region: "eu"},
}
payload, err := json.Marshal(config)
if err != nil {
t.Fatalf("json.Marshal() error = %v", err)
}
gin.SetMode(gin.TestMode)
recorder := httptest.NewRecorder()
ctx, _ := gin.CreateTestContext(recorder)
ctx.Request = httptest.NewRequest(http.MethodPost, "/api/persistence/verify", bytes.NewReader(payload))
ctx.Request.Header.Set("Content-Type", "application/json")
VerifyPersistence(ctx, t.TempDir(), hub.URL)
if recorder.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
}
for _, header := range []string{"X-Kerberos-Hub-PublicKey", "X-Kerberos-Hub-PrivateKey"} {
if originalHeaders.Get(header) == "" {
t.Errorf("%s was not sent to the configured Hub", header)
}
if redirectedHeaders != nil {
t.Errorf("redirect target received a request with %s=%q", header, redirectedHeaders.Get(header))
}
}
}
func TestVerifyPersistenceKerberosHubRejectsUnsavedURI(t *testing.T) {
requestCount := 0
untrusted := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
requestCount++
w.WriteHeader(http.StatusOK)
}))
defer untrusted.Close()
config := models.Config{
Cloud: "kerberoshub",
Key: "camera-1",
Name: "front-door",
HubURI: untrusted.URL,
HubKey: "project-public",
HubPrivateKey: "project-private",
S3: &models.S3{Region: "eu"},
}
payload, err := json.Marshal(config)
if err != nil {
t.Fatalf("json.Marshal() error = %v", err)
}
gin.SetMode(gin.TestMode)
recorder := httptest.NewRecorder()
ctx, _ := gin.CreateTestContext(recorder)
ctx.Request = httptest.NewRequest(http.MethodPost, "/api/persistence/verify", bytes.NewReader(payload))
ctx.Request.Header.Set("Content-Type", "application/json")
VerifyPersistence(ctx, t.TempDir(), "https://saved-hub.example.com")
if recorder.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
}
if requestCount != 0 {
t.Fatalf("untrusted Hub received %d requests, want none", requestCount)
}
}
func TestVerifyHubRejectsUnsavedURI(t *testing.T) {
requestCount := 0
untrusted := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
requestCount++
w.WriteHeader(http.StatusOK)
}))
defer untrusted.Close()
config := models.Config{
HubURI: untrusted.URL,
HubKey: "project-public",
HubPrivateKey: "project-private",
}
payload, err := json.Marshal(config)
if err != nil {
t.Fatalf("json.Marshal() error = %v", err)
}
gin.SetMode(gin.TestMode)
recorder := httptest.NewRecorder()
ctx, _ := gin.CreateTestContext(recorder)
ctx.Request = httptest.NewRequest(http.MethodPost, "/api/hub/verify", bytes.NewReader(payload))
ctx.Request.Header.Set("Content-Type", "application/json")
VerifyHub(ctx, "https://saved-hub.example.com")
if recorder.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
}
if requestCount != 0 {
t.Fatalf("untrusted Hub received %d requests, want none", requestCount)
}
}
func TestHubPersistenceVerificationErrorExplainsStatus(t *testing.T) {
for _, test := range []struct {
status int
want string
}{
{status: http.StatusBadRequest, want: "credentials or device/project assignment"},
{status: http.StatusUnauthorized, want: "no active subscription"},
{status: http.StatusForbidden, want: "device is muted"},
{status: http.StatusBadGateway, want: "HTTP 502"},
} {
t.Run(http.StatusText(test.status), func(t *testing.T) {
if got := hubPersistenceVerificationError(test.status); !strings.Contains(got, test.want) {
t.Fatalf("hubPersistenceVerificationError(%d) = %q, want it to contain %q", test.status, got, test.want)
}
})
}
}
func TestHeartbeatFailureLogOmitsHubResponseBody(t *testing.T) { func TestHeartbeatFailureLogOmitsHubResponseBody(t *testing.T) {
response := &http.Response{ response := &http.Response{
StatusCode: http.StatusBadRequest, StatusCode: http.StatusBadRequest,
@@ -296,7 +96,7 @@ func TestHeartbeatONVIFPayloadCachesStaticAndReusesLoopSubscription(t *testing.T
ptzFunctionCalls++ ptzFunctionCalls++
return nil, true, true return nil, true, true
} }
heartbeatGetPresetsFromDevice = func(*goonvif.Device, int) ([]models.OnvifActionPreset, error) { heartbeatGetPresetsFromDevice = func(*goonvif.Device) ([]models.OnvifActionPreset, error) {
presetCalls++ presetCalls++
return []models.OnvifActionPreset{{Name: "Lobby", Token: "1"}}, nil return []models.OnvifActionPreset{{Name: "Lobby", Token: "1"}}, nil
} }
@@ -397,7 +197,7 @@ func TestHeartbeatONVIFPayloadRefreshesAfterCameraConfigChange(t *testing.T) {
heartbeatGetPTZFunctionsFromDevice = func(goonvifptz.GetConfigurationsResponse) ([]string, bool, bool) { heartbeatGetPTZFunctionsFromDevice = func(goonvifptz.GetConfigurationsResponse) ([]string, bool, bool) {
return nil, false, true return nil, false, true
} }
heartbeatGetPresetsFromDevice = func(*goonvif.Device, int) ([]models.OnvifActionPreset, error) { heartbeatGetPresetsFromDevice = func(*goonvif.Device) ([]models.OnvifActionPreset, error) {
presetCalls++ presetCalls++
return nil, nil return nil, nil
} }
@@ -477,7 +277,7 @@ func TestHeartbeatONVIFPayloadRetriesStaticFetchFailuresWithoutReconnect(t *test
heartbeatGetPTZFunctionsFromDevice = func(goonvifptz.GetConfigurationsResponse) ([]string, bool, bool) { heartbeatGetPTZFunctionsFromDevice = func(goonvifptz.GetConfigurationsResponse) ([]string, bool, bool) {
return nil, true, true return nil, true, true
} }
heartbeatGetPresetsFromDevice = func(*goonvif.Device, int) ([]models.OnvifActionPreset, error) { heartbeatGetPresetsFromDevice = func(*goonvif.Device) ([]models.OnvifActionPreset, error) {
presetCalls++ presetCalls++
if presetCalls == 1 { if presetCalls == 1 {
return nil, errors.New("temporary preset failure") return nil, errors.New("temporary preset failure")
@@ -618,7 +418,7 @@ func TestHeartbeatONVIFPayloadReconnectFailureInvalidatesCache(t *testing.T) {
heartbeatGetPTZFunctionsFromDevice = func(goonvifptz.GetConfigurationsResponse) ([]string, bool, bool) { heartbeatGetPTZFunctionsFromDevice = func(goonvifptz.GetConfigurationsResponse) ([]string, bool, bool) {
return nil, true, false return nil, true, false
} }
heartbeatGetPresetsFromDevice = func(*goonvif.Device, int) ([]models.OnvifActionPreset, error) { heartbeatGetPresetsFromDevice = func(*goonvif.Device) ([]models.OnvifActionPreset, error) {
presetCalls++ presetCalls++
return []models.OnvifActionPreset{{Name: "Preset", Token: "1"}}, nil return []models.OnvifActionPreset{{Name: "Preset", Token: "1"}}, nil
} }
@@ -790,60 +590,3 @@ func countString(values []string, want string) int {
} }
return count return count
} }
// Some devices accept the subscription but reject the pulls, or never publish
// the initial I/O state. The relay outputs and digital inputs must then be
// queried directly instead of reporting no I/O at all.
func TestHeartbeatONVIFPayloadFallsBackToDirectIOWhenSubscriptionsReturnNoEvents(t *testing.T) {
restoreHeartbeatONVIFStubs(t)
device := newTestONVIFDevice()
camera := models.IPCamera{
ONVIFXAddr: "http://camera/onvif",
ONVIFUsername: "operator",
ONVIFPassword: "secret",
}
state := newHeartbeatONVIFState()
state.cameraConfiguration = camera
state.cameraKey = heartbeatONVIFCameraKey(camera)
state.device = device
state.staticLoaded = true
state.staticPayload.enabled = "true"
heartbeatCreatePullPointSubscription = func(*goonvif.Device) (string, error) {
return "pull-point", nil
}
heartbeatGetEventMessages = func(*goonvif.Device, string) ([]agentonvif.ONVIFEvents, error) {
return nil, errors.New("pull rejected")
}
heartbeatUnsubscribePullPoint = func(*goonvif.Device, string) error {
return nil
}
var relayCalls, inputCalls int
heartbeatGetRelayOutputs = func(*goonvif.Device) (goonvifdevice.GetRelayOutputsResponse, error) {
relayCalls++
return goonvifdevice.GetRelayOutputsResponse{RelayOutputs: []goonvifxsd.RelayOutput{{DeviceEntity: goonvifxsd.DeviceEntity{Token: "relay0"}}}}, nil
}
heartbeatGetDigitalInputs = func(*goonvif.Device) (goonvifdevice.GetDigitalInputsResponse, error) {
inputCalls++
return goonvifdevice.GetDigitalInputsResponse{DigitalInputs: []goonvifxsd.DigitalInput{{Token: "di0"}}}, nil
}
payload := getHeartbeatONVIFPayload(camera, state)
if relayCalls != 1 || inputCalls != 1 {
t.Fatalf("direct I/O queries: relay=%d inputs=%d, want 1 each", relayCalls, inputCalls)
}
var events []agentonvif.ONVIFEvents
if err := json.Unmarshal(payload.eventsList, &events); err != nil {
t.Fatalf("payload.eventsList is not valid JSON: %v", err)
}
got := map[string]string{}
for _, event := range events {
got[event.Key] = event.Type
}
if got["relay0"] != "output" || got["di0"] != "input" || len(got) != 2 {
t.Fatalf("payload.eventsList = %s, want relay0 output and di0 input", payload.eventsList)
}
}
-195
View File
@@ -1,195 +0,0 @@
package cloud
import (
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"net/http"
"sort"
"strings"
)
const (
customHeadersManifestHeader = "X-Kerberos-Storage-Custom-Headers"
maxCustomHeaders = 32
maxCustomHeaderNameLength = 128
maxCustomHeaderValueLength = 4096
)
var disallowedCustomHeaders = map[string]struct{}{
"authorization": {},
"connection": {},
"content-length": {},
"content-type": {},
"cookie": {},
"expect": {},
"host": {},
"keep-alive": {},
"proxy-authorization": {},
"proxy-connection": {},
"te": {},
"trailer": {},
"trace-id": {},
"transfer-encoding": {},
"tus-resumable": {},
"upgrade": {},
}
func parseCustomVaultHeaders(value string) (map[string]string, error) {
if strings.TrimSpace(value) == "" {
return nil, nil
}
// Decode into pointers so JSON null values can be told apart from strings.
var rawHeaders map[string]*string
if err := json.Unmarshal([]byte(value), &rawHeaders); err != nil {
return nil, fmt.Errorf("custom Vault headers must be a JSON object of string values: %w", err)
}
if rawHeaders == nil {
return nil, errors.New("custom Vault headers must be a JSON object of string values")
}
if len(rawHeaders) > maxCustomHeaders {
return nil, fmt.Errorf("custom Vault headers exceed the limit of %d", maxCustomHeaders)
}
headers := make(map[string]string, len(rawHeaders))
seen := make(map[string]struct{}, len(rawHeaders))
for name, rawValue := range rawHeaders {
if rawValue == nil {
return nil, fmt.Errorf("custom Vault header %q must be a string, not null", name)
}
value := *rawValue
headers[name] = value
if err := validateCustomVaultHeader(name, value); err != nil {
return nil, err
}
lowerName := strings.ToLower(name)
if _, duplicate := seen[lowerName]; duplicate {
return nil, fmt.Errorf("custom Vault header %q is duplicated with different casing", name)
}
seen[lowerName] = struct{}{}
}
return headers, nil
}
func validateCustomVaultHeader(name, value string) error {
if name == "" || len(name) > maxCustomHeaderNameLength || !isHTTPToken(name) {
return fmt.Errorf("invalid custom Vault header name %q", name)
}
lowerName := strings.ToLower(name)
if strings.HasPrefix(lowerName, "x-kerberos-") {
return fmt.Errorf("custom Vault header %q uses the reserved X-Kerberos namespace", name)
}
if strings.HasPrefix(lowerName, "upload-") {
return fmt.Errorf("custom Vault header %q uses the reserved tus Upload namespace", name)
}
if _, disallowed := disallowedCustomHeaders[lowerName]; disallowed {
return fmt.Errorf("custom Vault header %q is reserved", name)
}
if len(value) > maxCustomHeaderValueLength {
return fmt.Errorf("custom Vault header %q exceeds the %d byte value limit", name, maxCustomHeaderValueLength)
}
for _, character := range value {
if character < 0x20 || character == 0x7f {
return fmt.Errorf("custom Vault header %q contains an invalid value", name)
}
}
return nil
}
func isHTTPToken(value string) bool {
if value == "" {
return false
}
for _, character := range value {
if (character >= 'a' && character <= 'z') ||
(character >= 'A' && character <= 'Z') ||
(character >= '0' && character <= '9') ||
strings.ContainsRune("!#$%&'*+-.^_`|~", character) {
continue
}
return false
}
return true
}
func setCustomVaultHeaders(headers http.Header, customHeaders map[string]string) error {
if len(customHeaders) == 0 {
return nil
}
names := make([]string, 0, len(customHeaders))
for name, value := range customHeaders {
if err := validateCustomVaultHeader(name, value); err != nil {
return err
}
names = append(names, name)
// Assign directly so the configured name is not canonicalised by Set.
headers[name] = []string{value}
}
sort.Strings(names)
manifest, err := json.Marshal(names)
if err != nil {
return err
}
headers.Set(customHeadersManifestHeader, base64.RawURLEncoding.EncodeToString(manifest))
return nil
}
const maxVaultRedirects = 10
// stripVaultHeadersOnCrossHostRedirect removes Vault credentials and the
// customer-supplied metadata (custom headers, their manifest and the tus
// Upload-Metadata that embeds them) before following a redirect to another host.
func stripVaultHeadersOnCrossHostRedirect(req *http.Request, via []*http.Request) error {
if len(via) >= maxVaultRedirects {
return fmt.Errorf("stopped after %d redirects", maxVaultRedirects)
}
if len(via) == 0 || req.URL.Host == via[0].URL.Host {
return nil
}
customNames := customVaultHeaderNamesFromManifest(req.Header)
for name := range req.Header {
canonicalName := http.CanonicalHeaderKey(name)
_, custom := customNames[strings.ToLower(name)]
if custom || strings.HasPrefix(canonicalName, "X-Kerberos-") || canonicalName == "Upload-Metadata" {
delete(req.Header, name)
}
}
return nil
}
func customVaultHeaderNamesFromManifest(headers http.Header) map[string]struct{} {
encoded := headers.Get(customHeadersManifestHeader)
if encoded == "" {
return nil
}
manifest, err := base64.RawURLEncoding.DecodeString(encoded)
if err != nil {
return nil
}
var names []string
if err := json.Unmarshal(manifest, &names); err != nil {
return nil
}
lowerNames := make(map[string]struct{}, len(names))
for _, name := range names {
lowerNames[strings.ToLower(name)] = struct{}{}
}
return lowerNames
}
func encodeCustomVaultHeaders(customHeaders map[string]string) (string, error) {
if len(customHeaders) == 0 {
return "", nil
}
encoded, err := json.Marshal(customHeaders)
if err != nil {
return "", err
}
if len(encoded) == 0 {
return "", errors.New("custom Vault headers could not be encoded")
}
return string(encoded), nil
}
-100
View File
@@ -1,100 +0,0 @@
package cloud
import (
"encoding/base64"
"encoding/json"
"net/http"
"reflect"
"testing"
)
func TestCustomVaultHeadersAreValidatedAndAdded(t *testing.T) {
customHeaders, err := parseCustomVaultHeaders(`{"site_id":"site-1","line_id":"line-2"}`)
if err != nil {
t.Fatal(err)
}
headers := http.Header{}
if err := setCustomVaultHeaders(headers, customHeaders); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(headers["site_id"], []string{"site-1"}) || !reflect.DeepEqual(headers["line_id"], []string{"line-2"}) {
t.Fatalf("custom header names were not preserved: %#v", headers)
}
if _, canonicalised := headers["Site_id"]; canonicalised {
t.Fatalf("custom header name was canonicalised: %#v", headers)
}
encodedManifest, err := base64.RawURLEncoding.DecodeString(headers.Get(customHeadersManifestHeader))
if err != nil {
t.Fatal(err)
}
var names []string
if err := json.Unmarshal(encodedManifest, &names); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(names, []string{"line_id", "site_id"}) {
t.Fatalf("manifest = %#v", names)
}
}
func TestCustomVaultHeadersRejectReservedAndInvalidValues(t *testing.T) {
for _, value := range []string{
`{"X-Kerberos-Storage-AccessKey":"secret"}`,
`{"Authorization":"secret"}`,
`{"site_id":"one\nInjected: value"}`,
`{"bad header":"value"}`,
`{"site_id":1}`,
`{"Content-Type":"text/plain"}`,
`{"site_id":"one","SITE_ID":"two"}`,
`{"site_id":null}`,
`{"site_id":"one\ttwo"}`,
`{"Upload-Checksum":"sha1 abc"}`,
`{"upload-concat":"final;/files/a"}`,
`{"Upload-Defer-Length":"1"}`,
`null`,
} {
if _, err := parseCustomVaultHeaders(value); err == nil {
t.Fatalf("parseCustomVaultHeaders(%q) succeeded", value)
}
}
}
func TestVaultRedirectStripsCustomHeadersOnHostChange(t *testing.T) {
newRedirect := func(t *testing.T, host string) (*http.Request, []*http.Request) {
t.Helper()
original, err := http.NewRequest(http.MethodPost, "https://vault.example.com/api/storage", nil)
if err != nil {
t.Fatal(err)
}
redirected, err := http.NewRequest(http.MethodPost, "https://"+host+"/api/storage", nil)
if err != nil {
t.Fatal(err)
}
redirected.Header.Set("X-Kerberos-Storage-AccessKey", "secret")
redirected.Header.Set("Upload-Metadata", "custom_headers abc")
redirected.Header.Set("Tus-Resumable", "1.0.0")
if err := setCustomVaultHeaders(redirected.Header, map[string]string{"site_id": "site-1", "Line-Id": "line-2"}); err != nil {
t.Fatal(err)
}
return redirected, []*http.Request{original}
}
crossHost, via := newRedirect(t, "other.example.com")
if err := stripVaultHeadersOnCrossHostRedirect(crossHost, via); err != nil {
t.Fatal(err)
}
if len(crossHost.Header) != 1 || crossHost.Header.Get("Tus-Resumable") != "1.0.0" {
t.Fatalf("cross-host redirect headers = %#v", crossHost.Header)
}
sameHost, via := newRedirect(t, "vault.example.com")
if err := stripVaultHeadersOnCrossHostRedirect(sameHost, via); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(sameHost.Header["site_id"], []string{"site-1"}) ||
sameHost.Header.Get("X-Kerberos-Storage-AccessKey") != "secret" ||
sameHost.Header.Get(customHeadersManifestHeader) == "" {
t.Fatalf("same-host redirect headers = %#v", sameHost.Header)
}
}
+4 -2
View File
@@ -5,13 +5,13 @@ package cloud
import ( import (
"bytes" "bytes"
"errors" "errors"
"os"
"github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox"
"github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/files" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/files"
"github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/users" "github.com/dropbox/dropbox-sdk-go-unofficial/v6/dropbox/users"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/utils"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
) )
@@ -37,12 +37,14 @@ func UploadDropbox(configuration *models.Configuration, fileName string) (bool,
// Upload to Dropbox // Upload to Dropbox
log.Info("UploadDropbox: Uploading to Dropbox") log.Info("UploadDropbox: Uploading to Dropbox")
log.Info("UploadDropbox: Upload started for " + fileName) log.Info("UploadDropbox: Upload started for " + fileName)
fullname := "data/recordings/" + fileName
dConfig := dropbox.Config{ dConfig := dropbox.Config{
Token: token, Token: token,
LogLevel: dropbox.LogInfo, // if needed, set the desired logging level. Default is off LogLevel: dropbox.LogInfo, // if needed, set the desired logging level. Default is off
} }
file, err := utils.OpenRecording("data/recordings", fileName) file, err := os.OpenFile(fullname, os.O_RDWR, 0755)
if file != nil { if file != nil {
defer func() { defer func() {
if cerr := file.Close(); cerr != nil { if cerr := file.Close(); cerr != nil {
@@ -0,0 +1,550 @@
package frameprocessing
import (
"bytes"
"context"
"crypto/tls"
"encoding/json"
"errors"
"fmt"
"image"
"image/jpeg"
"io"
"mime/multipart"
"net/http"
"net/textproto"
"net/url"
"os"
"time"
mqtt "github.com/eclipse/paho.mqtt.golang"
"github.com/gofrs/uuid"
"github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/packets"
"github.com/kerberos-io/agent/machinery/src/utils"
log "github.com/sirupsen/logrus"
)
const (
schemaVersion = "1.0"
maxResponseBodyBytes = 64 << 10
)
type Decoder interface {
DecodePacket(packets.Packet) (image.YCbCr, error)
}
type Observer interface {
SetFrameProcessingConfigured(bool)
RecordFrameProcessingSample()
RecordFrameProcessingQueued(int, bool)
SetFrameProcessingQueueDepth(int)
RecordFrameProcessingSuccess(time.Time)
RecordFrameProcessingFailure()
}
type Metadata struct {
SchemaVersion string `json:"schemaVersion"`
RequestID string `json:"requestId"`
FrameID string `json:"frameId"`
DeviceID string `json:"deviceId"`
CapturedAt int64 `json:"capturedAt"`
ExpiresAt int64 `json:"expiresAt"`
ProcessingProfile string `json:"processingProfile"`
SourceStream string `json:"sourceStream"`
Width int `json:"width"`
Height int `json:"height"`
TraceID string `json:"traceId,omitempty"`
}
type Frame struct {
Metadata Metadata
JPEG []byte
}
type Sender struct {
endpoint string
token string
client *http.Client
}
type StatusPublisher interface {
Publish(context.Context, models.FrameProcessingStatus) error
}
type MQTTStatusPublisher struct {
client mqtt.Client
hubKey string
configuration *models.Configuration
timeout time.Duration
}
func NewMQTTStatusPublisher(client mqtt.Client, hubKey string, configuration *models.Configuration) *MQTTStatusPublisher {
return &MQTTStatusPublisher{
client: client, hubKey: hubKey, configuration: configuration, timeout: 5 * time.Second,
}
}
func (p *MQTTStatusPublisher) Publish(ctx context.Context, status models.FrameProcessingStatus) error {
if p == nil || p.client == nil || p.hubKey == "" || p.configuration == nil {
return errors.New("frame-processing MQTT status publisher is not configured")
}
value, err := structToMap(status)
if err != nil {
return err
}
payload, err := models.PackageMQTTMessage(p.configuration, models.Message{
Payload: models.Payload{
Version: schemaVersion,
Action: models.FrameProcessingStatusAction,
DeviceId: status.DeviceID,
Value: value,
},
})
if err != nil {
return fmt.Errorf("package frame-processing status: %w", err)
}
token := p.client.Publish("kerberos/hub/"+p.hubKey, 1, false, payload)
timer := time.NewTimer(p.timeout)
defer timer.Stop()
select {
case <-ctx.Done():
return ctx.Err()
case <-timer.C:
return errors.New("frame-processing status publish timed out")
case <-token.Done():
if err := token.Error(); err != nil {
return fmt.Errorf("publish frame-processing status: %w", err)
}
return nil
}
}
func structToMap(value any) (map[string]interface{}, error) {
encoded, err := json.Marshal(value)
if err != nil {
return nil, fmt.Errorf("marshal value: %w", err)
}
var result map[string]interface{}
if err := json.Unmarshal(encoded, &result); err != nil {
return nil, fmt.Errorf("decode value map: %w", err)
}
return result, nil
}
func NewSender(config models.FrameProcessing) (*Sender, error) {
if config.Token == "" {
return nil, errors.New("frameProcessing.token is required")
}
endpoint, err := url.ParseRequestURI(config.Endpoint)
if err != nil || (endpoint.Scheme != "http" && endpoint.Scheme != "https") || endpoint.Host == "" {
return nil, errors.New("frameProcessing.endpoint must be an absolute HTTP or HTTPS URL")
}
transport := http.DefaultTransport.(*http.Transport).Clone()
if os.Getenv("AGENT_TLS_INSECURE") == "true" {
if transport.TLSClientConfig == nil {
transport.TLSClientConfig = &tls.Config{}
}
transport.TLSClientConfig.InsecureSkipVerify = true
}
return &Sender{
endpoint: endpoint.String(),
token: config.Token,
client: &http.Client{
Transport: transport,
Timeout: time.Duration(config.RequestTimeoutSeconds) * time.Second,
},
}, nil
}
func (s *Sender) Submit(ctx context.Context, frame Frame) error {
var body bytes.Buffer
writer := multipart.NewWriter(&body)
metadataHeader := make(textproto.MIMEHeader)
metadataHeader.Set("Content-Disposition", `form-data; name="metadata"`)
metadataHeader.Set("Content-Type", "application/json")
metadataPart, err := writer.CreatePart(metadataHeader)
if err != nil {
return fmt.Errorf("create metadata part: %w", err)
}
if err := json.NewEncoder(metadataPart).Encode(frame.Metadata); err != nil {
return fmt.Errorf("encode metadata: %w", err)
}
frameHeader := make(textproto.MIMEHeader)
frameHeader.Set("Content-Disposition", `form-data; name="frame"; filename="frame.jpg"`)
frameHeader.Set("Content-Type", "image/jpeg")
framePart, err := writer.CreatePart(frameHeader)
if err != nil {
return fmt.Errorf("create frame part: %w", err)
}
if _, err := framePart.Write(frame.JPEG); err != nil {
return fmt.Errorf("write frame part: %w", err)
}
if err := writer.Close(); err != nil {
return fmt.Errorf("close multipart body: %w", err)
}
request, err := http.NewRequestWithContext(ctx, http.MethodPost, s.endpoint, &body)
if err != nil {
return fmt.Errorf("create frame request: %w", err)
}
request.Header.Set("Content-Type", writer.FormDataContentType())
if s.token != "" {
request.Header.Set("Authorization", "Bearer "+s.token)
}
response, err := s.client.Do(request)
if err != nil {
return fmt.Errorf("submit frame: %w", err)
}
defer response.Body.Close()
_, readErr := io.Copy(io.Discard, io.LimitReader(response.Body, maxResponseBodyBytes))
if readErr != nil {
return fmt.Errorf("read frame response: %w", readErr)
}
if response.StatusCode < http.StatusOK || response.StatusCode >= http.StatusMultipleChoices {
return fmt.Errorf("frame processor returned %s", response.Status)
}
return nil
}
func Run(
ctx context.Context,
cursor *packets.QueueCursor,
decoder Decoder,
config models.FrameProcessing,
deviceID string,
stream string,
observer Observer,
) error {
if config.Enabled != "true" {
return nil
}
if cursor == nil || decoder == nil {
return errors.New("frame processing requires a packet cursor and decoder")
}
if deviceID == "" {
return errors.New("frame processing requires a device ID")
}
if err := validateConfig(config); err != nil {
return err
}
sender, err := NewSender(config)
if err != nil {
return err
}
if observer != nil {
observer.SetFrameProcessingConfigured(true)
defer observer.SetFrameProcessingConfigured(false)
}
frames := make(chan Frame, config.PeriodicQueueCapacity)
samplerDone := make(chan error, 1)
go func() {
samplerDone <- sample(ctx, cursor, decoder, config, deviceID, stream, frames, observer)
close(frames)
}()
for {
select {
case <-ctx.Done():
<-samplerDone
return nil
case err := <-samplerDone:
return normalizeCancellation(ctx, err)
case frame, ok := <-frames:
if !ok {
return normalizeCancellation(ctx, <-samplerDone)
}
if observer != nil {
observer.SetFrameProcessingQueueDepth(len(frames))
}
if err := sender.Submit(ctx, frame); err != nil {
if ctx.Err() != nil {
return nil
}
if observer != nil {
observer.RecordFrameProcessingFailure()
observer.SetFrameProcessingQueueDepth(len(frames))
}
log.WithError(err).WithFields(log.Fields{
"component": "frame_processing",
"device_id": deviceID,
"event": "frame_submission_failed",
"frame_id": frame.Metadata.FrameID,
}).Warn("Failed to submit frame for processing")
continue
}
if observer != nil {
observer.RecordFrameProcessingSuccess(time.Now())
observer.SetFrameProcessingQueueDepth(len(frames))
}
}
}
}
func RunRequested(
ctx context.Context,
decoder Decoder,
config models.FrameProcessing,
deviceID string,
stream string,
requests <-chan models.FrameProcessingWork,
statusPublisher StatusPublisher,
observer Observer,
) error {
if config.Enabled != "true" {
return nil
}
if decoder == nil || requests == nil {
return errors.New("requested frame processing requires a decoder and request channel")
}
if deviceID == "" {
return errors.New("requested frame processing requires a device ID")
}
if err := validateConfig(config); err != nil {
return err
}
sender, err := NewSender(config)
if err != nil {
return err
}
for {
select {
case <-ctx.Done():
return nil
case work, ok := <-requests:
if !ok {
return nil
}
request := work.Request
if work.Cursor == nil {
publishStatus(ctx, statusPublisher, request, deviceID, "", "failed", true, "capture cursor is unavailable")
continue
}
if request.ExpiresAt <= time.Now().UnixMilli() {
publishStatus(ctx, statusPublisher, request, deviceID, "", "expired", false, "capture request expired")
continue
}
packet, err := nextKeyframe(ctx, work.Cursor, request.ExpiresAt)
if err != nil {
if ctx.Err() != nil {
return nil
}
publishStatus(ctx, statusPublisher, request, deviceID, "", "expired", false, "no keyframe before request expiry")
continue
}
frame, err := prepareRequestedFrame(packet, decoder, config, deviceID, stream, request, time.Now())
if err != nil {
if observer != nil {
observer.RecordFrameProcessingFailure()
}
publishStatus(ctx, statusPublisher, request, deviceID, "", "failed", true, "failed to prepare frame")
continue
}
if err := sender.Submit(ctx, frame); err != nil {
if ctx.Err() != nil {
return nil
}
if observer != nil {
observer.RecordFrameProcessingFailure()
}
publishStatus(ctx, statusPublisher, request, deviceID, frame.Metadata.FrameID, "failed", true, "frame submission failed")
continue
}
if observer != nil {
observer.RecordFrameProcessingSuccess(time.Now())
}
publishStatus(ctx, statusPublisher, request, deviceID, frame.Metadata.FrameID, "submitted", false, "")
}
}
}
func sample(
ctx context.Context,
cursor *packets.QueueCursor,
decoder Decoder,
config models.FrameProcessing,
deviceID string,
stream string,
frames chan Frame,
observer Observer,
) error {
interval := time.Duration(config.IntervalSeconds) * time.Second
nextDeadline := time.Now().Add(interval)
for {
packet, err := cursor.ReadPacketContext(ctx)
if err != nil {
return err
}
now := time.Now()
if len(packet.Data) == 0 || !packet.IsKeyFrame || now.Before(nextDeadline) {
continue
}
for !nextDeadline.After(now) {
nextDeadline = nextDeadline.Add(interval)
}
if observer != nil {
observer.RecordFrameProcessingSample()
}
frame, err := prepareFrame(packet, decoder, config, deviceID, stream, now)
if err != nil {
if observer != nil {
observer.RecordFrameProcessingFailure()
}
log.WithError(err).WithFields(log.Fields{
"component": "frame_processing",
"event": "frame_preparation_failed",
"stream": stream,
}).Warn("Failed to prepare frame for processing")
continue
}
dropped := enqueueLatest(frames, frame)
if observer != nil {
observer.RecordFrameProcessingQueued(len(frames), dropped)
}
}
}
func prepareFrame(packet packets.Packet, decoder Decoder, config models.FrameProcessing, deviceID, stream string, now time.Time) (Frame, error) {
frameID, err := uuid.NewV4()
if err != nil {
return Frame{}, fmt.Errorf("generate frame ID: %w", err)
}
return prepareFrameWithIdentity(packet, decoder, config, deviceID, stream, "periodic-"+frameID.String(), frameID.String(), config.Profile, "", now)
}
func prepareRequestedFrame(packet packets.Packet, decoder Decoder, config models.FrameProcessing, deviceID, stream string, request models.FrameProcessingRequest, now time.Time) (Frame, error) {
frameID, err := uuid.NewV4()
if err != nil {
return Frame{}, fmt.Errorf("generate frame ID: %w", err)
}
return prepareFrameWithIdentity(packet, decoder, config, deviceID, stream, request.RequestID, frameID.String(), request.ProcessingProfile, request.TraceID, now)
}
func prepareFrameWithIdentity(packet packets.Packet, decoder Decoder, config models.FrameProcessing, deviceID, stream, requestID, frameID, profile, traceID string, now time.Time) (Frame, error) {
decoded, err := decoder.DecodePacket(packet)
if err != nil {
return Frame{}, fmt.Errorf("decode keyframe: %w", err)
}
resized, err := utils.ResizeImage(&decoded, uint(config.Width), uint(config.Height))
if err != nil {
return Frame{}, fmt.Errorf("resize keyframe: %w", err)
}
var encoded bytes.Buffer
if err := jpeg.Encode(&encoded, *resized, &jpeg.Options{Quality: config.JPEGQuality}); err != nil {
return Frame{}, fmt.Errorf("encode keyframe: %w", err)
}
if int64(encoded.Len()) > config.MaxFrameBytes {
return Frame{}, fmt.Errorf("encoded keyframe exceeds frameProcessing.maxFrameBytes (%d)", config.MaxFrameBytes)
}
capturedAt := packet.CurrentTime
if capturedAt <= 0 {
capturedAt = now.UnixMilli()
}
bounds := (*resized).Bounds()
return Frame{
Metadata: Metadata{
SchemaVersion: schemaVersion,
RequestID: requestID,
FrameID: frameID,
DeviceID: deviceID,
CapturedAt: capturedAt,
ExpiresAt: now.Add(time.Duration(config.FrameTTLSeconds) * time.Second).UnixMilli(),
ProcessingProfile: profile,
SourceStream: stream,
Width: bounds.Dx(),
Height: bounds.Dy(),
TraceID: traceID,
},
JPEG: encoded.Bytes(),
}, nil
}
func nextKeyframe(ctx context.Context, cursor *packets.QueueCursor, expiresAt int64) (packets.Packet, error) {
requestContext, cancel := context.WithDeadline(ctx, time.UnixMilli(expiresAt))
defer cancel()
for {
packet, err := cursor.ReadPacketContext(requestContext)
if err != nil {
return packets.Packet{}, err
}
if packet.IsKeyFrame && len(packet.Data) > 0 {
return packet, nil
}
}
}
func publishStatus(ctx context.Context, publisher StatusPublisher, request models.FrameProcessingRequest, deviceID, frameID, status string, retryable bool, message string) {
if publisher == nil {
return
}
err := publisher.Publish(ctx, models.FrameProcessingStatus{
SchemaVersion: models.FrameProcessingSchemaVersion,
RequestID: request.RequestID,
FrameID: frameID,
DeviceID: deviceID,
Status: status,
OccurredAt: time.Now().UnixMilli(),
Retryable: retryable,
Message: message,
TraceID: request.TraceID,
})
if err != nil && ctx.Err() == nil {
log.WithError(err).WithFields(log.Fields{
"component": "frame_processing",
"event": "status_publish_failed",
"request_id": request.RequestID,
"status": status,
}).Warn("Failed to publish frame-processing status")
}
}
func enqueueLatest(frames chan Frame, frame Frame) bool {
select {
case frames <- frame:
return false
default:
}
select {
case <-frames:
default:
}
frames <- frame
return true
}
func normalizeCancellation(ctx context.Context, err error) error {
if ctx.Err() != nil || errors.Is(err, context.Canceled) {
return nil
}
return err
}
func validateConfig(config models.FrameProcessing) error {
if config.IntervalSeconds <= 0 {
return errors.New("frameProcessing.intervalSeconds must be positive")
}
if config.Width <= 0 || config.Width > 8192 || config.Height < 0 || config.Height > 8192 {
return errors.New("frameProcessing dimensions must be between 0 and 8192, with a positive width")
}
if config.JPEGQuality < 1 || config.JPEGQuality > 100 {
return errors.New("frameProcessing.jpegQuality must be between 1 and 100")
}
if config.RequestTimeoutSeconds <= 0 || config.RequestTimeoutSeconds > 60 {
return errors.New("frameProcessing.requestTimeoutSeconds must be between 1 and 60")
}
if config.FrameTTLSeconds <= 0 || config.FrameTTLSeconds > 3600 {
return errors.New("frameProcessing.frameTtlSeconds must be between 1 and 3600")
}
if config.MaxFrameBytes <= 0 || config.MaxFrameBytes > 16<<20 {
return errors.New("frameProcessing.maxFrameBytes must be between 1 and 16777216")
}
if config.PeriodicQueueCapacity <= 0 || config.PeriodicQueueCapacity > 64 {
return errors.New("frameProcessing.periodicQueueCapacity must be between 1 and 64")
}
if config.Profile == "" {
return errors.New("frameProcessing.profile is required")
}
return nil
}
@@ -0,0 +1,285 @@
package frameprocessing
import (
"bytes"
"context"
"encoding/json"
"image"
"image/color"
"io"
"mime/multipart"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/packets"
)
type fakeDecoder struct{}
func (fakeDecoder) DecodePacket(packets.Packet) (image.YCbCr, error) {
frame := image.NewYCbCr(image.Rect(0, 0, 4, 4), image.YCbCrSubsampleRatio420)
for index := range frame.Y {
frame.Y[index] = color.Gray{Y: 200}.Y
}
return *frame, nil
}
type fakeStatusPublisher struct {
statuses chan models.FrameProcessingStatus
}
func (p *fakeStatusPublisher) Publish(_ context.Context, status models.FrameProcessingStatus) error {
p.statuses <- status
return nil
}
func TestEnqueueLatestReplacesOldestFrame(t *testing.T) {
frames := make(chan Frame, 1)
frames <- Frame{Metadata: Metadata{FrameID: "old"}}
if dropped := enqueueLatest(frames, Frame{Metadata: Metadata{FrameID: "new"}}); !dropped {
t.Fatal("enqueueLatest() did not report dropping the stale frame")
}
if got := (<-frames).Metadata.FrameID; got != "new" {
t.Fatalf("queued frame = %q, want new", got)
}
}
func TestPrepareFrameUsesAgentCaptureTimestamp(t *testing.T) {
now := time.UnixMilli(2_000)
frame, err := prepareFrame(packets.Packet{CurrentTime: 1_500}, fakeDecoder{}, models.FrameProcessing{
Profile: "never-trigger", Width: 2, Height: 2, JPEGQuality: 70, FrameTTLSeconds: 30, MaxFrameBytes: 4 << 20,
}, "device-1", "sub", now)
if err != nil {
t.Fatal(err)
}
if frame.Metadata.CapturedAt != 1_500 || frame.Metadata.ExpiresAt != 32_000 {
t.Fatalf("metadata timestamps = %+v", frame.Metadata)
}
if frame.Metadata.Width != 2 || frame.Metadata.Height != 2 || len(frame.JPEG) == 0 {
t.Fatalf("prepared frame = %+v, bytes=%d", frame.Metadata, len(frame.JPEG))
}
}
func TestSenderSubmitsContractMultipartRequest(t *testing.T) {
var gotMetadata Metadata
var gotFrame []byte
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
if got := request.Header.Get("Authorization"); got != "Bearer secret" {
t.Errorf("Authorization = %q", got)
}
reader, err := request.MultipartReader()
if err != nil {
t.Error(err)
w.WriteHeader(http.StatusBadRequest)
return
}
for {
part, err := reader.NextPart()
if err == io.EOF {
break
}
if err != nil {
t.Error(err)
return
}
switch part.FormName() {
case "metadata":
if err := json.NewDecoder(part).Decode(&gotMetadata); err != nil {
t.Error(err)
}
case "frame":
gotFrame, err = io.ReadAll(part)
if err != nil {
t.Error(err)
}
}
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"decision":"no-event"}`))
}))
defer server.Close()
sender, err := NewSender(models.FrameProcessing{Endpoint: server.URL, Token: "secret", RequestTimeoutSeconds: 2})
if err != nil {
t.Fatal(err)
}
want := Frame{Metadata: Metadata{SchemaVersion: schemaVersion, FrameID: "frame-1"}, JPEG: []byte("jpeg")}
if err := sender.Submit(context.Background(), want); err != nil {
t.Fatal(err)
}
if gotMetadata.FrameID != want.Metadata.FrameID || !bytes.Equal(gotFrame, want.JPEG) {
t.Fatalf("submitted metadata=%+v frame=%q", gotMetadata, gotFrame)
}
}
func TestNewSenderRejectsRelativeEndpoint(t *testing.T) {
if _, err := NewSender(models.FrameProcessing{Endpoint: "/v1/frames", Token: "secret", RequestTimeoutSeconds: 1}); err == nil {
t.Fatal("NewSender() accepted a relative endpoint")
}
}
func TestValidateConfigRejectsUnboundedQueue(t *testing.T) {
config := models.FrameProcessing{
Profile: "never-trigger", IntervalSeconds: 10, Width: 640,
JPEGQuality: 70, RequestTimeoutSeconds: 5, FrameTTLSeconds: 30,
MaxFrameBytes: 4 << 20, PeriodicQueueCapacity: 65,
}
if err := validateConfig(config); err == nil {
t.Fatal("validateConfig() accepted an unbounded queue")
}
}
func TestMultipartContentTypeIsParseable(t *testing.T) {
var body bytes.Buffer
writer := multipart.NewWriter(&body)
if err := writer.Close(); err != nil {
t.Fatal(err)
}
request := httptest.NewRequest(http.MethodPost, "/", &body)
request.Header.Set("Content-Type", writer.FormDataContentType())
if _, err := request.MultipartReader(); err != nil {
t.Fatal(err)
}
}
func TestRunCancelsBlockedPacketRead(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusOK)
}))
defer server.Close()
queue := packets.NewQueue()
defer queue.Close()
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() {
done <- Run(ctx, queue.Latest(), fakeDecoder{}, models.FrameProcessing{
Enabled: "true", Endpoint: server.URL, Token: "secret", Profile: "never-trigger",
Stream: "main", IntervalSeconds: 10, Width: 640, JPEGQuality: 70,
RequestTimeoutSeconds: 2, FrameTTLSeconds: 30, MaxFrameBytes: 4 << 20,
PeriodicQueueCapacity: 1,
}, "device-1", "main", nil)
}()
cancel()
select {
case err := <-done:
if err != nil {
t.Fatalf("Run() error = %v", err)
}
case <-time.After(time.Second):
t.Fatal("Run() did not stop after cancellation")
}
}
func TestRunRequestedCapturesNextKeyframeAndSubmitsHTTP(t *testing.T) {
metadataReceived := make(chan Metadata, 1)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
reader, err := request.MultipartReader()
if err != nil {
t.Error(err)
return
}
for {
part, err := reader.NextPart()
if err == io.EOF {
break
}
if err != nil {
t.Error(err)
return
}
if part.FormName() == "metadata" {
var metadata Metadata
if err := json.NewDecoder(part).Decode(&metadata); err != nil {
t.Error(err)
return
}
metadataReceived <- metadata
}
}
w.WriteHeader(http.StatusOK)
}))
defer server.Close()
queue := packets.NewQueue()
defer queue.Close()
if err := queue.WriteHeader([]packets.Stream{{Index: 0, IsVideo: true}}); err != nil {
t.Fatal(err)
}
requests := make(chan models.FrameProcessingWork, 1)
statuses := &fakeStatusPublisher{statuses: make(chan models.FrameProcessingStatus, 4)}
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
config := models.FrameProcessing{
Enabled: "true", Endpoint: server.URL, Token: "secret", Profile: "never-trigger",
IntervalSeconds: 10, Width: 2, Height: 2, JPEGQuality: 70,
RequestTimeoutSeconds: 2, FrameTTLSeconds: 30, MaxFrameBytes: 4 << 20,
PeriodicQueueCapacity: 1,
}
go func() {
done <- RunRequested(ctx, fakeDecoder{}, config, "device-1", "sub", requests, statuses, nil)
}()
requests <- models.FrameProcessingWork{
Request: models.FrameProcessingRequest{
SchemaVersion: models.FrameProcessingSchemaVersion,
RequestID: "request-1", ProcessingProfile: "always-trigger",
ExpiresAt: time.Now().Add(time.Second).UnixMilli(), TraceID: "trace-1",
},
Cursor: queue.LatestAtCurrentTail(),
}
queue.WritePacket(packets.Packet{Idx: 0, IsVideo: true, IsKeyFrame: true, CurrentTime: 1234, Data: []byte{1}})
metadata := <-metadataReceived
if metadata.RequestID != "request-1" || metadata.CapturedAt != 1234 || metadata.TraceID != "trace-1" {
t.Fatalf("submitted metadata = %+v", metadata)
}
status := <-statuses.statuses
if status.Status != "submitted" || status.FrameID == "" {
t.Fatalf("status = %+v", status)
}
cancel()
if err := <-done; err != nil {
t.Fatalf("RunRequested() error = %v", err)
}
}
func TestRunRequestedExpiresWhileWaitingForKeyframe(t *testing.T) {
queue := packets.NewQueue()
defer queue.Close()
requests := make(chan models.FrameProcessingWork, 1)
statuses := &fakeStatusPublisher{statuses: make(chan models.FrameProcessingStatus, 1)}
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() {
done <- RunRequested(ctx, fakeDecoder{}, models.FrameProcessing{
Enabled: "true", Endpoint: "http://127.0.0.1:1/v1/frames", Token: "secret", Profile: "never-trigger",
IntervalSeconds: 10, Width: 2, Height: 2, JPEGQuality: 70,
RequestTimeoutSeconds: 1, FrameTTLSeconds: 30, MaxFrameBytes: 4 << 20,
PeriodicQueueCapacity: 1,
}, "device-1", "main", requests, statuses, nil)
}()
requests <- models.FrameProcessingWork{
Request: models.FrameProcessingRequest{
SchemaVersion: models.FrameProcessingSchemaVersion,
RequestID: "request-expiring", ProcessingProfile: "never-trigger",
ExpiresAt: time.Now().Add(20 * time.Millisecond).UnixMilli(),
},
Cursor: queue.LatestAtCurrentTail(),
}
select {
case status := <-statuses.statuses:
if status.Status != "expired" {
t.Fatalf("status = %+v", status)
}
case <-time.After(time.Second):
t.Fatal("requested frame did not expire while waiting for a keyframe")
}
cancel()
if err := <-done; err != nil {
t.Fatalf("RunRequested() error = %v", err)
}
}
+3 -2
View File
@@ -9,7 +9,6 @@ import (
"os" "os"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/utils"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
) )
@@ -79,8 +78,10 @@ func UploadKerberosHub(configuration *models.Configuration, fileName string) (bo
}).Info("Resumable Hub upload unavailable; using legacy upload") }).Info("Resumable Hub upload unavailable; using legacy upload")
} }
fullname := "data/recordings/" + fileName
// Check if we still have the file otherwise we abort the request. // Check if we still have the file otherwise we abort the request.
file, err := utils.OpenRecording("data/recordings", fileName) file, err := os.OpenFile(fullname, os.O_RDWR, 0755)
if file != nil { if file != nil {
defer file.Close() defer file.Close()
} }
+7 -26
View File
@@ -10,7 +10,6 @@ import (
"time" "time"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/utils"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
) )
@@ -36,23 +35,10 @@ func UploadKerberosVault(configuration *models.Configuration, fileName string) (
// This can happen when the file was already removed (e.g. cleanup, or an // This can happen when the file was already removed (e.g. cleanup, or an
// earlier successful upload). Skip it so the watcher drops the marker // earlier successful upload). Skip it so the watcher drops the marker
// instead of retrying indefinitely. // instead of retrying indefinitely.
filePath, err := utils.ResolveRecordingPath("data/recordings", fileName) info, err := os.Stat("data/recordings/" + fileName)
if err != nil { if err != nil {
if os.IsNotExist(err) { log.Info("UploadKerberosVault: skipping " + fileName + ", file doesn't exist anymore")
log.Info("UploadKerberosVault: skipping " + fileName + ", file doesn't exist anymore") return false, false, nil
return false, false, nil
}
log.WithError(err).Error("UploadKerberosVault: could not resolve recording path")
return false, true, err
}
info, err := os.Stat(filePath)
if err != nil {
if os.IsNotExist(err) {
log.Info("UploadKerberosVault: skipping " + fileName + ", file doesn't exist anymore")
return false, false, nil
}
log.WithError(err).Error("UploadKerberosVault: could not stat recording")
return false, true, err
} }
if info.Size() == 0 { if info.Size() == 0 {
log.Warn("UploadKerberosVault: skipping " + fileName + ", recording is empty") log.Warn("UploadKerberosVault: skipping " + fileName + ", recording is empty")
@@ -192,11 +178,9 @@ func sendToVault(vault models.KStorage, publicKey, deviceKey, fileName, label, s
// is sent as the body of a POST to {URI}/storage. Kept for backwards // is sent as the body of a POST to {URI}/storage. Kept for backwards
// compatibility with vault deployments that do not support resumable uploads. // compatibility with vault deployments that do not support resumable uploads.
func uploadVaultLegacy(vault models.KStorage, publicKey, deviceKey, fileName, label string) (bool, bool, string, error) { func uploadVaultLegacy(vault models.KStorage, publicKey, deviceKey, fileName, label string) (bool, bool, string, error) {
customHeaders, err := parseCustomVaultHeaders(vault.CustomHeaders) fullname := "data/recordings/" + fileName
if err != nil {
return false, false, "", err file, err := os.Open(fullname)
}
file, err := utils.OpenRecording("data/recordings", fileName)
if file != nil { if file != nil {
defer file.Close() defer file.Close()
} }
@@ -219,9 +203,6 @@ func uploadVaultLegacy(vault models.KStorage, publicKey, deviceKey, fileName, la
} }
req.Header.Set("Content-Type", "video/mp4") req.Header.Set("Content-Type", "video/mp4")
setVaultHeaders(req.Header, vault, publicKey, deviceKey, fileName) setVaultHeaders(req.Header, vault, publicKey, deviceKey, fileName)
if err := setCustomVaultHeaders(req.Header, customHeaders); err != nil {
return false, false, "", err
}
setQueuedRecordingMetadataHeaders(req.Header, fileName) setQueuedRecordingMetadataHeaders(req.Header, fileName)
client := newVaultHTTPClient(0) client := newVaultHTTPClient(0)
@@ -286,7 +267,7 @@ func newVaultHTTPClient(timeout time.Duration) *http.Client {
transport.TLSClientConfig.InsecureSkipVerify = true transport.TLSClientConfig.InsecureSkipVerify = true
} }
client := &http.Client{Transport: transport, CheckRedirect: stripVaultHeadersOnCrossHostRedirect} client := &http.Client{Transport: transport}
if timeout > 0 { if timeout > 0 {
client.Timeout = timeout client.Timeout = timeout
} }
@@ -1,58 +0,0 @@
package cloud
import (
"testing"
"github.com/kerberos-io/agent/machinery/src/models"
log "github.com/sirupsen/logrus"
"github.com/sirupsen/logrus/hooks/test"
)
func TestHandleRealtimeProcessingWithoutMQTTClient(t *testing.T) {
tests := []struct {
name string
config models.Config
wantWarning bool
}{
{
name: "enabled without Hub credentials",
config: models.Config{RealtimeProcessing: "true"},
wantWarning: true,
},
{
name: "disabled",
config: models.Config{RealtimeProcessing: "false"},
},
{
name: "offline",
config: models.Config{RealtimeProcessing: "true", Offline: "true"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
hook := test.NewGlobal()
defer hook.Reset()
configuration := &models.Configuration{Config: tt.config}
// No cursor or decoder should be accessed without an MQTT client.
HandleRealtimeProcessing(nil, configuration, nil, nil, nil)
warnings := 0
for _, entry := range hook.AllEntries() {
if entry.Level == log.WarnLevel {
warnings++
if entry.Message != "cloud.RealtimeProcessing(): stopping as MQTT client is not configured." {
t.Errorf("unexpected warning: %s", entry.Message)
}
}
}
wantWarnings := 0
if tt.wantWarning {
wantWarnings = 1
}
if warnings != wantWarnings {
t.Fatalf("warnings = %d, want %d", warnings, wantWarnings)
}
})
}
}
+2 -30
View File
@@ -2,7 +2,6 @@ package cloud
import ( import (
"encoding/json" "encoding/json"
"fmt"
"math" "math"
"net/http" "net/http"
"os" "os"
@@ -11,16 +10,12 @@ import (
"strings" "strings"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
log "github.com/sirupsen/logrus"
) )
const recordingFPSHeader = "X-Kerberos-Storage-Fps" const recordingFPSHeader = "X-Kerberos-Storage-Fps"
const recordingDurationHeader = "X-Kerberos-Storage-Duration" const recordingDurationHeader = "X-Kerberos-Storage-Duration"
const recordingTimestampHeader = "X-Kerberos-Storage-Timestamp" const recordingTimestampHeader = "X-Kerberos-Storage-Timestamp"
const recordingEncryptedHeader = "X-Kerberos-Storage-Encrypted" const recordingEncryptedHeader = "X-Kerberos-Storage-Encrypted"
const recordingDeviceNameHeader = "X-Kerberos-Storage-DeviceName"
const recordingRegionHeader = "X-Kerberos-Storage-RegionCoordinates"
const recordingChangesHeader = "X-Kerberos-Storage-NumberOfChanges"
// queuedRecordingFPS reads the FPS snapshot written into the upload marker // queuedRecordingFPS reads the FPS snapshot written into the upload marker
// when the recording was finalized. Historical empty markers intentionally // when the recording was finalized. Historical empty markers intentionally
@@ -66,14 +61,6 @@ func decodeRecordingUploadMetadata(value []byte) (models.RecordingUploadMetadata
} }
func readRecordingUploadMetadata(fileName string) ([]byte, bool) { func readRecordingUploadMetadata(fileName string) ([]byte, bool) {
value, err := readRecordingUploadMetadataFile(fileName)
if err != nil && !os.IsNotExist(err) {
log.WithError(err).Error("Failed to read recording upload metadata")
}
return value, err == nil
}
func readRecordingUploadMetadataFile(fileName string) ([]byte, error) {
markerNames := []string{ markerNames := []string{
models.RecordingUploadMetadataFileName(fileName), models.RecordingUploadMetadataFileName(fileName),
filepath.Base(fileName), filepath.Base(fileName),
@@ -81,13 +68,10 @@ func readRecordingUploadMetadataFile(fileName string) ([]byte, error) {
for _, markerName := range markerNames { for _, markerName := range markerNames {
value, err := os.ReadFile(filepath.Join("data", "cloud", markerName)) value, err := os.ReadFile(filepath.Join("data", "cloud", markerName))
if err == nil { if err == nil {
return value, nil return value, true
}
if !os.IsNotExist(err) {
return nil, fmt.Errorf("read recording upload metadata %s: %w", markerName, err)
} }
} }
return nil, os.ErrNotExist return nil, false
} }
func setQueuedRecordingMetadataHeaders(header http.Header, fileName string) { func setQueuedRecordingMetadataHeaders(header http.Header, fileName string) {
@@ -95,18 +79,6 @@ func setQueuedRecordingMetadataHeaders(header http.Header, fileName string) {
header.Set(recordingFPSHeader, fps) header.Set(recordingFPSHeader, fps)
} }
if metadata, ok := queuedRecordingMetadata(fileName); ok { if metadata, ok := queuedRecordingMetadata(fileName); ok {
if metadata.DeviceKey != "" {
header.Set("X-Kerberos-Storage-Device", metadata.DeviceKey)
}
if metadata.DeviceName != "" {
header.Set(recordingDeviceNameHeader, metadata.DeviceName)
}
if metadata.RegionCoordinates != "" {
header.Set(recordingRegionHeader, metadata.RegionCoordinates)
}
if metadata.NumberOfChanges != "" {
header.Set(recordingChangesHeader, metadata.NumberOfChanges)
}
if metadata.Duration > 0 { if metadata.Duration > 0 {
header.Set(recordingDurationHeader, strconv.FormatUint(metadata.Duration, 10)) header.Set(recordingDurationHeader, strconv.FormatUint(metadata.Duration, 10))
} }
+36 -155
View File
@@ -2,20 +2,14 @@ package cloud
import ( import (
"crypto/tls" "crypto/tls"
"encoding/json"
"errors" "errors"
"fmt"
"math"
"net/http" "net/http"
"net/url" "net/url"
"os" "os"
"path/filepath"
"strconv" "strconv"
"strings" "strings"
"time"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/utils"
"github.com/minio/minio-go/v6" "github.com/minio/minio-go/v6"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
) )
@@ -24,6 +18,15 @@ func UploadS3(configuration *models.Configuration, fileName string) (bool, bool,
config := configuration.Config config := configuration.Config
// timestamp_microseconds_instanceName_regionCoordinates_numberOfChanges_token
// 1564859471_6-474162_oprit_577-283-727-375_1153_27.mp4
// - Timestamp
// - Size + - + microseconds
// - device
// - Region
// - Number of changes
// - Token
if config.S3 == nil { if config.S3 == nil {
errorMessage := "UploadS3: Uploading Failed, as no settings found" errorMessage := "UploadS3: Uploading Failed, as no settings found"
log.Error(errorMessage) log.Error(errorMessage)
@@ -68,14 +71,24 @@ func UploadS3(configuration *models.Configuration, fileName string) (bool, bool,
s3Client.SetCustomTransport(transport) s3Client.SetCustomTransport(transport)
} }
objectName, userMetadata, err := s3RecordingUploadDetails(config, fileName, aws_access_key_id) fileParts := strings.Split(fileName, "_")
if err != nil { if len(fileParts) == 1 {
log.WithError(err).Error("UploadS3: invalid recording upload metadata") errorMessage := "UploadS3: " + fileName + " is not a valid name."
return false, true, err log.Error(errorMessage)
return false, true, errors.New(errorMessage)
} }
deviceKey := config.Key
startRecording, _ := strconv.ParseInt(fileParts[0], 10, 64)
devicename := fileParts[2]
coordinates := fileParts[3]
//numberOfChanges := fileParts[4]
token, _ := strconv.Atoi(fileParts[5])
log.Info("UploadS3: Upload started for " + fileName) log.Info("UploadS3: Upload started for " + fileName)
file, err := utils.OpenRecording("data/recordings", fileName) fullname := "data/recordings/" + fileName
file, err := os.OpenFile(fullname, os.O_RDWR, 0755)
if file != nil { if file != nil {
defer file.Close() defer file.Close()
} }
@@ -94,13 +107,23 @@ func UploadS3(configuration *models.Configuration, fileName string) (bool, bool,
} }
n, err := s3Client.PutObject(config.S3.Bucket, n, err := s3Client.PutObject(config.S3.Bucket,
objectName, config.S3.Username+"/"+fileName,
file, file,
fileInfo.Size(), fileInfo.Size(),
minio.PutObjectOptions{ minio.PutObjectOptions{
ContentType: "video/mp4", ContentType: "video/mp4",
StorageClass: "ONEZONE_IA", StorageClass: "ONEZONE_IA",
UserMetadata: userMetadata, UserMetadata: map[string]string{
"event-timestamp": strconv.FormatInt(startRecording, 10),
"event-microseconds": deviceKey,
"event-instancename": devicename,
"event-regioncoordinates": coordinates,
"event-numberofchanges": deviceKey,
"event-token": strconv.Itoa(token),
"productid": deviceKey,
"publickey": aws_access_key_id,
"uploadtime": "now",
},
}) })
if err != nil { if err != nil {
@@ -112,145 +135,3 @@ func UploadS3(configuration *models.Configuration, fileName string) (bool, bool,
return true, true, nil return true, true, nil
} }
} }
func s3RecordingObjectName(username, deviceKey string, startRecording int64) string {
return username + "/" + time.UnixMilli(startRecording).UTC().Format("2006/01/02") +
"/" + strconv.FormatInt(startRecording, 10) + "-" + deviceKey + ".mp4"
}
func s3RecordingUploadDetails(config models.Config, fileName, publicKey string) (string, map[string]string, error) {
value, err := readRecordingUploadMetadataFile(fileName)
if err != nil && !os.IsNotExist(err) {
return "", nil, err
}
deviceKey := config.Key
var startRecording int64
userMetadata := map[string]string{
"publickey": publicKey,
"uploadtime": "now",
}
marker := strings.TrimSpace(string(value))
_, fpsErr := strconv.ParseFloat(marker, 64)
if err == nil && marker != "" && fpsErr != nil {
var metadata models.RecordingUploadMetadata
if err := json.Unmarshal(value, &metadata); err != nil {
return "", nil, fmt.Errorf("decode recording upload metadata for %s: %w", fileName, err)
}
if metadata.FileName != "" && metadata.FileName != filepath.Base(fileName) {
return "", nil, fmt.Errorf("recording upload metadata filename does not match %s", fileName)
}
if metadata.Timestamp <= 0 {
return "", nil, fmt.Errorf("invalid recording timestamp in upload metadata for %s", fileName)
}
deviceKey = metadata.DeviceKey
startRecording = metadata.Timestamp
userMetadata["event-instancename"] = config.Name
if metadata.DeviceName == "" || metadata.RegionCoordinates == "" || metadata.NumberOfChanges == "" {
if description, ok := s3LegacyRecordingDescription(fileName); ok {
for key, value := range description {
userMetadata[key] = value
}
}
}
if metadata.DeviceName != "" {
userMetadata["event-instancename"] = metadata.DeviceName
}
if metadata.RegionCoordinates != "" {
userMetadata["event-regioncoordinates"] = metadata.RegionCoordinates
}
if metadata.NumberOfChanges != "" {
userMetadata["event-numberofchanges"] = metadata.NumberOfChanges
}
userMetadata["event-microseconds"] = strconv.FormatInt(metadata.Timestamp%1000*1000, 10)
userMetadata["duration"] = strconv.FormatUint(metadata.Duration, 10)
userMetadata["encrypted"] = strconv.FormatBool(metadata.Encrypted)
if metadata.FPS > 0 && metadata.FPS <= 240 {
userMetadata["fps"] = strconv.FormatFloat(metadata.FPS, 'f', -1, 64)
}
} else {
// Empty and FPS-only markers predate structured recording metadata.
fileParts := strings.Split(fileName, "_")
if len(fileParts) < 6 {
return "", nil, fmt.Errorf("%s is not a valid legacy recording name", fileName)
}
startRecording, err = strconv.ParseInt(fileParts[0], 10, 64)
if err != nil {
return "", nil, fmt.Errorf("invalid recording timestamp in %s: %w", fileName, err)
}
if startRecording <= 0 || startRecording > math.MaxInt64/1000 {
return "", nil, fmt.Errorf("invalid recording timestamp in %s", fileName)
}
startRecording *= 1000
_, precision, found := strings.Cut(fileParts[1], "-")
if found {
fraction, err := strconv.ParseInt(precision, 10, 64)
if err != nil || fraction < 0 || fraction >= 1000000 {
return "", nil, fmt.Errorf("invalid recording precision in %s", fileName)
}
if len(precision) > 3 {
fraction /= 1000
}
startRecording += fraction
}
token, _ := strconv.Atoi(fileParts[5])
userMetadata["event-microseconds"] = deviceKey
userMetadata["event-instancename"] = fileParts[2]
userMetadata["event-regioncoordinates"] = fileParts[3]
userMetadata["event-numberofchanges"] = deviceKey
userMetadata["event-token"] = strconv.Itoa(token)
}
if deviceKey == "" || strings.ContainsAny(deviceKey, "/\\") {
return "", nil, errors.New("missing or invalid recording device key")
}
if startRecording <= 0 {
return "", nil, fmt.Errorf("invalid recording timestamp for %s", fileName)
}
userMetadata["event-timestamp"] = strconv.FormatInt(startRecording/1000, 10)
userMetadata["productid"] = deviceKey
return s3RecordingObjectName(config.S3.Username, deviceKey, startRecording), userMetadata, nil
}
func s3LegacyRecordingDescription(fileName string) (map[string]string, bool) {
base := filepath.Base(fileName)
if filepath.Ext(base) != ".mp4" {
return nil, false
}
parts := strings.Split(strings.TrimSuffix(base, ".mp4"), "_")
if len(parts) != 6 || parts[2] == "" {
return nil, false
}
seconds, err := strconv.ParseInt(parts[0], 10, 64)
if err != nil || seconds <= 0 || seconds > math.MaxInt64/1000 {
return nil, false
}
digits, fraction, found := strings.Cut(parts[1], "-")
precision, err := strconv.Atoi(digits)
if !found || err != nil || precision < 1 || precision > 6 || len(fraction) != precision {
return nil, false
}
if _, err := strconv.ParseUint(fraction, 10, 64); err != nil {
return nil, false
}
coordinates := strings.Split(parts[3], "-")
if len(coordinates) != 4 {
return nil, false
}
for _, coordinate := range coordinates {
if _, err := strconv.ParseUint(coordinate, 10, 64); err != nil {
return nil, false
}
}
changes, err := strconv.ParseInt(parts[4], 10, 64)
if err != nil || changes < -1 {
return nil, false
}
if _, err := strconv.ParseUint(parts[5], 10, 64); err != nil {
return nil, false
}
return map[string]string{
"event-instancename": parts[2],
"event-regioncoordinates": parts[3],
"event-numberofchanges": parts[4],
}, true
}
-328
View File
@@ -1,328 +0,0 @@
package cloud
import (
"encoding/json"
"os"
"path/filepath"
"reflect"
"strconv"
"strings"
"testing"
"time"
"github.com/kerberos-io/agent/machinery/src/models"
)
func TestS3RecordingUploadDetailsUsesCheckpoint(t *testing.T) {
for _, fileName := range []string{
"1767355200123-checkpoint-key.mp4",
"1564859471_6-474162_old-camera_0-0-0-0_1153_27.mp4",
} {
t.Run(fileName, func(t *testing.T) {
withRecording(t, fileName, []byte("recording"))
recorded := time.Date(2026, time.January, 2, 12, 0, 0, 123000000, time.UTC)
metadata := models.RecordingUploadMetadata{
FileName: fileName,
DeviceKey: "checkpoint-key",
Timestamp: recorded.UnixMilli(),
Duration: 20452,
FPS: 29.97,
Encrypted: true,
DeviceName: "checkpoint-camera",
RegionCoordinates: "1-2-3-4",
NumberOfChanges: "57",
}
payload, err := json.Marshal(metadata)
if err != nil {
t.Fatal(err)
}
withQueuedRecordingFPS(t, fileName, string(payload))
config := models.Config{
Key: "changed-config-key",
Name: "camera-name",
S3: &models.S3{Username: "user"},
}
objectName, userMetadata, err := s3RecordingUploadDetails(config, fileName, "public-key")
if err != nil {
t.Fatal(err)
}
wantObjectName := "user/2026/01/02/" + strconv.FormatInt(recorded.UnixMilli(), 10) + "-checkpoint-key.mp4"
if objectName != wantObjectName {
t.Fatalf("object name = %q, want %q", objectName, wantObjectName)
}
wantMetadata := map[string]string{
"publickey": "public-key",
"uploadtime": "now",
"event-instancename": "checkpoint-camera",
"event-regioncoordinates": "1-2-3-4",
"event-numberofchanges": "57",
"event-microseconds": "123000",
"event-timestamp": strconv.FormatInt(recorded.Unix(), 10),
"productid": "checkpoint-key",
"duration": "20452",
"fps": "29.97",
"encrypted": "true",
}
if !reflect.DeepEqual(userMetadata, wantMetadata) {
t.Fatalf("metadata = %#v, want %#v", userMetadata, wantMetadata)
}
})
}
}
func TestS3RecordingUploadDetailsBackfillsLegacyCheckpointDescriptions(t *testing.T) {
const legacyName = "1564859471_6-474162_recorded-camera_1-2-3-4_1153_27.mp4"
tests := []struct {
name string
fileName string
camera string
region string
changes string
wantCamera string
wantRegion string
wantChanges string
}{
{"pre-upgrade checkpoint", legacyName, "", "", "", "recorded-camera", "1-2-3-4", "1153"},
{"checkpoint camera", legacyName, "snapshot-camera", "", "", "snapshot-camera", "1-2-3-4", "1153"},
{"checkpoint region", legacyName, "", "5-6-7-8", "", "recorded-camera", "5-6-7-8", "1153"},
{"checkpoint zero changes", legacyName, "", "", "0", "recorded-camera", "1-2-3-4", "0"},
{"dated reference", "2019/08/03/" + legacyName, "", "", "", "recorded-camera", "1-2-3-4", "1153"},
{"continuous recording", "1564859471_3-474_recorded-camera_0-0-0-0_-1_27.mp4", "", "", "", "recorded-camera", "0-0-0-0", "-1"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
withRecording(t, filepath.Base(tt.fileName), []byte("recording"))
metadata := models.RecordingUploadMetadata{
FileName: filepath.Base(tt.fileName),
DeviceKey: "checkpoint-key",
Timestamp: 1767355200123,
Duration: 20452,
FPS: 29.97,
Encrypted: true,
DeviceName: tt.camera,
RegionCoordinates: tt.region,
NumberOfChanges: tt.changes,
}
payload, err := json.Marshal(metadata)
if err != nil {
t.Fatal(err)
}
withQueuedRecordingFPS(t, tt.fileName, string(payload))
config := models.Config{Key: "current-key", Name: "current-camera", S3: &models.S3{Username: "user"}}
objectName, got, err := s3RecordingUploadDetails(config, tt.fileName, "public-key")
if err != nil {
t.Fatal(err)
}
if want := "user/2026/01/02/1767355200123-checkpoint-key.mp4"; objectName != want {
t.Fatalf("object name = %q, want %q", objectName, want)
}
want := map[string]string{
"publickey": "public-key",
"uploadtime": "now",
"event-instancename": tt.wantCamera,
"event-regioncoordinates": tt.wantRegion,
"event-numberofchanges": tt.wantChanges,
"event-microseconds": "123000",
"event-timestamp": "1767355200",
"productid": "checkpoint-key",
"duration": "20452",
"fps": "29.97",
"encrypted": "true",
}
if !reflect.DeepEqual(got, want) {
t.Fatalf("metadata = %#v, want %#v", got, want)
}
})
}
}
func TestS3RecordingUploadDetailsDoesNotBackfillInvalidLegacyNames(t *testing.T) {
for _, fileName := range []string{
"1767355200123-checkpoint-key.mp4",
"invalid_6-474162_camera_0-0-0-0_1153_27.mp4",
"1564859471_6-invalid_camera_0-0-0-0_1153_27.mp4",
"1564859471_3-474162_camera_0-0-0-0_1153_27.mp4",
"1564859471_6-474162__0-0-0-0_1153_27.mp4",
"1564859471_6-474162_camera_invalid_1153_27.mp4",
"1564859471_6-474162_camera_0-0-0-0_invalid_27.mp4",
"1564859471_6-474162_camera_0-0-0-0_1153_invalid.mp4",
"1564859471_6-474162_camera_0-0-0-0_1153_27_extra.mp4",
} {
t.Run(fileName, func(t *testing.T) {
withRecording(t, fileName, []byte("recording"))
metadata := models.RecordingUploadMetadata{
FileName: fileName, DeviceKey: "checkpoint-key", Timestamp: 1767355200123, Duration: 20452,
}
payload, err := json.Marshal(metadata)
if err != nil {
t.Fatal(err)
}
withQueuedRecordingFPS(t, fileName, string(payload))
config := models.Config{Key: "current-key", Name: "current-camera", S3: &models.S3{Username: "user"}}
objectName, got, err := s3RecordingUploadDetails(config, fileName, "public-key")
if err != nil {
t.Fatal(err)
}
if objectName != "user/2026/01/02/1767355200123-checkpoint-key.mp4" ||
got["event-instancename"] != "current-camera" || got["event-regioncoordinates"] != "" ||
got["event-numberofchanges"] != "" || got["event-timestamp"] != "1767355200" ||
got["productid"] != "checkpoint-key" {
t.Fatalf("unexpected fallback for invalid legacy name: %q, %#v", objectName, got)
}
})
}
}
func TestS3RecordingUploadDetailsLegacyMarkers(t *testing.T) {
for _, marker := range []string{"missing", "empty", "fps-only", "old-marker-name"} {
t.Run(marker, func(t *testing.T) {
const fileName = "1564859471_6-474162_camera_0-0-0-0_1153_27.mp4"
withRecording(t, fileName, []byte("recording"))
switch marker {
case "empty":
withQueuedRecordingFPS(t, fileName, "")
case "fps-only", "old-marker-name":
withQueuedRecordingFPS(t, fileName, "29.97")
if marker == "old-marker-name" {
err := os.Rename(filepath.Join("data/cloud", models.RecordingUploadMetadataFileName(fileName)),
filepath.Join("data/cloud", fileName))
if err != nil {
t.Fatal(err)
}
}
}
config := models.Config{Key: "legacy-key", S3: &models.S3{Username: "user"}}
objectName, metadata, err := s3RecordingUploadDetails(config, fileName, "public-key")
if err != nil {
t.Fatal(err)
}
if want := "user/2019/08/03/1564859471474-legacy-key.mp4"; objectName != want {
t.Fatalf("object name = %q, want %q", objectName, want)
}
if metadata["productid"] != "legacy-key" || metadata["event-instancename"] != "camera" ||
metadata["event-regioncoordinates"] != "0-0-0-0" || metadata["event-timestamp"] != "1564859471" {
t.Fatalf("unexpected legacy metadata: %#v", metadata)
}
})
}
}
func TestS3RecordingUploadDetailsRejectsInvalidCheckpoint(t *testing.T) {
tests := []struct {
name string
marker string
want string
}{
{"malformed JSON", `{"timestamp":`, "decode"},
{"missing timestamp", `{"device_key":"camera"}`, "timestamp"},
{"missing device key", `{"timestamp":1787015373000}`, "device key"},
{"invalid device key", `{"timestamp":1787015373000,"device_key":"camera/key"}`, "device key"},
{"mismatched filename", `{"timestamp":1787015373000,"device_key":"camera","filename":"other.mp4"}`, "filename"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
const fileName = "1564859471_6-474162_camera_0-0-0-0_1153_27.mp4"
withRecording(t, fileName, []byte("recording"))
withQueuedRecordingFPS(t, fileName, tt.marker)
config := models.Config{Key: "legacy-key", S3: &models.S3{Username: "user"}}
_, _, err := s3RecordingUploadDetails(config, fileName, "public-key")
if err == nil || !strings.Contains(err.Error(), tt.want) {
t.Fatalf("error = %v, want error containing %q instead of legacy fallback", err, tt.want)
}
})
}
}
func TestS3RecordingUploadDetailsReportsCheckpointReadError(t *testing.T) {
const fileName = "1564859471_6-474162_camera_0-0-0-0_1153_27.mp4"
withRecording(t, fileName, []byte("recording"))
if err := os.MkdirAll(filepath.Join("data/cloud", models.RecordingUploadMetadataFileName(fileName)), 0o755); err != nil {
t.Fatal(err)
}
config := models.Config{Key: "legacy-key", S3: &models.S3{Username: "user"}}
_, _, err := s3RecordingUploadDetails(config, fileName, "public-key")
if err == nil || !strings.Contains(err.Error(), "read recording upload metadata") {
t.Fatalf("error = %v, want checkpoint read error instead of legacy fallback", err)
}
}
func TestS3RecordingObjectName(t *testing.T) {
tests := []struct {
name string
recorded time.Time
directory string
}{
{
name: "zero padded month and day",
recorded: time.Date(2026, time.January, 2, 12, 0, 0, 0, time.UTC),
directory: "2026/01/02",
},
{
name: "UTC date across year boundary",
recorded: time.Date(2026, time.January, 1, 1, 0, 0, 0, time.FixedZone("UTC+2", 2*60*60)),
directory: "2025/12/31",
},
{
name: "leap day",
recorded: time.Date(2024, time.February, 29, 23, 59, 59, 0, time.UTC),
directory: "2024/02/29",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
const deviceKey = "camera-key-123"
want := "user/" + tt.directory + "/" + strconv.FormatInt(tt.recorded.UnixMilli(), 10) + "-" + deviceKey + ".mp4"
for attempt := 0; attempt < 2; attempt++ {
if got := s3RecordingObjectName("user", deviceKey, tt.recorded.UnixMilli()); got != want {
t.Fatalf("s3RecordingObjectName() = %q, want %q", got, want)
}
}
})
}
}
func TestUploadS3RejectsInvalidRecordingNames(t *testing.T) {
configuration := &models.Configuration{
Config: models.Config{
Key: "camera-key-123",
S3: &models.S3{
Publickey: "test-public-key",
Secretkey: "test-secret-key",
Region: "eu-west-1",
},
},
}
for _, fileName := range []string{
"recording.mp4",
"1787015373_camera.mp4",
"invalid_6-474162_camera_0-0-0-0_1153_27.mp4",
} {
t.Run(fileName, func(t *testing.T) {
uploaded, configured, err := UploadS3(configuration, fileName)
if uploaded || !configured || err == nil {
t.Fatalf("UploadS3() = (%v, %v, %v), want (false, true, error)", uploaded, configured, err)
}
})
}
}
func TestUploadS3RejectsInvalidDeviceKeys(t *testing.T) {
for _, deviceKey := range []string{"", "camera/key", `camera\key`} {
t.Run(deviceKey, func(t *testing.T) {
configuration := &models.Configuration{
Config: models.Config{
Key: deviceKey,
S3: &models.S3{
Publickey: "test-public-key",
Secretkey: "test-secret-key",
Region: "eu-west-1",
},
},
}
uploaded, configured, err := UploadS3(configuration, "1787015373_6-474162_camera_0-0-0-0_1153_27.mp4")
if uploaded || !configured || err == nil || !strings.Contains(err.Error(), "device key") {
t.Fatalf("UploadS3() = (%v, %v, %v), want (false, true, device key error)", uploaded, configured, err)
}
})
}
}
+20 -57
View File
@@ -16,7 +16,6 @@ import (
"time" "time"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/utils"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
) )
@@ -107,7 +106,7 @@ func logTusUploadProgress(label string, offset, size int64, loggedBucket *int64)
// creation request; it is empty on HEAD/PATCH/DELETE. // creation request; it is empty on HEAD/PATCH/DELETE.
type tusHeaderFunc func(h http.Header, fileName string) type tusHeaderFunc func(h http.Header, fileName string)
// runTusUpload performs a resumable (tus) upload of a flat or dated recording. // runTusUpload performs a resumable (tus) upload of data/recordings/<fileName>
// to baseURL, sending target-specific authentication/routing headers via // to baseURL, sending target-specific authentication/routing headers via
// setHeaders on every request. It encapsulates the create/resume/chunk/finalize // setHeaders on every request. It encapsulates the create/resume/chunk/finalize
// state machine shared by the Kerberos Vault (direct) and Kerberos Hub (proxied) // state machine shared by the Kerberos Vault (direct) and Kerberos Hub (proxied)
@@ -121,7 +120,9 @@ type tusHeaderFunc func(h http.Header, fileName string)
// should fall back to the legacy single-POST upload (older deployments). // should fall back to the legacy single-POST upload (older deployments).
// - body: a short message for logging. // - body: a short message for logging.
func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tusHeaderFunc) (uploaded bool, responded bool, supported bool, body string, err error) { func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tusHeaderFunc) (uploaded bool, responded bool, supported bool, body string, err error) {
file, ferr := utils.OpenRecording("data/recordings", fileName) fullname := "data/recordings/" + fileName
file, ferr := os.Open(fullname)
if file != nil { if file != nil {
defer file.Close() defer file.Close()
} }
@@ -140,6 +141,19 @@ func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tu
size := info.Size() size := info.Size()
client := newVaultHTTPClient(0) client := newVaultHTTPClient(0)
client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
if len(via) == 0 {
return nil
}
if req.URL.Host != via[0].URL.Host {
for k := range req.Header {
if strings.HasPrefix(http.CanonicalHeaderKey(k), "X-Kerberos-") {
req.Header.Del(k)
}
}
}
return nil
}
sidecar := tusSidecarPath(fileName, slot) sidecar := tusSidecarPath(fileName, slot)
uploadURL := loadTusResumeState(sidecar, baseURL) uploadURL := loadTusResumeState(sidecar, baseURL)
@@ -164,7 +178,6 @@ func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tu
// and loop forever, wedging the upload worker on one recording and saturating the // and loop forever, wedging the upload worker on one recording and saturating the
// uplink. // uplink.
highWaterOffset := int64(0) highWaterOffset := int64(0)
var lastErr error
for attempt := 0; attempt < maxAttempts; attempt++ { for attempt := 0; attempt < maxAttempts; attempt++ {
// (1) Ensure we have an active upload URL, creating one if needed. // (1) Ensure we have an active upload URL, creating one if needed.
@@ -172,7 +185,6 @@ func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tu
created, status, cerr := tusCreate(client, baseURL, size, metadata, setHeaders, fileName) created, status, cerr := tusCreate(client, baseURL, size, metadata, setHeaders, fileName)
lastStatus = status lastStatus = status
if cerr != nil { if cerr != nil {
lastErr = cerr
if status == http.StatusNotFound || status == http.StatusMethodNotAllowed || status == http.StatusNotImplemented { if status == http.StatusNotFound || status == http.StatusMethodNotAllowed || status == http.StatusNotImplemented {
// The vault does not implement tus; let the caller fall back. // The vault does not implement tus; let the caller fall back.
return false, false, false, "", cerr return false, false, false, "", cerr
@@ -189,7 +201,6 @@ func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tu
offset, status, herr := tusHead(client, uploadURL, setHeaders) offset, status, herr := tusHead(client, uploadURL, setHeaders)
lastStatus = status lastStatus = status
if herr != nil { if herr != nil {
lastErr = herr
if status == http.StatusNotFound || status == http.StatusGone { if status == http.StatusNotFound || status == http.StatusGone {
// The upload expired/was removed server-side; start over. // The upload expired/was removed server-side; start over.
removeTusResumeState(sidecar) removeTusResumeState(sidecar)
@@ -246,7 +257,6 @@ func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tu
newOffset, status, respBody, perr := tusPatch(client, uploadURL, offset, patchLen, file, setHeaders) newOffset, status, respBody, perr := tusPatch(client, uploadURL, offset, patchLen, file, setHeaders)
lastStatus = status lastStatus = status
if perr != nil { if perr != nil {
lastErr = perr
if status >= 400 { if status >= 400 {
// Definitive rejection (e.g. provider push failed during finalize). // Definitive rejection (e.g. provider push failed during finalize).
// Re-evaluate via HEAD on the next iteration to decide retry/restart. // Re-evaluate via HEAD on the next iteration to decide retry/restart.
@@ -293,12 +303,7 @@ func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tu
// report responded=false so the caller keeps the recording queued and retries // report responded=false so the caller keeps the recording queued and retries
// later instead of consuming its retry budget and entering the long back-off // later instead of consuming its retry budget and entering the long back-off
// timeout. // timeout.
message := label + ": resumable upload did not complete after retries" return false, lastStatus > 0, true, "resumable upload did not complete after retries", errors.New(label + ": resumable upload did not complete after retries")
err = errors.New(message)
if lastErr != nil {
err = fmt.Errorf("%s: %w", message, lastErr)
}
return false, lastStatus > 0, true, "resumable upload did not complete after retries", err
} }
// uploadVaultResumable uploads a recording directly to a Kerberos Vault using // uploadVaultResumable uploads a recording directly to a Kerberos Vault using
@@ -306,10 +311,6 @@ func runTusUpload(baseURL, metadata, fileName, label, slot string, setHeaders tu
// X-Kerberos-Storage-* headers on every request and routing (directory/provider) // X-Kerberos-Storage-* headers on every request and routing (directory/provider)
// is additionally carried in the tus Upload-Metadata. // is additionally carried in the tus Upload-Metadata.
func uploadVaultResumable(vault models.KStorage, publicKey, deviceKey, fileName, label, slot string) (bool, bool, bool, string, error) { func uploadVaultResumable(vault models.KStorage, publicKey, deviceKey, fileName, label, slot string) (bool, bool, bool, string, error) {
customHeaders, err := parseCustomVaultHeaders(vault.CustomHeaders)
if err != nil {
return false, false, true, "", err
}
baseURL := strings.TrimRight(vault.URI, "/") + tusUploadPath baseURL := strings.TrimRight(vault.URI, "/") + tusUploadPath
metadataValues := map[string]string{ metadataValues := map[string]string{
"filename": fileName, "filename": fileName,
@@ -320,22 +321,10 @@ func uploadVaultResumable(vault models.KStorage, publicKey, deviceKey, fileName,
"cloudkey": publicKey, "cloudkey": publicKey,
"fps": queuedRecordingFPS(fileName), "fps": queuedRecordingFPS(fileName),
} }
if encodedHeaders, err := encodeCustomVaultHeaders(customHeaders); err != nil {
return false, false, true, "", err
} else if encodedHeaders != "" {
metadataValues["custom_headers"] = encodedHeaders
}
customRequestHeaders := http.Header{}
if err := setCustomVaultHeaders(customRequestHeaders, customHeaders); err != nil {
return false, false, true, "", err
}
addRecordingTusMetadata(metadataValues, fileName) addRecordingTusMetadata(metadataValues, fileName)
metadata := encodeTusMetadata(metadataValues) metadata := encodeTusMetadata(metadataValues)
setHeaders := func(h http.Header, fn string) { setHeaders := func(h http.Header, fn string) {
setVaultTusHeaders(h, vault, publicKey, deviceKey, fn) setVaultTusHeaders(h, vault, publicKey, deviceKey, fn)
for name, values := range customRequestHeaders {
h[name] = append([]string(nil), values...)
}
} }
return runTusUpload(baseURL, metadata, fileName, label, slot, setHeaders) return runTusUpload(baseURL, metadata, fileName, label, slot, setHeaders)
} }
@@ -366,12 +355,6 @@ func addRecordingTusMetadata(values map[string]string, fileName string) {
if !ok { if !ok {
return return
} }
if metadata.DeviceKey != "" {
values["device"] = metadata.DeviceKey
}
values["device_name"] = metadata.DeviceName
values["region_coordinates"] = metadata.RegionCoordinates
values["number_of_changes"] = metadata.NumberOfChanges
if metadata.Duration > 0 { if metadata.Duration > 0 {
values["duration"] = strconv.FormatUint(metadata.Duration, 10) values["duration"] = strconv.FormatUint(metadata.Duration, 10)
} }
@@ -404,29 +387,11 @@ func tusCreate(client *http.Client, baseURL string, size int64, metadata string,
if err != nil { if err != nil {
return "", 0, err return "", 0, err
} }
io.Copy(io.Discard, resp.Body)
if resp.StatusCode != http.StatusCreated { if resp.StatusCode != http.StatusCreated {
const maxErrorBodyBytes = 4096
body, readErr := io.ReadAll(io.LimitReader(resp.Body, maxErrorBodyBytes+1))
if readErr != nil {
return "", resp.StatusCode, fmt.Errorf("unexpected status creating upload: %s; read error response: %w", resp.Status, readErr)
}
truncated := len(body) > maxErrorBodyBytes
if truncated {
body = body[:maxErrorBodyBytes]
}
message := strings.TrimSpace(string(body))
if truncated {
message += " [truncated]"
}
if message != "" {
return "", resp.StatusCode, fmt.Errorf("unexpected status creating upload: %s: %q", resp.Status, message)
}
return "", resp.StatusCode, fmt.Errorf("unexpected status creating upload: %s", resp.Status) return "", resp.StatusCode, fmt.Errorf("unexpected status creating upload: %s", resp.Status)
} }
// Location identifies the created upload; its response body is optional.
if _, err := io.Copy(io.Discard, resp.Body); err != nil {
log.WithError(err).WithField("component", "tus").Debug("Could not drain optional upload creation response body")
}
location := resp.Header.Get("Location") location := resp.Header.Get("Location")
if location == "" { if location == "" {
return "", resp.StatusCode, errors.New("missing Location header in create response") return "", resp.StatusCode, errors.New("missing Location header in create response")
@@ -532,7 +497,6 @@ func setVaultTusHeaders(h http.Header, vault models.KStorage, publicKey, deviceK
h.Set("X-Kerberos-Storage-Capture", "IPCamera") h.Set("X-Kerberos-Storage-Capture", "IPCamera")
if fileName != "" { if fileName != "" {
h.Set("X-Kerberos-Storage-FileName", fileName) h.Set("X-Kerberos-Storage-FileName", fileName)
setQueuedRecordingMetadataHeaders(h, fileName)
} }
} }
@@ -549,7 +513,6 @@ func setHubTusHeaders(h http.Header, config *models.Config, fileName string) {
h.Set("X-Kerberos-Storage-Capture", "IPCamera") h.Set("X-Kerberos-Storage-Capture", "IPCamera")
if fileName != "" { if fileName != "" {
h.Set("X-Kerberos-Storage-FileName", fileName) h.Set("X-Kerberos-Storage-FileName", fileName)
setQueuedRecordingMetadataHeaders(h, fileName)
} }
} }
+1 -240
View File
@@ -3,7 +3,6 @@ package cloud
import ( import (
"bytes" "bytes"
"encoding/base64" "encoding/base64"
"encoding/json"
"fmt" "fmt"
"io" "io"
"net" "net"
@@ -14,231 +13,12 @@ import (
"strconv" "strconv"
"strings" "strings"
"sync" "sync"
"sync/atomic"
"testing" "testing"
"time" "time"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/utils"
) )
func TestResumableEOFRestartPreservesLatestFailure(t *testing.T) {
previousDelay := tusBackoffBaseDelay
tusBackoffBaseDelay = 0
t.Cleanup(func() { tusBackoffBaseDelay = previousDelay })
const fileName = "1767355200123-device-key.mp4"
withRecording(t, fileName, []byte("recording"))
fake := newFakeTus()
fake.failFinalize = 1
var heads atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodHead && heads.Add(1) <= 2 {
w.WriteHeader(http.StatusServiceUnavailable)
return
}
fake.ServeHTTP(w, r)
}))
defer server.Close()
uploaded, responded, supported, _, err := uploadVaultResumable(testVault(server.URL), "public", "device-key", fileName, "test", "primary")
if uploaded || !responded || !supported || err == nil ||
!strings.Contains(err.Error(), "unexpected status on PATCH: 502 Bad Gateway") ||
strings.Contains(err.Error(), "503 Service Unavailable") {
t.Fatalf("upload = %t/%t/%t, %v; want the latest finalization failure after EOF restart", uploaded, responded, supported, err)
}
patches, _ := fake.patchCounts()
if heads.Load() != 4 || fake.createCount() != 1 || patches != 1 ||
len(fake.requestsForMethod(http.MethodDelete)) != 1 {
t.Fatalf("unexpected retry sequence: heads=%d, creates=%d, patches=%d", heads.Load(), fake.createCount(), patches)
}
}
func TestResumableCreationKeepsLocationAfterBodyReadError(t *testing.T) {
previousDelay := tusBackoffBaseDelay
tusBackoffBaseDelay = 0
t.Cleanup(func() { tusBackoffBaseDelay = previousDelay })
const fileName = "1767355200123-device-key.mp4"
payload := []byte("recording")
withRecording(t, fileName, payload)
fake := newFakeTus()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
w.Header().Set("Content-Length", "100")
fake.ServeHTTP(w, r)
_, _ = io.WriteString(w, "short")
return
}
fake.ServeHTTP(w, r)
}))
defer server.Close()
uploaded, responded, supported, _, err := uploadVaultResumable(testVault(server.URL), "public", "device-key", fileName, "test", "primary")
if !uploaded || !responded || !supported || err != nil {
t.Fatalf("upload = %t/%t/%t, %v; want success despite the interrupted optional creation body", uploaded, responded, supported, err)
}
if fake.createCount() != 1 || fake.totalBytes() != int64(len(payload)) {
t.Fatalf("created %d slots and uploaded %d bytes; want one reused slot and %d bytes", fake.createCount(), fake.totalBytes(), len(payload))
}
}
func TestTusCreateStillRequiresLocationAfterBodyReadError(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Length", "100")
w.WriteHeader(http.StatusCreated)
_, _ = io.WriteString(w, "short")
}))
defer server.Close()
location, status, err := tusCreate(server.Client(), server.URL, 8, "",
func(http.Header, string) {}, "1767355200123-device-key.mp4")
if location != "" || status != http.StatusCreated || err == nil ||
!strings.Contains(err.Error(), "missing Location") {
t.Fatalf("creation = %q, %d, %v; want missing Location error", location, status, err)
}
}
func TestTusCreateReportsBoundedServerErrors(t *testing.T) {
for _, tc := range []struct {
name string
body string
want string
}{
{"server error", "ERR_INTERNAL_SERVER_ERROR: A region must be set when sending requests to S3.\n", "A region must be set"},
{"empty error", "", "500 Internal Server Error"},
{"large error", strings.Repeat("x", 10000), "[truncated]"},
} {
t.Run(tc.name, func(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
_, _ = io.WriteString(w, tc.body)
}))
defer server.Close()
location, status, err := tusCreate(server.Client(), server.URL, 8, "",
func(http.Header, string) {}, "1767355200123-device-key.mp4")
if location != "" || status != http.StatusInternalServerError || err == nil ||
!strings.Contains(err.Error(), tc.want) || len(err.Error()) > 4300 {
t.Fatalf("creation = %q, %d, %v; want bounded server error", location, status, err)
}
})
}
}
func TestResumableCreateFailureRetainsServerCause(t *testing.T) {
previousDelay := tusBackoffBaseDelay
tusBackoffBaseDelay = 0
t.Cleanup(func() { tusBackoffBaseDelay = previousDelay })
for _, integration := range []string{"vault", "hub"} {
t.Run(integration, func(t *testing.T) {
const fileName = "1767355200123-device-key.mp4"
withRecording(t, fileName, []byte("recording"))
var requests atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requests.Add(1)
if r.Method != http.MethodPost || r.URL.Path != tusUploadPath {
t.Errorf("unexpected request: %s %s", r.Method, r.URL.Path)
}
w.WriteHeader(http.StatusInternalServerError)
_, _ = io.WriteString(w, "ERR_INTERNAL_SERVER_ERROR: A region must be set when sending requests to S3.")
}))
defer server.Close()
var uploaded, responded, supported bool
var err error
if integration == "vault" {
uploaded, responded, supported, _, err = uploadVaultResumable(testVault(server.URL), "public", "device-key", fileName, "test", "primary")
} else {
uploaded, responded, supported, _, err = uploadHubResumable(testHubConfig(server.URL), fileName, "test", "hub")
}
if uploaded || !responded || !supported || err == nil ||
!strings.Contains(err.Error(), "resumable upload did not complete after retries") ||
!strings.Contains(err.Error(), "A region must be set") {
t.Fatalf("upload = %t/%t/%t, %v; want original server cause after retries", uploaded, responded, supported, err)
}
if requests.Load() != 4 {
t.Fatalf("creation attempts = %d, want 4 without legacy fallback", requests.Load())
}
if _, err := os.Stat(filepath.Join("data/recordings", fileName)); err != nil {
t.Fatalf("failed upload must retain the local recording: %v", err)
}
})
}
}
func TestUploadKerberosVaultReadsDatedLocalRecordings(t *testing.T) {
previousCount, previousTimeout := kstorageRetryCount, kstorageRetryTimeout
t.Cleanup(func() { kstorageRetryCount, kstorageRetryTimeout = previousCount, previousTimeout })
for _, transport := range []string{"resumable", "legacy"} {
t.Run(transport, func(t *testing.T) {
const fileName = "1564859471123-device-key.mp4"
payload := bytes.Repeat([]byte("video"), 1024)
withRecording(t, fileName, payload)
datedPath, err := utils.CreateRecordingPath("data/recordings", fileName, time.Unix(1564859471, 0))
if err != nil {
t.Fatal(err)
}
if err := os.Rename(filepath.Join("data/recordings", fileName), datedPath); err != nil {
t.Fatal(err)
}
withQueuedRecordingFPS(t, fileName, `{"filename":"1564859471123-device-key.mp4","device_key":"device-key","timestamp":1564859471123,"duration":27,"fps":25,"device_name":"camera-name","region_coordinates":"1-2-3-4","number_of_changes":"57"}`)
fake := newFakeTus()
var legacyBody []byte
var legacyHeaders http.Header
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if transport == "resumable" {
fake.ServeHTTP(w, r)
return
}
body, readErr := io.ReadAll(r.Body)
if readErr != nil {
t.Error(readErr)
}
legacyBody = body
legacyHeaders = r.Header.Clone()
w.WriteHeader(http.StatusOK)
}))
defer server.Close()
if transport == "legacy" {
t.Setenv("AGENT_DISABLE_RESUMABLE_UPLOAD", "true")
} else {
t.Setenv("AGENT_DISABLE_RESUMABLE_UPLOAD", "false")
}
kstorageRetryCount, kstorageRetryTimeout = 0, 0
vault := testVault(server.URL)
config := &models.Configuration{Config: models.Config{
Key: "changed-config-key",
KStorage: &vault,
KStorageSecondary: &models.KStorage{},
}}
uploaded, configured, err := UploadKerberosVault(config, fileName)
if err != nil || !uploaded || !configured {
t.Fatalf("UploadKerberosVault() = (%v, %v, %v), want success", uploaded, configured, err)
}
if transport == "resumable" {
if got := fake.totalBytes(); got != int64(len(payload)) {
t.Fatalf("uploaded %d bytes, want %d", got, len(payload))
}
posts := fake.requestsForMethod(http.MethodPost)
if len(posts) != 1 {
t.Fatalf("got %d creation requests, want 1", len(posts))
}
metadata := decodeTusMetadata(posts[0].header.Get("Upload-Metadata"))
if metadata["filename"] != fileName || metadata["directory"] != "dir" || metadata["timestamp"] != "1564859471123" ||
metadata["device"] != "device-key" || metadata["device_name"] != "camera-name" ||
metadata["region_coordinates"] != "1-2-3-4" || metadata["number_of_changes"] != "57" {
t.Fatalf("unexpected upload metadata: %#v", metadata)
}
} else if !bytes.Equal(legacyBody, payload) ||
legacyHeaders.Get("X-Kerberos-Storage-FileName") != fileName ||
legacyHeaders.Get("X-Kerberos-Storage-Directory") != "dir" ||
legacyHeaders.Get("X-Kerberos-Storage-Device") != "device-key" ||
legacyHeaders.Get(recordingDeviceNameHeader) != "camera-name" ||
legacyHeaders.Get(recordingRegionHeader) != "1-2-3-4" ||
legacyHeaders.Get(recordingChangesHeader) != "57" ||
legacyHeaders.Get(recordingTimestampHeader) != "1564859471123" {
t.Fatalf("unexpected legacy upload: %d bytes, headers %#v", len(legacyBody), legacyHeaders)
}
})
}
}
// fakeUpload tracks the state of a single resumable upload on the fake server. // fakeUpload tracks the state of a single resumable upload on the fake server.
type fakeUpload struct { type fakeUpload struct {
size int64 size int64
@@ -524,9 +304,7 @@ func TestUploadVaultResumable_HappyPath(t *testing.T) {
withRecording(t, fileName, payload) withRecording(t, fileName, payload)
withQueuedRecordingFPS(t, fileName, `{"filename":"recording.mp4","device_key":"device-key","timestamp":1785934709414,"duration":20452,"fps":29.97}`) withQueuedRecordingFPS(t, fileName, `{"filename":"recording.mp4","device_key":"device-key","timestamp":1785934709414,"duration":20452,"fps":29.97}`)
vault := testVault(ts.URL) uploaded, responded, supported, _, err := uploadVaultResumable(testVault(ts.URL), "pk", "dev", fileName, "test", "primary")
vault.CustomHeaders = `{"site_id":"site-1","equipment_id":"equipment-3"}`
uploaded, responded, supported, _, err := uploadVaultResumable(vault, "pk", "dev", fileName, "test", "primary")
if err != nil { if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
@@ -550,23 +328,6 @@ func TestUploadVaultResumable_HappyPath(t *testing.T) {
if got := metadata["timestamp"]; got != "1785934709414" { if got := metadata["timestamp"]; got != "1785934709414" {
t.Fatalf("POST metadata timestamp = %q, want %q", got, "1785934709414") t.Fatalf("POST metadata timestamp = %q, want %q", got, "1785934709414")
} }
var customHeaders map[string]string
if err := json.Unmarshal([]byte(metadata["custom_headers"]), &customHeaders); err != nil {
t.Fatal(err)
}
if customHeaders["site_id"] != "site-1" || customHeaders["equipment_id"] != "equipment-3" {
t.Fatalf("POST custom header metadata = %#v", customHeaders)
}
for _, method := range []string{http.MethodPost, http.MethodHead, http.MethodPatch} {
for _, request := range srv.requestsForMethod(method) {
if request.header.Get("site_id") != "site-1" || request.header.Get("equipment_id") != "equipment-3" {
t.Fatalf("%s custom headers = %#v", method, request.header)
}
if request.header.Get(customHeadersManifestHeader) == "" {
t.Fatalf("%s is missing the custom header manifest", method)
}
}
}
} }
func TestQueuedRecordingFPSValidation(t *testing.T) { func TestQueuedRecordingFPSValidation(t *testing.T) {
+72 -5
View File
@@ -14,6 +14,7 @@ import (
"github.com/kerberos-io/agent/machinery/src/capture" "github.com/kerberos-io/agent/machinery/src/capture"
"github.com/kerberos-io/agent/machinery/src/cloud" "github.com/kerberos-io/agent/machinery/src/cloud"
"github.com/kerberos-io/agent/machinery/src/cloud/frameprocessing"
"github.com/kerberos-io/agent/machinery/src/computervision" "github.com/kerberos-io/agent/machinery/src/computervision"
configService "github.com/kerberos-io/agent/machinery/src/config" configService "github.com/kerberos-io/agent/machinery/src/config"
"github.com/kerberos-io/agent/machinery/src/lifecycle" "github.com/kerberos-io/agent/machinery/src/lifecycle"
@@ -558,6 +559,74 @@ func RunAgent(parent context.Context, configDirectory string, configuration *mod
}) })
} }
// Frame Processing is the HTTP-based successor to the legacy MQTT
// realtime-processing output. Both remain independently configurable during
// the compatibility period.
frameProcessingConfig := configuration.Config.FrameProcessing
if frameProcessingConfig != nil && frameProcessingConfig.Enabled == "true" && configuration.Config.Offline != "true" {
selectedCursor := queue.Latest()
selectedRequestQueue := queue
selectedClient := rtspClient
selectedStream := "main"
selectionError := error(nil)
switch frameProcessingConfig.Stream {
case "auto", "":
if subStreamEnabled && rtspSubClient != nil && subQueue != nil {
selectedCursor = subQueue.Latest()
selectedRequestQueue = subQueue
selectedClient = rtspSubClient
selectedStream = "sub"
}
case "main":
case "sub":
if !subStreamEnabled || rtspSubClient == nil || subQueue == nil {
selectionError = errors.New("frameProcessing.stream is sub but no substream is available")
} else {
selectedCursor = subQueue.Latest()
selectedRequestQueue = subQueue
selectedClient = rtspSubClient
selectedStream = "sub"
}
default:
selectionError = fmt.Errorf("unsupported frameProcessing.stream %q", frameProcessingConfig.Stream)
}
registerTask("frame-processing", lifecycle.TaskPolicy{}, func(taskContext context.Context) error {
if selectionError != nil {
return selectionError
}
return frameprocessing.Run(
taskContext,
selectedCursor,
selectedClient,
*frameProcessingConfig,
configuration.Config.Key,
selectedStream,
communication,
)
})
if frameProcessingConfig.AllowRequestedFrames == "true" {
frameProcessingRequests := run.FrameProcessingRequests()
run.SetFrameProcessingQueue(selectedRequestQueue)
frameProcessingStatusPublisher := frameprocessing.NewMQTTStatusPublisher(mqttClient, config.HubKey, configuration)
registerTask("frame-processing-requested", lifecycle.TaskPolicy{}, func(taskContext context.Context) error {
if selectionError != nil {
return selectionError
}
return frameprocessing.RunRequested(
taskContext,
selectedClient,
*frameProcessingConfig,
configuration.Config.Key,
selectedStream,
frameProcessingRequests,
frameProcessingStatusPublisher,
communication,
)
})
}
}
// Handle Upload to cloud provider (Kerberos Hub, Kerberos Vault and others) // Handle Upload to cloud provider (Kerberos Hub, Kerberos Vault and others)
registerTask("upload", lifecycle.TaskPolicy{}, func(context.Context) error { registerTask("upload", lifecycle.TaskPolicy{}, func(context.Context) error {
cloud.HandleUpload(configDirectory, configuration, communication) cloud.HandleUpload(configDirectory, configuration, communication)
@@ -964,7 +1033,7 @@ func GetDashboard(c *gin.Context, configDirectory string, configuration *models.
// All days stored in this agent. // All days stored in this agent.
days := []string{} days := []string{}
latestEvents := []models.Media{} latestEvents := []models.Media{}
files, err := utils.ReadRecordingDirectory(recordingDirectory) files, err := utils.ReadDirectory(recordingDirectory)
if err == nil { if err == nil {
events := utils.GetSortedDirectory(files) events := utils.GetSortedDirectory(files)
@@ -975,8 +1044,6 @@ func GetDashboard(c *gin.Context, configDirectory string, configuration *models.
var eventFilter models.EventFilter var eventFilter models.EventFilter
eventFilter.NumberOfElements = 5 eventFilter.NumberOfElements = 5
latestEvents = utils.GetMediaFormatted(events, recordingDirectory, configuration, eventFilter) // will get 5 latest recordings. latestEvents = utils.GetMediaFormatted(events, recordingDirectory, configuration, eventFilter) // will get 5 latest recordings.
} else {
log.WithError(err).Error("Could not list recordings for Agent status")
} }
c.JSON(200, gin.H{ c.JSON(200, gin.H{
@@ -1009,7 +1076,7 @@ func GetLatestEvents(c *gin.Context, configDirectory string, configuration *mode
eventFilter.NumberOfElements = 10 eventFilter.NumberOfElements = 10
} }
recordingDirectory := configDirectory + "/data/recordings" recordingDirectory := configDirectory + "/data/recordings"
files, err := utils.ReadRecordingDirectory(recordingDirectory) files, err := utils.ReadDirectory(recordingDirectory)
if err == nil { if err == nil {
events := utils.GetSortedDirectory(files) events := utils.GetSortedDirectory(files)
// We will get all recordings from the directory (as defined by the filter). // We will get all recordings from the directory (as defined by the filter).
@@ -1038,7 +1105,7 @@ func GetLatestEvents(c *gin.Context, configDirectory string, configuration *mode
// @Success 200 // @Success 200
func GetDays(c *gin.Context, configDirectory string, configuration *models.Configuration, communication *models.Communication) { func GetDays(c *gin.Context, configDirectory string, configuration *models.Configuration, communication *models.Communication) {
recordingDirectory := configDirectory + "/data/recordings" recordingDirectory := configDirectory + "/data/recordings"
files, err := utils.ReadRecordingDirectory(recordingDirectory) files, err := utils.ReadDirectory(recordingDirectory)
if err == nil { if err == nil {
events := utils.GetSortedDirectory(files) events := utils.GetSortedDirectory(files)
days := utils.GetDays(events, recordingDirectory, configuration) days := utils.GetDays(events, recordingDirectory, configuration)
+101 -18
View File
@@ -300,6 +300,9 @@ func initConfigPointers(config *models.Config) {
if config.Signing == nil { if config.Signing == nil {
config.Signing = &models.Signing{} config.Signing = &models.Signing{}
} }
if config.FrameProcessing == nil {
config.FrameProcessing = &models.FrameProcessing{}
}
if config.Dropbox == nil { if config.Dropbox == nil {
config.Dropbox = &models.Dropbox{} config.Dropbox = &models.Dropbox{}
} }
@@ -315,19 +318,13 @@ func initConfigPointers(config *models.Config) {
func applyAgentEnvVars(configuration *models.Configuration, prefix string, applyDefaults bool) { func applyAgentEnvVars(configuration *models.Configuration, prefix string, applyDefaults bool) {
environmentVariables := os.Environ() environmentVariables := os.Environ()
if prefix == "" {
if deploymentName := os.Getenv("DEPLOYMENT_NAME"); deploymentName != "" {
configuration.Config.Name = deploymentName
if configuration.Config.FriendlyName == "" {
configuration.Config.FriendlyName = deploymentName
}
}
}
// Initialize the configuration for some new fields. // Initialize the configuration for some new fields.
if configuration.Config.KStorageSecondary == nil { if configuration.Config.KStorageSecondary == nil {
configuration.Config.KStorageSecondary = &models.KStorage{} configuration.Config.KStorageSecondary = &models.KStorage{}
} }
if configuration.Config.FrameProcessing == nil {
configuration.Config.FrameProcessing = &models.FrameProcessing{}
}
for _, env := range environmentVariables { for _, env := range environmentVariables {
fullKey := strings.SplitN(env, "=", 2)[0] fullKey := strings.SplitN(env, "=", 2)[0]
@@ -394,9 +391,6 @@ func applyAgentEnvVars(configuration *models.Configuration, prefix string, apply
case "AGENT_CAPTURE_IPCAMERA_ONVIF_PASSWORD": case "AGENT_CAPTURE_IPCAMERA_ONVIF_PASSWORD":
configuration.Config.Capture.IPCamera.ONVIFPassword = value configuration.Config.Capture.IPCamera.ONVIFPassword = value
break break
case "AGENT_CAPTURE_IPCAMERA_ONVIF_CHANNEL":
configuration.Config.Capture.IPCamera.ONVIFChannel, _ = strconv.Atoi(value)
break
/* Recording mode */ /* Recording mode */
case "AGENT_CAPTURE_RECORDING": case "AGENT_CAPTURE_RECORDING":
@@ -553,6 +547,66 @@ func applyAgentEnvVars(configuration *models.Configuration, prefix string, apply
configuration.Config.RealtimeProcessingTopic = value configuration.Config.RealtimeProcessingTopic = value
break break
/* Keyframe-aligned HTTP frame processing */
case "AGENT_FRAME_PROCESSING_ENABLED":
configuration.Config.FrameProcessing.Enabled = value
break
case "AGENT_FRAME_PROCESSING_ENDPOINT":
configuration.Config.FrameProcessing.Endpoint = value
break
case "AGENT_FRAME_PROCESSING_TOKEN":
configuration.Config.FrameProcessing.Token = value
break
case "AGENT_FRAME_PROCESSING_PROFILE":
configuration.Config.FrameProcessing.Profile = value
break
case "AGENT_FRAME_PROCESSING_ALLOW_REQUESTED_FRAMES":
configuration.Config.FrameProcessing.AllowRequestedFrames = value
break
case "AGENT_FRAME_PROCESSING_STREAM":
configuration.Config.FrameProcessing.Stream = value
break
case "AGENT_FRAME_PROCESSING_INTERVAL_SECONDS":
if interval, err := strconv.ParseInt(value, 10, 64); err == nil {
configuration.Config.FrameProcessing.IntervalSeconds = interval
}
break
case "AGENT_FRAME_PROCESSING_WIDTH":
if width, err := strconv.Atoi(value); err == nil {
configuration.Config.FrameProcessing.Width = width
}
break
case "AGENT_FRAME_PROCESSING_HEIGHT":
if height, err := strconv.Atoi(value); err == nil {
configuration.Config.FrameProcessing.Height = height
}
break
case "AGENT_FRAME_PROCESSING_JPEG_QUALITY":
if quality, err := strconv.Atoi(value); err == nil {
configuration.Config.FrameProcessing.JPEGQuality = quality
}
break
case "AGENT_FRAME_PROCESSING_REQUEST_TIMEOUT_SECONDS":
if timeout, err := strconv.ParseInt(value, 10, 64); err == nil {
configuration.Config.FrameProcessing.RequestTimeoutSeconds = timeout
}
break
case "AGENT_FRAME_PROCESSING_FRAME_TTL_SECONDS":
if ttl, err := strconv.ParseInt(value, 10, 64); err == nil {
configuration.Config.FrameProcessing.FrameTTLSeconds = ttl
}
break
case "AGENT_FRAME_PROCESSING_MAX_FRAME_BYTES":
if maxBytes, err := strconv.ParseInt(value, 10, 64); err == nil {
configuration.Config.FrameProcessing.MaxFrameBytes = maxBytes
}
break
case "AGENT_FRAME_PROCESSING_PERIODIC_QUEUE_CAPACITY":
if capacity, err := strconv.Atoi(value); err == nil {
configuration.Config.FrameProcessing.PeriodicQueueCapacity = capacity
}
break
/* WebRTC settings for live-streaming (remote) */ /* WebRTC settings for live-streaming (remote) */
case "AGENT_STUN_URI": case "AGENT_STUN_URI":
configuration.Config.STUNURI = value configuration.Config.STUNURI = value
@@ -615,9 +669,6 @@ func applyAgentEnvVars(configuration *models.Configuration, prefix string, apply
case "AGENT_KERBEROSVAULT_DIRECTORY": case "AGENT_KERBEROSVAULT_DIRECTORY":
configuration.Config.KStorage.Directory = value configuration.Config.KStorage.Directory = value
break break
case "AGENT_KERBEROSVAULT_CUSTOM_HEADERS":
configuration.Config.KStorage.CustomHeaders = value
break
/* Retry policy and timeout */ /* Retry policy and timeout */
case "AGENT_KERBEROSVAULT_MAX_RETRIES": case "AGENT_KERBEROSVAULT_MAX_RETRIES":
@@ -649,9 +700,6 @@ func applyAgentEnvVars(configuration *models.Configuration, prefix string, apply
case "AGENT_KERBEROSVAULT_SECONDARY_DIRECTORY": case "AGENT_KERBEROSVAULT_SECONDARY_DIRECTORY":
configuration.Config.KStorageSecondary.Directory = value configuration.Config.KStorageSecondary.Directory = value
break break
case "AGENT_KERBEROSVAULT_SECONDARY_CUSTOM_HEADERS":
configuration.Config.KStorageSecondary.CustomHeaders = value
break
/* When storing in dropbox */ /* When storing in dropbox */
case "AGENT_DROPBOX_ACCESS_TOKEN": case "AGENT_DROPBOX_ACCESS_TOKEN":
@@ -701,6 +749,41 @@ func applyAgentEnvVars(configuration *models.Configuration, prefix string, apply
configuration.Config.Capture.PixelChangeThreshold = &defaultPixelChangeThreshold configuration.Config.Capture.PixelChangeThreshold = &defaultPixelChangeThreshold
} }
if applyDefaults {
frameProcessing := configuration.Config.FrameProcessing
if frameProcessing == nil {
frameProcessing = &models.FrameProcessing{}
configuration.Config.FrameProcessing = frameProcessing
}
if frameProcessing.Profile == "" {
frameProcessing.Profile = "never-trigger"
}
if frameProcessing.Stream == "" {
frameProcessing.Stream = "auto"
}
if frameProcessing.IntervalSeconds <= 0 {
frameProcessing.IntervalSeconds = 10
}
if frameProcessing.Width <= 0 {
frameProcessing.Width = 640
}
if frameProcessing.JPEGQuality <= 0 || frameProcessing.JPEGQuality > 100 {
frameProcessing.JPEGQuality = 70
}
if frameProcessing.RequestTimeoutSeconds <= 0 {
frameProcessing.RequestTimeoutSeconds = 5
}
if frameProcessing.FrameTTLSeconds <= 0 {
frameProcessing.FrameTTLSeconds = 30
}
if frameProcessing.MaxFrameBytes <= 0 {
frameProcessing.MaxFrameBytes = 4 << 20
}
if frameProcessing.PeriodicQueueCapacity <= 0 {
frameProcessing.PeriodicQueueCapacity = 1
}
}
// Signing is a new feature, so if empty we set default values. Only applied // Signing is a new feature, so if empty we set default values. Only applied
// for the effective configuration (applyDefaults), not for the separate // for the effective configuration (applyDefaults), not for the separate
// global/custom views. // global/custom views.
+67 -59
View File
@@ -3,7 +3,6 @@ package config
import ( import (
"context" "context"
"errors" "errors"
"os"
"testing" "testing"
"time" "time"
@@ -12,53 +11,6 @@ import (
"go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo"
) )
func TestApplyAgentEnvVarsDeploymentName(t *testing.T) {
tests := []struct {
name string
prefix string
deploymentName string
agentName string
initialName string
initialDisplay string
wantName string
wantDisplay string
}{
{name: "deployment fallback", deploymentName: "camera-1", wantName: "camera-1", wantDisplay: "camera-1"},
{name: "explicit display name", deploymentName: "camera-1", agentName: "Front Door", wantName: "camera-1", wantDisplay: "Front Door"},
{name: "existing display name", deploymentName: "camera-1", initialDisplay: "Front Door", wantName: "camera-1", wantDisplay: "Front Door"},
{name: "deployment overrides bundled identity", deploymentName: "camera-1", initialName: "default", wantName: "camera-1", wantDisplay: "camera-1"},
{name: "no deployment", initialName: "existing", initialDisplay: "Existing Camera", wantName: "existing", wantDisplay: "Existing Camera"},
{name: "standalone display name", agentName: "Front Door", wantDisplay: "Front Door"},
{name: "global layer excludes deployment", prefix: "GLOBAL_", deploymentName: "camera-1"},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
t.Setenv("DEPLOYMENT_NAME", test.deploymentName)
t.Setenv(test.prefix+"AGENT_NAME", test.agentName)
if test.agentName == "" {
if err := os.Unsetenv(test.prefix + "AGENT_NAME"); err != nil {
t.Fatal(err)
}
}
configuration := &models.Configuration{Config: models.Config{
Name: test.initialName,
FriendlyName: test.initialDisplay,
}}
initConfigPointers(&configuration.Config)
applyAgentEnvVars(configuration, test.prefix, false)
if got := configuration.Config.Name; got != test.wantName {
t.Errorf("Name = %q, want %q", got, test.wantName)
}
if got := configuration.Config.FriendlyName; got != test.wantDisplay {
t.Errorf("FriendlyName = %q, want %q", got, test.wantDisplay)
}
})
}
}
func TestApplyAgentEnvVarsPixelChangeThresholdDefault(t *testing.T) { func TestApplyAgentEnvVarsPixelChangeThresholdDefault(t *testing.T) {
tests := []struct { tests := []struct {
name string name string
@@ -88,24 +40,80 @@ func TestApplyAgentEnvVarsPixelChangeThresholdDefault(t *testing.T) {
} }
} }
func TestApplyAgentEnvVarsVaultCustomHeaders(t *testing.T) { func intPointer(value int) *int {
t.Setenv("AGENT_KERBEROSVAULT_CUSTOM_HEADERS", `{"site_id":"site-1"}`) return &value
t.Setenv("AGENT_KERBEROSVAULT_SECONDARY_CUSTOM_HEADERS", `{"site_id":"site-2"}`) }
func TestApplyAgentEnvVarsFrameProcessing(t *testing.T) {
t.Setenv("AGENT_FRAME_PROCESSING_ENABLED", "true")
t.Setenv("AGENT_FRAME_PROCESSING_ENDPOINT", "http://processor:8080/v1/frames")
t.Setenv("AGENT_FRAME_PROCESSING_TOKEN", "secret")
t.Setenv("AGENT_FRAME_PROCESSING_PROFILE", "always-trigger")
t.Setenv("AGENT_FRAME_PROCESSING_ALLOW_REQUESTED_FRAMES", "true")
t.Setenv("AGENT_FRAME_PROCESSING_STREAM", "sub")
t.Setenv("AGENT_FRAME_PROCESSING_INTERVAL_SECONDS", "15")
t.Setenv("AGENT_FRAME_PROCESSING_WIDTH", "320")
t.Setenv("AGENT_FRAME_PROCESSING_HEIGHT", "180")
t.Setenv("AGENT_FRAME_PROCESSING_JPEG_QUALITY", "80")
t.Setenv("AGENT_FRAME_PROCESSING_REQUEST_TIMEOUT_SECONDS", "7")
t.Setenv("AGENT_FRAME_PROCESSING_FRAME_TTL_SECONDS", "45")
t.Setenv("AGENT_FRAME_PROCESSING_MAX_FRAME_BYTES", "2097152")
t.Setenv("AGENT_FRAME_PROCESSING_PERIODIC_QUEUE_CAPACITY", "2")
configuration := &models.Configuration{} configuration := &models.Configuration{}
initConfigPointers(&configuration.Config) initConfigPointers(&configuration.Config)
applyAgentEnvVars(configuration, "", true)
applyAgentEnvVars(configuration, "", false) got := configuration.Config.FrameProcessing
if got == nil {
if got := configuration.Config.KStorage.CustomHeaders; got != `{"site_id":"site-1"}` { t.Fatal("FrameProcessing is nil")
t.Fatalf("primary custom headers = %q", got)
} }
if got := configuration.Config.KStorageSecondary.CustomHeaders; got != `{"site_id":"site-2"}` { if got.Enabled != "true" || got.Endpoint != "http://processor:8080/v1/frames" || got.Token != "secret" {
t.Fatalf("secondary custom headers = %q", got) t.Fatalf("FrameProcessing identity = %+v", got)
}
if got.Profile != "always-trigger" || got.AllowRequestedFrames != "true" || got.Stream != "sub" || got.IntervalSeconds != 15 {
t.Fatalf("FrameProcessing schedule = %+v", got)
}
if got.Width != 320 || got.Height != 180 || got.JPEGQuality != 80 {
t.Fatalf("FrameProcessing image = %+v", got)
}
if got.RequestTimeoutSeconds != 7 || got.FrameTTLSeconds != 45 || got.MaxFrameBytes != 2097152 || got.PeriodicQueueCapacity != 2 {
t.Fatalf("FrameProcessing delivery = %+v", got)
} }
} }
func intPointer(value int) *int { func TestApplyAgentEnvVarsFrameProcessingDefaults(t *testing.T) {
return &value configuration := &models.Configuration{}
initConfigPointers(&configuration.Config)
applyAgentEnvVars(configuration, "", true)
got := configuration.Config.FrameProcessing
if got.Profile != "never-trigger" || got.Stream != "auto" || got.IntervalSeconds != 10 {
t.Fatalf("FrameProcessing defaults = %+v", got)
}
if got.Width != 640 || got.Height != 0 || got.JPEGQuality != 70 {
t.Fatalf("FrameProcessing image defaults = %+v", got)
}
if got.RequestTimeoutSeconds != 5 || got.FrameTTLSeconds != 30 || got.MaxFrameBytes != 4<<20 || got.PeriodicQueueCapacity != 1 {
t.Fatalf("FrameProcessing delivery defaults = %+v", got)
}
}
func TestOverrideWithEnvironmentVariablesInheritsGlobalFrameProcessing(t *testing.T) {
t.Setenv("GLOBAL_AGENT_FRAME_PROCESSING_ENABLED", "true")
t.Setenv("GLOBAL_AGENT_FRAME_PROCESSING_ENDPOINT", "https://processor.example/v1/frames")
t.Setenv("GLOBAL_AGENT_FRAME_PROCESSING_PROFILE", "never-trigger")
configuration := &models.Configuration{}
OverrideWithEnvironmentVariables(configuration)
got := configuration.Config.FrameProcessing
if got == nil || got.Enabled != "true" || got.Endpoint != "https://processor.example/v1/frames" {
t.Fatalf("effective FrameProcessing = %+v", got)
}
if configuration.CustomConfig.FrameProcessing == nil || configuration.CustomConfig.FrameProcessing.Enabled != "" {
t.Fatalf("custom FrameProcessing unexpectedly overrides global config: %+v", configuration.CustomConfig.FrameProcessing)
}
} }
func TestNewFactoryConfigReadContextUsesDatabaseTimeout(t *testing.T) { func TestNewFactoryConfigReadContextUsesDatabaseTimeout(t *testing.T) {
+61 -21
View File
@@ -20,6 +20,8 @@ var (
nextAgentRunID atomic.Uint64 nextAgentRunID atomic.Uint64
) )
const defaultFrameProcessingRequestCapacity = 8
type AgentRunClient interface { type AgentRunClient interface {
Close(context.Context) error Close(context.Context) error
} }
@@ -56,19 +58,21 @@ type AgentRun struct {
activated bool activated bool
stopping bool stopping bool
resourcesMu sync.RWMutex resourcesMu sync.RWMutex
mainClient AgentRunClient mainClient AgentRunClient
subClient AgentRunClient subClient AgentRunClient
backchannelClient AgentRunClient backchannelClient AgentRunClient
mainQueue *packets.Queue mainQueue *packets.Queue
subQueue *packets.Queue subQueue *packets.Queue
releaseClients func() frameProcessingQueue *packets.Queue
releaseClients func()
channelsMu sync.RWMutex channelsMu sync.RWMutex
channelsClosed bool channelsClosed bool
liveHDHandshakes chan LiveHDHandshake liveHDHandshakes chan LiveHDHandshake
motionEvents chan MotionDataPartial motionEvents chan MotionDataPartial
onvifActions chan OnvifAction onvifActions chan OnvifAction
frameProcessingRequests chan FrameProcessingWork
shutdownOnce sync.Once shutdownOnce sync.Once
shutdownReport AgentRunShutdownReport shutdownReport AgentRunShutdownReport
@@ -80,15 +84,16 @@ func NewAgentRun(parent context.Context, communication *Communication, stopUploa
} }
ctx, cancel := context.WithCancelCause(parent) ctx, cancel := context.WithCancelCause(parent)
run := &AgentRun{ run := &AgentRun{
id: nextAgentRunID.Add(1), id: nextAgentRunID.Add(1),
ctx: ctx, ctx: ctx,
cancel: cancel, cancel: cancel,
supervisor: lifecycle.NewSupervisor(ctx), supervisor: lifecycle.NewSupervisor(ctx),
communication: communication, communication: communication,
stopUpload: stopUpload, stopUpload: stopUpload,
liveHDHandshakes: make(chan LiveHDHandshake, 100), liveHDHandshakes: make(chan LiveHDHandshake, 100),
motionEvents: make(chan MotionDataPartial, 10), motionEvents: make(chan MotionDataPartial, 10),
onvifActions: make(chan OnvifAction, 10), onvifActions: make(chan OnvifAction, 10),
frameProcessingRequests: make(chan FrameProcessingWork, defaultFrameProcessingRequestCapacity),
} }
log.WithFields(log.Fields{ log.WithFields(log.Fields{
"component": "agent_run", "component": "agent_run",
@@ -233,6 +238,12 @@ func (r *AgentRun) SetSubQueue(queue *packets.Queue) {
r.resourcesMu.Unlock() r.resourcesMu.Unlock()
} }
func (r *AgentRun) SetFrameProcessingQueue(queue *packets.Queue) {
r.resourcesMu.Lock()
r.frameProcessingQueue = queue
r.resourcesMu.Unlock()
}
func (r *AgentRun) SetClientRelease(release func()) { func (r *AgentRun) SetClientRelease(release func()) {
r.resourcesMu.Lock() r.resourcesMu.Lock()
r.releaseClients = release r.releaseClients = release
@@ -269,6 +280,10 @@ func (r *AgentRun) ONVIFActions() <-chan OnvifAction {
return r.onvifActions return r.onvifActions
} }
func (r *AgentRun) FrameProcessingRequests() <-chan FrameProcessingWork {
return r.frameProcessingRequests
}
func (r *AgentRun) TrySendLiveHDHandshake(handshake LiveHDHandshake) bool { func (r *AgentRun) TrySendLiveHDHandshake(handshake LiveHDHandshake) bool {
if r.isStopping() { if r.isStopping() {
return false return false
@@ -332,6 +347,30 @@ func (r *AgentRun) TrySendONVIF(action OnvifAction) bool {
} }
} }
func (r *AgentRun) TrySendFrameProcessingRequest(request FrameProcessingRequest) bool {
if r.isStopping() {
return false
}
r.channelsMu.RLock()
defer r.channelsMu.RUnlock()
if r.channelsClosed {
return false
}
r.resourcesMu.RLock()
queue := r.frameProcessingQueue
r.resourcesMu.RUnlock()
if queue == nil {
return false
}
work := FrameProcessingWork{Request: request, Cursor: queue.LatestAtCurrentTail()}
select {
case r.frameProcessingRequests <- work:
return true
default:
return false
}
}
func (r *AgentRun) Shutdown(ctx context.Context, cause error) AgentRunShutdownReport { func (r *AgentRun) Shutdown(ctx context.Context, cause error) AgentRunShutdownReport {
if ctx == nil { if ctx == nil {
ctx = context.Background() ctx = context.Background()
@@ -458,6 +497,7 @@ func (r *AgentRun) closeChannels() {
close(r.liveHDHandshakes) close(r.liveHDHandshakes)
close(r.motionEvents) close(r.motionEvents)
close(r.onvifActions) close(r.onvifActions)
close(r.frameProcessingRequests)
} }
func sendRunStop(ctx context.Context, channel chan<- string) bool { func sendRunStop(ctx context.Context, channel chan<- string) bool {
+25
View File
@@ -112,6 +112,31 @@ func TestAgentRunOwnsAndShutsDownResources(t *testing.T) {
if _, ok := <-run.ONVIFActions(); ok { if _, ok := <-run.ONVIFActions(); ok {
t.Fatal("ONVIF channel remained open") t.Fatal("ONVIF channel remained open")
} }
if _, ok := <-run.FrameProcessingRequests(); ok {
t.Fatal("frame-processing request channel remained open")
}
}
func TestAgentRunBoundsFrameProcessingRequests(t *testing.T) {
communication := &Communication{}
run := NewAgentRun(context.Background(), communication, false)
queue := packets.NewQueue()
run.SetMainQueue(queue)
run.SetFrameProcessingQueue(queue)
if err := run.Activate(); err != nil {
t.Fatal(err)
}
run.Seal()
t.Cleanup(func() { run.Shutdown(context.Background(), errors.New("test complete")) })
for index := 0; index < defaultFrameProcessingRequestCapacity; index++ {
if !communication.TrySendFrameProcessingRequest(FrameProcessingRequest{RequestID: "request"}) {
t.Fatalf("request %d was rejected before the queue was full", index)
}
}
if communication.TrySendFrameProcessingRequest(FrameProcessingRequest{RequestID: "overflow"}) {
t.Fatal("overflow request was accepted")
}
} }
func TestAgentRunShutdownIsConcurrentAndIdempotent(t *testing.T) { func TestAgentRunShutdownIsConcurrentAndIdempotent(t *testing.T) {
-6
View File
@@ -12,7 +12,6 @@ type OnvifCredentials struct {
ONVIFXAddr string `json:"onvif_xaddr,omitempty" bson:"onvif_xaddr"` ONVIFXAddr string `json:"onvif_xaddr,omitempty" bson:"onvif_xaddr"`
ONVIFUsername string `json:"onvif_username,omitempty" bson:"onvif_username"` ONVIFUsername string `json:"onvif_username,omitempty" bson:"onvif_username"`
ONVIFPassword string `json:"onvif_password,omitempty" bson:"onvif_password"` ONVIFPassword string `json:"onvif_password,omitempty" bson:"onvif_password"`
ONVIFChannel int `json:"onvif_channel,omitempty" bson:"onvif_channel,omitempty"` // 1-based; 0 = first profile
} }
type CameraStreams struct { type CameraStreams struct {
@@ -69,11 +68,6 @@ type OnvifZoom struct {
Zoom float64 `json:"zoom,omitempty" bson:"zoom"` Zoom float64 `json:"zoom,omitempty" bson:"zoom"`
} }
type OnvifFocus struct {
OnvifCredentials OnvifCredentials `json:"onvif_credentials,omitempty" bson:"onvif_credentials"`
Focus float64 `json:"focus,omitempty" bson:"focus"`
}
type OnvifPreset struct { type OnvifPreset struct {
OnvifCredentials OnvifCredentials `json:"onvif_credentials,omitempty" bson:"onvif_credentials"` OnvifCredentials OnvifCredentials `json:"onvif_credentials,omitempty" bson:"onvif_credentials"`
Preset string `json:"preset,omitempty" bson:"preset"` Preset string `json:"preset,omitempty" bson:"preset"`
+76
View File
@@ -71,6 +71,17 @@ type HubRuntimeTelemetry struct {
LastSuccessfulHeartbeatAt int64 LastSuccessfulHeartbeatAt int64
} }
type FrameProcessingRuntimeTelemetry struct {
Configured bool `json:"configured"`
Sampled uint64 `json:"sampled"`
Queued uint64 `json:"queued"`
Dropped uint64 `json:"dropped"`
Submitted uint64 `json:"submitted"`
Failed uint64 `json:"failed"`
QueueDepth int64 `json:"queueDepth"`
LastSuccessAt int64 `json:"lastSuccessAt"`
}
type hubRuntimeTelemetry struct { type hubRuntimeTelemetry struct {
configured atomic.Bool configured atomic.Bool
connected atomic.Bool connected atomic.Bool
@@ -78,6 +89,17 @@ type hubRuntimeTelemetry struct {
lastSuccessfulHeartbeatAt atomic.Int64 lastSuccessfulHeartbeatAt atomic.Int64
} }
type frameProcessingRuntimeTelemetry struct {
configured atomic.Bool
sampled atomic.Uint64
queued atomic.Uint64
dropped atomic.Uint64
submitted atomic.Uint64
failed atomic.Uint64
queueDepth atomic.Int64
lastSuccessAt atomic.Int64
}
type recoveryTelemetry struct { type recoveryTelemetry struct {
moqHighReconnects atomic.Uint64 moqHighReconnects atomic.Uint64
moqHighLastFrameUnixMillis atomic.Int64 moqHighLastFrameUnixMillis atomic.Int64
@@ -151,6 +173,7 @@ type Communication struct {
mainStreamTelemetry streamRuntimeTelemetry mainStreamTelemetry streamRuntimeTelemetry
subStreamTelemetry streamRuntimeTelemetry subStreamTelemetry streamRuntimeTelemetry
hubTelemetry hubRuntimeTelemetry hubTelemetry hubRuntimeTelemetry
frameProcessingTelemetry frameProcessingRuntimeTelemetry
recovery recoveryTelemetry recovery recoveryTelemetry
} }
@@ -231,6 +254,54 @@ func (c *Communication) HubRuntimeTelemetry() HubRuntimeTelemetry {
} }
} }
func (c *Communication) SetFrameProcessingConfigured(configured bool) {
c.frameProcessingTelemetry.configured.Store(configured)
if !configured {
c.frameProcessingTelemetry.queueDepth.Store(0)
}
}
func (c *Communication) RecordFrameProcessingSample() {
c.frameProcessingTelemetry.sampled.Add(1)
}
func (c *Communication) RecordFrameProcessingQueued(depth int, dropped bool) {
c.frameProcessingTelemetry.queueDepth.Store(int64(depth))
c.frameProcessingTelemetry.queued.Add(1)
if dropped {
c.frameProcessingTelemetry.dropped.Add(1)
}
}
func (c *Communication) SetFrameProcessingQueueDepth(depth int) {
c.frameProcessingTelemetry.queueDepth.Store(int64(depth))
}
func (c *Communication) RecordFrameProcessingSuccess(at time.Time) {
c.frameProcessingTelemetry.submitted.Add(1)
if !at.IsZero() {
c.frameProcessingTelemetry.lastSuccessAt.Store(at.Unix())
}
}
func (c *Communication) RecordFrameProcessingFailure() {
c.frameProcessingTelemetry.failed.Add(1)
}
func (c *Communication) FrameProcessingRuntimeTelemetry() FrameProcessingRuntimeTelemetry {
telemetry := &c.frameProcessingTelemetry
return FrameProcessingRuntimeTelemetry{
Configured: telemetry.configured.Load(),
Sampled: telemetry.sampled.Load(),
Queued: telemetry.queued.Load(),
Dropped: telemetry.dropped.Load(),
Submitted: telemetry.submitted.Load(),
Failed: telemetry.failed.Load(),
QueueDepth: telemetry.queueDepth.Load(),
LastSuccessAt: telemetry.lastSuccessAt.Load(),
}
}
func (c *Communication) RecordMoQReconnect(quality string) { func (c *Communication) RecordMoQReconnect(quality string) {
if quality == StreamQualityLow { if quality == StreamQualityLow {
c.recovery.moqLowReconnects.Add(1) c.recovery.moqLowReconnects.Add(1)
@@ -364,3 +435,8 @@ func (c *Communication) TrySendONVIF(action OnvifAction) bool {
} }
return true return true
} }
func (c *Communication) TrySendFrameProcessingRequest(request FrameProcessingRequest) bool {
run := c.CurrentRun()
return run != nil && run.TrySendFrameProcessingRequest(request)
}
+58 -40
View File
@@ -12,44 +12,64 @@ type Configuration struct {
// Config is the highlevel struct which contains all the configuration of // Config is the highlevel struct which contains all the configuration of
// your Kerberos Open Source instance. // your Kerberos Open Source instance.
type Config struct { type Config struct {
Type string `json:"type"` Type string `json:"type"`
Key string `json:"key"` Key string `json:"key"`
Name string `json:"name"` Name string `json:"name"`
FriendlyName string `json:"friendly_name"` FriendlyName string `json:"friendly_name"`
Time string `json:"time" bson:"time"` Time string `json:"time" bson:"time"`
Offline string `json:"offline"` Offline string `json:"offline"`
AutoClean string `json:"auto_clean"` AutoClean string `json:"auto_clean"`
RemoveAfterUpload string `json:"remove_after_upload"` RemoveAfterUpload string `json:"remove_after_upload"`
MaxDirectorySize int64 `json:"max_directory_size"` MaxDirectorySize int64 `json:"max_directory_size"`
MinFreeSpace int64 `json:"min_free_space,omitempty"` MinFreeSpace int64 `json:"min_free_space,omitempty"`
Timezone string `json:"timezone"` Timezone string `json:"timezone"`
Capture Capture `json:"capture"` Capture Capture `json:"capture"`
Timetable []*Timetable `json:"timetable"` Timetable []*Timetable `json:"timetable"`
Region *Region `json:"region"` Region *Region `json:"region"`
Cloud string `json:"cloud" bson:"cloud"` Cloud string `json:"cloud" bson:"cloud"`
S3 *S3 `json:"s3,omitempty" bson:"s3,omitempty"` S3 *S3 `json:"s3,omitempty" bson:"s3,omitempty"`
KStorage *KStorage `json:"kstorage,omitempty" bson:"kstorage,omitempty"` KStorage *KStorage `json:"kstorage,omitempty" bson:"kstorage,omitempty"`
KStorageSecondary *KStorage `json:"kstorage_secondary,omitempty" bson:"kstorage_secondary,omitempty"` KStorageSecondary *KStorage `json:"kstorage_secondary,omitempty" bson:"kstorage_secondary,omitempty"`
Dropbox *Dropbox `json:"dropbox,omitempty" bson:"dropbox,omitempty"` Dropbox *Dropbox `json:"dropbox,omitempty" bson:"dropbox,omitempty"`
MQTTURI string `json:"mqtturi" bson:"mqtturi,omitempty"` MQTTURI string `json:"mqtturi" bson:"mqtturi,omitempty"`
MQTTUsername string `json:"mqtt_username" bson:"mqtt_username"` MQTTUsername string `json:"mqtt_username" bson:"mqtt_username"`
MQTTPassword string `json:"mqtt_password" bson:"mqtt_password"` MQTTPassword string `json:"mqtt_password" bson:"mqtt_password"`
STUNURI string `json:"stunuri" bson:"stunuri"` STUNURI string `json:"stunuri" bson:"stunuri"`
ForceTurn string `json:"turn_force" bson:"turn_force"` ForceTurn string `json:"turn_force" bson:"turn_force"`
TURNURI string `json:"turnuri" bson:"turnuri"` TURNURI string `json:"turnuri" bson:"turnuri"`
TURNUsername string `json:"turn_username" bson:"turn_username"` TURNUsername string `json:"turn_username" bson:"turn_username"`
TURNPassword string `json:"turn_password" bson:"turn_password"` TURNPassword string `json:"turn_password" bson:"turn_password"`
HeartbeatURI string `json:"heartbeaturi" bson:"heartbeaturi"` /*obsolete*/ HeartbeatURI string `json:"heartbeaturi" bson:"heartbeaturi"` /*obsolete*/
HubEncryption string `json:"hub_encryption" bson:"hub_encryption"` HubEncryption string `json:"hub_encryption" bson:"hub_encryption"`
HubURI string `json:"hub_uri" bson:"hub_uri"` HubURI string `json:"hub_uri" bson:"hub_uri"`
HubKey string `json:"hub_key" bson:"hub_key"` HubKey string `json:"hub_key" bson:"hub_key"`
HubPrivateKey string `json:"hub_private_key" bson:"hub_private_key"` HubPrivateKey string `json:"hub_private_key" bson:"hub_private_key"`
HubSite string `json:"hub_site" bson:"hub_site"` HubSite string `json:"hub_site" bson:"hub_site"`
ConditionURI string `json:"condition_uri" bson:"condition_uri"` ConditionURI string `json:"condition_uri" bson:"condition_uri"`
Encryption *Encryption `json:"encryption,omitempty" bson:"encryption,omitempty"` Encryption *Encryption `json:"encryption,omitempty" bson:"encryption,omitempty"`
Signing *Signing `json:"signing,omitempty" bson:"signing,omitempty"` Signing *Signing `json:"signing,omitempty" bson:"signing,omitempty"`
RealtimeProcessing string `json:"realtimeprocessing,omitempty" bson:"realtimeprocessing,omitempty"` FrameProcessing *FrameProcessing `json:"frameProcessing,omitempty" bson:"frameProcessing,omitempty"`
RealtimeProcessingTopic string `json:"realtimeprocessing_topic" bson:"realtimeprocessing_topic"` RealtimeProcessing string `json:"realtimeprocessing,omitempty" bson:"realtimeprocessing,omitempty"`
RealtimeProcessingTopic string `json:"realtimeprocessing_topic" bson:"realtimeprocessing_topic"`
}
// FrameProcessing configures keyframe-aligned JPEG delivery to an external
// processor. It is independent from the legacy MQTT realtimeprocessing output.
type FrameProcessing struct {
Enabled string `json:"enabled,omitempty" bson:"enabled,omitempty"`
Endpoint string `json:"endpoint,omitempty" bson:"endpoint,omitempty"`
Token string `json:"-" bson:"-"`
Profile string `json:"profile,omitempty" bson:"profile,omitempty"`
AllowRequestedFrames string `json:"allowRequestedFrames,omitempty" bson:"allowRequestedFrames,omitempty"`
Stream string `json:"stream,omitempty" bson:"stream,omitempty"`
IntervalSeconds int64 `json:"intervalSeconds,omitempty" bson:"intervalSeconds,omitempty"`
Width int `json:"width,omitempty" bson:"width,omitempty"`
Height int `json:"height,omitempty" bson:"height,omitempty"`
JPEGQuality int `json:"jpegQuality,omitempty" bson:"jpegQuality,omitempty"`
RequestTimeoutSeconds int64 `json:"requestTimeoutSeconds,omitempty" bson:"requestTimeoutSeconds,omitempty"`
FrameTTLSeconds int64 `json:"frameTtlSeconds,omitempty" bson:"frameTtlSeconds,omitempty"`
MaxFrameBytes int64 `json:"maxFrameBytes,omitempty" bson:"maxFrameBytes,omitempty"`
PeriodicQueueCapacity int `json:"periodicQueueCapacity,omitempty" bson:"periodicQueueCapacity,omitempty"`
} }
// Capture defines which camera type (Id) you are using (IP, USB or Raspberry Pi camera), // Capture defines which camera type (Id) you are using (IP, USB or Raspberry Pi camera),
@@ -105,7 +125,6 @@ type IPCamera struct {
ONVIFXAddr string `json:"onvif_xaddr" bson:"onvif_xaddr"` ONVIFXAddr string `json:"onvif_xaddr" bson:"onvif_xaddr"`
ONVIFUsername string `json:"onvif_username" bson:"onvif_username"` ONVIFUsername string `json:"onvif_username" bson:"onvif_username"`
ONVIFPassword string `json:"onvif_password" bson:"onvif_password"` ONVIFPassword string `json:"onvif_password" bson:"onvif_password"`
ONVIFChannel int `json:"onvif_channel,omitempty" bson:"onvif_channel,omitempty"` // 1-based video input on multi-channel devices (encoders, NVRs); 0 = first profile
SPSNALUs [][]byte `json:"sps_nalus,omitempty" bson:"sps_nalus,omitempty"` SPSNALUs [][]byte `json:"sps_nalus,omitempty" bson:"sps_nalus,omitempty"`
PPSNALUs [][]byte `json:"pps_nalus,omitempty" bson:"pps_nalus,omitempty"` PPSNALUs [][]byte `json:"pps_nalus,omitempty" bson:"pps_nalus,omitempty"`
VPSNALUs [][]byte `json:"vps_nalus,omitempty" bson:"vps_nalus,omitempty"` VPSNALUs [][]byte `json:"vps_nalus,omitempty" bson:"vps_nalus,omitempty"`
@@ -188,7 +207,6 @@ type KStorage struct {
SecretAccessKey string `json:"secret_access_key,omitempty" bson:"secret_access_key,omitempty"` SecretAccessKey string `json:"secret_access_key,omitempty" bson:"secret_access_key,omitempty"`
Provider string `json:"provider,omitempty" bson:"provider,omitempty"` Provider string `json:"provider,omitempty" bson:"provider,omitempty"`
Directory string `json:"directory,omitempty" bson:"directory,omitempty"` Directory string `json:"directory,omitempty" bson:"directory,omitempty"`
CustomHeaders string `json:"custom_headers,omitempty" bson:"custom_headers,omitempty"`
MaxRetries int `json:"max_retries,omitempty" bson:"max_retries,omitempty"` MaxRetries int `json:"max_retries,omitempty" bson:"max_retries,omitempty"`
Timeout int `json:"timeout,omitempty" bson:"timeout,omitempty"` Timeout int `json:"timeout,omitempty" bson:"timeout,omitempty"`
} }
+33
View File
@@ -0,0 +1,33 @@
package models
import "github.com/kerberos-io/agent/machinery/src/packets"
const (
FrameProcessingSchemaVersion = "1.0"
FrameProcessingStatusAction = "frame-processing-status"
)
type FrameProcessingRequest struct {
SchemaVersion string `json:"schemaVersion"`
RequestID string `json:"requestId"`
ProcessingProfile string `json:"processingProfile"`
ExpiresAt int64 `json:"expiresAt"`
TraceID string `json:"traceId,omitempty"`
}
type FrameProcessingWork struct {
Request FrameProcessingRequest
Cursor *packets.QueueCursor
}
type FrameProcessingStatus struct {
SchemaVersion string `json:"schemaVersion"`
RequestID string `json:"requestId"`
FrameID string `json:"frameId,omitempty"`
DeviceID string `json:"deviceId"`
Status string `json:"status"`
OccurredAt int64 `json:"occurredAt"`
Retryable bool `json:"retryable,omitempty"`
Message string `json:"message,omitempty"`
TraceID string `json:"traceId,omitempty"`
}
@@ -0,0 +1,42 @@
package models
import (
"encoding/json"
"strings"
"testing"
"time"
)
func TestFrameProcessingTokenIsNotSerialized(t *testing.T) {
config := Config{FrameProcessing: &FrameProcessing{
Enabled: "true",
Endpoint: "https://processor.example/v1/frames",
Token: "do-not-expose",
}}
value, err := json.Marshal(config)
if err != nil {
t.Fatal(err)
}
if strings.Contains(string(value), config.FrameProcessing.Token) {
t.Fatalf("serialized config exposed frame-processing token: %s", value)
}
}
func TestFrameProcessingRuntimeTelemetry(t *testing.T) {
communication := &Communication{}
communication.SetFrameProcessingConfigured(true)
communication.RecordFrameProcessingSample()
communication.RecordFrameProcessingQueued(1, false)
communication.RecordFrameProcessingQueued(1, true)
communication.SetFrameProcessingQueueDepth(0)
communication.RecordFrameProcessingFailure()
communication.RecordFrameProcessingSuccess(time.Unix(123, 0))
got := communication.FrameProcessingRuntimeTelemetry()
if !got.Configured || got.Sampled != 1 || got.Queued != 2 || got.Dropped != 1 || got.Failed != 1 || got.Submitted != 1 {
t.Fatalf("FrameProcessingRuntimeTelemetry() = %+v", got)
}
if got.QueueDepth != 0 || got.LastSuccessAt != 123 {
t.Fatalf("FrameProcessingRuntimeTelemetry() timing = %+v", got)
}
}
-1
View File
@@ -12,7 +12,6 @@ type OnvifActionPTZ struct {
Down int `json:"down" bson:"down"` Down int `json:"down" bson:"down"`
Center int `json:"center" bson:"center"` Center int `json:"center" bson:"center"`
Zoom float64 `json:"zoom" bson:"zoom"` Zoom float64 `json:"zoom" bson:"zoom"`
Focus float64 `json:"focus" bson:"focus"`
X float64 `json:"x" bson:"x"` X float64 `json:"x" bson:"x"`
Y float64 `json:"y" bson:"y"` Y float64 `json:"y" bson:"y"`
Z float64 `json:"z" bson:"z"` Z float64 `json:"z" bson:"z"`
@@ -11,15 +11,12 @@ const RecordingUploadMetadataExtension = ".metadata"
// with a recording. New optional fields can be added without changing the queue // with a recording. New optional fields can be added without changing the queue
// mechanism or breaking older agents. // mechanism or breaking older agents.
type RecordingUploadMetadata struct { type RecordingUploadMetadata struct {
FileName string `json:"filename"` FileName string `json:"filename"`
DeviceKey string `json:"device_key"` DeviceKey string `json:"device_key"`
Timestamp int64 `json:"timestamp"` // Unix milliseconds. Timestamp int64 `json:"timestamp"` // Unix milliseconds.
Duration uint64 `json:"duration"` // Milliseconds. Duration uint64 `json:"duration"` // Milliseconds.
FPS float64 `json:"fps,omitempty"` FPS float64 `json:"fps,omitempty"`
Encrypted bool `json:"encrypted,omitempty"` Encrypted bool `json:"encrypted,omitempty"`
DeviceName string `json:"device_name,omitempty"`
RegionCoordinates string `json:"region_coordinates,omitempty"`
NumberOfChanges string `json:"number_of_changes,omitempty"`
} }
// RecordingUploadMetadataFileName returns the queue marker name associated // RecordingUploadMetadataFileName returns the queue marker name associated
-113
View File
@@ -1,113 +0,0 @@
package onvif
import (
"errors"
"fmt"
"io"
"github.com/kerberos-io/onvif"
"github.com/kerberos-io/onvif/media"
xsdonvif "github.com/kerberos-io/onvif/xsd/onvif"
)
// Multi-channel devices (encoders, NVRs) expose several media profiles per
// video input, e.g. a Hanwha SPE-420 returns DefaultProfile-01-0..03-0 for
// channel 1 and DefaultProfile-01-1..03-1 for channel 2. PTZ, presets and
// focus must be addressed with a profile (or video source) of the channel the
// camera is wired to, otherwise commands drive the wrong camera.
//
// A channel is 1-based, counted in the order the device first lists each video
// source in GetProfiles. Channel 0 (unset) keeps the historic behaviour of
// using the first profile, so single-sensor cameras need no configuration.
// GetTokenFromChannel returns the media profile token to use for PTZ commands
// on the given 1-based channel.
func GetTokenFromChannel(device *onvif.Device, channel int) (xsdonvif.ReferenceToken, error) {
if channel <= 0 {
return GetTokenFromProfile(device, 0)
}
profiles, err := getMediaProfiles(device)
if err != nil {
return "", err
}
profile, err := selectChannelProfile(profiles, channel)
if err != nil {
return "", err
}
return profile.Token, nil
}
// GetVideoSourceTokenFromChannel returns the video source token of the given
// 1-based channel, as used by the imaging (focus) service.
func GetVideoSourceTokenFromChannel(device *onvif.Device, channel int) (xsdonvif.ReferenceToken, error) {
if channel <= 0 {
return GetVideoSourceTokenFromProfile(device, 0)
}
profiles, err := getMediaProfiles(device)
if err != nil {
return "", err
}
profile, err := selectChannelProfile(profiles, channel)
if err != nil {
return "", err
}
return *profile.VideoSourceConfiguration.SourceToken, nil
}
func getMediaProfiles(device *onvif.Device) ([]xsdonvif.Profile, error) {
resp, err := device.CallMethod(media.GetProfiles{})
if err != nil {
if resp != nil {
resp.Body.Close()
}
return nil, err
}
b, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
return nil, err
}
decodedXML, et, err := getXMLNode(string(b), "GetProfilesResponse")
if err != nil {
return nil, err
}
var profilesResp media.GetProfilesResponse
if err := decodedXML.DecodeElement(&profilesResp, et); err != nil {
return nil, err
}
return profilesResp.Profiles, nil
}
// selectChannelProfile groups profiles by video source and returns a profile
// of the channel-th source (1-based). Within a channel it prefers the first
// profile that has a PTZ configuration attached.
func selectChannelProfile(profiles []xsdonvif.Profile, channel int) (xsdonvif.Profile, error) {
if channel <= 0 {
return xsdonvif.Profile{}, errors.New("onvif channel must be 1 or higher")
}
var sources []xsdonvif.ReferenceToken
bySource := map[xsdonvif.ReferenceToken][]xsdonvif.Profile{}
for _, profile := range profiles {
if profile.VideoSourceConfiguration == nil || profile.VideoSourceConfiguration.SourceToken == nil {
continue
}
source := *profile.VideoSourceConfiguration.SourceToken
if _, seen := bySource[source]; !seen {
sources = append(sources, source)
}
bySource[source] = append(bySource[source], profile)
}
if channel > len(sources) {
return xsdonvif.Profile{}, fmt.Errorf("onvif channel %d not found: device exposes %d video source(s)", channel, len(sources))
}
candidates := bySource[sources[channel-1]]
for _, profile := range candidates {
if profile.PTZConfiguration != nil {
return profile, nil
}
}
return candidates[0], nil
}
-105
View File
@@ -1,105 +0,0 @@
package onvif
import (
"fmt"
"testing"
xsdonvif "github.com/kerberos-io/onvif/xsd/onvif"
)
func testProfile(token string, source string, ptz bool) xsdonvif.Profile {
profile := xsdonvif.Profile{Token: xsdonvif.ReferenceToken(token)}
if source != "" {
sourceToken := xsdonvif.ReferenceToken(source)
profile.VideoSourceConfiguration = &xsdonvif.VideoSourceConfiguration{SourceToken: &sourceToken}
}
if ptz {
profile.PTZConfiguration = &xsdonvif.PTZConfiguration{}
}
return profile
}
// spe420Profiles mirrors a Hanwha SPE-420: three profiles per channel, token
// suffix -(N-1), listed grouped by profile type rather than by channel.
func spe420Profiles() []xsdonvif.Profile {
var profiles []xsdonvif.Profile
for kind := 1; kind <= 3; kind++ {
for ch := 0; ch < 4; ch++ {
profiles = append(profiles, testProfile(
fmt.Sprintf("DefaultProfile-0%d-%d", kind, ch),
fmt.Sprintf("VideoSourceToken-%d", ch),
true,
))
}
}
return profiles
}
func TestSelectChannelProfileMapsEncoderChannels(t *testing.T) {
profiles := spe420Profiles()
for channel := 1; channel <= 4; channel++ {
profile, err := selectChannelProfile(profiles, channel)
if err != nil {
t.Fatalf("channel %d: %v", channel, err)
}
want := fmt.Sprintf("DefaultProfile-01-%d", channel-1)
if string(profile.Token) != want {
t.Fatalf("channel %d: got %s, want %s", channel, profile.Token, want)
}
}
}
func TestSelectChannelProfilePrefersProfileWithPTZ(t *testing.T) {
profiles := []xsdonvif.Profile{
testProfile("mjpeg", "src-0", false),
testProfile("main", "src-0", true),
}
profile, err := selectChannelProfile(profiles, 1)
if err != nil {
t.Fatal(err)
}
if profile.Token != "main" {
t.Fatalf("got %s, want main", profile.Token)
}
}
func TestSelectChannelProfileFallsBackToFirstProfileOfChannel(t *testing.T) {
profiles := []xsdonvif.Profile{
testProfile("a", "src-0", false),
testProfile("b", "src-1", false),
testProfile("c", "src-1", false),
}
profile, err := selectChannelProfile(profiles, 2)
if err != nil {
t.Fatal(err)
}
if profile.Token != "b" {
t.Fatalf("got %s, want b", profile.Token)
}
}
func TestSelectChannelProfileSkipsProfilesWithoutVideoSource(t *testing.T) {
profiles := []xsdonvif.Profile{
testProfile("audio-only", "", false),
testProfile("video", "src-0", false),
}
profile, err := selectChannelProfile(profiles, 1)
if err != nil {
t.Fatal(err)
}
if profile.Token != "video" {
t.Fatalf("got %s, want video", profile.Token)
}
}
func TestSelectChannelProfileRejectsUnknownChannel(t *testing.T) {
if _, err := selectChannelProfile(spe420Profiles(), 5); err == nil {
t.Fatal("expected error for channel beyond the device's video sources")
}
if _, err := selectChannelProfile(spe420Profiles(), 0); err == nil {
t.Fatal("expected error for channel 0")
}
if _, err := selectChannelProfile(nil, 1); err == nil {
t.Fatal("expected error when the device has no profiles")
}
}
-466
View File
@@ -1,466 +0,0 @@
package onvif
import (
"encoding/xml"
"errors"
"fmt"
"io"
"math"
"net/http"
"regexp"
"slices"
"time"
"github.com/kerberos-io/onvif"
"github.com/kerberos-io/onvif/imaging"
"github.com/kerberos-io/onvif/media"
xsdonvif "github.com/kerberos-io/onvif/xsd/onvif"
log "github.com/sirupsen/logrus"
)
// Focus control goes through the ONVIF imaging service. The request types of
// the onvif library serialise every field (all three move types, every imaging
// setting), which cameras reject or which would overwrite unrelated imaging
// settings. The types below only carry the fields we want to send. Schema
// elements use the "onvif" prefix, which the library declares on the envelope
// as http://www.onvif.org/ver10/schema.
const (
focusModeAuto = "AUTO"
focusModeManual = "MANUAL"
// Same move duration as ContinuousZoom.
continuousFocusDuration = 500 * time.Millisecond
// Step for cameras that only support relative focus moves.
relativeFocusDistance = 0.1
// Step at full speed for cameras that only support absolute focus moves
// (e.g. Axis); scaled by the requested speed.
absoluteFocusStep = 0.1
// Time to let the camera settle in MANUAL before re-enabling AUTO.
autoFocusRetriggerDelay = 300 * time.Millisecond
)
type imagingMoveRequest struct {
XMLName xml.Name `xml:"timg:Move"`
VideoSourceToken xsdonvif.ReferenceToken `xml:"timg:VideoSourceToken"`
Focus focusMove `xml:"timg:Focus"`
}
type focusMove struct {
Absolute *absoluteFocusMove `xml:"onvif:Absolute,omitempty"`
Relative *relativeFocusMove `xml:"onvif:Relative,omitempty"`
Continuous *continuousFocusMove `xml:"onvif:Continuous,omitempty"`
}
type absoluteFocusMove struct {
Position float64 `xml:"onvif:Position"`
}
type relativeFocusMove struct {
Distance float64 `xml:"onvif:Distance"`
Speed float64 `xml:"onvif:Speed,omitempty"`
}
type continuousFocusMove struct {
Speed float64 `xml:"onvif:Speed"`
}
type imagingStopRequest struct {
XMLName xml.Name `xml:"timg:Stop"`
VideoSourceToken xsdonvif.ReferenceToken `xml:"timg:VideoSourceToken"`
}
type imagingGetSettingsRequest struct {
XMLName xml.Name `xml:"timg:GetImagingSettings"`
VideoSourceToken xsdonvif.ReferenceToken `xml:"timg:VideoSourceToken"`
}
type imagingGetSettingsResponse struct {
ImagingSettings struct {
Brightness *float64 `xml:"Brightness"`
Focus struct {
AutoFocusMode string `xml:"AutoFocusMode"`
} `xml:"Focus"`
} `xml:"ImagingSettings"`
}
type imagingSetFocusModeRequest struct {
XMLName xml.Name `xml:"timg:SetImagingSettings"`
VideoSourceToken xsdonvif.ReferenceToken `xml:"timg:VideoSourceToken"`
ImagingSettings struct {
Brightness *float64 `xml:"onvif:Brightness,omitempty"`
Focus struct {
AutoFocusMode string `xml:"onvif:AutoFocusMode"`
} `xml:"onvif:Focus"`
} `xml:"timg:ImagingSettings"`
}
type imagingGetOptionsRequest struct {
XMLName xml.Name `xml:"timg:GetOptions"`
VideoSourceToken xsdonvif.ReferenceToken `xml:"timg:VideoSourceToken"`
}
type imagingGetOptionsResponse struct {
ImagingOptions struct {
Focus struct {
AutoFocusModes []string `xml:"AutoFocusModes"`
} `xml:"Focus"`
} `xml:"ImagingOptions"`
}
type imagingGetMoveOptionsRequest struct {
XMLName xml.Name `xml:"timg:GetMoveOptions"`
VideoSourceToken xsdonvif.ReferenceToken `xml:"timg:VideoSourceToken"`
}
type imagingGetMoveOptionsResponse struct {
MoveOptions struct {
Absolute *struct {
Position struct {
Min float64 `xml:"Min"`
Max float64 `xml:"Max"`
} `xml:"Position"`
} `xml:"Absolute"`
Relative *struct{} `xml:"Relative"`
Continuous *struct{} `xml:"Continuous"`
} `xml:"MoveOptions"`
}
type imagingGetStatusRequest struct {
XMLName xml.Name `xml:"timg:GetStatus"`
VideoSourceToken xsdonvif.ReferenceToken `xml:"timg:VideoSourceToken"`
}
type imagingGetStatusResponse struct {
Status struct {
FocusStatus20 *struct {
Position *float64 `xml:"Position"`
} `xml:"FocusStatus20"`
FocusStatus *struct {
Position *float64 `xml:"Position"`
} `xml:"FocusStatus"`
} `xml:"Status"`
}
// focusMoveOptions lists the focus move types a camera supports.
type focusMoveOptions struct {
Continuous bool
Relative bool
Absolute bool
AbsoluteMin float64
AbsoluteMax float64
}
// allFocusMoveOptions is used when a camera does not report its move options:
// every move type is tried in turn.
var allFocusMoveOptions = focusMoveOptions{Continuous: true, Relative: true, Absolute: true, AbsoluteMin: 0, AbsoluteMax: 1}
// focusController abstracts the imaging calls so the focus logic can be tested
// without a camera.
type focusController interface {
FocusMode() (string, error)
FocusModes() ([]string, error)
SetFocusMode(mode string) error
MoveOptions() (focusMoveOptions, error)
FocusPosition() (float64, error)
MoveFocus(move focusMove) error
StopFocus() error
}
type onvifFocusClient struct {
device *onvif.Device
endpoint string
token xsdonvif.ReferenceToken
}
func newONVIFFocusClient(device *onvif.Device, channel int) (*onvifFocusClient, error) {
endpoint, err := device.GetEndpointByRequestStruct(&imaging.Move{})
if err != nil {
return nil, errors.New("camera does not expose the ONVIF imaging service: " + err.Error())
}
token, err := GetVideoSourceTokenFromChannel(device, channel)
if err != nil {
return nil, err
}
return &onvifFocusClient{device: device, endpoint: endpoint, token: token}, nil
}
var soapFaultReason = regexp.MustCompile(`<(?:[\w.-]+:)?Text[^>]*>([^<]+)</`)
// call sends an imaging request and returns the response body. A rejected
// request returns an error carrying the camera's SOAP fault reason.
func (client *onvifFocusClient) call(operation string, request interface{}) ([]byte, error) {
body, err := xml.Marshal(request)
if err != nil {
return nil, err
}
resp, err := client.device.SendSoap(client.endpoint, string(body))
if resp == nil {
if err == nil {
err = errors.New("no response")
}
return nil, fmt.Errorf("%s: %w", operation, err)
}
b, readErr := io.ReadAll(resp.Body)
resp.Body.Close()
if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
reason := http.StatusText(resp.StatusCode)
if m := soapFaultReason.FindSubmatch(b); m != nil {
reason = string(m[1])
}
return nil, fmt.Errorf("%s: camera returned HTTP %d: %s", operation, resp.StatusCode, reason)
}
if readErr != nil {
return nil, fmt.Errorf("%s: %w", operation, readErr)
}
return b, nil
}
func (client *onvifFocusClient) query(operation string, request interface{}, responseNode string, response interface{}) error {
b, err := client.call(operation, request)
if err != nil {
return err
}
decodedXML, et, err := getXMLNode(string(b), responseNode)
if err != nil {
return fmt.Errorf("%s: %w", operation, err)
}
if err := decodedXML.DecodeElement(response, et); err != nil {
return fmt.Errorf("%s: %w", operation, err)
}
return nil
}
func (client *onvifFocusClient) imagingSettings() (imagingGetSettingsResponse, error) {
var settings imagingGetSettingsResponse
err := client.query("get_imaging_settings", imagingGetSettingsRequest{VideoSourceToken: client.token}, "GetImagingSettingsResponse", &settings)
return settings, err
}
func (client *onvifFocusClient) FocusMode() (string, error) {
settings, err := client.imagingSettings()
return settings.ImagingSettings.Focus.AutoFocusMode, err
}
func (client *onvifFocusClient) SetFocusMode(mode string) error {
request := imagingSetFocusModeRequest{VideoSourceToken: client.token}
request.ImagingSettings.Focus.AutoFocusMode = mode
_, err := client.call("set_focus_mode", request)
if err == nil {
return nil
}
// Some cameras (seen on Axis) fail on a SetImagingSettings that only
// carries Focus. Retry with the current brightness, which leaves it as is.
settings, settingsErr := client.imagingSettings()
if settingsErr != nil || settings.ImagingSettings.Brightness == nil {
return err
}
request.ImagingSettings.Brightness = settings.ImagingSettings.Brightness
if _, retryErr := client.call("set_focus_mode", request); retryErr != nil {
return errors.Join(err, retryErr)
}
return nil
}
func (client *onvifFocusClient) FocusModes() ([]string, error) {
var response imagingGetOptionsResponse
if err := client.query("get_imaging_options", imagingGetOptionsRequest{VideoSourceToken: client.token}, "GetOptionsResponse", &response); err != nil {
return nil, err
}
return response.ImagingOptions.Focus.AutoFocusModes, nil
}
func (client *onvifFocusClient) MoveOptions() (focusMoveOptions, error) {
var response imagingGetMoveOptionsResponse
if err := client.query("get_focus_move_options", imagingGetMoveOptionsRequest{VideoSourceToken: client.token}, "GetMoveOptionsResponse", &response); err != nil {
return focusMoveOptions{}, err
}
moveOptions := response.MoveOptions
options := focusMoveOptions{
Continuous: moveOptions.Continuous != nil,
Relative: moveOptions.Relative != nil,
Absolute: moveOptions.Absolute != nil,
AbsoluteMin: 0,
AbsoluteMax: 1,
}
if moveOptions.Absolute != nil && moveOptions.Absolute.Position.Max > moveOptions.Absolute.Position.Min {
options.AbsoluteMin = moveOptions.Absolute.Position.Min
options.AbsoluteMax = moveOptions.Absolute.Position.Max
}
return options, nil
}
func (client *onvifFocusClient) FocusPosition() (float64, error) {
var response imagingGetStatusResponse
if err := client.query("get_focus_status", imagingGetStatusRequest{VideoSourceToken: client.token}, "GetStatusResponse", &response); err != nil {
return 0, err
}
status := response.Status
if status.FocusStatus20 != nil && status.FocusStatus20.Position != nil {
return *status.FocusStatus20.Position, nil
}
if status.FocusStatus != nil && status.FocusStatus.Position != nil {
return *status.FocusStatus.Position, nil
}
return 0, errors.New("get_focus_status: camera did not report a focus position")
}
func (client *onvifFocusClient) MoveFocus(move focusMove) error {
_, err := client.call("focus_move", imagingMoveRequest{VideoSourceToken: client.token, Focus: move})
return err
}
func (client *onvifFocusClient) StopFocus() error {
_, err := client.call("focus_stop", imagingStopRequest{VideoSourceToken: client.token})
return err
}
// ContinuousFocus moves the focus motor a short step, the focus equivalent of
// ContinuousZoom. Speed is in [-1, 1]: positive focuses near, negative focuses
// far. Cameras with continuous focus move for a moment and stop; cameras with
// only relative or absolute focus (e.g. Axis) step by an amount scaled to the
// speed. The camera is switched to MANUAL focus first, because cameras ignore
// manual moves while autofocus is active; use AutoFocus to hand control back.
func ContinuousFocus(device *onvif.Device, channel int, speed float64) error {
client, err := newONVIFFocusClient(device, channel)
if err != nil {
return err
}
return continuousFocus(client, speed, continuousFocusDuration)
}
// AutoFocus triggers the camera's native ONVIF autofocus. Setting AUTO while
// already in AUTO is a no-op on most cameras, so we toggle through MANUAL to
// force a fresh focus cycle.
func AutoFocus(device *onvif.Device, channel int) error {
client, err := newONVIFFocusClient(device, channel)
if err != nil {
return err
}
return autoFocus(client, autoFocusRetriggerDelay)
}
func continuousFocus(client focusController, speed float64, duration time.Duration) error {
speed = math.Max(-1, math.Min(1, speed))
if speed == 0 {
return client.StopFocus()
}
if err := ensureFocusMode(client, focusModeManual); err != nil {
// Some cameras have no focus mode setting but still accept moves.
log.Debug("onvif.continuousFocus(): could not switch to manual focus: " + err.Error())
}
options, err := client.MoveOptions()
if err != nil {
log.Debug("onvif.continuousFocus(): could not read focus move options, trying all move types: " + err.Error())
options = allFocusMoveOptions
}
var moveErrs []error
if options.Continuous {
err := client.MoveFocus(focusMove{Continuous: &continuousFocusMove{Speed: speed}})
if err == nil {
time.Sleep(duration)
return client.StopFocus()
}
moveErrs = append(moveErrs, err)
}
if options.Relative {
// A single relative step needs no stop.
err := client.MoveFocus(focusMove{Relative: &relativeFocusMove{
Distance: math.Copysign(relativeFocusDistance, speed),
Speed: math.Abs(speed),
}})
if err == nil {
return nil
}
moveErrs = append(moveErrs, err)
}
if options.Absolute {
position, err := client.FocusPosition()
if err == nil {
target := math.Max(options.AbsoluteMin, math.Min(options.AbsoluteMax, position+speed*absoluteFocusStep))
err = client.MoveFocus(focusMove{Absolute: &absoluteFocusMove{Position: target}})
}
if err == nil {
return nil
}
moveErrs = append(moveErrs, err)
}
if len(moveErrs) == 0 {
return errors.New("camera does not support any focus move")
}
return errors.Join(moveErrs...)
}
func ensureFocusMode(client focusController, mode string) error {
current, err := client.FocusMode()
if err == nil && current == mode {
return nil
}
return client.SetFocusMode(mode)
}
var errNoNativeAutoFocus = errors.New("camera does not support native ONVIF autofocus")
func autoFocus(client focusController, delay time.Duration) error {
// Some cameras (seen on Dahua) only advertise MANUAL, yet accept a switch
// to AUTO and silently ignore it.
if modes, err := client.FocusModes(); err == nil && !slices.Contains(modes, focusModeAuto) {
return errNoNativeAutoFocus
}
mode, err := client.FocusMode()
if err == nil && mode == focusModeAuto {
if err := client.SetFocusMode(focusModeManual); err != nil {
return err
}
time.Sleep(delay)
}
if err := client.SetFocusMode(focusModeAuto); err != nil {
return err
}
if mode, err := client.FocusMode(); err == nil && mode != focusModeAuto {
return fmt.Errorf("%w: camera accepted AUTO but reports %s", errNoNativeAutoFocus, mode)
}
return nil
}
// GetVideoSourceTokenFromProfile returns the video source token of a media
// profile; the imaging service is addressed by video source, not by profile.
func GetVideoSourceTokenFromProfile(device *onvif.Device, profileId int) (xsdonvif.ReferenceToken, error) {
var sourceToken xsdonvif.ReferenceToken
resp, err := device.CallMethod(media.GetProfiles{})
if err != nil {
if resp != nil {
resp.Body.Close()
}
return sourceToken, err
}
b, err := io.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
return sourceToken, err
}
decodedXML, et, err := getXMLNode(string(b), "GetProfilesResponse")
if err != nil {
return sourceToken, err
}
var mProfilesResp media.GetProfilesResponse
if err := decodedXML.DecodeElement(&mProfilesResp, et); err != nil {
return sourceToken, err
}
for i, profile := range mProfilesResp.Profiles {
if i == profileId && profile.VideoSourceConfiguration != nil && profile.VideoSourceConfiguration.SourceToken != nil {
return *profile.VideoSourceConfiguration.SourceToken, nil
}
}
return sourceToken, errors.New("no video source token found for profile")
}
-418
View File
@@ -1,418 +0,0 @@
package onvif
import (
"encoding/xml"
"errors"
"math"
"strings"
"testing"
)
type fakeFocusClient struct {
mode string
modeErr error
focusModes []string
focusModesErr error
ignoreAuto bool
setModeErr error
options *focusMoveOptions
optionsErr error
position float64
positionErr error
continuousErr error
relativeErr error
absoluteErr error
modes []string
moves []focusMove
stopCalls int
}
func (client *fakeFocusClient) FocusMode() (string, error) {
return client.mode, client.modeErr
}
func (client *fakeFocusClient) FocusModes() ([]string, error) {
if client.focusModes == nil && client.focusModesErr == nil {
return []string{focusModeManual, focusModeAuto}, nil
}
return client.focusModes, client.focusModesErr
}
func (client *fakeFocusClient) SetFocusMode(mode string) error {
client.modes = append(client.modes, mode)
if client.setModeErr != nil {
return client.setModeErr
}
if mode == focusModeAuto && client.ignoreAuto {
return nil
}
client.mode = mode
return nil
}
func (client *fakeFocusClient) MoveOptions() (focusMoveOptions, error) {
if client.optionsErr != nil {
return focusMoveOptions{}, client.optionsErr
}
if client.options == nil {
return allFocusMoveOptions, nil
}
return *client.options, nil
}
func (client *fakeFocusClient) FocusPosition() (float64, error) {
return client.position, client.positionErr
}
func (client *fakeFocusClient) MoveFocus(move focusMove) error {
client.moves = append(client.moves, move)
switch {
case move.Continuous != nil:
return client.continuousErr
case move.Relative != nil:
return client.relativeErr
default:
return client.absoluteErr
}
}
func (client *fakeFocusClient) StopFocus() error {
client.stopCalls++
return nil
}
func TestContinuousFocusSwitchesToManualMovesAndStops(t *testing.T) {
client := &fakeFocusClient{mode: focusModeAuto}
if err := continuousFocus(client, 0.5, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if len(client.modes) != 1 || client.modes[0] != focusModeManual {
t.Fatalf("modes = %v, want [MANUAL]", client.modes)
}
if len(client.moves) != 1 || client.moves[0].Continuous == nil || client.moves[0].Continuous.Speed != 0.5 {
t.Fatalf("moves = %+v, want one continuous move at 0.5", client.moves)
}
if client.stopCalls != 1 {
t.Fatalf("stopCalls = %d, want 1", client.stopCalls)
}
}
func TestContinuousFocusKeepsManualMode(t *testing.T) {
client := &fakeFocusClient{mode: focusModeManual}
if err := continuousFocus(client, 0.5, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if len(client.modes) != 0 {
t.Fatalf("modes = %v, want no mode change when already MANUAL", client.modes)
}
}
func TestContinuousFocusClampsSpeed(t *testing.T) {
client := &fakeFocusClient{}
if err := continuousFocus(client, -3, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if got := client.moves[0].Continuous.Speed; got != -1 {
t.Fatalf("speed = %v, want -1", got)
}
}
func TestContinuousFocusIgnoresUnsupportedFocusMode(t *testing.T) {
client := &fakeFocusClient{setModeErr: errors.New("not supported")}
if err := continuousFocus(client, 0.5, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if len(client.moves) != 1 || client.stopCalls != 1 {
t.Fatalf("moves = %d stopCalls = %d, want 1 and 1", len(client.moves), client.stopCalls)
}
}
func TestContinuousFocusFallsBackToRelative(t *testing.T) {
client := &fakeFocusClient{continuousErr: errors.New("continuous not supported")}
if err := continuousFocus(client, -0.4, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if len(client.moves) != 2 || client.moves[1].Relative == nil {
t.Fatalf("moves = %+v, want continuous then relative", client.moves)
}
relative := client.moves[1].Relative
if relative.Distance != -relativeFocusDistance || relative.Speed != 0.4 {
t.Fatalf("relative = %+v, want distance %v speed 0.4", relative, -relativeFocusDistance)
}
if client.stopCalls != 0 {
t.Fatalf("stopCalls = %d, want 0 for a relative move", client.stopCalls)
}
}
func TestContinuousFocusUsesAbsoluteWhenOnlyAbsoluteSupported(t *testing.T) {
// Axis cameras report only absolute focus moves.
client := &fakeFocusClient{
mode: focusModeManual,
options: &focusMoveOptions{Absolute: true, AbsoluteMin: 0, AbsoluteMax: 1},
position: 0.48,
}
if err := continuousFocus(client, 0.5, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if len(client.moves) != 1 || client.moves[0].Absolute == nil {
t.Fatalf("moves = %+v, want a single absolute move", client.moves)
}
if got, want := client.moves[0].Absolute.Position, 0.48+0.5*absoluteFocusStep; math.Abs(got-want) > 1e-9 {
t.Fatalf("position = %v, want %v", got, want)
}
if client.stopCalls != 0 {
t.Fatalf("stopCalls = %d, want 0 for an absolute move", client.stopCalls)
}
}
func TestContinuousFocusClampsAbsoluteToRange(t *testing.T) {
client := &fakeFocusClient{
options: &focusMoveOptions{Absolute: true, AbsoluteMin: 0, AbsoluteMax: 1},
position: 0.02,
}
if err := continuousFocus(client, -1, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if got := client.moves[0].Absolute.Position; got != 0 {
t.Fatalf("position = %v, want clamped to 0", got)
}
}
func TestContinuousFocusTriesAllMovesWithoutOptions(t *testing.T) {
client := &fakeFocusClient{
optionsErr: errors.New("no move options"),
continuousErr: errors.New("continuous not supported"),
relativeErr: errors.New("relative not supported"),
position: 0.5,
}
if err := continuousFocus(client, 0.5, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if len(client.moves) != 3 || client.moves[2].Absolute == nil {
t.Fatalf("moves = %+v, want continuous, relative then absolute", client.moves)
}
}
func TestContinuousFocusReturnsErrorWhenAllMovesFail(t *testing.T) {
client := &fakeFocusClient{
continuousErr: errors.New("continuous not supported"),
relativeErr: errors.New("relative not supported"),
positionErr: errors.New("no position"),
}
err := continuousFocus(client, 0.5, 0)
if err == nil || !strings.Contains(err.Error(), "continuous") || !strings.Contains(err.Error(), "relative") || !strings.Contains(err.Error(), "position") {
t.Fatalf("continuousFocus() error = %v, want every move error", err)
}
}
func TestContinuousFocusReturnsErrorWhenNoMoveSupported(t *testing.T) {
client := &fakeFocusClient{options: &focusMoveOptions{}}
if err := continuousFocus(client, 0.5, 0); err == nil {
t.Fatal("continuousFocus() error = nil, want an error")
}
if len(client.moves) != 0 {
t.Fatalf("moves = %+v, want none", client.moves)
}
}
func TestContinuousFocusZeroSpeedStops(t *testing.T) {
client := &fakeFocusClient{}
if err := continuousFocus(client, 0, 0); err != nil {
t.Fatalf("continuousFocus() error = %v", err)
}
if len(client.moves) != 0 || len(client.modes) != 0 || client.stopCalls != 1 {
t.Fatalf("moves = %d modes = %v stopCalls = %d, want only a stop", len(client.moves), client.modes, client.stopCalls)
}
}
func TestAutoFocusRetriggersWhenAlreadyAuto(t *testing.T) {
client := &fakeFocusClient{mode: focusModeAuto}
if err := autoFocus(client, 0); err != nil {
t.Fatalf("autoFocus() error = %v", err)
}
if strings.Join(client.modes, ",") != "MANUAL,AUTO" {
t.Fatalf("modes = %v, want [MANUAL AUTO]", client.modes)
}
}
func TestAutoFocusFromManual(t *testing.T) {
client := &fakeFocusClient{mode: focusModeManual}
if err := autoFocus(client, 0); err != nil {
t.Fatalf("autoFocus() error = %v", err)
}
if strings.Join(client.modes, ",") != "AUTO" {
t.Fatalf("modes = %v, want [AUTO]", client.modes)
}
}
func TestAutoFocusWhenModeUnreadable(t *testing.T) {
client := &fakeFocusClient{modeErr: errors.New("unreadable")}
if err := autoFocus(client, 0); err != nil {
t.Fatalf("autoFocus() error = %v", err)
}
if strings.Join(client.modes, ",") != "AUTO" {
t.Fatalf("modes = %v, want [AUTO]", client.modes)
}
}
func TestAutoFocusRejectsCameraWithoutAutoMode(t *testing.T) {
// Dahua cameras advertise only MANUAL.
client := &fakeFocusClient{mode: focusModeManual, focusModes: []string{focusModeManual}}
if err := autoFocus(client, 0); !errors.Is(err, errNoNativeAutoFocus) {
t.Fatalf("autoFocus() error = %v, want errNoNativeAutoFocus", err)
}
if len(client.modes) != 0 {
t.Fatalf("modes = %v, want no mode change", client.modes)
}
}
func TestAutoFocusDetectsIgnoredAutoMode(t *testing.T) {
client := &fakeFocusClient{mode: focusModeManual, ignoreAuto: true}
if err := autoFocus(client, 0); !errors.Is(err, errNoNativeAutoFocus) {
t.Fatalf("autoFocus() error = %v, want errNoNativeAutoFocus", err)
}
}
func TestAutoFocusWhenFocusModesUnreadable(t *testing.T) {
client := &fakeFocusClient{mode: focusModeManual, focusModesErr: errors.New("no options")}
if err := autoFocus(client, 0); err != nil {
t.Fatalf("autoFocus() error = %v", err)
}
if strings.Join(client.modes, ",") != "AUTO" {
t.Fatalf("modes = %v, want [AUTO]", client.modes)
}
}
func TestImagingRequestsOnlyCarryFocusFields(t *testing.T) {
move, err := xml.Marshal(imagingMoveRequest{
VideoSourceToken: "source",
Focus: focusMove{Continuous: &continuousFocusMove{Speed: 0.5}},
})
if err != nil {
t.Fatalf("marshal move: %v", err)
}
wantMove := "<timg:Move><timg:VideoSourceToken>source</timg:VideoSourceToken><timg:Focus><onvif:Continuous><onvif:Speed>0.5</onvif:Speed></onvif:Continuous></timg:Focus></timg:Move>"
if string(move) != wantMove {
t.Fatalf("move XML = %s\nwant %s", move, wantMove)
}
absolute, err := xml.Marshal(imagingMoveRequest{
VideoSourceToken: "source",
Focus: focusMove{Absolute: &absoluteFocusMove{Position: 0.53}},
})
if err != nil {
t.Fatalf("marshal absolute move: %v", err)
}
wantAbsolute := "<timg:Move><timg:VideoSourceToken>source</timg:VideoSourceToken><timg:Focus><onvif:Absolute><onvif:Position>0.53</onvif:Position></onvif:Absolute></timg:Focus></timg:Move>"
if string(absolute) != wantAbsolute {
t.Fatalf("absolute move XML = %s\nwant %s", absolute, wantAbsolute)
}
request := imagingSetFocusModeRequest{VideoSourceToken: "source"}
request.ImagingSettings.Focus.AutoFocusMode = focusModeManual
settings, err := xml.Marshal(request)
if err != nil {
t.Fatalf("marshal settings: %v", err)
}
wantSettings := "<timg:SetImagingSettings><timg:VideoSourceToken>source</timg:VideoSourceToken><timg:ImagingSettings><onvif:Focus><onvif:AutoFocusMode>MANUAL</onvif:AutoFocusMode></onvif:Focus></timg:ImagingSettings></timg:SetImagingSettings>"
if string(settings) != wantSettings {
t.Fatalf("settings XML = %s\nwant %s", settings, wantSettings)
}
// Brightness must come before Focus (schema order) for the Axis retry.
brightness := 50.0
request.ImagingSettings.Brightness = &brightness
settings, err = xml.Marshal(request)
if err != nil {
t.Fatalf("marshal settings with brightness: %v", err)
}
wantSettings = "<timg:SetImagingSettings><timg:VideoSourceToken>source</timg:VideoSourceToken><timg:ImagingSettings><onvif:Brightness>50</onvif:Brightness><onvif:Focus><onvif:AutoFocusMode>MANUAL</onvif:AutoFocusMode></onvif:Focus></timg:ImagingSettings></timg:SetImagingSettings>"
if string(settings) != wantSettings {
t.Fatalf("settings XML = %s\nwant %s", settings, wantSettings)
}
}
const testImagingEnvelope = `<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://www.w3.org/2003/05/soap-envelope" xmlns:timg="http://www.onvif.org/ver20/imaging/wsdl" xmlns:tt="http://www.onvif.org/ver10/schema"><SOAP-ENV:Body>%s</SOAP-ENV:Body></SOAP-ENV:Envelope>`
func decodeTestImagingResponse(t *testing.T, body string, node string, out interface{}) {
t.Helper()
decoder, start, err := getXMLNode(strings.Replace(testImagingEnvelope, "%s", body, 1), node)
if err != nil {
t.Fatalf("getXMLNode() error = %v", err)
}
if err := decoder.DecodeElement(out, start); err != nil {
t.Fatalf("DecodeElement() error = %v", err)
}
}
func TestImagingSettingsResponseDecodesFocusModeAndBrightness(t *testing.T) {
var settings imagingGetSettingsResponse
decodeTestImagingResponse(t, `<timg:GetImagingSettingsResponse><timg:ImagingSettings><tt:Brightness>50</tt:Brightness><tt:Focus><tt:AutoFocusMode>AUTO</tt:AutoFocusMode></tt:Focus></timg:ImagingSettings></timg:GetImagingSettingsResponse>`, "GetImagingSettingsResponse", &settings)
if settings.ImagingSettings.Focus.AutoFocusMode != focusModeAuto {
t.Fatalf("AutoFocusMode = %q, want AUTO", settings.ImagingSettings.Focus.AutoFocusMode)
}
if settings.ImagingSettings.Brightness == nil || *settings.ImagingSettings.Brightness != 50 {
t.Fatalf("Brightness = %v, want 50", settings.ImagingSettings.Brightness)
}
}
func TestImagingOptionsResponseDecodesFocusModes(t *testing.T) {
// Response captured from a Dahua camera.
var response imagingGetOptionsResponse
decodeTestImagingResponse(t, `<timg:GetOptionsResponse><timg:ImagingOptions><tt:Brightness><tt:Min>0</tt:Min><tt:Max>100</tt:Max></tt:Brightness><tt:Focus><tt:AutoFocusModes>MANUAL</tt:AutoFocusModes><tt:DefaultSpeed><tt:Min>-1</tt:Min><tt:Max>1</tt:Max></tt:DefaultSpeed></tt:Focus></timg:ImagingOptions></timg:GetOptionsResponse>`, "GetOptionsResponse", &response)
if got := strings.Join(response.ImagingOptions.Focus.AutoFocusModes, ","); got != "MANUAL" {
t.Fatalf("AutoFocusModes = %q, want MANUAL", got)
}
}
func TestMoveOptionsResponseDecodesAbsoluteOnly(t *testing.T) {
// Response captured from an Axis camera.
var response imagingGetMoveOptionsResponse
decodeTestImagingResponse(t, `<timg:GetMoveOptionsResponse><timg:MoveOptions><tt:Absolute><tt:Position><tt:Min>0</tt:Min><tt:Max>1</tt:Max></tt:Position></tt:Absolute></timg:MoveOptions></timg:GetMoveOptionsResponse>`, "GetMoveOptionsResponse", &response)
options := response.MoveOptions
if options.Absolute == nil || options.Relative != nil || options.Continuous != nil {
t.Fatalf("options = %+v, want only absolute", options)
}
if options.Absolute.Position.Min != 0 || options.Absolute.Position.Max != 1 {
t.Fatalf("absolute range = %+v, want 0..1", options.Absolute.Position)
}
}
func TestStatusResponseDecodesFocusPosition(t *testing.T) {
// Response captured from an Axis camera.
var response imagingGetStatusResponse
decodeTestImagingResponse(t, `<timg:GetStatusResponse><timg:Status><tt:FocusStatus20><tt:Position>0.479226589</tt:Position><tt:MoveStatus>IDLE</tt:MoveStatus></tt:FocusStatus20></timg:Status></timg:GetStatusResponse>`, "GetStatusResponse", &response)
if response.Status.FocusStatus20 == nil || response.Status.FocusStatus20.Position == nil || *response.Status.FocusStatus20.Position != 0.479226589 {
t.Fatalf("status = %+v, want position 0.479226589", response.Status)
}
}
func TestSOAPFaultReasonExtraction(t *testing.T) {
fault := `<SOAP-ENV:Fault><SOAP-ENV:Reason><SOAP-ENV:Text xml:lang="en">Argument value invalid</SOAP-ENV:Text></SOAP-ENV:Reason></SOAP-ENV:Fault>`
m := soapFaultReason.FindStringSubmatch(fault)
if m == nil || m[1] != "Argument value invalid" {
t.Fatalf("fault reason = %v, want Argument value invalid", m)
}
}
+257 -361
View File
@@ -5,9 +5,7 @@ import (
"encoding/json" "encoding/json"
"encoding/xml" "encoding/xml"
"errors" "errors"
"fmt"
"io" "io"
"math"
"net/http" "net/http"
"strconv" "strconv"
"strings" "strings"
@@ -119,30 +117,10 @@ func HandleONVIFActions(configuration *models.Configuration, communication *mode
// Connect to Onvif device // Connect to Onvif device
cameraConfiguration := configuration.Config.Capture.IPCamera cameraConfiguration := configuration.Config.Capture.IPCamera
device, _, err := ConnectToOnvifDevice(&cameraConfiguration) device, _, err := ConnectToOnvifDevice(&cameraConfiguration)
if err == nil && (onvifAction.Action == "focus" || onvifAction.Action == "autofocus") { if err == nil {
// Focus goes through the imaging service, so it also works on // Get token from the first profile
// cameras without PTZ (e.g. fixed cameras with a motorised lens). token, err := GetTokenFromProfile(device, 0)
if onvifAction.Action == "focus" {
err := ContinuousFocus(device, cameraConfiguration.ONVIFChannel, ptzAction.Focus)
if err != nil {
log.Error("onvif.HandleONVIFActions() - ContinuousFocus: " + err.Error())
} else {
log.Info("onvif.HandleONVIFActions() - ContinuousFocus: successfully focused camera")
}
} else {
err := AutoFocus(device, cameraConfiguration.ONVIFChannel)
if err != nil {
log.Error("onvif.HandleONVIFActions() - AutoFocus: " + err.Error())
} else {
log.Info("onvif.HandleONVIFActions() - AutoFocus: successfully triggered autofocus")
}
}
} else if err == nil {
// Get the profile token of the configured channel
token, err := GetTokenFromChannel(device, cameraConfiguration.ONVIFChannel)
if err == nil { if err == nil {
// Get the configurations from the device // Get the configurations from the device
@@ -152,7 +130,7 @@ func HandleONVIFActions(configuration *models.Configuration, communication *mode
if onvifAction.Action == "absolute-move" { if onvifAction.Action == "absolute-move" {
// Move the camera to the saved absolute position. // We will move the camera to zero position.
x := ptzAction.X x := ptzAction.X
y := ptzAction.Y y := ptzAction.Y
z := ptzAction.Z z := ptzAction.Z
@@ -163,18 +141,47 @@ func HandleONVIFActions(configuration *models.Configuration, communication *mode
// Log functions // Log functions
log.Debug("onvif.HandleONVIFActions(): functions: " + strings.Join(functions, ", ")) log.Debug("onvif.HandleONVIFActions(): functions: " + strings.Join(functions, ", "))
err = MoveToPosition(device, configurations, token, x, y, z) // Check if we need to use absolute or continuous move
/*canAbsoluteMove := false
canContinuousMove := false
if len(functions) > 0 {
for _, function := range functions {
if function == "AbsolutePanTiltMove" || function == "AbsoluteZoomMove" {
canAbsoluteMove = true
} else if function == "ContinuousPanTiltMove" || function == "ContinuousZoomMove" {
canContinuousMove = true
}
}
}*/
// Ideally we should be able to use the AbsolutePanTiltMove function, but it looks like
// the current detection through GetPTZFuntionsFromDevice is not working properly. Therefore we will fallback
// on the ContinuousPanTiltMove function which is more compatible with more cameras.
err = AbsolutePanTiltMoveFake(device, configurations, token, x, y, z)
if err != nil { if err != nil {
log.Error("onvif.HandleONVIFActions() - MoveToPosition: " + err.Error()) log.Debug("onvif.HandleONVIFActions() - AbsolutePanTitleMoveFake: " + err.Error())
} else { } else {
log.Info("onvif.HandleONVIFActions() - MoveToPosition: successfully moved camera.") log.Info("onvif.HandleONVIFActions() - AbsolutePanTitleMoveFake: successfully moved camera.")
} }
/*if canAbsoluteMove {
err = AbsolutePanTiltMove(device, configurations, token, x, y, z)
if err != nil {
log.Error("HandleONVIFActions (AbsolutePanTitleMove): " + err.Error())
}
} else if canContinuousMove {
err = AbsolutePanTiltMoveFake(device, configurations, token, x, y, z)
if err != nil {
log.Error("HandleONVIFActions (AbsolutePanTitleMoveFake): " + err.Error())
}
}*/
} else if onvifAction.Action == "preset" { } else if onvifAction.Action == "preset" {
// Execute the preset // Execute the preset
preset := ptzAction.Preset preset := ptzAction.Preset
err := GoToPresetFromDevice(device, cameraConfiguration.ONVIFChannel, preset) err := GoToPresetFromDevice(device, preset)
if err != nil { if err != nil {
log.Debug("onvif.HandleONVIFActions() - GotoPreset: " + err.Error()) log.Debug("onvif.HandleONVIFActions() - GotoPreset: " + err.Error())
} else { } else {
@@ -369,8 +376,8 @@ func GetPositionFromDevice(configuration models.Configuration) (xsdonvif.PTZVect
device, _, err := ConnectToOnvifDevice(&cameraConfiguration) device, _, err := ConnectToOnvifDevice(&cameraConfiguration)
if err == nil { if err == nil {
// Get the profile token of the configured channel // Get token from the first profile
token, err := GetTokenFromChannel(device, cameraConfiguration.ONVIFChannel) token, err := GetTokenFromProfile(device, 0)
if err == nil { if err == nil {
// Get the PTZ configurations from the device // Get the PTZ configurations from the device
position, err := GetPosition(device, token) position, err := GetPosition(device, token)
@@ -464,20 +471,16 @@ func handleONVIFResponse(operation string, response *http.Response, requestErr e
} }
func AbsolutePanTiltMove(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, pan float64, tilt float64, zoom float64) error { func AbsolutePanTiltMove(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, pan float64, tilt float64, zoom float64) error {
if len(configuration.PTZConfiguration) == 0 {
return errors.New("camera returned no PTZ configuration")
}
ptzConfiguration := configuration.PTZConfiguration[0]
absolutePantiltVector := xsdonvif.Vector2D{ absolutePantiltVector := xsdonvif.Vector2D{
X: pan, X: pan,
Y: tilt, Y: tilt,
Space: ptzConfiguration.DefaultAbsolutePantTiltPositionSpace, Space: configuration.PTZConfiguration[0].DefaultAbsolutePantTiltPositionSpace,
} }
absoluteZoomVector := xsdonvif.Vector1D{ absoluteZoomVector := xsdonvif.Vector1D{
X: zoom, X: zoom,
Space: ptzConfiguration.DefaultAbsoluteZoomPositionSpace, Space: configuration.PTZConfiguration[0].DefaultAbsoluteZoomPositionSpace,
} }
resp, err := device.CallMethod(ptz.AbsoluteMove{ resp, err := device.CallMethod(ptz.AbsoluteMove{
@@ -490,325 +493,240 @@ func AbsolutePanTiltMove(device *onvif.Device, configuration ptz.GetConfiguratio
return handleONVIFResponse("absolute_move", resp, err) return handleONVIFResponse("absolute_move", resp, err)
} }
type ptzMoveClient interface { // This function will simulate the AbsolutePanTiltMove function.
GetPosition() (xsdonvif.PTZVector, error) // However the AboslutePanTiltMove function is not working on all cameras.
AbsoluteMove(ptzTarget) error // So we'll use the ContinuousMove function to simulate the AbsolutePanTiltMove function using the position polling.
ContinuousMove(ptzVelocity) error func AbsolutePanTiltMoveFake(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, pan float64, tilt float64, zoom float64) error {
Stop() error position, err := GetPosition(device, token)
} if position.PanTilt.X >= pan-0.01 && position.PanTilt.X <= pan+0.01 && position.PanTilt.Y >= tilt-0.01 && position.PanTilt.Y <= tilt+0.01 && position.Zoom.X >= zoom-0.01 && position.Zoom.X <= zoom+0.01 {
log.Debug("AbsolutePanTiltMoveFake: already at position")
} else {
type ptzTarget struct { // The speed of panning, the higher the faster we'll pan the camera
Pan float64 // value is a range between 0 and 1.
Tilt float64 speed := 0.6
Zoom float64 wait := 100 * time.Millisecond
}
type ptzVelocity struct { // We'll move quickly to the position (might be inaccurate)
Pan float64 err = ZoomOutCompletely(device, configuration, token)
Tilt float64 err = PanUntilPosition(device, configuration, token, pan, zoom, speed, wait)
Zoom float64 err = TiltUntilPosition(device, configuration, token, tilt, zoom, speed, wait)
}
type ptzMoveSupport struct { // Now we'll move a bit slower to make sure we are ok (will be more accurate)
Absolute bool speed = 0.1
Continuous bool wait = 200 * time.Millisecond
}
type ptzMoveOptions struct { err = PanUntilPosition(device, configuration, token, pan, zoom, speed, wait)
PanTolerance float64 err = TiltUntilPosition(device, configuration, token, tilt, zoom, speed, wait)
TiltTolerance float64 err = ZoomUntilPosition(device, configuration, token, zoom, speed, wait)
ZoomTolerance float64
NativeTimeout time.Duration
ContinuousTimeout time.Duration
NoProgressTimeout time.Duration
PollInterval time.Duration
ProgressEpsilon float64
VelocityGain float64
MinVelocity float64
MaxVelocity float64
VelocityChange float64
}
var defaultPTZMoveOptions = ptzMoveOptions{ return err
PanTolerance: 0.01,
TiltTolerance: 0.005,
ZoomTolerance: 0.005,
NativeTimeout: 8 * time.Second,
ContinuousTimeout: 15 * time.Second,
NoProgressTimeout: 3 * time.Second,
PollInterval: 150 * time.Millisecond,
ProgressEpsilon: 0.001,
VelocityGain: 1.5,
MinVelocity: 0.08,
MaxVelocity: 0.7,
VelocityChange: 0.05,
}
type devicePTZMoveClient struct {
device *onvif.Device
configuration xsdonvif.PTZConfiguration
token xsdonvif.ReferenceToken
}
func (client *devicePTZMoveClient) GetPosition() (xsdonvif.PTZVector, error) {
return GetPosition(client.device, client.token)
}
func (client *devicePTZMoveClient) AbsoluteMove(target ptzTarget) error {
configuration := ptz.GetConfigurationsResponse{
PTZConfiguration: []xsdonvif.PTZConfiguration{client.configuration},
} }
return AbsolutePanTiltMove(client.device, configuration, client.token, target.Pan, target.Tilt, target.Zoom) return err
} }
func (client *devicePTZMoveClient) ContinuousMove(velocity ptzVelocity) error { func ZoomOutCompletely(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken) error {
panTilt := xsdonvif.Vector2D{ // Zoom out completely!!!
X: velocity.Pan, zoomOut := xsdonvif.Vector1D{
Y: velocity.Tilt, X: -1,
Space: client.configuration.DefaultContinuousPanTiltVelocitySpace, Space: configuration.PTZConfiguration[0].DefaultContinuousZoomVelocitySpace,
} }
zoom := xsdonvif.Vector1D{ _, err := device.CallMethod(ptz.ContinuousMove{
X: velocity.Zoom, ProfileToken: &token,
Space: client.configuration.DefaultContinuousZoomVelocitySpace, Velocity: xsdonvif.PTZSpeedZoom{
} Zoom: zoomOut,
resp, err := client.device.CallMethod(ptz.ContinuousMove{
ProfileToken: &client.token,
Velocity: ptz.Speed{
PanTilt: &panTilt,
Zoom: &zoom,
}, },
}) })
return handleONVIFResponse("continuous_move_to_position", resp, err) if err != nil {
} log.Error("ZoomOutCompletely: " + err.Error())
}
func (client *devicePTZMoveClient) Stop() error { for {
resp, err := client.device.CallMethod(ptz.Stop{ position, _ := GetPosition(device, token)
ProfileToken: client.token, if position.Zoom.X == 0 {
PanTilt: true, break
}
time.Sleep(250 * time.Millisecond)
}
_, err = device.CallMethod(ptz.Stop{
ProfileToken: token,
Zoom: true, Zoom: true,
}) })
return handleONVIFResponse("move_to_position_stop", resp, err)
}
func MoveToPosition(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, pan float64, tilt float64, zoom float64) error {
if len(configuration.PTZConfiguration) == 0 {
return errors.New("camera returned no PTZ configuration")
}
ptzConfiguration := configuration.PTZConfiguration[0]
client := &devicePTZMoveClient{
device: device,
configuration: ptzConfiguration,
token: token,
}
support := ptzMoveSupport{
Absolute: ptzConfiguration.DefaultAbsolutePantTiltPositionSpace != nil &&
ptzConfiguration.DefaultAbsoluteZoomPositionSpace != nil,
Continuous: ptzConfiguration.DefaultContinuousPanTiltVelocitySpace != nil &&
ptzConfiguration.DefaultContinuousZoomVelocitySpace != nil,
}
return moveToPosition(client, support, ptzTarget{Pan: pan, Tilt: tilt, Zoom: zoom}, defaultPTZMoveOptions)
}
// AbsolutePanTiltMoveFake preserves the continuous-move compatibility path for callers that explicitly request it.
func AbsolutePanTiltMoveFake(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, pan float64, tilt float64, zoom float64) error {
if len(configuration.PTZConfiguration) == 0 {
return errors.New("camera returned no PTZ configuration")
}
ptzConfiguration := configuration.PTZConfiguration[0]
client := &devicePTZMoveClient{
device: device,
configuration: ptzConfiguration,
token: token,
}
support := ptzMoveSupport{
Continuous: ptzConfiguration.DefaultContinuousPanTiltVelocitySpace != nil &&
ptzConfiguration.DefaultContinuousZoomVelocitySpace != nil,
}
return moveToPosition(client, support, ptzTarget{Pan: pan, Tilt: tilt, Zoom: zoom}, defaultPTZMoveOptions)
}
func moveToPosition(client ptzMoveClient, support ptzMoveSupport, target ptzTarget, options ptzMoveOptions) error {
if err := validatePTZTarget(target); err != nil {
return err
}
position, err := client.GetPosition()
if err != nil { if err != nil {
return fmt.Errorf("read initial PTZ position: %w", err) log.Error("ZoomOutCompletely: " + err.Error())
} }
_, _, reached, err := ptzTargetError(position, target, options) return err
if err != nil {
return err
}
if reached {
return nil
}
var nativeErr error
if support.Absolute {
if err := client.AbsoluteMove(target); err != nil {
nativeErr = fmt.Errorf("native absolute move: %w", err)
} else if err := waitForPTZTarget(client, target, options.NativeTimeout, options); err != nil {
nativeErr = fmt.Errorf("verify native absolute move: %w", err)
} else {
return nil
}
if err := client.Stop(); err != nil {
nativeErr = errors.Join(nativeErr, fmt.Errorf("stop native absolute move: %w", err))
}
log.WithError(nativeErr).Warn("Native ONVIF absolute move failed; using continuous-move fallback")
}
if !support.Continuous {
if nativeErr != nil {
return errors.Join(nativeErr, errors.New("camera does not advertise complete continuous PTZ support"))
}
return errors.New("camera does not advertise a supported absolute or continuous PTZ movement method")
}
if err := moveContinuouslyToPTZTarget(client, target, options); err != nil {
if nativeErr != nil {
return errors.Join(nativeErr, fmt.Errorf("continuous-move fallback: %w", err))
}
return fmt.Errorf("continuous move: %w", err)
}
return nil
} }
func waitForPTZTarget(client ptzMoveClient, target ptzTarget, timeout time.Duration, options ptzMoveOptions) error { func PanUntilPosition(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, pan float64, zoom float64, speed float64, wait time.Duration) error {
deadline := time.Now().Add(timeout) position, err := GetPosition(device, token)
lastProgress := time.Now()
bestDistance := math.Inf(1)
for { if position.PanTilt.X >= pan-0.01 && position.PanTilt.X <= pan+0.01 {
position, err := client.GetPosition()
if err != nil { } else {
return fmt.Errorf("read PTZ position: %w", err)
} // We'll need to determine if we need to move CW or CCW.
_, distance, reached, err := ptzTargetError(position, target, options) // Check the current position and compare it with the desired position.
if err != nil { directionX := speed
return err if position.PanTilt.X > pan {
} directionX = speed * -1
if reached {
return nil
} }
panTiltVector := xsdonvif.Vector2D{
X: directionX,
Y: 0,
Space: configuration.PTZConfiguration[0].DefaultContinuousPanTiltVelocitySpace,
}
resp, err := device.CallMethod(ptz.ContinuousMove{
ProfileToken: &token,
Velocity: xsdonvif.PTZSpeedPanTilt{
PanTilt: panTiltVector,
},
})
err = handleONVIFResponse("continuous_pan", resp, err)
// While moving we'll check if we reached the desired position.
// or if we overshot the desired position.
// Break after 3seconds
now := time.Now() now := time.Now()
if bestDistance-distance >= options.ProgressEpsilon { for {
bestDistance = distance position, _ := GetPosition(device, token)
lastProgress = now if position.PanTilt.X == -1 || position.PanTilt.X == 1 || (directionX > 0 && position.PanTilt.X >= pan) || (directionX < 0 && position.PanTilt.X <= pan) || (position.PanTilt.X >= pan-0.01 && position.PanTilt.X <= pan+0.01) {
} break
if !now.Before(deadline) {
return fmt.Errorf("target not reached within %s", timeout)
}
if now.Sub(lastProgress) >= options.NoProgressTimeout {
return fmt.Errorf("PTZ position made no progress for %s", options.NoProgressTimeout)
}
time.Sleep(options.PollInterval)
}
}
func moveContinuouslyToPTZTarget(client ptzMoveClient, target ptzTarget, options ptzMoveOptions) (err error) {
defer func() {
if stopErr := client.Stop(); stopErr != nil {
err = errors.Join(err, fmt.Errorf("stop continuous move: %w", stopErr))
}
}()
deadline := time.Now().Add(options.ContinuousTimeout)
lastProgress := time.Now()
bestDistance := math.Inf(1)
var lastVelocity ptzVelocity
haveVelocity := false
for {
position, positionErr := client.GetPosition()
if positionErr != nil {
return fmt.Errorf("read PTZ position: %w", positionErr)
}
delta, distance, reached, targetErr := ptzTargetError(position, target, options)
if targetErr != nil {
return targetErr
}
if reached {
return nil
}
now := time.Now()
if bestDistance-distance >= options.ProgressEpsilon {
bestDistance = distance
lastProgress = now
}
if !now.Before(deadline) {
return fmt.Errorf("target not reached within %s", options.ContinuousTimeout)
}
if now.Sub(lastProgress) >= options.NoProgressTimeout {
return fmt.Errorf("PTZ position made no progress for %s", options.NoProgressTimeout)
}
velocity := ptzVelocity{
Pan: proportionalPTZVelocity(delta.Pan, options.PanTolerance, options),
Tilt: proportionalPTZVelocity(delta.Tilt, options.TiltTolerance, options),
Zoom: proportionalPTZVelocity(delta.Zoom, options.ZoomTolerance, options),
}
if !haveVelocity || ptzVelocityChanged(lastVelocity, velocity, options.VelocityChange) {
if moveErr := client.ContinuousMove(velocity); moveErr != nil {
return fmt.Errorf("set continuous PTZ velocity: %w", moveErr)
} }
lastVelocity = velocity if time.Since(now) > 3*time.Second {
haveVelocity = true break
}
time.Sleep(wait)
} }
time.Sleep(options.PollInterval)
}
}
func ptzTargetError(position xsdonvif.PTZVector, target ptzTarget, options ptzMoveOptions) (ptzVelocity, float64, bool, error) { _, err = device.CallMethod(ptz.Stop{
if position.PanTilt == nil || position.Zoom == nil { ProfileToken: token,
return ptzVelocity{}, 0, false, errors.New("camera returned an incomplete PTZ position") PanTilt: true,
} Zoom: true,
delta := ptzVelocity{ })
Pan: target.Pan - position.PanTilt.X,
Tilt: target.Tilt - position.PanTilt.Y,
Zoom: target.Zoom - position.Zoom.X,
}
reached := math.Abs(delta.Pan) <= options.PanTolerance &&
math.Abs(delta.Tilt) <= options.TiltTolerance &&
math.Abs(delta.Zoom) <= options.ZoomTolerance
distance := math.Abs(delta.Pan) + math.Abs(delta.Tilt) + math.Abs(delta.Zoom)
return delta, distance, reached, nil
}
func proportionalPTZVelocity(delta float64, tolerance float64, options ptzMoveOptions) float64 { if err != nil {
if math.Abs(delta) <= tolerance { log.Error("ContinuousPanTiltMove (Pan): " + err.Error())
return 0
}
speed := math.Abs(delta) * options.VelocityGain
speed = math.Max(options.MinVelocity, math.Min(speed, options.MaxVelocity))
return math.Copysign(speed, delta)
}
func ptzVelocityChanged(previous ptzVelocity, next ptzVelocity, threshold float64) bool {
return math.Abs(previous.Pan-next.Pan) >= threshold ||
math.Abs(previous.Tilt-next.Tilt) >= threshold ||
math.Abs(previous.Zoom-next.Zoom) >= threshold
}
func validatePTZTarget(target ptzTarget) error {
values := []struct {
name string
value float64
}{
{name: "pan", value: target.Pan},
{name: "tilt", value: target.Tilt},
{name: "zoom", value: target.Zoom},
}
for _, value := range values {
if math.IsNaN(value.value) || math.IsInf(value.value, 0) {
return fmt.Errorf("invalid PTZ %s target", value.name)
} }
} }
return nil return err
}
func TiltUntilPosition(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, tilt float64, zoom float64, speed float64, wait time.Duration) error {
position, err := GetPosition(device, token)
if position.PanTilt.Y >= tilt-0.005 && position.PanTilt.Y <= tilt+0.005 {
} else {
// We'll need to determine if we need to move CW or CCW.
// Check the current position and compare it with the desired position.
directionY := speed
if position.PanTilt.Y > tilt {
directionY = speed * -1
}
panTiltVector := xsdonvif.Vector2D{
X: 0,
Y: directionY,
Space: configuration.PTZConfiguration[0].DefaultContinuousPanTiltVelocitySpace,
}
velocity := xsdonvif.PTZSpeedPanTilt{
PanTilt: panTiltVector,
}
resp, err := device.CallMethod(ptz.ContinuousMove{
ProfileToken: &token,
Velocity: velocity,
})
err = handleONVIFResponse("continuous_tilt", resp, err)
// While moving we'll check if we reached the desired position.
// or if we overshot the desired position.
// Break after 3seconds
now := time.Now()
for {
position, _ := GetPosition(device, token)
if position.PanTilt.Y == -1 || position.PanTilt.Y == 1 || (directionY > 0 && position.PanTilt.Y >= tilt) || (directionY < 0 && position.PanTilt.Y <= tilt) || (position.PanTilt.Y >= tilt-0.005 && position.PanTilt.Y <= tilt+0.005) {
break
}
if time.Since(now) > 3*time.Second {
break
}
time.Sleep(wait)
}
_, err = device.CallMethod(ptz.Stop{
ProfileToken: token,
PanTilt: true,
Zoom: true,
})
if err != nil {
log.Error("ContinuousPanTiltMove (Tilt): " + err.Error())
}
}
return err
}
func ZoomUntilPosition(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, zoom float64, speed float64, wait time.Duration) error {
position, err := GetPosition(device, token)
if position.Zoom.X >= zoom-0.005 && position.Zoom.X <= zoom+0.005 {
} else {
// We'll need to determine if we need to move CW or CCW.
// Check the current position and compare it with the desired position.
directionZ := speed
if position.Zoom.X > zoom {
directionZ = speed * -1
}
zoomVector := xsdonvif.Vector1D{
X: directionZ,
Space: configuration.PTZConfiguration[0].DefaultContinuousZoomVelocitySpace,
}
resp, err := device.CallMethod(ptz.ContinuousMove{
ProfileToken: &token,
Velocity: xsdonvif.PTZSpeedZoom{
Zoom: zoomVector,
},
})
err = handleONVIFResponse("continuous_zoom_to_position", resp, err)
// While moving we'll check if we reached the desired position.
// or if we overshot the desired position.
// Break after 3seconds
now := time.Now()
for {
position, _ := GetPosition(device, token)
if position.Zoom.X == -1 || position.Zoom.X == 1 || (directionZ > 0 && position.Zoom.X >= zoom) || (directionZ < 0 && position.Zoom.X <= zoom) || (position.Zoom.X >= zoom-0.005 && position.Zoom.X <= zoom+0.005) {
break
}
if time.Since(now) > 3*time.Second {
break
}
time.Sleep(wait)
}
_, err = device.CallMethod(ptz.Stop{
ProfileToken: token,
PanTilt: true,
Zoom: true,
})
if err != nil {
log.Error("ContinuousPanTiltMove (Zoom): " + err.Error())
}
}
return err
} }
func ContinuousPanTilt(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, pan float64, tilt float64) error { func ContinuousPanTilt(device *onvif.Device, configuration ptz.GetConfigurationsResponse, token xsdonvif.ReferenceToken, pan float64, tilt float64) error {
@@ -883,12 +801,12 @@ func GetCapabilitiesFromDevice(dev *onvif.Device) []string {
return capabilities return capabilities
} }
func GetPresetsFromDevice(device *onvif.Device, channel int) ([]models.OnvifActionPreset, error) { func GetPresetsFromDevice(device *onvif.Device) ([]models.OnvifActionPreset, error) {
var presets []models.OnvifActionPreset var presets []models.OnvifActionPreset
var presetsResponse ptz.GetPresetsResponse var presetsResponse ptz.GetPresetsResponse
// Get the profile token of the requested channel // Get token from the first profile
token, err := GetTokenFromChannel(device, channel) token, err := GetTokenFromProfile(device, 0)
if err == nil { if err == nil {
resp, err := device.CallMethod(ptz.GetPresets{ resp, err := device.CallMethod(ptz.GetPresets{
ProfileToken: token, ProfileToken: token,
@@ -933,11 +851,11 @@ func GetPresetsFromDevice(device *onvif.Device, channel int) ([]models.OnvifActi
return presets, err return presets, err
} }
func GoToPresetFromDevice(device *onvif.Device, channel int, presetName string) error { func GoToPresetFromDevice(device *onvif.Device, presetName string) error {
var goToPresetResponse ptz.GotoPresetResponse var goToPresetResponse ptz.GotoPresetResponse
// Get the profile token of the requested channel // Get token from the first profile
token, err := GetTokenFromChannel(device, channel) token, err := GetTokenFromProfile(device, 0)
if err == nil { if err == nil {
preset := xsdonvif.ReferenceToken(presetName) preset := xsdonvif.ReferenceToken(presetName)
resp, err := device.CallMethod(ptz.GotoPreset{ resp, err := device.CallMethod(ptz.GotoPreset{
@@ -977,10 +895,6 @@ func GetPTZFunctionsFromDevice(configurations ptz.GetConfigurationsResponse) ([]
canZoom := false canZoom := false
canPanTilt := false canPanTilt := false
if len(configurations.PTZConfiguration) == 0 {
return functions, canZoom, canPanTilt
}
if configurations.PTZConfiguration[0].DefaultAbsolutePantTiltPositionSpace != nil { if configurations.PTZConfiguration[0].DefaultAbsolutePantTiltPositionSpace != nil {
functions = append(functions, "AbsolutePanTiltMove") functions = append(functions, "AbsolutePanTiltMove")
canPanTilt = true canPanTilt = true
@@ -1040,7 +954,6 @@ func VerifyOnvifConnection(c *gin.Context) {
ONVIFXAddr: onvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifCredentials.ONVIFUsername, ONVIFUsername: onvifCredentials.ONVIFUsername,
ONVIFPassword: onvifCredentials.ONVIFPassword, ONVIFPassword: onvifCredentials.ONVIFPassword,
ONVIFChannel: onvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -1049,8 +962,8 @@ func VerifyOnvifConnection(c *gin.Context) {
cameraConfiguration := configuration.Config.Capture.IPCamera cameraConfiguration := configuration.Config.Capture.IPCamera
device, capabilities, err := ConnectToOnvifDevice(&cameraConfiguration) device, capabilities, err := ConnectToOnvifDevice(&cameraConfiguration)
if err == nil { if err == nil {
// Get the profile token of the requested channel // Get token from the first profile
token, err := GetTokenFromChannel(device, cameraConfiguration.ONVIFChannel) token, err := GetTokenFromProfile(device, 0)
if err == nil { if err == nil {
c.JSON(200, gin.H{ c.JSON(200, gin.H{
"device": device, "device": device,
@@ -1129,23 +1042,6 @@ func CreatePullPointSubscription(dev *onvif.Device) (string, error) {
return pullPointAdress, err return pullPointAdress, err
} }
const (
wsAddressingNamespace = "http://www.w3.org/2005/08/addressing"
pullMessagesAction = "http://www.onvif.org/ver10/events/wsdl/PullPointSubscription/PullMessagesRequest"
unsubscribeAction = "http://docs.oasis-open.org/wsn/bw-2/SubscriptionManager/UnsubscribeRequest"
)
// subscriptionAddressingHeader builds the WS-Addressing Action and To headers
// for a request sent to a pull-point subscription. Some devices identify the
// subscription from wsa:To rather than the request URL, and reject requests
// without it as NotAuthorized.
func subscriptionAddressingHeader(subscriptionAddress string, action string) string {
var address bytes.Buffer
_ = xml.EscapeText(&address, []byte(subscriptionAddress))
return `<wsa:Action xmlns:wsa="` + wsAddressingNamespace + `">` + action + `</wsa:Action>` +
`<wsa:To xmlns:wsa="` + wsAddressingNamespace + `">` + address.String() + `</wsa:To>`
}
func UnsubscribePullPoint(dev *onvif.Device, pullPointAddress string) error { func UnsubscribePullPoint(dev *onvif.Device, pullPointAddress string) error {
// Unsubscribe from the device // Unsubscribe from the device
@@ -1159,7 +1055,7 @@ func UnsubscribePullPoint(dev *onvif.Device, pullPointAddress string) error {
return err return err
} }
res, err := dev.SendSoapWithHeader(pullPointAddress, string(requestBody), subscriptionAddressingHeader(pullPointAddress, unsubscribeAction)) res, err := dev.SendSoap(pullPointAddress, string(requestBody))
if err != nil { if err != nil {
log.WithError(err).WithFields(log.Fields{ log.WithError(err).WithFields(log.Fields{
"component": "onvif", "component": "onvif",
@@ -1241,7 +1137,7 @@ func GetEventMessages(dev *onvif.Device, pullPointAddress string) ([]ONVIFEvents
log.Error("onvif.main.GetEventMessages(pullMessages): " + err.Error()) log.Error("onvif.main.GetEventMessages(pullMessages): " + err.Error())
return eventsArray, err return eventsArray, err
} }
res, err := dev.SendSoapWithHeader(string(subscriptionURI), string(requestBody), subscriptionAddressingHeader(subscriptionURI, pullMessagesAction)) res, err := dev.SendSoap(string(subscriptionURI), string(requestBody))
if err != nil { if err != nil {
log.Error("onvif.main.GetEventMessages(pullMessages): " + err.Error()) log.Error("onvif.main.GetEventMessages(pullMessages): " + err.Error())
return eventsArray, err return eventsArray, err
-264
View File
@@ -1,264 +0,0 @@
package onvif
import (
"encoding/xml"
"errors"
"strings"
"testing"
"time"
"github.com/kerberos-io/onvif/ptz"
xsdonvif "github.com/kerberos-io/onvif/xsd/onvif"
)
type fakePTZMoveClient struct {
current ptzTarget
target ptzTarget
lastVelocity ptzVelocity
absoluteErr error
continuousErr error
stopErr error
ignoreAbsolute bool
stalled bool
incompletePosition bool
positionErr error
positionErrAtCall int
positionCalls int
absoluteCalls int
continuousVelocities []ptzVelocity
stopCalls int
moving bool
}
func (client *fakePTZMoveClient) GetPosition() (xsdonvif.PTZVector, error) {
client.positionCalls++
if client.positionErr != nil && client.positionCalls == client.positionErrAtCall {
return xsdonvif.PTZVector{}, client.positionErr
}
if client.moving && !client.stalled {
client.current.Pan = moveFakeAxis(client.current.Pan, client.target.Pan, client.lastVelocity.Pan)
client.current.Tilt = moveFakeAxis(client.current.Tilt, client.target.Tilt, client.lastVelocity.Tilt)
client.current.Zoom = moveFakeAxis(client.current.Zoom, client.target.Zoom, client.lastVelocity.Zoom)
}
panTilt := &xsdonvif.Vector2D{X: client.current.Pan, Y: client.current.Tilt}
if client.incompletePosition {
return xsdonvif.PTZVector{PanTilt: panTilt}, nil
}
return xsdonvif.PTZVector{
PanTilt: panTilt,
Zoom: &xsdonvif.Vector1D{X: client.current.Zoom},
}, nil
}
func (client *fakePTZMoveClient) AbsoluteMove(target ptzTarget) error {
client.absoluteCalls++
client.target = target
if client.absoluteErr != nil {
return client.absoluteErr
}
if !client.ignoreAbsolute {
client.current = target
}
return nil
}
func (client *fakePTZMoveClient) ContinuousMove(velocity ptzVelocity) error {
if client.continuousErr != nil {
return client.continuousErr
}
client.lastVelocity = velocity
client.continuousVelocities = append(client.continuousVelocities, velocity)
client.moving = true
return nil
}
func (client *fakePTZMoveClient) Stop() error {
client.stopCalls++
client.moving = false
return client.stopErr
}
func moveFakeAxis(current float64, target float64, velocity float64) float64 {
step := velocity * 0.5
if step == 0 {
return current
}
next := current + step
if (velocity > 0 && next >= target) || (velocity < 0 && next <= target) {
return target
}
return next
}
func testPTZMoveOptions() ptzMoveOptions {
options := defaultPTZMoveOptions
options.NativeTimeout = 50 * time.Millisecond
options.ContinuousTimeout = 100 * time.Millisecond
options.NoProgressTimeout = 10 * time.Millisecond
options.PollInterval = time.Millisecond
options.ProgressEpsilon = 0.0001
options.VelocityChange = 0.01
return options
}
func TestMoveToPositionUsesVerifiedNativeMove(t *testing.T) {
target := ptzTarget{Pan: 0.5, Tilt: -0.25, Zoom: 0.4}
client := &fakePTZMoveClient{}
err := moveToPosition(client, ptzMoveSupport{Absolute: true, Continuous: true}, target, testPTZMoveOptions())
if err != nil {
t.Fatalf("moveToPosition() error = %v", err)
}
if client.absoluteCalls != 1 {
t.Fatalf("absolute calls = %d, want 1", client.absoluteCalls)
}
if len(client.continuousVelocities) != 0 {
t.Fatalf("continuous calls = %d, want 0", len(client.continuousVelocities))
}
}
func TestMoveToPositionFallsBackToSimultaneousContinuousMove(t *testing.T) {
target := ptzTarget{Pan: 0.5, Tilt: -0.25, Zoom: 0.4}
client := &fakePTZMoveClient{
target: target,
absoluteErr: errors.New("absolute move rejected"),
}
err := moveToPosition(client, ptzMoveSupport{Absolute: true, Continuous: true}, target, testPTZMoveOptions())
if err != nil {
t.Fatalf("moveToPosition() error = %v", err)
}
if len(client.continuousVelocities) == 0 {
t.Fatal("continuous fallback was not used")
}
first := client.continuousVelocities[0]
if first.Pan == 0 || first.Tilt == 0 || first.Zoom == 0 {
t.Fatalf("first fallback velocity = %+v, want all axes moving", first)
}
if client.stopCalls != 2 {
t.Fatalf("stop calls = %d, want native cleanup and fallback cleanup", client.stopCalls)
}
}
func TestMoveToPositionFallsBackWhenNativeMoveMakesNoProgress(t *testing.T) {
target := ptzTarget{Pan: 0.3, Tilt: 0.2, Zoom: 0.1}
client := &fakePTZMoveClient{
target: target,
ignoreAbsolute: true,
}
options := testPTZMoveOptions()
options.NoProgressTimeout = 3 * time.Millisecond
err := moveToPosition(client, ptzMoveSupport{Absolute: true, Continuous: true}, target, options)
if err != nil {
t.Fatalf("moveToPosition() error = %v", err)
}
if len(client.continuousVelocities) == 0 {
t.Fatal("continuous fallback was not used")
}
}
func TestMoveToPositionStopsAfterContinuousStatusError(t *testing.T) {
target := ptzTarget{Pan: 0.3, Tilt: 0.2, Zoom: 0.1}
client := &fakePTZMoveClient{
target: target,
positionErr: errors.New("status unavailable"),
positionErrAtCall: 3,
}
err := moveToPosition(client, ptzMoveSupport{Continuous: true}, target, testPTZMoveOptions())
if err == nil || !strings.Contains(err.Error(), "status unavailable") {
t.Fatalf("moveToPosition() error = %v, want status error", err)
}
if client.stopCalls != 1 {
t.Fatalf("stop calls = %d, want 1", client.stopCalls)
}
}
func TestMoveToPositionStopsWhenContinuousMoveIsRejected(t *testing.T) {
target := ptzTarget{Pan: 0.3, Tilt: 0.2, Zoom: 0.1}
client := &fakePTZMoveClient{
target: target,
continuousErr: errors.New("continuous move rejected"),
}
err := moveToPosition(client, ptzMoveSupport{Continuous: true}, target, testPTZMoveOptions())
if err == nil || !strings.Contains(err.Error(), "continuous move rejected") {
t.Fatalf("moveToPosition() error = %v, want movement error", err)
}
if client.stopCalls != 1 {
t.Fatalf("stop calls = %d, want 1", client.stopCalls)
}
}
func TestMoveToPositionReturnsNoProgressErrorAndStops(t *testing.T) {
target := ptzTarget{Pan: 0.3, Tilt: 0.2, Zoom: 0.1}
client := &fakePTZMoveClient{
target: target,
stalled: true,
}
options := testPTZMoveOptions()
options.NoProgressTimeout = 3 * time.Millisecond
err := moveToPosition(client, ptzMoveSupport{Continuous: true}, target, options)
if err == nil || !strings.Contains(err.Error(), "made no progress") {
t.Fatalf("moveToPosition() error = %v, want no-progress error", err)
}
if client.stopCalls != 1 {
t.Fatalf("stop calls = %d, want 1", client.stopCalls)
}
}
func TestMoveToPositionReturnsDeadlineErrorAndStops(t *testing.T) {
target := ptzTarget{Pan: 100, Tilt: 100, Zoom: 100}
client := &fakePTZMoveClient{target: target}
options := testPTZMoveOptions()
options.ContinuousTimeout = 3 * time.Millisecond
options.NoProgressTimeout = 50 * time.Millisecond
err := moveToPosition(client, ptzMoveSupport{Continuous: true}, target, options)
if err == nil || !strings.Contains(err.Error(), "target not reached within") {
t.Fatalf("moveToPosition() error = %v, want deadline error", err)
}
if client.stopCalls != 1 {
t.Fatalf("stop calls = %d, want 1", client.stopCalls)
}
}
func TestMoveToPositionRejectsIncompletePosition(t *testing.T) {
client := &fakePTZMoveClient{incompletePosition: true}
err := moveToPosition(client, ptzMoveSupport{Continuous: true}, ptzTarget{Pan: 0.1}, testPTZMoveOptions())
if err == nil || !strings.Contains(err.Error(), "incomplete PTZ position") {
t.Fatalf("moveToPosition() error = %v, want incomplete-position error", err)
}
}
func TestCombinedContinuousMoveVelocityIncludesEveryAxis(t *testing.T) {
request := ptz.ContinuousMove{
Velocity: ptz.Speed{
PanTilt: &xsdonvif.Vector2D{X: 0.5, Y: -0.25},
Zoom: &xsdonvif.Vector1D{X: 0.2},
},
}
encoded, err := xml.Marshal(request)
if err != nil {
t.Fatalf("xml.Marshal() error = %v", err)
}
xmlBody := string(encoded)
if !strings.Contains(xmlBody, `PanTilt x="0.5" y="-0.25"`) {
t.Fatalf("ContinuousMove XML = %s, want pan and tilt", xmlBody)
}
if !strings.Contains(xmlBody, `Zoom x="0.2"`) {
t.Fatalf("ContinuousMove XML = %s, want zoom", xmlBody)
}
}
func TestGetPTZFunctionsHandlesMissingConfiguration(t *testing.T) {
functions, canZoom, canPanTilt := GetPTZFunctionsFromDevice(ptz.GetConfigurationsResponse{})
if len(functions) != 0 || canZoom || canPanTilt {
t.Fatalf("GetPTZFunctionsFromDevice() = %v, %t, %t; want empty capabilities", functions, canZoom, canPanTilt)
}
}
-88
View File
@@ -1,88 +0,0 @@
package onvif
import (
"io"
"net/http"
"net/http/httptest"
"strings"
"sync"
"testing"
"github.com/kerberos-io/onvif"
)
// newSubscriptionTestDevice starts a fake ONVIF device and returns a connected
// device plus the request bodies it received on the subscription endpoint.
func newSubscriptionTestDevice(t *testing.T, response string) (*onvif.Device, string, func() []string) {
t.Helper()
var mu sync.Mutex
var subscriptionBodies []string
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
body, _ := io.ReadAll(r.Body)
if r.URL.Path == "/onvif/subscription" {
mu.Lock()
subscriptionBodies = append(subscriptionBodies, string(body))
mu.Unlock()
_, _ = w.Write([]byte(response))
return
}
_, _ = w.Write([]byte(`<Envelope><Body/></Envelope>`))
}))
t.Cleanup(srv.Close)
dev, err := onvif.NewDevice(onvif.DeviceParams{Xaddr: strings.TrimPrefix(srv.URL, "http://")})
if err != nil {
t.Fatalf("NewDevice() error = %v", err)
}
subscriptionAddress := srv.URL + "/onvif/subscription?subscription=7&idx=2"
return dev, subscriptionAddress, func() []string {
mu.Lock()
defer mu.Unlock()
return append([]string(nil), subscriptionBodies...)
}
}
func assertSubscriptionAddressing(t *testing.T, body string, action string) {
t.Helper()
for _, want := range []string{
`<wsa:Action xmlns:wsa="http://www.w3.org/2005/08/addressing">` + action + `</wsa:Action>`,
`<wsa:To xmlns:wsa="http://www.w3.org/2005/08/addressing">`,
`/onvif/subscription?subscription=7&amp;idx=2</wsa:To>`,
} {
if !strings.Contains(body, want) {
t.Fatalf("request body does not contain %q:\n%s", want, body)
}
}
}
// Some devices identify a pull-point subscription by wsa:To and reject
// PullMessages without it as NotAuthorized.
func TestGetEventMessagesSendsSubscriptionAddressingHeaders(t *testing.T) {
dev, subscriptionAddress, bodies := newSubscriptionTestDevice(t, `<Envelope><Body><PullMessagesResponse/></Body></Envelope>`)
if _, err := GetEventMessages(dev, subscriptionAddress); err != nil {
t.Fatalf("GetEventMessages() error = %v", err)
}
received := bodies()
if len(received) != 1 {
t.Fatalf("subscription requests = %d, want 1", len(received))
}
assertSubscriptionAddressing(t, received[0], pullMessagesAction)
}
func TestUnsubscribePullPointSendsSubscriptionAddressingHeaders(t *testing.T) {
dev, subscriptionAddress, bodies := newSubscriptionTestDevice(t, `<Envelope><Body><UnsubscribeResponse/></Body></Envelope>`)
if err := UnsubscribePullPoint(dev, subscriptionAddress); err != nil {
t.Fatalf("UnsubscribePullPoint() error = %v", err)
}
received := bodies()
if len(received) != 1 {
t.Fatalf("subscription requests = %d, want 1", len(received))
}
assertSubscriptionAddressing(t, received[0], unsubscribeAction)
}
+24 -24
View File
@@ -40,9 +40,6 @@ func NewQueue() *Queue {
} }
func (self *Queue) SetMaxGopCount(n int) { func (self *Queue) SetMaxGopCount(n int) {
if n < 1 {
n = 1
}
self.lock.Lock() self.lock.Lock()
self.maxgopcount = n self.maxgopcount = n
self.lock.Unlock() self.lock.Unlock()
@@ -100,31 +97,20 @@ func (self *Queue) WritePacket(pkt Packet) (err error) {
self.lock.Lock() self.lock.Lock()
self.buf.Push(pkt) self.buf.Push(pkt)
isVideoKeyframe := pkt.Idx == int8(self.videoidx) && pkt.IsKeyFrame if pkt.Idx == int8(self.videoidx) && pkt.IsKeyFrame {
if isVideoKeyframe {
self.curgopcount++ self.curgopcount++
}
for self.curgopcount > self.maxgopcount && self.buf.Count > 0 { for self.curgopcount >= self.maxgopcount && self.buf.Count > 1 {
for self.buf.Count > 0 { pkt := self.buf.Pop()
oldest := self.buf.Pop() if pkt.Idx == int8(self.videoidx) && pkt.IsKeyFrame {
if oldest.Idx == int8(self.videoidx) && oldest.IsKeyFrame { self.curgopcount--
self.curgopcount-- }
break if self.curgopcount < self.maxgopcount {
} break
}
// Discard the dependent frames from the evicted GOP as well. Keeping
// them would let an overrun cursor resume on a P-frame whose reference
// keyframe is no longer in the queue.
for self.buf.Count > 0 {
oldest := self.buf.Get(self.buf.Head)
if oldest.Idx == int8(self.videoidx) && oldest.IsKeyFrame {
break
}
self.buf.Pop()
}
} }
} }
//println("shrink", self.curgopcount, self.maxgopcount, self.buf.Head, self.buf.Tail, "count", self.buf.Count, "size", self.buf.Size)
self.cond.Broadcast() self.cond.Broadcast()
@@ -154,6 +140,20 @@ func (self *Queue) Latest() *QueueCursor {
return cursor return cursor
} }
// LatestAtCurrentTail returns a cursor fixed at the queue tail at call time.
// Unlike Latest, its start position is not deferred until the first read. This
// is used by command-driven consumers that must not skip packets arriving after
// a request was accepted but before their first blocking read begins.
func (self *Queue) LatestAtCurrentTail() *QueueCursor {
self.cond.L.Lock()
defer self.cond.L.Unlock()
return &QueueCursor{
que: self,
pos: self.buf.Tail,
gotpos: true,
}
}
// Create cursor position at oldest buffered packet. // Create cursor position at oldest buffered packet.
func (self *Queue) Oldest() *QueueCursor { func (self *Queue) Oldest() *QueueCursor {
cursor := self.newCursor() cursor := self.newCursor()
@@ -0,0 +1,20 @@
package packets
import "testing"
func TestLatestAtCurrentTailDoesNotSkipPacketWrittenAfterCreation(t *testing.T) {
queue := NewQueue()
defer queue.Close()
cursor := queue.LatestAtCurrentTail()
want := Packet{CurrentTime: 123, Data: []byte{1}}
if err := queue.WritePacket(want); err != nil {
t.Fatal(err)
}
got, err := cursor.ReadPacket()
if err != nil {
t.Fatal(err)
}
if got.CurrentTime != want.CurrentTime {
t.Fatalf("packet timestamp = %d, want %d", got.CurrentTime, want.CurrentTime)
}
}
-99
View File
@@ -107,102 +107,3 @@ func TestQueueCursorReadPacketContextDoesNotAllocateWhenPacketIsAvailable(t *tes
t.Fatalf("ReadPacketContext() allocations = %.2f, want 0", allocations) t.Fatalf("ReadPacketContext() allocations = %.2f, want 0", allocations)
} }
} }
func TestQueueEvictionKeepsKeyframeAtHead(t *testing.T) {
queue := NewQueue()
if err := queue.WriteHeader([]Stream{{Index: 0, IsVideo: true}}); err != nil {
t.Fatal(err)
}
queue.SetMaxGopCount(2)
for _, packet := range []Packet{
{Idx: 0, IsVideo: true, IsKeyFrame: true, Data: []byte("IDR-0")},
{Idx: 1, IsAudio: true, Data: []byte("audio-0")},
{Idx: 0, IsVideo: true, Data: []byte("P-0")},
{Idx: 0, IsVideo: true, IsKeyFrame: true, Data: []byte("IDR-1")},
{Idx: 0, IsVideo: true, Data: []byte("P-1")},
{Idx: 0, IsVideo: true, IsKeyFrame: true, Data: []byte("IDR-2")},
} {
if err := queue.WritePacket(packet); err != nil {
t.Fatal(err)
}
}
oldest, err := queue.Oldest().ReadPacket()
if err != nil {
t.Fatal(err)
}
if !oldest.IsKeyFrame || string(oldest.Data) != "IDR-1" {
t.Fatalf("oldest packet = %q (keyframe=%t), want IDR-1 keyframe", oldest.Data, oldest.IsKeyFrame)
}
}
func TestQueueWithSingleGOPRetainsCurrentKeyframe(t *testing.T) {
queue := NewQueue()
if err := queue.WriteHeader([]Stream{{Index: 0, IsVideo: true}}); err != nil {
t.Fatal(err)
}
queue.SetMaxGopCount(1)
for _, packet := range []Packet{
{Idx: 0, IsVideo: true, IsKeyFrame: true, Data: []byte("IDR-0")},
{Idx: 0, IsVideo: true, Data: []byte("P-0")},
{Idx: 0, IsVideo: true, IsKeyFrame: true, Data: []byte("IDR-1")},
} {
if err := queue.WritePacket(packet); err != nil {
t.Fatal(err)
}
}
oldest, err := queue.Oldest().ReadPacket()
if err != nil {
t.Fatal(err)
}
if !oldest.IsKeyFrame || string(oldest.Data) != "IDR-1" {
t.Fatalf("oldest packet = %q (keyframe=%t), want IDR-1 keyframe", oldest.Data, oldest.IsKeyFrame)
}
}
func TestLaggingQueueCursorResumesAtKeyframe(t *testing.T) {
queue := NewQueue()
if err := queue.WriteHeader([]Stream{{Index: 0, IsVideo: true}}); err != nil {
t.Fatal(err)
}
queue.SetMaxGopCount(2)
for _, packet := range []Packet{
{Idx: 0, IsVideo: true, IsKeyFrame: true, Data: []byte("IDR-0")},
{Idx: 0, IsVideo: true, Data: []byte("P-0")},
{Idx: 0, IsVideo: true, IsKeyFrame: true, Data: []byte("IDR-1")},
} {
if err := queue.WritePacket(packet); err != nil {
t.Fatal(err)
}
}
cursor := queue.Oldest()
first, err := cursor.ReadPacket()
if err != nil {
t.Fatal(err)
}
if string(first.Data) != "IDR-0" {
t.Fatalf("first packet = %q, want IDR-0", first.Data)
}
for _, packet := range []Packet{
{Idx: 0, IsVideo: true, Data: []byte("P-1")},
{Idx: 0, IsVideo: true, IsKeyFrame: true, Data: []byte("IDR-2")},
} {
if err := queue.WritePacket(packet); err != nil {
t.Fatal(err)
}
}
resumed, err := cursor.ReadPacket()
if err != nil {
t.Fatal(err)
}
if !resumed.IsKeyFrame || string(resumed.Data) != "IDR-1" {
t.Fatalf("resumed packet = %q (keyframe=%t), want IDR-1 keyframe", resumed.Data, resumed.IsKeyFrame)
}
}
+7 -5
View File
@@ -42,11 +42,12 @@ type HubHealth struct {
// Health describes the Agent process health exposed to API clients. // Health describes the Agent process health exposed to API clients.
type Health struct { type Health struct {
Description string `json:"description"` Description string `json:"description"`
CameraConnected bool `json:"cameraConnected"` CameraConnected bool `json:"cameraConnected"`
MainStream StreamHealth `json:"mainStream"` MainStream StreamHealth `json:"mainStream"`
SubStream StreamHealth `json:"subStream"` SubStream StreamHealth `json:"subStream"`
Hub HubHealth `json:"hub"` Hub HubHealth `json:"hub"`
FrameProcessing models.FrameProcessingRuntimeTelemetry `json:"frameProcessing"`
} }
// HealthResponseData contains the typed payload of a health response. // HealthResponseData contains the typed payload of a health response.
@@ -108,6 +109,7 @@ func buildHealth(communication *models.Communication, now time.Time) Health {
LastHeartbeatAttemptAt: hubTelemetry.LastHeartbeatAttemptAt, LastHeartbeatAttemptAt: hubTelemetry.LastHeartbeatAttemptAt,
LastSuccessfulHeartbeatAt: hubTelemetry.LastSuccessfulHeartbeatAt, LastSuccessfulHeartbeatAt: hubTelemetry.LastSuccessfulHeartbeatAt,
}, },
FrameProcessing: communication.FrameProcessingRuntimeTelemetry(),
} }
} }
@@ -35,6 +35,10 @@ func TestHealthCheckReturnsStandardPublicResponse(t *testing.T) {
communication.SetHubConfigured(true) communication.SetHubConfigured(true)
communication.RecordHubHeartbeatAttempt(now.Add(-2 * time.Second)) communication.RecordHubHeartbeatAttempt(now.Add(-2 * time.Second))
communication.RecordHubHeartbeatSuccess(now.Add(-time.Second)) communication.RecordHubHeartbeatSuccess(now.Add(-time.Second))
communication.SetFrameProcessingConfigured(true)
communication.RecordFrameProcessingSample()
communication.RecordFrameProcessingQueued(1, false)
communication.RecordFrameProcessingSuccess(now.Add(-time.Second))
router := gin.New() router := gin.New()
AddRoutes(router, authMiddleware, "", nil, communication, nil) AddRoutes(router, authMiddleware, "", nil, communication, nil)
@@ -101,6 +105,9 @@ func TestHealthCheckReturnsStandardPublicResponse(t *testing.T) {
if !health.Hub.Configured || !health.Hub.Connected { if !health.Hub.Configured || !health.Hub.Connected {
t.Errorf("data.health.hub = %+v, want configured and connected", health.Hub) t.Errorf("data.health.hub = %+v, want configured and connected", health.Hub)
} }
if !health.FrameProcessing.Configured || health.FrameProcessing.Sampled != 1 || health.FrameProcessing.Submitted != 1 {
t.Errorf("data.health.frameProcessing = %+v", health.FrameProcessing)
}
} }
func TestBuildHealthMarksStaleHubHeartbeatDisconnected(t *testing.T) { func TestBuildHealthMarksStaleHubHeartbeatDisconnected(t *testing.T) {
+8 -66
View File
@@ -1,7 +1,6 @@
package http package http
import ( import (
"errors"
"strconv" "strconv"
"strings" "strings"
"time" "time"
@@ -75,7 +74,6 @@ func LoginToOnvif(c *gin.Context) {
ONVIFXAddr: onvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifCredentials.ONVIFUsername, ONVIFUsername: onvifCredentials.ONVIFUsername,
ONVIFPassword: onvifCredentials.ONVIFPassword, ONVIFPassword: onvifCredentials.ONVIFPassword,
ONVIFChannel: onvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -84,8 +82,8 @@ func LoginToOnvif(c *gin.Context) {
cameraConfiguration := configuration.Config.Capture.IPCamera cameraConfiguration := configuration.Config.Capture.IPCamera
device, capabilities, err := onvif.ConnectToOnvifDevice(&cameraConfiguration) device, capabilities, err := onvif.ConnectToOnvifDevice(&cameraConfiguration)
if err == nil { if err == nil {
// Get the profile token of the requested channel // Get token from the first profile
token, err := onvif.GetTokenFromChannel(device, cameraConfiguration.ONVIFChannel) token, err := onvif.GetTokenFromProfile(device, 0)
if err == nil { if err == nil {
c.JSON(200, gin.H{ c.JSON(200, gin.H{
"device": device, "device": device,
@@ -130,7 +128,6 @@ func GetOnvifCapabilities(c *gin.Context) {
ONVIFXAddr: onvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifCredentials.ONVIFUsername, ONVIFUsername: onvifCredentials.ONVIFUsername,
ONVIFPassword: onvifCredentials.ONVIFPassword, ONVIFPassword: onvifCredentials.ONVIFPassword,
ONVIFChannel: onvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -175,7 +172,6 @@ func DoOnvifPanTilt(c *gin.Context) {
ONVIFXAddr: onvifPanTilt.OnvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifPanTilt.OnvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifPanTilt.OnvifCredentials.ONVIFUsername, ONVIFUsername: onvifPanTilt.OnvifCredentials.ONVIFUsername,
ONVIFPassword: onvifPanTilt.OnvifCredentials.ONVIFPassword, ONVIFPassword: onvifPanTilt.OnvifCredentials.ONVIFPassword,
ONVIFChannel: onvifPanTilt.OnvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -185,8 +181,8 @@ func DoOnvifPanTilt(c *gin.Context) {
device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration) device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration)
if err == nil { if err == nil {
// Get the profile token of the requested channel // Get token from the first profile
token, err := onvif.GetTokenFromChannel(device, cameraConfiguration.ONVIFChannel) token, err := onvif.GetTokenFromProfile(device, 0)
if err == nil { if err == nil {
@@ -250,7 +246,6 @@ func DoOnvifZoom(c *gin.Context) {
ONVIFXAddr: onvifZoom.OnvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifZoom.OnvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifZoom.OnvifCredentials.ONVIFUsername, ONVIFUsername: onvifZoom.OnvifCredentials.ONVIFUsername,
ONVIFPassword: onvifZoom.OnvifCredentials.ONVIFPassword, ONVIFPassword: onvifZoom.OnvifCredentials.ONVIFPassword,
ONVIFChannel: onvifZoom.OnvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -260,8 +255,8 @@ func DoOnvifZoom(c *gin.Context) {
device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration) device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration)
if err == nil { if err == nil {
// Get the profile token of the requested channel // Get token from the first profile
token, err := onvif.GetTokenFromChannel(device, cameraConfiguration.ONVIFChannel) token, err := onvif.GetTokenFromProfile(device, 0)
if err == nil { if err == nil {
@@ -303,54 +298,6 @@ func DoOnvifZoom(c *gin.Context) {
} }
} }
// DoOnvifFocus godoc
// @Router /api/camera/onvif/focus [post]
// @ID camera-onvif-focus
// @Tags onvif
// @Param focus body models.OnvifFocus true "OnvifFocus"
// @Summary Focusing the camera near or far.
// @Description Focusing the camera near (positive) or far (negative).
// @Success 200 {object} models.APIResponse
func DoOnvifFocus(c *gin.Context) {
var onvifFocus models.OnvifFocus
err := c.BindJSON(&onvifFocus)
if err == nil && onvifFocus.OnvifCredentials.ONVIFXAddr == "" {
err = errors.New("missing onvif_xaddr")
}
if err == nil {
cameraConfiguration := models.IPCamera{
ONVIFXAddr: onvifFocus.OnvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifFocus.OnvifCredentials.ONVIFUsername,
ONVIFPassword: onvifFocus.OnvifCredentials.ONVIFPassword,
ONVIFChannel: onvifFocus.OnvifCredentials.ONVIFChannel,
}
device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration)
if err == nil {
err := onvif.ContinuousFocus(device, cameraConfiguration.ONVIFChannel, onvifFocus.Focus)
if err == nil {
c.JSON(200, models.APIResponse{
Message: "Successfully focused the camera",
})
} else {
c.JSON(400, models.APIResponse{
Message: "Something went wrong: " + err.Error(),
})
}
} else {
c.JSON(400, models.APIResponse{
Message: "Something went wrong: " + err.Error(),
})
}
} else {
c.JSON(400, models.APIResponse{
Message: "Something went wrong: " + err.Error(),
})
}
}
// GetOnvifPresets godoc // GetOnvifPresets godoc
// @Router /api/camera/onvif/presets [post] // @Router /api/camera/onvif/presets [post]
// @ID camera-onvif-presets // @ID camera-onvif-presets
@@ -372,7 +319,6 @@ func GetOnvifPresets(c *gin.Context) {
ONVIFXAddr: onvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifCredentials.ONVIFUsername, ONVIFUsername: onvifCredentials.ONVIFUsername,
ONVIFPassword: onvifCredentials.ONVIFPassword, ONVIFPassword: onvifCredentials.ONVIFPassword,
ONVIFChannel: onvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -381,7 +327,7 @@ func GetOnvifPresets(c *gin.Context) {
cameraConfiguration := configuration.Config.Capture.IPCamera cameraConfiguration := configuration.Config.Capture.IPCamera
device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration) device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration)
if err == nil { if err == nil {
presets, err := onvif.GetPresetsFromDevice(device, cameraConfiguration.ONVIFChannel) presets, err := onvif.GetPresetsFromDevice(device)
if err == nil { if err == nil {
c.JSON(200, gin.H{ c.JSON(200, gin.H{
"presets": presets, "presets": presets,
@@ -424,7 +370,6 @@ func GoToOnvifPreset(c *gin.Context) {
ONVIFXAddr: onvifPreset.OnvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifPreset.OnvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifPreset.OnvifCredentials.ONVIFUsername, ONVIFUsername: onvifPreset.OnvifCredentials.ONVIFUsername,
ONVIFPassword: onvifPreset.OnvifCredentials.ONVIFPassword, ONVIFPassword: onvifPreset.OnvifCredentials.ONVIFPassword,
ONVIFChannel: onvifPreset.OnvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -433,7 +378,7 @@ func GoToOnvifPreset(c *gin.Context) {
cameraConfiguration := configuration.Config.Capture.IPCamera cameraConfiguration := configuration.Config.Capture.IPCamera
device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration) device, _, err := onvif.ConnectToOnvifDevice(&cameraConfiguration)
if err == nil { if err == nil {
err := onvif.GoToPresetFromDevice(device, cameraConfiguration.ONVIFChannel, onvifPreset.Preset) err := onvif.GoToPresetFromDevice(device, onvifPreset.Preset)
if err == nil { if err == nil {
c.JSON(200, gin.H{ c.JSON(200, gin.H{
"data": "Camera preset activated: " + onvifPreset.Preset, "data": "Camera preset activated: " + onvifPreset.Preset,
@@ -480,7 +425,6 @@ func DoGetDigitalInputs(c *gin.Context) {
ONVIFXAddr: onvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifCredentials.ONVIFUsername, ONVIFUsername: onvifCredentials.ONVIFUsername,
ONVIFPassword: onvifCredentials.ONVIFPassword, ONVIFPassword: onvifCredentials.ONVIFPassword,
ONVIFChannel: onvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -570,7 +514,6 @@ func DoGetRelayOutputs(c *gin.Context) {
ONVIFXAddr: onvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifCredentials.ONVIFUsername, ONVIFUsername: onvifCredentials.ONVIFUsername,
ONVIFPassword: onvifCredentials.ONVIFPassword, ONVIFPassword: onvifCredentials.ONVIFPassword,
ONVIFChannel: onvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -644,7 +587,6 @@ func DoTriggerRelayOutput(c *gin.Context) {
ONVIFXAddr: onvifCredentials.ONVIFXAddr, ONVIFXAddr: onvifCredentials.ONVIFXAddr,
ONVIFUsername: onvifCredentials.ONVIFUsername, ONVIFUsername: onvifCredentials.ONVIFUsername,
ONVIFPassword: onvifCredentials.ONVIFPassword, ONVIFPassword: onvifCredentials.ONVIFPassword,
ONVIFChannel: onvifCredentials.ONVIFChannel,
}, },
}, },
}, },
@@ -1,81 +0,0 @@
package http
import (
"net/http/httptest"
"os"
"path/filepath"
"testing"
"github.com/gin-gonic/gin"
"github.com/kerberos-io/agent/machinery/src/encryption"
"github.com/kerberos-io/agent/machinery/src/models"
)
func TestFilesServesFlatAndDatedRecordings(t *testing.T) {
gin.SetMode(gin.TestMode)
for _, layout := range []string{"flat", "dated"} {
for _, encrypted := range []bool{false, true} {
name := layout + "-plain"
if encrypted {
name = layout + "-encrypted"
}
t.Run(name, func(t *testing.T) {
const fileName = "1767355200123-device-key.mp4"
directory := t.TempDir()
relativePath := fileName
if layout == "dated" {
relativePath = "2026/01/02/" + fileName
}
filePath := filepath.Join(directory, "data/recordings", relativePath)
if err := os.MkdirAll(filepath.Dir(filePath), 0o755); err != nil {
t.Fatal(err)
}
config := &models.Configuration{Config: models.Config{Encryption: &models.Encryption{}}}
content := []byte("recording-payload")
if encrypted {
config.Config.Encryption.Recordings = "true"
config.Config.Encryption.SymmetricKey = "0123456789abcdef0123456789abcdef"
ciphertext, err := encryption.AesEncrypt(content, config.Config.Encryption.SymmetricKey)
if err != nil {
t.Fatal(err)
}
content = []byte(ciphertext)
}
if err := os.WriteFile(filePath, content, 0o644); err != nil {
t.Fatal(err)
}
router := gin.New()
router.GET("/file/*filepath", func(c *gin.Context) { Files(c, directory, config) })
for _, reference := range []string{relativePath, fileName} {
response := httptest.NewRecorder()
router.ServeHTTP(response, httptest.NewRequest("GET", "/file/"+reference, nil))
if response.Code != 200 || response.Body.String() != "recording-payload" {
t.Fatalf("GET %s = %d %q", reference, response.Code, response.Body.String())
}
if got := response.Header().Get("Content-Type"); got != "video/mp4" {
t.Fatalf("Content-Type = %q, want video/mp4", got)
}
}
})
}
}
}
func TestFilesRejectsMissingAndOutsideRecordings(t *testing.T) {
directory := t.TempDir()
if err := os.MkdirAll(filepath.Join(directory, "data/recordings"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(directory, "data/outside.mp4"), []byte("not a recording"), 0o644); err != nil {
t.Fatal(err)
}
router := gin.New()
router.GET("/file/*filepath", func(c *gin.Context) { Files(c, directory, &models.Configuration{}) })
for _, reference := range []string{"missing.mp4", "../outside.mp4", "2026/01/02/missing.mp4"} {
response := httptest.NewRecorder()
router.ServeHTTP(response, httptest.NewRequest("GET", "/file/"+reference, nil))
if response.Code != 404 {
t.Fatalf("GET %s = %d, want 404", reference, response.Code)
}
}
}
+2 -3
View File
@@ -65,12 +65,12 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
// Will verify the hub settings. // Will verify the hub settings.
api.POST("/hub/verify", func(c *gin.Context) { api.POST("/hub/verify", func(c *gin.Context) {
cloud.VerifyHub(c, configuration.Config.HubURI) cloud.VerifyHub(c)
}) })
// Will verify the persistence settings. // Will verify the persistence settings.
api.POST("/persistence/verify", func(c *gin.Context) { api.POST("/persistence/verify", func(c *gin.Context) {
cloud.VerifyPersistence(c, configDirectory, configuration.Config.HubURI) cloud.VerifyPersistence(c, configDirectory)
}) })
// Will verify the secondary persistence settings. // Will verify the secondary persistence settings.
@@ -108,7 +108,6 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
api.POST("/camera/onvif/gotopreset", GoToOnvifPreset) api.POST("/camera/onvif/gotopreset", GoToOnvifPreset)
api.POST("/camera/onvif/pantilt", DoOnvifPanTilt) api.POST("/camera/onvif/pantilt", DoOnvifPanTilt)
api.POST("/camera/onvif/zoom", DoOnvifZoom) api.POST("/camera/onvif/zoom", DoOnvifZoom)
api.POST("/camera/onvif/focus", DoOnvifFocus)
api.POST("/camera/onvif/inputs", DoGetDigitalInputs) api.POST("/camera/onvif/inputs", DoGetDigitalInputs)
api.POST("/camera/onvif/outputs", DoGetRelayOutputs) api.POST("/camera/onvif/outputs", DoGetRelayOutputs)
api.POST("/camera/onvif/outputs/:output", DoTriggerRelayOutput) api.POST("/camera/onvif/outputs/:output", DoTriggerRelayOutput)
+2 -4
View File
@@ -5,7 +5,6 @@ import (
"io" "io"
"os" "os"
"strconv" "strconv"
"strings"
"time" "time"
jwt "github.com/appleboy/gin-jwt/v2" jwt "github.com/appleboy/gin-jwt/v2"
@@ -20,7 +19,6 @@ import (
"github.com/kerberos-io/agent/machinery/src/capture" "github.com/kerberos-io/agent/machinery/src/capture"
"github.com/kerberos-io/agent/machinery/src/encryption" "github.com/kerberos-io/agent/machinery/src/encryption"
"github.com/kerberos-io/agent/machinery/src/models" "github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/utils"
swaggerFiles "github.com/swaggo/files" swaggerFiles "github.com/swaggo/files"
ginSwagger "github.com/swaggo/gin-swagger" ginSwagger "github.com/swaggo/gin-swagger"
) )
@@ -162,9 +160,9 @@ func requestLogger() gin.HandlerFunc {
func Files(c *gin.Context, configDirectory string, configuration *models.Configuration) { func Files(c *gin.Context, configDirectory string, configuration *models.Configuration) {
// Get File // Get File
filePath, err := utils.ResolveRecordingPath(configDirectory+"/data/recordings", strings.TrimPrefix(c.Param("filepath"), "/")) filePath := configDirectory + "/data/recordings" + c.Param("filepath")
_, err := os.Open(filePath)
if err != nil { if err != nil {
log.WithError(err).Warn("Could not resolve recording for playback")
c.JSON(404, gin.H{"error": "File not found"}) c.JSON(404, gin.H{"error": "File not found"})
return return
} }
+103
View File
@@ -1,6 +1,7 @@
package mqtt package mqtt
import ( import (
"bytes"
"context" "context"
"crypto/rsa" "crypto/rsa"
"crypto/tls" "crypto/tls"
@@ -8,6 +9,7 @@ import (
"encoding/base64" "encoding/base64"
"encoding/json" "encoding/json"
"encoding/pem" "encoding/pem"
"errors"
"fmt" "fmt"
"io/ioutil" "io/ioutil"
"math/rand" "math/rand"
@@ -578,6 +580,8 @@ func MQTTListenerHandler(mqttClient mqtt.Client, hubKey string, configDirectory
go HandleReceiveHDCandidates(mqttClient, hubKey, payload, configuration, communication) go HandleReceiveHDCandidates(mqttClient, hubKey, payload, configuration, communication)
case "trigger-relay": case "trigger-relay":
go HandleTriggerRelay(mqttClient, hubKey, payload, configuration, communication) go HandleTriggerRelay(mqttClient, hubKey, payload, configuration, communication)
case "capture-frame":
HandleCaptureFrame(mqttClient, hubKey, payload, remoteAuthenticated, configuration, communication)
case "remote-session-open": case "remote-session-open":
go HandleRemoteSessionOpen(mqttClient, hubKey, payload, remoteAuthenticated, configuration) go HandleRemoteSessionOpen(mqttClient, hubKey, payload, remoteAuthenticated, configuration)
case "remote-session-input": case "remote-session-input":
@@ -606,6 +610,105 @@ func MQTTListenerHandler(mqttClient mqtt.Client, hubKey string, configDirectory
} }
} }
func HandleCaptureFrame(mqttClient mqtt.Client, hubKey string, payload models.Payload, remoteAuthenticated bool, configuration *models.Configuration, communication *models.Communication) {
request, err := decodeFrameProcessingRequest(payload)
if err != nil {
log.WithError(err).WithFields(log.Fields{
"component": "routers/mqtt",
"event": "capture_frame_rejected",
}).Warn("Rejected invalid capture-frame command")
return
}
config := configuration.Config
if !frameProcessingCommandAuthenticated(config, remoteAuthenticated) {
log.WithFields(log.Fields{
"component": "routers/mqtt",
"event": "capture_frame_rejected",
"request_id": request.RequestID,
}).Warn("Rejected unauthenticated capture-frame command")
return
}
status := "accepted"
message := ""
frameProcessing := config.FrameProcessing
if frameProcessing == nil || frameProcessing.Enabled != "true" || frameProcessing.AllowRequestedFrames != "true" || config.Offline == "true" {
status = "rejected"
message = "frame processing is not available"
} else if request.ExpiresAt <= time.Now().UnixMilli() {
status = "expired"
message = "capture request expired"
} else if request.ExpiresAt-time.Now().UnixMilli() > frameProcessing.FrameTTLSeconds*1000 {
status = "rejected"
message = "capture request expiry exceeds configured frame TTL"
} else if !communication.TrySendFrameProcessingRequest(request) {
status = "rejected"
message = "requested-frame queue is unavailable or full"
}
publishFrameProcessingStatus(mqttClient, hubKey, configuration, models.FrameProcessingStatus{
SchemaVersion: models.FrameProcessingSchemaVersion,
RequestID: request.RequestID,
DeviceID: config.Key,
Status: status,
OccurredAt: time.Now().UnixMilli(),
Retryable: status == "rejected" && message == "requested-frame queue is unavailable or full",
Message: message,
TraceID: request.TraceID,
})
}
func decodeFrameProcessingRequest(payload models.Payload) (models.FrameProcessingRequest, error) {
encoded, err := json.Marshal(payload.Value)
if err != nil {
return models.FrameProcessingRequest{}, fmt.Errorf("marshal capture-frame value: %w", err)
}
var request models.FrameProcessingRequest
decoder := json.NewDecoder(bytes.NewReader(encoded))
decoder.DisallowUnknownFields()
if err := decoder.Decode(&request); err != nil {
return models.FrameProcessingRequest{}, fmt.Errorf("decode capture-frame value: %w", err)
}
if request.SchemaVersion != models.FrameProcessingSchemaVersion {
return models.FrameProcessingRequest{}, fmt.Errorf("unsupported schemaVersion %q", request.SchemaVersion)
}
if request.RequestID == "" || request.ProcessingProfile == "" || request.ExpiresAt <= 0 {
return models.FrameProcessingRequest{}, errors.New("requestId, processingProfile, and expiresAt are required")
}
return request, nil
}
func frameProcessingCommandAuthenticated(config models.Config, remoteAuthenticated bool) bool {
hubAuthenticationRequired := config.HubEncryption == "true" && config.HubPrivateKey != ""
endToEndAuthenticationRequired := config.Encryption != nil && config.Encryption.Enabled == "true"
return remoteAuthenticated || (!hubAuthenticationRequired && !endToEndAuthenticationRequired)
}
func publishFrameProcessingStatus(mqttClient mqtt.Client, hubKey string, configuration *models.Configuration, status models.FrameProcessingStatus) {
if mqttClient == nil || hubKey == "" {
return
}
encoded, err := json.Marshal(status)
if err != nil {
return
}
value := make(map[string]interface{})
if err := json.Unmarshal(encoded, &value); err != nil {
return
}
payload, err := models.PackageMQTTMessage(configuration, models.Message{
Payload: models.Payload{
Version: models.FrameProcessingSchemaVersion,
Action: models.FrameProcessingStatusAction,
DeviceId: status.DeviceID,
Value: value,
},
})
if err != nil {
log.WithError(err).Warn("Failed to package frame-processing status")
return
}
mqttClient.Publish("kerberos/hub/"+hubKey, 1, false, payload)
}
func HandleRecording(mqttClient mqtt.Client, hubKey string, payload models.Payload, configuration *models.Configuration, communication *models.Communication) { func HandleRecording(mqttClient mqtt.Client, hubKey string, payload models.Payload, configuration *models.Configuration, communication *models.Communication) {
value := payload.Value value := payload.Value
+49
View File
@@ -157,6 +157,55 @@ func TestRemoteAccessRequiresExplicitOptIn(t *testing.T) {
} }
} }
func TestDecodeFrameProcessingRequest(t *testing.T) {
request, err := decodeFrameProcessingRequest(models.Payload{Value: map[string]interface{}{
"schemaVersion": "1.0",
"requestId": "request-1",
"processingProfile": "always-trigger",
"expiresAt": float64(2_000),
"traceId": "trace-1",
}})
if err != nil {
t.Fatal(err)
}
if request.RequestID != "request-1" || request.ExpiresAt != 2_000 || request.TraceID != "trace-1" {
t.Fatalf("decoded request = %+v", request)
}
}
func TestDecodeFrameProcessingRequestRejectsUnknownField(t *testing.T) {
_, err := decodeFrameProcessingRequest(models.Payload{Value: map[string]interface{}{
"schemaVersion": "1.0",
"requestId": "request-1",
"processingProfile": "always-trigger",
"expiresAt": float64(2_000),
"unexpected": true,
}})
if err == nil {
t.Fatal("decodeFrameProcessingRequest() accepted an unknown field")
}
}
func TestFrameProcessingCommandAuthentication(t *testing.T) {
plainConfig := models.Config{}
if !frameProcessingCommandAuthenticated(plainConfig, false) {
t.Fatal("trusted plaintext broker configuration rejected a command")
}
hiddenConfig := models.Config{HubEncryption: "true", HubPrivateKey: "private"}
if frameProcessingCommandAuthenticated(hiddenConfig, false) {
t.Fatal("Hub-encrypted configuration accepted plaintext command")
}
if !frameProcessingCommandAuthenticated(hiddenConfig, true) {
t.Fatal("Hub-encrypted configuration rejected authenticated command")
}
e2eConfig := models.Config{Encryption: &models.Encryption{Enabled: "true"}}
if frameProcessingCommandAuthenticated(e2eConfig, false) {
t.Fatal("end-to-end encrypted configuration accepted plaintext command")
}
}
func TestNormalizeTerminalSize(t *testing.T) { func TestNormalizeTerminalSize(t *testing.T) {
rows, columns := normalizeTerminalSize(0, 0) rows, columns := normalizeTerminalSize(0, 0)
if rows != 24 || columns != 80 { if rows != 24 || columns != 80 {
+80 -45
View File
@@ -191,32 +191,51 @@ func GetMediaFormatted(files []os.FileInfo, recordingDirectory string, configura
count := 0 count := 0
for _, file := range files { for _, file := range files {
fileName := file.Name() fileName := file.Name()
recordedAt, err := RecordingStartTime(fileName) fileParts := strings.Split(fileName, "_")
if err != nil { if len(fileParts) == 6 {
continue timestamp := fileParts[0]
} timestampInt, err := strconv.ParseInt(timestamp, 10, 64)
timestamp := recordedAt.Unix() if err == nil {
if eventFilter.TimestampOffsetStart > 0 && timestamp < eventFilter.TimestampOffsetStart {
continue if eventFilter.TimestampOffsetStart > 0 {
} // TimestampOffsetStart represents the newest lower bound to include.
if eventFilter.TimestampOffsetEnd > 0 && timestamp >= eventFilter.TimestampOffsetEnd { if timestampInt < eventFilter.TimestampOffsetStart {
continue continue
} }
loc, _ := time.LoadLocation(configuration.Config.Timezone) }
localTime := recordedAt.In(loc)
filePaths = append(filePaths, models.Media{ // If we have an offset we will check if we should skip or not
Key: fileName, if eventFilter.TimestampOffsetEnd > 0 {
Path: recordingDirectory + "/" + fileName, // Medias are sorted from new to older. TimestampOffsetEnd holds the oldest
CameraName: configuration.Config.Name, // timestamp of the previous batch of events. By doing this check, we make sure
CameraKey: configuration.Config.Key, // to skip the previous batch.
Day: localTime.Format("02-01-2006"), if timestampInt >= eventFilter.TimestampOffsetEnd {
ShortDay: localTime.Format("Jan _2"), continue
Time: localTime.Format("15:04:05"), }
Timestamp: strconv.FormatInt(timestamp, 10), }
})
count++ loc, _ := time.LoadLocation(configuration.Config.Timezone)
if eventFilter.NumberOfElements > 0 && count >= eventFilter.NumberOfElements { time := time.Unix(timestampInt, 0).In(loc)
break day := time.Format("02-01-2006")
timeString := time.Format("15:04:05")
shortDay := time.Format("Jan _2")
media := models.Media{
Key: fileName,
Path: recordingDirectory + "/" + fileName,
CameraName: configuration.Config.Name,
CameraKey: configuration.Config.Key,
Day: day,
ShortDay: shortDay,
Time: timeString,
Timestamp: timestamp,
}
filePaths = append(filePaths, media)
count = count + 1
if eventFilter.NumberOfElements > 0 && count >= eventFilter.NumberOfElements {
break
}
}
} }
} }
return filePaths return filePaths
@@ -225,12 +244,18 @@ func GetMediaFormatted(files []os.FileInfo, recordingDirectory string, configura
func GetDays(files []os.FileInfo, recordingDirectory string, configuration *models.Configuration) []string { func GetDays(files []os.FileInfo, recordingDirectory string, configuration *models.Configuration) []string {
days := []string{} days := []string{}
for _, file := range files { for _, file := range files {
recordedAt, err := RecordingStartTime(file.Name()) fileName := file.Name()
if err != nil { fileParts := strings.Split(fileName, "_")
continue if len(fileParts) == 6 {
timestamp := fileParts[0]
timestampInt, err := strconv.ParseInt(timestamp, 10, 64)
if err == nil {
loc, _ := time.LoadLocation(configuration.Config.Timezone)
time := time.Unix(timestampInt, 0).In(loc)
day := time.Format("02-01-2006")
days = append(days, day)
}
} }
loc, _ := time.LoadLocation(configuration.Config.Timezone)
days = append(days, recordedAt.In(loc).Format("02-01-2006"))
} }
uniqueDays := Unique(days) uniqueDays := Unique(days)
return uniqueDays return uniqueDays
@@ -253,13 +278,10 @@ func NumberOfFilesInDirectory(path string) int {
return len(files) return len(files)
} }
// NumberOfMP4sInDirectory counts MP4 files, including dated subdirectories. // NumberOfMP4sInDirectory returns the count of all files with mp4 extension in current directory
func NumberOfMP4sInDirectory(path string) int { func NumberOfMP4sInDirectory(path string) int {
files, err := ReadRecordingDirectory(path) pattern := filepath.Join(path, "*.mp4")
if err != nil { files, _ := filepath.Glob(pattern)
log.WithError(err).Error("Could not count recordings")
return 0
}
return len(files) return len(files)
} }
@@ -387,13 +409,25 @@ func Decrypt(directoryOrFile string, symmetricKey []byte) {
var files []string var files []string
if fileInfo.IsDir() { if fileInfo.IsDir() {
dir, err := ReadRecordingDirectory(directoryOrFile) // Create decrypted directory
err = os.MkdirAll(directoryOrFile+"/decrypted", 0755)
if err != nil {
log.Fatal(err.Error())
return
}
dir, err := os.ReadDir(directoryOrFile)
if err != nil { if err != nil {
log.Fatal(err.Error()) log.Fatal(err.Error())
return return
} }
for _, file := range dir { for _, file := range dir {
files = append(files, filepath.Join(directoryOrFile, file.Name())) // Check if file is not a directory
if !file.IsDir() {
// Check if an mp4 file
if strings.HasSuffix(file.Name(), ".mp4") {
files = append(files, directoryOrFile+"/"+file.Name())
}
}
} }
} else { } else {
files = append(files, directoryOrFile) files = append(files, directoryOrFile)
@@ -415,12 +449,13 @@ func Decrypt(directoryOrFile string, symmetricKey []byte) {
return return
} }
outputDirectory := filepath.Join(filepath.Dir(file), "decrypted") // Write decrypted content to file with appended .decrypted
if err := os.MkdirAll(outputDirectory, 0o755); err != nil { // Get filename split by / and get last element.
log.Fatal(err.Error()) fileParts := strings.Split(file, "/")
return fileName := fileParts[len(fileParts)-1]
} pathToFile := strings.Join(fileParts[:len(fileParts)-1], "/")
err = os.WriteFile(filepath.Join(outputDirectory, filepath.Base(file)), []byte(decrypted), 0644)
err = os.WriteFile(pathToFile+"/decrypted/"+fileName, []byte(decrypted), 0644)
if err != nil { if err != nil {
log.Fatal(err.Error()) log.Fatal(err.Error())
return return
-146
View File
@@ -1,146 +0,0 @@
package utils
import (
"fmt"
"io/fs"
"os"
"path/filepath"
"strconv"
"strings"
"time"
)
func RecordingFileName(timestamp int64, deviceKey string) (string, error) {
if timestamp <= 0 {
return "", fmt.Errorf("invalid recording timestamp %d", timestamp)
}
if deviceKey == "" || strings.ContainsAny(deviceKey, "/\\") {
return "", fmt.Errorf("missing or invalid recording device key")
}
return strconv.FormatInt(timestamp, 10) + "-" + deviceKey + ".mp4", nil
}
func RecordingStartTime(name string) (time.Time, error) {
base := filepath.Base(name)
if !strings.HasSuffix(base, ".mp4") {
return time.Time{}, fmt.Errorf("invalid recording filename %q", name)
}
timestamp, deviceKey, short := strings.Cut(strings.TrimSuffix(base, ".mp4"), "-")
if short && deviceKey != "" {
if millis, err := strconv.ParseInt(timestamp, 10, 64); err == nil && millis > 0 {
return time.UnixMilli(millis), nil
}
}
parts := strings.Split(base, "_")
if len(parts) == 6 {
seconds, err := strconv.ParseInt(parts[0], 10, 64)
if err == nil && seconds > 0 {
return time.Unix(seconds, 0), nil
}
}
return time.Time{}, fmt.Errorf("invalid recording filename %q", name)
}
func CreateRecordingPath(directory, fileName string, recordedAt time.Time) (string, error) {
if !filepath.IsLocal(fileName) || fileName == "." || filepath.Base(fileName) != fileName || strings.ContainsAny(fileName, "/\\") {
return "", fmt.Errorf("invalid recording filename %q", fileName)
}
if recordedAt.UnixMilli() <= 0 {
return "", fmt.Errorf("invalid recording start time %s", recordedAt)
}
directory = filepath.Join(directory, recordedAt.UTC().Format("2006/01/02"))
if err := os.MkdirAll(directory, 0o755); err != nil {
return "", fmt.Errorf("create recording directory: %w", err)
}
return filepath.Join(directory, fileName), nil
}
// ResolveRecordingPath accepts relative paths from listings and historical
// basename-only references from upload markers and playback URLs.
func ResolveRecordingPath(directory, name string) (string, error) {
if !filepath.IsLocal(name) {
return "", fmt.Errorf("invalid recording path %q", name)
}
filePath := filepath.Join(directory, name)
info, err := os.Stat(filePath)
if os.IsNotExist(err) && filepath.Base(name) == name {
recordedAt, parseErr := RecordingStartTime(name)
if parseErr == nil {
filePath = filepath.Join(directory, recordedAt.UTC().Format("2006/01/02"), name)
info, err = os.Stat(filePath)
}
}
if err != nil {
return "", err
}
if !info.Mode().IsRegular() {
return "", fmt.Errorf("recording %q is not a regular file", name)
}
return filePath, nil
}
func OpenRecording(directory, name string) (*os.File, error) {
filePath, err := ResolveRecordingPath(directory, name)
if err != nil {
return nil, err
}
return os.Open(filePath)
}
func RemoveRecording(directory, name string) error {
filePath, err := ResolveRecordingPath(directory, name)
if err != nil {
return err
}
return os.Remove(filePath)
}
type recordingFileInfo struct {
os.FileInfo
relativePath string
}
func (file recordingFileInfo) Name() string {
return file.relativePath
}
// ReadRecordingDirectory returns MP4s with root-relative names, preserving the
// file information used by the existing sorting and media formatting helpers.
func ReadRecordingDirectory(directory string) ([]os.FileInfo, error) {
return readRecordingDirectory(directory, filepath.WalkDir)
}
func readRecordingDirectory(directory string, walkDir func(string, fs.WalkDirFunc) error) ([]os.FileInfo, error) {
files := []os.FileInfo{}
err := walkDir(directory, func(filePath string, entry fs.DirEntry, err error) error {
if err != nil {
if os.IsNotExist(err) && filePath != directory {
return nil
}
return err
}
if entry.IsDir() && entry.Name() == "decrypted" && filePath != directory {
return filepath.SkipDir
}
if !entry.Type().IsRegular() || filepath.Ext(entry.Name()) != ".mp4" {
return nil
}
info, err := entry.Info()
if err != nil {
if os.IsNotExist(err) {
return nil
}
return err
}
name, err := filepath.Rel(directory, filePath)
if err != nil {
return err
}
files = append(files, recordingFileInfo{FileInfo: info, relativePath: filepath.ToSlash(name)})
return nil
})
if err != nil {
return nil, err
}
return files, nil
}
-311
View File
@@ -1,311 +0,0 @@
package utils
import (
"errors"
"io"
"io/fs"
"os"
"path/filepath"
"reflect"
"strconv"
"testing"
"time"
"github.com/kerberos-io/agent/machinery/src/encryption"
"github.com/kerberos-io/agent/machinery/src/models"
)
func TestShortRecordingNamePreservesMillisecondsAndDeviceKey(t *testing.T) {
const timestamp = int64(1767355200123)
const deviceKey = "device-key_with-hyphens"
name, err := RecordingFileName(timestamp, deviceKey)
if err != nil || name != "1767355200123-device-key_with-hyphens.mp4" {
t.Fatalf("RecordingFileName() = %q, %v", name, err)
}
other, err := RecordingFileName(timestamp+1, deviceKey)
if err != nil || other == name {
t.Fatalf("recordings within the same second must have distinct names: %q, %v", other, err)
}
directory := t.TempDir()
filePath, err := CreateRecordingPath(directory, name, time.UnixMilli(timestamp))
if err != nil {
t.Fatal(err)
}
if want := filepath.Join(directory, "2026/01/02", name); filePath != want {
t.Fatalf("path = %q, want %q", filePath, want)
}
if err := os.WriteFile(filePath, []byte("video"), 0o644); err != nil {
t.Fatal(err)
}
resolved, err := ResolveRecordingPath(directory, name)
if err != nil || resolved != filePath {
t.Fatalf("ResolveRecordingPath() = %q, %v", resolved, err)
}
files, err := ReadRecordingDirectory(directory)
if err != nil {
t.Fatal(err)
}
config := &models.Configuration{Config: models.Config{Timezone: "UTC"}}
media := GetMediaFormatted(files, directory, config, models.EventFilter{TimestampOffsetStart: timestamp / 1000})
if len(media) != 1 || media[0].Key != "2026/01/02/"+name || media[0].Timestamp != "1767355200" {
t.Fatalf("unexpected short-name media: %+v", media)
}
if days := GetDays(files, directory, config); !reflect.DeepEqual(days, []string{"02-01-2026"}) {
t.Fatalf("unexpected short-name days: %v", days)
}
if err := RemoveRecording(directory, name); err != nil {
t.Fatal(err)
}
for _, invalidKey := range []string{"", "camera/key", `camera\key`} {
if _, err := RecordingFileName(timestamp, invalidKey); err == nil {
t.Errorf("accepted invalid device key %q", invalidKey)
}
}
if _, err := RecordingFileName(0, deviceKey); err == nil {
t.Fatal("accepted invalid recording timestamp")
}
}
func TestCreateRecordingPathUsesRecordingUTCDate(t *testing.T) {
directory := t.TempDir()
recordedAt := time.Date(2026, time.January, 1, 1, 0, 0, 0, time.FixedZone("UTC+2", 2*60*60))
name := strconv.FormatInt(recordedAt.Unix(), 10) + "_3-123_camera_0-0-0-0_1_1000.mp4"
filePath, err := CreateRecordingPath(directory, name, recordedAt)
if err != nil {
t.Fatal(err)
}
if want := filepath.Join(directory, "2025/12/31", name); filePath != want {
t.Fatalf("path = %q, want %q", filePath, want)
}
if err := os.WriteFile(filePath, []byte("video"), 0o644); err != nil {
t.Fatal(err)
}
for _, reference := range []string{name, "2025/12/31/" + name} {
got, err := ResolveRecordingPath(directory, reference)
if err != nil || got != filePath {
t.Fatalf("ResolveRecordingPath(%q) = %q, %v; want %q", reference, got, err, filePath)
}
file, err := OpenRecording(directory, reference)
if err != nil {
t.Fatal(err)
}
content, err := io.ReadAll(file)
file.Close()
if err != nil || string(content) != "video" {
t.Fatalf("recording content = %q, %v", content, err)
}
}
if err := RemoveRecording(directory, name); err != nil {
t.Fatal(err)
}
if _, err := os.Stat(filePath); !os.IsNotExist(err) {
t.Fatalf("recording still exists after removal: %v", err)
}
}
func TestRecordingPathsKeepFlatFilesAccessible(t *testing.T) {
directory := t.TempDir()
name := "legacy-recording.mp4"
filePath := filepath.Join(directory, name)
if err := os.WriteFile(filePath, []byte("legacy"), 0o644); err != nil {
t.Fatal(err)
}
got, err := ResolveRecordingPath(directory, name)
if err != nil || got != filePath {
t.Fatalf("ResolveRecordingPath() = %q, %v; want %q", got, err, filePath)
}
if err := RemoveRecording(directory, name); err != nil {
t.Fatal(err)
}
}
func TestRecordingPathsReportInvalidAndMissingPaths(t *testing.T) {
directory := t.TempDir()
for _, name := range []string{"", ".", "..", "../outside.mp4", "/outside.mp4", "nested/recording.mp4", `nested\recording.mp4`} {
if _, err := CreateRecordingPath(directory, name, time.Now()); err == nil {
t.Errorf("CreateRecordingPath(%q) should reject invalid filename", name)
}
}
for _, name := range []string{"", ".", "../outside.mp4", "/outside.mp4"} {
if _, err := ResolveRecordingPath(directory, name); err == nil {
t.Errorf("ResolveRecordingPath(%q) should reject invalid path", name)
}
}
for _, name := range []string{"missing.mp4", "1700000000_missing.mp4", "2026/01/01/missing.mp4"} {
if _, err := ResolveRecordingPath(directory, name); !os.IsNotExist(err) {
t.Errorf("ResolveRecordingPath(%q) error = %v, want not-exist", name, err)
}
}
blocked := filepath.Join(directory, "not-a-directory")
if err := os.WriteFile(blocked, nil, 0o644); err != nil {
t.Fatal(err)
}
if _, err := CreateRecordingPath(blocked, "recording.mp4", time.Now()); err == nil {
t.Fatal("expected directory creation error")
}
if _, err := CreateRecordingPath(directory, "recording.mp4", time.Time{}); err == nil {
t.Fatal("expected invalid recording start time error")
}
if _, err := ReadRecordingDirectory(filepath.Join(directory, "missing")); !os.IsNotExist(err) {
t.Fatalf("ReadRecordingDirectory() error = %v, want not-exist", err)
}
}
func TestReadRecordingDirectoryIncludesFlatAndDatedMedia(t *testing.T) {
directory := t.TempDir()
names := []string{
"1700000000_6_7_8_9_10.mp4",
"2026/01/02/1767355200_6_7_8_9_10.mp4",
}
for index, name := range names {
filePath := filepath.Join(directory, name)
if err := os.MkdirAll(filepath.Dir(filePath), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filePath, []byte("video"), 0o644); err != nil {
t.Fatal(err)
}
modified := time.Unix(int64(index+1), 0)
if err := os.Chtimes(filePath, modified, modified); err != nil {
t.Fatal(err)
}
}
if err := os.WriteFile(filepath.Join(directory, "2026/01/02/ignore.txt"), nil, 0o644); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(filepath.Join(directory, "2026/01/02/decrypted"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(directory, "2026/01/02/decrypted/output.mp4"), nil, 0o644); err != nil {
t.Fatal(err)
}
files, err := ReadRecordingDirectory(directory)
if err != nil {
t.Fatal(err)
}
if len(files) != 2 || NumberOfMP4sInDirectory(directory) != 2 {
t.Fatalf("expected 2 MP4 recordings, got %d", len(files))
}
config := &models.Configuration{Config: models.Config{Timezone: "UTC", Name: "camera", Key: "device"}}
files = GetSortedDirectory(files)
media := GetMediaFormatted(files, directory, config, models.EventFilter{})
if len(media) != 2 || media[0].Key != names[1] || media[1].Key != names[0] {
t.Fatalf("unexpected media ordering or relative keys: %+v", media)
}
if media[0].Path != filepath.Join(directory, names[1]) || media[0].Timestamp != "1767355200" {
t.Fatalf("unexpected nested media path or timestamp: %+v", media[0])
}
if got, want := GetDays(files, directory, config), []string{"02-01-2026", "14-11-2023"}; !reflect.DeepEqual(got, want) {
t.Fatalf("days = %v, want %v", got, want)
}
filtered := GetMediaFormatted(files, directory, config, models.EventFilter{TimestampOffsetStart: 1767355200})
if len(filtered) != 1 || filtered[0].Key != names[1] {
t.Fatalf("unexpected filtered nested media: %+v", filtered)
}
}
func TestReadRecordingDirectoryContinuesAfterConcurrentDeletion(t *testing.T) {
for _, origin := range []string{"Info", "WalkDir"} {
t.Run(origin, func(t *testing.T) {
directory := t.TempDir()
for _, name := range []string{"deleted.mp4", "surviving.mp4"} {
if err := os.WriteFile(filepath.Join(directory, name), []byte("video"), 0o644); err != nil {
t.Fatal(err)
}
}
entries, err := os.ReadDir(directory)
if err != nil {
t.Fatal(err)
}
files, err := readRecordingDirectory(directory, func(root string, visit fs.WalkDirFunc) error {
deleted := filepath.Join(root, entries[0].Name())
if err := os.Remove(deleted); err != nil {
t.Fatal(err)
}
var err error
if origin == "Info" {
err = visit(deleted, entries[0], nil)
} else {
err = visit(deleted, nil, &fs.PathError{Op: "lstat", Path: deleted, Err: fs.ErrNotExist})
}
if err != nil {
return err
}
return visit(filepath.Join(root, entries[1].Name()), entries[1], nil)
})
if err != nil {
t.Fatal(err)
}
if len(files) != 1 || files[0].Name() != "surviving.mp4" || files[0].Size() != 5 {
t.Fatalf("expected surviving recording after concurrent deletion, got %v", files)
}
})
}
}
type recordingDirEntryInfoError struct {
fs.DirEntry
err error
}
func (entry recordingDirEntryInfoError) Info() (fs.FileInfo, error) {
return nil, entry.err
}
func TestReadRecordingDirectoryReportsOtherScanErrors(t *testing.T) {
for _, origin := range []string{"Info", "WalkDir"} {
t.Run(origin, func(t *testing.T) {
directory := t.TempDir()
filePath := filepath.Join(directory, "recording.mp4")
if err := os.WriteFile(filePath, []byte("video"), 0o644); err != nil {
t.Fatal(err)
}
entries, err := os.ReadDir(directory)
if err != nil {
t.Fatal(err)
}
wantErr := &fs.PathError{Op: "lstat", Path: filePath, Err: fs.ErrPermission}
files, err := readRecordingDirectory(directory, func(root string, visit fs.WalkDirFunc) error {
if origin == "Info" {
return visit(filePath, recordingDirEntryInfoError{DirEntry: entries[0], err: wantErr}, nil)
}
return visit(filePath, nil, wantErr)
})
if !errors.Is(err, fs.ErrPermission) || files != nil {
t.Fatalf("scan = %v, %v; want permission error without partial results", files, err)
}
})
}
}
func TestDecryptDirectoryIncludesDatedRecordingsAndSkipsOutputs(t *testing.T) {
directory := t.TempDir()
key := []byte("0123456789abcdef0123456789abcdef")
payload := []byte("recording-payload")
ciphertext, err := encryption.AesEncrypt(payload, string(key))
if err != nil {
t.Fatal(err)
}
names := []string{"legacy.mp4", "2026/01/02/recording.mp4"}
for _, name := range names {
filePath := filepath.Join(directory, name)
if err := os.MkdirAll(filepath.Dir(filePath), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filePath, []byte(ciphertext), 0o644); err != nil {
t.Fatal(err)
}
}
Decrypt(directory, key)
Decrypt(directory, key)
for _, name := range names {
output := filepath.Join(directory, filepath.Dir(name), "decrypted", filepath.Base(name))
content, err := os.ReadFile(output)
if err != nil || string(content) != string(payload) {
t.Fatalf("decrypted %q = %q, %v", name, content, err)
}
}
if got := NumberOfMP4sInDirectory(directory); got != len(names) {
t.Fatalf("recording count = %d, want %d (excluding decrypted outputs)", got, len(names))
}
}
+17 -179
View File
@@ -3,9 +3,7 @@ package webrtc
import ( import (
"io" "io"
"sync" "sync"
"time"
"github.com/pion/rtcp"
pionWebRTC "github.com/pion/webrtc/v4" pionWebRTC "github.com/pion/webrtc/v4"
pionMedia "github.com/pion/webrtc/v4/pkg/media" pionMedia "github.com/pion/webrtc/v4/pkg/media"
log "github.com/sirupsen/logrus" log "github.com/sirupsen/logrus"
@@ -14,23 +12,14 @@ import (
const ( const (
// peerSampleBuffer controls how many samples can be buffered per peer before // peerSampleBuffer controls how many samples can be buffered per peer before
// dropping. Keeps slow peers from blocking the broadcaster. // dropping. Keeps slow peers from blocking the broadcaster.
peerSampleBuffer = 60 peerSampleBuffer = 60
keyframeRequestInterval = time.Second
) )
type peerSample struct {
pionMedia.Sample
skippedDuration time.Duration
}
// peerTrack is a per-peer track with its own non-blocking sample channel. // peerTrack is a per-peer track with its own non-blocking sample channel.
type peerTrack struct { type peerTrack struct {
track *pionWebRTC.TrackLocalStaticSample track *pionWebRTC.TrackLocalStaticSample
samples chan peerSample samples chan pionMedia.Sample
done chan struct{} done chan struct{}
connected bool
needsKeyframe bool
skippedDuration time.Duration
} }
// TrackBroadcaster fans out media samples to multiple peer-specific tracks // TrackBroadcaster fans out media samples to multiple peer-specific tracks
@@ -38,17 +27,11 @@ type peerTrack struct {
// goroutine that drains samples independently, so a slow/congested peer // goroutine that drains samples independently, so a slow/congested peer
// cannot stall the others. // cannot stall the others.
type TrackBroadcaster struct { type TrackBroadcaster struct {
mu sync.RWMutex mu sync.RWMutex
peers map[string]*peerTrack peers map[string]*peerTrack
mimeType string mimeType string
id string id string
streamID string streamID string
requestKeyframe func() error
requestTimer *time.Timer
requestInFlight bool
lastRequest time.Time
requests sync.WaitGroup
closed bool
} }
// NewTrackBroadcaster creates a new broadcaster for either video or audio. // NewTrackBroadcaster creates a new broadcaster for either video or audio.
@@ -74,18 +57,12 @@ func (b *TrackBroadcaster) AddPeer(sessionKey string) (*pionWebRTC.TrackLocalSta
} }
pt := &peerTrack{ pt := &peerTrack{
track: track, track: track,
samples: make(chan peerSample, peerSampleBuffer), samples: make(chan pionMedia.Sample, peerSampleBuffer),
done: make(chan struct{}), done: make(chan struct{}),
connected: b.mimeType != pionWebRTC.MimeTypeH264,
needsKeyframe: b.mimeType == pionWebRTC.MimeTypeH264,
} }
b.mu.Lock() b.mu.Lock()
if b.closed {
b.mu.Unlock()
return nil, io.ErrClosedPipe
}
b.peers[sessionKey] = pt b.peers[sessionKey] = pt
b.mu.Unlock() b.mu.Unlock()
@@ -93,7 +70,7 @@ func (b *TrackBroadcaster) AddPeer(sessionKey string) (*pionWebRTC.TrackLocalSta
go func() { go func() {
defer close(pt.done) defer close(pt.done)
for sample := range pt.samples { for sample := range pt.samples {
if err := writePeerSample(pt.track, sample); err != nil { if err := pt.track.WriteSample(sample); err != nil {
if err == io.ErrClosedPipe { if err == io.ErrClosedPipe {
return return
} }
@@ -114,16 +91,6 @@ func (b *TrackBroadcaster) AddPeer(sessionKey string) (*pionWebRTC.TrackLocalSta
return track, nil return track, nil
} }
func writePeerSample(track *pionWebRTC.TrackLocalStaticSample, sample peerSample) error {
if sample.skippedDuration > 0 {
// An empty sample advances Pion's RTP clock without sending a packet.
if err := track.WriteSample(pionMedia.Sample{Duration: sample.skippedDuration}); err != nil {
return err
}
}
return track.WriteSample(sample.Sample)
}
// RemovePeer stops the writer goroutine and removes the peer. // RemovePeer stops the writer goroutine and removes the peer.
func (b *TrackBroadcaster) RemovePeer(sessionKey string) { func (b *TrackBroadcaster) RemovePeer(sessionKey string) {
b.mu.Lock() b.mu.Lock()
@@ -147,37 +114,14 @@ func (b *TrackBroadcaster) RemovePeer(sessionKey string) {
// WriteSample fans out a sample to all connected peers without blocking. // WriteSample fans out a sample to all connected peers without blocking.
// If a peer's buffer is full (slow consumer), the sample is dropped for // If a peer's buffer is full (slow consumer), the sample is dropped for
// that peer only — other peers are unaffected. // that peer only — other peers are unaffected.
func (b *TrackBroadcaster) WriteSample(sample pionMedia.Sample, isKeyframe bool) { func (b *TrackBroadcaster) WriteSample(sample pionMedia.Sample) {
b.mu.Lock() b.mu.RLock()
defer b.mu.Unlock() defer b.mu.RUnlock()
if b.closed {
return
}
for sessionKey, pt := range b.peers { for sessionKey, pt := range b.peers {
video := b.mimeType == pionWebRTC.MimeTypeH264
if video && (!pt.connected || (pt.needsKeyframe && !isKeyframe)) {
pt.skippedDuration += sample.Duration
continue
}
select { select {
case pt.samples <- peerSample{Sample: sample, skippedDuration: pt.skippedDuration}: case pt.samples <- sample:
pt.skippedDuration = 0
if video && isKeyframe {
pt.needsKeyframe = false
}
default: default:
if video {
pt.needsKeyframe = true
drainPeerSamples(pt)
if isKeyframe {
pt.samples <- peerSample{Sample: sample, skippedDuration: pt.skippedDuration}
pt.skippedDuration = 0
pt.needsKeyframe = false
} else {
pt.skippedDuration += sample.Duration
}
}
log.WithFields(log.Fields{ log.WithFields(log.Fields{
"component": "webrtc", "component": "webrtc",
"event": "slow_peer_sample_dropped", "event": "slow_peer_sample_dropped",
@@ -185,106 +129,6 @@ func (b *TrackBroadcaster) WriteSample(sample pionMedia.Sample, isKeyframe bool)
}).Warn("Dropping WebRTC sample for slow peer") }).Warn("Dropping WebRTC sample for slow peer")
} }
} }
b.scheduleKeyframeRequestLocked()
}
func drainPeerSamples(pt *peerTrack) {
for {
select {
case sample := <-pt.samples:
pt.skippedDuration += sample.skippedDuration + sample.Duration
default:
return
}
}
}
func (b *TrackBroadcaster) SetPeerConnected(sessionKey string, connected bool) {
b.mu.Lock()
defer b.mu.Unlock()
pt, ok := b.peers[sessionKey]
if !ok || b.mimeType != pionWebRTC.MimeTypeH264 || pt.connected == connected {
return
}
pt.connected = connected
pt.needsKeyframe = true
drainPeerSamples(pt)
b.scheduleKeyframeRequestLocked()
}
func (b *TrackBroadcaster) HandleRTCP(sessionKey string, data []byte) error {
feedback, err := rtcp.Unmarshal(data)
if err != nil {
return err
}
for _, packet := range feedback {
switch packet.(type) {
case *rtcp.PictureLossIndication, *rtcp.FullIntraRequest:
b.mu.Lock()
if pt, ok := b.peers[sessionKey]; ok && pt.connected && b.mimeType == pionWebRTC.MimeTypeH264 {
pt.needsKeyframe = true
drainPeerSamples(pt)
b.scheduleKeyframeRequestLocked()
}
b.mu.Unlock()
return nil
}
}
return nil
}
func (b *TrackBroadcaster) waitingForKeyframeLocked() bool {
for _, pt := range b.peers {
if pt.connected && pt.needsKeyframe {
return true
}
}
return false
}
func (b *TrackBroadcaster) scheduleKeyframeRequestLocked() {
if b.closed || b.requestKeyframe == nil || b.requestInFlight || !b.waitingForKeyframeLocked() {
return
}
if b.requestTimer == nil {
delay := time.Until(b.lastRequest.Add(keyframeRequestInterval))
if delay < 0 {
delay = 0
}
b.requestTimer = time.AfterFunc(delay, b.sendKeyframeRequest)
}
}
func (b *TrackBroadcaster) sendKeyframeRequest() {
b.mu.Lock()
b.requestTimer = nil
if b.closed || !b.waitingForKeyframeLocked() {
b.mu.Unlock()
return
}
b.lastRequest = time.Now()
b.requestInFlight = true
b.requests.Add(1)
b.mu.Unlock()
defer b.requests.Done()
if err := b.requestKeyframe(); err != nil {
log.WithError(err).WithFields(log.Fields{
"component": "webrtc",
"event": "keyframe_request_failed",
}).Warn("Camera keyframe request failed; waiting for a periodic IDR")
} else {
log.WithFields(log.Fields{
"component": "webrtc",
"event": "keyframe_requested",
}).Debug("Requested camera keyframe")
}
b.mu.Lock()
b.requestInFlight = false
b.scheduleKeyframeRequestLocked()
b.mu.Unlock()
} }
// PeerCount returns the current number of connected peers. // PeerCount returns the current number of connected peers.
@@ -297,17 +141,11 @@ func (b *TrackBroadcaster) PeerCount() int {
// Close removes all peers and stops all writer goroutines. // Close removes all peers and stops all writer goroutines.
func (b *TrackBroadcaster) Close() { func (b *TrackBroadcaster) Close() {
b.mu.Lock() b.mu.Lock()
b.closed = true
if b.requestTimer != nil {
b.requestTimer.Stop()
b.requestTimer = nil
}
keys := make([]string, 0, len(b.peers)) keys := make([]string, 0, len(b.peers))
for k := range b.peers { for k := range b.peers {
keys = append(keys, k) keys = append(keys, k)
} }
b.mu.Unlock() b.mu.Unlock()
b.requests.Wait()
for _, key := range keys { for _, key := range keys {
b.RemovePeer(key) b.RemovePeer(key)
-360
View File
@@ -1,360 +0,0 @@
package webrtc
import (
"bytes"
"errors"
"fmt"
"io"
"sync"
"sync/atomic"
"testing"
"time"
"github.com/kerberos-io/agent/machinery/src/capture"
"github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/packets"
"github.com/pion/rtcp"
pionWebRTC "github.com/pion/webrtc/v4"
pionMedia "github.com/pion/webrtc/v4/pkg/media"
)
func bufferedTestPeer(capacity int) *peerTrack {
done := make(chan struct{})
close(done)
return &peerTrack{
samples: make(chan peerSample, capacity),
done: done,
needsKeyframe: true,
}
}
func testVideoBroadcaster(t *testing.T) (*TrackBroadcaster, *peerTrack) {
t.Helper()
b := NewTrackBroadcaster(pionWebRTC.MimeTypeH264, "video", "test")
pt := bufferedTestPeer(peerSampleBuffer)
b.peers["viewer"] = pt
t.Cleanup(b.Close)
return b, pt
}
func TestVideoPeerStartsAndReconnectsAtKeyframe(t *testing.T) {
b, pt := testVideoBroadcaster(t)
sample := pionMedia.Sample{Data: []byte{1}}
b.WriteSample(sample, true)
if len(pt.samples) != 0 {
t.Fatal("sent a keyframe before the transport connected")
}
b.SetPeerConnected("viewer", true)
b.WriteSample(sample, false)
if len(pt.samples) != 0 {
t.Fatal("sent a dependent frame before the first IDR")
}
b.WriteSample(sample, true)
b.WriteSample(sample, false)
if len(pt.samples) != 2 || pt.needsKeyframe {
t.Fatal("did not release video after the first IDR")
}
b.SetPeerConnected("viewer", false)
b.WriteSample(sample, true)
if len(pt.samples) != 0 {
t.Fatal("retained or sent video while disconnected")
}
b.SetPeerConnected("viewer", true)
b.WriteSample(sample, false)
if len(pt.samples) != 0 {
t.Fatal("reconnected viewer resumed on a dependent frame")
}
b.WriteSample(sample, true)
if len(pt.samples) != 1 {
t.Fatal("reconnected viewer did not resume at an IDR")
}
}
func TestLateViewerDoesNotResetExistingViewer(t *testing.T) {
b, first := testVideoBroadcaster(t)
b.SetPeerConnected("viewer", true)
b.WriteSample(pionMedia.Sample{}, true)
<-first.samples
late := bufferedTestPeer(peerSampleBuffer)
b.peers["late"] = late
b.SetPeerConnected("late", true)
b.WriteSample(pionMedia.Sample{}, false)
if len(first.samples) != 1 || len(late.samples) != 0 {
t.Fatal("late viewer either interrupted an existing viewer or received a dependent frame")
}
b.WriteSample(pionMedia.Sample{}, true)
if len(late.samples) != 1 {
t.Fatal("late viewer did not receive the next IDR")
}
}
func TestVideoFeedbackRequestsFreshKeyframe(t *testing.T) {
for _, feedback := range []rtcp.Packet{
&rtcp.PictureLossIndication{MediaSSRC: 123},
&rtcp.FullIntraRequest{FIR: []rtcp.FIREntry{{SSRC: 123, SequenceNumber: 1}}},
} {
t.Run(fmt.Sprintf("%T", feedback), func(t *testing.T) {
b, pt := testVideoBroadcaster(t)
b.SetPeerConnected("viewer", true)
b.WriteSample(pionMedia.Sample{}, true)
b.WriteSample(pionMedia.Sample{}, false)
rr, err := rtcp.Marshal([]rtcp.Packet{&rtcp.ReceiverReport{}})
if err != nil {
t.Fatal(err)
}
if err := b.HandleRTCP("viewer", rr); err != nil || len(pt.samples) != 2 {
t.Fatal("receiver report reset the video gate", err)
}
data, err := rtcp.Marshal([]rtcp.Packet{&rtcp.ReceiverReport{}, feedback})
if err != nil {
t.Fatal(err)
}
if err := b.HandleRTCP("viewer", data); err != nil {
t.Fatal(err)
}
b.WriteSample(pionMedia.Sample{}, false)
if len(pt.samples) != 0 || !pt.needsKeyframe {
t.Fatal("PLI/FIR did not discard stale queued frames and wait for an IDR")
}
b.WriteSample(pionMedia.Sample{}, true)
if len(pt.samples) != 1 {
t.Fatal("PLI/FIR recovery did not resume at an IDR")
}
if err := b.HandleRTCP("viewer", []byte{0}); err == nil {
t.Fatal("malformed RTCP was accepted")
}
})
}
}
func TestSlowVideoPeerRecoversWithoutBlockingOthers(t *testing.T) {
for _, overflowIsKeyframe := range []bool{false, true} {
t.Run(map[bool]string{false: "dependent-frame-dropped", true: "new-IDR-replaces-backlog"}[overflowIsKeyframe], func(t *testing.T) {
b, fast := testVideoBroadcaster(t)
slow := bufferedTestPeer(2)
b.peers["slow"] = slow
b.SetPeerConnected("viewer", true)
b.SetPeerConnected("slow", true)
b.WriteSample(pionMedia.Sample{}, true)
b.WriteSample(pionMedia.Sample{}, false)
b.WriteSample(pionMedia.Sample{}, overflowIsKeyframe)
if len(fast.samples) != 3 {
t.Fatal("slow viewer interrupted another viewer")
}
if overflowIsKeyframe {
if len(slow.samples) != 1 || slow.needsKeyframe {
t.Fatal("fresh IDR did not replace the stale backlog")
}
} else {
b.WriteSample(pionMedia.Sample{}, false)
if len(slow.samples) != 0 || !slow.needsKeyframe {
t.Fatal("slow viewer forwarded dependent frames after a drop")
}
b.WriteSample(pionMedia.Sample{}, true)
if len(slow.samples) != 1 {
t.Fatal("slow viewer did not recover at the next IDR")
}
}
})
}
}
func TestAudioDoesNotWaitForVideoKeyframe(t *testing.T) {
b := NewTrackBroadcaster(pionWebRTC.MimeTypePCMU, "audio", "test")
pt := bufferedTestPeer(2)
pt.connected = true
pt.needsKeyframe = false
b.peers["viewer"] = pt
t.Cleanup(b.Close)
b.SetPeerConnected("viewer", false)
for range 3 {
b.WriteSample(pionMedia.Sample{}, false)
}
if len(pt.samples) != 2 {
t.Fatal("audio queue behavior changed")
}
}
func TestVideoSampleBufferPreservesKeyframeFlag(t *testing.T) {
b, pt := testVideoBroadcaster(t)
b.SetPeerConnected("viewer", true)
state := &streamState{}
first := packets.Packet{Data: []byte{0x65}, IsKeyFrame: true, Time: 1}
processVideoPacket(first, state, b, models.Config{})
processVideoPacket(packets.Packet{Data: []byte{0x41}, Time: 34}, state, b, models.Config{})
if len(pt.samples) != 1 || !bytes.Equal((<-pt.samples).Data, first.Data) {
t.Fatal("buffered IDR lost its keyframe flag")
}
b.SetPeerConnected("viewer", false)
b.SetPeerConnected("viewer", true)
writeFinalSamples(state, b, nil)
if len(pt.samples) != 0 {
t.Fatal("final dependent frame was mislabeled as an IDR")
}
state.lastVideoSample = &pionMedia.Sample{Data: first.Data}
state.lastVideoKeyframe = true
writeFinalSamples(state, b, nil)
if len(pt.samples) != 1 {
t.Fatal("final IDR lost its keyframe flag")
}
}
func TestKeyframeRequestsCoalesceAndRetryUntilIDR(t *testing.T) {
b, _ := testVideoBroadcaster(t)
calls := make(chan time.Time, 10)
var count atomic.Int32
b.requestKeyframe = func() error {
calls <- time.Now()
if count.Add(1) == 1 {
return errors.New("camera is not ready yet")
}
b.WriteSample(pionMedia.Sample{}, true)
return nil
}
for _, id := range []string{"viewer", "second", "third"} {
if id != "viewer" {
b.mu.Lock()
b.peers[id] = bufferedTestPeer(peerSampleBuffer)
b.mu.Unlock()
}
b.SetPeerConnected(id, true)
}
var first time.Time
select {
case first = <-calls:
case <-time.After(2 * time.Second):
t.Fatal("connected viewer did not request a keyframe")
}
feedback, err := rtcp.Marshal([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: 123}})
if err != nil {
t.Fatal(err)
}
for range 100 {
if err := b.HandleRTCP("viewer", feedback); err != nil {
t.Fatal(err)
}
}
select {
case second := <-calls:
if second.Sub(first) < keyframeRequestInterval-5*time.Millisecond {
t.Fatal("feedback bypassed the per-stream request rate limit")
}
case <-time.After(2 * time.Second):
t.Fatal("failed camera request was not retried")
}
select {
case <-calls:
t.Fatal("requests continued after all viewers received an IDR")
case <-time.After(keyframeRequestInterval + 100*time.Millisecond):
}
}
func TestKeyframeRequestsStopOnDisconnectAndClose(t *testing.T) {
b, _ := testVideoBroadcaster(t)
var calls atomic.Int32
b.requestKeyframe = func() error { calls.Add(1); return nil }
b.lastRequest = time.Now()
b.SetPeerConnected("viewer", true)
b.SetPeerConnected("viewer", false)
time.Sleep(keyframeRequestInterval + 50*time.Millisecond)
if calls.Load() != 0 {
t.Fatal("disconnected viewer requested a keyframe")
}
b.SetPeerConnected("viewer", true)
b.Close()
if _, err := b.AddPeer("closed"); !errors.Is(err, io.ErrClosedPipe) {
t.Fatalf("AddPeer() after Close() = %v, want closed pipe", err)
}
}
func TestBroadcasterCloseWaitsForKeyframeRequest(t *testing.T) {
b, _ := testVideoBroadcaster(t)
started, release, closed := make(chan struct{}), make(chan struct{}), make(chan struct{})
unblock := sync.OnceFunc(func() { close(release) })
defer unblock()
b.requestKeyframe = func() error {
close(started)
<-release
return nil
}
b.SetPeerConnected("viewer", true)
select {
case <-started:
case <-time.After(2 * time.Second):
t.Fatal("request did not start")
}
go func() { b.Close(); close(closed) }()
select {
case <-closed:
t.Fatal("Close returned before the in-flight camera request completed")
case <-time.After(30 * time.Millisecond):
}
unblock()
select {
case <-closed:
case <-time.After(2 * time.Second):
t.Fatal("Close did not finish")
}
}
func TestConcurrentVideoFeedbackAndPeerLifecycle(t *testing.T) {
b := NewTrackBroadcaster(pionWebRTC.MimeTypeH264, "video", "test")
t.Cleanup(b.Close)
data, err := rtcp.Marshal([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: 123}})
if err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
for _, id := range []string{"first", "second", "third"} {
if _, err := b.AddPeer(id); err != nil {
t.Fatal(err)
}
wg.Add(1)
go func() {
defer wg.Done()
for j := range 200 {
b.SetPeerConnected(id, j%5 != 0)
b.WriteSample(pionMedia.Sample{Data: []byte{0, 0, 0, 1, 0x65}, Duration: time.Millisecond}, j%10 == 0)
if err := b.HandleRTCP(id, data); err != nil {
t.Error(err)
}
}
b.RemovePeer(id)
}()
}
wg.Wait()
}
type keyframeTestSource struct {
capture.RTSPClient
request func() error
}
func (s keyframeTestSource) RequestKeyframe() error { return s.request() }
func TestVideoBroadcastersRequestTheirOwnSource(t *testing.T) {
streams := []packets.Stream{{Name: "H264", IsVideo: true}}
var mainCalls, subCalls atomic.Int32
main := NewVideoBroadcaster(streams, keyframeTestSource{request: func() error { mainCalls.Add(1); return nil }})
sub := NewVideoBroadcaster(streams, keyframeTestSource{request: func() error { subCalls.Add(1); return nil }})
t.Cleanup(main.Close)
t.Cleanup(sub.Close)
if err := main.requestKeyframe(); err != nil {
t.Fatal(err)
}
if mainCalls.Load() != 1 || subCalls.Load() != 0 {
t.Fatal("main feedback reached the wrong source")
}
if err := sub.requestKeyframe(); err != nil {
t.Fatal(err)
}
if mainCalls.Load() != 1 || subCalls.Load() != 1 {
t.Fatal("sub feedback reached the wrong source")
}
}
+30 -40
View File
@@ -18,6 +18,7 @@ import (
mqtt "github.com/eclipse/paho.mqtt.golang" mqtt "github.com/eclipse/paho.mqtt.golang"
"github.com/pion/interceptor" "github.com/pion/interceptor"
"github.com/pion/interceptor/pkg/intervalpli"
pionWebRTC "github.com/pion/webrtc/v4" pionWebRTC "github.com/pion/webrtc/v4"
pionMedia "github.com/pion/webrtc/v4/pkg/media" pionMedia "github.com/pion/webrtc/v4/pkg/media"
) )
@@ -428,6 +429,16 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
panic(err) panic(err)
} }
// Register a intervalpli factory
// This interceptor sends a PLI every 3 seconds. A PLI causes a video keyframe to be generated by the sender.
// This makes our video seekable and more error resilent, but at a cost of lower picture quality and higher bitrates
// A real world application should process incoming RTCP packets from viewers and forward them to senders
intervalPliFactory, err := intervalpli.NewReceiverInterceptor()
if err != nil {
panic(err)
}
interceptorRegistry.Add(intervalPliFactory)
api := pionWebRTC.NewAPI( api := pionWebRTC.NewAPI(
pionWebRTC.WithMediaEngine(mediaEngine), pionWebRTC.WithMediaEngine(mediaEngine),
pionWebRTC.WithInterceptorRegistry(interceptorRegistry), pionWebRTC.WithInterceptorRegistry(interceptorRegistry),
@@ -508,16 +519,9 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
case <-ctx.Done(): case <-ctx.Done():
return return
default: default:
n, _, rtcpErr := videoSender.Read(rtcpBuf) if _, _, rtcpErr := videoSender.Read(rtcpBuf); rtcpErr != nil {
if rtcpErr != nil {
if ctx.Err() == nil && rtcpErr != io.EOF && rtcpErr != io.ErrClosedPipe {
log.WithError(rtcpErr).Warn("WebRTC video RTCP reader failed")
}
return return
} }
if err := videoBroadcaster.HandleRTCP(sessionKey, rtcpBuf[:n]); err != nil {
log.WithError(err).Warn("Ignoring malformed WebRTC video RTCP feedback")
}
} }
} }
}() }()
@@ -576,9 +580,6 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
switch connectionState { switch connectionState {
case pionWebRTC.PeerConnectionStateDisconnected: case pionWebRTC.PeerConnectionStateDisconnected:
if videoBroadcaster != nil {
videoBroadcaster.SetPeerConnected(sessionKey, false)
}
// Disconnected is a transient state that can recover. // Disconnected is a transient state that can recover.
// Start a grace period timer; if we don't recover, then cleanup. // Start a grace period timer; if we don't recover, then cleanup.
wrapper.disconnectMu.Lock() wrapper.disconnectMu.Lock()
@@ -618,9 +619,6 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
cleanupPeerConnection(sessionKey, wrapper) cleanupPeerConnection(sessionKey, wrapper)
case pionWebRTC.PeerConnectionStateConnected: case pionWebRTC.PeerConnectionStateConnected:
if videoBroadcaster != nil {
videoBroadcaster.SetPeerConnected(sessionKey, true)
}
// Cancel any pending disconnect timer — connection recovered // Cancel any pending disconnect timer — connection recovered
wrapper.disconnectMu.Lock() wrapper.disconnectMu.Lock()
if wrapper.disconnectTimer != nil { if wrapper.disconnectTimer != nil {
@@ -762,17 +760,11 @@ func InitializeWebRTCConnection(configuration *models.Configuration, communicati
} }
} }
func NewVideoBroadcaster(streams []packets.Stream, rtspClient capture.RTSPClient) *TrackBroadcaster { func NewVideoBroadcaster(streams []packets.Stream) *TrackBroadcaster {
// Verify H264 is available (same check as NewVideoTrack) // Verify H264 is available (same check as NewVideoTrack)
for _, s := range streams { for _, s := range streams {
if s.Name == "H264" { if s.Name == "H264" {
b := NewTrackBroadcaster(pionWebRTC.MimeTypeH264, "video", trackStreamID) return NewTrackBroadcaster(pionWebRTC.MimeTypeH264, "video", trackStreamID)
if requester, ok := rtspClient.(capture.KeyframeRequester); ok {
b.requestKeyframe = requester.RequestKeyframe
} else {
log.Warn("RTSP source does not support keyframe requests; waiting for periodic IDRs")
}
return b
} }
} }
log.Error("webrtc.main.NewVideoBroadcaster(): no H264 stream found") log.Error("webrtc.main.NewVideoBroadcaster(): no H264 stream found")
@@ -866,19 +858,18 @@ func NewAudioTrack(streams []packets.Stream) *pionWebRTC.TrackLocalStaticSample
// streamState holds state information for the streaming process // streamState holds state information for the streaming process
type streamState struct { type streamState struct {
lastKeepAlive int64 lastKeepAlive int64
peerCount int64 peerCount int64
start bool start bool
catchingUp bool catchingUp bool
receivedKeyFrame bool receivedKeyFrame bool
lastAudioSample *pionMedia.Sample lastAudioSample *pionMedia.Sample
lastVideoSample *pionMedia.Sample lastVideoSample *pionMedia.Sample
lastVideoKeyframe bool audioPacketsSeen int64
audioPacketsSeen int64 aacPacketsSeen int64
aacPacketsSeen int64 audioSamplesSent int64
audioSamplesSent int64 aacNoOutput int64
aacNoOutput int64 aacErrors int64
aacErrors int64
} }
// codecSupport tracks which codecs are available in the stream // codecSupport tracks which codecs are available in the stream
@@ -952,11 +943,11 @@ func updateStreamState(communication *models.Communication, state *streamState)
// writeFinalSamples writes any remaining buffered samples // writeFinalSamples writes any remaining buffered samples
func writeFinalSamples(state *streamState, videoBroadcaster, audioBroadcaster *TrackBroadcaster) { func writeFinalSamples(state *streamState, videoBroadcaster, audioBroadcaster *TrackBroadcaster) {
if state.lastVideoSample != nil && videoBroadcaster != nil { if state.lastVideoSample != nil && videoBroadcaster != nil {
videoBroadcaster.WriteSample(*state.lastVideoSample, state.lastVideoKeyframe) videoBroadcaster.WriteSample(*state.lastVideoSample)
} }
if state.lastAudioSample != nil && audioBroadcaster != nil { if state.lastAudioSample != nil && audioBroadcaster != nil {
audioBroadcaster.WriteSample(*state.lastAudioSample, false) audioBroadcaster.WriteSample(*state.lastAudioSample)
} }
} }
@@ -1020,11 +1011,10 @@ func processVideoPacket(pkt packets.Packet, state *streamState, videoBroadcaster
if state.lastVideoSample != nil { if state.lastVideoSample != nil {
state.lastVideoSample.Duration = sampleDuration(pkt, state.lastVideoSample.PacketTimestamp, 33*time.Millisecond) state.lastVideoSample.Duration = sampleDuration(pkt, state.lastVideoSample.PacketTimestamp, 33*time.Millisecond)
videoBroadcaster.WriteSample(*state.lastVideoSample, state.lastVideoKeyframe) videoBroadcaster.WriteSample(*state.lastVideoSample)
} }
state.lastVideoSample = &sample state.lastVideoSample = &sample
state.lastVideoKeyframe = pkt.IsKeyFrame
} }
// processAudioPacket processes an audio packet and writes samples to the broadcaster. // processAudioPacket processes an audio packet and writes samples to the broadcaster.
@@ -1107,7 +1097,7 @@ func processAudioPacket(pkt packets.Packet, state *streamState, audioBroadcaster
"samples_queued": state.audioSamplesSent, "samples_queued": state.audioSamplesSent,
}).Debug("WebRTC audio sample queued") }).Debug("WebRTC audio sample queued")
} }
audioBroadcaster.WriteSample(*state.lastAudioSample, false) audioBroadcaster.WriteSample(*state.lastAudioSample)
} }
state.lastAudioSample = &sample state.lastAudioSample = &sample
+1 -149
View File
@@ -1,18 +1,6 @@
package webrtc package webrtc
import ( import "testing"
"encoding/base64"
"encoding/json"
"sync"
"testing"
"time"
"github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/packets"
"github.com/pion/rtcp"
pionWebRTC "github.com/pion/webrtc/v4"
pionMedia "github.com/pion/webrtc/v4/pkg/media"
)
func TestBuildICEServersOmitsEmptyURLs(t *testing.T) { func TestBuildICEServersOmitsEmptyURLs(t *testing.T) {
webRTC := CreateWebRTC("camera", []string{""}, []string{""}, "", "") webRTC := CreateWebRTC("camera", []string{""}, []string{""}, "", "")
@@ -38,7 +26,6 @@ func TestBuildICEServersIncludesConfiguredURLs(t *testing.T) {
if len(iceServers) != 2 { if len(iceServers) != 2 {
t.Fatalf("buildICEServers() returned %d servers, want 2", len(iceServers)) t.Fatalf("buildICEServers() returned %d servers, want 2", len(iceServers))
} }
if got := iceServers[0].URLs[0]; got != "stun:turn-fra1.kerberos.io:3478" { if got := iceServers[0].URLs[0]; got != "stun:turn-fra1.kerberos.io:3478" {
t.Fatalf("STUN URL = %q, want trimmed URL", got) t.Fatalf("STUN URL = %q, want trimmed URL", got)
} }
@@ -49,138 +36,3 @@ func TestBuildICEServersIncludesConfiguredURLs(t *testing.T) {
t.Fatal("TURN credentials were not preserved") t.Fatal("TURN credentials were not preserved")
} }
} }
func TestWebRTCConnectionRequestsStartupAndRecoveryKeyframes(t *testing.T) {
viewer, err := pionWebRTC.NewPeerConnection(pionWebRTC.Configuration{})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
if err := viewer.Close(); err != nil {
t.Error(err)
}
})
if _, err := viewer.AddTransceiverFromKind(pionWebRTC.RTPCodecTypeVideo, pionWebRTC.RTPTransceiverInit{
Direction: pionWebRTC.RTPTransceiverDirectionRecvonly,
}); err != nil {
t.Fatal(err)
}
tracks := make(chan *pionWebRTC.TrackRemote, 1)
viewer.OnTrack(func(track *pionWebRTC.TrackRemote, _ *pionWebRTC.RTPReceiver) {
tracks <- track
})
offer, err := viewer.CreateOffer(nil)
if err != nil {
t.Fatal(err)
}
gathered := pionWebRTC.GatheringCompletePromise(viewer)
if err := viewer.SetLocalDescription(offer); err != nil {
t.Fatal(err)
}
select {
case <-gathered:
case <-time.After(5 * time.Second):
t.Fatal("viewer ICE gathering timed out")
}
requests := make(chan time.Time, 10)
b := NewVideoBroadcaster([]packets.Stream{{Name: "H264", IsVideo: true}}, keyframeTestSource{
request: func() error { requests <- time.Now(); return nil },
})
t.Cleanup(b.Close)
const sessionKey = "unit-camera/startup-recovery"
t.Cleanup(func() {
globalConnectionManager.mu.RLock()
wrapper := globalConnectionManager.peerConnections[sessionKey]
globalConnectionManager.mu.RUnlock()
if wrapper != nil {
cleanupPeerConnection(sessionKey, wrapper)
}
})
var signalingMu sync.Mutex
var pending []pionWebRTC.ICECandidateInit
signaling := &models.LiveHDSignalingCallbacks{
SendCandidate: func(_ string, data string) error {
var candidate pionWebRTC.ICECandidateInit
if err := json.Unmarshal([]byte(data), &candidate); err != nil {
return err
}
signalingMu.Lock()
defer signalingMu.Unlock()
if viewer.RemoteDescription() == nil {
pending = append(pending, candidate)
return nil
}
return viewer.AddICECandidate(candidate)
},
SendAnswer: func(_ string, data string) error {
answer, err := base64.StdEncoding.DecodeString(data)
if err != nil {
return err
}
signalingMu.Lock()
defer signalingMu.Unlock()
if err := viewer.SetRemoteDescription(pionWebRTC.SessionDescription{
Type: pionWebRTC.SDPTypeAnswer, SDP: string(answer),
}); err != nil {
return err
}
for _, candidate := range pending {
if err := viewer.AddICECandidate(candidate); err != nil {
return err
}
}
pending = nil
return nil
},
}
InitializeWebRTCConnection(
&models.Configuration{Config: models.Config{Key: "unit-camera"}},
&models.Communication{}, nil, b, nil,
models.LiveHDHandshake{
Signaling: signaling,
Payload: models.RequestHDStreamPayload{
SessionID: "startup-recovery",
SessionDescription: base64.StdEncoding.EncodeToString([]byte(viewer.LocalDescription().SDP)),
},
},
)
var firstRequest time.Time
select {
case firstRequest = <-requests:
case <-time.After(5 * time.Second):
t.Fatal("connected transport did not request a startup keyframe")
}
b.WriteSample(pionMedia.Sample{Data: []byte{0, 0, 0, 1, 0x41, 0x80}, Duration: time.Second / 30}, false)
select {
case <-tracks:
t.Fatal("viewer received dependent video before its startup IDR")
case <-time.After(100 * time.Millisecond):
}
b.WriteSample(pionMedia.Sample{Data: []byte{0, 0, 0, 1, 0x65, 0x88, 0x84}, Duration: time.Second / 30}, true)
var track *pionWebRTC.TrackRemote
select {
case track = <-tracks:
case <-time.After(3 * time.Second):
t.Fatal("viewer did not receive the requested startup IDR")
}
for _, feedback := range []rtcp.Packet{
&rtcp.PictureLossIndication{SenderSSRC: 42, MediaSSRC: uint32(track.SSRC())},
&rtcp.FullIntraRequest{SenderSSRC: 42, FIR: []rtcp.FIREntry{{SSRC: uint32(track.SSRC()), SequenceNumber: 1}}},
} {
if err := viewer.WriteRTCP([]rtcp.Packet{feedback}); err != nil {
t.Fatal(err)
}
select {
case at := <-requests:
if at.Sub(firstRequest) < keyframeRequestInterval-5*time.Millisecond {
t.Fatal("real viewer feedback bypassed keyframe request throttling")
}
firstRequest = at
case <-time.After(3 * time.Second):
t.Fatalf("real %T feedback did not request a recovery keyframe", feedback)
}
b.WriteSample(pionMedia.Sample{Data: []byte{0, 0, 0, 1, 0x65, 0x88, 0x84}, Duration: time.Second / 30}, true)
}
}
-163
View File
@@ -1,163 +0,0 @@
package webrtc
import (
"errors"
"testing"
"time"
"github.com/pion/interceptor"
"github.com/pion/rtcp"
"github.com/pion/rtp"
pionWebRTC "github.com/pion/webrtc/v4"
pionMedia "github.com/pion/webrtc/v4/pkg/media"
)
type clockTestWriter struct {
timestamps []uint32
}
func (w *clockTestWriter) WriteRTP(header *rtp.Header, payload []byte) (int, error) {
w.timestamps = append(w.timestamps, header.Timestamp)
return len(payload), nil
}
func (*clockTestWriter) Write([]byte) (int, error) {
return 0, errors.New("unexpected raw RTP write")
}
type clockTestContext struct {
writer *clockTestWriter
}
func (clockTestContext) ID() string { return "clock-test" }
func (clockTestContext) SSRC() pionWebRTC.SSRC { return 123 }
func (clockTestContext) SSRCRetransmission() pionWebRTC.SSRC { return 0 }
func (clockTestContext) SSRCForwardErrorCorrection() pionWebRTC.SSRC { return 0 }
func (clockTestContext) RTCPReader() interceptor.RTCPReader { return nil }
func (clockTestContext) HeaderExtensions() []pionWebRTC.RTPHeaderExtensionParameter {
return nil
}
func (c clockTestContext) WriteStream() pionWebRTC.TrackLocalWriter { return c.writer }
func (clockTestContext) CodecParameters() []pionWebRTC.RTPCodecParameters {
return []pionWebRTC.RTPCodecParameters{{
RTPCodecCapability: pionWebRTC.RTPCodecCapability{MimeType: pionWebRTC.MimeTypeH264, ClockRate: 90000},
PayloadType: 96,
}}
}
func clockTestPeer(t *testing.T) (*TrackBroadcaster, *peerTrack, *clockTestWriter) {
t.Helper()
b, pt := testVideoBroadcaster(t)
pt.samples = make(chan peerSample, 2)
track, err := pionWebRTC.NewTrackLocalStaticSample(
pionWebRTC.RTPCodecCapability{MimeType: pionWebRTC.MimeTypeH264},
"video", "clock-test", pionWebRTC.WithRTPTimestamp(1000),
)
if err != nil {
t.Fatal(err)
}
writer := &clockTestWriter{}
if _, err := track.Bind(clockTestContext{writer: writer}); err != nil {
t.Fatal(err)
}
pt.track = track
b.SetPeerConnected("viewer", true)
return b, pt, writer
}
func clockVideoSample(duration time.Duration) pionMedia.Sample {
return pionMedia.Sample{
Data: []byte{0, 0, 0, 1, 0x65, 0x88, 0x84},
Duration: duration,
}
}
func writeClockSample(t *testing.T, pt *peerTrack) {
t.Helper()
select {
case sample := <-pt.samples:
if err := writePeerSample(pt.track, sample); err != nil {
t.Fatal(err)
}
default:
t.Fatal("expected queued video sample")
}
}
func TestVideoRecoveryPreservesRTPClock(t *testing.T) {
for _, scenario := range []string{"PLI", "FIR", "reconnect", "overflow"} {
t.Run(scenario, func(t *testing.T) {
b, pt, writer := clockTestPeer(t)
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
writeClockSample(t, pt)
b.WriteSample(clockVideoSample(70*time.Millisecond), false)
switch scenario {
case "PLI", "FIR":
var feedback rtcp.Packet = &rtcp.PictureLossIndication{MediaSSRC: 123}
if scenario == "FIR" {
feedback = &rtcp.FullIntraRequest{FIR: []rtcp.FIREntry{{SSRC: 123, SequenceNumber: 1}}}
}
data, err := rtcp.Marshal([]rtcp.Packet{feedback})
if err != nil {
t.Fatal(err)
}
if err := b.HandleRTCP("viewer", data); err != nil {
t.Fatal(err)
}
b.WriteSample(clockVideoSample(30*time.Millisecond), false)
case "reconnect":
b.SetPeerConnected("viewer", false)
b.WriteSample(clockVideoSample(30*time.Millisecond), false)
b.SetPeerConnected("viewer", true)
case "overflow":
b.WriteSample(clockVideoSample(30*time.Millisecond), false)
}
b.WriteSample(clockVideoSample(1900*time.Millisecond), false)
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
writeClockSample(t, pt)
if len(writer.timestamps) != 2 {
t.Fatalf("sent %d RTP packets, want only the two IDRs", len(writer.timestamps))
}
// The initial 40 ms frame plus 2000 ms of discarded video at 90 kHz.
if got := writer.timestamps[1] - writer.timestamps[0]; got != 183600 {
t.Fatalf("recovery RTP timestamp delta = %d, want 183600", got)
}
})
}
}
func TestOverflowIDRPreservesDiscardedRTPDuration(t *testing.T) {
b, pt, writer := clockTestPeer(t)
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
writeClockSample(t, pt)
b.WriteSample(clockVideoSample(70*time.Millisecond), false)
b.WriteSample(clockVideoSample(30*time.Millisecond), false)
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
writeClockSample(t, pt)
if len(writer.timestamps) != 2 || writer.timestamps[1]-writer.timestamps[0] != 12600 {
t.Fatalf("overflow IDR compressed the RTP clock: %v", writer.timestamps)
}
}
func TestRepeatedFeedbackPreservesAlreadyQueuedSkippedTime(t *testing.T) {
b, pt, writer := clockTestPeer(t)
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
writeClockSample(t, pt)
data, err := rtcp.Marshal([]rtcp.Packet{&rtcp.PictureLossIndication{MediaSSRC: 123}})
if err != nil {
t.Fatal(err)
}
for range 2 {
if err := b.HandleRTCP("viewer", data); err != nil {
t.Fatal(err)
}
b.WriteSample(clockVideoSample(time.Second), false)
b.WriteSample(clockVideoSample(40*time.Millisecond), true)
}
writeClockSample(t, pt)
if len(writer.timestamps) != 2 || writer.timestamps[1]-writer.timestamps[0] != 187200 {
t.Fatalf("repeated feedback lost queued skipped time: %v", writer.timestamps)
}
}
-2
View File
@@ -223,8 +223,6 @@
"kerberosvault_description_accesskey": "The access key of your Vault account.", "kerberosvault_description_accesskey": "The access key of your Vault account.",
"kerberosvault_secretkey": "Secret key", "kerberosvault_secretkey": "Secret key",
"kerberosvault_description_secretkey": "The secret key of your Vault account.", "kerberosvault_description_secretkey": "The secret key of your Vault account.",
"kerberosvault_customheaders": "Custom upload headers",
"kerberosvault_description_customheaders": "A JSON object of custom HTTP headers, for example {\"site_id\":\"site-1\",\"line_id\":\"line-2\"}. These values are included as metadata in Vault integration messages.",
"kerberosvault_maxretries": "Max retries", "kerberosvault_maxretries": "Max retries",
"kerberosvault_description_maxretries": "The maximum number of retries to upload a recording.", "kerberosvault_description_maxretries": "The maximum number of retries to upload a recording.",
"kerberosvault_timeout": "Timeout", "kerberosvault_timeout": "Timeout",
+3 -4
View File
@@ -1,6 +1,5 @@
const { hostname, host, protocol } = window.location; const { hostname, host, protocol } = window.location;
const websocketprotocol = protocol === 'http:' ? 'ws:' : 'wss:'; const websocketprotocol = protocol === 'http:' ? 'ws:' : 'wss:';
const devAgentPort = process.env.REACT_APP_AGENT_API_PORT || '8082';
// Uncomment this when using codespaces or other special DNS names (which you can't control) // Uncomment this when using codespaces or other special DNS names (which you can't control)
// replace this with the DNS name of the kerberos agent server (the codespace url) // replace this with the DNS name of the kerberos agent server (the codespace url)
@@ -10,9 +9,9 @@ const dev = {
ENV: 'dev', ENV: 'dev',
// Comment the below lines, when using codespaces or other special DNS names (which you can't control) // Comment the below lines, when using codespaces or other special DNS names (which you can't control)
HOSTNAME: hostname, HOSTNAME: hostname,
API_URL: `${protocol}//${hostname}:${devAgentPort}/api`, API_URL: `${protocol}//${hostname}:8080/api`,
URL: `${protocol}//${hostname}:${devAgentPort}`, URL: `${protocol}//${hostname}:8080`,
WS_URL: `${websocketprotocol}//${hostname}:${devAgentPort}/ws`, WS_URL: `${websocketprotocol}//${hostname}:8080/ws`,
MODE: window['env']['mode'], MODE: window['env']['mode'],
// Uncomment, and comment the above lines, when using codespaces or other special DNS names (which you can't control) // Uncomment, and comment the above lines, when using codespaces or other special DNS names (which you can't control)
// HOSTNAME: externalHost, // HOSTNAME: externalHost,
-44
View File
@@ -2542,28 +2542,6 @@ export class Settings extends React.Component {
) )
} }
/> />
<Input
noPadding
label={t(
'settings.persistence.kerberosvault_customheaders'
)}
placeholder={t(
'settings.persistence.kerberosvault_description_customheaders'
)}
value={
config.kstorage
? config.kstorage.custom_headers || ''
: ''
}
onChange={(value) =>
this.onUpdateField(
'kstorage',
'custom_headers',
value,
config.kstorage
)
}
/>
<Input <Input
noPadding noPadding
label={t( label={t(
@@ -2837,28 +2815,6 @@ export class Settings extends React.Component {
) )
} }
/> />
<Input
noPadding
label={t(
'settings.persistence.kerberosvault_customheaders'
)}
placeholder={t(
'settings.persistence.kerberosvault_description_customheaders'
)}
value={
config.kstorage_secondary
? config.kstorage_secondary.custom_headers || ''
: ''
}
onChange={(value) =>
this.onUpdateField(
'kstorage_secondary',
'custom_headers',
value,
config.kstorage_secondary
)
}
/>
</BlockBody> </BlockBody>
<BlockFooter> <BlockFooter>
<Button <Button