fix: account for HTTP/S traffic and separate network curves

This commit is contained in:
2026-11-02 14:13:26 +08:00
parent 5291b2ab72
commit 4c3b7ead4e
10 changed files with 336 additions and 13 deletions
+197
View File
@@ -0,0 +1,197 @@
#!/usr/bin/python3
"""Maintain passive HTTP/S and rsync counters without resetting accumulated bytes.
HTTP/S endpoints come from Nginx's HTTP configuration and tunasync HTTP(S)
upstreams. This is endpoint accounting, not packet inspection of arbitrary
encrypted protocols. Local proxy hops are excluded; both receive and transmit
traffic on the mirror host are counted, regardless of standard/custom ports.
"""
import argparse
import fnmatch
import hashlib
import json
import os
from pathlib import Path
import posixpath
import re
import subprocess
import tempfile
import tomllib
from urllib.parse import urlsplit
TABLE = 'mirrorouc_monitor'
VERSION = 1
COUNTERS = ('http4', 'http6', 'rsync4', 'rsync6')
TOKEN = re.compile(r'''"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\#[^\n]*|[{};]|[^\s{};\#]+''')
def directives(source, initial=()):
context, pending = list(initial), []
for match in TOKEN.finditer(source):
token = match[0]
if token.startswith('#'):
continue
if token == '{':
context.append(pending[0] if pending else '')
pending = []
elif token == '}':
if len(context) <= len(initial):
raise ValueError('Unbalanced Nginx configuration')
context.pop()
pending = []
elif token == ';':
if pending:
yield tuple(context), pending
pending = []
else:
pending.append(token.strip('\'"'))
def nginx_http_ports(dump):
parts = re.split(r'^# configuration file (.+):\s*$', dump, flags=re.M)
documents = dict(zip(parts[1::2], parts[2::2]))
if not documents:
documents = {'/etc/nginx/nginx.conf': dump}
entry = next(iter(documents))
prefix = posixpath.dirname(entry)
todo, seen, ports = [(entry, ())], set(), set()
while todo:
file, initial = todo.pop()
if (file, initial) in seen:
continue
seen.add((file, initial))
for context, args in directives(documents[file], initial):
if args[0] == 'include' and len(args) == 2:
pattern = posixpath.normpath(posixpath.join(prefix, args[1]))
todo.extend((name, context) for name in documents if fnmatch.fnmatchcase(name, pattern))
elif args[0] == 'listen' and context == ('http', 'server') and len(args) > 1:
address = args[1]
if address.startswith('unix:') or 'quic' in args[2:]:
continue
value = address.rsplit(':', 1)[-1]
port = int(value) if value.isdecimal() else 80
if not 1 <= port <= 65535:
raise ValueError('Invalid Nginx HTTP listener port')
ports.add(port)
return ports
def http_upstream_ports(worker_config):
# Include ordinary HTTP(S) clients as well as explicitly configured custom
# upstream ports. rsync/SSH/FTP URLs must not contribute ports to this set.
ports, seen, todo = {80, 443}, set(), [Path(worker_config)]
while todo:
path = todo.pop()
if path in seen or not path.exists():
continue
seen.add(path)
doc = tomllib.loads(path.read_text())
pattern = doc.get('include', {}).get('include_mirrors')
if pattern:
from glob import glob
todo.extend(Path(name) for name in glob(pattern))
for mirror in doc.get('mirrors', []):
upstream = urlsplit(mirror.get('upstream', ''))
if upstream.scheme in ('http', 'https'):
ports.add(upstream.port or (443 if upstream.scheme == 'https' else 80))
return ports
def shape(document):
def clean(value):
if isinstance(value, dict):
return {key: clean(item) for key, item in value.items() if key not in ('handle', 'packets', 'bytes')}
if isinstance(value, list):
return [clean(item) for item in value]
return value
objects = [clean(item) for item in document.get('nftables', []) if 'metainfo' not in item]
return hashlib.sha256(json.dumps(objects, sort_keys=True).encode()).hexdigest()
def transaction(current, listeners, upstreams, table=TABLE):
if not re.fullmatch(r'[a-zA-Z0-9_]+', table):
raise ValueError('Invalid counter table')
objects = current.get('nftables', [])
existing = lambda kind: {item[kind]['name'] for item in objects if kind in item}
lines = [] if existing('table') else [f'add table inet {table}']
for name in COUNTERS:
if name not in existing('counter'):
lines.append(f'add counter inet {table} {name}')
for name, ports in (('http_listeners', listeners), ('http_upstreams', upstreams)):
if name not in existing('set'):
lines.append(f'add set inet {table} {name} {{ type inet_service; }}')
lines.append(f'flush set inet {table} {name}')
if ports:
if any(not isinstance(port, int) or not 1 <= port <= 65535 for port in ports):
raise ValueError('Invalid HTTP endpoint port')
lines.append(f'add element inet {table} {name} {{ ' + ', '.join(map(str, sorted(ports))) + ' }')
for direction, interface, local, remote in (('input', 'iifname', 'dport', 'sport'), ('output', 'oifname', 'sport', 'dport')):
if direction not in existing('chain'):
lines.append(f'add chain inet {table} {direction} {{ type filter hook {direction} priority 300; policy accept; }}')
lines.append(f'flush chain inet {table} {direction}')
lines.append(f'add rule inet {table} {direction} {interface} "lo" return')
for version in (4, 6):
for field, endpoint in ((local, 'http_listeners'), (remote, 'http_upstreams')):
# Return after accounting so a packet is counted exactly once.
lines.append(f'add rule inet {table} {direction} meta nfproto ipv{version} tcp {field} @{endpoint} counter name http{version} return')
for field in ('sport', 'dport'):
lines.append(f'add rule inet {table} {direction} meta nfproto ipv{version} tcp {field} 873 counter name rsync{version} return')
# Migrate the former HTTPS-only rules, preserving both rsync counters.
if 'account' in existing('chain'):
lines.extend((f'flush chain inet {table} account', f'delete chain inet {table} account'))
for name in ('https4', 'https6'):
if name in existing('counter'):
lines.append(f'delete counter inet {table} {name}')
return '\n'.join(lines) + '\n'
def read_table(nft):
result = subprocess.run([nft, '-j', '-a', 'list', 'table', 'inet', TABLE], capture_output=True, text=True, timeout=5)
if result.returncode:
if 'No such file or directory' in result.stderr or 'does not exist' in result.stderr:
return {}
raise RuntimeError('Unable to read protocol counters: ' + result.stderr.strip())
return json.loads(result.stdout)
def ensure(args):
import fcntl
args.state.parent.mkdir(parents=True, exist_ok=True)
with (args.state.parent / '.protocol-counters.lock').open('a') as lock:
fcntl.flock(lock, fcntl.LOCK_EX)
dump = subprocess.run([args.nginx, '-T'], capture_output=True, text=True, timeout=10, check=True).stdout
listeners = nginx_http_ports(dump)
if not listeners:
raise RuntimeError('No Nginx TCP HTTP listeners discovered; keeping existing accounting unchanged')
upstreams = http_upstream_ports(args.worker_config)
current = read_table(args.nft)
settings = {'version': VERSION, 'listeners': sorted(listeners), 'upstreams': sorted(upstreams)}
try:
previous = json.loads(args.state.read_text())
except (OSError, ValueError):
previous = {}
if all(previous.get(key) == value for key, value in settings.items()) and previous.get('shape') == shape(current):
return
commands = transaction(current, listeners, upstreams)
for flags in (['-c'], []):
subprocess.run([args.nft, *flags, '-f', '-'], input=commands, capture_output=True, text=True, timeout=5, check=True)
settings['shape'] = shape(read_table(args.nft))
fd, name = tempfile.mkstemp(dir=args.state.parent, prefix='.protocol-')
try:
with os.fdopen(fd, 'w') as stream:
json.dump(settings, stream, sort_keys=True)
os.chmod(name, 0o640)
os.replace(name, args.state)
finally:
if os.path.exists(name):
os.unlink(name)
print(json.dumps(settings), flush=True)
if __name__ == '__main__':
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument('--nginx', default='/usr/sbin/nginx')
parser.add_argument('--nft', default='/usr/sbin/nft')
parser.add_argument('--worker-config', default='/etc/tunasync/worker.conf')
parser.add_argument('--state', type=Path, default=Path('/var/lib/mirrorouc/metrics/protocol-counters.json'))
ensure(parser.parse_args())