ws-pipe-relay

video optimization/
WebSocketServer.clientsByCamera
2026-07-04 21:03:50 +05:00 · 2026-07-04 18:57:41 +05:00 · 2026-07-04 18:09:16 +05:00 · 2026-07-04 17:26:30 +05:00 · 2026-07-03 17:38:23 +05:00 · 2026-07-03 17:30:05 +05:00
21 changed files with 411 additions and 89 deletions
--- a/app/Dockerfile
+++ b/app/Dockerfile
@@ -10,5 +10,9 @@ COPY src ./src

 RUN npm run build && npm prune --omit=dev

+# app/public/index.html has content for video preview
+# TODO move all static files (html, mappers) to a separate folder "assets"
+COPY public ./public 
+
 ENV NODE_ENV=production
 CMD ["node", "dist/index.js"]
--- a/app/public/index.html
+++ b/app/public/index.html
@@ -4,15 +4,39 @@
  <meta charset="utf-8" />
  <title>edge5 video relay</title>
  <script src="https://cdn.jsdelivr.net/npm/mpegts.js/dist/mpegts.js"></script>
+  <style>
+    body { margin: 0; background: #000; }
+    #v { display: block; width: 100vw; height: 100vh; object-fit: contain; }
+  </style>
 </head>
 <body>
-  <video id="v" controls autoplay muted style="width:100%"></video>
+  <video id="v" controls autoplay muted></video>
  <script>
-    const wsUrl = `ws://${location.hostname}:9090`
+    const cameraId = new URLSearchParams(location.search).get('camera') ?? 'v1';
+    const wsUrl = `${location.protocol === 'https:' ? 'wss' : 'ws'}://${location.host}/ws/${cameraId}`;
    const player = mpegts.createPlayer(
-      { type: 'mpegts', isLive: true, url: wsUrl },
-      { liveBufferLatencyChasing: true, liveBufferLatencyMaxLatency: 1.5 }
-    )
+      { type: 'mpegts', isLive: true, url: wsUrl, hasAudio: false },
+      {
+        enableWorker: true,             // transmuxing в отдельном треде
+        enableStashBuffer: true,        // включить stash
+        stashInitialSize: 384,
+
+        autoCleanupSourceBuffer: true,  // не копить старые буферы в MSE
+        autoCleanupMaxBackwardDuration: 10,
+        autoCleanupMinBackwardDuration: 5,
+
+        // liveSync — плавное догоняние через playbackRate, а не жёсткий seek
+        liveSync: true,
+        liveSyncTargetLatency: 4.0,    // target после выравнивания ← дать буферу вырасти
+        liveSyncMaxLatency: 10.0,      // при плохом интернете даём 10с ← не трогать буфер до 10s
+        liveSyncPlaybackRate: 1.05,    // ускорение не более 1.2x ← очень мягкое догоняние
+
+        liveBufferLatencyChasing: false,  // включить stash ← убрать конфликтующий механизм
+
+        lazyLoad: false,
+        deferLoadAfterSourceOpen: false,
+      }
+    );
    player.attachMediaElement(document.getElementById('v'))
    player.load()
    player.play()
--- a/app/src/handlers/demo-modbus.ts
+++ b/app/src/handlers/demo-modbus.ts
@@ -1,10 +1,9 @@
+import { log } from '../helpers/log.js'
 import type { TopicHandler } from '../types.js'

-export const TOPIC = 'data/demo/modbus/v1'
-
 const EDGE = 'demo'
 const REGISTER_COUNT = 125
