334 lines
15 KiB
Python
334 lines
15 KiB
Python
"""Monitor 启动配置 — 所有可配置项均来自 config.json，后台「启动配置」页可编辑。"""
|
||
import json
|
||
import os
|
||
from urllib.parse import quote
|
||
|
||
from framework.settings import BASE_DIR
|
||
from monitor_runtime.paths import RESOURCE_ROOT, DESKTOP
|
||
from app.utils.Secrets import get_runtime_secret
|
||
|
||
|
||
def _resolve_path(path, base=None):
|
||
"""相对路径基于项目根目录 BASE_DIR 解析为绝对路径。"""
|
||
base = base or str(BASE_DIR)
|
||
if not path:
|
||
return ""
|
||
p = str(path).strip()
|
||
if not p:
|
||
return ""
|
||
if os.path.isabs(p):
|
||
return os.path.normpath(p)
|
||
return os.path.normpath(os.path.join(base, p.replace("\\", "/")))
|
||
|
||
|
||
def _bool(v, default=False):
|
||
if v is None:
|
||
return default
|
||
if isinstance(v, bool):
|
||
return v
|
||
if isinstance(v, (int, float)):
|
||
return v != 0
|
||
return str(v).strip().lower() in ("1", "true", "yes", "on")
|
||
|
||
|
||
def _int(v, default=0):
|
||
try:
|
||
return int(v)
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
|
||
def _float(v, default=0.0):
|
||
try:
|
||
return float(v)
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
|
||
class Config:
|
||
def __init__(self, filepath):
|
||
self.__filepath = filepath
|
||
config_data = None
|
||
for encoding in ["utf-8", "gbk"]:
|
||
try:
|
||
with open(filepath, "r", encoding=encoding) as f:
|
||
config_data = json.loads(f.read())
|
||
break
|
||
except Exception as e:
|
||
print("Config.__init__() error:%s,encoding=%s|%s" % (str(e), encoding, str(filepath)))
|
||
|
||
if not config_data:
|
||
raise Exception("Config.__init__() read %s error" % str(filepath))
|
||
|
||
self.__config_data = config_data
|
||
self._apply(config_data)
|
||
|
||
def _apply(self, config_data):
|
||
self.__config_data_str = str(config_data)
|
||
base = str(BASE_DIR)
|
||
|
||
# —— 基础 ——
|
||
# Internal credentials are never sourced from the web-editable config.
|
||
self.internalApiSecret = get_runtime_secret("internal_api_secret")
|
||
self.internalHost = "127.0.0.1"
|
||
self.externalHost = config_data.get("host", "127.0.0.1")
|
||
self.adminPort = _int(config_data.get("adminPort"), 10001)
|
||
|
||
self.logDebug = _bool(config_data.get("logDebug"), False)
|
||
self.isEnableLoginCaptcha = _bool(config_data.get("isEnableLoginCaptcha"), True)
|
||
self.isEnableUpdatePopup = _bool(config_data.get("isEnableUpdatePopup"), False)
|
||
# Both flags require an explicit local opt-in. Endpoints are environment-only.
|
||
self.telemetryEnabled = _bool(config_data.get("telemetryEnabled"), False)
|
||
self.updateCheckEnabled = _bool(config_data.get("updateCheckEnabled"), False)
|
||
|
||
self.autoAddStreamProxy = _bool(config_data.get("autoAddStreamProxy"), True)
|
||
self.autoAddStreamProxySleep = _int(config_data.get("autoAddStreamProxySleep"), 15)
|
||
|
||
# —— 路径与工具 ——
|
||
self.ffmpeg = str(os.environ.get("MONITOR_FFMPEG") or config_data.get("ffmpeg", "ffmpeg") or "ffmpeg").strip()
|
||
if DESKTOP:
|
||
self.ffmpeg = str(RESOURCE_ROOT / "tools" / "ffmpeg.exe")
|
||
self.fontPath = _resolve_path(config_data.get("fontPath", ""), str(RESOURCE_ROOT))
|
||
self.uploadDir = _resolve_path(config_data.get("uploadDir", "static/upload"), base)
|
||
self.storageDir = _resolve_path(config_data.get("storageDir", "static/storage"), base)
|
||
|
||
# —— 流媒体 ZLM ——
|
||
self.mediaHttpPort = _int(config_data.get("mediaHttpPort"), 10002)
|
||
self.mediaRtspPort = _int(config_data.get("mediaRtspPort"), 10554)
|
||
self.mediaRtmpPort = _int(config_data.get("mediaRtmpPort"), 10935)
|
||
self.isEnableMediaProxyRtmp = _bool(config_data.get("isEnableMediaProxyRtmp"), False)
|
||
self.mediaSecret = get_runtime_secret("media_secret")
|
||
self.mediaStartPath = _resolve_path(config_data.get("mediaStartPath", ""), str(RESOURCE_ROOT))
|
||
if DESKTOP:
|
||
self.mediaStartPath = str(RESOURCE_ROOT / "zlm" / "monitor_zlm.exe")
|
||
self.mediaStartConfigPath = _resolve_path(config_data.get("mediaStartConfigPath", ""), base)
|
||
self.autoStartMedia = _bool(config_data.get("autoStartMedia"), False)
|
||
if DESKTOP:
|
||
self.autoStartMedia = True
|
||
|
||
self.adminHost = "http://" + self.internalHost + ":" + str(self.adminPort)
|
||
self.mediaHttpHost = "http://" + self.internalHost + ":" + str(self.mediaHttpPort)
|
||
|
||
# —— 视频分析 ——
|
||
self.analysisTargetFps = _int(config_data.get("analysisTargetFps"), 5)
|
||
self.analysisConfThreshold = _float(config_data.get("analysisConfThreshold"), 0.4)
|
||
self.analysisProcessMode = _int(config_data.get("analysisProcessMode"), 1)
|
||
self.analysisSharedInference = _bool(config_data.get("analysisSharedInference"), True)
|
||
self.analysisInferenceWorkers = max(1, _int(config_data.get("analysisInferenceWorkers"), 1))
|
||
|
||
# —— 录像 ——
|
||
self.recordingEnabled = _bool(config_data.get("recordingEnabled"), False)
|
||
self.recordingSegmentSeconds = max(60, _int(config_data.get("recordingSegmentSeconds"), 600))
|
||
self.recordingRetainDays = max(0, _int(config_data.get("recordingRetainDays"), 7))
|
||
self.recordingRetainGb = max(0.0, _float(config_data.get("recordingRetainGb"), 0.0))
|
||
|
||
# —— GB28181 SIP ——
|
||
__sip = config_data.get("sipServer") or {}
|
||
self.sipServer = {
|
||
"sipServerIp": str(__sip.get("sipServerIp", "127.0.0.1")).strip(),
|
||
"sipServerPort": _int(__sip.get("sipServerPort"), 15060),
|
||
"sipServerNonce": get_runtime_secret("sip_server_nonce"),
|
||
"sipTransferMode": _int(__sip.get("sipTransferMode"), 0),
|
||
"sipServerId": str(__sip.get("sipServerId", "34020000002000000001")).strip(),
|
||
"sipServerRealm": str(__sip.get("sipServerRealm", "3402000000")).strip(),
|
||
"sipServerPass": get_runtime_secret("sip_server_password"),
|
||
"sipServerTimeout": _int(__sip.get("sipServerTimeout"), 1800),
|
||
"sipServerExpiry": _int(__sip.get("sipServerExpiry"), 3600),
|
||
"rtpTransferMode": _int(__sip.get("rtpTransferMode"), 0),
|
||
"rtpTransferAudioType": _int(__sip.get("rtpTransferAudioType"), 0),
|
||
"autoInviteAfterRecCateLog": _bool(__sip.get("autoInviteAfterRecCateLog"), True),
|
||
}
|
||
|
||
self._ensure_storage_dirs()
|
||
self._sync_media_server_config()
|
||
|
||
def _sync_media_server_config(self):
|
||
"""Inject runtime-only secrets into the selected ZLM config.
|
||
|
||
ZLM supports a static hook URL but cannot produce our per-request HMAC,
|
||
so its two hooks carry the high-entropy token and are additionally
|
||
restricted to a direct loopback peer by Django middleware.
|
||
"""
|
||
source_path = self.mediaStartConfigPath
|
||
if not source_path or not os.path.isfile(source_path):
|
||
return
|
||
try:
|
||
lines = None
|
||
source_encoding = "utf-8"
|
||
for encoding in ("utf-8", "gbk"):
|
||
try:
|
||
with open(source_path, "r", encoding=encoding) as f:
|
||
lines = f.readlines()
|
||
source_encoding = encoding
|
||
break
|
||
except UnicodeDecodeError:
|
||
continue
|
||
if lines is None:
|
||
raise RuntimeError("unsupported config encoding")
|
||
section = ""
|
||
token = quote(self.internalApiSecret, safe="")
|
||
hook_urls = {
|
||
"on_publish": "http://127.0.0.1:%d/inner/on_publish?token=%s" % (self.adminPort, token),
|
||
"on_stream_not_found": "http://127.0.0.1:%d/inner/on_stream_not_found?token=%s" % (self.adminPort, token),
|
||
}
|
||
output = []
|
||
for line in lines:
|
||
stripped = line.strip()
|
||
if stripped.startswith("[") and stripped.endswith("]"):
|
||
section = stripped[1:-1].strip().lower()
|
||
if "=" in line and not stripped.startswith(";"):
|
||
key = line.split("=", 1)[0].strip()
|
||
if section == "api" and key == "secret":
|
||
newline = "secret=%s\n" % self.mediaSecret
|
||
line = newline
|
||
elif section == "hook" and key in hook_urls:
|
||
newline = "%s=%s\n" % (key, hook_urls[key])
|
||
line = newline
|
||
output.append(line)
|
||
runtime_dir = os.path.join(str(BASE_DIR), ".runtime")
|
||
os.makedirs(runtime_dir, exist_ok=True)
|
||
runtime_path = os.path.join(runtime_dir, "zlm-config.ini")
|
||
temp = runtime_path + ".tmp"
|
||
with open(temp, "w", encoding=source_encoding, newline="") as f:
|
||
f.writelines(output)
|
||
os.replace(temp, runtime_path)
|
||
self.mediaStartConfigPath = runtime_path
|
||
except Exception as e:
|
||
raise RuntimeError("failed to secure ZLM config %s: %s" % (source_path, e))
|
||
|
||
def _ensure_storage_dirs(self):
|
||
for d in (self.uploadDir, self.storageDir):
|
||
if d and not os.path.exists(d):
|
||
os.makedirs(d, exist_ok=True)
|
||
self.uploadAlgorithmWeightDir = os.path.join(self.uploadDir, "weight")
|
||
self.uploadAudioDir = os.path.join(self.uploadDir, "audio")
|
||
self.uploadAudioDir_www = "/upload/audio/"
|
||
|
||
self.storageTempDir = os.path.join(self.storageDir, "temp")
|
||
self.storageAlarmDir = os.path.join(self.storageDir, "alarm")
|
||
self.storageSnapshotsDir = os.path.join(self.storageDir, "snapshots")
|
||
self.storageRecordDir = os.path.join(self.storageDir, "record")
|
||
for d in (self.storageTempDir, self.storageAlarmDir, self.storageSnapshotsDir, self.storageRecordDir):
|
||
if not os.path.exists(d):
|
||
os.makedirs(d, exist_ok=True)
|
||
self.storageDir_www = "/storage/openAccess?filename="
|
||
|
||
def getStr(self):
|
||
return json.dumps(self.to_dict(), ensure_ascii=False)
|
||
|
||
def to_dict(self, include_secrets=False):
|
||
"""供启动配置页 / API 使用的完整配置快照。"""
|
||
d = dict(self.__config_data)
|
||
d.setdefault("sipServer", {})
|
||
d.pop("safe", None)
|
||
d.pop("internalApiSecret", None)
|
||
d.pop("mediaSecret", None)
|
||
# 布尔/int 与内存态保持一致
|
||
d["host"] = self.externalHost
|
||
d["autoAddStreamProxy"] = self.autoAddStreamProxy
|
||
d["autoAddStreamProxySleep"] = self.autoAddStreamProxySleep
|
||
d["isEnableLoginCaptcha"] = self.isEnableLoginCaptcha
|
||
d["logDebug"] = self.logDebug
|
||
d["isEnableUpdatePopup"] = self.isEnableUpdatePopup
|
||
d["telemetryEnabled"] = self.telemetryEnabled
|
||
d["updateCheckEnabled"] = self.updateCheckEnabled
|
||
d["isEnableMediaProxyRtmp"] = self.isEnableMediaProxyRtmp
|
||
d["autoStartMedia"] = self.autoStartMedia
|
||
d["analysisSharedInference"] = self.analysisSharedInference
|
||
d["recordingEnabled"] = self.recordingEnabled
|
||
d["sipServer"] = dict(self.sipServer)
|
||
d["sipServer"].pop("sipServerPass", None)
|
||
d["sipServer"].pop("sipServerNonce", None)
|
||
if include_secrets:
|
||
d["internalApiSecret"] = self.internalApiSecret
|
||
d["mediaSecret"] = self.mediaSecret
|
||
d["sipServer"]["sipServerPass"] = self.sipServer["sipServerPass"]
|
||
d["sipServer"]["sipServerNonce"] = self.sipServer["sipServerNonce"]
|
||
return d
|
||
|
||
def save_from_web(self, params):
|
||
"""合并 Web 表单并写回 config.json（保留未在表单中的键）。"""
|
||
data = dict(self.__config_data)
|
||
p = params or {}
|
||
|
||
def _set(key, val):
|
||
data[key] = val
|
||
|
||
for key in ("ffmpeg",):
|
||
if key in p:
|
||
_set(key, str(p.get(key) or "").strip())
|
||
|
||
if "host" in p:
|
||
_set("host", str(p.get("host") or "").strip())
|
||
if "uploadDir" in p:
|
||
_set("uploadDir", str(p.get("uploadDir") or "").strip())
|
||
if "storageDir" in p:
|
||
_set("storageDir", str(p.get("storageDir") or "").strip())
|
||
if "fontPath" in p:
|
||
_set("fontPath", str(p.get("fontPath") or "").strip())
|
||
if "mediaStartPath" in p:
|
||
_set("mediaStartPath", str(p.get("mediaStartPath") or "").strip())
|
||
if "mediaStartConfigPath" in p:
|
||
_set("mediaStartConfigPath", str(p.get("mediaStartConfigPath") or "").strip())
|
||
|
||
int_keys = (
|
||
"adminPort", "mediaHttpPort", "mediaRtspPort", "mediaRtmpPort",
|
||
"autoAddStreamProxySleep",
|
||
"analysisTargetFps", "analysisProcessMode", "analysisInferenceWorkers",
|
||
"recordingSegmentSeconds", "recordingRetainDays",
|
||
)
|
||
for key in int_keys:
|
||
if key in p:
|
||
_set(key, _int(p.get(key), data.get(key)))
|
||
|
||
float_keys = ("analysisConfThreshold", "recordingRetainGb")
|
||
for key in float_keys:
|
||
if key in p:
|
||
_set(key, _float(p.get(key), data.get(key)))
|
||
|
||
bool_keys = (
|
||
"autoAddStreamProxy", "isEnableLoginCaptcha", "logDebug", "isEnableUpdatePopup",
|
||
"telemetryEnabled", "updateCheckEnabled",
|
||
"isEnableMediaProxyRtmp", "autoStartMedia",
|
||
"analysisSharedInference", "recordingEnabled",
|
||
)
|
||
for key in bool_keys:
|
||
if key in p:
|
||
_set(key, _bool(p.get(key), _bool(data.get(key))))
|
||
|
||
sip = dict(data.get("sipServer") or {})
|
||
sip_map = {
|
||
"sipServerIp": "sipServerIp",
|
||
"sipServerPort": ("sipServerPort", _int),
|
||
"sipTransferMode": ("sipTransferMode", _int),
|
||
"sipServerId": "sipServerId",
|
||
"sipServerRealm": "sipServerRealm",
|
||
"sipServerTimeout": ("sipServerTimeout", _int),
|
||
"sipServerExpiry": ("sipServerExpiry", _int),
|
||
"rtpTransferMode": ("rtpTransferMode", _int),
|
||
"rtpTransferAudioType": ("rtpTransferAudioType", _int),
|
||
"autoInviteAfterRecCateLog": ("autoInviteAfterRecCateLog", _bool),
|
||
}
|
||
for param_key, spec in sip_map.items():
|
||
if param_key not in p:
|
||
continue
|
||
if isinstance(spec, tuple):
|
||
sip_key, conv = spec
|
||
sip[sip_key] = conv(p.get(param_key), sip.get(sip_key))
|
||
else:
|
||
sip[spec] = str(p.get(param_key) or "").strip()
|
||
data["sipServer"] = sip
|
||
for _k in (
|
||
"install", "code", "name", "describe", "safe", "internalApiSecret",
|
||
"mediaSecret",
|
||
):
|
||
data.pop(_k, None)
|
||
for _k in ("sipServerPass", "sipServerNonce"):
|
||
data["sipServer"].pop(_k, None)
|
||
|
||
with open(self.__filepath, "w", encoding="utf-8") as f:
|
||
json.dump(data, f, indent=4, ensure_ascii=False)
|
||
|
||
self.__config_data = data
|
||
self._apply(data)
|