Dilshod Rasulov
d66928ee78
Collapse four duplicated host+auth client-building blocks into a single ProxmoxClient.from_server() classmethod (the canonical source of truth): - _helpers._get_proxmox_client now delegates to from_server (107 callers untouched) - ipam._build_proxmox_client removed; its one call site uses from_server - task_queue_service keeps its per-server cache pool, builds via from_server - monitoring_worker keeps its ValueError-on-missing-auth contract, builds via from_server Behaviour preserved (token-first, then password; non-default port appended). Verified: containers rebuild healthy, smoke test of both auth paths passes. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
2527 lines
107 KiB
Python
2527 lines
107 KiB
Python
import time
|
||
import urllib3
|
||
import asyncio
|
||
from concurrent.futures import ThreadPoolExecutor
|
||
from typing import List, Dict, Optional, Union, Any
|
||
from proxmoxer import ProxmoxAPI, AuthenticationError
|
||
from loguru import logger
|
||
import threading
|
||
from functools import lru_cache
|
||
from contextlib import asynccontextmanager
|
||
import base64
|
||
|
||
from .mixins.vm import VmMixin
|
||
from .mixins.lxc import LxcMixin
|
||
from .mixins.cluster import ClusterMixin
|
||
from .mixins.storage import StorageMixin
|
||
from .mixins.network import NetworkMixin
|
||
from .mixins.snapshot import SnapshotMixin
|
||
|
||
proxmox_executor = ThreadPoolExecutor(max_workers=20, thread_name_prefix="proxmox_")
|
||
|
||
connection_cache = {}
|
||
connection_cache_lock = threading.Lock()
|
||
MAX_CACHE_SIZE = 50
|
||
|
||
async def _run_in_executor(func, *args, **kwargs):
|
||
"""Run a blocking function in the proxmox thread pool executor."""
|
||
loop = asyncio.get_event_loop()
|
||
return await loop.run_in_executor(proxmox_executor, lambda: func(*args, **kwargs))
|
||
|
||
def get_proxmox_resources(host: str, user: str = "root@pam",
|
||
password: str = None, token_name: str = None,
|
||
token_value: str = None, verify_ssl: bool = False,
|
||
node: str = None, timeout: int = 10) -> Dict[str, List[Dict]]:
|
||
"""
|
||
Вспомогательная функция для получения всех ресурсов Proxmox
|
||
|
||
Args:
|
||
node: Имя ноды для фильтрации (если None, получить со всех нод)
|
||
timeout: Connection timeout in seconds
|
||
|
||
Returns:
|
||
Dict с ключами 'vms' и 'containers'
|
||
"""
|
||
client = ProxmoxClient(host, user, password, token_name, token_value, verify_ssl, timeout=timeout)
|
||
return client.get_all_resources(node)
|
||
|
||
def cleanup_expired_connections():
|
||
"""Cleanup expired connections from cache"""
|
||
current_time = time.time()
|
||
expired_keys = []
|
||
|
||
for key, data in connection_cache.items():
|
||
if current_time - data['created'] > 3600: # 1 hour
|
||
expired_keys.append(key)
|
||
|
||
for key in expired_keys:
|
||
del connection_cache[key]
|
||
logger.debug(f"Removed expired Proxmox connection: {key}")
|
||
|
||
def clear_server_cache(host: str):
|
||
"""Clear all cached connections for a specific server"""
|
||
keys_to_remove = [key for key in connection_cache.keys() if key.startswith(f"{host}:")]
|
||
for key in keys_to_remove:
|
||
del connection_cache[key]
|
||
logger.info(f"Cleared cache for server: {key}")
|
||
|
||
def clear_all_cache():
|
||
"""Clear entire connection cache"""
|
||
connection_cache.clear()
|
||
logger.info("Cleared all Proxmox connection cache")
|
||
|
||
@lru_cache(maxsize=32)
|
||
def get_cached_client(host: str, user: str, password_hash: str = None,
|
||
token_name: str = None, token_value_hash: str = None) -> 'ProxmoxClient':
|
||
"""Get cached Proxmox client instance"""
|
||
return ProxmoxClient(
|
||
host=host,
|
||
user=user,
|
||
password=password_hash,
|
||
token_name=token_name,
|
||
token_value=token_value_hash
|
||
)
|
||
|
||
class ProxmoxClient(VmMixin, LxcMixin, ClusterMixin, StorageMixin, NetworkMixin, SnapshotMixin):
|
||
@classmethod
|
||
def from_server(cls, server) -> "ProxmoxClient":
|
||
"""Single source of truth for building a client from a ProxmoxServer model.
|
||
|
||
Picks token auth when available, otherwise password auth, and appends a
|
||
non-default port to the host. Callers across the API and services layers
|
||
(see api/proxmox/_helpers.py and services/task_queue_service.py) should
|
||
go through here instead of duplicating the host/auth branching.
|
||
"""
|
||
host = server.ip_address or getattr(server, "hostname", "") or ""
|
||
if getattr(server, "port", None) and server.port != 8006:
|
||
host = f"{host}:{server.port}"
|
||
|
||
if getattr(server, "use_password", False) and getattr(server, "password", ""):
|
||
return cls(
|
||
host=host,
|
||
user=server.api_user,
|
||
password=server.password,
|
||
verify_ssl=server.verify_ssl,
|
||
)
|
||
return cls(
|
||
host=host,
|
||
user=server.api_user,
|
||
token_name=server.api_token_name,
|
||
token_value=server.api_token_value,
|
||
verify_ssl=server.verify_ssl,
|
||
)
|
||
|
||
def __init__(self, host: str, user: str = "root@pam", password: str = None,
|
||
token_name: str = None, token_value: str = None, verify_ssl: bool = True,
|
||
timeout: int = 30):
|
||
"""
|
||
Инициализация Proxmox клиента
|
||
|
||
Args:
|
||
host: IP адрес или hostname Proxmox сервера
|
||
user: Пользователь (например root@pam)
|
||
password: Пароль (для password auth)
|
||
token_name: Имя API токена (для token auth)
|
||
token_value: Значение API токена (для token auth)
|
||
verify_ssl: Проверять SSL сертификат
|
||
timeout: Таймаут подключения в секундах
|
||
"""
|
||
self.host = host
|
||
self.user = user
|
||
self.timeout = timeout
|
||
# Stored for SSH fallbacks (e.g. pvecm delnode) that need root password auth
|
||
self._password = password
|
||
# Улучшенный ключ кеша - включаем token_name для уникальности
|
||
self.connection_key = f"{host}:{user}:{token_name or 'password'}"
|
||
self.proxmox = None
|
||
self.last_used = time.time()
|
||
|
||
# Check cache first
|
||
with connection_cache_lock:
|
||
if self.connection_key in connection_cache:
|
||
cached_client = connection_cache[self.connection_key]
|
||
if time.time() - cached_client['created'] < 3600: # 1 hour cache
|
||
self.proxmox = cached_client['client']
|
||
logger.debug(f"Using cached Proxmox connection for {host}")
|
||
# Обновляем время последнего использования
|
||
cached_client['created'] = time.time()
|
||
return
|
||
else:
|
||
# Remove expired connection
|
||
del connection_cache[self.connection_key]
|
||
logger.debug(f"Removed expired cache for {self.connection_key}")
|
||
|
||
try:
|
||
if token_name and token_value:
|
||
# Аутентификация через API токен (рекомендуется)
|
||
self.proxmox = ProxmoxAPI(
|
||
host,
|
||
user=user,
|
||
token_name=token_name,
|
||
token_value=token_value,
|
||
verify_ssl=verify_ssl,
|
||
timeout=timeout
|
||
)
|
||
logger.info(f"Connected to Proxmox {host} using API token")
|
||
elif password:
|
||
# Аутентификация через пароль
|
||
self.proxmox = ProxmoxAPI(
|
||
host,
|
||
user=user,
|
||
password=password,
|
||
verify_ssl=verify_ssl,
|
||
timeout=timeout
|
||
)
|
||
logger.info("Connected to Proxmox using password")
|
||
else:
|
||
logger.error("Необходимо указать либо password, либо token")
|
||
return
|
||
|
||
# Test connection
|
||
if self.proxmox:
|
||
try:
|
||
self.proxmox.version.get()
|
||
# Cache successful connection
|
||
with connection_cache_lock:
|
||
if len(connection_cache) >= MAX_CACHE_SIZE:
|
||
oldest_key = min(connection_cache.keys(), key=lambda k: connection_cache[k]['created'])
|
||
del connection_cache[oldest_key]
|
||
connection_cache[self.connection_key] = {
|
||
'client': self.proxmox,
|
||
'created': time.time()
|
||
}
|
||
logger.debug(f"Cached connection for {self.connection_key}")
|
||
except Exception as e:
|
||
logger.error(f"Failed to test Proxmox connection for {host}: {e}")
|
||
self.proxmox = None
|
||
# Удаляем неудачное подключение из кеша
|
||
with connection_cache_lock:
|
||
if self.connection_key in connection_cache:
|
||
del connection_cache[self.connection_key]
|
||
|
||
except AuthenticationError as e:
|
||
logger.error(f"Ошибка аутентификации Proxmox {host}: {e}")
|
||
self.proxmox = None
|
||
# Удаляем из кеша при ошибке аутентификации
|
||
with connection_cache_lock:
|
||
if self.connection_key in connection_cache:
|
||
del connection_cache[self.connection_key]
|
||
except Exception as e:
|
||
logger.error(f"Ошибка подключения к Proxmox {host}: {e}")
|
||
self.proxmox = None
|
||
# Удаляем из кеша при ошибке подключения
|
||
if self.connection_key in connection_cache:
|
||
del connection_cache[self.connection_key]
|
||
|
||
def is_connected(self) -> bool:
|
||
"""Check if client is properly connected"""
|
||
if not self.proxmox:
|
||
return False
|
||
try:
|
||
self.proxmox.version.get()
|
||
self.last_used = time.time()
|
||
return True
|
||
except Exception:
|
||
return False
|
||
|
||
@asynccontextmanager
|
||
async def ensure_connection(self):
|
||
"""Ensure connection is active before use"""
|
||
if not self.is_connected():
|
||
logger.warning(f"Lost connection to Proxmox {self.host}, attempting reconnect")
|
||
# Remove from cache and try to reconnect
|
||
if self.connection_key in connection_cache:
|
||
del connection_cache[self.connection_key]
|
||
yield self.proxmox
|
||
|
||
def get_nodes(self) -> List[Dict]:
|
||
"""Получить список нод кластера"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
try:
|
||
nodes = self.proxmox.nodes.get()
|
||
return nodes
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения списка нод {self.host}: {e}")
|
||
return []
|
||
|
||
def get_vms(self, node: str = None) -> List[Dict]:
|
||
"""
|
||
Получить список виртуальных машин (QEMU)
|
||
|
||
Args:
|
||
node: Имя ноды (если None, получить со всех нод)
|
||
|
||
Returns:
|
||
Список VM с информацией
|
||
"""
|
||
if not self.proxmox:
|
||
logger.warning(f"Cannot get VMs from {self.host}: proxmox client is None")
|
||
return []
|
||
|
||
vms = []
|
||
|
||
try:
|
||
if node:
|
||
nodes = [{'node': node}]
|
||
else:
|
||
nodes = self.get_nodes()
|
||
|
||
for n in nodes:
|
||
node_name = n.get('node')
|
||
try:
|
||
qemu_vms = self.proxmox.nodes(node_name).qemu.get()
|
||
for vm in qemu_vms:
|
||
vm['node'] = node_name
|
||
vm['type'] = 'qemu'
|
||
vms.append(vm)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения VM с ноды {node_name}: {e}")
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения списка VM {self.host}: {e}")
|
||
|
||
return vms
|
||
|
||
def get_containers(self, node: str = None) -> List[Dict]:
|
||
"""
|
||
Получить список LXC контейнеров
|
||
|
||
Args:
|
||
node: Имя ноды (если None, получить со всех нод)
|
||
|
||
Returns:
|
||
Список LXC контейнеров с информацией
|
||
"""
|
||
if not self.proxmox:
|
||
logger.warning(f"Cannot get containers from {self.host}: proxmox client is None")
|
||
return []
|
||
|
||
containers = []
|
||
|
||
try:
|
||
if node:
|
||
nodes = [{'node': node}]
|
||
else:
|
||
nodes = self.get_nodes()
|
||
|
||
for n in nodes:
|
||
node_name = n.get('node')
|
||
try:
|
||
lxc_containers = self.proxmox.nodes(node_name).lxc.get()
|
||
for ct in lxc_containers:
|
||
ct['node'] = node_name
|
||
ct['type'] = 'lxc'
|
||
containers.append(ct)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения LXC с ноды {node_name}: {e}")
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения списка LXC {self.host}: {e}")
|
||
|
||
return containers
|
||
|
||
def get_all_resources(self, node: str = None) -> Dict[str, List[Dict]]:
|
||
"""Получить все ресурсы (VM + LXC)
|
||
|
||
Args:
|
||
node: Имя ноды для фильтрации (если None, получить со всех нод)
|
||
"""
|
||
return {
|
||
'vms': self.get_vms(node),
|
||
'containers': self.get_containers(node)
|
||
}
|
||
|
||
def get_cluster_resources(self, type_: Optional[str] = None) -> List[Dict]:
|
||
"""Получить живые метрики со всех VM/LXC одним запросом через /cluster/resources.
|
||
|
||
Args:
|
||
type_: 'vm' для VM/LXC, 'node' для нод, None для всех
|
||
Returns:
|
||
Список ресурсов с полями cpu, mem, maxmem, disk, maxdisk, uptime, netin, netout, status и т.д.
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
try:
|
||
if type_:
|
||
return self.proxmox.cluster.resources.get(type=type_) or []
|
||
return self.proxmox.cluster.resources.get() or []
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения cluster/resources с {self.host}: {e}")
|
||
return []
|
||
|
||
def get_node_status(self, node: str) -> Optional[Dict]:
|
||
"""
|
||
Получить статус ноды Proxmox (CPU, память, uptime и т.д.)
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
|
||
Returns:
|
||
Dict с данными о статусе ноды
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
status = self.proxmox.nodes(node).status.get()
|
||
return status
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения статуса ноды {node}: {e}")
|
||
return None
|
||
|
||
def get_node_rrddata(self, node: str, timeframe: str = "hour") -> Dict:
|
||
"""
|
||
Получить исторические данные ноды для графиков
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
timeframe: Временной диапазон (hour, day, week, month, year)
|
||
|
||
Returns:
|
||
Dict с массивом данных RRD
|
||
"""
|
||
if not self.proxmox:
|
||
return {"data": []}
|
||
|
||
try:
|
||
rrddata = self.proxmox.nodes(node).rrddata.get(timeframe=timeframe)
|
||
return {"data": rrddata}
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения RRD данных ноды {node}: {e}")
|
||
return {"data": []}
|
||
|
||
def get_templates(self, node: str = None) -> List[Dict]:
|
||
"""
|
||
Получить список шаблонов VM (template=1)
|
||
|
||
Args:
|
||
node: Имя ноды (если None, получить со всех нод)
|
||
|
||
Returns:
|
||
Список VM-шаблонов
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
templates = []
|
||
|
||
try:
|
||
if node:
|
||
nodes = [{'node': node}]
|
||
else:
|
||
nodes = self.get_nodes()
|
||
|
||
for n in nodes:
|
||
node_name = n.get('node')
|
||
try:
|
||
qemu_vms = self.proxmox.nodes(node_name).qemu.get()
|
||
for vm in qemu_vms:
|
||
# Проверяем, является ли VM шаблоном
|
||
if vm.get('template') == 1:
|
||
vm['node'] = node_name
|
||
vm['type'] = 'qemu'
|
||
templates.append(vm)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения шаблонов с ноды {node_name}: {e}")
|
||
try:
|
||
lxc_cts = self.proxmox.nodes(node_name).lxc.get()
|
||
for ct in lxc_cts:
|
||
# LXC контейнер-шаблон (template=1)
|
||
if ct.get('template') in (1, '1', True):
|
||
ct['node'] = node_name
|
||
ct['type'] = 'lxc'
|
||
templates.append(ct)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения LXC-шаблонов с ноды {node_name}: {e}")
|
||
# vztmpl файлы из storage (стандартные LXC шаблоны)
|
||
try:
|
||
storages = self.proxmox.nodes(node_name).storage.get()
|
||
seen_volids = set()
|
||
for stor in storages:
|
||
stor_name = stor.get('storage')
|
||
stor_content = stor.get('content', '') or ''
|
||
if 'vztmpl' not in stor_content:
|
||
continue
|
||
try:
|
||
items = self.proxmox.nodes(node_name).storage(stor_name).content.get(content='vztmpl')
|
||
except Exception as e:
|
||
logger.warning(f"Не удалось прочитать vztmpl из {stor_name} на {node_name}: {e}")
|
||
continue
|
||
for item in items:
|
||
volid = item.get('volid')
|
||
if not volid or volid in seen_volids:
|
||
continue
|
||
seen_volids.add(volid)
|
||
# Имя файла без 'storage:vztmpl/'
|
||
fname = volid.split('/', 1)[-1] if '/' in volid else volid
|
||
# Убираем расширения .tar.zst / .tar.gz / .tar.xz
|
||
display_name = fname
|
||
for ext in ('.tar.zst', '.tar.gz', '.tar.xz', '.tar'):
|
||
if display_name.endswith(ext):
|
||
display_name = display_name[: -len(ext)]
|
||
break
|
||
templates.append({
|
||
'vmid': None,
|
||
'volid': volid,
|
||
'name': display_name,
|
||
'node': node_name,
|
||
'type': 'lxc',
|
||
'is_file_template': True,
|
||
'maxmem': 0,
|
||
'maxdisk': int(item.get('size') or 0),
|
||
'storage': stor_name,
|
||
})
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения vztmpl с ноды {node_name}: {e}")
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения списка шаблонов {self.host}: {e}")
|
||
|
||
return templates
|
||
|
||
def get_storages(self, node: str) -> List[Dict]:
|
||
"""
|
||
Получить список хранилищ на ноде
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
|
||
Returns:
|
||
Список доступных хранилищ
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
try:
|
||
storages = self.proxmox.nodes(node).storage.get()
|
||
return storages
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения хранилищ ноды {node}: {e}")
|
||
return []
|
||
|
||
async def async_get_nodes(self) -> List[Dict]:
|
||
"""Non-blocking version of get_nodes()."""
|
||
return await _run_in_executor(self.get_nodes)
|
||
|
||
async def async_get_vms(self, node: str = None) -> List[Dict]:
|
||
"""Non-blocking version of get_vms()."""
|
||
return await _run_in_executor(self.get_vms, node)
|
||
|
||
async def async_get_containers(self, node: str = None) -> List[Dict]:
|
||
"""Non-blocking version of get_containers()."""
|
||
return await _run_in_executor(self.get_containers, node)
|
||
|
||
async def async_get_node_status(self, node: str) -> Optional[Dict]:
|
||
"""Non-blocking version of get_node_status()."""
|
||
return await _run_in_executor(self.get_node_status, node)
|
||
|
||
async def async_get_vm_status(self, node: str, vmid: int) -> Optional[Dict]:
|
||
"""Non-blocking version of get_vm_status()."""
|
||
return await _run_in_executor(self.get_vm_status, node, vmid)
|
||
|
||
async def async_get_container_status(self, node: str, vmid: int) -> Optional[Dict]:
|
||
"""Non-blocking version of get_container_status()."""
|
||
return await _run_in_executor(self.get_container_status, node, vmid)
|
||
|
||
async def async_get_storages(self, node: str) -> List[Dict]:
|
||
"""Non-blocking version of get_storages()."""
|
||
return await _run_in_executor(self.get_storages, node)
|
||
|
||
async def async_get_all_resources(self, node: str = None) -> Dict[str, List[Dict]]:
|
||
"""Non-blocking version of get_all_resources()."""
|
||
return await _run_in_executor(self.get_all_resources, node)
|
||
|
||
def get_next_vmid(self) -> Optional[int]:
|
||
"""
|
||
Получить следующий свободный VMID
|
||
|
||
Returns:
|
||
Свободный VMID или None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
vmid = self.proxmox.cluster.nextid.get()
|
||
return int(vmid)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения следующего VMID: {e}")
|
||
return None
|
||
|
||
def clone_vm_from_template(
|
||
self,
|
||
node: str,
|
||
template_vmid: int,
|
||
new_vmid: int,
|
||
name: str,
|
||
full_clone: bool = True,
|
||
target_storage: str = None,
|
||
target_node: str = None,
|
||
description: str = None
|
||
) -> Optional[str]:
|
||
"""
|
||
Клонировать VM из шаблона
|
||
|
||
Args:
|
||
node: Имя ноды где находится шаблон
|
||
template_vmid: VMID шаблона
|
||
new_vmid: VMID новой VM
|
||
name: Имя новой VM
|
||
full_clone: Полный клон (True) или linked clone (False)
|
||
target_storage: Целевое хранилище (опционально)
|
||
target_node: Целевая нода для VM (для кросс-нодного деплоя)
|
||
description: Описание VM
|
||
|
||
Returns:
|
||
UPID задачи или None при ошибке
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
params = {
|
||
'newid': new_vmid,
|
||
'name': name,
|
||
'full': 1 if full_clone else 0,
|
||
}
|
||
|
||
if target_storage:
|
||
params['storage'] = target_storage
|
||
|
||
if target_node and target_node != node:
|
||
params['target'] = target_node
|
||
|
||
if description:
|
||
params['description'] = description
|
||
|
||
result = self.proxmox.nodes(node).qemu(template_vmid).clone.post(**params)
|
||
target_info = f" -> {target_node}" if target_node and target_node != node else ""
|
||
logger.info(f"Клонирование VM {template_vmid} -> {new_vmid} ({name}) на {node}{target_info}")
|
||
return result
|
||
except Exception as e:
|
||
logger.error(f"Ошибка клонирования VM {template_vmid} -> {new_vmid}: {e}")
|
||
return None
|
||
|
||
def clone_template_to_node(
|
||
self,
|
||
source_node: str,
|
||
template_vmid: int,
|
||
target_node: str,
|
||
new_vmid: int = None,
|
||
target_storage: str = None
|
||
) -> Optional[Dict]:
|
||
"""
|
||
Клонировать шаблон с одной ноды на другую.
|
||
Используется для репликации шаблонов между нодами кластера.
|
||
|
||
Args:
|
||
source_node: Исходная нода где находится шаблон
|
||
template_vmid: VMID шаблона на исходной ноде
|
||
target_node: Целевая нода куда клонировать
|
||
new_vmid: VMID для клона на целевой ноде (опционально, будет сгенерирован)
|
||
target_storage: Целевое хранилище на целевой ноде (если не указано - найдёт автоматически)
|
||
|
||
Returns:
|
||
Dict с upid задачи и new_vmid, или None при ошибке
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
if source_node == target_node:
|
||
logger.warning(f"Source and target node are the same: {source_node}")
|
||
return None
|
||
|
||
try:
|
||
# Get next VMID if not provided
|
||
if not new_vmid:
|
||
new_vmid = self.get_next_vmid()
|
||
if not new_vmid:
|
||
logger.error("Failed to get next VMID for template clone")
|
||
return None
|
||
|
||
# Get template info to preserve its name
|
||
template_config = self.proxmox.nodes(source_node).qemu(template_vmid).config.get()
|
||
template_name = template_config.get('name', f'template-{template_vmid}')
|
||
|
||
# Auto-detect target storage if not provided
|
||
# For cross-node cloning with local storage, we MUST specify target storage
|
||
if not target_storage:
|
||
target_storage = self._get_default_vm_storage(target_node)
|
||
if target_storage:
|
||
logger.info(f"Auto-detected target storage: {target_storage} on {target_node}")
|
||
|
||
params = {
|
||
'newid': new_vmid,
|
||
'name': f"{template_name}",
|
||
'target': target_node,
|
||
'full': 1, # Full clone for cross-node
|
||
}
|
||
|
||
if target_storage:
|
||
params['storage'] = target_storage
|
||
|
||
result = self.proxmox.nodes(source_node).qemu(template_vmid).clone.post(**params)
|
||
logger.info(f"Клонирование шаблона {template_vmid} с {source_node} на {target_node} (new vmid: {new_vmid}, storage: {target_storage})")
|
||
|
||
return {
|
||
'upid': result,
|
||
'new_vmid': new_vmid,
|
||
'target_node': target_node
|
||
}
|
||
except Exception as e:
|
||
logger.error(f"Ошибка клонирования шаблона {template_vmid} на ноду {target_node}: {e}")
|
||
return None
|
||
|
||
def _get_default_vm_storage(self, node: str) -> Optional[str]:
|
||
"""
|
||
Получить хранилище по умолчанию для VM на ноде.
|
||
Ищет хранилища с поддержкой 'images' (VM дисков).
|
||
|
||
Returns:
|
||
Имя хранилища или None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
storages = self.proxmox.nodes(node).storage.get()
|
||
|
||
# Priority: local-lvm > local-zfs > any with 'images' content
|
||
priority_storages = ['local-lvm', 'local-zfs', 'local']
|
||
|
||
# Filter storages that support VM images
|
||
vm_storages = []
|
||
for s in storages:
|
||
content = s.get('content', '')
|
||
if 'images' in content:
|
||
vm_storages.append(s)
|
||
|
||
if not vm_storages:
|
||
logger.warning(f"No VM storage found on node {node}")
|
||
return None
|
||
|
||
# Try priority storages first
|
||
for priority in priority_storages:
|
||
for s in vm_storages:
|
||
if s.get('storage') == priority and s.get('active', 1):
|
||
return s.get('storage')
|
||
|
||
# Return first active storage with images support
|
||
for s in vm_storages:
|
||
if s.get('active', 1):
|
||
return s.get('storage')
|
||
|
||
return vm_storages[0].get('storage') if vm_storages else None
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error getting default storage for node {node}: {e}")
|
||
return None
|
||
|
||
def convert_to_template(self, node: str, vmid: int) -> bool:
|
||
"""
|
||
Преобразовать VM в шаблон
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: VMID VM
|
||
|
||
Returns:
|
||
True если успешно
|
||
"""
|
||
if not self.proxmox:
|
||
return False
|
||
|
||
try:
|
||
self.proxmox.nodes(node).qemu(vmid).template.post()
|
||
logger.info(f"VM {vmid} на {node} преобразован в шаблон")
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"Ошибка преобразования VM {vmid} в шаблон: {e}")
|
||
return False
|
||
|
||
def find_template_on_nodes(self, template_vmid: int, nodes: List[str] = None) -> Optional[Dict]:
|
||
"""
|
||
Найти шаблон по VMID на всех нодах кластера
|
||
|
||
Args:
|
||
template_vmid: VMID искомого шаблона
|
||
nodes: Список нод для поиска (опционально, по умолчанию все ноды)
|
||
|
||
Returns:
|
||
Dict с node и template info, или None если не найден
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
if not nodes:
|
||
nodes_info = self.get_nodes()
|
||
nodes = [n.get('node') for n in nodes_info if n.get('node')]
|
||
|
||
for node in nodes:
|
||
try:
|
||
status = self.get_vm_status(node, template_vmid)
|
||
if status:
|
||
config = self.proxmox.nodes(node).qemu(template_vmid).config.get()
|
||
is_template = config.get('template', 0) == 1
|
||
return {
|
||
'node': node,
|
||
'vmid': template_vmid,
|
||
'name': config.get('name', ''),
|
||
'is_template': is_template,
|
||
'status': status
|
||
}
|
||
except Exception:
|
||
continue
|
||
|
||
return None
|
||
except Exception as e:
|
||
logger.error(f"Ошибка поиска шаблона {template_vmid}: {e}")
|
||
return None
|
||
|
||
def replicate_template_to_node(
|
||
self,
|
||
source_node: str,
|
||
template_vmid: int,
|
||
target_node: str,
|
||
target_storage: str = None,
|
||
timeout: int = 600
|
||
) -> Optional[int]:
|
||
"""
|
||
Полная репликация шаблона на другую ноду с ожиданием завершения.
|
||
Клонирует шаблон с тем же VMID и преобразует клон в шаблон на целевой ноде.
|
||
|
||
Args:
|
||
source_node: Исходная нода
|
||
template_vmid: VMID шаблона (будет сохранён на целевой ноде)
|
||
target_node: Целевая нода
|
||
target_storage: Целевое хранилище
|
||
timeout: Таймаут ожидания в секундах
|
||
|
||
Returns:
|
||
VMID шаблона на целевой ноде (тот же что и исходный), или None при ошибке
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
# Step 1: Clone template to target node with SAME VMID
|
||
clone_result = self.clone_template_to_node(
|
||
source_node=source_node,
|
||
template_vmid=template_vmid,
|
||
target_node=target_node,
|
||
new_vmid=template_vmid, # Keep the same VMID
|
||
target_storage=target_storage
|
||
)
|
||
|
||
if not clone_result:
|
||
logger.error("Failed to start template clone")
|
||
return None
|
||
|
||
upid = clone_result['upid']
|
||
new_vmid = clone_result['new_vmid'] # Should be same as template_vmid
|
||
|
||
# Step 2: Wait for clone to complete
|
||
logger.info(f"Waiting for template clone task: {upid}")
|
||
success = self.wait_for_task(source_node, upid, timeout=timeout)
|
||
|
||
if not success:
|
||
logger.error(f"Template clone task failed or timed out: {upid}")
|
||
return None
|
||
|
||
# Step 3: Convert cloned VM to template
|
||
logger.info(f"Converting cloned VM {new_vmid} to template on {target_node}")
|
||
if not self.convert_to_template(target_node, new_vmid):
|
||
logger.error(f"Failed to convert VM {new_vmid} to template")
|
||
# VM created but not a template - still usable
|
||
return new_vmid
|
||
|
||
logger.info(f"Successfully replicated template {template_vmid} to {target_node} as {new_vmid}")
|
||
return new_vmid
|
||
|
||
except Exception as e:
|
||
logger.error(f"Error replicating template to {target_node}: {e}")
|
||
return None
|
||
|
||
def configure_vm(
|
||
self,
|
||
node: str,
|
||
vmid: int,
|
||
cores: int = None,
|
||
memory: int = None,
|
||
disk_size: int = None,
|
||
disk_storage: str = None,
|
||
network_bridge: str = None,
|
||
cloud_init_user: str = None,
|
||
cloud_init_password: str = None,
|
||
ssh_keys: str = None,
|
||
ip_config: str = None,
|
||
onboot: bool = None
|
||
) -> bool:
|
||
"""
|
||
Настроить параметры VM после клонирования
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: VMID VM
|
||
cores: Количество ядер CPU
|
||
memory: Память в MB
|
||
disk_size: Размер диска в GB
|
||
disk_storage: Хранилище диска
|
||
network_bridge: Сетевой мост
|
||
cloud_init_user: Пользователь cloud-init
|
||
cloud_init_password: Пароль cloud-init
|
||
ssh_keys: SSH ключи (public)
|
||
ip_config: Конфигурация IP (например, "ip=dhcp" или "ip=192.168.1.100/24,gw=192.168.1.1")
|
||
onboot: Автозапуск VM при старте хоста
|
||
|
||
Returns:
|
||
True если успешно
|
||
"""
|
||
if not self.proxmox:
|
||
return False
|
||
|
||
try:
|
||
params = {}
|
||
|
||
if cores:
|
||
params['cores'] = cores
|
||
|
||
if memory:
|
||
params['memory'] = memory
|
||
|
||
if onboot is not None:
|
||
params['onboot'] = 1 if onboot else 0
|
||
|
||
if network_bridge:
|
||
params['net0'] = f'virtio,bridge={network_bridge}'
|
||
|
||
# Cloud-init configuration
|
||
if cloud_init_user:
|
||
params['ciuser'] = cloud_init_user
|
||
|
||
if cloud_init_password:
|
||
params['cipassword'] = cloud_init_password
|
||
|
||
if ssh_keys:
|
||
# SSH keys need URL encoding
|
||
import urllib.parse
|
||
params['sshkeys'] = urllib.parse.quote(ssh_keys, safe='')
|
||
|
||
if ip_config:
|
||
params['ipconfig0'] = ip_config
|
||
|
||
if params:
|
||
self.proxmox.nodes(node).qemu(vmid).config.put(**params)
|
||
logger.info(f"VM {vmid} настроена: {params.keys()}")
|
||
|
||
# Resize disk if needed
|
||
if disk_size:
|
||
try:
|
||
# Get current disk info
|
||
config = self.proxmox.nodes(node).qemu(vmid).config.get()
|
||
# Find the main disk (usually scsi0 or virtio0)
|
||
# Exclude ide0/ide2 which are often CD-ROM or cloud-init drives
|
||
disk_key = None
|
||
current_size_gb = 0
|
||
for key in ['scsi0', 'virtio0', 'sata0', 'scsi1', 'virtio1']:
|
||
if key in config:
|
||
disk_config = config[key]
|
||
# Skip if it's a cdrom or cloud-init drive
|
||
if 'cdrom' in disk_config.lower() or 'cloudinit' in disk_config.lower() or 'media=cdrom' in disk_config.lower():
|
||
continue
|
||
disk_key = key
|
||
# Parse current size from config (format: "storage:vm-xxx-disk-0,size=32G")
|
||
if 'size=' in disk_config:
|
||
size_part = disk_config.split('size=')[1].split(',')[0]
|
||
if size_part.endswith('G'):
|
||
current_size_gb = int(size_part[:-1])
|
||
elif size_part.endswith('M'):
|
||
current_size_gb = int(size_part[:-1]) // 1024
|
||
break
|
||
|
||
if disk_key:
|
||
# Only resize if requested size is larger than current
|
||
if disk_size > current_size_gb:
|
||
resize_upid = self.proxmox.nodes(node).qemu(vmid).resize.put(
|
||
disk=disk_key,
|
||
size=f'{disk_size}G'
|
||
)
|
||
# Wait for resize task to complete before proceeding
|
||
if isinstance(resize_upid, str):
|
||
self.wait_for_task(node, resize_upid, timeout=120)
|
||
logger.info(f"Диск {disk_key} VM {vmid} изменен с {current_size_gb}G до {disk_size}G")
|
||
else:
|
||
logger.info(f"Диск {disk_key} VM {vmid} уже имеет размер {current_size_gb}G >= запрошенного {disk_size}G")
|
||
else:
|
||
logger.warning(f"Не найден основной диск для VM {vmid}")
|
||
except Exception as e:
|
||
logger.warning(f"Не удалось изменить размер диска VM {vmid}: {e}")
|
||
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"Ошибка настройки VM {vmid}: {e}")
|
||
return False
|
||
|
||
def get_task_status(self, node: str, upid: str) -> Dict:
|
||
"""Get status of a Proxmox task by UPID"""
|
||
if not self.proxmox:
|
||
return {}
|
||
try:
|
||
status = self.proxmox.nodes(node).tasks(upid).status.get()
|
||
return status
|
||
except Exception as e:
|
||
logger.error(f"Error getting task status {upid}: {e}")
|
||
return {}
|
||
|
||
def wait_for_task(self, node: str, upid: str, timeout: int = 300) -> bool:
|
||
"""
|
||
Ждать завершения задачи
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
upid: UPID задачи
|
||
timeout: Таймаут в секундах
|
||
|
||
Returns:
|
||
True если задача успешно завершена
|
||
"""
|
||
import time as time_module
|
||
|
||
start_time = time_module.time()
|
||
while time_module.time() - start_time < timeout:
|
||
status = self.get_task_status(node, upid)
|
||
if status:
|
||
if status.get('status') == 'stopped':
|
||
# Проверяем exitstatus
|
||
exit_status = status.get('exitstatus')
|
||
if exit_status != 'OK':
|
||
logger.error(f"Proxmox task {upid} failed with exitstatus={exit_status!r}")
|
||
# 'OK' — success; 'WARNINGS: N' — success with warnings (container still created)
|
||
return exit_status == 'OK' or (isinstance(exit_status, str) and exit_status.startswith('WARNINGS:'))
|
||
time_module.sleep(2)
|
||
|
||
logger.warning(f"Таймаут ожидания задачи {upid}")
|
||
return False
|
||
|
||
def delete_vm(self, node: str, vmid: int, force: bool = False) -> Optional[str]:
|
||
"""
|
||
Удалить виртуальную машину
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID виртуальной машины
|
||
force: Принудительное удаление (остановит VM если запущена)
|
||
|
||
Returns:
|
||
UPID задачи удаления или True при успехе
|
||
|
||
Raises:
|
||
Exception: При ошибке удаления
|
||
"""
|
||
if not self.proxmox:
|
||
raise Exception("Proxmox client not connected")
|
||
|
||
# Check if VM is HA managed and remove from HA first
|
||
try:
|
||
ha_status = self.proxmox.nodes(node).qemu(vmid).status.current.get()
|
||
if ha_status and isinstance(ha_status, dict):
|
||
ha_info = ha_status.get('ha', {})
|
||
if ha_info.get('managed'):
|
||
# Remove from HA
|
||
try:
|
||
self.proxmox.cluster.ha.resources(f"vm:{vmid}").delete()
|
||
logger.info(f"Removed VM {vmid} from HA before deletion")
|
||
except Exception as ha_e:
|
||
logger.warning(f"Failed to remove VM {vmid} from HA: {ha_e}")
|
||
except Exception as e:
|
||
logger.debug(f"Could not check HA status for VM {vmid}: {e}")
|
||
|
||
params = {'purge': 1} # Always purge to handle HA and other resources
|
||
if force:
|
||
params['force'] = 1
|
||
|
||
result = self.proxmox.nodes(node).qemu(vmid).delete(**params)
|
||
logger.info(f"Запущено удаление VM {vmid} на {node}")
|
||
return result if result else True
|
||
|
||
def delete_container(self, node: str, vmid: int, force: bool = False) -> Optional[str]:
|
||
"""
|
||
Удалить контейнер (LXC)
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID контейнера
|
||
force: Принудительное удаление (остановит контейнер если запущен)
|
||
|
||
Returns:
|
||
UPID задачи удаления или True при успехе
|
||
|
||
Raises:
|
||
Exception: При ошибке удаления
|
||
"""
|
||
if not self.proxmox:
|
||
raise Exception("Proxmox client not connected")
|
||
|
||
# Check if container is HA managed and remove from HA first
|
||
try:
|
||
ha_status = self.proxmox.nodes(node).lxc(vmid).status.current.get()
|
||
if ha_status and isinstance(ha_status, dict):
|
||
ha_info = ha_status.get('ha', {})
|
||
if ha_info.get('managed'):
|
||
# Remove from HA
|
||
try:
|
||
self.proxmox.cluster.ha.resources(f"ct:{vmid}").delete()
|
||
logger.info(f"Removed container {vmid} from HA before deletion")
|
||
except Exception as ha_e:
|
||
logger.warning(f"Failed to remove container {vmid} from HA: {ha_e}")
|
||
except Exception as e:
|
||
logger.debug(f"Could not check HA status for container {vmid}: {e}")
|
||
|
||
params = {'purge': 1} # Always purge to handle HA and other resources
|
||
if force:
|
||
params['force'] = 1
|
||
|
||
result = self.proxmox.nodes(node).lxc(vmid).delete(**params)
|
||
logger.info(f"Запущено удаление контейнера {vmid} на {node}")
|
||
return result if result else True
|
||
|
||
def get_vm_config(self, node: str, vmid: int) -> Optional[Dict]:
|
||
"""
|
||
Получить конфигурацию виртуальной машины
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID виртуальной машины
|
||
|
||
Returns:
|
||
Словарь с конфигурацией VM
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
config = self.proxmox.nodes(node).qemu(vmid).config.get()
|
||
return dict(config)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения конфигурации VM {vmid}: {e}")
|
||
return None
|
||
|
||
def update_vm_config(self, node: str, vmid: int, config: Dict) -> bool:
|
||
"""
|
||
Обновить конфигурацию виртуальной машины
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID виртуальной машины
|
||
config: Словарь с параметрами для обновления
|
||
|
||
Returns:
|
||
True при успехе
|
||
"""
|
||
if not self.proxmox:
|
||
return False
|
||
|
||
try:
|
||
# Фильтруем разрешенные параметры
|
||
allowed_params = {
|
||
'cores', 'sockets', 'memory', 'balloon', 'name', 'description',
|
||
'cpu', 'cpulimit', 'cpuunits', 'onboot', 'boot', 'bootdisk',
|
||
'net0', 'net1', 'net2', 'net3',
|
||
'scsi0', 'scsi1', 'scsi2', 'scsi3',
|
||
'virtio0', 'virtio1', 'virtio2', 'virtio3',
|
||
'ide0', 'ide1', 'ide2', 'ide3',
|
||
'sata0', 'sata1', 'sata2', 'sata3',
|
||
'agent', 'ostype', 'tablet', 'hotplug',
|
||
'ciuser', 'cipassword', 'sshkeys', 'ipconfig0', 'ipconfig1',
|
||
}
|
||
|
||
filtered_config = {k: v for k, v in config.items() if k in allowed_params}
|
||
|
||
if filtered_config:
|
||
self.proxmox.nodes(node).qemu(vmid).config.put(**filtered_config)
|
||
logger.info(f"Конфигурация VM {vmid} обновлена: {list(filtered_config.keys())}")
|
||
return True
|
||
else:
|
||
logger.warning(f"Нет разрешенных параметров для обновления VM {vmid}")
|
||
return False
|
||
except Exception as e:
|
||
logger.error(f"Ошибка обновления конфигурации VM {vmid}: {e}")
|
||
return False
|
||
|
||
def get_container_config(self, node: str, vmid: int) -> Optional[Dict]:
|
||
"""
|
||
Получить конфигурацию LXC контейнера
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID контейнера
|
||
|
||
Returns:
|
||
Словарь с конфигурацией
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
config = self.proxmox.nodes(node).lxc(vmid).config.get()
|
||
return dict(config)
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения конфигурации LXC {vmid}: {e}")
|
||
return None
|
||
|
||
def update_container_config(
|
||
self,
|
||
node: str,
|
||
vmid: int,
|
||
hostname: str = None,
|
||
memory: int = None,
|
||
swap: int = None,
|
||
cores: int = None,
|
||
cpulimit: float = None,
|
||
onboot: bool = None,
|
||
description: str = None,
|
||
net0: str = None
|
||
) -> bool:
|
||
"""
|
||
Обновить конфигурацию LXC контейнера
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID контейнера
|
||
hostname: Новое имя хоста
|
||
memory: Память в MB
|
||
swap: Swap в MB
|
||
cores: Количество ядер
|
||
cpulimit: Лимит CPU (0.0-128.0)
|
||
onboot: Автозапуск
|
||
description: Описание
|
||
net0: Конфигурация сети
|
||
|
||
Returns:
|
||
True при успехе
|
||
"""
|
||
if not self.proxmox:
|
||
return False
|
||
|
||
try:
|
||
params = {}
|
||
|
||
if hostname:
|
||
params['hostname'] = hostname
|
||
if memory is not None:
|
||
params['memory'] = memory
|
||
if swap is not None:
|
||
params['swap'] = swap
|
||
if cores is not None:
|
||
params['cores'] = cores
|
||
if cpulimit is not None:
|
||
params['cpulimit'] = cpulimit
|
||
if onboot is not None:
|
||
params['onboot'] = 1 if onboot else 0
|
||
if description is not None:
|
||
params['description'] = description
|
||
if net0:
|
||
params['net0'] = net0
|
||
|
||
if params:
|
||
self.proxmox.nodes(node).lxc(vmid).config.put(**params)
|
||
logger.info(f"Конфигурация LXC {vmid} обновлена: {list(params.keys())}")
|
||
return True
|
||
return False
|
||
except Exception as e:
|
||
logger.error(f"Ошибка обновления конфигурации LXC {vmid}: {e}")
|
||
return False
|
||
|
||
def resize_container_disk(self, node: str, vmid: int, disk: str, size: str) -> bool:
|
||
"""
|
||
Изменить размер диска LXC контейнера
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID контейнера
|
||
disk: Имя диска (rootfs, mp0, mp1, etc)
|
||
size: Размер для добавления (например '+5G')
|
||
|
||
Returns:
|
||
True при успехе
|
||
"""
|
||
if not self.proxmox:
|
||
return False
|
||
|
||
try:
|
||
resize_upid = self.proxmox.nodes(node).lxc(vmid).resize.put(disk=disk, size=size)
|
||
# Wait for resize task to complete to avoid lock conflicts
|
||
if isinstance(resize_upid, str):
|
||
self.wait_for_task(node, resize_upid, timeout=120)
|
||
logger.info(f"Диск {disk} LXC {vmid} изменен на {size}")
|
||
return True
|
||
except Exception as e:
|
||
logger.error(f"Ошибка изменения размера диска LXC {vmid}: {e}")
|
||
return False
|
||
|
||
def get_vm_interfaces(self, node: str, vmid: int) -> List[Dict]:
|
||
"""
|
||
Получить сетевые интерфейсы VM через QEMU guest agent
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID виртуальной машины
|
||
|
||
Returns:
|
||
Список интерфейсов с IP адресами
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
try:
|
||
# Пытаемся получить информацию через guest agent
|
||
result = self.proxmox.nodes(node).qemu(vmid).agent('network-get-interfaces').get()
|
||
|
||
interfaces = []
|
||
if result and 'result' in result:
|
||
for iface in result['result']:
|
||
if 'ip-addresses' in iface and iface['ip-addresses']:
|
||
name = iface.get('name', 'unknown')
|
||
# Пропускаем loopback
|
||
if name == 'lo':
|
||
continue
|
||
|
||
ips = []
|
||
for ip_info in iface['ip-addresses']:
|
||
ip = ip_info.get('ip-address')
|
||
ip_type = ip_info.get('ip-address-type', 'unknown')
|
||
if ip and ip_type in ['ipv4', 'ipv6']:
|
||
ips.append({
|
||
'address': ip,
|
||
'type': ip_type,
|
||
'prefix': ip_info.get('prefix', 0)
|
||
})
|
||
|
||
if ips:
|
||
interfaces.append({
|
||
'name': name,
|
||
'hardware_address': iface.get('hardware-address', ''),
|
||
'ips': ips
|
||
})
|
||
|
||
return interfaces
|
||
except Exception as e:
|
||
logger.debug(f"Не удалось получить сетевые интерфейсы VM {vmid} (guest agent может быть не установлен): {e}")
|
||
return []
|
||
|
||
def get_container_interfaces(self, node: str, vmid: int) -> List[Dict]:
|
||
"""
|
||
Получить сетевые интерфейсы контейнера
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID контейнера
|
||
|
||
Returns:
|
||
Список интерфейсов с IP адресами
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
try:
|
||
# Для LXC можем получить IP из конфигурации
|
||
config = self.proxmox.nodes(node).lxc(vmid).config.get()
|
||
interfaces = []
|
||
|
||
# Проверяем net0, net1 и т.д.
|
||
for i in range(10):
|
||
net_key = f'net{i}'
|
||
if net_key in config:
|
||
net_config = config[net_key]
|
||
# Парсим строку конфигурации сети
|
||
iface_info = {'name': f'eth{i}', 'ips': []}
|
||
|
||
# Пытаемся извлечь MAC адрес
|
||
if 'hwaddr=' in net_config:
|
||
mac = net_config.split('hwaddr=')[1].split(',')[0]
|
||
iface_info['hardware_address'] = mac
|
||
|
||
interfaces.append(iface_info)
|
||
|
||
# Также проверяем IP из конфигурации
|
||
for i in range(10):
|
||
ipconfig_key = f'ipconfig{i}'
|
||
if ipconfig_key in config and interfaces and i < len(interfaces):
|
||
ipconfig = config[ipconfig_key]
|
||
# Парсим ip=192.168.1.10/24,gw=192.168.1.1
|
||
if 'ip=' in ipconfig:
|
||
ip_part = ipconfig.split('ip=')[1].split(',')[0]
|
||
if ip_part != 'dhcp':
|
||
# Разделяем IP и префикс
|
||
if '/' in ip_part:
|
||
ip, prefix = ip_part.split('/')
|
||
interfaces[i]['ips'].append({
|
||
'address': ip,
|
||
'type': 'ipv4',
|
||
'prefix': int(prefix)
|
||
})
|
||
|
||
return [iface for iface in interfaces if iface.get('ips')]
|
||
except Exception as e:
|
||
logger.debug(f"Не удалось получить сетевые интерфейсы контейнера {vmid}: {e}")
|
||
return []
|
||
|
||
def execute_command(self, node: str, vmid: int, command: str, timeout: int = 30) -> Dict:
|
||
"""
|
||
Выполнить команду на VM через QEMU guest agent
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID виртуальной машины
|
||
command: Команда для выполнения (например: "ls -la /tmp")
|
||
timeout: Таймаут в секундах для ожидания результата
|
||
|
||
Returns:
|
||
Dict с ключами: success, stdout, stderr, exit_code
|
||
"""
|
||
if not self.proxmox:
|
||
return {
|
||
'success': False,
|
||
'error': 'Proxmox connection not initialized',
|
||
'stdout': '',
|
||
'stderr': '',
|
||
'exit_code': -1
|
||
}
|
||
|
||
try:
|
||
# Запускаем команду через guest agent
|
||
exec_result = self.proxmox.nodes(node).qemu(vmid).agent.exec.post(
|
||
command=command
|
||
)
|
||
|
||
if 'pid' not in exec_result:
|
||
return {
|
||
'success': False,
|
||
'error': 'Failed to start command execution',
|
||
'stdout': '',
|
||
'stderr': '',
|
||
'exit_code': -1
|
||
}
|
||
|
||
pid = exec_result['pid']
|
||
|
||
# Ждем завершения команды и возвращаем результат
|
||
return self._wait_exec_status(node, vmid, pid, timeout)
|
||
|
||
except Exception as e:
|
||
logger.error(f"Failed to execute command on VM {vmid}: {e}")
|
||
return {
|
||
'success': False,
|
||
'error': str(e),
|
||
'stdout': '',
|
||
'stderr': '',
|
||
'exit_code': -1
|
||
}
|
||
|
||
def _wait_exec_status(self, node: str, vmid: int, pid: int, timeout: int) -> Dict:
|
||
"""
|
||
Опросить статус выполнения команды guest agent по pid до завершения.
|
||
|
||
Returns:
|
||
Dict с ключами: success, stdout, stderr, exit_code
|
||
"""
|
||
start_time = time.time()
|
||
while time.time() - start_time < timeout:
|
||
try:
|
||
status = self.proxmox.nodes(node).qemu(vmid).agent('exec-status').get(pid=pid)
|
||
|
||
if status.get('exited'):
|
||
# Команда завершена
|
||
return {
|
||
'success': True,
|
||
'stdout': status.get('out-data', ''),
|
||
'stderr': status.get('err-data', ''),
|
||
'exit_code': status.get('exitcode', 0)
|
||
}
|
||
except Exception as e:
|
||
logger.debug(f"Error checking command status: {e}")
|
||
|
||
# Ждем немного перед следующей проверкой
|
||
time.sleep(0.5)
|
||
|
||
# Таймаут
|
||
return {
|
||
'success': False,
|
||
'error': f'Command execution timeout ({timeout}s)',
|
||
'stdout': '',
|
||
'stderr': '',
|
||
'exit_code': -1
|
||
}
|
||
|
||
def execute_script(self, node: str, vmid: int, script_content: str,
|
||
interpreter: str = "/bin/bash", timeout: int = 60) -> Dict:
|
||
"""
|
||
Выполнить bash скрипт на VM через QEMU guest agent
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID виртуальной машины
|
||
script_content: Содержимое скрипта
|
||
interpreter: Путь к интерпретатору (по умолчанию /bin/bash)
|
||
timeout: Таймаут в секундах
|
||
|
||
Returns:
|
||
Dict с результатом выполнения
|
||
"""
|
||
if not self.proxmox:
|
||
return {
|
||
'success': False,
|
||
'error': 'Proxmox connection not initialized',
|
||
'stdout': '',
|
||
'stderr': '',
|
||
'exit_code': -1
|
||
}
|
||
|
||
try:
|
||
# Передаем скрипт напрямую интерпретатору через stdin (input-data).
|
||
# Интерпретатор запускается без -c, читая тело скрипта со stdin,
|
||
# поэтому многострочные скрипты, кавычки и shebang (#!...) в первой
|
||
# строке обрабатываются корректно без дополнительного слоя кавычек.
|
||
#
|
||
# Proxmox API сам кодирует input-data в base64 перед передачей
|
||
# guest agent'у, поэтому передаем сырое содержимое скрипта.
|
||
exec_result = self.proxmox.nodes(node).qemu(vmid).agent.exec.post(
|
||
command=[interpreter],
|
||
**{'input-data': script_content}
|
||
)
|
||
|
||
if 'pid' not in exec_result:
|
||
return {
|
||
'success': False,
|
||
'error': 'Failed to start script execution',
|
||
'stdout': '',
|
||
'stderr': '',
|
||
'exit_code': -1
|
||
}
|
||
|
||
return self._wait_exec_status(node, vmid, exec_result['pid'], timeout)
|
||
|
||
except Exception as e:
|
||
logger.error(f"Failed to execute script on VM {vmid}: {e}")
|
||
return {
|
||
'success': False,
|
||
'error': str(e),
|
||
'stdout': '',
|
||
'stderr': '',
|
||
'exit_code': -1
|
||
}
|
||
|
||
def get_all_lxc_templates(self) -> List[Dict]:
|
||
"""
|
||
Получить шаблоны LXC со всех нод кластера с информацией о типе хранилища.
|
||
|
||
Returns:
|
||
Список шаблонов с полями: volid, storage, node, shared, storage_type
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
all_templates = []
|
||
seen = set() # Для дедупликации shared шаблонов
|
||
|
||
try:
|
||
nodes = self.get_nodes()
|
||
|
||
# Сначала получим информацию о всех хранилищах кластера
|
||
storage_info = {}
|
||
try:
|
||
cluster_storage = self.proxmox.storage.get()
|
||
for stor in cluster_storage:
|
||
stor_name = stor.get('storage')
|
||
# shared=1 означает что хранилище доступно со всех нод
|
||
storage_info[stor_name] = {
|
||
'shared': stor.get('shared', 0) == 1,
|
||
'type': stor.get('type', 'unknown')
|
||
}
|
||
except Exception as e:
|
||
logger.warning(f"Could not get cluster storage info: {e}")
|
||
|
||
for node_info in nodes:
|
||
node = node_info.get('node')
|
||
if not node:
|
||
continue
|
||
|
||
try:
|
||
templates = self.get_lxc_templates(node)
|
||
for tpl in templates:
|
||
stor_name = tpl.get('storage', '')
|
||
volid = tpl.get('volid', '')
|
||
|
||
# Определяем shared ли хранилище
|
||
is_shared = storage_info.get(stor_name, {}).get('shared', False)
|
||
stor_type = storage_info.get(stor_name, {}).get('type', 'unknown')
|
||
|
||
# Для shared хранилищ - добавляем только один раз
|
||
if is_shared:
|
||
if volid in seen:
|
||
continue
|
||
seen.add(volid)
|
||
|
||
tpl['shared'] = is_shared
|
||
tpl['storage_type'] = stor_type
|
||
all_templates.append(tpl)
|
||
except Exception as e:
|
||
logger.warning(f"Could not get templates from node {node}: {e}")
|
||
|
||
return all_templates
|
||
except Exception as e:
|
||
logger.error(f"Error getting all LXC templates: {e}")
|
||
return []
|
||
|
||
def get_lxc_templates(self, node: str, storage: str = None) -> List[Dict]:
|
||
"""
|
||
Получить список доступных шаблонов LXC контейнеров
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
storage: Хранилище (если None - ищем на всех с типом vztmpl)
|
||
|
||
Returns:
|
||
Список шаблонов с информацией
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
templates = []
|
||
try:
|
||
# Получаем список хранилищ с типом vztmpl
|
||
storages = self.proxmox.nodes(node).storage.get()
|
||
|
||
for stor in storages:
|
||
stor_name = stor.get('storage')
|
||
stor_content = stor.get('content', '')
|
||
|
||
# Проверяем, поддерживает ли хранилище vztmpl
|
||
if 'vztmpl' not in stor_content:
|
||
continue
|
||
|
||
if storage and stor_name != storage:
|
||
continue
|
||
|
||
try:
|
||
# Получаем содержимое хранилища
|
||
logger.info(f"[LXC Templates] Fetching templates from storage: {stor_name}")
|
||
content = self.proxmox.nodes(node).storage(stor_name).content.get(content='vztmpl')
|
||
logger.info(f"[LXC Templates] Found {len(content)} templates in {stor_name}")
|
||
for item in content:
|
||
item['storage'] = stor_name
|
||
item['node'] = node
|
||
templates.append(item)
|
||
except Exception as e:
|
||
logger.warning(f"Не удалось получить шаблоны из {stor_name}: {e}")
|
||
|
||
return templates
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения LXC шаблонов с ноды {node}: {e}")
|
||
return []
|
||
|
||
def download_lxc_template(self, node: str, storage: str, template: str) -> Optional[str]:
|
||
"""
|
||
Скачать шаблон LXC из репозитория
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
storage: Хранилище для загрузки
|
||
template: Имя шаблона (например debian-12-standard_12.2-1_amd64.tar.zst)
|
||
|
||
Returns:
|
||
UPID задачи или None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
result = self.proxmox.nodes(node).aplinfo.post(
|
||
storage=storage,
|
||
template=template
|
||
)
|
||
logger.info(f"Запущена загрузка шаблона {template} на {node}:{storage}")
|
||
return result
|
||
except Exception as e:
|
||
logger.error(f"Ошибка загрузки шаблона {template}: {e}")
|
||
return None
|
||
|
||
def get_available_lxc_templates(self, node: str) -> List[Dict]:
|
||
"""
|
||
Получить список доступных для загрузки шаблонов LXC
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
|
||
Returns:
|
||
Список доступных шаблонов из репозитория
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
try:
|
||
templates = self.proxmox.nodes(node).aplinfo.get()
|
||
return templates
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения списка доступных шаблонов: {e}")
|
||
return []
|
||
|
||
def create_lxc_container(
|
||
self,
|
||
node: str,
|
||
vmid: int,
|
||
ostemplate: str,
|
||
hostname: str,
|
||
password: str = None,
|
||
ssh_public_keys: str = None,
|
||
storage: str = 'local-lvm',
|
||
rootfs_size: int = 8,
|
||
memory: int = 512,
|
||
swap: int = 512,
|
||
cores: int = 1,
|
||
net0: str = None,
|
||
unprivileged: bool = True,
|
||
start_after_create: bool = False,
|
||
onboot: bool = False,
|
||
description: str = None,
|
||
features: str = None,
|
||
nameserver: str = None,
|
||
searchdomain: str = None,
|
||
) -> Optional[str]:
|
||
"""
|
||
Создать новый LXC контейнер
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID контейнера
|
||
ostemplate: Путь к шаблону (storage:vztmpl/template.tar.gz)
|
||
hostname: Имя хоста контейнера
|
||
password: Пароль root (опционально, если есть ssh_public_keys)
|
||
ssh_public_keys: SSH публичные ключи
|
||
storage: Хранилище для rootfs
|
||
rootfs_size: Размер rootfs в GB
|
||
memory: Память в MB
|
||
swap: Swap в MB
|
||
cores: Количество ядер CPU
|
||
net0: Конфигурация сети (например: name=eth0,bridge=vmbr0,ip=dhcp)
|
||
unprivileged: Непривилегированный контейнер (рекомендуется)
|
||
start_after_create: Запустить после создания
|
||
onboot: Автозапуск при старте хоста
|
||
description: Описание контейнера
|
||
features: Дополнительные features (nesting, keyctl, etc)
|
||
|
||
Returns:
|
||
UPID задачи или None при ошибке
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
params = {
|
||
'vmid': vmid,
|
||
'ostemplate': ostemplate,
|
||
'hostname': hostname,
|
||
'storage': storage,
|
||
'rootfs': f'{storage}:{rootfs_size}',
|
||
'memory': memory,
|
||
'swap': swap,
|
||
'cores': cores,
|
||
'unprivileged': 1 if unprivileged else 0,
|
||
'start': 1 if start_after_create else 0,
|
||
'onboot': 1 if onboot else 0,
|
||
}
|
||
|
||
if password:
|
||
params['password'] = password
|
||
|
||
if ssh_public_keys:
|
||
# proxmoxer URL-encodes params automatically; pass key as-is
|
||
params['ssh-public-keys'] = ssh_public_keys.strip()
|
||
|
||
if net0:
|
||
params['net0'] = net0
|
||
else:
|
||
# Конфигурация по умолчанию
|
||
params['net0'] = 'name=eth0,bridge=vmbr0,ip=dhcp'
|
||
|
||
if description:
|
||
params['description'] = description
|
||
|
||
# Enable nesting by default — required for systemd 255+ (Ubuntu 24.04, Debian 13)
|
||
# to avoid "WARN: Systemd 255 detected. You may need to enable nesting." warning
|
||
if features:
|
||
params['features'] = features
|
||
else:
|
||
params['features'] = 'nesting=1'
|
||
|
||
if nameserver:
|
||
params['nameserver'] = nameserver
|
||
|
||
if searchdomain:
|
||
params['searchdomain'] = searchdomain
|
||
|
||
result = self.proxmox.nodes(node).lxc.post(**params)
|
||
logger.info(f"Запущено создание LXC контейнера {vmid} ({hostname}) на {node}")
|
||
return result
|
||
except Exception as e:
|
||
logger.error(f"Ошибка создания LXC контейнера {vmid}: {e}")
|
||
return None
|
||
|
||
def clone_lxc_container(
|
||
self,
|
||
node: str,
|
||
source_vmid: int,
|
||
new_vmid: int,
|
||
hostname: str,
|
||
full_clone: bool = True,
|
||
target_storage: str = None,
|
||
description: str = None
|
||
) -> Optional[str]:
|
||
"""
|
||
Клонировать LXC контейнер
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
source_vmid: VMID исходного контейнера
|
||
new_vmid: VMID нового контейнера
|
||
hostname: Имя хоста нового контейнера
|
||
full_clone: Полный клон (True) или linked clone (False)
|
||
target_storage: Целевое хранилище
|
||
description: Описание
|
||
|
||
Returns:
|
||
UPID задачи или None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
params = {
|
||
'newid': new_vmid,
|
||
'hostname': hostname,
|
||
'full': 1 if full_clone else 0,
|
||
}
|
||
|
||
if target_storage:
|
||
params['storage'] = target_storage
|
||
|
||
if description:
|
||
params['description'] = description
|
||
|
||
result = self.proxmox.nodes(node).lxc(source_vmid).clone.post(**params)
|
||
logger.info(f"Клонирование LXC {source_vmid} -> {new_vmid} ({hostname}) на {node}")
|
||
return result
|
||
except Exception as e:
|
||
logger.error(f"Ошибка клонирования LXC {source_vmid} -> {new_vmid}: {e}")
|
||
return None
|
||
|
||
def migrate_container(
|
||
self,
|
||
node: str,
|
||
vmid: int,
|
||
target_node: str,
|
||
target_storage: str = None,
|
||
online: bool = False
|
||
) -> Optional[str]:
|
||
"""
|
||
Мигрировать LXC контейнер на другую ноду
|
||
|
||
Args:
|
||
node: Текущая нода контейнера
|
||
vmid: ID контейнера
|
||
target_node: Целевая нода
|
||
target_storage: Целевое хранилище (опционально)
|
||
online: Онлайн миграция (для запущенных контейнеров)
|
||
|
||
Returns:
|
||
UPID задачи или None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
params = {
|
||
'target': target_node,
|
||
}
|
||
|
||
if target_storage:
|
||
params['target-storage'] = target_storage
|
||
|
||
if online:
|
||
params['online'] = 1
|
||
|
||
result = self.proxmox.nodes(node).lxc(vmid).migrate.post(**params)
|
||
logger.info(f"Миграция LXC {vmid} с {node} на {target_node}")
|
||
return result
|
||
except Exception as e:
|
||
logger.error(f"Ошибка миграции LXC {vmid}: {e}")
|
||
return None
|
||
|
||
def get_vm_termproxy(self, node: str, vmid: int) -> Dict:
|
||
"""
|
||
Получить данные для терминального подключения к VM через xterm.js
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID виртуальной машины
|
||
|
||
Returns:
|
||
Dict с данными терминала (port, ticket, user)
|
||
"""
|
||
if not self.proxmox:
|
||
return {}
|
||
|
||
try:
|
||
term_data = self.proxmox.nodes(node).qemu(vmid).termproxy.post()
|
||
return term_data
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения termproxy для VM {vmid} на {node}: {e}")
|
||
return {}
|
||
|
||
def get_container_termproxy(self, node: str, vmid: int) -> Dict:
|
||
"""
|
||
Получить данные для терминального подключения к LXC контейнеру через xterm.js
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID контейнера
|
||
|
||
Returns:
|
||
Dict с данными терминала (port, ticket, user)
|
||
"""
|
||
if not self.proxmox:
|
||
return {}
|
||
|
||
try:
|
||
term_data = self.proxmox.nodes(node).lxc(vmid).termproxy.post()
|
||
return term_data
|
||
except Exception as e:
|
||
logger.error(f"Ошибка получения termproxy для LXC {vmid} на {node}: {e}")
|
||
return {}
|
||
|
||
def exec_in_container(self, node: str, vmid: int, command: list) -> Dict:
|
||
"""
|
||
Выполнить команду в LXC контейнере через pct exec
|
||
|
||
Args:
|
||
node: Имя ноды
|
||
vmid: ID контейнера
|
||
command: Список [команда, arg1, arg2, ...]
|
||
|
||
Returns:
|
||
Dict с upid задачи выполнения
|
||
"""
|
||
if not self.proxmox:
|
||
return {}
|
||
|
||
try:
|
||
# Proxmox ожидает command и args отдельно
|
||
cmd = command[0] if command else "/bin/bash"
|
||
args = command[1:] if len(command) > 1 else []
|
||
|
||
# Формируем data для POST запроса
|
||
data = {"command": cmd}
|
||
for idx, arg in enumerate(args):
|
||
data[f"args[{idx}]"] = arg
|
||
|
||
result = self.proxmox.nodes(node).lxc(vmid).exec.post(**data)
|
||
return result
|
||
except Exception as e:
|
||
logger.error(f"Ошибка exec в LXC {vmid} на {node}: {e}")
|
||
return {}
|
||
|
||
def get_task_log(self, node: str, upid: str, start: int = 0, limit: int = 500) -> List[Dict]:
|
||
"""Get task log lines"""
|
||
if not self.proxmox:
|
||
return []
|
||
try:
|
||
log = self.proxmox.nodes(node).tasks(upid).log.get(start=start, limit=limit)
|
||
return log
|
||
except Exception as e:
|
||
logger.error(f"Error getting task log {upid}: {e}")
|
||
return []
|
||
|
||
def sdn_is_available(self) -> bool:
|
||
"""
|
||
Check if SDN is available on this Proxmox cluster.
|
||
SDN requires Proxmox VE 7.0+ and proper configuration.
|
||
"""
|
||
if not self.proxmox:
|
||
return False
|
||
|
||
try:
|
||
# Try to access SDN API
|
||
self.proxmox.cluster.sdn.get()
|
||
return True
|
||
except Exception as e:
|
||
logger.debug(f"SDN not available: {e}")
|
||
return False
|
||
|
||
def get_sdn_zone(self, zone: str) -> Optional[Dict]:
|
||
"""
|
||
Get details of a specific SDN zone.
|
||
|
||
Args:
|
||
zone: Zone name/ID
|
||
|
||
Returns:
|
||
Zone configuration dict or None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
zone_data = self.proxmox.cluster.sdn.zones(zone).get()
|
||
return zone_data
|
||
except Exception as e:
|
||
logger.error(f"Error getting SDN zone {zone}: {e}")
|
||
return None
|
||
|
||
def delete_sdn_zone(self, zone: str) -> Dict:
|
||
"""
|
||
Delete an SDN zone.
|
||
|
||
Args:
|
||
zone: Zone name to delete
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
self.proxmox.cluster.sdn.zones(zone).delete()
|
||
logger.info(f"Deleted SDN zone: {zone}")
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error deleting SDN zone {zone}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def get_sdn_vnet(self, vnet: str) -> Optional[Dict]:
|
||
"""
|
||
Get details of a specific VNet.
|
||
|
||
Args:
|
||
vnet: VNet name
|
||
|
||
Returns:
|
||
VNet configuration dict or None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
vnet_data = self.proxmox.cluster.sdn.vnets(vnet).get()
|
||
return vnet_data
|
||
except Exception as e:
|
||
logger.error(f"Error getting SDN vnet {vnet}: {e}")
|
||
return None
|
||
|
||
def delete_sdn_vnet(self, vnet: str) -> Dict:
|
||
"""
|
||
Delete an SDN VNet.
|
||
|
||
Args:
|
||
vnet: VNet name to delete
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
self.proxmox.cluster.sdn.vnets(vnet).delete()
|
||
logger.info(f"Deleted SDN vnet: {vnet}")
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error deleting SDN vnet {vnet}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def get_sdn_subnets(self, vnet: str) -> List[Dict]:
|
||
"""
|
||
Get subnets for a specific VNet.
|
||
|
||
Args:
|
||
vnet: VNet name
|
||
|
||
Returns:
|
||
List of subnets in the VNet
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
try:
|
||
subnets = self.proxmox.cluster.sdn.vnets(vnet).subnets.get()
|
||
return subnets if isinstance(subnets, list) else []
|
||
except Exception as e:
|
||
logger.error(f"Error getting subnets for vnet {vnet}: {e}")
|
||
return []
|
||
|
||
def delete_sdn_subnet(self, vnet: str, subnet: str) -> Dict:
|
||
"""
|
||
Delete a subnet from a VNet.
|
||
|
||
Args:
|
||
vnet: VNet name
|
||
subnet: Subnet to delete (CIDR format, URL-encoded)
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
# Subnet ID in URL is the CIDR with / replaced by -
|
||
subnet_id = subnet.replace("/", "-")
|
||
self.proxmox.cluster.sdn.vnets(vnet).subnets(subnet_id).delete()
|
||
logger.info(f"Deleted subnet {subnet} from vnet {vnet}")
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error deleting subnet {subnet} from vnet {vnet}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def apply_sdn_changes(self) -> Dict:
|
||
"""
|
||
Apply pending SDN configuration changes to all nodes.
|
||
This is required after creating/modifying zones, vnets, or subnets.
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
result = self.proxmox.cluster.sdn.put()
|
||
logger.info("Applied SDN changes to cluster")
|
||
return {"success": True, "upid": result}
|
||
except Exception as e:
|
||
logger.error(f"Error applying SDN changes: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def get_sdn_pending(self) -> List[Dict]:
|
||
"""
|
||
Get pending SDN changes.
|
||
|
||
Returns:
|
||
List of pending changes
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
try:
|
||
# Pending status is typically in the zone/vnet responses
|
||
zones = self.get_sdn_zones()
|
||
vnets = self.get_sdn_vnets()
|
||
|
||
pending = []
|
||
for zone in zones:
|
||
if zone.get('pending'):
|
||
pending.append({"type": "zone", "id": zone.get('zone'), "pending": zone.get('pending')})
|
||
for vnet in vnets:
|
||
if vnet.get('pending'):
|
||
pending.append({"type": "vnet", "id": vnet.get('vnet'), "pending": vnet.get('pending')})
|
||
|
||
return pending
|
||
except Exception as e:
|
||
logger.error(f"Error getting SDN pending changes: {e}")
|
||
return []
|
||
|
||
def update_sdn_zone(self, zone: str, **kwargs) -> Dict:
|
||
"""
|
||
Update an existing SDN zone.
|
||
|
||
Args:
|
||
zone: Zone name to update
|
||
**kwargs: Fields to update (mtu, dns, reversedns, ipam, etc.)
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
self.proxmox.cluster.sdn.zones(zone).put(**kwargs)
|
||
logger.info(f"Updated SDN zone: {zone}")
|
||
return {"success": True, "zone": zone}
|
||
except Exception as e:
|
||
logger.error(f"Error updating SDN zone {zone}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def update_sdn_vnet(self, vnet: str, **kwargs) -> Dict:
|
||
"""
|
||
Update an existing SDN VNet.
|
||
|
||
Args:
|
||
vnet: VNet name to update
|
||
**kwargs: Fields to update (alias, tag, vlanaware, etc.)
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
self.proxmox.cluster.sdn.vnets(vnet).put(**kwargs)
|
||
logger.info(f"Updated SDN vnet: {vnet}")
|
||
return {"success": True, "vnet": vnet}
|
||
except Exception as e:
|
||
logger.error(f"Error updating SDN vnet {vnet}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def get_node_networks(self, node: str) -> List[Dict]:
|
||
"""
|
||
Get all network interfaces configured on a node.
|
||
|
||
Args:
|
||
node: Node name
|
||
|
||
Returns:
|
||
List of network interface objects
|
||
"""
|
||
if not self.proxmox:
|
||
return []
|
||
|
||
try:
|
||
ifaces = self.proxmox.nodes(node).network.get()
|
||
return ifaces if isinstance(ifaces, list) else []
|
||
except Exception as e:
|
||
logger.error(f"Error getting node {node} networks: {e}")
|
||
return []
|
||
|
||
def get_node_network(self, node: str, iface: str) -> Optional[Dict]:
|
||
"""
|
||
Get details of a specific network interface on a node.
|
||
|
||
Args:
|
||
node: Node name
|
||
iface: Interface name (e.g., vmbr0, bond0)
|
||
|
||
Returns:
|
||
Interface configuration dict or None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
return self.proxmox.nodes(node).network(iface).get()
|
||
except Exception as e:
|
||
logger.error(f"Error getting node {node} interface {iface}: {e}")
|
||
return None
|
||
|
||
def create_node_network(self, node: str, iface_type: str, **kwargs) -> Dict:
|
||
"""
|
||
Create a new network interface on a node.
|
||
|
||
Args:
|
||
node: Node name
|
||
iface_type: Type of interface ('bridge', 'bond', 'vlan', 'eth')
|
||
**kwargs: Interface parameters (iface, address, netmask, gateway,
|
||
bridge_ports, bond_slaves, bond_mode, vlan-id,
|
||
vlan-raw-device, autostart, comments, etc.)
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
params = {"type": iface_type}
|
||
params.update(kwargs)
|
||
self.proxmox.nodes(node).network.post(**params)
|
||
iface_name = kwargs.get("iface", "")
|
||
logger.info(f"Created {iface_type} interface {iface_name} on node {node}")
|
||
return {"success": True, "iface": iface_name}
|
||
except Exception as e:
|
||
logger.error(f"Error creating {iface_type} interface on node {node}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def update_node_network(self, node: str, iface: str, **kwargs) -> Dict:
|
||
"""
|
||
Update a network interface on a node.
|
||
|
||
Args:
|
||
node: Node name
|
||
iface: Interface name to update
|
||
**kwargs: Fields to update
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
self.proxmox.nodes(node).network(iface).put(**kwargs)
|
||
logger.info(f"Updated interface {iface} on node {node}")
|
||
return {"success": True, "iface": iface}
|
||
except Exception as e:
|
||
logger.error(f"Error updating interface {iface} on node {node}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def delete_node_network(self, node: str, iface: str) -> Dict:
|
||
"""
|
||
Delete a network interface from a node.
|
||
|
||
Args:
|
||
node: Node name
|
||
iface: Interface name to delete
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
self.proxmox.nodes(node).network(iface).delete()
|
||
logger.info(f"Deleted interface {iface} from node {node}")
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error deleting interface {iface} from node {node}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def apply_node_network_config(self, node: str) -> Dict:
|
||
"""
|
||
Apply pending network configuration changes on a node.
|
||
|
||
Args:
|
||
node: Node name
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
result = self.proxmox.nodes(node).network.put()
|
||
logger.info(f"Applied network config on node {node}")
|
||
return {"success": True, "result": result}
|
||
except Exception as e:
|
||
logger.error(f"Error applying network config on node {node}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def revert_node_network_config(self, node: str) -> Dict:
|
||
"""
|
||
Revert pending network configuration changes on a node (restore from running config).
|
||
|
||
Args:
|
||
node: Node name
|
||
|
||
Returns:
|
||
Result dict with success status
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
|
||
try:
|
||
self.proxmox.nodes(node).network.delete()
|
||
logger.info(f"Reverted network config on node {node}")
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error reverting network config on node {node}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def get_snapshot_config(self, node: str, vmid: int, snapname: str, vm_type: str = 'qemu') -> Optional[Dict]:
|
||
"""
|
||
Get configuration of a snapshot.
|
||
|
||
Args:
|
||
node: Node name
|
||
vmid: VM/Container ID
|
||
snapname: Snapshot name
|
||
vm_type: 'qemu' for VMs, 'lxc' for containers
|
||
|
||
Returns:
|
||
Snapshot configuration dict or None
|
||
"""
|
||
if not self.proxmox:
|
||
return None
|
||
|
||
try:
|
||
if vm_type == 'qemu':
|
||
config = self.proxmox.nodes(node).qemu(vmid).snapshot(snapname).config.get()
|
||
else:
|
||
config = self.proxmox.nodes(node).lxc(vmid).snapshot(snapname).config.get()
|
||
return config
|
||
except Exception as e:
|
||
logger.error(f"Error getting snapshot {snapname} config: {e}")
|
||
return None
|
||
|
||
def get_cluster_storages(self) -> List[Dict]:
|
||
"""Get all storages configured on this Proxmox cluster"""
|
||
if not self.proxmox:
|
||
return []
|
||
try:
|
||
storages = self.proxmox.storage.get()
|
||
return storages
|
||
except Exception as e:
|
||
logger.error(f"Error getting storages from {self.host}: {e}")
|
||
return []
|
||
|
||
def create_storage(self, storage_id: str, storage_type: str, **kwargs) -> Dict:
|
||
"""Create a new storage configuration"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
try:
|
||
self.proxmox.storage.post(storage=storage_id, type=storage_type, **kwargs)
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error creating storage {storage_id}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def update_storage(self, storage_id: str, **kwargs) -> Dict:
|
||
"""Update storage configuration"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
try:
|
||
self.proxmox.storage(storage_id).put(**kwargs)
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error updating storage {storage_id}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def delete_storage(self, storage_id: str) -> Dict:
|
||
"""Delete storage configuration"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
try:
|
||
self.proxmox.storage(storage_id).delete()
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error deleting storage {storage_id}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def list_backups(self, node: str, storage: str, vmid: int = None) -> List[Dict]:
|
||
"""List backup files in a storage on a node"""
|
||
if not self.proxmox:
|
||
return []
|
||
try:
|
||
params = {"content": "backup"}
|
||
if vmid:
|
||
params["vmid"] = vmid
|
||
items = self.proxmox.nodes(node).storage(storage).content.get(**params)
|
||
return items
|
||
except Exception as e:
|
||
logger.error(f"Error listing backups on {node}/{storage}: {e}")
|
||
return []
|
||
|
||
def create_backup(self, node: str, vmid: int, storage: str,
|
||
mode: str = "snapshot", compress: str = "zstd",
|
||
remove: int = 1, keep_last: int = None, notes: str = None) -> Dict:
|
||
"""
|
||
Trigger vzdump backup for a VM/container.
|
||
Returns {"success": True, "upid": "..."} or {"success": False, "error": "..."}
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
try:
|
||
params = {
|
||
"vmid": vmid,
|
||
"storage": storage,
|
||
"mode": mode,
|
||
"compress": compress,
|
||
"remove": int(bool(remove)),
|
||
}
|
||
if keep_last and int(keep_last) > 0:
|
||
params["prune-backups"] = f"keep-last={int(keep_last)}"
|
||
if notes:
|
||
params["notes-template"] = notes
|
||
upid = self.proxmox.nodes(node).vzdump.post(**params)
|
||
return {"success": True, "upid": upid}
|
||
except Exception as e:
|
||
logger.error(f"Error creating backup for VM {vmid} on {node}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def restore_vm(self, node: str, vmid: int, archive: str, storage: str = None,
|
||
new_vmid: int = None, start: bool = False, unique: bool = True,
|
||
force: bool = False) -> Dict:
|
||
"""
|
||
Restore a QEMU VM from backup.
|
||
archive: volume id like 'local:backup/vzdump-qemu-100-...'
|
||
storage: TARGET storage for the restored disks. When empty/None, Proxmox
|
||
restores each disk to the storage recorded in the backup config
|
||
("from backup configuration"). The backup source is encoded in
|
||
`archive`, so this must NOT be the backup storage.
|
||
force: overwrite an existing VM with the same vmid (must be stopped).
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
try:
|
||
# For QEMU, restore is triggered by passing `archive` to POST /nodes/{node}/qemu.
|
||
# There is NO `restore` parameter (unlike LXC) — sending it returns a 400.
|
||
params = {
|
||
"vmid": new_vmid if new_vmid else vmid,
|
||
"archive": archive,
|
||
"start": 1 if start else 0,
|
||
"unique": 1 if unique else 0,
|
||
}
|
||
if storage:
|
||
params["storage"] = storage
|
||
if force:
|
||
params["force"] = 1
|
||
upid = self.proxmox.nodes(node).qemu.post(**params)
|
||
return {"success": True, "upid": upid}
|
||
except Exception as e:
|
||
logger.error(f"Error restoring VM {vmid} on {node}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def restore_lxc(self, node: str, vmid: int, archive: str, storage: str = None,
|
||
new_vmid: int = None, start: bool = False,
|
||
force: bool = False) -> Dict:
|
||
"""Restore an LXC container from backup.
|
||
|
||
storage: TARGET storage for the restored rootfs. When empty/None, Proxmox
|
||
restores to the storage recorded in the backup config. The backup
|
||
source is encoded in `archive`, so this must NOT be the backup storage.
|
||
force: overwrite an existing container with the same vmid (must be stopped).
|
||
"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
try:
|
||
params = {
|
||
"vmid": new_vmid if new_vmid else vmid,
|
||
"ostemplate": archive,
|
||
"restore": 1,
|
||
"start": 1 if start else 0,
|
||
}
|
||
if storage:
|
||
params["storage"] = storage
|
||
if force:
|
||
params["force"] = 1
|
||
upid = self.proxmox.nodes(node).lxc.post(**params)
|
||
return {"success": True, "upid": upid}
|
||
except Exception as e:
|
||
logger.error(f"Error restoring LXC {vmid} on {node}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def delete_backup(self, node: str, storage: str, volid: str) -> Dict:
|
||
"""Delete a specific backup file by its volume ID"""
|
||
if not self.proxmox:
|
||
return {"success": False, "error": "Not connected"}
|
||
try:
|
||
self.proxmox.nodes(node).storage(storage).content(volid).delete()
|
||
return {"success": True}
|
||
except Exception as e:
|
||
logger.error(f"Error deleting backup {volid}: {e}")
|
||
return {"success": False, "error": str(e)}
|
||
|
||
def get_cluster_backup_jobs(self) -> List[Dict]:
|
||
"""Fetch native vzdump backup jobs configured in Proxmox (cluster/backup)"""
|
||
if not self.proxmox:
|
||
return []
|
||
try:
|
||
jobs = self.proxmox.cluster.backup.get()
|
||
return jobs if isinstance(jobs, list) else []
|
||
except Exception as e:
|
||
logger.error(f"Error fetching cluster backup jobs: {e}")
|
||
return []
|
||
|