Compare commits

...
Author SHA1 Message Date
Cédric Verstraeten d1646457f2 Merge pull request #361 from kerberos-io/fix/security-hardening
security: require authentication everywhere and drop the default JWT key
2026-11-21 23:26:04 +01:00
Cédric VerstraetenandClaude Opus 5.5 c0baade8fd security: require authentication everywhere and drop the default JWT key
- JWT signing key: without AGENT_JWT_SECRET, generate a random secret on
  first start and keep it in data/config/jwt_secret (0600) instead of
  falling back to a publicly known constant. AGENT_JWT_SECRET still takes
  precedence, so deployments that share a key with Kerberos Factory are
  unchanged.
- Only tokens for the configured account are authorised, and malformed
  token claims are rejected instead of panicking.
- /ws (live view) and /file (recordings) now require a valid token. The UI
  passes it as ?token=, since browsers cannot set headers on WebSocket
  connections or <video src>; it no longer opens the socket before sign-in.
  /file no longer sends its own wildcard CORS header.
- pprof is off by default; AGENT_ENABLE_PPROF=true registers it behind auth.
- Release workflows pass tags to shell steps through quoted environment
  variables and validate them; the shared release-bump workflow is pinned
  to a commit and no longer receives inherited secrets.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 22:17:28 +00:00
Cédric Verstraeten 37ebcfe641 Merge pull request #360 from kerberos-io/chore/yarn-lock-public-registry
ui: resolve yarn.lock packages from the public registry
2026-11-21 23:14:43 +01:00
Cédric Verstraeten de16cb9c83 Merge pull request #359 from kerberos-io/fix/security-alerts
Fix open Dependabot and code scanning alerts
2026-11-21 23:13:48 +01:00
Cédric VerstraetenandClaude Opus 5.5 23c4c932a9 ui: resolve yarn.lock packages from the public registry
158 entries in ui/yarn.lock were resolved from an Azure DevOps feed
(ms-feed-25.pkgs.visualstudio.com) instead of registry.yarnpkg.com. Point them
back at the public registry. Each entry's sha1 was checked against the npm
registry before it was rewritten, so the tarballs are identical. The 96
sha1-only integrity values are replaced with the registry's sha512.

axios is left as is: #359 moves it to 0.34.0 on the public registry.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 22:11:06 +00:00
Cédric VerstraetenandClaude Opus 5.5 58285d1141 ui: bump axios to 0.34.0
Fixes Dependabot alerts #601 (GHSA-x97p-jq2g-jp4f) and #602
(GHSA-9fr6-4gfg-395g). The dependency ranges are unchanged, so only the axios
lockfile entry moves, now resolved from registry.yarnpkg.com.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 22:08:02 +00:00
Cédric VerstraetenandClaude Opus 5.5 1473c1e4cf cloud: only skip S3 proxy TLS checks when AGENT_TLS_INSECURE is set
The S3 proxy transport always set InsecureSkipVerify. Gate it on
AGENT_TLS_INSECURE like the other HTTP clients in the agent. Deployments that
use an S3 proxy with a self-signed certificate now need AGENT_TLS_INSECURE=true.

Fixes code scanning alert #100 (go/disabled-certificate-check).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 22:08:02 +00:00
Cédric VerstraetenandClaude Opus 5.5 39d6cf3020 cloud: restrict Vault verification to the saved URI
VerifyPersistence and VerifySecondaryPersistence sent the Vault access and
secret keys to whatever URI the request body named. Apply the same rule the
Hub check already uses: only the saved URI may be contacted, and redirects
are refused so the keys cannot be forwarded to another host.

Fixes code scanning alerts #84, #85, #86 and #87 (go/request-forgery).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 22:08:02 +00:00
Cédric Verstraeten 81c81f3a76 Merge pull request #358 from kerberos-io/docs/recording-layout
docs: move recording layout into README-FILE-STRUCTURE.md
2026-11-21 22:55:31 +01:00
Cédric Verstraeten 5040e6b32c Merge pull request #357 from kerberos-io/feat/moq-dev-v0.7
machinery: migrate MoQ publishing to moq.dev/moq v0.7
2026-11-21 22:53:04 +01:00
Cédric VerstraetenandClaude Opus 5.5 7e979023ae ui: migrate from Create React App to Vite (#355)
* ui: migrate from Create React App to Vite

react-scripts 5 is unmaintained and pins vulnerable versions of
webpack-dev-server, webpack-dev-middleware, postcss 7 and svgo.

- build and dev server: Vite 8 with @vitejs/plugin-react
- tests: Vitest 4 with jsdom (jest.* -> vi.*; mocked default exports
  now return { default })
- index.html moves to ui/ and loads src/index.jsx as a module
- REACT_APP_ENVIRONMENT is replaced by import.meta.env.PROD/MODE, and
  REACT_APP_AGENT_API_PORT is renamed to VITE_AGENT_API_PORT
- bundled output goes to static/ so it does not mix with public/assets
- package.json is not "type": "module": that would switch CommonJS
  interop to Node semantics and break default imports such as
  @giantmachines/redux-websocket
- sass 1.54 -> 1.108 (Vite needs the modern compiler API); sass-loader
  removed
- requires Node >= 20.19

`yarn build` still writes to machinery/www, so the Dockerfile and CI
workflow are unchanged.

Clears the remaining 9 react-scripts Dependabot alerts. Five alerts for
svgo 1 and decode-uri-component 0.2 remain; they come from build-tool
dependencies of @kerberos-io/ui and are not part of the bundle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ui: vendor @kerberos-io/ui 1.77.1 to clear the last Dependabot alerts

@kerberos-io/ui 1.77.1 moves its build tools (@svgr/webpack,
svg-react-loader, sass-loader, Storybook, Rollup plugins) out of its
runtime dependencies. Those pulled svgo 1 and decode-uri-component 0.2
into the agent's lockfile.

1.77.1 is tagged on GitHub but was never published to npm, so install
it from a tarball built from kerberos-io/ui@ae1faa7 (tag v1.77.1) and
committed under ui/vendor. Compared with the published 1.77.0 the
exports are identical; the only code change is the bundled uuid (8 -> 11).

The Dockerfile copies ui/vendor before `yarn --frozen-lockfile`.
ui/vendor/README.md records the checksum and how to switch back to the
registry once a fixed version is published.

Clears the remaining 5 Dependabot alerts (svgo, decode-uri-component).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ui: install @kerberos-io/ui 1.77.1 from its GitHub release

Replace the vendored tarball with the one attached to the kerberos-io/ui
v1.77.1 GitHub release, as uug-ai/factory already does. That tarball is
built by the ui repo's release workflow and ships with a .sha256 file
(e9f94f44...); yarn.lock pins it by hash.

Its JS is identical to the locally built tarball, and its CSS differs
only in selector order within @extend-generated rules.

This removes ui/vendor and the extra COPY line in the Dockerfile.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* ui: address lint findings in the Vite migration

- vite.config.mjs: disable import/no-unresolved; eslint-plugin-import 2.x
  cannot resolve packages that only define "exports" (vite, plugin-react)
- ui/README.md: turn the scripts table into a list to keep lines short
- README.md: wrap the edited UI paragraph

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 22:52:44 +01:00
Cédric Verstraeten 7f4c5dda80 Merge pull request #354 from kerberos-io/fix/dependabot-alerts
fix: resolve Dependabot security alerts in machinery and ui
2026-11-21 22:51:39 +01:00
Cédric VerstraetenandClaude Opus 5.5 b80fc93f22 machinery: migrate MoQ publishing to moq.dev/moq v0.7
github.com/moq-dev/moq-go was renamed to moq.dev/moq. Its native library
(moq.dev/moq-ffi v0.4.27) ships without LLVM bitcode, so `go build -tags moq`
works on Go 1.26.11+, which rejects the bitcode in moq-go-ffi v0.3.x.

- github.com/moq-dev/moq-go v0.5.7 -> moq.dev/moq v0.7.27
  (moq-go-ffi v0.3.7 -> moq.dev/moq-ffi v0.4.27)
- BroadcastProducer.PublishMedia("avc3", nil) ->
  PublishVideo(moq.VideoFormatAvc3, nil); the rest of the API the agent
  uses is unchanged
- unpin Go: the build image goes back to golang:1.26-trixie and the
  devcontainer drops GOTOOLCHAIN=go1.26.10

Compatibility:
- the derived track name is still "0.avc3"
- the relay accepts the new client (wire protocol moq-lite-05 -> moq-lite-07)
- the catalog keeps the same rendition, codec and container; the
  per-rendition "timeline" moves to a top-level "archive" and a "clock"
  object is added. The Hub viewer's schema (@moq/hang 0.2.16, used by
  @moq/watch 0.2.17) accepts it, and timeline is optional and unused for
  live playback.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 21:48:58 +00:00
