markmorado/pvemanager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

feat(vm-ops): make reinstall/clone/change-password async via DeployTask

Browse Source 
Backend:
- Add DeployTask.kind column ('deploy'|'reinstall'|'clone'|'change_password')
  + Migration 23: ALTER TABLE deploy_tasks ADD kind, drop NOT NULL on template_id
- Update DeployTask.to_dict() with kind-aware Russian descriptions
- New backend/app/api/proxmox/async_ops.py with three workers:
    _do_reinstall_sync, _do_clone_sync, _do_change_password_sync
  All run on shared _deploy_executor thread pool from templates.py and
  report progress through _update_deploy_task (DB + WebSocket broadcast)
- Rewrite five vms.py endpoints to return 202 + DeployTaskStartResponse:
    POST /vm/{vmid}/clone, /container/{vmid}/clone,
    POST /vm/{vmid}/reinstall,
    POST /vm/{vmid}/change-password, /container/{vmid}/change-password

Frontend:
- DeployTask: add 'kind' and 'server_id' fields
- useCloneInstance/useReinstallInstance/useChangePassword now return
  AsyncTaskResponse {task_id, status, name}; remove invalidateQueries
- InstanceActionDialogs: each onSuccess pushes task to deploy-tasks-store
  with appropriate kind, shows 'launched in background' toast
- InstancesPage:
  * ghostRows only for kind in {deploy, clone}, deduped by (server_id, vmid)
  * reinstall / change_password tasks shown as inline overlay (badge + ring)
    on the existing VM row's status column
This commit is contained in:
markmorado
2026-04-30 00:08:41 +02:00
parent 89d70654fc
commit 79d6864d43
9 changed files with 578 additions and 207 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
backend/app/api/proxmox/async_ops.py Normal file
View File