-const DEMO_CLOUD_INGEST_URL = process.env.DEMO_CLOUD_INGEST_URL
+const DEMO_CLOUD_INGEST_URL = process.env.DEMO_CLOUD_INGEST_URL as string

 type DemoModbusMetric = {
  edge: string
@@ -29,14 +28,14 @@ function toMetrics(values: number[], timestamp: string): DemoModbusMetric[] {
  return values.map((value, index) => ({
    edge: EDGE,
    timestamp,
-    tag: `${EDGE}.modbus.${index + 1}`,
+    tag: `register-${index}`,
    value,
  }))
 }

 async function postMetrics(metrics: DemoModbusMetric[]): Promise<void> {
  for (const metric of metrics) {
-    const response = await fetch(DEMO_CLOUD_INGEST_URL as string, {
+    const response = await fetch(DEMO_CLOUD_INGEST_URL, {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
@@ -51,11 +50,11 @@ async function postMetrics(metrics: DemoModbusMetric[]): Promise<void> {
    }
  }

-  console.log('demo.modbus.posted', { count: metrics.length })
+  log(`${EDGE}.modbus.posted ${metrics.length} metrics`)
 }

 export const handleDemoModbus: TopicHandler = async (topic, payload) => {
-  console.log('demo.modbus.received', { topic, bytes: payload.length })
+  log(`${EDGE}.modbus.received ${topic} ${payload.length} bytes`)

  const values = parseValues(payload)
  const metrics = toMetrics(values, new Date().toISOString())
--- a/app/src/handlers/demo-plc.ts
+++ b/app/src/handlers/demo-plc.ts
@@ -1,10 +1,9 @@
+import { log } from '../helpers/log.js'
 import { parseJson } from '../helpers/parse.js'
 import type { TopicHandler } from '../types.js'

-export const TOPIC = 'data/demo/plc/v1'
-
 const EDGE = 'demo'
-const DEMO_CLOUD_INGEST_URL = process.env.DEMO_CLOUD_INGEST_URL
+const DEMO_CLOUD_INGEST_URL = process.env.DEMO_CLOUD_INGEST_URL as string

 type DemoPlcPayload = {
  tag: string
@@ -28,7 +27,7 @@ function toMetric(payload: DemoPlcPayload, timestamp: string): DemoPlcMetric {
 }

 async function postMetric(metric: DemoPlcMetric): Promise<void> {
-  const response = await fetch(DEMO_CLOUD_INGEST_URL as string, {
+  const response = await fetch(DEMO_CLOUD_INGEST_URL, {
    method: 'POST',
    headers: {
      'content-type': 'application/json',
@@ -42,11 +41,11 @@ async function postMetric(metric: DemoPlcMetric): Promise<void> {
    throw new Error(text)
  }

-  console.log('demo.plc.posted', { tag: metric.tag })
+  log('demo.plc.posted', { tag: metric.tag })
 }

 export const handleDemoPlc: TopicHandler = async (topic, payload) => {
-  console.log('demo.plc.received', { topic, bytes: payload.length })
+  log('demo.plc.received', { topic, bytes: payload.length })

  const value = parseJson<DemoPlcPayload>(payload)
  const metric = toMetric(value, new Date().toISOString())
--- a/app/src/handlers/edge5-modbus-v2.ts
+++ b/app/src/handlers/edge5-modbus-v2.ts
@@ -1,10 +1,10 @@
 import { postCloudIngest } from '../cloud-ingest.js'
+import { log } from '../helpers/log.js'
 import { createMetricMapper, type MappedMetric } from '../mapping.js'
 import type { TopicHandler } from '../types.js'

-export const TOPIC = 'data/edge5/modbus/v2'
-
 const REGISTER_COUNT = 125
+
 const mapper = createMetricMapper({
  filePath: process.env.EDGE5_MODBUS_V2_MAPPING_FILE as string,
 })
@@ -39,7 +39,7 @@ async function postMetrics(metrics: MappedMetric[]): Promise<void> {
    }
  }

-  console.log('edge5.modbus.v2.posted', {
+  log('edge5.modbus.v2.posted', {
    total: metrics.length,
    succeeded: metrics.length - errors.length,
    failed: errors.length,
@@ -51,7 +51,7 @@ async function postMetrics(metrics: MappedMetric[]): Promise<void> {
 }

 export const handleEdge5ModbusV2: TopicHandler = async (topic, payload) => {
-  console.log('edge5.modbus.v2.received', { topic, bytes: payload.length })
+  log('edge5.modbus.v2.received', { topic, bytes: payload.length })

  const values = parseValues(payload)
  const metrics = mapper.mapValues(values, new Date().toISOString())
--- a/app/src/handlers/edge5-video-v2.ts
+++ b/app/src/handlers/edge5-video-v2.ts
@@ -0,0 +1,21 @@
+import { log } from '../helpers/log.js'
+import { lastTopicSegment } from '../helpers/topic-match.js'
+import { onEdgeChunk } from '../stream/edge-chunk-relay.js'
+import type { TopicHandler } from '../types.js'
+
+const LOG_INTERVAL_MS = 10_000
+
+const lastLogByCamera = new Map<string, number>()
+
+export const handleEdge5VideoV2: TopicHandler = async (topic, payload) => {
+  const cameraId = lastTopicSegment(topic)
+
+  const now = Date.now()
+  const lastLog = lastLogByCamera.get(cameraId) ?? 0
+  if (now - lastLog >= LOG_INTERVAL_MS) {
+    log(`edge5.video.v2 [${cameraId}] ↑ ${payload.length}B`)
+    lastLogByCamera.set(cameraId, now)
+  }
+
+  onEdgeChunk(cameraId, payload);
+}
--- a/app/src/handlers/edge5-video.ts
+++ b/app/src/handlers/edge5-video.ts
@@ -1,16 +1,15 @@
+import { log } from '../helpers/log.js'
 import { onEdgeChunk } from '../stream/edge-chunk-relay.js'
 import type { TopicHandler } from '../types.js'

-export const TOPIC = 'data/edge5/video/v1'
-
-const BEACON_MS = 3000
-let lastBeacon = 0
+const LOG_INTERVAL_MS = 10_000
+let lastLog = 0

 export const handleEdge5Video: TopicHandler = async (_topic, payload) => {
  const now = Date.now()
-  if (now - lastBeacon >= BEACON_MS) {
-    console.log(`edge5.video ↑ ${payload.length}B`)
-    lastBeacon = now
+  if (now - lastLog >= LOG_INTERVAL_MS) {
+    log(`edge5.video ↑ ${payload.length}B`)
+    lastLog = now
  }
-  onEdgeChunk(payload)
+  onEdgeChunk('v1', payload);
 }
--- a/app/src/handlers/edge5cdab-modbus.ts
+++ b/app/src/handlers/edge5cdab-modbus.ts
@@ -0,0 +1,79 @@
+import { postCloudIngest } from '../cloud-ingest.js'
+import { log } from '../helpers/log.js'
+import type { TopicHandler } from '../types.js'
+
+const EDGE = 'edge5cdab'
+const REGISTER_COUNT = 100
+
+type Edge5iiModbusMetric = {
+  edge: string
+  timestamp: string
+  tag: string
+  value: number
+};
+
+function toFloatCDAB(reg0: number, reg1: number): number {
+  const buf = Buffer.allocUnsafe(4)
+  buf.writeUInt16BE(reg1, 0)
+  buf.writeUInt16BE(reg0, 2)
+  return buf.readFloatBE(0)
+}
+
+function parseValues(payload: Buffer): number[] {
+  const values = JSON.parse(payload.toString('utf8')) as number[]
+  assertRegisterCount(values)
+  return values
+}
+
+function assertRegisterCount(values: number[]): void {
+  if (values.length !== REGISTER_COUNT) {
+    throw new Error(`Expected ${REGISTER_COUNT} modbus values, got ${values.length}`)
+  }
+}
+
+function toMetrics(values: number[], timestamp: string): Edge5iiModbusMetric[] {
+  const metrics: Edge5iiModbusMetric[] = []
+
+  for (let i = 0; i < values.length; i += 2) {
+    const tag = `register-${String(i).padStart(3, '0')}`
+    const value = toFloatCDAB(values[i], values[i + 1])
+    if (isNaN(value)) {
+      log(
+        `${EDGE}.modbus: не удалось собрать число для ${tag}, ` +
+          `исходные values[${i}]=${values[i]}, values[${i + 1}]=${values[i + 1]}, пропуск`,
+      )
+      continue
+    };
+
+    metrics.push({
+      edge: EDGE,
+      timestamp,
+      tag,
+      value,
+    })
+  }
+
+  return metrics
+}
+
+async function postMetrics(metrics: Edge5iiModbusMetric[]): Promise<void> {
+  for (const metric of metrics) {
+    const response = await postCloudIngest(metric)
+
+    if (!response.ok) {
+      const text = await response.text()
+      throw new Error(text)
+    }
+  }
+
+  log(`${EDGE}.modbus.posted ${metrics.length} metrics`)
+}
+
+export const handle: TopicHandler = async (topic, payload) => {
+  const timestamp = new Date().toISOString()
+  log(`${EDGE}.modbus.received ${topic} ${payload.length} bytes`)
+
+  const values = parseValues(payload)
+  const metrics = toMetrics(values, timestamp);
+  await postMetrics(metrics)
+}
--- a/app/src/handlers/edge5i-modbus.ts
+++ b/app/src/handlers/edge5i-modbus.ts
@@ -1,12 +1,11 @@
 import { postCloudIngest } from '../cloud-ingest.js'
+import { log } from '../helpers/log.js'
 import type { TopicHandler } from '../types.js'

-export const TOPIC = 'data/edge5/modbus/v1'
+const EDGE = 'edge5i'
+const REGISTER_COUNT = 100

-const EDGE = 'edge5'
-const REGISTER_COUNT = 125
-
-type Edge5ModbusMetric = {
+type DemoModbusMetric = {
  edge: string
  timestamp: string
  tag: string
@@ -25,16 +24,16 @@ function assertRegisterCount(values: number[]): void {
  }
 }

-function toMetrics(values: number[], timestamp: string): Edge5ModbusMetric[] {
+function toMetrics(values: number[], timestamp: string): DemoModbusMetric[] {
  return values.map((value, index) => ({
    edge: EDGE,
    timestamp,
-    tag: `${EDGE}.modbus.${index + 1}`,
+    tag: `register-${String(index).padStart(3, '0')}`,
    value,
  }))
 }

-async function postMetrics(metrics: Edge5ModbusMetric[]): Promise<void> {
+async function postMetrics(metrics: DemoModbusMetric[]): Promise<void> {
  for (const metric of metrics) {
    const response = await postCloudIngest(metric)

@@ -44,11 +43,11 @@ async function postMetrics(metrics: Edge5ModbusMetric[]): Promise<void> {
    }
  }

-  console.log('edge5.modbus.posted', { count: metrics.length })
+  log(`${EDGE}.modbus.posted ${metrics.length} metrics`)
 }

-export const handleEdge5Modbus: TopicHandler = async (topic, payload) => {
-  console.log('edge5.modbus.received', { topic, bytes: payload.length })
+export const handle: TopicHandler = async (topic, payload) => {
+  log(`${EDGE}.modbus.received ${topic} ${payload.length} bytes`)

  const values = parseValues(payload)
  const metrics = toMetrics(values, new Date().toISOString())
--- a/app/src/handlers/index.ts
+++ b/app/src/handlers/index.ts
@@ -1,15 +1,24 @@
-import { register } from '../registry.js'
-import { handleDemoModbus, TOPIC as demoModbus } from './demo-modbus.js'
-import { handleDemoPlc, TOPIC as demoPlc } from './demo-plc.js'
-import { handleEdge5Modbus, TOPIC as edge5Modbus } from './edge5-modbus.js'
-import {
-  handleEdge5ModbusV2,
-  TOPIC as edge5ModbusV2,
-} from './edge5-modbus-v2.js'
-import { handleEdge5Video, TOPIC as edge5Video } from './edge5-video.js'
+import { register } from '../registry.js';

-register(demoModbus, handleDemoModbus)
-register(demoPlc, handleDemoPlc)
-register(edge5Modbus, handleEdge5Modbus)
-register(edge5ModbusV2, handleEdge5ModbusV2)
-register(edge5Video, handleEdge5Video)
+import { handleDemoPlc } from './demo-plc.js';
+import { handleDemoModbus } from './demo-modbus.js';
+import { handleEdge5ModbusV2 } from './edge5-modbus-v2.js';
+import { handleEdge5Video } from './edge5-video.js';
+import { handleEdge5VideoV2 } from './edge5-video-v2.js';
+
+import { handle as interpretation } from './edge5i-modbus.js';
+import { handle as cdab} from './edge5cdab-modbus.js';
+
+const DEMO_PLC_TOPIC = 'data/demo/plc/v1';
+const DEMO_MODBUS_TOPIC = 'data/demo/modbus/v1';
+const EDGE5_MODBUS_TOPIC = 'data/edge5/modbus/v2';
+const EDGE5_VIDEO_TOPIC = 'data/edge5/video/v1';
+
+register(DEMO_PLC_TOPIC, handleDemoPlc);
+register(DEMO_MODBUS_TOPIC, handleDemoModbus);
+register(EDGE5_MODBUS_TOPIC, handleEdge5ModbusV2);
+register(EDGE5_VIDEO_TOPIC, handleEdge5Video);
+
+register('data/edge5i/modbus', interpretation);
+register('data/edge5cdab/modbus', cdab);
+register('data/edge5/video/v2/+', handleEdge5VideoV2);
--- a/app/src/helpers/log.ts
+++ b/app/src/helpers/log.ts
@@ -0,0 +1,3 @@
+export function log(...args: unknown[]): void {
+  console.log(`[${new Date().toISOString()}]`, ...args)
+}
--- a/app/src/helpers/topic-match.ts
+++ b/app/src/helpers/topic-match.ts
@@ -0,0 +1,38 @@
+export function topicMatchesFilter(filter: string, topic: string): boolean {
+  const filterParts = filter.split('/')
+  const topicParts = topic.split('/')
+
+  let fi = 0
+  let ti = 0
+
+  while (fi < filterParts.length) {
+    const segment = filterParts[fi]
+
+    if (segment === '#') {
+      return fi === filterParts.length - 1
+    }
+
+    if (ti >= topicParts.length) {
+      return false
+    }
+
+    if (segment === '+') {
+      fi++
+      ti++
+      continue
+    }
+
+    if (segment !== topicParts[ti]) {
+      return false
+    }
+
+    fi++
+    ti++
+  }
+
+  return ti === topicParts.length
+}
+
+export function lastTopicSegment(topic: string): string {
+  return topic.split('/').at(-1) ?? ''
+}
--- a/app/src/http/server.ts
+++ b/app/src/http/server.ts
@@ -3,6 +3,8 @@ import { createServer } from 'node:http'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'

+import { log } from '../helpers/log.js'
+
 const httpPort = Number(process.env.HTTP_PORT)
 const publicDir = join(dirname(fileURLToPath(import.meta.url)), '../../public')
 const indexPath = join(publicDir, 'index.html')
@@ -24,5 +26,5 @@ createServer(async (req, res) => {

  res.writeHead(404).end('Not Found')
 }).listen(httpPort, () => {
-  console.log('http.server_started', { port: httpPort })
+  log('http.server_started', { port: httpPort })
 })
--- a/app/src/index.ts
+++ b/app/src/index.ts
@@ -2,5 +2,8 @@ import './handlers/index.js'
 import './http/server.js'
 import './mqtt.js'
 import './stream/edge-chunk-relay.js'
+import './stream/ws-pipe-relay.js'

-console.log('mqtt-worker.started')
+import { log } from './helpers/log.js'
+
+log('mqtt-worker.started')
--- a/app/src/mqtt.ts
+++ b/app/src/mqtt.ts
@@ -1,5 +1,6 @@
 import mqtt from 'mqtt'

+import { log } from './helpers/log.js'
 import { getRegisteredTopics } from './registry.js'
 import { routeMessage } from './router.js'

@@ -8,7 +9,7 @@ const mqttUrl = process.env.MQTT_URL as string
 export const mqttClient = mqtt.connect(mqttUrl)

 mqttClient.on('connect', () => {
-  console.log('mqtt.connected', { url: mqttUrl })
+  log('mqtt.connected', { url: mqttUrl })

  const topics = getRegisteredTopics()
  if (topics.length === 0) {
@@ -21,7 +22,7 @@ mqttClient.on('connect', () => {
      console.error('mqtt.subscribe_error', err)
      return
    }
-    console.log('mqtt.subscribed', { topics })
+    log('mqtt.subscribed', { topics })
  })
 })

@@ -34,5 +35,5 @@ mqttClient.on('error', (err) => {
 })

 mqttClient.on('reconnect', () => {
-  console.log('mqtt.reconnect')
+  log('mqtt.reconnect')
 })
--- a/app/src/registry.ts
+++ b/app/src/registry.ts
@@ -1,18 +1,37 @@
+import { topicMatchesFilter } from './helpers/topic-match.js'
 import type { TopicHandler } from './types.js'

-const handlers = new Map<string, TopicHandler>()
+const exactHandlers = new Map<string, TopicHandler>()
+const patternHandlers = new Map<string, TopicHandler>()
+
+function isPatternTopic(topic: string): boolean {
+  return topic.includes('+') || topic.includes('#')
+}

 export function register(topic: string, handler: TopicHandler): void {
+  const handlers = isPatternTopic(topic) ? patternHandlers : exactHandlers
+
  if (handlers.has(topic)) {
    throw new Error(`Handler already registered for topic: ${topic}`)
  }
  handlers.set(topic, handler)
 }

-export function getHandler(topic: string): TopicHandler | undefined {
-  return handlers.get(topic)
+export function resolveHandler(topic: string): TopicHandler | undefined {
+  const exact = exactHandlers.get(topic)
+  if (exact) {
+    return exact
+  }
+
+  for (const [filter, handler] of patternHandlers) {
+    if (topicMatchesFilter(filter, topic)) {
+      return handler
+    }
+  }
+
+  return undefined
 }

 export function getRegisteredTopics(): string[] {
-  return [...handlers.keys()]
+  return [...exactHandlers.keys(), ...patternHandlers.keys()]
 }
--- a/app/src/router.ts
+++ b/app/src/router.ts
@@ -1,10 +1,10 @@
-import { getHandler } from './registry.js'
+import { resolveHandler } from './registry.js'

 export async function routeMessage(
  topic: string,
  payload: Buffer,
 ): Promise<void> {
-  const handler = getHandler(topic)
+  const handler = resolveHandler(topic)

  if (!handler) {
    console.warn('mqtt.unhandled_topic', { topic })
--- a/app/src/stream/edge-chunk-relay.ts
+++ b/app/src/stream/edge-chunk-relay.ts
@@ -1,29 +1,41 @@
 import type { IncomingMessage } from 'http'
 import { WebSocket, WebSocketServer } from 'ws'

+import { log } from '../helpers/log.js'
+import { lastTopicSegment } from '../helpers/topic-match.js'
+
 const wsPort = Number(process.env.WS_PORT)

 const wss = new WebSocketServer({ port: wsPort, perMessageDeflate: false })
-const clients = new Set<WebSocket>()
+
+const clientsByCamera = new Map<string, Set<WebSocket>>()
+
+function getClients(cameraId: string): Set<WebSocket> {
+  let clients = clientsByCamera.get(cameraId)
+  if (!clients) {
+    clients = new Set()
+    clientsByCamera.set(cameraId, clients)
+  }
+  return clients
+}

 wss.on('connection', (ws: WebSocket, req: IncomingMessage) => {
-  clients.add(ws)
-  console.log('ws.client_connected', {
-    clients: clients.size,
-    ip: req.socket.remoteAddress,
-  })
+  log(`ws.connection ${req.url}`);
+  const cameraId = req.url ? lastTopicSegment(req.url) : 'v1';
+
+  const clients = getClients(cameraId);
+  clients.add(ws);

  ws.on('close', () => {
    clients.delete(ws)
-    console.log('ws.client_closed', { clients: clients.size })
-  })
+    if (clients.size === 0) clientsByCamera.delete(cameraId)
+  });
+
 })

-wss.on('listening', () => {
-  console.log('ws.server_started', { port: wsPort })
-})
-
-export function onEdgeChunk(chunk: Buffer): void {
+export function onEdgeChunk(cameraId: string, chunk: Buffer): void {
+  const clients = clientsByCamera.get(cameraId)
+  if (!clients) return
  for (const client of clients) {
    if (client.readyState === WebSocket.OPEN) {
      client.send(chunk)
--- a/app/src/stream/ws-pipe-relay.ts
+++ b/app/src/stream/ws-pipe-relay.ts
@@ -0,0 +1,94 @@
+import type { IncomingMessage } from 'http'
+import { WebSocket, WebSocketServer } from 'ws'
+
+import { log } from '../helpers/log.js'
+import { lastTopicSegment } from '../helpers/topic-match.js'
+
+const wsPipePort = Number(process.env.WS_PIPE_PORT)
+const LOG_INTERVAL_MS = 10_000
+
+const wss = new WebSocketServer({ port: wsPipePort, perMessageDeflate: false })
+
+const producersByChannel = new Map<string, WebSocket>()
+const viewersByChannel = new Map<string, Set<WebSocket>>()
+const lastLogByChannel = new Map<string, number>()
+
+function getViewers(channel: string): Set<WebSocket> {
+  let viewers = viewersByChannel.get(channel)
+  if (!viewers) {
+    viewers = new Set()
+    viewersByChannel.set(channel, viewers)
+  }
+  return viewers
+}
+
+function broadcast(channel: string, chunk: Buffer): void {
+  const clients = viewersByChannel.get(channel)
+  if (!clients) return
+  for (const client of clients) {
+    if (client.readyState === WebSocket.OPEN) {
+      client.send(chunk)
+    }
+  }
+}
+
+function logThroughput(channel: string, bytes: number): void {
+  const now = Date.now()
+  const lastLog = lastLogByChannel.get(channel) ?? 0
+  if (now - lastLog >= LOG_INTERVAL_MS) {
+    log(`pipe.in [${channel}] ↑ ${bytes}B`)
+    lastLogByChannel.set(channel, now)
+  }
+}
+
+function handleProducer(ws: WebSocket, channel: string): void {
+  const existing = producersByChannel.get(channel)
+  if (existing?.readyState === WebSocket.OPEN) {
+    existing.close(1000, 'replaced')
+  }
+  producersByChannel.set(channel, ws)
+
+  ws.on('message', (data, isBinary) => {
+    if (!isBinary) return
+    const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data as ArrayBuffer)
+    logThroughput(channel, chunk.length)
+    broadcast(channel, chunk)
+  })
+
+  ws.on('close', () => {
+    if (producersByChannel.get(channel) === ws) {
+      producersByChannel.delete(channel)
+    }
+  })
+}
+
+function handleViewer(ws: WebSocket, channel: string, path: string): void {
+  log(`pipe.out.connection ${path}`)
+  const viewers = getViewers(channel)
+  viewers.add(ws)
+
+  ws.on('close', () => {
+    viewers.delete(ws)
+    if (viewers.size === 0) viewersByChannel.delete(channel)
+  })
+}
+
+wss.on('connection', (ws: WebSocket, req: IncomingMessage) => {
+  const path = req.url?.split('?')[0] ?? ''
+
+  if (path.startsWith('/in/')) {
+    handleProducer(ws, lastTopicSegment(path))
+    return
+  }
+
+  if (path.startsWith('/out/')) {
+    handleViewer(ws, lastTopicSegment(path), path)
+    return
+  }
+
+  ws.close(1008, 'unknown path')
+})
+
+wss.on('listening', () => {
+  log('pipe.server_started', { port: wsPipePort })
+})
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -3,26 +3,37 @@ services:
    build: ./mosquitto
    container_name: mosquitto
    ports:
-      - "1883:1883"
+      - "1883:1883" # external MQTT port for receiving data
    volumes:
      - mosquitto_data:/mosquitto/data
+    networks:
+      - default

  app:
    build: ./app
    container_name: mqtt-worker
    depends_on:
      - mosquitto
-    ports:
-      - "80:80"
-      - "9090:9090"
+    expose:
+      - 80 
+      - 9090 
+      - 9091
    environment:
      MQTT_URL: mqtt://mosquitto:1883
-      HTTP_PORT: "80"
-      WS_PORT: "9090"
-      CLOUD_INGEST_URL: ${CLOUD_INGEST_URL:-https://demo.backend.drill.greact.ru/ingest}
-      CLOUD_INGEST_API_KEY: ${CLOUD_INGEST_API_KEY:-}
-      DEMO_CLOUD_INGEST_URL: ${DEMO_CLOUD_INGEST_URL:-}
+      HTTP_PORT: 80 # http port for video previewiong page
+      WS_PORT: 9090 # WebSocket port for video streaming
+      WS_PIPE_PORT: 9091 # WebSocket port for incoming and outgoing binary data
+      CLOUD_INGEST_URL: ${CLOUD_INGEST_URL}
+      CLOUD_INGEST_API_KEY: ${CLOUD_INGEST_API_KEY}
+      DEMO_CLOUD_INGEST_URL: ${DEMO_CLOUD_INGEST_URL}
      EDGE5_MODBUS_V2_MAPPING_FILE: ${EDGE5_MODBUS_V2_MAPPING_FILE:-/app/src/mappings/edge5-modbus.json}
+    networks:
+      - default
+      - proxy

 volumes:
  mosquitto_data:
+
+networks:
+  proxy:
+    external: true
--- a/package-lock.json
+++ b/package-lock.json
@@ -0,0 +1,6 @@
+{
+  "name": "mqtt-ingest",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}
Author	SHA1	Message	Date
Nikita Biziaev	cd599a177b	ws-pipe-relay	2026-07-04 21:03:50 +05:00
Nikita Biziaev	a829a9df3d	video optimization/	2026-07-04 18:57:41 +05:00
Nikita Biziaev	eb001771b5	WebSocketServer.clientsByCamera	2026-07-04 18:09:16 +05:00
Nikita Biziaev	e0437edf18	data/edge5/video/v2/+	2026-07-04 17:26:30 +05:00
Nikita Biziaev	f61fd87bac	fit video	2026-07-03 17:38:23 +05:00
Nikita Biziaev	80772c8751	custom domain name	2026-07-03 17:30:05 +05:00
Nikita Biziaev	3eb9680ef8	networks comments	2026-07-03 17:16:31 +05:00
Nikita Biziaev	495651379a	video preview page	2026-07-03 17:07:55 +05:00
Nikita Biziaev	11a4f9d03a	app/public/index.html	2026-07-03 16:51:55 +05:00
Nikita Biziaev	9988281368	exceeded log	2026-07-03 13:34:52 +05:00
Nikita Biziaev	60bde31a7b	cdab validate numbers	2026-07-03 12:13:54 +05:00
Nikita Biziaev	5b53f4ed12	Merge branch 'dev'	2026-07-03 12:06:03 +05:00
Nikita Biziaev	337497171a	stringify	2026-07-03 12:03:39 +05:00
Никита Бизяев	d65bf84a60	Merge pull request 'добавлена поддержка dev окружения' (#10 ) from dev into main Reviewed-on: #10	2026-07-03 06:38:41 +00:00
Первов Артем	64dde77f7b	добавлена поддержка dev окружения	2026-07-02 22:39:59 +03:00
Nikita Biziaev	d7bfaa678e	data/edge5cdab/modbus & logging	2026-07-02 18:39:43 +05:00
Nikita Biziaev	f5dd5a7f7f	padStart(3, '0')	2026-07-02 15:51:33 +05:00
Nikita Biziaev	540a8ba1e9	data/edge5i/modbus	2026-07-02 14:40:49 +05:00
Nikita Biziaev	16c1712752	data/edge5/modbus/v1 to demo refactoring	2026-07-01 13:34:28 +05:00
Никита Бизяев	ac4e0d68c3	Merge pull request 'Обновил отправку тегов с массива на построчный формат' (#8 ) from edge5modbus into main Reviewed-on: #8	2026-06-22 06:45:44 +00:00
APervov	adde96d8ea	Merge pull request 'Скорректировал порядок сборки в Dockerfile. Устранена проблема - не подтягиваливались devDependencies (tsc) при production сборке.' (#7 ) from edge5modbus into main Reviewed-on: #7	2026-06-19 12:46:00 +00:00
APervov	34f24824e7	Merge pull request 'remove default env values. correct package json with env vars .' (#6 ) from edge5modbus into main Reviewed-on: #6	2026-06-19 08:18:07 +00:00
APervov	381bb5db31	Merge pull request 'add mapper. add v2 handler. add tag description short and full versions. delete topic[1-5].' (#5 ) from edge5modbus into main Reviewed-on: #5	2026-06-19 06:15:28 +00:00
Никита Бизяев	ed039af385	Merge pull request 'remove bash code from docker-compose. Add Dockerfile. Remove comments.' (#4 ) from edge5modbus into main Reviewed-on: #4	2026-06-09 05:53:08 +00:00
APervov	8820c5b518	Merge pull request 'update CLOUD_INGEST_URL var' (#3 ) from edge5modbus into main Reviewed-on: #3	2026-06-05 18:31:41 +00:00
APervov	04b38fe078	Merge pull request 'update docker-compose.yml' (#2 ) from edge5modbus into main Reviewed-on: #2	2026-06-05 18:25:12 +00:00
APervov	fb1ff5af1c	Merge pull request 'add reading of 125 values from emulator' (#1 ) from edge5modbus into main Reviewed-on: #1	2026-06-05 15:38:43 +00:00
Никита Бизяев	5df97a687b	Update docker-compose.yml	2026-06-05 13:35:35 +00:00