AlkantarClanX12
Your IP : 3.147.71.175
import asyncio
import functools
import logging
from datetime import timezone
from typing import Callable, Dict, List, Optional
from defence360agent.contracts.config import (
ACRONIS,
ANTIVIRUS_MODE,
AcronisBackup as AcronisBackupConfig,
BackupConfig,
BackupRestore,
CLOUDLINUX,
CLOUDLINUX_ON_PREMISE,
CLUSTERLOGICS,
CPANEL,
Core,
DIRECTADMIN,
PLESK,
R1SOFT,
SAMPLE_BACKEND,
)
from defence360agent.contracts.license import LicenseCLN
from defence360agent.internals.cln import BackupNotFound, RestCLN
from defence360agent.subsys.panels.cpanel.panel import cPanel
from defence360agent.subsys.panels.directadmin.panel import DirectAdmin
from defence360agent.subsys.panels.plesk.panel import Plesk
if not ANTIVIRUS_MODE:
from restore_infected import backup_backends
from restore_infected.backup_backends.acronis import BackupFailed
from restore_infected.backup_backends_lib import (
BackendNonApplicableError,
BackendNotAuthorizedError,
)
logger = logging.getLogger(__name__)
def get_backend(name):
try:
return _get_avalible_backends(include_sample=True)[name]()
except (KeyError, BackendNonApplicableError) as e:
raise ValueError("Backup system is not available: {}".format(name))
def get_available_backends_names() -> List[str]:
names = []
# Don't list the CL Backup as available for selection
for name, cls in _get_avalible_backends(include_cl=False).items():
try:
cls()
except BackendNonApplicableError:
pass
else:
names.append(name)
return names
def _get_avalible_backends(
include_sample=False,
include_cl=True,
) -> Dict[str, Callable]:
backends = {
ACRONIS: Acronis,
R1SOFT: R1Soft,
# https://cloudlinux.atlassian.net/browse/DEF-8806
# CLUSTERLOGICS: ClusterLogics,
}
if BackupRestore.CL_BACKUP_ALLOWED and include_cl:
backends[CLOUDLINUX] = CloudLinux
if BackupRestore.CL_ON_PREMISE_BACKUP_ALLOWED:
backends[CLOUDLINUX_ON_PREMISE] = CloudLinuxOnPremise
if cPanel.is_installed():
backends[CPANEL] = cPanelBackup
elif Plesk.is_installed():
backends[PLESK] = PleskBackup
elif DirectAdmin.is_installed():
backends[DIRECTADMIN] = DirectAdminBackup
if include_sample:
backends[SAMPLE_BACKEND] = Sample
return backends
def get_current_backend() -> Optional[str]:
conf = BackupConfig().config_to_dict().get("BACKUP_SYSTEM", {})
return conf.get("enabled") and conf.get("backup_system")
async def get_last_backup_timestamp() -> Optional[int]:
backend = get_current_backend()
if not backend:
return None
backend_instance = get_backend(backend) # type: BackupSystem
return await backend_instance.get_last_backup_timestamp()
def transactional(f):
async def wrapper(cls, *args, **kwargs):
ok = False
try:
rv = await f(cls, *args, **kwargs)
ok = True
finally:
cls._update_backups_config(enabled=ok)
return rv
return wrapper
class BackupException(Exception):
pass
class BackupSystem:
def __init__(self, name, log_path=None):
self.name = name
self.log_path = log_path
def _update_backups_config(self, enabled):
new_conf = {
"BACKUP_SYSTEM": {
"enabled": enabled,
"backup_system": self.name if enabled else None,
}
}
BackupConfig().dict_to_config(new_conf, overwrite=True, validate=True)
async def init(self, *args, **kwargs):
self._update_backups_config(enabled=True)
async def disable(self, delete_backups=False):
self._update_backups_config(enabled=False)
async def check(self):
return {}
async def show(self):
return {}
async def make_backup(self):
pass
async def check_state(self) -> bool:
conf = BackupConfig().config_to_dict().get("BACKUP_SYSTEM", {})
return conf.get("enabled") and conf.get("backup_system") == self.name
async def get_last_backup_timestamp(self) -> Optional[int]:
return None
class PleskBackup(BackupSystem):
def __init__(self):
super().__init__(PLESK)
class cPanelBackup(BackupSystem):
def __init__(self):
super().__init__(CPANEL)
class DirectAdminBackup(BackupSystem):
def __init__(self):
super().__init__(DIRECTADMIN)
class R1Soft(BackupSystem):
def __init__(self):
super().__init__(R1SOFT)
self.backend = backup_backends.backend("r1soft", async_=True)
async def show(self) -> dict:
info_data = await self.backend.info()
return {
k: v
for k, v in info_data.items()
if k in ("username", "timestamp", "ip")
}
@transactional
async def init(self, ip, username, password, encryption_key, **kwargs):
await self.backend.init(ip, username, password, encryption_key)
class ClusterLogics(BackupSystem):
def __init__(self):
super().__init__(CLUSTERLOGICS)
self.backend = backup_backends.backend(CLUSTERLOGICS, async_=True)
async def show(self) -> dict:
info_data = await self.backend.info()
return {
k: v
for k, v in info_data.items()
if k in ("username", "url", "apikey")
}
@transactional
async def init(self, **kwargs):
# 'force' argument (for arconis only) has default value
# also, need to use default value for 'url',
# assigned inside backend.init
del kwargs["force"]
await self.backend.init(**kwargs)
class Sample(BackupSystem):
def __init__(self):
super().__init__(SAMPLE_BACKEND)
self.backend = backup_backends.backend(self.name, async_=True)
class Acronis(BackupSystem):
def __init__(self):
super().__init__(
ACRONIS,
"/var/log/%s/%s" % (Core.PRODUCT, AcronisBackupConfig.LOG_NAME),
)
self.backend = backup_backends.backend(self.name, async_=True)
async def show(self) -> dict:
info_data = await self.backend.info()
return {
k: v
for k, v in info_data.items()
if k in ("username", "timestamp")
}
@transactional
async def init(self, username, password, force=False, **kwargs):
provision = not await self.backend.is_agent_installed()
await self.backend.init(
username,
password,
provision=provision,
force=force,
tmp_dir=Core.TMPDIR,
)
async def _list_backups(self, until=None):
return await self.backend.backups(until)
async def get_last_backup_timestamp(self) -> Optional[int]:
backups = await self._list_backups()
if backups:
return int(
max(
backup.created.replace(tzinfo=timezone.utc).timestamp()
for backup in backups
)
)
return None
async def check_state(self) -> bool:
"""if backup exists, than state OK"""
try:
return bool(await self._list_backups())
except (asyncio.CancelledError, BackendNotAuthorizedError):
raise
except Exception:
logger.exception("Error during checking state")
return False
class CloudLinuxBase(Acronis):
async def show(self) -> dict:
info_data = await self.backend.info()
info_data["backup_space_used_bytes"] = info_data.pop("usage")
info_data["login_url"] = await self.backend.login_url()
return info_data
async def make_backup(self):
logger.info("Making backup")
try:
await self.backend.make_initial_backup_strict()
except BackupFailed as e:
logging.exception("CloudLinux backup failed")
raise BackupException(
str(e) if len(e.args) and e.args[0] else "BackupFailed"
)
async def get_backup_progress(self) -> Optional[int]:
return await self.backend.get_backup_progress()
async def init(self, username, password, force=False, **kwargs):
logger.info("Starting %s init" % self.name)
provision = not await self.backend.is_agent_installed()
await self.backend.init(
username,
password,
provision=provision,
force=force,
tmp_dir=Core.TMPDIR,
)
class CloudLinux(CloudLinuxBase):
PAID, UNPAID = "paid", "unpaid"
def __init__(self):
super().__init__()
self.name = CLOUDLINUX
@transactional
async def init(self, force=False, **kwargs):
credentials = await RestCLN.acronis_credentials(
server_id=LicenseCLN.get_server_id()
)
await super().init(
credentials["login"],
credentials["password"],
force=force,
)
class Decorators:
@staticmethod
def update_credentials_on_unauthorized_error(f):
@functools.wraps(f)
async def wrapped(self, *args, **kwargs):
try:
return await f(self, *args, **kwargs)
except BackendNotAuthorizedError:
await self.init(force=True)
return await f(self, *args, **kwargs)
return wrapped
@Decorators.update_credentials_on_unauthorized_error
async def show(self) -> dict:
info_data = await super().show()
# FIXME: raise exception when server_id is None
response = await RestCLN.acronis_check(
server_id=LicenseCLN.get_server_id()
)
purchased_backup_gb = response.get("size", 0)
resize_url = response.get("url", None)
info_data["purchased_backup_gb"] = purchased_backup_gb
info_data["resize_url"] = resize_url
return info_data
@Decorators.update_credentials_on_unauthorized_error
async def make_backup(self):
await super().make_backup()
@Decorators.update_credentials_on_unauthorized_error
async def get_backup_progress(self) -> Optional[int]:
return await super().get_backup_progress()
@Decorators.update_credentials_on_unauthorized_error
async def get_last_backup_timestamp(self) -> Optional[int]:
return await super().get_last_backup_timestamp()
@Decorators.update_credentials_on_unauthorized_error
async def check_state(self) -> bool:
return await super().check_state()
async def check(self) -> dict:
try:
content = await RestCLN.acronis_check(
server_id=LicenseCLN.get_server_id()
)
except BackupNotFound as e:
return {"status": self.UNPAID, "url": e.add_used_space()}
return {"status": self.PAID, "size": content.get("size")}
async def disable(self, delete_backups=False):
await super().disable()
if delete_backups:
await RestCLN.acronis_remove(server_id=LicenseCLN.get_server_id())
class CloudLinuxOnPremise(CloudLinuxBase):
def __init__(self):
super().__init__()
self.name = CLOUDLINUX_ON_PREMISE
@transactional
async def init(self, *args, **kwargs):
await super().init(*args, **kwargs)