@@ -0,0 +1,329 @@
"""
Async background workers for VM/LXC operations: reinstall, clone, change_password.
These run in the same `_deploy_executor` thread pool used by deploy, and report
progress through DeployTask records (with `kind` field) + WebSocket broadcast.
"""
from __future__ import annotations
import time
from typing import Optional
from loguru import logger
from ...db import SessionLocal
from ...models import ProxmoxServer, VMInstance, OSTemplate, DeployTask, User
from ...proxmox_client import ProxmoxClient
from ...logging_service import LoggingService
from ._helpers import _get_proxmox_client, get_next_vmid
# Re-use deploy executor and update helper
from ..templates import _deploy_executor, _update_deploy_task # noqa: F401
def _connect(server: ProxmoxServer) -> Optional[ProxmoxClient]:
"""Return connected ProxmoxClient or None."""
client = _get_proxmox_client(server)
return client if client.is_connected() else None
# ==================== Reinstall ====================
def _do_reinstall_sync(task_id: int, server_id: int, vmid: int, node: str,
user_id: int, username: str):
"""Re-create VM/LXC from its saved template under the same VMID."""
db = SessionLocal()
server = None
is_lxc = False
try:
_update_deploy_task(task_id, 'running', 'Подготовка...', 5, vmid=vmid, node=node)
server = db.query(ProxmoxServer).filter(ProxmoxServer.id == server_id).first()
if not server:
_update_deploy_task(task_id, 'failed', 'Сервер не найден', 0, error='Proxmox сервер не найден')
return
cached = db.query(VMInstance).filter(
VMInstance.server_id == server_id,
VMInstance.vmid == vmid,
VMInstance.deleted_at.is_(None),
).first()
if not cached or not cached.template_id:
_update_deploy_task(task_id, 'failed', 'Шаблон не привязан', 0,
error='У VM не сохранён шаблон, переустановка недоступна')
return
tpl = db.query(OSTemplate).filter(OSTemplate.id == cached.template_id).first()
if not tpl or not tpl.vmid:
_update_deploy_task(task_id, 'failed', 'Шаблон не найден', 0, error='Шаблон не найден или некорректен')
return
# Resolve template VMID & source node (cross-node aware)
local_template_vmid = tpl.get_vmid_for_node(node)
if local_template_vmid:
template_source_node = node
template_vmid = local_template_vmid
else:
template_source_node = tpl.get_source_node() or tpl.node or node
template_vmid = tpl.vmid
name = cached.name
cores = cached.cores
memory = cached.memory
description = cached.description
is_lxc = (cached.vm_type == 'lxc')
memory_mb = int(memory) // (1024 * 1024) if memory else None
_update_deploy_task(task_id, 'running', 'Подключение к Proxmox...', 10, vmid=vmid, node=node)
client = _connect(server)
if not client:
_update_deploy_task(task_id, 'failed', 'Ошибка подключения к Proxmox', 10,
error='Не удалось подключиться к Proxmox серверу')
return
# 1) Stop
_update_deploy_task(task_id, 'running', 'Остановка инстанса...', 20, vmid=vmid, node=node)
try:
if is_lxc:
client.stop_container(node, vmid, force=False)
else:
client.stop_vm(node, vmid, force=False)
except Exception:
pass
for _ in range(20):
try:
st = client.get_container_status(node, vmid) if is_lxc else client.get_vm_status(node, vmid)
if not st or st.get('status') != 'running':
break
except Exception:
break
time.sleep(0.5)
# 2) Delete
_update_deploy_task(task_id, 'running', 'Удаление старого инстанса...', 35, vmid=vmid, node=node)
try:
if is_lxc:
client.delete_container(node, vmid, force=False)
else:
client.delete_vm(node, vmid, force=False)
except Exception as e:
_update_deploy_task(task_id, 'failed', 'Ошибка удаления', 35, error=f'Не удалось удалить инстанс: {e}')
return
for _ in range(30):
st = client.get_container_status(node, vmid) if is_lxc else client.get_vm_status(node, vmid)
if not st:
break
time.sleep(1)
# 3) Clone from template
_update_deploy_task(task_id, 'running', f'Клонирование из шаблона {tpl.name}...', 50, vmid=vmid, node=node)
try:
if is_lxc:
upid = client.clone_container(
node=template_source_node, vmid=template_vmid, new_vmid=vmid,
hostname=name, full=True, target_node=node,
description=description,
)
else:
upid = client.clone_vm(
node=template_source_node, vmid=template_vmid, new_vmid=vmid,
name=name, full=True, target_node=node,
description=description,
)
except Exception as e:
_update_deploy_task(task_id, 'failed', 'Ошибка клонирования', 50, error=f'Clone failed: {e}')
return
if not upid:
_update_deploy_task(task_id, 'failed', 'Ошибка клонирования', 50,
error='Proxmox не вернул UPID задачи клонирования')
return
_update_deploy_task(task_id, 'running', 'Ожидание завершения клонирования...', 75, vmid=vmid, node=node)
try:
client.wait_for_task(template_source_node, upid, timeout=600)
except Exception:
pass
# 4) Re-apply config
_update_deploy_task(task_id, 'running', 'Применение конфигурации...', 90, vmid=vmid, node=node)
try:
cfg = {}
if cores:
cfg['cores'] = cores
if memory_mb:
cfg['memory'] = memory_mb
if cfg:
if is_lxc:
client.update_container_config(node, vmid, cfg)
else:
client.update_vm_config(node, vmid, cfg)
except Exception as _ce:
logger.warning(f"[REINSTALL #{task_id}] re-apply config failed: {_ce}")
LoggingService.log_proxmox_action(
db=db, action='reinstall',
resource_type='lxc' if is_lxc else 'vm', resource_id=vmid,
username=username, resource_name=name,
server_id=server_id, server_name=server.name, node_name=node,
details={'template_id': tpl.id, 'template_vmid': template_vmid}, success=True,
)
_update_deploy_task(task_id, 'completed', 'Переустановка завершена', 100, vmid=vmid, node=node)
logger.info(f"[REINSTALL #{task_id}] vmid={vmid} reinstalled by {username}")
except Exception as e:
err = str(e)
logger.error(f"[REINSTALL #{task_id}] failed: {err}")
try:
if server is not None:
LoggingService.log_proxmox_action(
db=db, action='reinstall',
resource_type='lxc' if is_lxc else 'vm', resource_id=vmid,
username=username, server_id=server_id,
server_name=server.name, node_name=node,
success=False, error_message=err,
)
except Exception:
pass
_update_deploy_task(task_id, 'failed', f'Ошибка: {err[:150]}', 0, error=err)
finally:
db.close()
# ==================== Clone ====================
def _do_clone_sync(task_id: int, server_id: int, src_vmid: int, node: str, vm_type: str,
new_name: str, full: bool, target_node: Optional[str],
target_storage: Optional[str], description: Optional[str],
user_id: int, username: str):
"""Clone existing VM/LXC into a new VMID."""
db = SessionLocal()
server = None
is_lxc = (vm_type == 'lxc')
new_vmid: Optional[int] = None
try:
_update_deploy_task(task_id, 'running', 'Подключение к Proxmox...', 10, node=node)
server = db.query(ProxmoxServer).filter(ProxmoxServer.id == server_id).first()
if not server:
_update_deploy_task(task_id, 'failed', 'Сервер не найден', 0, error='Proxmox сервер не найден')
return
client = _connect(server)
if not client:
_update_deploy_task(task_id, 'failed', 'Ошибка подключения к Proxmox', 10,
error='Не удалось подключиться к Proxmox серверу')
return
_update_deploy_task(task_id, 'running', 'Аллокация VMID...', 30, node=node)
new_vmid = client.get_next_vmid() or get_next_vmid(db, server_id)
if not new_vmid:
_update_deploy_task(task_id, 'failed', 'Не удалось выделить VMID', 30, error='Failed to allocate new VMID')
return
_update_deploy_task(task_id, 'running', f'Клонирование → VMID {new_vmid}...', 50,
vmid=new_vmid, node=target_node or node)
try:
if is_lxc:
upid = client.clone_container(
node=node, vmid=src_vmid, new_vmid=new_vmid, hostname=new_name,
full=full, target_node=target_node,
target_storage=target_storage, description=description,
)
else:
upid = client.clone_vm(
node=node, vmid=src_vmid, new_vmid=new_vmid, name=new_name,
full=full, target_node=target_node,
target_storage=target_storage, description=description,
)
except Exception as e:
_update_deploy_task(task_id, 'failed', 'Ошибка клонирования', 50, error=f'Clone failed: {e}')
return
if not upid:
_update_deploy_task(task_id, 'failed', 'Ошибка клонирования', 50, error='Proxmox не вернул UPID')
return
_update_deploy_task(task_id, 'running', 'Ожидание завершения клонирования...', 70,
vmid=new_vmid, node=target_node or node)
try:
client.wait_for_task(node, upid, timeout=600)
except Exception:
pass
LoggingService.log_proxmox_action(
db=db, action='clone',
resource_type='lxc' if is_lxc else 'vm', resource_id=src_vmid,
username=username, server_id=server_id,
server_name=server.name, node_name=node,
details={'new_vmid': new_vmid, 'name': new_name}, success=True,
)
_update_deploy_task(task_id, 'completed', f'Клонирование завершено (VMID {new_vmid})', 100,
vmid=new_vmid, node=target_node or node)
logger.info(f"[CLONE #{task_id}] {src_vmid} -> {new_vmid} ({new_name}) by {username}")
except Exception as e:
err = str(e)
logger.error(f"[CLONE #{task_id}] failed: {err}")
_update_deploy_task(task_id, 'failed', f'Ошибка: {err[:150]}', 0, error=err)
finally:
db.close()
# ==================== Change Password ====================
def _do_change_password_sync(task_id: int, server_id: int, vmid: int, node: str, vm_type: str,
target_username: str, password: str,
user_id: int, username: str):
"""Change password inside VM (qemu-guest-agent) or LXC (pct exec)."""
db = SessionLocal()
server = None
is_lxc = (vm_type == 'lxc')
try:
_update_deploy_task(task_id, 'running', 'Подключение к Proxmox...', 30, vmid=vmid, node=node)
server = db.query(ProxmoxServer).filter(ProxmoxServer.id == server_id).first()
if not server:
_update_deploy_task(task_id, 'failed', 'Сервер не найден', 0, error='Proxmox сервер не найден')
return
client = _connect(server)
if not client:
_update_deploy_task(task_id, 'failed', 'Ошибка подключения к Proxmox', 30,
error='Не удалось подключиться к Proxmox серверу')
return
_update_deploy_task(task_id, 'running', f'Смена пароля для {target_username}...', 60,
vmid=vmid, node=node)
if is_lxc:
res = client.change_container_password(node, vmid, target_username, password)
else:
res = client.change_vm_password(node, vmid, target_username, password)
if not res.get('success'):
err = res.get('error') or 'Failed to change password'
_update_deploy_task(task_id, 'failed', 'Ошибка смены пароля', 60, error=err)
try:
LoggingService.log_proxmox_action(
db=db, action='change-password',
resource_type='lxc' if is_lxc else 'vm', resource_id=vmid,
username=username, server_id=server_id,
server_name=server.name, node_name=node,
details={'target_user': target_username}, success=False, error_message=err,
)
except Exception:
pass
return
LoggingService.log_proxmox_action(
db=db, action='change-password',
resource_type='lxc' if is_lxc else 'vm', resource_id=vmid,
username=username, server_id=server_id,
server_name=server.name, node_name=node,
details={'target_user': target_username}, success=True,
)
_update_deploy_task(task_id, 'completed', 'Пароль успешно изменён', 100, vmid=vmid, node=node)
logger.info(f"[CHPASS #{task_id}] vmid={vmid} target_user={target_username} by {username}")
except Exception as e:
err = str(e)
logger.error(f"[CHPASS #{task_id}] failed: {err}")
_update_deploy_task(task_id, 'failed', f'Ошибка: {err[:150]}', 0, error=err)
finally:
db.close()

