flowchart LR
    A[预约系统 / OA] -->|REST + WebHook| B(信令服务器nNode.js + Socket.IO)
    B <-- WebSocket --> C[会议室网关n树莓派 / 工控机 + WebRTC Native]
    C <-- GPIO / RS485 --> D[门禁控制器n继电器 / 韦根协议]
    C <-- USB / CSI --> E[智能感知模块n毫米波 / TOF / 摄像头]
    F[用户端n浏览器 / 小程序] <-- WebRTC --> B

// signaling/server.js
const { Server } = require('socket.io');
const jwt = require('jsonwebtoken');
const io = new Server(3000, { cors: { origin: '*' } });

const rooms = new Map(); // roomId -> { gatewaySocket, userSockets: Set }

io.use((socket, next) => {
  const token = socket.handshake.auth.token;
  try { socket.user = jwt.verify(token, process.env.JWT_SECRET); next(); }
  catch { next(new Error('Invalid token')); }
});

io.on('connection', socket => {
  const { roomId, role } = socket.user; // role: 'gateway' | 'user'

  if (role === 'gateway') {
    rooms.set(roomId, { gateway: socket, users: new Set() });
    socket.join(roomId);
  } else {
    const room = rooms.get(roomId);
    if (!room) return socket.disconnect();
    room.users.add(socket.id);
    socket.join(roomId);
  }

  // 透传 SDP / Candidate
  socket.on('signal', ({ target, payload }) => {
    io.to(target).emit('signal', { from: socket.id, payload });
  });

  socket.on('disconnect', () => {
    const room = rooms.get(roomId);
    if (!room) return;
    if (role === 'gateway') rooms.delete(roomId);
    else { room.users.delete(socket.id); if (!room.users.size) rooms.delete(roomId); }
  });
});

# hal/door.py
from abc import ABC, abstractmethod
import RPi.GPIO as GPIO

class DoorController(ABC):
    @abstractmethod
    def unlock(self, duration_sec: int = 5): ...
    @abstractmethod
    def lock(self): ...
    @abstractmethod
    def get_state(self) -> str: ...  # 'locked' | 'unlocked' | 'ajar'

class RelayDoor(DoorController):
    def __init__(self, pin: int = 17):
        self.pin = pin
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(pin, GPIO.OUT, initial=GPIO.HIGH)  # 高电平锁定

    def unlock(self, duration_sec=5):
        GPIO.output(self.pin, GPIO.LOW)
        threading.Timer(duration_sec, self.lock).start()

    def lock(self):
        GPIO.output(self.pin, GPIO.HIGH)

    def get_state(self):
        return 'unlocked' if GPIO.input(self.pin) == GPIO.LOW else 'locked'

# gateway/main.py
import asyncio, json
from aiortc import RTCPeerConnection, RTCSessionDescription
from aiortc.contrib.signaling import BYE
from hal.door import RelayDoor
from hal.sensor import RadarSensor   # 见第 5 节

pc = RTCPeerConnection()
door = RelayDoor()
sensor = RadarSensor()

@pc.on("datachannel")
def on_dc(channel):
    if channel.label == "dc-control":
        @channel.on("message")
        def on_msg(msg):
            cmd = json.loads(msg)
            if cmd["action"] == "unlock":
                door.unlock(cmd.get("duration", 5))
                channel.send(json.dumps({"event": "DOOR_OPENED", "ts": time.time()}))
            elif cmd["action"] == "lock":
                door.lock()
                channel.send(json.dumps({"event": "DOOR_LOCKED", "ts": time.time()}))
    elif channel.label == "dc-sensor":
        # 定时上报感知数据
        async def report():
            while True:
                await asyncio.sleep(2)
                channel.send(json.dumps(sensor.read()))
        asyncio.create_task(report())

# 信令循环（对接第 3 节 Socket.IO）
async def signaling_loop():
    # 省略：通过 aiohttp 建立 WebSocket，处理 offer/answer/candidate
    pass

asyncio.run(signaling_loop())

# hal/sensor.py
from enum import Enum, auto
import serial, struct

class RoomState(Enum):
    EMPTY = auto()
    OCCUPIED = auto()
    MEETING_ACTIVE = auto()
    MEETING_ENDED = auto()