Cédric VerstraetenandClaude Opus 5.5 57055498a2 docs: move recording layout into README-FILE-STRUCTURE.md
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 21:46:55 +00:00
Cédric Verstraeten 3f27243138 Merge pull request #356 from kerberos-io/fix/rtsp-transport-followups
Harden configurable RTSP transport (follow-up to #351)
2026-11-21 21:43:02 +01:00
Cédric VerstraetenandClaude Opus 5.5 ce9b9a3b54 Drop rtsp_transport from the MQTT verify payload
Hub verify keeps using the configured transport; out of scope for now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 20:39:44 +00:00
Cédric VerstraetenandClaude Opus 5.5 f6575652bc Harden configurable RTSP transport (follow-up to #351)
- MQTT verify: accept rtsp_transport in the verify payload and fall back
  to the configured transport, like the RTSP url already does, so unsaved
  transport choices can be verified from Kerberos Hub.
- RTSPS + forced UDP: fail fast with a clear error when the camera does
  not offer SRTP, instead of every SETUP failing with "unable to setup
  secure UDP" (which Connect only logs). "auto" already picks TCP here.
- Backchannel: always use TCP. gortsplib's auto fallback only triggers
  when no packets are received, which never happens on a send-only
  backchannel, and talk-back over UDP is not validated on hardware.
- UDP read buffer: request 4 MiB, capped at net.core.rmem_max, because
  gortsplib fails the SETUP when it cannot get the exact size requested.
- Logging: route gortsplib's transport-switch messages through the
  structured logger and log the negotiated transport per stream.
- README: document the transport options and their caveats.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-21 20:25:48 +00:00
Cédric Verstraeten 1e16a8e27c Merge pull request #351 from officialasishkumar/feature/rtsp-transport-selection
Add configurable RTSP transport (tcp, udp, auto)
2026-11-21 21:22:43 +01:00
Asish Kumar 40c62f74fa Add configurable RTSP transport (tcp, udp, auto)
The agent hard-coded TCP (interleaved) for every camera connection, so
cameras and networks that only work well over UDP could not be used and
there was no way to let the client negotiate the transport.

Add an optional capture.ipcamera.rtsp_transport setting, also available
as AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT, with these values:

- tcp (default, also used when unset): unchanged behaviour
- udp: force RTP over UDP
- auto: let gortsplib try UDP first and fall back to TCP

Unknown values log a warning and fall back to TCP so a typo cannot break
an existing deployment. The setting is applied to the main, sub and
backchannel clients and to both camera verification paths (HTTP and
MQTT). The Settings page gets a transport dropdown next to the RTSP URLs
and the verify request forwards the selected value, so unsaved choices
can be tested. The README documents the new variable.

Tests cover the transport-to-protocol mapping and the environment
override.

Signed-off-by: Asish Kumar <officialasishkumar@gmail.com>
2026-11-12 21:09:25 +05:30
46 changed files with 2130 additions and 7857 deletions
-4
View File
@@ -1,9 +1,5 @@
FROM mcr.microsoft.com/devcontainers/go:1.26-trixie
# Same pin as the main Dockerfile: Go 1.26.11 rejects moq-go-ffi v0.3.x's
# archives (LLVM bitcode), which breaks `go build -tags moq`.
ENV GOTOOLCHAIN=go1.26.10
# Install node environment
RUN apt-get update && \
apt-get install -y --no-install-recommends \
+34 -24
View File
@@ -22,10 +22,12 @@ env:
jobs:
# Determine the next version, create the GitHub release and expose the tag.
bump-release:
uses: uug-ai/workflows/.github/workflows/release-bump.yml@main
# Pinned to a reviewed commit of uug-ai/workflows so changes there cannot
# alter this release without a change here. It only needs GITHUB_TOKEN,
# which GitHub provides to called workflows, so no secrets are passed on.
uses: uug-ai/workflows/.github/workflows/release-bump.yml@6c1805abf25ac34add01d4af711277e8a68945ab # main as of 2026-11-20
with:
bump: ${{ github.event.inputs.bump }}
secrets: inherit
# Publish the platform image to the uug-ai GitHub Container Registry
# (ghcr.io/uug-ai/agent-platform).
@@ -56,6 +58,9 @@ jobs:
strategy:
matrix:
architecture: [amd64]
env:
ARCH: ${{ matrix.architecture }}
RELEASE_TAG: ${{ needs.bump-release.outputs.tag }}
steps:
- name: Login to DockerHub
uses: docker/login-action@v3
@@ -66,16 +71,16 @@ jobs:
uses: actions/checkout@v4
- name: Run Build
run: |
docker build --provenance=false --build-arg VERSION=${{ needs.bump-release.outputs.tag }} -t ${{matrix.architecture}} .
CID=$(docker create ${{matrix.architecture}})
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
docker rm ${CID}
docker build --provenance=false --build-arg VERSION="${RELEASE_TAG}" -t "${ARCH}" .
CID=$(docker create "${ARCH}")
docker cp "${CID}:/home/agent" "./output-${ARCH}"
docker rm "${CID}"
- name: Strip binary
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
- name: Build and push Docker image
run: |
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
docker push $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
@@ -90,6 +95,9 @@ jobs:
strategy:
matrix:
architecture: [arm64]
env:
ARCH: ${{ matrix.architecture }}
RELEASE_TAG: ${{ needs.bump-release.outputs.tag }}
steps:
- name: Login to DockerHub
uses: docker/login-action@v3
@@ -100,16 +108,16 @@ jobs:
uses: actions/checkout@v4
- name: Run Build
run: |
docker build --provenance=false --build-arg VERSION=${{ needs.bump-release.outputs.tag }} -t ${{matrix.architecture}} .
CID=$(docker create ${{matrix.architecture}})
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
docker rm ${CID}
docker build --provenance=false --build-arg VERSION="${RELEASE_TAG}" -t "${ARCH}" .
CID=$(docker create "${ARCH}")
docker cp "${CID}:/home/agent" "./output-${ARCH}"
docker rm "${CID}"
- name: Strip binary
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
- name: Build and push Docker image
run: |
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
docker push $REPO-arch:arch-${{matrix.architecture}}-${{ needs.bump-release.outputs.tag }}
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
@@ -119,6 +127,8 @@ jobs:
create-manifest:
runs-on: ubuntu-24.04
needs: [bump-release, build-amd64, build-arm64]
env:
RELEASE_TAG: ${{ needs.bump-release.outputs.tag }}
steps:
- name: Login to DockerHub
uses: docker/login-action@v3
@@ -127,16 +137,16 @@ jobs:
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Create and push multi-arch manifest
run: |
docker manifest create $REPO:${{ needs.bump-release.outputs.tag }} \
$REPO-arch:arch-amd64-${{ needs.bump-release.outputs.tag }} \
$REPO-arch:arch-arm64-${{ needs.bump-release.outputs.tag }}
docker manifest push $REPO:${{ needs.bump-release.outputs.tag }}
docker manifest create "${REPO}:${RELEASE_TAG}" \
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
docker manifest push "${REPO}:${RELEASE_TAG}"
- name: Create and push latest manifest
run: |
docker manifest create $REPO:latest \
$REPO-arch:arch-amd64-${{ needs.bump-release.outputs.tag }} \
$REPO-arch:arch-arm64-${{ needs.bump-release.outputs.tag }}
docker manifest push $REPO:latest
docker manifest create "${REPO}:latest" \
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
docker manifest push "${REPO}:latest"
create-release:
runs-on: ubuntu-24.04
+41 -22
View File
@@ -11,6 +11,9 @@ on:
env:
REPO: kerberos/agent
# Expressions are passed to shell steps through the environment and quoted,
# never interpolated into the script, so a crafted tag cannot inject commands.
RELEASE_TAG: ${{ github.event.inputs.tag || github.ref_name }}
jobs:
build-amd64:
@@ -20,7 +23,15 @@ jobs:
strategy:
matrix:
architecture: [amd64]
env:
ARCH: ${{ matrix.architecture }}
steps:
- name: Validate release tag
run: |
if [[ ! "${RELEASE_TAG}" =~ ^[A-Za-z0-9._-]+$ ]]; then
echo "Invalid release tag: only letters, digits, '.', '_' and '-' are allowed." >&2
exit 1
fi
- name: Login to DockerHub
uses: docker/login-action@v3
with:
@@ -30,16 +41,16 @@ jobs:
uses: actions/checkout@v4
- name: Run Build
run: |
docker build --provenance=false --build-arg VERSION=${{github.event.inputs.tag || github.ref_name}} -t ${{matrix.architecture}} .
CID=$(docker create ${{matrix.architecture}})
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
docker rm ${CID}
docker build --provenance=false --build-arg VERSION="${RELEASE_TAG}" -t "${ARCH}" .
CID=$(docker create "${ARCH}")
docker cp "${CID}:/home/agent" "./output-${ARCH}"
docker rm "${CID}"
- name: Strip binary
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
- name: Build and push Docker image
run: |
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
docker push $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
@@ -53,7 +64,15 @@ jobs:
strategy:
matrix:
architecture: [arm64]
env:
ARCH: ${{ matrix.architecture }}
steps:
- name: Validate release tag
run: |
if [[ ! "${RELEASE_TAG}" =~ ^[A-Za-z0-9._-]+$ ]]; then
echo "Invalid release tag: only letters, digits, '.', '_' and '-' are allowed." >&2
exit 1
fi
- name: Login to DockerHub
uses: docker/login-action@v3
with:
@@ -63,16 +82,16 @@ jobs:
uses: actions/checkout@v4
- name: Run Build
run: |
docker build --provenance=false --build-arg VERSION=${{github.event.inputs.tag || github.ref_name}} -t ${{matrix.architecture}} .
CID=$(docker create ${{matrix.architecture}})
docker cp ${CID}:/home/agent ./output-${{matrix.architecture}}
docker rm ${CID}
docker build --provenance=false --build-arg VERSION="${RELEASE_TAG}" -t "${ARCH}" .
CID=$(docker create "${ARCH}")
docker cp "${CID}:/home/agent" "./output-${ARCH}"
docker rm "${CID}"
- name: Strip binary
run: tar -cf agent-${{matrix.architecture}}.tar -C output-${{matrix.architecture}} . && rm -rf output-${{matrix.architecture}}
run: tar -cf "agent-${ARCH}.tar" -C "output-${ARCH}" . && rm -rf "output-${ARCH}"
- name: Build and push Docker image
run: |
docker tag ${{matrix.architecture}} $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
docker push $REPO-arch:arch-${{matrix.architecture}}-${{github.event.inputs.tag || github.ref_name}}
docker tag "${ARCH}" "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
docker push "${REPO}-arch:arch-${ARCH}-${RELEASE_TAG}"
- name: Upload artifact
uses: actions/upload-artifact@v4
with:
@@ -90,16 +109,16 @@ jobs:
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Create and push multi-arch manifest
run: |
docker manifest create $REPO:${{ github.event.inputs.tag || github.ref_name }} \
$REPO-arch:arch-amd64-${{github.event.inputs.tag || github.ref_name}} \
$REPO-arch:arch-arm64-${{github.event.inputs.tag || github.ref_name}}
docker manifest push $REPO:${{ github.event.inputs.tag || github.ref_name }}
docker manifest create "${REPO}:${RELEASE_TAG}" \
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
docker manifest push "${REPO}:${RELEASE_TAG}"
- name: Create and push latest manifest
run: |
docker manifest create $REPO:latest \
$REPO-arch:arch-amd64-${{github.event.inputs.tag || github.ref_name}} \
$REPO-arch:arch-arm64-${{github.event.inputs.tag || github.ref_name}}
docker manifest push $REPO:latest
docker manifest create "${REPO}:latest" \
"${REPO}-arch:arch-amd64-${RELEASE_TAG}" \
"${REPO}-arch:arch-arm64-${RELEASE_TAG}"
docker manifest push "${REPO}:latest"
if: github.event.inputs.tag == 'test'
create-release:
+1 -4
View File
@@ -1,8 +1,5 @@
# Pinned to 1.26.10: Go 1.26.11 rejects C archives containing LLVM bitcode
# ("disallowed LTO section .llvmbc"), and moq-go-ffi v0.3.x ships such archives.
# Unpin once the MoQ code moves to moq.dev/moq (moq-ffi v0.4.27+ is clean).
ARG GO_IMAGE=golang:1.26.10-trixie
ARG GO_IMAGE=golang:1.26-trixie
ARG RUNTIME_IMAGE=debian:trixie-slim
ARG VERSION=0.0.0
FROM ${GO_IMAGE} AS build-machinery
+58
View File
@@ -0,0 +1,58 @@
# Recording file structure
This document describes where the Kerberos Agent stores recordings, locally and in
direct S3 uploads, and how the current layout relates to the legacy one.
## 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.
## 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.
+23 -57
View File
@@ -61,6 +61,7 @@ There are a myriad of cameras out there (USB, IP and other cameras), and it migh
1. [Encryption](#encryption)
2. [H264 vs H265](#h264-vs-h265)
3. [Recording file structure](README-FILE-STRUCTURE.md)
### Contributing
@@ -76,60 +77,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. [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
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).
@@ -354,6 +301,22 @@ For a private CA, mount a PEM trust bundle containing every CA certificate neede
See [RTSPS and TLS certificates](README-RTSPS-TLS.md) for the complete Bosch UI, private-CA, deployment, validation, and troubleshooting procedure.
### RTSP transport (TCP, UDP or auto)
`AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT` (or the transport dropdown in Settings) selects how RTP media is received from the camera:
- `tcp` (default): media is interleaved on the RTSP TCP connection. Most reliable, works through any NAT or firewall.
- `udp`: media is sent over separate UDP ports. Lower latency, but lost packets are not resent.
- `auto`: UDP first, falling back to TCP when the camera refuses UDP or no UDP packets arrive within 3 seconds.
Notes:
- With `rtsps://` URLs, `udp` only works when the camera offers SRTP. Otherwise the connection fails with a message pointing to `tcp` or `auto`. `auto` uses TCP for such cameras on its own.
- The audio backchannel (talk-back) always uses TCP.
- For UDP the Agent requests a 4 MiB socket receive buffer, capped at the host's `net.core.rmem_max` (often about 208 KiB). For high-bitrate main streams, raise the limit on the host, for example `sysctl -w net.core.rmem_max=4194304`. Lost packets are logged as `rtp_packets_lost`.
- UDP needs the camera's RTP packets to reach the Agent. Docker bridge networking normally works; if a firewall or Kubernetes network policy drops them, use `auto` or `tcp`.
- The transport the Agent ended up with is logged as `rtsp_transport` (and `rtsp_transport_switch` when `auto` falls back to TCP).
| Name | Description | Default Value |
| --------------------------------------- | ----------------------------------------------------------------------------------------------- | ------------------------------ |
| `LOG_LEVEL` | Level for logging, could be "info", "warning", "debug", "error" or "fatal". | "info" |
@@ -375,6 +338,7 @@ See [RTSPS and TLS certificates](README-RTSPS-TLS.md) for the complete Bosch UI,
| `AGENT_TIMETABLE` | A (weekly) time table to specify when to make recordings "start1,end1,start2,end2;start1.. | "" |
| `AGENT_REGION_POLYGON` | A single polygon set for motion detection: "x1,y1;x2,y2;x3,y3;... | "" |
| `AGENT_CAPTURE_IPCAMERA_RTSP` | Full-HD RTSP or RTSPS endpoint for the target camera. | "" |
| `AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT` | Transport for the RTSP streams: "tcp", "udp" or "auto" (UDP first, falls back to TCP). | "tcp" |
| `AGENT_CAPTURE_IPCAMERA_SUB_RTSP` | RTSP or RTSPS sub-stream endpoint used for livestreaming (WebRTC). | "" |
| `AGENT_CAPTURE_IPCAMERA_RTSPS_CA_FILE` | PEM CA bundle appended to the system roots for RTSPS camera certificate verification. | "" |
| `AGENT_CAPTURE_IPCAMERA_RTSPS_INSECURE` | Disable RTSPS camera certificate verification; use only when a trusted CA cannot be installed. | "false" |
@@ -662,7 +626,9 @@ The Kerberos Agent is divided in two parts: a `machinery` and `web` part. Both p
### UI
The `web` is a **React** project which is the main entry point for an end user to view recordings, a livestream, and modify the configuration of the `machinery`.
The `web` is a **React** project, built with [Vite](https://vite.dev), which is
the main entry point for an end user to view recordings, a livestream, and
modify the configuration of the `machinery`.
git clone https://github.com/kerberos-io/agent
cd ui
@@ -671,7 +637,7 @@ The `web` is a **React** project which is the main entry point for an end user t
This starts the web app on port `3000`. In development, the UI connects to the
Agent API on port `8082`. Override that port when needed:
REACT_APP_AGENT_API_PORT=9090 yarn start
VITE_AGENT_API_PORT=9090 yarn start
![login-agent](./assets/img/agent-login.gif)
@@ -691,7 +657,7 @@ You can simply run the `machinery` using following commands.
This will launch the Kerberos Agent and run a webserver on port `8082`, matching
the UI development default. You can change the port together with
`REACT_APP_AGENT_API_PORT`. We strongly support the usage of
`VITE_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.
+2 -2
View File
@@ -27,7 +27,6 @@ require (
github.com/kerberos-io/joy4 v1.0.64
github.com/kerberos-io/onvif v1.2.3
github.com/minio/minio-go/v6 v6.0.57
github.com/moq-dev/moq-go v0.5.7
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
github.com/pion/interceptor v0.1.47
github.com/pion/rtcp v1.2.17
@@ -47,6 +46,7 @@ require (
go.opentelemetry.io/otel/sdk v1.47.0
go.opentelemetry.io/otel/trace v1.47.0
golang.org/x/net v0.62.0
moq.dev/moq v0.7.27
)
require (
@@ -99,7 +99,6 @@ require (
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/montanaflynn/stats v0.7.1 // indirect
github.com/moq-dev/moq-go-ffi v0.3.7 // indirect
github.com/nxadm/tail v1.4.11 // indirect
github.com/pelletier/go-toml/v2 v2.2.3 // indirect
github.com/pion/datachannel v1.6.2 // indirect
@@ -143,4 +142,5 @@ require (
gopkg.in/ini.v1 v1.42.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
howett.net/plist v0.0.0-20181124034731-591f970eefbb // indirect
moq.dev/moq-ffi v0.4.27 // indirect
)
+4 -4
View File
@@ -857,10 +857,6 @@ github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9G
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/montanaflynn/stats v0.7.1 h1:etflOAAHORrCC44V+aR6Ftzort912ZU+YLiSTuV8eaE=
github.com/montanaflynn/stats v0.7.1/go.mod h1:etXPPgVO6n31NxCd9KQUMvCM+ve0ruNzt6R8Bnaayow=
github.com/moq-dev/moq-go v0.5.7 h1:LfFpgAU8FRMcnU85L5Lb03HzxhYbQ2+BhT/pJQdjy5U=
github.com/moq-dev/moq-go v0.5.7/go.mod h1:5K8zjKKjWe5lzfCtlfxoAfdCr3KX6EBuTOZsz0WBnzw=
github.com/moq-dev/moq-go-ffi v0.3.7 h1:+xwPOzTJHvB0tuTnW6znbvvOgT4yLnN7sMqXXZYh02M=
github.com/moq-dev/moq-go-ffi v0.3.7/go.mod h1:zxpOlUetvaoxWBnbXTdILtLLUytaoVuLvO36lftwWO0=
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=
@@ -2174,6 +2170,10 @@ modernc.org/tcl v1.15.1/go.mod h1:aEjeGJX2gz1oWKOLDVZ2tnEWLUrIn8H+GFu+akoDhqs=
modernc.org/token v1.0.1/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
modernc.org/z v1.7.0/go.mod h1:hVdgNMh8ggTuRG1rGU8x+xGRFfiQUIAw0ZqlPy8+HyQ=
moq.dev/moq v0.7.27 h1:MICXMveLyoFBPj6Tu10oLH8NMhkYaDOa7oe6ay0RQ/c=
moq.dev/moq v0.7.27/go.mod h1:zdCa+pXvmwXg+qTXgVJzO9jX7GbI7R/AFGwWOx1BKg0=
moq.dev/moq-ffi v0.4.27 h1:PCXoyW1QTUN2XnM4pkAIBGpOAFjhm1OmCyPfPHszKPc=
moq.dev/moq-ffi v0.4.27/go.mod h1:a+uEvcnNtY3e9T4/3UqjHBnyYHNLY8rZp+/m7tmL5n8=
nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
+140 -5
View File
@@ -32,6 +32,7 @@ import (
"github.com/bluenviron/gortsplib/v5/pkg/format/rtplpcm"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpmpeg4audio"
"github.com/bluenviron/gortsplib/v5/pkg/format/rtpsimpleaudio"
"github.com/bluenviron/gortsplib/v5/pkg/headers"
"github.com/bluenviron/mediacommon/pkg/bits"
"github.com/bluenviron/mediacommon/pkg/codecs/h264"
"github.com/bluenviron/mediacommon/pkg/codecs/h265"
@@ -50,6 +51,104 @@ const (
rtspsInsecureEnv = "AGENT_CAPTURE_IPCAMERA_RTSPS_INSECURE"
)
// RTSP transport options for the camera connection.
const (
RTSPTransportTCP = "tcp"
RTSPTransportUDP = "udp"
RTSPTransportAuto = "auto"
)
// rtspProtocol maps the configured RTSP transport onto the gortsplib client
// protocol. An empty value keeps the historical default (TCP). "auto" returns
// nil, which lets gortsplib try UDP first and fall back to TCP when the camera
// or the network does not support it. Unknown values fall back to TCP.
func rtspProtocol(transport string) *gortsplib.Protocol {
var protocol gortsplib.Protocol
switch strings.ToLower(strings.TrimSpace(transport)) {
case "", RTSPTransportTCP:
protocol = gortsplib.ProtocolTCP
case RTSPTransportUDP:
protocol = gortsplib.ProtocolUDP
case RTSPTransportAuto:
return nil
default:
log.Warn("capture.golibrtsp.rtspProtocol(): unknown RTSP transport \"" + transport + "\", falling back to tcp")
protocol = gortsplib.ProtocolTCP
}
return &protocol
}
// backChannelProtocol is the transport used for the audio backchannel. It is
// always TCP: gortsplib's "auto" fallback only switches to TCP when no packets
// are received over UDP, which never happens on a send-only backchannel, and
// talk-back over UDP has not been validated on camera hardware.
func backChannelProtocol() *gortsplib.Protocol {
protocol := gortsplib.ProtocolTCP
return &protocol
}
// errSecureUDPUnavailable is returned when UDP is forced on an RTSPS camera
// that does not offer SRTP, so the media could not be sent encrypted over UDP.
var errSecureUDPUnavailable = errors.New(
"the RTSPS camera does not offer SRTP, so RTP over UDP cannot be encrypted; " +
"set the RTSP transport to \"tcp\" or \"auto\"")
// checkSecureUDP rejects forced UDP on an RTSPS stream whose video media is not
// SRTP (RTP/SAVP). gortsplib would otherwise fail every SETUP with "unable to
// setup secure UDP", which Connect only logs. "auto" is not affected because
// gortsplib picks TCP on its own for such streams.
func checkSecureUDP(scheme string, protocol *gortsplib.Protocol, medias []*description.Media) error {
if protocol == nil || *protocol != gortsplib.ProtocolUDP || !strings.EqualFold(scheme, "rtsps") {
return nil
}
for _, medi := range medias {
if medi.Type == description.MediaTypeVideo && medi.Profile != headers.TransportProfileSAVP {
return errSecureUDPUnavailable
}
}
return nil
}
// udpReadBufferTarget is the UDP socket read buffer requested for RTP over
// UDP. The OS default (around 208 KiB on Linux) drops packets on
// high-bitrate main streams.
const udpReadBufferTarget = 4 * 1024 * 1024
// rmemMaxPath holds the largest receive buffer an unprivileged socket may use.
const rmemMaxPath = "/proc/sys/net/core/rmem_max"
// udpReadBufferSize returns the UDP read buffer to request: the target,
// capped at the OS limit rmemMax. gortsplib fails the SETUP when it cannot get
// the exact size it asked for, so the size must never exceed the limit. It
// returns 0 (OS default) for TCP, or when the limit is unknown or not above the
// default.
func udpReadBufferSize(protocol *gortsplib.Protocol, rmemMax int) int {
if protocol != nil && *protocol == gortsplib.ProtocolTCP {
return 0
}
if rmemMax <= 0 {
return 0
}
if rmemMax < udpReadBufferTarget {
return rmemMax
}
return udpReadBufferTarget
}
// readRmemMax reads the OS receive buffer limit, or 0 when it is unavailable
// (non-Linux systems or a restricted /proc).
func readRmemMax() int {
data, err := os.ReadFile(rmemMaxPath)
if err != nil {
return 0
}
value, err := strconv.Atoi(strings.TrimSpace(string(data)))
if err != nil {
return 0
}
return value
}
func rtspsTLSConfig() (*tls.Config, error) {
if os.Getenv(rtspsInsecureEnv) == "true" {
return &tls.Config{InsecureSkipVerify: true}, nil // #nosec G402 -- explicit opt-in for cameras with self-signed certificates
@@ -97,6 +196,8 @@ func sanitizeRTSPError(err error, rawURL string) error {
type Golibrtsp struct {
RTSPClient
Url string
// Transport selects the RTSP transport: "tcp" (default), "udp" or "auto".
Transport string
Client gortsplib.Client
clientStarted bool
@@ -546,12 +647,22 @@ func (g *Golibrtsp) Connect(ctx context.Context, ctxOtel context.Context) (err e
return fmt.Errorf("configure RTSPS TLS: %w", err)
}
protocol := gortsplib.ProtocolTCP
g.health = newStreamHealth()
protocol := rtspProtocol(g.Transport)
g.Client = gortsplib.Client{
RequestBackChannels: false,
Protocol: &protocol,
Protocol: protocol,
UDPReadBufferSize: udpReadBufferSize(protocol, readRmemMax()),
TLSConfig: tlsConfig,
// In "auto" mode gortsplib may move from UDP to TCP; report it through
// the structured logger instead of gortsplib's plain stdout logging.
OnTransportSwitch: func(err error) {
log.WithFields(log.Fields{
"component": "capture",
"event": "rtsp_transport_switch",
"stream": g.streamLabel,
}).Warn("RTSP transport switched: " + err.Error())
},
// Route gortsplib's packet-loss / decode-error reporting through our
// structured logger with stream context (replaces its plain stdout
// logging). These hooks are what let us tell whether the camera is
@@ -585,6 +696,10 @@ func (g *Golibrtsp) Connect(ctx context.Context, ctxOtel context.Context) (err e
return sanitizeRTSPError(err, g.Url)
}
if err = checkSecureUDP(u.Scheme, protocol, desc.Medias); err != nil {
return err
}
// Initialize the mutex and FPS calculation.
g.VideoDecoderMutex = &sync.Mutex{}
g.initFPSCalculation()
@@ -822,6 +937,27 @@ func (g *Golibrtsp) Connect(ctx context.Context, ctxOtel context.Context) (err e
return
}
// logNegotiatedTransport logs the transport that SETUP agreed on, which can
// differ from the configured one in "auto" mode. A later UDP to TCP switch
// (no packets received in time) is reported by OnTransportSwitch.
func (g *Golibrtsp) logNegotiatedTransport() {
transport := g.Client.Transport()
if transport == nil || transport.Session == nil {
return
}
configured := strings.ToLower(strings.TrimSpace(g.Transport))
if configured == "" {
configured = RTSPTransportTCP
}
log.WithFields(log.Fields{
"component": "capture",
"event": "rtsp_transport",
"stream": g.streamLabel,
"configured": configured,
"negotiated": transport.Session.Protocol.String(),
}).Info("RTSP transport negotiated")
}
func (g *Golibrtsp) ConnectBackChannel(ctx context.Context, ctxRunAgent context.Context) (err error) {
_, span := tracer.Start(ctxRunAgent, "ConnectBackChannel")
@@ -832,11 +968,9 @@ func (g *Golibrtsp) ConnectBackChannel(ctx context.Context, ctxRunAgent context.
return fmt.Errorf("configure RTSPS TLS: %w", err)
}
// Transport TCP
protocol := gortsplib.ProtocolTCP
g.Client = gortsplib.Client{
RequestBackChannels: true,
Protocol: &protocol,
Protocol: backChannelProtocol(),
TLSConfig: tlsConfig,
}
// parse URL
@@ -956,6 +1090,7 @@ func (g *Golibrtsp) Start(ctx context.Context, streamType string, queue *packets
if g.health == nil {
g.health = newStreamHealth()
}
g.logNegotiatedTransport()
// called when a MULAW audio RTP packet arrives
if g.AudioG711Media != nil && g.AudioG711Forma != nil {
+100
View File
@@ -12,6 +12,9 @@ import (
"strings"
"testing"
"github.com/bluenviron/gortsplib/v5"
"github.com/bluenviron/gortsplib/v5/pkg/description"
"github.com/bluenviron/gortsplib/v5/pkg/headers"
"github.com/bluenviron/mediacommon/pkg/codecs/h264"
)
@@ -247,3 +250,100 @@ func TestH264FrameNumTrackerHonorsPermittedGaps(t *testing.T) {
func testH264Slice(naluType h264.NALUType, frameNum uint32) []byte {
return []byte{0x60 | byte(naluType), 0xE0 | byte(frameNum&0x1F)}
}
func TestRTSPProtocol(t *testing.T) {
tcp := gortsplib.ProtocolTCP
udp := gortsplib.ProtocolUDP
tests := []struct {
transport string
want *gortsplib.Protocol
}{
{transport: "", want: &tcp},
{transport: "tcp", want: &tcp},
{transport: " TCP ", want: &tcp},
{transport: "udp", want: &udp},
{transport: "UDP", want: &udp},
{transport: "auto", want: nil},
{transport: "Auto", want: nil},
{transport: "bogus", want: &tcp},
}
for _, test := range tests {
t.Run(test.transport, func(t *testing.T) {
got := rtspProtocol(test.transport)
if test.want == nil {
if got != nil {
t.Fatalf("rtspProtocol(%q) = %v, want nil (auto)", test.transport, *got)
}
return
}
if got == nil || *got != *test.want {
t.Fatalf("rtspProtocol(%q) = %v, want %v", test.transport, got, *test.want)
}
})
}
}
func TestBackChannelProtocolIsTCP(t *testing.T) {
if got := backChannelProtocol(); got == nil || *got != gortsplib.ProtocolTCP {
t.Fatalf("backChannelProtocol() = %v, want tcp", got)
}
}
func TestCheckSecureUDP(t *testing.T) {
tcp := gortsplib.ProtocolTCP
udp := gortsplib.ProtocolUDP
plainVideo := []*description.Media{
{Type: description.MediaTypeVideo, Profile: headers.TransportProfileAVP},
}
srtpVideo := []*description.Media{
{Type: description.MediaTypeVideo, Profile: headers.TransportProfileSAVP},
}
tests := []struct {
name string
scheme string
protocol *gortsplib.Protocol
medias []*description.Media
wantErr bool
}{
{name: "rtsps udp plain video", scheme: "rtsps", protocol: &udp, medias: plainVideo, wantErr: true},
{name: "rtsps udp srtp video", scheme: "rtsps", protocol: &udp, medias: srtpVideo},
{name: "rtsps tcp", scheme: "rtsps", protocol: &tcp, medias: plainVideo},
{name: "rtsps auto", scheme: "rtsps", protocol: nil, medias: plainVideo},
{name: "rtsp udp", scheme: "rtsp", protocol: &udp, medias: plainVideo},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
err := checkSecureUDP(test.scheme, test.protocol, test.medias)
if test.wantErr && !errors.Is(err, errSecureUDPUnavailable) {
t.Fatalf("checkSecureUDP() = %v, want errSecureUDPUnavailable", err)
}
if !test.wantErr && err != nil {
t.Fatalf("checkSecureUDP() = %v, want nil", err)
}
})
}
}
func TestUDPReadBufferSize(t *testing.T) {
tcp := gortsplib.ProtocolTCP
udp := gortsplib.ProtocolUDP
tests := []struct {
name string
protocol *gortsplib.Protocol
rmemMax int
want int
}{
{name: "tcp keeps os default", protocol: &tcp, rmemMax: 8 << 20, want: 0},
{name: "unknown limit keeps os default", protocol: &udp, rmemMax: 0, want: 0},
{name: "default linux limit", protocol: &udp, rmemMax: 212992, want: 212992},
{name: "raised limit capped at target", protocol: &udp, rmemMax: 16 << 20, want: udpReadBufferTarget},
{name: "auto uses target", protocol: nil, rmemMax: 16 << 20, want: udpReadBufferTarget},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if got := udpReadBufferSize(test.protocol, test.rmemMax); got != test.want {
t.Fatalf("udpReadBufferSize() = %d, want %d", got, test.want)
}
})
}
}
+2 -1
View File
@@ -858,7 +858,8 @@ func VerifyCamera(c *gin.Context) {
// Currently only support H264 encoded cameras, this will change.
// Establishing the camera connection without backchannel if no substream
rtspClient := &Golibrtsp{
Url: rtspUrl,
Url: rtspUrl,
Transport: cameraStreams.RTSPTransport,
}
err := rtspClient.Connect(ctx, ctxVerifyCamera)
+51 -22
View File
@@ -1503,9 +1503,9 @@ func VerifyHub(c *gin.Context, configuredHubURI string) {
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr, CheckRedirect: rejectHubVerificationRedirect}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
} else {
client = &http.Client{CheckRedirect: rejectHubVerificationRedirect}
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
}
resp, err := client.Do(req)
@@ -1554,7 +1554,7 @@ func VerifyHub(c *gin.Context, configuredHubURI string) {
// @Summary Will verify the persistence.
// @Description Will verify the persistence.
// @Success 200 {object} models.APIResponse
func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string) {
func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI, configuredVaultURI string) {
var config models.Config
err := c.BindJSON(&config)
@@ -1610,9 +1610,9 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr, CheckRedirect: rejectHubVerificationRedirect}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
} else {
client = &http.Client{CheckRedirect: rejectHubVerificationRedirect}
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
}
resp, err := client.Do(req)
@@ -1655,18 +1655,27 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
provider := config.KStorage.Provider
if err == nil && uri != "" && accessKey != "" && secretAccessKey != "" {
vaultURI, uriErr := configuredVaultVerificationURI(uri, configuredVaultURI)
if uriErr != nil {
msg := "cloud.VerifyPersistence(kerberosvault): " + uriErr.Error()
log.Error(msg)
c.JSON(http.StatusBadRequest, models.APIResponse{
Data: msg,
})
return
}
var client *http.Client
if os.Getenv("AGENT_TLS_INSECURE") == "true" {
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
} else {
client = &http.Client{}
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
}
req, err := http.NewRequest("POST", uri+"/ping", nil)
req, err := http.NewRequest("POST", vaultURI+"/ping", nil)
if err == nil {
req.Header.Add("X-Kerberos-Storage-AccessKey", accessKey)
req.Header.Add("X-Kerberos-Storage-SecretAccessKey", secretAccessKey)
@@ -1695,7 +1704,7 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
}
defer file.Close()
req, err := http.NewRequest("POST", uri+"/storage", file)
req, err := http.NewRequest("POST", vaultURI+"/storage", file)
if err == nil {
req.Header.Set("Content-Type", "video/mp4")
@@ -1713,9 +1722,9 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
} else {
client = &http.Client{}
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
}
resp, err := client.Do(req)
@@ -1807,19 +1816,30 @@ func VerifyPersistence(c *gin.Context, configDirectory, configuredHubURI string)
}
}
func configuredHubVerificationURI(requested, configured string) (string, error) {
// configuredVerificationURI only lets a verify request reach the endpoint that
// is already saved in the agent configuration. It returns the saved value, not
// the requested one, so credentials are never sent to a URI from the request body.
func configuredVerificationURI(target, 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")
return "", errors.New("save the " + target + " URI before verifying it")
}
if requested != configured {
return "", errors.New("the Hub URI does not match the saved configuration; save it before verifying")
return "", errors.New("the " + target + " URI does not match the saved configuration; save it before verifying")
}
return configured, nil
}
func rejectHubVerificationRedirect(_ *http.Request, _ []*http.Request) error {
func configuredHubVerificationURI(requested, configured string) (string, error) {
return configuredVerificationURI("Hub", requested, configured)
}
func configuredVaultVerificationURI(requested, configured string) (string, error) {
return configuredVerificationURI("Kerberos Vault", requested, configured)
}
func rejectVerificationRedirect(_ *http.Request, _ []*http.Request) error {
return http.ErrUseLastResponse
}
@@ -1850,7 +1870,7 @@ func hubPersistenceVerificationError(statusCode int) string {
// @Summary Will verify the secondary persistence.
// @Description Will verify the secondary persistence.
// @Success 200 {object} models.APIResponse
func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
func VerifySecondaryPersistence(c *gin.Context, configDirectory, configuredVaultURI string) {
var config models.Config
err := c.BindJSON(&config)
@@ -1874,18 +1894,27 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
provider := config.KStorageSecondary.Provider
if err == nil && uri != "" && accessKey != "" && secretAccessKey != "" {
vaultURI, uriErr := configuredVaultVerificationURI(uri, configuredVaultURI)
if uriErr != nil {
msg := "cloud.VerifySecondaryPersistence(kerberosvault): " + uriErr.Error()
log.Error(msg)
c.JSON(http.StatusBadRequest, models.APIResponse{
Data: msg,
})
return
}
var client *http.Client
if os.Getenv("AGENT_TLS_INSECURE") == "true" {
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
} else {
client = &http.Client{}
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
}
req, err := http.NewRequest("POST", uri+"/ping", nil)
req, err := http.NewRequest("POST", vaultURI+"/ping", nil)
if err == nil {
req.Header.Add("X-Kerberos-Storage-AccessKey", accessKey)
req.Header.Add("X-Kerberos-Storage-SecretAccessKey", secretAccessKey)
@@ -1914,7 +1943,7 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
}
defer file.Close()
req, err := http.NewRequest("POST", uri+"/storage", file)
req, err := http.NewRequest("POST", vaultURI+"/storage", file)
if err == nil {
req.Header.Set("Content-Type", "video/mp4")
@@ -1932,9 +1961,9 @@ func VerifySecondaryPersistence(c *gin.Context, configDirectory string) {
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
client = &http.Client{Transport: tr}
client = &http.Client{Transport: tr, CheckRedirect: rejectVerificationRedirect}
} else {
client = &http.Client{}
client = &http.Client{CheckRedirect: rejectVerificationRedirect}
}
resp, err := client.Do(req)
+126 -3
View File
@@ -53,7 +53,7 @@ func TestVerifyPersistenceKerberosHubUsesAuthorizationHead(t *testing.T) {
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)
VerifyPersistence(ctx, t.TempDir(), server.URL, "")
if recorder.Code != http.StatusOK {
t.Fatalf("status = %d, body = %s", recorder.Code, recorder.Body.String())
@@ -112,7 +112,7 @@ func TestVerifyPersistenceKerberosHubRejectsCrossHostRedirect(t *testing.T) {
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)
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())
@@ -155,7 +155,7 @@ func TestVerifyPersistenceKerberosHubRejectsUnsavedURI(t *testing.T) {
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")
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())
@@ -199,6 +199,129 @@ func TestVerifyHubRejectsUnsavedURI(t *testing.T) {
}
}
func vaultVerifyContext(t *testing.T, path string, config models.Config) (*gin.Context, *httptest.ResponseRecorder) {
t.Helper()
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, path, bytes.NewReader(payload))
ctx.Request.Header.Set("Content-Type", "application/json")
return ctx, recorder
}
func vaultStorage(uri string) *models.KStorage {
return &models.KStorage{
URI: uri,
AccessKey: "vault-access",
SecretAccessKey: "vault-secret",
Provider: "minio",
Directory: "camera-1",
}
}
func TestVerifyPersistenceVaultRejectsUnsavedURI(t *testing.T) {
requestCount := 0
untrusted := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
requestCount++
w.WriteHeader(http.StatusOK)
}))
defer untrusted.Close()
ctx, recorder := vaultVerifyContext(t, "/api/persistence/verify", models.Config{
Cloud: "kerberosvault",
KStorage: vaultStorage(untrusted.URL),
})
VerifyPersistence(ctx, t.TempDir(), "", "https://saved-vault.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 Vault received %d requests, want none", requestCount)
}
}
func TestVerifySecondaryPersistenceVaultRejectsUnsavedURI(t *testing.T) {
requestCount := 0
untrusted := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
requestCount++
w.WriteHeader(http.StatusOK)
}))
defer untrusted.Close()
ctx, recorder := vaultVerifyContext(t, "/api/persistence/secondary/verify", models.Config{
Cloud: "kerberosvault",
KStorageSecondary: vaultStorage(untrusted.URL),
})
VerifySecondaryPersistence(ctx, t.TempDir(), "")
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 Vault received %d requests, want none", requestCount)
}
}
func TestVerifyPersistenceVaultUsesSavedURI(t *testing.T) {
var pingHeaders http.Header
vault := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/ping" {
pingHeaders = r.Header.Clone()
}
w.WriteHeader(http.StatusInternalServerError)
}))
defer vault.Close()
ctx, _ := vaultVerifyContext(t, "/api/persistence/verify", models.Config{
Cloud: "kerberosvault",
KStorage: vaultStorage(vault.URL + "/"),
})
VerifyPersistence(ctx, t.TempDir(), "", vault.URL)
if pingHeaders == nil {
t.Fatal("saved Vault did not receive the /ping request")
}
if got := pingHeaders.Get("X-Kerberos-Storage-AccessKey"); got != "vault-access" {
t.Fatalf("X-Kerberos-Storage-AccessKey = %q, want %q", got, "vault-access")
}
}
func TestVerifySecondaryPersistenceVaultRejectsCrossHostRedirect(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()
vault := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, target.URL+r.URL.Path, http.StatusTemporaryRedirect)
}))
defer vault.Close()
ctx, recorder := vaultVerifyContext(t, "/api/persistence/secondary/verify", models.Config{
Cloud: "kerberosvault",
KStorageSecondary: vaultStorage(vault.URL),
})
VerifySecondaryPersistence(ctx, t.TempDir(), vault.URL)
if recorder.Code != http.StatusBadRequest {
t.Fatalf("status = %d, want %d; body = %s", recorder.Code, http.StatusBadRequest, recorder.Body.String())
}
if redirectedHeaders != nil {
t.Fatalf("redirect target received a request with X-Kerberos-Storage-SecretAccessKey=%q", redirectedHeaders.Get("X-Kerberos-Storage-SecretAccessKey"))
}
}
func TestHubPersistenceVerificationErrorExplainsStatus(t *testing.T) {
for _, test := range []struct {
status int
+2 -2
View File
@@ -16,7 +16,7 @@ import (
"github.com/kerberos-io/agent/machinery/src/cloud/livemoq"
"github.com/kerberos-io/agent/machinery/src/models"
"github.com/kerberos-io/agent/machinery/src/packets"
"github.com/moq-dev/moq-go/moq"
"moq.dev/moq"
log "github.com/sirupsen/logrus"
)
@@ -292,7 +292,7 @@ func publishLiveStreamMoQ(ctx context.Context, config liveMoQConfig) error {
}
defer finishBroadcast()
stream, err := broadcast.PublishMedia("avc3", nil)
stream, err := broadcast.PublishVideo(moq.VideoFormatAvc3, nil)
if err != nil {
return fmt.Errorf("create H.264 media stream: %w", err)
}
+2 -2
View File
@@ -12,7 +12,7 @@ import (
"github.com/kerberos-io/agent/machinery/src/cloud/livemoq"
"github.com/kerberos-io/agent/machinery/src/models"
"github.com/moq-dev/moq-go/moq"
"moq.dev/moq"
)
func TestCloseLiveMoQPublisherFinishesBeforeClosingClient(t *testing.T) {
@@ -155,7 +155,7 @@ func TestNativeMoQClientCloseStopsActiveWriter(t *testing.T) {
server.Close()
t.Fatal(err)
}
stream, err := broadcast.PublishMedia("avc3", nil)
stream, err := broadcast.PublishVideo(moq.VideoFormatAvc3, nil)
if err != nil {
client.Close()
server.Close()
+4 -2
View File
@@ -59,11 +59,13 @@ func UploadS3(configuration *models.Configuration, fileName string) (bool, bool,
// Check if we need to use the proxy.
if config.S3.ProxyURI != "" {
var transport http.RoundTripper = &http.Transport{
transport := &http.Transport{
Proxy: func(*http.Request) (*url.URL, error) {
return url.Parse(config.S3.ProxyURI)
},
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
if os.Getenv("AGENT_TLS_INSECURE") == "true" {
transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
}
s3Client.SetCustomTransport(transport)
}
+3
View File
@@ -207,6 +207,7 @@ func RunAgent(parent context.Context, configDirectory string, configuration *mod
// Establishing the camera connection without backchannel if no substream
rtspUrl := mainRTSP
rtspClient = captureDevice.SetMainClient(rtspUrl)
rtspClient.Transport = config.Capture.IPCamera.RTSPTransport
run.SetMainClient(rtspClient)
if rtspUrl != "" {
err := rtspClient.Connect(run.Context(), ctxRunAgent)
@@ -316,6 +317,7 @@ func RunAgent(parent context.Context, configDirectory string, configuration *mod
// For the sub stream we will not enable backchannel.
subStreamEnabled = true
rtspSubClient = captureDevice.SetSubClient(subRtspUrl)
rtspSubClient.Transport = config.Capture.IPCamera.RTSPTransport
run.SetSubClient(rtspSubClient)
@@ -436,6 +438,7 @@ func RunAgent(parent context.Context, configDirectory string, configuration *mod
// Try to create backchannel
communication.HasBackChannel.Store(false)
rtspBackChannelClient = captureDevice.SetBackChannelClient(rtspUrl)
rtspBackChannelClient.Transport = config.Capture.IPCamera.RTSPTransport
run.SetBackchannelClient(rtspBackChannelClient)
err = rtspBackChannelClient.ConnectBackChannel(run.Context(), ctxRunAgent)
if err == nil {
+5
View File
@@ -369,6 +369,11 @@ func applyAgentEnvVars(configuration *models.Configuration, prefix string, apply
case "AGENT_CAPTURE_IPCAMERA_RTSP":
configuration.Config.Capture.IPCamera.RTSP = value
break
case "AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT":
configuration.Config.Capture.IPCamera.RTSPTransport = value
break
case "AGENT_CAPTURE_IPCAMERA_SUB_RTSP":
configuration.Config.Capture.IPCamera.SubRTSP = value
break
+12
View File
@@ -104,6 +104,18 @@ func TestApplyAgentEnvVarsVaultCustomHeaders(t *testing.T) {
}
}
func TestApplyAgentEnvVarsRTSPTransport(t *testing.T) {
t.Setenv("AGENT_CAPTURE_IPCAMERA_RTSP_TRANSPORT", "udp")
configuration := &models.Configuration{}
initConfigPointers(&configuration.Config)
applyAgentEnvVars(configuration, "", false)
if got := configuration.Config.Capture.IPCamera.RTSPTransport; got != "udp" {
t.Fatalf("RTSPTransport = %q, want udp", got)
}
}
func intPointer(value int) *int {
return &value
}
+2
View File
@@ -18,6 +18,8 @@ type OnvifCredentials struct {
type CameraStreams struct {
RTSP string `json:"rtsp"`
SubRTSP string `json:"sub_rtsp"`
// RTSPTransport is optional: "tcp" (default), "udp" or "auto".
RTSPTransport string `json:"rtsp_transport,omitempty"`
}
// DiscoveredDevice describes a device found on the local network during a
+4
View File
@@ -93,6 +93,10 @@ type IPCamera struct {
Height int `json:"height"`
FPS string `json:"fps"`
// RTSPTransport selects the transport used for RTSP media: "tcp"
// (default), "udp" or "auto" (UDP first, falling back to TCP).
RTSPTransport string `json:"rtsp_transport,omitempty" bson:"rtsp_transport,omitempty"`
SubRTSP string `json:"sub_rtsp"`
SubWidth int `json:"sub_width"`
SubHeight int `json:"sub_height"`
+1 -1
View File
@@ -16,7 +16,7 @@ import (
func TestHealthCheckReturnsStandardPublicResponse(t *testing.T) {
gin.SetMode(gin.TestMode)
middlewareConfig := JWTMiddleWare()
middlewareConfig := JWTMiddleWare(t.TempDir())
authMiddleware, err := jwt.New(&middlewareConfig)
if err != nil {
t.Fatalf("initialize JWT middleware: %v", err)
+20 -23
View File
@@ -11,21 +11,17 @@ import (
"github.com/kerberos-io/agent/machinery/src/models"
)
func JWTMiddleWare() jwt.GinJWTMiddleware {
func JWTMiddleWare(configDirectory string) jwt.GinJWTMiddleware {
identityKey := "id"
// Allow the JWT signing secret to be configured through an environment
// variable so that tokens issued by another service (e.g. the Kerberos
// Factory) can be validated by the agent. Falls back to the historic
// default to preserve backwards compatibility.
myKey := os.Getenv("AGENT_JWT_SECRET")
if myKey == "" {
myKey = "TOBECHANGED"
}
// AGENT_JWT_SECRET lets tokens issued by another service (e.g. the
// Kerberos Factory) be validated by the agent. Without it, a random secret
// is generated once and stored with the configuration; see loadJWTSecret.
myKey := loadJWTSecret(configDirectory)
m := jwt.GinJWTMiddleware{
Realm: "kerberosio",
Key: []byte(myKey),
Key: myKey,
Timeout: time.Hour * 24,
MaxRefresh: time.Hour * 24 * 7,
IdentityKey: identityKey,
@@ -39,10 +35,15 @@ func JWTMiddleWare() jwt.GinJWTMiddleware {
},
IdentityHandler: func(c *gin.Context) interface{} {
claims := jwt.ExtractClaims(c)
user := claims["id"].(map[string]interface{})
user, ok := claims["id"].(map[string]interface{})
if !ok {
return nil
}
username, _ := user["username"].(string)
role, _ := user["role"].(string)
return &models.User{
Username: user["username"].(string),
Role: user["role"].(string),
Username: username,
Role: role,
}
},
Authenticator: func(c *gin.Context) (interface{}, error) {
@@ -53,11 +54,7 @@ func JWTMiddleWare() jwt.GinJWTMiddleware {
username := loginVals.Username
password := loginVals.Password
// Get username from ENV
usernameFromConfig := os.Getenv("AGENT_USERNAME")
if usernameFromConfig == "" {
usernameFromConfig = "root"
}
usernameFromConfig := agentUsername()
// Get password from ENV
passwordFromConfig := os.Getenv("AGENT_PASSWORD")
if passwordFromConfig == "" {
@@ -76,7 +73,7 @@ func JWTMiddleWare() jwt.GinJWTMiddleware {
LoginResponse: func(c *gin.Context, code int, token string, expire time.Time) {
// Decrypt the token
hmacSecret := []byte(myKey) // todo in config file
hmacSecret := myKey
t, _ := jwtgo.Parse(token, func(token *jwtgo.Token) (interface{}, error) {
return hmacSecret, nil
})
@@ -94,10 +91,10 @@ func JWTMiddleWare() jwt.GinJWTMiddleware {
})
},
Authorizator: func(data interface{}, c *gin.Context) bool {
if _, ok := data.(*models.User); ok { //&& v.Username == "admin" {
return true
}
return false
// Only the configured account may use the API, even with a
// validly signed token.
user, ok := data.(*models.User)
return ok && user.Username != "" && user.Username == agentUsername()
},
Unauthorized: func(c *gin.Context, code int, message string) {
c.AbortWithStatusJSON(code, gin.H{
+113
View File
@@ -0,0 +1,113 @@
package http
import (
"crypto/rand"
"encoding/hex"
"errors"
"os"
"path/filepath"
"strings"
log "github.com/sirupsen/logrus"
)
const (
// jwtSecretFileName lives next to config.json so it persists on the same
// volume and survives restarts and upgrades.
jwtSecretFileName = "jwt_secret"
// minJWTSecretLength is the shortest persisted secret that is accepted.
// Generated secrets are 64 hex characters (32 random bytes).
minJWTSecretLength = 32
// legacyJWTSecret was the hard-coded fallback in earlier releases. It is
// public, so it is never used implicitly.
legacyJWTSecret = "TOBECHANGED"
)
// loadJWTSecret returns the key used to sign and verify API tokens.
//
// AGENT_JWT_SECRET always wins, so deployments that share a secret with
// another service (such as Kerberos Factory) keep working. Without it, a
// random secret is generated on first start and stored in
// <configDirectory>/data/config/jwt_secret. If that file cannot be written,
// an in-memory random secret is used, which means users must sign in again
// after a restart.
func loadJWTSecret(configDirectory string) []byte {
if secret := os.Getenv("AGENT_JWT_SECRET"); secret != "" {
if secret == legacyJWTSecret {
log.WithFields(log.Fields{
"component": "http",
"event": "jwt_secret_insecure",
}).Warn("AGENT_JWT_SECRET is set to the publicly known legacy default; set a random value")
}
return []byte(secret)
}
path := filepath.Join(configDirectory, "data", "config", jwtSecretFileName)
if data, err := os.ReadFile(path); err == nil {
secret := strings.TrimSpace(string(data))
if len(secret) >= minJWTSecretLength {
return []byte(secret)
}
log.WithFields(log.Fields{
"component": "http",
"event": "jwt_secret_invalid",
"path": path,
}).Warn("Stored JWT secret is too short; generating a new one")
} else if !errors.Is(err, os.ErrNotExist) {
log.WithError(err).WithFields(log.Fields{
"component": "http",
"event": "jwt_secret_read_failed",
"path": path,
}).Warn("Could not read stored JWT secret; generating a new one")
}
secret, err := randomJWTSecret()
if err != nil {
log.WithError(err).WithFields(log.Fields{
"component": "http",
"event": "jwt_secret_generation_failed",
}).Fatal("Could not generate a JWT signing secret")
}
if err := writeJWTSecret(path, secret); err != nil {
log.WithError(err).WithFields(log.Fields{
"component": "http",
"event": "jwt_secret_persist_failed",
"path": path,
}).Warn("Could not store the generated JWT secret; sessions will not survive a restart")
} else {
log.WithFields(log.Fields{
"component": "http",
"event": "jwt_secret_generated",
"path": path,
}).Info("Generated a new JWT signing secret")
}
return []byte(secret)
}
func randomJWTSecret() (string, error) {
buf := make([]byte, 32)
if _, err := rand.Read(buf); err != nil {
return "", err
}
return hex.EncodeToString(buf), nil
}
func writeJWTSecret(path, secret string) error {
if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
return err
}
tmp := path + ".tmp"
if err := os.WriteFile(tmp, []byte(secret+"\n"), 0o600); err != nil {
return err
}
return os.Rename(tmp, path)
}
// agentUsername is the single account allowed to use the API.
func agentUsername() string {
if username := os.Getenv("AGENT_USERNAME"); username != "" {
return username
}
return "root"
}
+15 -3
View File
@@ -18,7 +18,10 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
HealthCheck(c, communication)
})
r.GET("/ws", func(c *gin.Context) {
// The WebSocket carries the live camera stream, so it needs a token like
// the API. Browsers cannot set headers on WebSocket requests, so the UI
// passes it as the ?token= query parameter.
r.GET("/ws", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
websocket.WebsocketHandler(c, configuration, communication, captureDevice)
})
@@ -70,12 +73,12 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
// Will verify the persistence settings.
api.POST("/persistence/verify", func(c *gin.Context) {
cloud.VerifyPersistence(c, configDirectory, configuration.Config.HubURI)
cloud.VerifyPersistence(c, configDirectory, configuration.Config.HubURI, savedVaultURI(configuration.Config.KStorage))
})
// Will verify the secondary persistence settings.
api.POST("/persistence/secondary/verify", func(c *gin.Context) {
cloud.VerifySecondaryPersistence(c, configDirectory)
cloud.VerifySecondaryPersistence(c, configDirectory, savedVaultURI(configuration.Config.KStorageSecondary))
})
// Camera specific methods.
@@ -117,3 +120,12 @@ func AddRoutes(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirect
}
return api
}
// savedVaultURI returns the Kerberos Vault URI from the saved configuration,
// which is the only endpoint a persistence verify request may contact.
func savedVaultURI(storage *models.KStorage) string {
if storage == nil {
return ""
}
return storage.URI
}
+204
View File
@@ -0,0 +1,204 @@
package http
import (
"encoding/json"
stdhttp "net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
jwt "github.com/appleboy/gin-jwt/v2"
"github.com/gin-gonic/gin"
jwtgo "github.com/golang-jwt/jwt/v4"
"github.com/kerberos-io/agent/machinery/src/models"
)
func TestLoadJWTSecretPrefersEnvironment(t *testing.T) {
dir := t.TempDir()
t.Setenv("AGENT_JWT_SECRET", "shared-with-factory")
if got := string(loadJWTSecret(dir)); got != "shared-with-factory" {
t.Fatalf("loadJWTSecret() = %q, want the AGENT_JWT_SECRET value", got)
}
if _, err := os.Stat(filepath.Join(dir, "data", "config", jwtSecretFileName)); !os.IsNotExist(err) {
t.Fatalf("no secret file should be written when AGENT_JWT_SECRET is set, stat err = %v", err)
}
}
func TestLoadJWTSecretGeneratesAndPersistsRandomSecret(t *testing.T) {
dir := t.TempDir()
t.Setenv("AGENT_JWT_SECRET", "")
first := string(loadJWTSecret(dir))
if first == legacyJWTSecret || len(first) != 64 {
t.Fatalf("generated secret = %q, want 64 random hex characters", first)
}
path := filepath.Join(dir, "data", "config", jwtSecretFileName)
info, err := os.Stat(path)
if err != nil {
t.Fatalf("secret file not written: %v", err)
}
if perm := info.Mode().Perm(); perm != 0o600 {
t.Fatalf("secret file permissions = %o, want 600", perm)
}
if second := string(loadJWTSecret(dir)); second != first {
t.Fatalf("secret changed across restarts: %q then %q", first, second)
}
if other := string(loadJWTSecret(t.TempDir())); other == first {
t.Fatal("two installs generated the same secret")
}
}
func TestLoadJWTSecretReplacesShortStoredSecret(t *testing.T) {
dir := t.TempDir()
t.Setenv("AGENT_JWT_SECRET", "")
path := filepath.Join(dir, "data", "config", jwtSecretFileName)
if err := writeJWTSecret(path, legacyJWTSecret); err != nil {
t.Fatal(err)
}
got := string(loadJWTSecret(dir))
if got == legacyJWTSecret || len(got) != 64 {
t.Fatalf("short stored secret was reused: %q", got)
}
}
// securityRouter wires the real middleware and routes the way StartServer does.
func securityRouter(t *testing.T) (*gin.Engine, []byte) {
t.Helper()
gin.SetMode(gin.TestMode)
t.Setenv("AGENT_JWT_SECRET", "")
t.Setenv("AGENT_USERNAME", "")
t.Setenv("AGENT_PASSWORD", "")
dir := t.TempDir()
config := JWTMiddleWare(dir)
authMiddleware, err := jwt.New(&config)
if err != nil {
t.Fatalf("initialize JWT middleware: %v", err)
}
router := gin.New()
router.Use(gin.Recovery())
registerProfiler(router, authMiddleware)
AddRoutes(router, authMiddleware, dir, &models.Configuration{}, &models.Communication{}, nil)
registerFileRoute(router, authMiddleware, dir, &models.Configuration{})
return router, config.Key
}
func signedToken(t *testing.T, key []byte, username string) string {
t.Helper()
token := jwtgo.NewWithClaims(jwtgo.SigningMethodHS256, jwtgo.MapClaims{
"id": map[string]interface{}{"username": username, "role": "admin"},
"exp": time.Now().Add(time.Hour).Unix(),
"orig_iat": time.Now().Unix(),
})
signed, err := token.SignedString(key)
if err != nil {
t.Fatal(err)
}
return signed
}
func request(router *gin.Engine, method, target, bearer string) int {
req := httptest.NewRequest(method, target, nil)
if bearer != "" {
req.Header.Set("Authorization", "Bearer "+bearer)
}
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
return rec.Code
}
func TestAPIRejectsTokensSignedWithLegacyDefaultKey(t *testing.T) {
router, _ := securityRouter(t)
forged := signedToken(t, []byte(legacyJWTSecret), "root")
if code := request(router, "GET", "/api/config", forged); code != stdhttp.StatusUnauthorized {
t.Fatalf("token signed with the legacy key: status %d, want 401", code)
}
}
func TestAPIRejectsTokensForOtherUsers(t *testing.T) {
router, key := securityRouter(t)
other := signedToken(t, key, "intruder")
if code := request(router, "GET", "/api/config", other); code != stdhttp.StatusForbidden {
t.Fatalf("validly signed token for another user: status %d, want 403", code)
}
}
func TestLoginTokenGrantsAccess(t *testing.T) {
router, _ := securityRouter(t)
req := httptest.NewRequest("POST", "/api/login", strings.NewReader(`{"username":"root","password":"root"}`))
req.Header.Set("Content-Type", "application/json")
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
if rec.Code != stdhttp.StatusOK {
t.Fatalf("login: status %d, body %s", rec.Code, rec.Body.String())
}
var body struct {
Token string `json:"token"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil || body.Token == "" {
t.Fatalf("login response without token: %s", rec.Body.String())
}
if code := request(router, "GET", "/file/missing.mp4?token="+body.Token, ""); code == stdhttp.StatusUnauthorized || code == stdhttp.StatusForbidden {
t.Fatalf("login token rejected on /file: status %d", code)
}
}
func TestRecordingsRequireToken(t *testing.T) {
router, key := securityRouter(t)
if code := request(router, "GET", "/file/recording.mp4", ""); code != stdhttp.StatusUnauthorized {
t.Fatalf("/file without token: status %d, want 401", code)
}
// With a valid token the handler runs and reports the missing file.
token := signedToken(t, key, "root")
if code := request(router, "GET", "/file/recording.mp4?token="+token, ""); code != stdhttp.StatusNotFound {
t.Fatalf("/file with ?token=: status %d, want 404 from the handler", code)
}
}
func TestLiveWebSocketRequiresToken(t *testing.T) {
router, key := securityRouter(t)
if code := request(router, "GET", "/ws", ""); code != stdhttp.StatusUnauthorized {
t.Fatalf("/ws without token: status %d, want 401", code)
}
// With a valid token the request reaches the upgrader, which rejects a
// non-WebSocket request itself.
token := signedToken(t, key, "root")
if code := request(router, "GET", "/ws?token="+token, ""); code == stdhttp.StatusUnauthorized || code == stdhttp.StatusForbidden {
t.Fatalf("/ws with ?token=: status %d, want the request to pass authentication", code)
}
}
func TestProfilerDisabledByDefault(t *testing.T) {
t.Setenv("AGENT_ENABLE_PPROF", "")
router, key := securityRouter(t)
if code := request(router, "GET", "/debug/pprof/", signedToken(t, key, "root")); code != stdhttp.StatusNotFound {
t.Fatalf("pprof without AGENT_ENABLE_PPROF: status %d, want 404", code)
}
}
func TestProfilerRequiresTokenWhenEnabled(t *testing.T) {
t.Setenv("AGENT_ENABLE_PPROF", "true")
router, key := securityRouter(t)
if code := request(router, "GET", "/debug/pprof/", ""); code != stdhttp.StatusUnauthorized {
t.Fatalf("enabled pprof without token: status %d, want 401", code)
}
if code := request(router, "GET", "/debug/pprof/", signedToken(t, key, "root")); code != stdhttp.StatusOK {
t.Fatalf("enabled pprof with token: status %d, want 200", code)
}
}
+22 -9
View File
@@ -61,17 +61,14 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
c.AbortWithStatus(500)
}))
// Profiler
pprof.Register(r)
// Setup CORS
r.Use(CORS())
// Add Swagger
r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))
// The JWT middlewareergreggre
middleWare := JWTMiddleWare()
// The JWT middleware
middleWare := JWTMiddleWare(configDirectory)
authMiddleware, err := jwt.New(&middleWare)
if err != nil {
log.WithError(err).WithFields(log.Fields{
@@ -80,6 +77,8 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
}).Fatal("Failed to initialize JWT middleware")
}
registerProfiler(r, authMiddleware)
// Add all routes
AddRoutes(r, authMiddleware, configDirectory, configuration, communication, captureDevice)
@@ -103,9 +102,7 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
r.Use(static.Serve("/media", static.LocalFile(configDirectory+"/www", true)))
r.Use(static.Serve("/settings", static.LocalFile(configDirectory+"/www", true)))
r.Use(static.Serve("/login", static.LocalFile(configDirectory+"/www", true)))
r.Handle("GET", "/file/*filepath", func(c *gin.Context) {
Files(c, configDirectory, configuration)
})
registerFileRoute(r, authMiddleware, configDirectory, configuration)
// Run the api on port
log.WithFields(log.Fields{
@@ -123,6 +120,23 @@ func StartServer(configDirectory string, configuration *models.Configuration, co
}
}
// registerProfiler exposes the Go profiler only when AGENT_ENABLE_PPROF=true.
// The endpoints expose heap dumps (which can contain credentials) and can be
// used to exhaust the CPU, so they always require a valid token.
func registerProfiler(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware) {
if os.Getenv("AGENT_ENABLE_PPROF") == "true" {
pprof.Register(r.Group("", authMiddleware.MiddlewareFunc()))
}
}
// registerFileRoute serves recordings to signed-in users. Browsers load them
// through <video src>, so the UI passes the token as ?token=.
func registerFileRoute(r *gin.Engine, authMiddleware *jwt.GinJWTMiddleware, configDirectory string, configuration *models.Configuration) {
r.Handle("GET", "/file/*filepath", authMiddleware.MiddlewareFunc(), func(c *gin.Context) {
Files(c, configDirectory, configuration)
})
}
func requestLogger() gin.HandlerFunc {
return func(c *gin.Context) {
startedAt := time.Now()
@@ -196,7 +210,6 @@ func Files(c *gin.Context, configDirectory string, configuration *models.Configu
fileSize := len(contents)
// Send file to gin
c.Header("Access-Control-Allow-Origin", "*")
c.Header("Content-Disposition", "attachment; filename="+filePath)
c.Header("Content-Type", "video/mp4")
c.Header("Content-Length", strconv.Itoa(fileSize))
+4 -1
View File
@@ -860,7 +860,10 @@ func HandleVerifyStream(mqttClient mqtt.Client, hubKey string, payload models.Pa
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
rtspClient := &capture.Golibrtsp{Url: rtspUrl}
rtspClient := &capture.Golibrtsp{
Url: rtspUrl,
Transport: configuration.Config.Capture.IPCamera.RTSPTransport,
}
errConnect := rtspClient.Connect(ctx, ctx)
if errConnect != nil {
errMsg = errConnect.Error()
+27 -60
View File
@@ -1,70 +1,37 @@
# Getting Started with Create React App
# Kerberos Agent UI
This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).
The web interface of the Kerberos Agent: a React app built with
[Vite](https://vite.dev) and tested with [Vitest](https://vitest.dev).
Requires Node.js 20.19 or newer.
## Available Scripts
## Scripts
In the project directory, you can run:
- `yarn start`: starts the dev server on
[http://localhost:3000](http://localhost:3000) with hot reload.
- `yarn build`: builds for production and moves the output to
`../machinery/www`, where the Agent serves it.
- `yarn preview`: serves the production build from `../machinery/www` on
port 3000. Run `yarn build` first.
- `yarn test`: runs the test suite once. `yarn test:watch` keeps it running.
- `yarn lint`: lints `src/` with ESLint.
- `yarn format`: formats the code with Prettier.
### `yarn start`
## Configuration
Runs the app in the development mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in the browser.
In development the UI talks to the Agent API on port `8082` of the same host.
Override it with `VITE_AGENT_API_PORT`:
The page will reload if you make edits.\
You will also see any lint errors in the console.
VITE_AGENT_API_PORT=9090 yarn start
### `yarn test`
In production builds the UI uses the host and port it was served from.
Launches the test runner in the interactive watch mode.\
See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.
Runtime settings that differ per deployment (such as demo mode) live in
`public/env.js`, which the Agent can replace without rebuilding the UI.
### `yarn build`
## Layout
Builds the app for production to the `build` folder.\
It correctly bundles React in production mode and optimizes the build for the best performance.
The build is minified and the filenames include the hashes.\
Your app is ready to be deployed!
See the section about [deployment](https://facebook.github.io/create-react-app/docs/deployment) for more information.
### `yarn eject`
**Note: this is a one-way operation. Once you `eject`, you can’t go back!**
If you aren’t satisfied with the build tool and configuration choices, you can `eject` at any time. This command will remove the single build dependency from your project.
Instead, it will copy all the configuration files and the transitive dependencies (webpack, Babel, ESLint, etc) right into your project so you have full control over them. All of the commands except `eject` will still work, but they will point to the copied scripts so you can tweak them. At this point you’re on your own.
You don’t have to ever use `eject`. The curated feature set is suitable for small and middle deployments, and you shouldn’t feel obligated to use this feature. However we understand that this tool wouldn’t be useful if you couldn’t customize it when you are ready for it.
## Learn More
You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).
To learn React, check out the [React documentation](https://reactjs.org/).
### Code Splitting
This section has moved here: [https://facebook.github.io/create-react-app/docs/code-splitting](https://facebook.github.io/create-react-app/docs/code-splitting)
### Analyzing the Bundle Size
This section has moved here: [https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size](https://facebook.github.io/create-react-app/docs/analyzing-the-bundle-size)
### Making a Progressive Web App
This section has moved here: [https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app](https://facebook.github.io/create-react-app/docs/making-a-progressive-web-app)
### Advanced Configuration
This section has moved here: [https://facebook.github.io/create-react-app/docs/advanced-configuration](https://facebook.github.io/create-react-app/docs/advanced-configuration)
### Deployment
This section has moved here: [https://facebook.github.io/create-react-app/docs/deployment](https://facebook.github.io/create-react-app/docs/deployment)
### `yarn build` fails to minify
This section has moved here: [https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify](https://facebook.github.io/create-react-app/docs/troubleshooting#npm-run-build-fails-to-minify)
- `index.html`: the HTML entry point; Vite injects the bundle here.
- `src/`: application code. `src/index.jsx` is the entry module.
- `public/`: copied unchanged to the build root (favicons, fonts, locales, `env.js`).
- Bundled JS, CSS and assets go to `static/` in the build, so they don't mix
with the `assets/` folder from `public/`.
+26
View File
@@ -0,0 +1,26 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<link rel="apple-touch-icon" sizes="180x180" href="/favicons/apple-touch-icon.png?v=1">
<link rel="icon" type="image/png" sizes="32x32" href="/favicons/favicon-32x32.png?v=1">
<link rel="icon" type="image/png" sizes="16x16" href="/favicons/favicon-16x16.png?v=1">
<link rel="manifest" href="/favicons/site.webmanifest?v=1">
<link rel="mask-icon" href="/favicons/safari-pinned-tab.svg?v=1" color="#b4524e">
<link rel="shortcut icon" href="/favicons/favicon.ico?v=1">
<meta name="msapplication-TileColor" content="#b4524e">
<meta name="msapplication-config" content="/favicons/browserconfig.xml?v=1">
<meta name="theme-color" content="#ffffff">
<meta name="viewport" content="width=device-width, initial-scale=1" />
<meta name="theme-color" content="#000000" />
<link rel="manifest" href="/manifest.json" />
<script src="/env.js"></script>
<title>Kerberos Agent | Video surveillance for everyone </title>
</head>
<body>
<noscript>You need to enable JavaScript to run this app.</noscript>
<div id="root"></div>
<script type="module" src="/src/index.jsx"></script>
</body>
</html>
+15 -23
View File
@@ -1,15 +1,18 @@
{
"name": "agent-ui",
"version": "0.1.0",
"engines": {
"node": ">=20.19.0"
},
"dependencies": {
"@giantmachines/redux-websocket": "^1.5.1",
"@kerberos-io/ui": "^1.76.0",
"@kerberos-io/ui": "https://github.com/kerberos-io/ui/releases/download/v1.77.1/kerberos-io-ui-1.77.1.tgz",
"@material-ui/core": "^4.12.4",
"@material-ui/icons": "^4.11.3",
"@testing-library/jest-dom": "^5.16.5",
"@testing-library/react": "^11.2.7",
"@testing-library/user-event": "^12.8.3",
"axios": "^0.33.0",
"axios": "^0.34.0",
"classnames": "^2.3.1",
"connected-react-router": "^6.9.3",
"eslint-config-prettier": "8.5.*",
@@ -29,7 +32,6 @@
"react-router": "^5.2.0",
"react-router-dom": "^5.3.3",
"react-router-redux": "^4.0.8",
"react-scripts": "5.*",
"react-tooltip": "^4.2.21",
"redux": "^4.2.0",
"redux-devtools-extension": "^2.13.9",
@@ -44,38 +46,28 @@
"crypto": false
},
"scripts": {
"start": "DISABLE_ESLINT_PLUGIN=true react-scripts start",
"build": "DISABLE_ESLINT_PLUGIN=true GENERATE_SOURCEMAP=false REACT_APP_ENVIRONMENT=production react-scripts build && rm -rf ../machinery/www && mv build ../machinery/www",
"test": "DISABLE_ESLINT_PLUGIN=true react-scripts test",
"eject": "react-scripts eject",
"start": "vite",
"build": "vite build && rm -rf ../machinery/www && mv build ../machinery/www",
"preview": "vite preview --outDir ../machinery/www",
"test": "vitest run",
"test:watch": "vitest",
"lint": "eslint --debug 'src/**/*.{js,jsx,ts,tsx}'",
"format": "prettier --write \"**/*.{js,jsx,json,md}\""
},
"browserslist": {
"production": [
">0.2%",
"not dead",
"not op_mini all"
],
"development": [
"last 1 chrome version",
"last 1 firefox version",
"last 1 safari version"
]
},
"devDependencies": {
"@vitejs/plugin-react": "^6.3.0",
"eslint": "^7.32.0",
"eslint-config-airbnb": "^18.2.1",
"eslint-plugin-import": "^2.26.0",
"eslint-plugin-jsx-a11y": "^6.6.1",
"eslint-plugin-react": "^7.30.1",
"eslint-plugin-react-hooks": "^4.6.0",
"sass": "^1.54.4",
"sass-loader": "^10.3.1"
"jsdom": "^29.1.1",
"sass": "^1.108.2",
"vite": "^8.3.8",
"vitest": "^4.1.12"
},
"resolutions": {
"@tootallnate/once": "^2.0.1",
"serialize-javascript": "^7.1.3",
"uuid": "^11.1.1"
}
}
-48
View File
@@ -1,48 +0,0 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<link rel="apple-touch-icon" sizes="180x180" href="%PUBLIC_URL%/favicons/apple-touch-icon.png?v=1">
<link rel="icon" type="image/png" sizes="32x32" href="%PUBLIC_URL%/favicons/favicon-32x32.png?v=1">
<link rel="icon" type="image/png" sizes="16x16" href="%PUBLIC_URL%/favicons/favicon-16x16.png?v=1">
<link rel="manifest" href="%PUBLIC_URL%/favicons/site.webmanifest?v=1">
<link rel="mask-icon" href="%PUBLIC_URL%/favicons/safari-pinned-tab.svg?v=1" color="#b4524e">
<link rel="shortcut icon" href="%PUBLIC_URL%/favicons/favicon.ico?v=1">
<meta name="msapplication-TileColor" content="#b4524e">
<meta name="msapplication-config" content="%PUBLIC_URL%/favicons/browserconfig.xml?v=1">
<meta name="theme-color" content="#ffffff">
<meta name="viewport" content="width=device-width, initial-scale=1" />
<meta name="theme-color" content="#000000" />
<!--
manifest.json provides metadata used when your web app is installed on a
user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
-->
<link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
<script src="%PUBLIC_URL%/env.js"></script>
<!--
Notice the use of %PUBLIC_URL% in the tags above.
It will be replaced with the URL of the `public` folder during the build.
Only files inside the `public` folder can be referenced from the HTML.
Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
work correctly both with client-side routing and a non-root public URL.
Learn how to configure a non-root public URL by running `npm run build`.
-->
<title>Kerberos Agent | Video surveillance for everyone </title>
</head>
<body>
<noscript>You need to enable JavaScript to run this app.</noscript>
<div id="root"></div>
<!--
This HTML file is a template.
If you open it directly in the browser, you will see an empty page.
You can add webfonts, meta tags, or analytics to this file.
The build step will place the bundled scripts into the <body> tag.
To begin the development, run `npm start` or `yarn start`.
To create a production bundle, use `npm run build` or `yarn build`.
-->
</body>
</html>
+5
View File
@@ -103,6 +103,11 @@
"only_h264": "Currently only H264/H265 RTSP streams are supported.",
"rtsp_url": "RTSP URL",
"rtsp_h264": "A H264/H265 RTSP connection to your camera.",
"rtsp_transport": "RTSP transport",
"rtsp_transport_select": "Select RTSP transport",
"rtsp_transport_tcp": "TCP (reliable, default)",
"rtsp_transport_udp": "UDP (low latency)",
"rtsp_transport_auto": "Auto (UDP, fall back to TCP)",
"sub_rtsp_url": "Sub RTSP URL (used for livestreaming)",
"sub_rtsp_h264": "A secondary RTSP connection to the low resolution of your camera.",
"onvif": "ONVIF",
+7 -1
View File
@@ -24,6 +24,7 @@ import { connect } from 'react-redux';
import { Link } from 'react-router-dom';
import { logout } from './actions';
import config from './config';
import { getToken, withToken } from './api/api';
import { getDashboardInformation } from './actions/agent';
import LanguageSelect from './components/LanguageSelect/LanguageSelect';
import websocketClientId from './websocket';
@@ -260,7 +261,12 @@ const mapStateToProps = (state) => ({
const mapDispatchToProps = (dispatch) => ({
dispatchLogout: () => dispatch(logout()),
dispatchConnect: () => {
dispatch(connectWS(config.WS_URL));
// The WebSocket requires a token; there is nothing to connect to before
// sign-in (App mounts briefly on first load before the login redirect).
if (!getToken()) {
return;
}
dispatch(connectWS(withToken(config.WS_URL)));
},
dispatchDisconnect: () => dispatch(disconnectWS()),
dispatchSend: (message) => dispatch(send(message)),
+33 -28
View File
@@ -1,4 +1,5 @@
/* eslint-env jest */
import { vi } from 'vitest';
/* eslint-disable react/prop-types */
import React from 'react';
import { interval } from 'rxjs';
@@ -6,11 +7,11 @@ import { App } from './App';
const subscriptions = [];
jest.mock('rxjs', () => ({
interval: jest.fn(),
vi.mock('rxjs', () => ({
interval: vi.fn(),
}));
jest.mock('@kerberos-io/ui', () => {
vi.mock('@kerberos-io/ui', () => {
const Mock = ({ children }) => <div>{children}</div>;
return {
Badge: Mock,
@@ -27,42 +28,46 @@ jest.mock('@kerberos-io/ui', () => {
};
});
jest.mock('./components/LanguageSelect/LanguageSelect', () => () => null);
jest.mock('./actions', () => ({ logout: jest.fn() }));
jest.mock('./actions/agent', () => ({
getDashboardInformation: jest.fn(),
vi.mock('./components/LanguageSelect/LanguageSelect', () => ({
default: () => null,
}));
jest.mock('./config', () => ({
MODE: 'release',
URL: 'http://localhost',
WS_URL: 'ws://localhost/ws',
vi.mock('./actions', () => ({ logout: vi.fn() }));
vi.mock('./actions/agent', () => ({
getDashboardInformation: vi.fn(),
}));
jest.mock('react-redux', () => ({
vi.mock('./config', () => ({
default: {
MODE: 'release',
URL: 'http://localhost',
WS_URL: 'ws://localhost/ws',
},
}));
vi.mock('react-redux', () => ({
connect: () => (Component) => Component,
}));
jest.mock('react-i18next', () => ({
vi.mock('react-i18next', () => ({
withTranslation: () => (Component) => Component,
}));
jest.mock('react-router-dom', () => ({
vi.mock('react-router-dom', () => ({
Link: ({ children }) => <>{children}</>,
}));
jest.mock('@giantmachines/redux-websocket', () => ({
connect: jest.fn(),
disconnect: jest.fn(),
send: jest.fn(),
vi.mock('@giantmachines/redux-websocket', () => ({
connect: vi.fn(),
disconnect: vi.fn(),
send: vi.fn(),
}));
jest.mock('uuid', () => ({
v4: jest.fn(() => 'uuid-1'),
vi.mock('uuid', () => ({
v4: vi.fn(() => 'uuid-1'),
}));
describe('App lifecycle refresh behaviour', () => {
const baseProps = () => ({
t: (value) => value,
dispatchLogout: jest.fn(),
dispatchConnect: jest.fn(),
dispatchDisconnect: jest.fn(),
dispatchSend: jest.fn(),
dispatchGetDashboardInformation: jest.fn((onSuccess) => {
dispatchLogout: vi.fn(),
dispatchConnect: vi.fn(),
dispatchDisconnect: vi.fn(),
dispatchSend: vi.fn(),
dispatchGetDashboardInformation: vi.fn((onSuccess) => {
if (onSuccess) {
onSuccess();
}
@@ -78,12 +83,12 @@ describe('App lifecycle refresh behaviour', () => {
beforeEach(() => {
subscriptions.length = 0;
jest.clearAllMocks();
vi.clearAllMocks();
interval.mockImplementation(() => ({
subscribe: jest.fn((callback) => {
subscribe: vi.fn((callback) => {
const subscription = {
callback,
unsubscribe: jest.fn(),
unsubscribe: vi.fn(),
};
subscriptions.push(subscription);
return subscription;
+3
View File
@@ -134,11 +134,14 @@ export function doVerifyCamera(streamType, config, onSuccess, onError) {
const cameraStreams = {
rtsp: '',
sub_rtsp: '',
rtsp_transport: '',
};
if (config) {
cameraStreams.rtsp = config.capture.ipcamera.rtsp;
cameraStreams.sub_rtsp = config.capture.ipcamera.sub_rtsp;
cameraStreams.rtsp_transport =
config.capture.ipcamera.rtsp_transport || '';
}
const endpoint = API.post(`camera/verify/${streamType}`, cameraStreams);
+7 -4
View File
@@ -1,15 +1,18 @@
/* eslint-env jest */
import { vi } from 'vitest';
import API from './api';
import { doGetDashboardInformation } from './agent';
jest.mock('./api', () => ({
get: jest.fn(),
vi.mock('./api', () => ({
default: {
get: vi.fn(),
},
}));
describe('dashboard API', () => {
it('bounds dashboard requests so polling can recover', async () => {
const onSuccess = jest.fn();
const onError = jest.fn();
const onSuccess = vi.fn();
const onError = vi.fn();
API.get.mockResolvedValue({
status: 200,
data: { uptime: '1 minute' },
+12
View File
@@ -16,6 +16,18 @@ export function getToken() {
return localStorage.getItem('token');
}
// Browsers cannot attach an Authorization header to WebSocket connections or
// to media elements such as <video src>, so those URLs carry the token as the
// ?token= query parameter, which the agent's JWT middleware also accepts.
export function withToken(url) {
const token = getToken();
if (!token) {
return url;
}
const separator = url.includes('?') ? '&' : '?';
return `${url}${separator}token=${encodeURIComponent(token)}`;
}
export function getAPIObject(url) {
return {
url: config.API_URL + url,
@@ -1,22 +1,23 @@
/* eslint-env jest */
import { vi } from 'vitest';
import { ImageCanvas } from './ImageCanvas';
jest.mock('vott-ct', () => ({
vi.mock('vott-ct', () => ({
CanvasTools: {
Editor: jest.fn(),
Editor: vi.fn(),
Core: {
RegionData: jest.fn(),
Point2D: jest.fn(),
Tag: jest.fn(),
TagsDescriptor: jest.fn(),
RegionData: vi.fn(),
Point2D: vi.fn(),
Tag: vi.fn(),
TagsDescriptor: vi.fn(),
Colors: {
Color: jest.fn(),
Color: vi.fn(),
},
},
},
}));
jest.mock('vott-ct/lib/js/CanvasTools/Interface/ISelectorSettings', () => ({
vi.mock('vott-ct/lib/js/CanvasTools/Interface/ISelectorSettings', () => ({
SelectionMode: {
NONE: 'none',
RECT: 'rect',
@@ -24,7 +25,7 @@ jest.mock('vott-ct/lib/js/CanvasTools/Interface/ISelectorSettings', () => ({
},
}));
jest.mock('vott-ct/lib/js/CanvasTools/Core/RegionData', () => ({
vi.mock('vott-ct/lib/js/CanvasTools/Core/RegionData', () => ({
RegionDataType: {
Polygon: 'polygon',
},
@@ -32,9 +33,9 @@ jest.mock('vott-ct/lib/js/CanvasTools/Core/RegionData', () => ({
describe('ImageCanvas update guards', () => {
const callbacks = {
onAddRegion: jest.fn(),
onUpdateRegion: jest.fn(),
onDeleteRegion: jest.fn(),
onAddRegion: vi.fn(),
onUpdateRegion: vi.fn(),
onDeleteRegion: vi.fn(),
};
const baseProps = () => ({
@@ -45,7 +46,7 @@ describe('ImageCanvas update guards', () => {
});
beforeEach(() => {
jest.clearAllMocks();
vi.clearAllMocks();
});
it('ignores unrelated parent updates', () => {
@@ -55,8 +56,8 @@ describe('ImageCanvas update guards', () => {
};
const canvas = new ImageCanvas(props);
canvas.props = props;
canvas.loadImage = jest.fn();
canvas.loadData = jest.fn();
canvas.loadImage = vi.fn();
canvas.loadData = vi.fn();
canvas.componentDidUpdate({
...props,
@@ -71,8 +72,8 @@ describe('ImageCanvas update guards', () => {
const props = baseProps();
const canvas = new ImageCanvas(props);
canvas.props = props;
canvas.loadImage = jest.fn();
canvas.loadData = jest.fn();
canvas.loadImage = vi.fn();
canvas.loadData = vi.fn();
canvas.componentDidUpdate({
...props,
@@ -97,8 +98,8 @@ describe('ImageCanvas update guards', () => {
width: 100,
height: 100,
};
canvas.loadImage = jest.fn();
canvas.loadData = jest.fn();
canvas.loadImage = vi.fn();
canvas.loadData = vi.fn();
canvas.componentDidUpdate({
...props,
+3 -3
View File
@@ -1,6 +1,6 @@
const { hostname, host, protocol } = window.location;
const websocketprotocol = protocol === 'http:' ? 'ws:' : 'wss:';
const devAgentPort = process.env.REACT_APP_AGENT_API_PORT || '8082';
const devAgentPort = import.meta.env.VITE_AGENT_API_PORT || '8082';
// 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)
@@ -22,7 +22,7 @@ const dev = {
};
const prod = {
ENV: process.env.REACT_APP_ENVIRONMENT,
ENV: import.meta.env.MODE,
HOSTNAME: hostname,
API_URL: `${protocol}//${host}/api`,
URL: `${protocol}//${host}`,
@@ -30,7 +30,7 @@ const prod = {
MODE: window['env']['mode'],
};
const config = process.env.REACT_APP_ENVIRONMENT === 'production' ? prod : dev;
const config = import.meta.env.PROD ? prod : dev;
export default {
// Add common config values here
+4 -3
View File
@@ -26,6 +26,7 @@ import {
import './Dashboard.scss';
import ReactTooltip from 'react-tooltip';
import config from '../../config';
import { withToken } from '../../api/api';
import { getConfig } from '../../actions/agent';
function createUUID() {
@@ -426,7 +427,7 @@ class Dashboard extends React.Component {
}
};
this.webrtcSocket = new WebSocket(config.WS_URL);
this.webrtcSocket = new WebSocket(withToken(config.WS_URL));
this.webrtcSocket.onopen = () => {
this.sendWebRTCMessage('hello', {});
};
@@ -612,7 +613,7 @@ class Dashboard extends React.Component {
className="time"
onClick={() =>
this.openModal(
`${config.URL}/file/${event.key}`
withToken(`${config.URL}/file/${event.key}`)
)
}
>
@@ -625,7 +626,7 @@ class Dashboard extends React.Component {
className="pointer event-description"
onClick={() =>
this.openModal(
`${config.URL}/file/${event.key}`
withToken(`${config.URL}/file/${event.key}`)
)
}
>
+5 -2
View File
@@ -15,6 +15,7 @@ import { Link, withRouter } from 'react-router-dom';
import { connect } from 'react-redux';
import { getEvents } from '../../actions/agent';
import config from '../../config';
import { withToken } from '../../api/api';
import './Media.scss';
function formatDateTimeLocal(date) {
@@ -258,11 +259,13 @@ class Media extends React.Component {
{events.map((event) => (
<div
key={event.key}
onClick={() => this.openModal(`${config.URL}/file/${event.key}`)}
onClick={() =>
this.openModal(withToken(`${config.URL}/file/${event.key}`))
}
>
<VideoCard
isMediaWall
videoSrc={`${config.URL}/file/${event.key}`}
videoSrc={withToken(`${config.URL}/file/${event.key}`)}
hours={event.time}
month={event.short_day}
videoStatus=""
+28
View File
@@ -1074,6 +1074,34 @@ export class Settings extends React.Component {
)
}
/>
<Dropdown
isRadio
label={t('settings.camera.rtsp_transport')}
placeholder={t('settings.camera.rtsp_transport_select')}
items={[
{
label: t('settings.camera.rtsp_transport_tcp'),
value: 'tcp',
},
{
label: t('settings.camera.rtsp_transport_udp'),
value: 'udp',
},
{
label: t('settings.camera.rtsp_transport_auto'),
value: 'auto',
},
]}
selected={[config.capture.ipcamera.rtsp_transport || 'tcp']}
onChange={(value) =>
this.onUpdateDropdown(
'capture.ipcamera',
'rtsp_transport',
value[0],
config.capture.ipcamera
)
}
/>
</BlockBody>
<BlockFooter>
{config.capture.ipcamera &&
+44 -42
View File
@@ -1,17 +1,18 @@
/* eslint-env jest */
import { vi } from 'vitest';
/* eslint-disable react/prop-types */
import React from 'react';
import { Settings } from './Settings';
jest.mock('rxjs', () => ({
interval: jest.fn(() => ({
subscribe: jest.fn(() => ({
unsubscribe: jest.fn(),
vi.mock('rxjs', () => ({
interval: vi.fn(() => ({
subscribe: vi.fn(() => ({
unsubscribe: vi.fn(),
})),
})),
}));
jest.mock('@kerberos-io/ui', () => {
vi.mock('@kerberos-io/ui', () => {
const Mock = ({ children }) => <div>{children}</div>;
return {
Breadcrumb: Mock,
@@ -31,36 +32,37 @@ jest.mock('@kerberos-io/ui', () => {
};
});
jest.mock('react-redux', () => ({
vi.mock('react-redux', () => ({
connect: () => (Component) => Component,
}));
jest.mock('react-i18next', () => ({
vi.mock('react-i18next', () => ({
withTranslation: () => (Component) => Component,
}));
jest.mock('react-router-dom', () => ({
vi.mock('react-router-dom', () => ({
Link: ({ children }) => <>{children}</>,
withRouter: (Component) => Component,
}));
jest.mock('@giantmachines/redux-websocket', () => ({
send: jest.fn(),
vi.mock('@giantmachines/redux-websocket', () => ({
send: vi.fn(),
}));
jest.mock('../../components/ImageCanvas/ImageCanvas', () => () => null);
jest.mock('../../websocket', () => ({
__esModule: true,
vi.mock('../../components/ImageCanvas/ImageCanvas', () => ({
default: () => null,
}));
vi.mock('../../websocket', () => ({
default: 'uuid-1',
}));
jest.mock('../../actions/agent', () => ({
addRegion: jest.fn(),
updateRegion: jest.fn(),
removeRegion: jest.fn(),
saveConfig: jest.fn(),
verifyOnvif: jest.fn(),
verifyCamera: jest.fn(),
verifyHub: jest.fn(),
verifyPersistence: jest.fn(),
verifySecondaryPersistence: jest.fn(),
getConfig: jest.fn(),
updateConfig: jest.fn(),
vi.mock('../../actions/agent', () => ({
addRegion: vi.fn(),
updateRegion: vi.fn(),
removeRegion: vi.fn(),
saveConfig: vi.fn(),
verifyOnvif: vi.fn(),
verifyCamera: vi.fn(),
verifyHub: vi.fn(),
verifyPersistence: vi.fn(),
verifySecondaryPersistence: vi.fn(),
getConfig: vi.fn(),
updateConfig: vi.fn(),
}));
describe('Settings liveview lifecycle', () => {
@@ -78,22 +80,22 @@ describe('Settings liveview lifecycle', () => {
connected: true,
config,
images: [],
dispatchVerifyHub: jest.fn(),
dispatchVerifyPersistence: jest.fn(),
dispatchVerifySecondaryPersistence: jest.fn(),
dispatchGetConfig: jest.fn(),
dispatchUpdateConfig: jest.fn(),
dispatchSaveConfig: jest.fn(),
dispatchAddRegion: jest.fn(),
dispatchUpdateRegion: jest.fn(),
dispatchRemoveRegion: jest.fn(),
dispatchVerifyCamera: jest.fn(),
dispatchVerifyOnvif: jest.fn(),
dispatchSend: jest.fn(),
dispatchVerifyHub: vi.fn(),
dispatchVerifyPersistence: vi.fn(),
dispatchVerifySecondaryPersistence: vi.fn(),
dispatchGetConfig: vi.fn(),
dispatchUpdateConfig: vi.fn(),
dispatchSaveConfig: vi.fn(),
dispatchAddRegion: vi.fn(),
dispatchUpdateRegion: vi.fn(),
dispatchRemoveRegion: vi.fn(),
dispatchVerifyCamera: vi.fn(),
dispatchVerifyOnvif: vi.fn(),
dispatchSend: vi.fn(),
});
beforeEach(() => {
jest.clearAllMocks();
vi.clearAllMocks();
});
it('starts and stops SD imagery with the conditions editor visibility', () => {
@@ -105,8 +107,8 @@ describe('Settings liveview lifecycle', () => {
selectedTab: 'conditions',
search: '',
};
settings.initialiseLiveview = jest.fn();
settings.stopLiveview = jest.fn();
settings.initialiseLiveview = vi.fn();
settings.stopLiveview = vi.fn();
settings.componentDidUpdate(props, {
...settings.state,
@@ -138,7 +140,7 @@ describe('Settings liveview lifecycle', () => {
search: '',
};
settings.sdLiveviewActive = true;
settings.requestSDLiveviewFrame = jest.fn();
settings.requestSDLiveviewFrame = vi.fn();
settings.componentDidUpdate(
{
@@ -157,7 +159,7 @@ describe('Settings liveview lifecycle', () => {
settings.props = props;
settings.sdLiveviewActive = true;
settings.requestStreamSubscription = {
unsubscribe: jest.fn(),
unsubscribe: vi.fn(),
};
settings.componentWillUnmount();
+28
View File
@@ -0,0 +1,28 @@
// eslint-plugin-import 2.x cannot resolve packages that only define "exports".
/* eslint-disable import/no-unresolved */
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
plugins: [react()],
base: '/',
server: {
port: 3000,
host: true,
},
preview: {
port: 3000,
},
build: {
outDir: 'build',
// public/assets already holds static files; keep bundled output separate.
assetsDir: 'static',
sourcemap: false,
},
test: {
globals: true,
environment: 'jsdom',
setupFiles: './src/setupTests.js',
css: false,
},
});
+868 -7433
View File
File diff suppressed because it is too large Load Diff