284 lines
11 KiB
Python
284 lines
11 KiB
Python
"""Тонкий враппер вокруг librouteros для синхронных вызовов из API/воркеров."""
|
|
from __future__ import annotations
|
|
|
|
import socket
|
|
import ssl
|
|
from contextlib import contextmanager
|
|
from dataclasses import dataclass
|
|
from typing import Any, Iterator
|
|
|
|
from librouteros import connect
|
|
from librouteros.exceptions import LibRouterosError
|
|
from librouteros.login import plain
|
|
from loguru import logger
|
|
|
|
|
|
class RouterOSError(RuntimeError):
|
|
pass
|
|
|
|
|
|
@dataclass
|
|
class RouterOSCredentials:
|
|
host: str
|
|
username: str
|
|
password: str
|
|
# По умолчанию api-ssl: порт 8729 + TLS. plain api (8728) можно использовать
|
|
# для legacy-устройств, явно передав port=8728, use_tls=False.
|
|
port: int = 8729
|
|
use_tls: bool = True
|
|
timeout: float = 5.0
|
|
|
|
|
|
@contextmanager
|
|
def routeros_session(creds: RouterOSCredentials) -> Iterator[Any]:
|
|
kwargs: dict[str, Any] = {
|
|
"port": creds.port,
|
|
"timeout": creds.timeout,
|
|
"login_method": plain,
|
|
}
|
|
if creds.use_tls:
|
|
ctx = ssl.create_default_context()
|
|
ctx.check_hostname = False
|
|
ctx.verify_mode = ssl.CERT_NONE
|
|
kwargs["ssl_wrapper"] = ctx.wrap_socket
|
|
|
|
try:
|
|
api = connect(
|
|
host=creds.host,
|
|
username=creds.username,
|
|
password=creds.password,
|
|
**kwargs,
|
|
)
|
|
logger.info("RouterOS connected: {}:{} user={}", creds.host, creds.port, creds.username)
|
|
except (LibRouterosError, OSError, socket.timeout) as exc:
|
|
logger.warning(
|
|
"RouterOS connection failed: {}:{} user={} reason={}",
|
|
creds.host, creds.port, creds.username, exc,
|
|
)
|
|
raise RouterOSError(f"connect {creds.host}:{creds.port} failed: {exc}") from exc
|
|
|
|
try:
|
|
yield api
|
|
finally:
|
|
try:
|
|
api.close()
|
|
except Exception: # pragma: no cover
|
|
pass
|
|
|
|
|
|
def fetch_resource(creds: RouterOSCredentials) -> dict[str, Any]:
|
|
"""Возвращает первую запись `/system/resource`."""
|
|
with routeros_session(creds) as api:
|
|
rows = list(api.path("system", "resource"))
|
|
return rows[0] if rows else {}
|
|
|
|
|
|
def fetch_identity(creds: RouterOSCredentials) -> str | None:
|
|
with routeros_session(creds) as api:
|
|
rows = list(api.path("system", "identity"))
|
|
if not rows:
|
|
return None
|
|
return rows[0].get("name")
|
|
|
|
|
|
def fetch_interfaces(creds: RouterOSCredentials) -> list[dict[str, Any]]:
|
|
with routeros_session(creds) as api:
|
|
return list(api.path("interface"))
|
|
|
|
|
|
def cmd_reboot(creds: RouterOSCredentials) -> None:
|
|
"""Перезагрузить устройство (/system/reboot)."""
|
|
logger.info("Sending reboot to {}:{}", creds.host, creds.port)
|
|
with routeros_session(creds) as api:
|
|
tuple(api.path("system", "reboot"))
|
|
|
|
|
|
def cmd_safe_mode(creds: RouterOSCredentials) -> None:
|
|
"""Войти в safe mode (/system/safe-mode) — отправляет команду, устройство
|
|
подтвердит переход (RouterOS 7+). Если устройство уже в safe mode,
|
|
команда завершает его."""
|
|
logger.info("Toggling safe-mode on {}:{}", creds.host, creds.port)
|
|
with routeros_session(creds) as api:
|
|
tuple(api.path("system", "safe-mode"))
|
|
|
|
|
|
def check_internet(creds: RouterOSCredentials, target: str = "8.8.8.8") -> bool:
|
|
"""Проверка интернет-доступа на устройстве через `/ping count=1`."""
|
|
try:
|
|
with routeros_session(creds) as api:
|
|
rows = list(api(cmd="/ping", address=target, count="2"))
|
|
for row in rows:
|
|
recv = int(row.get("received") or 0)
|
|
if recv > 0:
|
|
return True
|
|
return False
|
|
except (RouterOSError, Exception) as exc:
|
|
logger.warning("internet check failed for {}: {}", creds.host, exc)
|
|
return False
|
|
|
|
|
|
def parse_uptime(uptime: str | None) -> int | None:
|
|
"""Парсит RouterOS uptime '1w2d3h4m5s' → секунды."""
|
|
if not uptime:
|
|
return None
|
|
import re
|
|
units = {"w": 604800, "d": 86400, "h": 3600, "m": 60, "s": 1}
|
|
total = 0
|
|
for value, unit in re.findall(r"(\d+)([wdhms])", uptime):
|
|
total += int(value) * units[unit]
|
|
return total or None
|
|
|
|
|
|
def execute_cli(creds: RouterOSCredentials, command: str) -> list[dict[str, Any]]:
|
|
"""Выполнить произвольную команду RouterOS API.
|
|
|
|
Команда должна быть в формате RouterOS API path-style, например:
|
|
`/system/identity/print`
|
|
`/interface/print`
|
|
`/ip/address/print where interface=ether1`
|
|
|
|
Дополнительные параметры через `name=value` после команды.
|
|
Возвращает список словарей-результатов.
|
|
"""
|
|
parts = command.strip().split()
|
|
if not parts:
|
|
raise RouterOSError("empty command")
|
|
cmd = parts[0]
|
|
if not cmd.startswith("/"):
|
|
raise RouterOSError("command must start with '/'")
|
|
kwargs: dict[str, str] = {}
|
|
where: dict[str, str] = {}
|
|
in_where = False
|
|
for token in parts[1:]:
|
|
if token == "where":
|
|
in_where = True
|
|
continue
|
|
if "=" in token:
|
|
k, v = token.split("=", 1)
|
|
(where if in_where else kwargs)[k] = v
|
|
logger.info("CLI exec on {}: {} args={} where={}", creds.host, cmd, kwargs, where)
|
|
try:
|
|
with routeros_session(creds) as api:
|
|
res = api(cmd=cmd, **kwargs)
|
|
rows = list(res)
|
|
if where:
|
|
rows = [r for r in rows if all(str(r.get(k)) == v for k, v in where.items())]
|
|
return rows
|
|
except (LibRouterosError, OSError) as exc:
|
|
raise RouterOSError(f"cli failed: {exc}") from exc
|
|
|
|
|
|
# ---------- Sprint 09 helpers ----------
|
|
|
|
def fetch_interface_stats(creds: RouterOSCredentials) -> list[dict[str, Any]]:
|
|
"""Список интерфейсов со счётчиками rx/tx и флагом running.
|
|
|
|
Возвращает: [{"name", "rx_bytes", "tx_bytes", "running", "type", "comment"}].
|
|
"""
|
|
out: list[dict[str, Any]] = []
|
|
try:
|
|
with routeros_session(creds) as api:
|
|
for r in api.path("interface"):
|
|
def _i(v: Any) -> int:
|
|
try:
|
|
return int(v)
|
|
except (TypeError, ValueError):
|
|
return 0
|
|
running = str(r.get("running", "")).lower() == "true"
|
|
disabled = str(r.get("disabled", "")).lower() == "true"
|
|
out.append({
|
|
"name": r.get("name"),
|
|
"rx_bytes": _i(r.get("rx-byte")),
|
|
"tx_bytes": _i(r.get("tx-byte")),
|
|
"running": running,
|
|
"disabled": disabled,
|
|
"type": r.get("type"),
|
|
"comment": r.get("comment") or None,
|
|
"mac_address": r.get("mac-address") or None,
|
|
})
|
|
except (LibRouterosError, OSError) as exc:
|
|
raise RouterOSError(f"interface stats failed: {exc}") from exc
|
|
return out
|
|
|
|
|
|
def fetch_dhcp_leases(creds: RouterOSCredentials) -> list[dict[str, Any]]:
|
|
"""Все лизы DHCP-сервера на устройстве."""
|
|
out: list[dict[str, Any]] = []
|
|
try:
|
|
with routeros_session(creds) as api:
|
|
for r in api.path("ip", "dhcp-server", "lease"):
|
|
out.append({
|
|
"address": r.get("address"),
|
|
"mac_address": r.get("mac-address"),
|
|
"host_name": r.get("host-name") or r.get("comment"),
|
|
"comment": r.get("comment") or None,
|
|
"server": r.get("server"),
|
|
"status": r.get("status"),
|
|
"dynamic": str(r.get("dynamic", "")).lower() == "true",
|
|
"blocked": str(r.get("blocked", "")).lower() == "true",
|
|
"last_seen": r.get("last-seen"),
|
|
"expires_after": r.get("expires-after"),
|
|
})
|
|
except (LibRouterosError, OSError) as exc:
|
|
raise RouterOSError(f"dhcp leases failed: {exc}") from exc
|
|
return out
|
|
|
|
|
|
def cmd_upgrade_check(creds: RouterOSCredentials, channel: str = "stable") -> dict[str, Any]:
|
|
"""Запросить у MikroTik проверку доступного обновления и инициировать
|
|
/system/package/update/check-for-updates. Возвращает текущее состояние."""
|
|
try:
|
|
with routeros_session(creds) as api:
|
|
try:
|
|
tuple(api.path("system", "package", "update").call("set",
|
|
**{"channel": channel}))
|
|
except Exception:
|
|
pass
|
|
try:
|
|
tuple(api(cmd="/system/package/update/check-for-updates"))
|
|
except Exception:
|
|
pass
|
|
rows = list(api.path("system", "package", "update"))
|
|
return rows[0] if rows else {}
|
|
except (LibRouterosError, OSError) as exc:
|
|
raise RouterOSError(f"upgrade check failed: {exc}") from exc
|
|
|
|
|
|
def cmd_upgrade_install(creds: RouterOSCredentials) -> None:
|
|
"""Запустить установку обновления (устройство ребутнётся)."""
|
|
try:
|
|
with routeros_session(creds) as api:
|
|
tuple(api(cmd="/system/package/update/install"))
|
|
except (LibRouterosError, OSError) as exc:
|
|
raise RouterOSError(f"upgrade install failed: {exc}") from exc
|
|
|
|
|
|
def push_firmware_via_ftp(
|
|
creds: RouterOSCredentials,
|
|
server: str,
|
|
port: int,
|
|
user: str,
|
|
password: str,
|
|
src_path: str,
|
|
dst_filename: str,
|
|
) -> None:
|
|
"""Загрузить файл с FTP-сервера контроллера на устройство (`/tool/fetch download`).
|
|
Используется для установки прошивки из локального репозитория без выгрузки на устройство.
|
|
"""
|
|
url = f"ftp://{server}:{port}/{src_path}"
|
|
try:
|
|
with routeros_session(creds) as api:
|
|
tuple(api(
|
|
cmd="/tool/fetch",
|
|
url=url, user=user, password=password,
|
|
mode="ftp", **{"dst-path": dst_filename},
|
|
))
|
|
except (LibRouterosError, OSError) as exc:
|
|
raise RouterOSError(f"fetch firmware failed: {exc}") from exc
|
|
|
|
|
|
def cmd_reboot_for_upgrade(creds: RouterOSCredentials) -> None:
|
|
"""`/system/reboot` — после загрузки .npk RouterOS установит апдейт при загрузке."""
|
|
cmd_reboot(creds)
|
|
|