class RadarSensor:
    def __init__(self, port="/dev/ttyUSB0"):
        self.ser = serial.Serial(port, 256000, timeout=0.1)
        self.state = RoomState.EMPTY
        self.last_motion_ts = 0

    def read(self):
        # 解析雷达 TLV 数据帧，简化示例
        raw = self.ser.read(256)
        if not raw: return {"state": self.state.name, "count": 0}
        # 假设解析出人数 count、最近动作距离 dist
        count, dist = self._parse_tlv(raw)
        now = time.time()

        # 状态迁移逻辑
        if count > 0:
            self.last_motion_ts = now
            if self.state == RoomState.EMPTY:
                self.state = RoomState.OCCUPIED
            elif self.state == RoomState.OCCUPIED and now - self.last_motion_ts > 300:
                self.state = RoomState.MEETING_ACTIVE
        elif self.state in (RoomState.OCCUPIED, RoomState.MEETING_ACTIVE):
            if now - self.last_motion_ts > 600:  # 10 分钟无人
                self.state = RoomState.MEETING_ENDED

        return {"state": self.state.name, "count": count, "distance": dist}

// packages/meeting-door-sdk/src/index.ts
export interface DoorSDKConfig {
  signalingUrl: string;      // wss://signal.corp.com
  tokenEndpoint: string;     // /api/v1/door/token
  roomId: string;
  onStateChange: (state: DoorState) => void;
}

export enum DoorState {
  IDLE = 'idle',
  CONNECTING = 'connecting',
  READY = 'ready',           // DataChannel 建立成功
  UNLOCKED = 'unlocked',
  LOCKED = 'locked',
  ERROR = 'error'
}

export class MeetingDoorSDK {
  private pc: RTCPeerConnection;
  private dc: RTCDataChannel | null = null;
  private state: DoorState = DoorState.IDLE;

  constructor(private cfg: DoorSDKConfig) {
    this.pc = new RTCPeerConnection({ iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] });
    this.initDataChannel();
  }

  private async initDataChannel() {
    this.dc = this.pc.createDataChannel('dc-control', { negotiated: true, id: 0 });
    this.dc.onopen = () => this.setState(DoorState.READY);
    this.dc.onmessage = e => this.cfg.onStateChange(JSON.parse(e.data));
    this.dc.onclose = () => this.setState(DoorState.IDLE);
  }

  async join() {
    this.setState(DoorState.CONNECTING);
    const token = await fetch(this.cfg.tokenEndpoint, {
      method: 'POST', body: JSON.stringify({ roomId: this.cfg.roomId })
    }).then(r => r.json()).then(r => r.token);

    const offer = await this.pc.createOffer();
    await this.pc.setLocalDescription(offer);

    // 通过 HTTP 发送 Offer 给信令服务器（或复用现有 WS）
    await fetch(`${this.cfg.signalingUrl.replace('wss','https')}/offer`, {
      method: 'POST', headers: { Authorization: `Bearer ${token}` },
      body: JSON.stringify({ sdp: offer.sdp, roomId: this.cfg.roomId })
    }).then(r => r.json()).then(ans => {
      this.pc.setRemoteDescription(new RTCSessionDescription(ans));
    });
  }

  unlock(duration = 5) { this.dc?.send(JSON.stringify({ action: 'unlock', duration })); }
  lock() { this.dc?.send(JSON.stringify({ action: 'lock' })); }
  destroy() { this.pc.close(); this.setState(DoorState.IDLE); }

  private setState(s: DoorState) { this.state = s; this.cfg.onStateChange(s); }
}

// dashboard/RoomStatusBoard.tsx
import { useEffect, useState } from 'react';
import { io, Socket } from 'socket.io-client';

interface RoomSnapshot {
  roomId: string;
  door: 'locked' | 'unlocked' | 'ajar';
  occupancy: number;
  meetingTitle?: string;
  env?: { temp: number; hum: number; co2: number };
}

export const RoomStatusBoard = ({ floorId }: { floorId: string }) => {
  const [rooms, setRooms] = useState<Map<string, RoomSnapshot>>(new Map());
  const [socket, setSocket] = useState<Socket | null>(null);

  useEffect(() => {
    const s = io('wss://signal.corp.com', { path: '/dashboard', auth: { token: getDashboardToken() } });
    s.on('room:snapshot', (data: RoomSnapshot) => setRooms(m => new Map(m).set(data.roomId, data)));
    s.on('room:batch', (list: RoomSnapshot[]) => setRooms(new Map(list.map(r => [r.roomId, r]))));
    setSocket(s);
    return () => s.disconnect();
  }, [floorId]);

  return (
    <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
      {[...rooms.values()].map(r => (
        <RoomCard key={r.roomId} data={r} />
      ))}
    </div>
  );
};