289
backend/app/api/proxmox/vms.py
View File

@@ -324,7 +324,7 @@ def _get_client_or_503(server: ProxmoxServer):
# -------- Clone --------
@router.post("/api/{server_id}/vm/{vmid}/clone")
@router.post("/api/{server_id}/vm/{vmid}/clone", status_code=202)
def clone_vm_endpoint(
server_id: int,
vmid: int,
@@ -333,39 +333,29 @@ def clone_vm_endpoint(
db: Session = Depends(get_db),
current_user: User = Depends(PermissionChecker("vms.create"))
):
"""Клонировать существующую VM (qemu)."""
"""Клонировать существующую VM (qemu) — фоновая задача."""
from ...models import DeployTask
from ..templates import _deploy_executor, DeployTaskStartResponse
from .async_ops import _do_clone_sync
require_vm_access(db, current_user, server_id, vmid)
server = _resolve_server(db, server_id)
client = _get_client_or_503(server)
new_vmid = client.get_next_vmid() or get_next_vmid(db, server_id)
if not new_vmid:
raise HTTPException(status_code=500, detail="Failed to allocate new VMID")
upid = client.clone_vm(
node=node, vmid=vmid, new_vmid=new_vmid, name=body.new_name,
full=body.full, target_node=body.target_node,
target_storage=body.target_storage, description=body.description,
_resolve_server(db, server_id)
task = DeployTask(
kind='clone', name=body.new_name, status='pending', step='В очереди...', progress=0,
template_id=None, server_id=server_id, user_id=current_user.id, node=node,
)
if not upid:
raise HTTPException(status_code=500, detail="Clone failed")
try:
ProxmoxTaskService.register(
db=db, upid=upid, server_id=server_id,
user_id=current_user.id, action='clone',
node=node, vmid=vmid, vm_type='qemu',
description=f"Клонирование VM {vmid} -> {new_vmid} ({body.new_name})",
)
except Exception as _te:
logger.warning(f"Failed to register clone task: {_te}")
LoggingService.log_proxmox_action(
db=db, action='clone', resource_type='vm', resource_id=vmid,
username=current_user.username, server_id=server_id,
server_name=server.name, node_name=node,
details={'new_vmid': new_vmid, 'name': body.new_name}, success=True,
db.add(task); db.commit(); db.refresh(task)
_deploy_executor.submit(
_do_clone_sync, task.id, server_id, vmid, node, 'qemu',
body.new_name, body.full, body.target_node, body.target_storage, body.description,
current_user.id, current_user.username,
)
return {"status": "success", "new_vmid": new_vmid, "upid": upid}
return DeployTaskStartResponse(task_id=task.id, status='pending', name=body.new_name)
@router.post("/api/{server_id}/container/{vmid}/clone")
@router.post("/api/{server_id}/container/{vmid}/clone", status_code=202)
def clone_container_endpoint(
server_id: int,
vmid: int,
@@ -374,35 +364,31 @@ def clone_container_endpoint(
db: Session = Depends(get_db),
current_user: User = Depends(PermissionChecker("vms.create"))
):
"""Клонировать существующий LXC контейнер."""
"""Клонировать существующий LXC контейнер — фоновая задача."""
from ...models import DeployTask
from ..templates import _deploy_executor, DeployTaskStartResponse
from .async_ops import _do_clone_sync
require_vm_access(db, current_user, server_id, vmid)
server = _resolve_server(db, server_id)
client = _get_client_or_503(server)
new_vmid = client.get_next_vmid() or get_next_vmid(db, server_id)
if not new_vmid:
raise HTTPException(status_code=500, detail="Failed to allocate new VMID")
upid = client.clone_container(
node=node, vmid=vmid, new_vmid=new_vmid, hostname=body.new_name,
full=body.full, target_node=body.target_node,
target_storage=body.target_storage, description=body.description,
_resolve_server(db, server_id)
task = DeployTask(
kind='clone', name=body.new_name, status='pending', step='В очереди...', progress=0,
template_id=None, server_id=server_id, user_id=current_user.id, node=node,
)
if not upid:
raise HTTPException(status_code=500, detail="Clone failed")
try:
ProxmoxTaskService.register(
db=db, upid=upid, server_id=server_id,
user_id=current_user.id, action='clone',
node=node, vmid=vmid, vm_type='lxc',
description=f"Клонирование LXC {vmid} -> {new_vmid} ({body.new_name})",
)
except Exception as _te:
logger.warning(f"Failed to register clone task: {_te}")
return {"status": "success", "new_vmid": new_vmid, "upid": upid}
db.add(task); db.commit(); db.refresh(task)
_deploy_executor.submit(
_do_clone_sync, task.id, server_id, vmid, node, 'lxc',
body.new_name, body.full, body.target_node, body.target_storage, body.description,
current_user.id, current_user.username,
)
return DeployTaskStartResponse(task_id=task.id, status='pending', name=body.new_name)
# -------- Reinstall (re-clone from saved template) --------
@router.post("/api/{server_id}/vm/{vmid}/reinstall")
@router.post("/api/{server_id}/vm/{vmid}/reinstall", status_code=202)
def reinstall_vm_endpoint(
server_id: int,
vmid: int,
@@ -410,10 +396,13 @@ def reinstall_vm_endpoint(
db: Session = Depends(get_db),
current_user: User = Depends(PermissionChecker("vms.delete"))
):
"""Переустановить VM/LXC, пересоздав её из исходного шаблона."""
"""Переустановить VM/LXC из исходного шаблона — фоновая задача."""
from ...models import DeployTask, OSTemplate
from ..templates import _deploy_executor, DeployTaskStartResponse
from .async_ops import _do_reinstall_sync
require_vm_access(db, current_user, server_id, vmid)
server = _resolve_server(db, server_id)
client = _get_client_or_503(server)
_resolve_server(db, server_id)
cached = db.query(VMInstance).filter(
VMInstance.server_id == server_id,
@@ -423,117 +412,27 @@ def reinstall_vm_endpoint(
if not cached or not cached.template_id:
raise HTTPException(status_code=400, detail="VM has no associated template; reinstall is not available")
from ...models import OSTemplate
tpl = db.query(OSTemplate).filter(OSTemplate.id == cached.template_id).first()
if not tpl or not tpl.vmid:
raise HTTPException(status_code=400, detail="Template not found or invalid")
# Resolve template VMID and source node (with cross-node replication support)
local_template_vmid = tpl.get_vmid_for_node(node)
if local_template_vmid:
template_source_node = node
template_vmid = local_template_vmid
else:
template_source_node = tpl.get_source_node() or tpl.node or node
template_vmid = tpl.vmid
if not template_vmid:
raise HTTPException(status_code=400, detail="Template VMID is not available for this node")
name = cached.name
cores = cached.cores
memory = cached.memory
description = cached.description
is_lxc = (cached.vm_type == 'lxc')
# VMInstance.memory is stored in bytes; Proxmox expects MB
memory_mb = int(memory) // (1024 * 1024) if memory else None
# 1) stop
try:
if is_lxc:
client.stop_container(node, vmid, force=False)
else:
client.stop_vm(node, vmid, force=False)
except Exception:
pass
import time as _t
for _ in range(20):
try:
st = client.get_container_status(node, vmid) if is_lxc else client.get_vm_status(node, vmid)
if not st or st.get('status') != 'running':
break
except Exception:
break
_t.sleep(0.5)
# 2) delete
try:
if is_lxc:
client.delete_container(node, vmid, force=False)
else:
client.delete_vm(node, vmid, force=False)
except Exception as e:
raise HTTPException(status_code=500, detail=f"Failed to delete instance: {e}")
for _ in range(30):
st = client.get_container_status(node, vmid) if is_lxc else client.get_vm_status(node, vmid)
if not st:
break
_t.sleep(1)
# 3) clone from template under same vmid
try:
if is_lxc:
upid = client.clone_container(
node=template_source_node, vmid=template_vmid, new_vmid=vmid,
hostname=name, full=True, target_node=node,
description=description,
)
else:
upid = client.clone_vm(
node=template_source_node, vmid=template_vmid, new_vmid=vmid,
name=name, full=True, target_node=node,
description=description,
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"Clone failed: {e}")
if not upid:
raise HTTPException(status_code=500, detail="Clone failed")
try:
client.wait_for_task(node, upid, timeout=600)
except Exception:
pass
# 4) Re-apply config
try:
if is_lxc:
cfg = {}
if cores: cfg['cores'] = cores
if memory_mb: cfg['memory'] = memory_mb
if cfg:
client.update_container_config(node, vmid, cfg)
else:
cfg = {}
if cores: cfg['cores'] = cores
if memory_mb: cfg['memory'] = memory_mb
if cfg:
client.update_vm_config(node, vmid, cfg)
except Exception as _ce:
logger.warning(f"Failed to re-apply config after reinstall: {_ce}")
LoggingService.log_proxmox_action(
db=db, action='reinstall',
resource_type='lxc' if is_lxc else 'vm', resource_id=vmid,
username=current_user.username, resource_name=name,
server_id=server_id, server_name=server.name, node_name=node,
details={'template_id': tpl.id, 'template_vmid': template_vmid},
success=True,
task = DeployTask(
kind='reinstall', name=cached.name, status='pending', step='В очереди...', progress=0,
template_id=tpl.id, server_id=server_id, user_id=current_user.id,
vmid=vmid, node=node,
)
return {"status": "success", "vmid": vmid, "upid": upid}
db.add(task); db.commit(); db.refresh(task)
_deploy_executor.submit(
_do_reinstall_sync, task.id, server_id, vmid, node,
current_user.id, current_user.username,
)
return DeployTaskStartResponse(task_id=task.id, status='pending', name=cached.name)
# -------- Change Password --------
@router.post("/api/{server_id}/vm/{vmid}/change-password")
@router.post("/api/{server_id}/vm/{vmid}/change-password", status_code=202)
def change_vm_password_endpoint(
server_id: int,
vmid: int,
@@ -542,25 +441,38 @@ def change_vm_password_endpoint(
db: Session = Depends(get_db),
current_user: User = Depends(PermissionChecker("vms.console"))
):
"""Сменить пароль пользователя на VM через QEMU guest agent."""
"""Сменить пароль на VM через QEMU guest agent — фоновая задача."""
from ...models import DeployTask
from ..templates import _deploy_executor, DeployTaskStartResponse
from .async_ops import _do_change_password_sync
require_vm_access(db, current_user, server_id, vmid)
server = _resolve_server(db, server_id)
client = _get_client_or_503(server)
_resolve_server(db, server_id)
if not body.password or len(body.password) < 4:
raise HTTPException(status_code=400, detail="Password too short")
res = client.change_vm_password(node, vmid, body.username, body.password)
if not res.get('success'):
raise HTTPException(status_code=500, detail=res.get('error') or 'Failed to change password')
LoggingService.log_proxmox_action(
db=db, action='change-password', resource_type='vm', resource_id=vmid,
username=current_user.username, server_id=server_id,
server_name=server.name, node_name=node,
details={'target_user': body.username}, success=True,
cached = db.query(VMInstance).filter(
VMInstance.server_id == server_id,
VMInstance.vmid == vmid,
VMInstance.deleted_at.is_(None),
).first()
name = cached.name if cached else f"VM {vmid}"
task = DeployTask(
kind='change_password', name=name, status='pending', step='В очереди...', progress=0,
template_id=None, server_id=server_id, user_id=current_user.id,
vmid=vmid, node=node,
)
return {"status": "success"}
db.add(task); db.commit(); db.refresh(task)
_deploy_executor.submit(
_do_change_password_sync, task.id, server_id, vmid, node, 'qemu',
body.username, body.password, current_user.id, current_user.username,
)
return DeployTaskStartResponse(task_id=task.id, status='pending', name=name)
@router.post("/api/{server_id}/container/{vmid}/change-password")
@router.post("/api/{server_id}/container/{vmid}/change-password", status_code=202)
def change_container_password_endpoint(
server_id: int,
vmid: int,
@@ -569,22 +481,35 @@ def change_container_password_endpoint(
db: Session = Depends(get_db),
current_user: User = Depends(PermissionChecker("vms.console"))
):
"""Сменить пароль пользователя в LXC через pct exec/chpasswd."""
"""Сменить пароль в LXC через pct exec/chpasswd — фоновая задача."""
from ...models import DeployTask
from ..templates import _deploy_executor, DeployTaskStartResponse
from .async_ops import _do_change_password_sync
require_vm_access(db, current_user, server_id, vmid)
server = _resolve_server(db, server_id)
client = _get_client_or_503(server)
_resolve_server(db, server_id)
if not body.password or len(body.password) < 4:
raise HTTPException(status_code=400, detail="Password too short")
res = client.change_container_password(node, vmid, body.username, body.password)
if not res.get('success'):
raise HTTPException(status_code=500, detail=res.get('error') or 'Failed to change password')
LoggingService.log_proxmox_action(
db=db, action='change-password', resource_type='lxc', resource_id=vmid,
username=current_user.username, server_id=server_id,
server_name=server.name, node_name=node,
details={'target_user': body.username}, success=True,
cached = db.query(VMInstance).filter(
VMInstance.server_id == server_id,
VMInstance.vmid == vmid,
VMInstance.deleted_at.is_(None),
).first()
name = cached.name if cached else f"CT {vmid}"
task = DeployTask(
kind='change_password', name=name, status='pending', step='В очереди...', progress=0,
template_id=None, server_id=server_id, user_id=current_user.id,
vmid=vmid, node=node,
)
return {"status": "success"}
db.add(task); db.commit(); db.refresh(task)
_deploy_executor.submit(
_do_change_password_sync, task.id, server_id, vmid, node, 'lxc',
body.username, body.password, current_user.id, current_user.username,
)
return DeployTaskStartResponse(task_id=task.id, status='pending', name=name)
# ==================== Generic VM/Container Action Handler ====================

1
backend/app/api/templates.py
View File

@@ -58,6 +58,7 @@ class DeployTaskStatusResponse(BaseModel):
created_at: Optional[str]
started_at: Optional[str]
completed_at: Optional[str]
kind: Optional[str] = 'deploy'
# ==================== Template Groups CRUD ====================

18
backend/app/models.py
View File

@@ -1069,6 +1069,9 @@ class DeployTask(Base):
status = Column(String(20), nullable=False, default='pending', index=True)
# pending / running / completed / failed
# Kind of async operation: 'deploy' / 'reinstall' / 'clone' / 'change_password'
kind = Column(String(30), nullable=False, default='deploy', index=True)
# Human-readable current step
step = Column(String(200), nullable=True)
# Progress 0–100
@@ -1076,7 +1079,7 @@ class DeployTask(Base):
# Input info
name = Column(String(100), nullable=False)
template_id = Column(Integer, nullable=False)
template_id = Column(Integer, nullable=True)
server_id = Column(Integer, nullable=True)
user_id = Column(Integer, ForeignKey("users.id", ondelete="CASCADE"), nullable=False, index=True)
@@ -1095,15 +1098,22 @@ class DeployTask(Base):
)
def to_dict(self) -> dict:
kind = self.kind or 'deploy'
descriptions = {
'deploy': f"Создание {self.name}",
'reinstall': f"Переустановка {self.name}",
'clone': f"Клонирование {self.name}",
'change_password': f"Смена пароля: {self.name}",
}
return {
'id': self.id,
'kind': 'deploy',
'kind': kind,
'status': self.status,
'step': self.step,
'current_step': self.step,
'progress': self.progress,
'progress_percent': self.progress,
'description': f"Создание {self.name}",
'description': descriptions.get(kind, self.name),
'name': self.name,
'template_id': self.template_id,
'server_id': self.server_id,
@@ -1116,4 +1126,4 @@ class DeployTask(Base):
}
def __repr__(self):
return f"<DeployTask(id={self.id}, name='{self.name}', status='{self.status}')>"
return f"<DeployTask(id={self.id}, kind='{self.kind}', name='{self.name}', status='{self.status}')>"

33
backend/migrations/migrations.py
View File

@@ -1287,6 +1287,31 @@ def migrate_deploy_tasks(conn):
logger.info("✓ deploy_tasks table created")
def migrate_deploy_tasks_kind(conn):
"""Migration 23: Add 'kind' column to deploy_tasks (deploy/reinstall/clone/change_password)"""
# Check if column exists
result = conn.execute(text("""
SELECT column_name FROM information_schema.columns
WHERE table_name = 'deploy_tasks' AND column_name = 'kind'
"""))
if result.fetchone():
logger.info("✓ deploy_tasks.kind already exists")
return
conn.execute(text("""
ALTER TABLE deploy_tasks
ADD COLUMN kind VARCHAR(30) NOT NULL DEFAULT 'deploy'
"""))
conn.execute(text("""
CREATE INDEX IF NOT EXISTS idx_deploy_tasks_kind
ON deploy_tasks (kind)
"""))
# template_id may be NULL for non-deploy tasks (clone/reinstall don't always need it)
conn.execute(text("""
ALTER TABLE deploy_tasks ALTER COLUMN template_id DROP NOT NULL
"""))
logger.info("✓ deploy_tasks.kind column added")
def run_all_migrations(engine, db_session=None):
"""
Run all migrations in order.
@@ -1477,6 +1502,14 @@ def run_all_migrations(engine, db_session=None):
logger.warning(f"Deploy tasks migration: {e}")
conn.rollback()
# Migration 23: deploy_tasks.kind column
try:
migrate_deploy_tasks_kind(conn)
conn.commit()
except Exception as e:
logger.warning(f"Deploy tasks kind migration: {e}")
conn.rollback()
logger.info("=" * 50)
logger.info("✓ All migrations completed successfully")
logger.info("=" * 50)

52
frontend/src/features/instances/InstanceActionDialogs.tsx
View File

@@ -31,6 +31,7 @@ import {
useVMConfig,
} from '@/hooks/use-instances';
import { toast } from 'sonner';
import { useDeployTasksStore } from '@/stores/deploy-tasks-store';
export type InstanceAction =
| 'clone'
@@ -75,6 +76,7 @@ function CloneDialog({ open, onClose, serverId, vmid, type, node, name }: Omit<P
const [newName, setNewName] = useState('');
const [full, setFull] = useState(true);
const clone = useCloneInstance(serverId, vmid, type, node);
const addDeployTask = useDeployTasksStore((s) => s.addTask);
const submit = () => {
if (!newName.trim()) return;
@@ -82,7 +84,19 @@ function CloneDialog({ open, onClose, serverId, vmid, type, node, name }: Omit<P
{ new_name: newName.trim(), full },
{
onSuccess: (data) => {
toast.success(`Cloned to VM #${data.new_vmid}`);
addDeployTask({
id: data.task_id,
name: data.name,
status: 'pending',
step: 'В очереди...',
progress: 0,
vmid: null,
node,
error_message: null,
kind: 'clone',
server_id: serverId,
});
toast.success('Клонирование запущено в фоне');
setNewName('');
onClose();
},
@@ -125,14 +139,27 @@ function CloneDialog({ open, onClose, serverId, vmid, type, node, name }: Omit<P
function ReinstallDialog({ open, onClose, serverId, vmid, node, name, type }: Omit<Props, 'open' | 'onOpenChange'> & { open: boolean; onClose: () => void }) {
const [confirm, setConfirm] = useState('');
const reinstall = useReinstallInstance(serverId, vmid, node);
const addDeployTask = useDeployTasksStore((s) => s.addTask);
const expected = name || String(vmid);
// Reinstall via this endpoint currently supports only saved-template instances.
const submit = () => {
if (confirm !== expected) return;
reinstall.mutate(undefined, {
onSuccess: () => {
toast.success(`Reinstall queued for ${expected}`);
onSuccess: (data) => {
addDeployTask({
id: data.task_id,
name: data.name || expected,
status: 'pending',
step: 'В очереди...',
progress: 0,
vmid,
node,
error_message: null,
kind: 'reinstall',
server_id: serverId,
});
toast.success('Переустановка запущена в фоне');
setConfirm('');
onClose();
},
@@ -172,12 +199,13 @@ function ReinstallDialog({ open, onClose, serverId, vmid, node, name, type }: Om
// ==================== Change Password ====================
function ChangePasswordDialog({ open, onClose, serverId, vmid, type, node }: Omit<Props, 'open' | 'onOpenChange'> & { open: boolean; onClose: () => void }) {
function ChangePasswordDialog({ open, onClose, serverId, vmid, type, node, name }: Omit<Props, 'open' | 'onOpenChange'> & { open: boolean; onClose: () => void }) {
const { t } = useTranslation();
const [username, setUsername] = useState('root');
const [password, setPassword] = useState('');
const [show, setShow] = useState(false);
const mut = useChangePassword(serverId, vmid, type, node);
const addDeployTask = useDeployTasksStore((s) => s.addTask);
const submit = () => {
if (!password || password.length < 4) {
@@ -187,8 +215,20 @@ function ChangePasswordDialog({ open, onClose, serverId, vmid, type, node }: Omi
mut.mutate(
{ username, password },
{
onSuccess: () => {
toast.success('Password changed');
onSuccess: (data) => {
addDeployTask({
id: data.task_id,
name: data.name || (name || `#${vmid}`),
status: 'pending',
step: 'В очереди...',
progress: 0,
vmid,
node,
error_message: null,
kind: 'change_password',
server_id: serverId,
});
toast.success('Смена пароля запущена в фоне');
setPassword('');
onClose();
},

38
frontend/src/features/instances/InstancesPage.tsx
View File

@@ -261,10 +261,19 @@ export default function InstancesPage() {
});
}, [vms, typeTab, statusFilter, nodeFilter, search]);
// Ghost rows from active deploy tasks (prepended before real VMs)
// Ghost rows from active deploy/clone tasks (prepended before real VMs).
// - reinstall / change_password tasks are NOT shown as ghosts (they live as overlays on real rows)
// - clone/deploy tasks whose vmid is already present in real list are skipped (de-dupe)
const ghostRows = useMemo<VMInstance[]>(() => {
const realKey = new Set((vms ?? []).map((v) => `${v.server_id}:${v.vmid}`));
return deployTasks
.filter((t) => t.status === 'pending' || t.status === 'running')
.filter((t) => {
const k = t.kind ?? 'deploy';
if (k !== 'deploy' && k !== 'clone') return false;
if (t.vmid && t.server_id && realKey.has(`${t.server_id}:${t.vmid}`)) return false;
return true;
})
.map((t) => ({
vmid: t.vmid ?? 0,
name: t.name,
@@ -274,6 +283,19 @@ export default function InstancesPage() {
server_id: undefined,
_deployTaskId: t.id,
}));
}, [deployTasks, vms]);
// Map (server_id:vmid) -> active reinstall/change_password task (for inline overlay)
const overlayByVm = useMemo(() => {
const m = new Map<string, typeof deployTasks[number]>();
for (const t of deployTasks) {
if (t.status !== 'pending' && t.status !== 'running') continue;
const k = t.kind ?? 'deploy';
if (k !== 'reinstall' && k !== 'change_password') continue;
if (!t.vmid || !t.server_id) continue;
m.set(`${t.server_id}:${t.vmid}`, t);
}
return m;
}, [deployTasks]);
const allRows = useMemo<VMInstance[]>(() => [...ghostRows, ...filteredVMs], [ghostRows, filteredVMs]);
@@ -416,6 +438,20 @@ export default function InstancesPage() {
);
}
const status = vm.status;
const overlay = vm.server_id != null ? overlayByVm.get(`${vm.server_id}:${vm.vmid}`) : undefined;
if (overlay) {
const label = overlay.kind === 'reinstall'
? t('instances.status_reinstalling', 'Reinstalling')
: t('instances.status_changing_password', 'Changing password');
return (
<div className="flex items-center gap-2">
<CircularProgress value={overlay.progress ?? 0} />
<Badge variant="secondary" className="bg-amber-500/10 text-amber-600 text-[10px]">
{label}{(overlay.progress ?? 0) > 0 ? ` ${overlay.progress}%` : ''}
</Badge>
</div>
);
}
return (
<Badge
variant="secondary"

23
frontend/src/hooks/use-instances.ts
View File

@@ -298,36 +298,31 @@ interface CloneRequest {
description?: string;
}
export interface AsyncTaskResponse {
task_id: number;
status: string;
name: string;
}
export function useCloneInstance(serverId: number, vmid: number, type: string, node: string) {
const qc = useQueryClient();
const prefix = type === 'lxc' ? 'container' : 'vm';
return useMutation<{ status: string; new_vmid: number; upid: string }, Error, CloneRequest>({
return useMutation<AsyncTaskResponse, Error, CloneRequest>({
mutationFn: (body) =>
apiClient.post(`/proxmox/api/${serverId}/${prefix}/${vmid}/clone?node=${node}`, body),
onSuccess: () => {
qc.invalidateQueries({ queryKey: vmKeys.all });
qc.invalidateQueries({ queryKey: vmKeys.resourcesAll });
},
});
}
export function useReinstallInstance(serverId: number, vmid: number, node: string) {
const qc = useQueryClient();
return useMutation<{ status: string; vmid: number; upid: string }, Error, void>({
return useMutation<AsyncTaskResponse, Error, void>({
mutationFn: () =>
apiClient.post(`/proxmox/api/${serverId}/vm/${vmid}/reinstall?node=${node}`),
onSuccess: () => {
qc.invalidateQueries({ queryKey: vmKeys.all });
qc.invalidateQueries({ queryKey: vmKeys.config(serverId, vmid) });
qc.invalidateQueries({ queryKey: vmKeys.status(serverId, vmid) });
},
});
}
// ==================== Change Password ====================
export function useChangePassword(serverId: number, vmid: number, type: string, node: string) {
const prefix = type === 'lxc' ? 'container' : 'vm';
return useMutation<{ status: string }, Error, { username: string; password: string }>({
return useMutation<AsyncTaskResponse, Error, { username: string; password: string }>({
mutationFn: (body) =>
apiClient.post(`/proxmox/api/${serverId}/${prefix}/${vmid}/change-password?node=${node}`, body),
});

2
frontend/src/stores/deploy-tasks-store.ts
View File

@@ -11,6 +11,8 @@ export interface DeployTask {
node: string | null;
error_message: string | null;
created_at: number;
kind?: 'deploy' | 'reinstall' | 'clone' | 'change_password';
server_id?: number | null;
}
interface DeployTasksState {