Files
MikrotikManager/backend/scripts/acceptance/chr-netflow-collector-smoke.py
T

243 lines
13 KiB
Python

"""Disposable collector-only cycle. No RouterOS clients or capture are opened."""
import argparse
import gzip
import hashlib
import io
import json
import os
import re
import runpy
import stat
import subprocess
import sys
import tarfile
import time
from pathlib import Path
owner = runpy.run_path(str(Path(__file__).with_name('chr-netflow-collector-container.py')))
require = owner['require']
MAX_PACKET = 128 * 1024 * 1024
PACKET_PATH = re.compile(r'(?:dist|drizzle|contracts-dist)/(?:[A-Za-z0-9_.-]+/)*[A-Za-z0-9_.-]+\Z')
def verify_packet(directory, digest, require_root=False):
require(re.fullmatch(r'[a-f0-9]{64}', digest), 'PACKET_DIGEST_REFUSED')
require(directory.resolve(strict=True) == directory and directory.is_dir(), 'PACKET_DIRECTORY_REFUSED')
manifest = directory / 'manifest.json'
info = manifest.lstat()
require(stat.S_ISREG(info.st_mode) and 0 < info.st_size <= 1048576, 'PACKET_MANIFEST_REFUSED')
raw = manifest.read_bytes()
require(hashlib.sha256(raw).hexdigest() == digest, 'PACKET_MANIFEST_DRIFT')
value = json.loads(raw)
require(value.get('format') == 'mmapp-netflow-collector-smoke-v1' and
value.get('cachedSourceRevision') == 'bf3d50e1ff2ee3b5c9268991a255c3b49ce6378e' and
type(value.get('files')) is list and 1 <= len(value['files']) <= 4096, 'PACKET_MANIFEST_REFUSED')
total, listed = 0, {'manifest.json'}
for row in value['files']:
relative = row.get('path', '')
require(PACKET_PATH.fullmatch(relative) and
not any(part in ('.', '..') for part in relative.split('/')) and relative not in listed and
type(row.get('size')) is int and 0 < row['size'] <= 2 * 1024 * 1024 and
re.fullmatch(r'[a-f0-9]{64}', row.get('sha256', '')), 'PACKET_FILE_REFUSED')
item = directory / relative
info = item.lstat()
total += row['size']
require(total <= MAX_PACKET and stat.S_ISREG(info.st_mode) and item.resolve(strict=True) == item and
info.st_size == row['size'] and hashlib.sha256(item.read_bytes()).hexdigest() == row['sha256'], 'PACKET_FILE_DRIFT')
listed.add(relative)
observed = set()
for folder, directories, filenames in os.walk(directory, followlinks=False):
parent = Path(folder)
for entry in [parent, *(parent / name for name in directories + filenames)]:
info = entry.lstat()
require(not stat.S_ISLNK(info.st_mode) and
(not require_root or info.st_uid == 0 and not info.st_mode & 0o022), 'PACKET_OWNERSHIP_REFUSED')
observed.update((parent / filename).relative_to(directory).as_posix() for filename in filenames)
require(observed == listed and 'dist/test/traffic-flow-chr-collector-bootstrap.js' in listed, 'PACKET_FILE_SET_DRIFT')
return {'files': len(listed) - 1, 'bytes': total, 'manifestSha256': digest}
def pack(directory, digest):
match = re.fullmatch(r'mcp-netflow-smoke-packet-([a-f0-9]{8})', directory.name)
require(match is not None, 'PACKET_DIRECTORY_REFUSED')
verified = verify_packet(directory, digest)
archive = directory.parent / ('mcp-netflow-collector-smoke-' + match[1] + '.tar.gz')
manifest = json.loads((directory / 'manifest.json').read_bytes())
script_root = Path(__file__).resolve().parent
scripts = ('chr-netflow-collector-smoke.py', 'chr-netflow-collector-container.py')
with archive.open('xb') as destination, gzip.GzipFile(fileobj=destination, mode='wb', filename='', mtime=0) as compressed:
with tarfile.open(fileobj=compressed, mode='w|', format=tarfile.USTAR_FORMAT) as tar:
def add(name, body):
item = tarfile.TarInfo(name)
item.mode = 0o644
item.size = len(body)
tar.addfile(item, io.BytesIO(body))
for name in scripts:
add(name, (script_root / name).read_bytes())
add('packet/manifest.json', (directory / 'manifest.json').read_bytes())
for row in manifest['files']:
add('packet/' + row['path'], (directory / row['path']).read_bytes())
with archive.open('rb') as stream:
archive_sha = hashlib.file_digest(stream, 'sha256').hexdigest()
return {**verified, 'archive': str(archive), 'archiveSha256': archive_sha, 'dockerUsed': False, 'networkUsed': False}
class SmokeNamespace:
"""Only the C alias and one local dummy address, never the transit topology."""
def __init__(self, run, ip, namespace, checkpoint):
self.name, self.device = 'nf' + run + 'nc', 'nf' + run + 'cv'
self.ip, self.namespace, self.checkpoint = ip, namespace, checkpoint
self.anchor = None
def create(self, read_anchor):
require(self.anchor is None and self.namespace(self.name) is None, 'SMOKE_NAMESPACE_PRESENT')
anchor = read_anchor()
require(anchor['namespace'] != anchor['hostNamespace'] and read_anchor() == anchor, 'SMOKE_ANCHOR_DRIFT')
self.checkpoint('smoke', 'attach-intent', anchor)
self.ip('netns', 'attach', self.name, str(anchor['pid']))
require(self.namespace(self.name) == anchor['namespace'] and read_anchor() == anchor, 'SMOKE_ATTACH_UNCONFIRMED')
self.checkpoint('smoke', 'attach-verified', anchor)
self.anchor = anchor
def current():
require(self.namespace(self.name) == anchor['namespace'] and read_anchor() == anchor, 'SMOKE_ANCHOR_DRIFT')
links = json.loads(self.ip('-n', self.name, '-j', 'link', 'show'))
require([item['ifname'] for item in links] == ['lo'], 'SMOKE_NAMESPACE_NOT_EMPTY')
self.checkpoint('smoke', 'dummy-intent', self.device)
current()
self.ip('-n', self.name, 'link', 'add', self.device, 'type', 'dummy')
current()
created = json.loads(self.ip('-n', self.name, '-j', '-d', 'link', 'show', 'dev', self.device))
require(len(created) == 1 and created[0]['ifname'] == self.device and
created[0]['linkinfo']['info_kind'] == 'dummy' and created[0]['ifindex'] > 0, 'SMOKE_DUMMY_UNCONFIRMED')
self.ip('-n', self.name, 'address', 'add', '198.18.242.3/32', 'dev', self.device)
current()
self.ip('-n', self.name, 'link', 'set', self.device, 'up')
rows = json.loads(self.ip('-n', self.name, '-j', '-d', 'address', 'show', 'dev', self.device))
routes = json.loads(self.ip('-n', self.name, '-j', '-4', 'route', 'show', 'table', 'all'))
require(len(rows) == 1 and rows[0]['ifname'] == self.device and rows[0]['linkinfo']['info_kind'] == 'dummy' and
rows[0]['ifindex'] == created[0]['ifindex'] and
'UP' in rows[0]['flags'] and any(row.get('local') == '198.18.242.3' and row.get('prefixlen') == 32
for row in rows[0]['addr_info']) and all(row.get('dst') != 'default' for row in routes) and
self.namespace(self.name) == anchor['namespace'] and read_anchor() == anchor, 'SMOKE_DUMMY_UNCONFIRMED')
self.checkpoint('smoke', 'dummy-verified', rows[0]['ifindex'])
return anchor
def restore(self, assert_anchor_exited):
require(self.anchor is not None and self.namespace(self.name) == self.anchor['namespace'],
'SMOKE_NAMESPACE_DRIFT')
assert_anchor_exited(self.anchor)
require(not self.ip('netns', 'pids', self.name).strip(), 'SMOKE_NAMESPACE_BUSY')
self.checkpoint('smoke', 'delete-intent', self.anchor)
self.ip('netns', 'delete', self.name)
require(self.namespace(self.name) is None, 'SMOKE_NAMESPACE_RETIREMENT_UNCONFIRMED')
self.checkpoint('smoke', 'delete-verified', self.anchor)
def linux_ip():
binary = next((item.resolve(strict=True) for item in (Path('/usr/sbin/ip'), Path('/usr/bin/ip'), Path('/sbin/ip'))
if item.is_file()), None)
require(binary is not None and binary.stat().st_uid == 0 and not binary.stat().st_mode & 0o022, 'IP_BINARY_UNPINNED')
def call(*args):
result = subprocess.run([str(binary), *args], env=owner['ENV'], stdin=subprocess.DEVNULL,
stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, timeout=8)
require(result.returncode == 0 and len(result.stdout) <= 128 * 1024, 'IP_OUTCOME_UNCONFIRMED')
return result.stdout.decode('utf-8', 'strict')
return call
def ns_pin(name):
try:
row = Path('/run/netns', name).lstat()
except FileNotFoundError:
return None
require(stat.S_ISREG(row.st_mode) and row.st_uid == 0, 'SMOKE_NAMESPACE_HANDLE_UNSAFE')
return [row.st_dev, row.st_ino]
def run_smoke(run, uid, gid, port, digest):
docker, attach = owner['local_docker']()
base = Path(owner['root'](run))
packet = base / 'packet'
verify_packet(packet, digest, require_root=True)
ip = linux_ip()
require(ns_pin('nf' + run + 'nc') is None, 'SMOKE_NAMESPACE_PRESENT')
journal = os.open(base / 'collector-smoke.jsonl', os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)
with os.fdopen(journal, 'w', encoding='utf-8') as report:
def checkpoint(role, phase, value):
report.write(json.dumps({'role': role, 'phase': phase, 'value': value}, separators=(',', ':')) + '\n')
report.flush()
os.fsync(report.fileno())
checkpoint('smoke', 'packet-verified', digest)
owner['prepare_private_storage'](run, uid, gid)
runner = owner['CollectorContainerOwner'](run, docker, checkpoint)
runner.create_anchor(uid, gid)
runner.start_anchor()
scope = SmokeNamespace(run, ip, ns_pin, checkpoint)
# Reuse the container owner's live-C admission and retirement checks.
class Journal:
value = {}
class Backend:
def namespace(self, name):
return ns_pin(name)
def root_baseline(self):
raw = [ip('-j', '-4', 'route', 'show', 'table', 'all'), ip('-j', '-d', 'link', 'show')]
# Link counters/traffic are outside root configuration; use exact names and ifindex.
links = sorted((row['ifname'], row['ifindex']) for row in json.loads(raw[1]))
return hashlib.sha256(json.dumps([json.loads(raw[0]), links], sort_keys=True).encode()).hexdigest()
def provision(backend, ledger, _plan, _pins, read_collector_anchor):
baseline = backend.root_baseline()
anchor = scope.create(read_collector_anchor)
require(backend.root_baseline() == baseline, 'ROOT_NETWORK_DRIFT')
ledger.value.update(collectorAnchor=anchor, rootBaseline=baseline, state='created')
return anchor
def cleanup(_backend, ledger, _plan, assert_collector_anchor_exited):
scope.restore(assert_collector_anchor_exited)
ledger.value['state'] = 'retired'
backend, ledger, plan = Backend(), Journal(), {'names': {'C': scope.name}}
pin = runner.create_linux_topology(provision, backend, ledger, plan, {'nonce': run + '0' * 24})
wait_until = time.monotonic() + 20
socket = base / 'pg-socket' / '.s.PGSQL.5432'
while not socket.exists() and time.monotonic() < wait_until:
time.sleep(.1)
require(stat.S_ISSOCK(socket.lstat().st_mode), 'PRIVATE_PG_NOT_READY')
runner.create_collector(uid, gid, port, pin['namespace'], pin['hostNamespace'], digest,
lambda: verify_packet(packet, digest, require_root=True))
runner.start_collector(attach)
runner.retire_exited('collector')
runner.stop_anchor(lambda: require(ledger.value['state'] == 'created', 'SMOKE_TOPOLOGY_DRIFT'))
runner.cleanup_linux_topology(cleanup, backend, ledger, plan)
runner.retire_exited('postgres')
checkpoint('smoke', 'complete', None)
return {'collectorSmokeCompleted': True, 'chrMutations': 0, 'capturePerformed': False, 'nativeAcceptance': False}
if __name__ == '__main__':
parser = argparse.ArgumentParser()
sub = parser.add_subparsers(dest='mode', required=True)
check = sub.add_parser('check')
check.add_argument('packet', type=Path)
check.add_argument('sha256')
package = sub.add_parser('pack')
package.add_argument('packet', type=Path)
package.add_argument('sha256')
run = sub.add_parser('run')
run.add_argument('run_id')
run.add_argument('uid', type=int)
run.add_argument('gid', type=int)
run.add_argument('port', type=int)
run.add_argument('sha256')
args = parser.parse_args()
try:
if args.mode == 'check':
result = {**verify_packet(args.packet.resolve(), args.sha256), 'dockerUsed': False, 'networkUsed': False}
elif args.mode == 'pack':
result = pack(args.packet.resolve(), args.sha256)
else:
result = run_smoke(args.run_id, args.uid, args.gid, args.port, args.sha256)
print(json.dumps(result))
except (OSError, ValueError, RuntimeError, subprocess.SubprocessError, KeyError) as error:
print(json.dumps({'completed': False, 'failureClass': type(error).__name__, 'automaticReplay': False}))
raise SystemExit(1) from None