151 lines
6.1 KiB
Python
151 lines
6.1 KiB
Python
from core.Errors import FileIntegrityError, UnsupportedApplicationVersionError, ApplicationAlreadyInstalledError
|
|
from core.controllers.ApplicationController import ApplicationController
|
|
from core.models.session.Application import Application
|
|
# from core.models.session.ApplicationVersion import ApplicationVersion
|
|
from core.models.orm_models.ApplicationVersion import ApplicationVersion
|
|
from core.models.manage.wrapper import safe_db_operation, WrapperRollback
|
|
from core.models.DatabaseOperation import DatabaseOperation, DBErrorType
|
|
from core.models.BaseProfile import get_application_version
|
|
|
|
from core.observers.ApplicationVersionObserver import ApplicationVersionObserver
|
|
from core.observers.ConnectionObserver import ConnectionObserver
|
|
from core.services.WebServiceApiService import WebServiceApiService
|
|
from core.errors.logger import logger
|
|
|
|
from io import BytesIO
|
|
from typing import Optional
|
|
import hashlib
|
|
import shutil
|
|
import tarfile
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy import select
|
|
|
|
@safe_db_operation
|
|
def execute_get_all(application: Optional[Application] = None, session: Session = None) -> DatabaseOperation:
|
|
query = select(ApplicationVersion)
|
|
|
|
if application is not None:
|
|
query = query.where(ApplicationVersion.application_code == application.code)
|
|
|
|
result = session.execute(query).scalars().all()
|
|
return DatabaseOperation(valid=True, data=result)
|
|
|
|
class ApplicationVersionController:
|
|
|
|
@staticmethod
|
|
def get(application_code: str, version_number: str):
|
|
return get_application_version(application_code, version_number)
|
|
|
|
@staticmethod
|
|
def get_all(application: Optional[Application] = None):
|
|
database_object = execute_get_all()
|
|
if database_object.valid:
|
|
return database_object.data
|
|
else:
|
|
logger.error(f"[Application Version Controller] Got invalid SQL Query which could not be solved by the wrapper, with error message {database_object.message} and type {database_object.error_type}")
|
|
return None
|
|
|
|
# legacy:
|
|
# @staticmethod
|
|
# def get_all(application: Optional[Application] = None):
|
|
# return ApplicationVersion.all(application)
|
|
|
|
@staticmethod
|
|
def install(application_version: ApplicationVersion, reinstall: bool = False, application_version_observer: Optional[ApplicationVersionObserver] = None, connection_observer: Optional[ConnectionObserver] = None):
|
|
|
|
if not application_version.is_supported:
|
|
raise UnsupportedApplicationVersionError('The application version in question is not supported.')
|
|
|
|
if reinstall:
|
|
ApplicationVersionController.uninstall(application_version)
|
|
|
|
if application_version.is_installed():
|
|
raise ApplicationAlreadyInstalledError('The application in question is already installed.')
|
|
|
|
from core.controllers.ConnectionController import ConnectionController
|
|
ConnectionController.with_preferred_connection(application_version, task=ApplicationVersionController.__install, application_version_observer=application_version_observer, connection_observer=connection_observer)
|
|
|
|
@staticmethod
|
|
def uninstall(application_version: ApplicationVersion):
|
|
shutil.rmtree(application_version.get_installation_path(), ignore_errors=True)
|
|
|
|
@staticmethod
|
|
def _sync(proxies: Optional[dict] = None):
|
|
|
|
applications = ApplicationController.get_all()
|
|
application_versions = []
|
|
|
|
for application_code in (application.code for application in applications):
|
|
|
|
application_version_subset = WebServiceApiService.get_application_versions(application_code, proxies)
|
|
|
|
for application_version in application_version_subset:
|
|
application_versions.append(application_version)
|
|
|
|
ApplicationVersion.truncate()
|
|
ApplicationVersion.save_many(application_versions)
|
|
|
|
@staticmethod
|
|
def __install(application_version: ApplicationVersion, application_version_observer: Optional[ApplicationVersionObserver] = None, proxies: Optional[dict] = None):
|
|
|
|
import requests
|
|
|
|
if application_version_observer is not None:
|
|
application_version_observer.notify('downloading', application_version)
|
|
|
|
if proxies is not None:
|
|
response = requests.get(application_version.download_path, stream=True, proxies=proxies)
|
|
else:
|
|
response = requests.get(application_version.download_path, stream=True)
|
|
|
|
if response.status_code == 200:
|
|
|
|
response_size = int(response.headers.get('Content-Length', 0))
|
|
response_buffer = BytesIO()
|
|
|
|
block_size = 1024
|
|
bytes_written = 0
|
|
|
|
for data in response.iter_content(block_size):
|
|
|
|
bytes_written += len(data)
|
|
response_buffer.write(data)
|
|
progress = (bytes_written / response_size) * 100 if response_size > 0 else 0
|
|
|
|
if application_version_observer is not None:
|
|
|
|
application_version_observer.notify('download_progressing', application_version, dict(
|
|
progress=progress
|
|
))
|
|
|
|
application_version_observer.notify('downloaded', application_version)
|
|
response_buffer.seek(0)
|
|
|
|
file_hash = ApplicationVersionController.__calculate_file_hash(response_buffer)
|
|
|
|
if file_hash != application_version.file_hash:
|
|
raise FileIntegrityError('Application version file integrity could not be verified.')
|
|
|
|
with tarfile.open(fileobj=response_buffer, mode = 'r:gz') as tar_file:
|
|
tar_file.extractall(application_version.get_installation_path())
|
|
|
|
with open(f'{application_version.get_installation_path()}/.sha3-512', 'w') as hash_file:
|
|
hash_file.write(f'{file_hash}\n')
|
|
|
|
else:
|
|
raise ConnectionError('The application version could not be downloaded.')
|
|
|
|
@staticmethod
|
|
def __calculate_file_hash(file):
|
|
|
|
hasher = hashlib.sha3_512()
|
|
buffer = file.read(65536)
|
|
|
|
while len(buffer) > 0:
|
|
|
|
hasher.update(buffer)
|
|
buffer = file.read(65536)
|
|
|
|
file.seek(0)
|
|
|
|
return hasher.hexdigest()
|