const RoomCard = ({ data }: { data: RoomSnapshot }) => (
  <div className={`p-4 rounded-xl border transition-colors ${
    data.door === 'unlocked' ? 'border-green-400 bg-green-50' :
    data.door === 'ajar'   ? 'border-yellow-400 bg-yellow-50' :
                             'border-gray-200 bg-white'
  }`}>
    <div className="flex justify-between items-center mb-2">
      <span className="font-mono text-sm text-gray-500">{data.roomId}</span>
      <DoorIcon state={data.door} />
    </div>
    <p className="truncate font-medium">{data.meetingTitle || '空闲'}</p>
    <div className="flex items-center gap-4 text-xs text-gray-600 mt-2">
      <span>👥 {data.occupancy}</span>
      {data.env && <>🌡 {data.env.temp}°C · 💧 {data.env.hum}% · 🫁 {data.env.co2}ppm</>}
    </div>
  </div>
);

// signaling/multi-tenant.js
const { Server } = require('socket.io');
const { createAdapter } = require('@socket.io/redis-adapter');
const { createClient } = require('redis');

const pubClient = createClient({ url: process.env.REDIS_URL });
const subClient = pubClient.duplicate();
const io = new Server({ adapter: createAdapter(pubClient, subClient) });

// Namespace 按租户隔离
io.of(/^/tenant-[w-]+$/).use(async (socket, next) => {
  const tenantId = socket.nsp.name.split('-')[1];
  const token = socket.handshake.auth.token;
  try {
    const payload = jwt.verify(token, getTenantPublicKey(tenantId));
    if (payload.tenantId !== tenantId) throw new Error('Tenant mismatch');
    socket.tenantId = tenantId;
    socket.userId = payload.sub;
    socket.roles = payload.roles || [];
    next();
  } catch (e) { next(e); }
}).on('connection', socket => {
  // 复用单租户逻辑，仅在 roomId 前加 tenantId 前缀
  const fullRoomId = `${socket.tenantId}:${socket.handshake.query.roomId}`;
  socket.join(fullRoomId);
  // ... 信令转发逻辑同单租户
});

# gateway/config.yaml 关键调优项
webrtc:
  ice:
    gatheringTimeout: 3000      # ms，内网环境可缩短
    candidatePoolSize: 10       # 预收集候选对
  dataChannel:
    maxRetransmits: 3           # 可靠模式重传次数
    ordered: true
  sctp:
    maxMessageSize: 65535       # 64 KB，避免大帧阻塞

signaling:
  redis:
    maxRetriesPerRequest: 3
    enableReadyCheck: true
  socketio:
    pingInterval: 15000         # 心跳 15s
    pingTimeout: 10000
    maxHttpBufferSize: 1e6      # 1 MB

# 使用 k6 模拟 500 并发会议室网关
# k6 run --vus 500 --duration 10m load/gateway.js

import ws from 'k6/ws';
import { check, sleep } from 'k6';

export const options = { stages: [{ target: 500, duration: '5m' }, { target: 500, duration: '5m' }] };

export default function () {
  const url = `wss://signal.corp.com/tenant-${__ENV.TENANT_ID}?roomId=room-${__VU}&token=${__ENV.TOKEN}`;
  ws.connect(url, {}, socket => {
    socket.on('open', () => {
      // 模拟网关发送心跳 + 传感器数据
      setInterval(() => socket.send(JSON.stringify({ type: 'heartbeat', ts: Date.now() })), 10000);
      setInterval(() => socket.send(JSON.stringify({ type: 'sensor', occupancy: Math.floor(Math.random()*10) })), 2000);
    });
    socket.on('message', msg => check(msg, { 'signal received': m => m.includes('sdp') }));
    socket.setTimeout(() => socket.close(), 600000);
  });
  sleep(600);
}

