2026-11-20 20:42:42 -03:00
|
|
|
import ipaddress
|
2026-02-04 09:43:17 -03:00
|
|
|
import os
|
|
|
|
|
import subprocess
|
|
|
|
|
from typing import Union
|
|
|
|
|
|
2026-11-20 20:42:42 -03:00
|
|
|
from django.utils.translation import gettext_lazy as _
|
|
|
|
|
|
|
|
|
|
from cluster.models import ClusterSettings, Worker
|
2026-02-04 09:43:17 -03:00
|
|
|
from wireguard.models import WireGuardInstance
|
|
|
|
|
|
2026-11-20 20:42:42 -03:00
|
|
|
WIREGUARD_CONFIG_DIR = '/etc/wireguard'
|
|
|
|
|
# Configurations of instances that run on workers (distributed cluster mode). Kept out of WIREGUARD_CONFIG_DIR
|
|
|
|
|
# so the primary server does not bring them up.
|
|
|
|
|
CLUSTER_WIREGUARD_CONFIG_DIR = '/etc/wireguard/cluster'
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def get_instance_config_dir(instance: WireGuardInstance) -> str:
|
|
|
|
|
return CLUSTER_WIREGUARD_CONFIG_DIR if instance.hosting_worker else WIREGUARD_CONFIG_DIR
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def get_config_servers(instance: WireGuardInstance) -> list:
|
|
|
|
|
"""Servers offered when downloading a peer configuration of the instance. Empty without the cluster."""
|
|
|
|
|
cluster_settings = ClusterSettings.objects.filter(name='cluster_settings', enabled=True).first()
|
|
|
|
|
if not cluster_settings:
|
|
|
|
|
return []
|
|
|
|
|
|
|
|
|
|
if ClusterSettings.is_distributed():
|
|
|
|
|
hosting_worker = instance.hosting_worker if instance else None
|
|
|
|
|
if hosting_worker:
|
|
|
|
|
return [{'name': hosting_worker.display_name, 'uuid': str(hosting_worker.uuid)}]
|
|
|
|
|
return [{'name': _('Primary Server'), 'uuid': ''}]
|
|
|
|
|
|
|
|
|
|
servers = []
|
|
|
|
|
if cluster_settings.primary_enable_wireguard:
|
|
|
|
|
servers.append({'name': _('Primary Server'), 'uuid': ''})
|
|
|
|
|
for worker in Worker.objects.filter(enabled=True):
|
|
|
|
|
servers.append({'name': worker.display_name, 'uuid': str(worker.uuid)})
|
|
|
|
|
return servers
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def sync_interface_routes(interface_name: str) -> list:
|
|
|
|
|
"""
|
|
|
|
|
Bring the IPv4 routes of a running interface in line with its allowed IPs, as wg-quick does on start.
|
|
|
|
|
wg syncconf only updates the peers, so networks added to or removed from a peer would otherwise only
|
|
|
|
|
get their routes on the next restart. Default routes (/0) are left to wg-quick. Returns the errors found.
|
|
|
|
|
"""
|
|
|
|
|
errors = []
|
|
|
|
|
allowed_ips_result = subprocess.run(['wg', 'show', interface_name, 'allowed-ips'], capture_output=True, text=True)
|
|
|
|
|
if allowed_ips_result.returncode != 0:
|
|
|
|
|
return [allowed_ips_result.stderr.strip()]
|
|
|
|
|
|
|
|
|
|
allowed_networks = set()
|
|
|
|
|
for line in allowed_ips_result.stdout.splitlines():
|
|
|
|
|
for value in line.split()[1:]:
|
|
|
|
|
try:
|
|
|
|
|
network = ipaddress.IPv4Network(value, strict=False)
|
|
|
|
|
except ValueError:
|
|
|
|
|
continue
|
|
|
|
|
if network.prefixlen:
|
|
|
|
|
allowed_networks.add(network)
|
|
|
|
|
allowed_networks = sorted(allowed_networks, key=lambda network: network.prefixlen)
|
|
|
|
|
|
|
|
|
|
for network in allowed_networks:
|
|
|
|
|
covering_routes = subprocess.run(
|
|
|
|
|
['ip', '-4', 'route', 'show', 'dev', interface_name, 'match', str(network)], capture_output=True, text=True,
|
|
|
|
|
).stdout.strip()
|
|
|
|
|
if covering_routes:
|
|
|
|
|
continue
|
|
|
|
|
# replace instead of add: the network may still be routed to another instance it was moved from
|
|
|
|
|
add_result = subprocess.run(
|
|
|
|
|
['ip', '-4', 'route', 'replace', str(network), 'dev', interface_name], capture_output=True, text=True
|
|
|
|
|
)
|
|
|
|
|
if add_result.returncode != 0:
|
|
|
|
|
errors.append(f"{network}: {add_result.stderr.strip()}")
|
|
|
|
|
|
|
|
|
|
routes_result = subprocess.run(
|
|
|
|
|
['ip', '-o', '-4', 'route', 'show', 'dev', interface_name], capture_output=True, text=True
|
|
|
|
|
)
|
|
|
|
|
for route in routes_result.stdout.splitlines():
|
|
|
|
|
fields = route.split()
|
|
|
|
|
if not fields or 'kernel' in fields:
|
|
|
|
|
continue
|
|
|
|
|
try:
|
|
|
|
|
route_network = ipaddress.IPv4Network(fields[0], strict=False)
|
|
|
|
|
except ValueError:
|
|
|
|
|
continue
|
|
|
|
|
# Only routes that no allowed IP covers are removed: the interface drops their traffic anyway
|
|
|
|
|
if any(route_network.subnet_of(network) for network in allowed_networks):
|
|
|
|
|
continue
|
|
|
|
|
delete_result = subprocess.run(
|
|
|
|
|
['ip', '-4', 'route', 'delete', str(route_network), 'dev', interface_name], capture_output=True, text=True,
|
|
|
|
|
)
|
|
|
|
|
if delete_result.returncode != 0:
|
|
|
|
|
errors.append(f"{route_network}: {delete_result.stderr.strip()}")
|
|
|
|
|
return errors
|
|
|
|
|
|
2026-02-04 09:43:17 -03:00
|
|
|
|
|
|
|
|
def func_reload_wireguard_interface(target: Union[str, WireGuardInstance], config_dir: str = "/etc/wireguard") -> tuple[bool, str]:
|
2026-11-20 20:42:42 -03:00
|
|
|
success, message = reload_wireguard_interface(target, config_dir)
|
|
|
|
|
if not success and isinstance(target, WireGuardInstance):
|
|
|
|
|
# Keep the apply banner so the configuration is applied again with a restart
|
|
|
|
|
target.pending_changes = True
|
|
|
|
|
WireGuardInstance.objects.filter(pk=target.pk).update(pending_changes=True)
|
|
|
|
|
return success, message
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def reload_wireguard_interface(target: Union[str, WireGuardInstance], config_dir: str) -> tuple[bool, str]:
|
2026-02-04 09:43:17 -03:00
|
|
|
"""
|
|
|
|
|
Reload a WireGuard interface safely using:
|
|
|
|
|
wg syncconf <iface> <(wg-quick strip <conf>)
|
|
|
|
|
|
|
|
|
|
Accepts:
|
|
|
|
|
- "wg0"
|
|
|
|
|
- "wg0.conf"
|
|
|
|
|
- WireGuardInstance object
|
|
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
|
(success: bool, message: str)
|
|
|
|
|
"""
|
|
|
|
|
|
|
|
|
|
# Resolve interface name and config path
|
|
|
|
|
if isinstance(target, WireGuardInstance):
|
2026-11-20 20:42:42 -03:00
|
|
|
if target.hosting_worker:
|
|
|
|
|
# The worker applies the new configuration on its next synchronization
|
|
|
|
|
return True, f"wg{target.instance_id} runs on {target.hosting_worker} and is updated by the cluster"
|
2026-02-04 09:43:17 -03:00
|
|
|
interface_name = f"wg{target.instance_id}"
|
|
|
|
|
conf_filename = f"{interface_name}.conf"
|
|
|
|
|
else:
|
|
|
|
|
name = target.replace(".conf", "")
|
|
|
|
|
interface_name = name
|
|
|
|
|
conf_filename = f"{name}.conf"
|
|
|
|
|
|
|
|
|
|
conf_path = os.path.join(config_dir, conf_filename)
|
|
|
|
|
|
|
|
|
|
if not os.path.exists(conf_path):
|
|
|
|
|
return False, f"Config file not found: {conf_path}"
|
|
|
|
|
|
|
|
|
|
try:
|
|
|
|
|
# First, run wg-quick strip to produce a clean wg-compatible config
|
|
|
|
|
strip_proc = subprocess.run(
|
|
|
|
|
["wg-quick", "strip", conf_path],
|
|
|
|
|
capture_output=True,
|
|
|
|
|
text=True,
|
|
|
|
|
check=True,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
# Write stripped config to a temp file
|
|
|
|
|
temp_path = f"/tmp/wgstrip_{interface_name}.conf"
|
|
|
|
|
with open(temp_path, "w") as f:
|
|
|
|
|
f.write(strip_proc.stdout)
|
|
|
|
|
|
|
|
|
|
# Apply syncconf
|
|
|
|
|
sync_proc = subprocess.run(
|
|
|
|
|
["wg", "syncconf", interface_name, temp_path],
|
|
|
|
|
capture_output=True,
|
|
|
|
|
text=True,
|
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
os.remove(temp_path)
|
|
|
|
|
|
|
|
|
|
if sync_proc.returncode != 0:
|
|
|
|
|
return False, sync_proc.stderr.strip()
|
|
|
|
|
|
2026-11-20 20:42:42 -03:00
|
|
|
route_errors = sync_interface_routes(interface_name)
|
|
|
|
|
if route_errors:
|
|
|
|
|
return False, f"{interface_name} reloaded with route errors: {'; '.join(route_errors)}"
|
|
|
|
|
|
2026-02-04 09:43:17 -03:00
|
|
|
return True, f"{interface_name} reloaded successfully"
|
|
|
|
|
|
|
|
|
|
except subprocess.CalledProcessError as e:
|
|
|
|
|
return False, e.stderr.strip() if e.stderr else str(e)
|
|
|
|
|
except Exception as e:
|
|
|
|
|
return False, str(e)
|