# gateway/feature_flags.py
class FeatureFlags:
    # 运维可通过 Consul/Etcd 热更新，无需重启网关
    WEbrtc_ENABLED = True
    SENSOR_FUSION_ENABLED = True
    AUTO_LOCK_AFTER_MEETING = True
    FALLBACK_HTTP_UNLOCK = True   # WebRTC 失败时允许 HTTP 开锁
    EMERGENCY_UNLOCK_PRIORITY = True  # 消防信号最高优先级

    @classmethod
    def evaluate(cls, key: str) -> bool:
        return consul_kv_get(f'flags/{key}', getattr(cls, key.upper()))

gitGraph
   commit tag:"v1.0.0-baseline"
   branch feat/sensor-fusion
   commit
   commit tag:"v1.1.0-rc1"
   checkout main
   merge feat/sensor-fusion tag:"v1.1.0"
   branch hotfix/turn-fallback
   commit tag:"v1.1.1"
   checkout main
   merge hotfix/turn-fallback

// gateway 中间件植入 trace-id
func TraceMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        traceID := r.Header.Get("X-Trace-ID")
        if traceID == "" { traceID = uuid.NewString() }
        ctx := trace.ContextWithSpanContext(r.Context(), trace.NewSpanContext(trace.SpanContextConfig{
            TraceID: traceID, SpanID: uuid.NewString()[:16], TraceFlags: trace.FlagsSampled,
        }))
        w.Header().Set("X-Trace-ID", traceID)
        next.ServeHTTP(w, r.WithContext(ctx))
    })
}

-- ClickHouse 物化视图：每日会议室利用率
CREATE MATERIALIZED VIEW mv_daily_room_util
ENGINE = SummingMergeTree()
PARTITION BY toYYYYMM(day)
ORDER BY (tenant_id, park_id, building_id, room_id, day)
AS SELECT
    tenant_id, park_id, building_id, room_id,
    toDate(ts) AS day,
    countIf(action = 'unlock') AS unlock_cnt,
    sumIf(duration_sec, action = 'unlock') AS total_open_sec,
    avg(occupancy) AS avg_occupancy,
    quantile(0.95)(occupancy) AS p95_occupancy
FROM door_events
GROUP BY tenant_id, park_id, building_id, room_id, day;

# contracts/door-api.yaml (OpenAPI 3.1)
openapi: 3.1.0
info: { title: Meeting Door API, version: 1.2.0 }
servers: [{ url: 'https://api.corp.com/v1' }]
paths:
  /door/unlock:
    post:
      security: [{ BearerAuth: [] }]
      parameters: [{ $ref: '#/components/parameters/RoomId' }]
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                duration: { type: integer, minimum: 1, maximum: 300, default: 5 }
      responses:
        '200':
          description: Unlock accepted
          content:
            application/json:
              schema: { $ref: '#/components/schemas/UnlockResponse' }
components:
  schemas:
    UnlockResponse:
      type: object
      required: [task_id, estimated_latency_ms]
      properties:
        task_id: { type: string, format: uuid }
        estimated_latency_ms: { type: integer }
  parameters:
    RoomId:
      name: room_id
      in: path
      required: true
      schema: { type: string, pattern: '^[A-Z]-d{3}$' }

# .gitlab-ci.yml 片段
stages: [build, test, sign, deploy-canary, deploy-prod]

build_firmware:
  stage: build
  image: docker.io/arm64v8/ubuntu:22.04
  script:
    - apt-get update && apt-get install -y cmake g++ libssl-dev
    - cmake -B build -DCMAKE_BUILD_TYPE=Release
    - cmake --build build --target gateway_firmware
  artifacts:
    paths: [build/gateway_firmware.bin]
    expire_in: 1 week

sign_firmware:
  stage: sign
  needs: [build_firmware]
  script:
    - cosign sign-blob --key env://COSIGN_PRIVATE_KEY build/gateway_firmware.bin > firmware.bin.sig
    - jq -n --arg ver "$CI_COMMIT_TAG" --arg sha "$(sha256sum build/gateway_firmware.bin | cut -d' ' -f1)" 
      --arg sig "$(cat firmware.bin.sig)" 
      '{version: $ver, sha256: $sha, signature: $sig, min_compatible: "1.0.0"}' > manifest.json
  artifacts: [manifest.json, firmware.bin.sig]

deploy_canary:
  stage: deploy-canary
  environment: canary
  script: aws s3 sync . s3://ota-bucket/canary/ --delete
  rules: [{ if: '$CI_COMMIT_BRANCH == "main"' }]