update_manager: use ZipDeploy to instantate web types
Signed-off-by: Eric Callahan <arksine.code@gmail.com>
This commit is contained in:
Eric Callahan
parent
8010c51521
commit
994123e92e
|
|
@ -16,7 +16,6 @@ from .app_deploy import AppDeploy
|
|||
from .git_deploy import GitDeploy
|
||||
from .zip_deploy import ZipDeploy
|
||||
from .system_deploy import PackageDeploy
|
||||
from .web_deploy import WebClientDeploy
|
||||
from ...common import RequestType
|
||||
|
||||
# Annotation imports
|
||||
|
|
@ -57,7 +56,7 @@ def get_deploy_class(
|
|||
) -> Union[Type[BaseDeploy], _T]:
|
||||
key = AppType.from_string(app_type) if isinstance(app_type, str) else app_type
|
||||
_deployers = {
|
||||
AppType.WEB: WebClientDeploy,
|
||||
AppType.WEB: ZipDeploy,
|
||||
AppType.GIT_REPO: GitDeploy,
|
||||
AppType.ZIP: ZipDeploy
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,401 +0,0 @@
|
|||
# Provides updates for Klipper and Moonraker
|
||||
#
|
||||
# Copyright (C) 2020 Eric Callahan <arksine.code@gmail.com>
|
||||
#
|
||||
# This file may be distributed under the terms of the GNU GPLv3 license.
|
||||
|
||||
from __future__ import annotations
|
||||
import os
|
||||
import pathlib
|
||||
import logging
|
||||
import shutil
|
||||
import zipfile
|
||||
from ...utils import source_info
|
||||
from ...utils import json_wrapper as jsonw
|
||||
from .common import AppType, Channel
|
||||
from .base_deploy import BaseDeploy
|
||||
|
||||
# Annotation imports
|
||||
from typing import (
|
||||
TYPE_CHECKING,
|
||||
Any,
|
||||
Optional,
|
||||
Tuple,
|
||||
Union,
|
||||
Dict,
|
||||
List,
|
||||
cast
|
||||
)
|
||||
if TYPE_CHECKING:
|
||||
from ...confighelper import ConfigHelper
|
||||
from ..file_manager.file_manager import FileManager
|
||||
from .update_manager import CommandHelper
|
||||
JsonType = Union[List[Any], Dict[str, Any]]
|
||||
|
||||
|
||||
class WebClientDeploy(BaseDeploy):
|
||||
def __init__(self,
|
||||
config: ConfigHelper,
|
||||
cmd_helper: CommandHelper
|
||||
) -> None:
|
||||
super().__init__(config, cmd_helper, prefix="Web Client")
|
||||
self.repo = config.get('repo').strip().strip("/")
|
||||
self.owner, self.project_name = self.repo.split("/", 1)
|
||||
self.path = pathlib.Path(config.get("path")).expanduser().resolve()
|
||||
self.type = AppType.from_string(config.get('type'))
|
||||
self.channel = Channel.from_string(config.get("channel", "stable"))
|
||||
if self.channel == Channel.DEV:
|
||||
self.server.add_warning(
|
||||
f"Invalid Channel '{self.channel}' for config "
|
||||
f"section [{config.get_name()}], type: {self.type}. "
|
||||
f"Must be one of the following: stable, beta. "
|
||||
f"Falling back to beta channel"
|
||||
)
|
||||
self.channel = Channel.BETA
|
||||
self.info_tags: List[str] = config.getlist("info_tags", [])
|
||||
self.persistent_files: List[str] = []
|
||||
self.warnings: List[str] = []
|
||||
self.anomalies: List[str] = []
|
||||
self.version: str = "?"
|
||||
pfiles = config.getlist('persistent_files', None)
|
||||
if pfiles is not None:
|
||||
self.persistent_files = [pf.strip("/") for pf in pfiles]
|
||||
for fname in (".version", "release_info.json"):
|
||||
if fname in self.persistent_files:
|
||||
raise config.error(
|
||||
"Invalid value for option 'persistent_files': "
|
||||
f"'{fname}' can not be persistent."
|
||||
)
|
||||
self._valid: bool = True
|
||||
self._is_prerelease: bool = False
|
||||
self._is_fallback: bool = False
|
||||
self._path_writable: bool = False
|
||||
|
||||
async def _validate_client_info(self) -> None:
|
||||
self._valid = False
|
||||
self._is_fallback = False
|
||||
eventloop = self.server.get_event_loop()
|
||||
self.warnings.clear()
|
||||
repo_parent = source_info.find_git_repo(self.path)
|
||||
homedir = pathlib.Path("~").expanduser()
|
||||
if not self._path_writable:
|
||||
self.warnings.append(
|
||||
f"Location at option 'path: {self.path}' is not writable."
|
||||
)
|
||||
elif not self.path.is_dir():
|
||||
self.warnings.append(
|
||||
f"Location at option 'path: {self.path}' is not a directory."
|
||||
)
|
||||
elif repo_parent is not None and repo_parent != homedir:
|
||||
self.warnings.append(
|
||||
f"Location at option 'path: {self.path}' is within a git repo. Found "
|
||||
f".git folder at '{repo_parent.joinpath('.git')}'"
|
||||
)
|
||||
else:
|
||||
rinfo = self.path.joinpath("release_info.json")
|
||||
if rinfo.is_file():
|
||||
try:
|
||||
data = await eventloop.run_in_thread(rinfo.read_text)
|
||||
uinfo: Dict[str, str] = jsonw.loads(data)
|
||||
project_name = uinfo["project_name"]
|
||||
owner = uinfo["project_owner"]
|
||||
self.version = uinfo["version"]
|
||||
except Exception:
|
||||
logging.exception("Failed to load release_info.json.")
|
||||
else:
|
||||
self._valid = True
|
||||
detected_repo = f"{owner}/{project_name}"
|
||||
if self.repo.lower() != detected_repo.lower():
|
||||
self.anomalies.append(
|
||||
f"Value at option 'repo: {self.repo}' does not match "
|
||||
f"detected repo '{detected_repo}', falling back to "
|
||||
"detected version."
|
||||
)
|
||||
self.repo = detected_repo
|
||||
self.owner = owner
|
||||
self.project_name = project_name
|
||||
else:
|
||||
version_path = self.path.joinpath(".version")
|
||||
if version_path.is_file():
|
||||
version = await eventloop.run_in_thread(version_path.read_text)
|
||||
self.version = version.strip()
|
||||
self._valid = await self._detect_fallback()
|
||||
if not self._valid:
|
||||
self.warnings.append("Failed to validate client installation")
|
||||
if self.server.is_debug_enabled():
|
||||
self.log_info("Debug Enabled, overriding validity checks")
|
||||
|
||||
async def _detect_fallback(self) -> bool:
|
||||
fallback_defs = {
|
||||
"mainsail": "mainsail-crew",
|
||||
"fluidd": "fluidd-core"
|
||||
}
|
||||
for fname in ("manifest.json", "manifest.webmanifest"):
|
||||
manifest = self.path.joinpath(fname)
|
||||
eventloop = self.server.get_event_loop()
|
||||
if manifest.is_file():
|
||||
try:
|
||||
mtext = await eventloop.run_in_thread(manifest.read_text)
|
||||
mdata: Dict[str, Any] = jsonw.loads(mtext)
|
||||
proj_name: str = mdata["name"].lower()
|
||||
except Exception:
|
||||
self.log_exc(f"Failed to load json from {manifest}")
|
||||
continue
|
||||
if proj_name in fallback_defs:
|
||||
owner = fallback_defs[proj_name]
|
||||
detected_repo = f"{owner}/{proj_name}"
|
||||
if detected_repo != self.repo.lower():
|
||||
self.anomalies.append(
|
||||
f"Value at option 'repo: {self.repo}' does not match "
|
||||
f"detected repo '{detected_repo}', falling back to "
|
||||
"detected version."
|
||||
)
|
||||
self.repo = detected_repo
|
||||
self.owner = owner
|
||||
self.project_name = proj_name
|
||||
self._is_fallback = True
|
||||
return True
|
||||
return False
|
||||
|
||||
async def initialize(self) -> Dict[str, Any]:
|
||||
fm: FileManager = self.server.lookup_component("file_manager")
|
||||
self._path_writable = not fm.check_reserved_path(
|
||||
self.path, need_write=True, raise_error=False
|
||||
)
|
||||
if self._path_writable:
|
||||
fm.add_reserved_path(f"update_manager {self.name}", self.path)
|
||||
await self._validate_client_info()
|
||||
storage = await super().initialize()
|
||||
if self.version == "?":
|
||||
self.version = storage.get("version", "?")
|
||||
self.remote_version: str = storage.get('remote_version', "?")
|
||||
self.rollback_version: str = storage.get('rollback_version', self.version)
|
||||
self.rollback_repo: str = storage.get(
|
||||
'rollback_repo', self.repo if self._valid else "?"
|
||||
)
|
||||
self.last_error: str = storage.get('last_error', "")
|
||||
dl_info: List[Any] = storage.get('dl_info', ["?", "?", 0])
|
||||
self.dl_info: Tuple[str, str, int] = cast(
|
||||
Tuple[str, str, int], tuple(dl_info))
|
||||
if not self.needs_refresh():
|
||||
self._log_client_info()
|
||||
return storage
|
||||
|
||||
def _log_client_info(self) -> None:
|
||||
warn_str = ""
|
||||
if self.warnings or self.anomalies:
|
||||
warn_str = "\nWarnings:\n"
|
||||
warn_str += "\n".join(
|
||||
[f" {item}" for item in self.warnings + self.anomalies]
|
||||
)
|
||||
dl_url, content_type, size = self.dl_info
|
||||
logging.info(
|
||||
f"Web Client {self.name} Detected:\n"
|
||||
f"Repo: {self.repo}\n"
|
||||
f"Channel: {self.channel}\n"
|
||||
f"Path: {self.path}\n"
|
||||
f"Local Version: {self.version}\n"
|
||||
f"Remote Version: {self.remote_version}\n"
|
||||
f"Valid: {self._valid}\n"
|
||||
f"Fallback Client Detected: {self._is_fallback}\n"
|
||||
f"Pre-release: {self._is_prerelease}\n"
|
||||
f"Download Url: {dl_url}\n"
|
||||
f"Download Size: {size}\n"
|
||||
f"Content Type: {content_type}\n"
|
||||
f"Rollback Version: {self.rollback_version}\n"
|
||||
f"Rollback Repo: {self.rollback_repo}"
|
||||
f"{warn_str}"
|
||||
)
|
||||
|
||||
async def refresh(self) -> None:
|
||||
try:
|
||||
if not self._valid:
|
||||
await self._validate_client_info()
|
||||
await self._get_remote_version()
|
||||
except Exception:
|
||||
logging.exception("Error Refreshing Client")
|
||||
self._log_client_info()
|
||||
self._save_state()
|
||||
|
||||
async def _fetch_github_version(
|
||||
self, repo: Optional[str] = None, tag: Optional[str] = None
|
||||
) -> Dict[str, Any]:
|
||||
if repo is None:
|
||||
if not self._valid:
|
||||
self.log_info("Invalid Web Installation, aborting remote refresh")
|
||||
return {}
|
||||
repo = self.repo
|
||||
if tag is not None:
|
||||
resource = f"repos/{repo}/releases/tags/{tag}"
|
||||
elif self.channel == Channel.STABLE:
|
||||
resource = f"repos/{repo}/releases/latest"
|
||||
else:
|
||||
resource = f"repos/{repo}/releases?per_page=1"
|
||||
client = self.cmd_helper.get_http_client()
|
||||
resp = await client.github_api_request(
|
||||
resource, attempts=3, retry_pause_time=.5
|
||||
)
|
||||
release: Union[List[Any], Dict[str, Any]] = {}
|
||||
if resp.status_code == 304:
|
||||
if resp.content:
|
||||
# Not modified, however we need to restore state from
|
||||
# cached content
|
||||
release = resp.json()
|
||||
else:
|
||||
# Either not necessary or not possible to restore from cache
|
||||
return {}
|
||||
elif resp.has_error():
|
||||
self.log_info(f"Github Request Error - {resp.error}")
|
||||
self.last_error = str(resp.error)
|
||||
return {}
|
||||
else:
|
||||
release = resp.json()
|
||||
result: Dict[str, Any] = {}
|
||||
if isinstance(release, list):
|
||||
if release:
|
||||
result = release[0]
|
||||
else:
|
||||
result = release
|
||||
self.last_error = ""
|
||||
return result
|
||||
|
||||
async def _get_remote_version(self) -> None:
|
||||
result = await self._fetch_github_version()
|
||||
if not result:
|
||||
return
|
||||
self.remote_version = result.get('name', "?")
|
||||
release_asset: Dict[str, Any] = result.get('assets', [{}])[0]
|
||||
dl_url: str = release_asset.get('browser_download_url', "?")
|
||||
content_type: str = release_asset.get('content_type', "?")
|
||||
size: int = release_asset.get('size', 0)
|
||||
self.dl_info = (dl_url, content_type, size)
|
||||
self._is_prerelease = result.get('prerelease', False)
|
||||
|
||||
def get_persistent_data(self) -> Dict[str, Any]:
|
||||
storage = super().get_persistent_data()
|
||||
storage['version'] = self.version
|
||||
storage['remote_version'] = self.remote_version
|
||||
storage['rollback_version'] = self.rollback_version
|
||||
storage['rollback_repo'] = self.rollback_repo
|
||||
storage['dl_info'] = list(self.dl_info)
|
||||
storage['last_error'] = self.last_error
|
||||
return storage
|
||||
|
||||
async def update(
|
||||
self, rollback_info: Optional[Tuple[str, str, int]] = None
|
||||
) -> bool:
|
||||
if not self._valid:
|
||||
raise self.server.error(
|
||||
f"Web Client {self.name}: Invalid install detected, aborting update"
|
||||
)
|
||||
if rollback_info is not None:
|
||||
dl_url, content_type, size = rollback_info
|
||||
start_msg = f"Rolling Back Web Client {self.name}..."
|
||||
else:
|
||||
if self.remote_version == "?":
|
||||
await self._get_remote_version()
|
||||
if self.remote_version == "?":
|
||||
raise self.server.error(
|
||||
f"Client {self.repo}: Unable to locate update"
|
||||
)
|
||||
dl_url, content_type, size = self.dl_info
|
||||
if self.version == self.remote_version:
|
||||
# Already up to date
|
||||
return False
|
||||
start_msg = f"Updating Web Client {self.name}..."
|
||||
if dl_url == "?":
|
||||
raise self.server.error(f"Client {self.repo}: Invalid download url")
|
||||
current_version = self.version
|
||||
event_loop = self.server.get_event_loop()
|
||||
self.cmd_helper.notify_update_response(start_msg)
|
||||
self.cmd_helper.notify_update_response(f"Downloading Client: {self.name}")
|
||||
td = await self.cmd_helper.create_tempdir(self.name, "client")
|
||||
try:
|
||||
tempdir = pathlib.Path(td.name)
|
||||
temp_download_file = tempdir.joinpath(f"{self.name}.zip")
|
||||
temp_persist_dir = tempdir.joinpath(self.name)
|
||||
client = self.cmd_helper.get_http_client()
|
||||
await client.download_file(
|
||||
dl_url, content_type, temp_download_file, size,
|
||||
self.cmd_helper.on_download_progress)
|
||||
self.cmd_helper.notify_update_response(
|
||||
f"Download Complete, extracting release to '{self.path}'")
|
||||
await event_loop.run_in_thread(
|
||||
self._extract_release, temp_persist_dir,
|
||||
temp_download_file)
|
||||
finally:
|
||||
await event_loop.run_in_thread(td.cleanup)
|
||||
self.version = self.remote_version
|
||||
await self._validate_client_info()
|
||||
if self._valid and rollback_info is None:
|
||||
self.rollback_version = current_version
|
||||
self.rollback_repo = self.repo
|
||||
msg = f"Client Update Finished: {self.name}"
|
||||
if rollback_info is not None:
|
||||
msg = f"Rollback Complete: {self.name}"
|
||||
self.cmd_helper.notify_update_response(msg, is_complete=True)
|
||||
self._log_client_info()
|
||||
self._save_state()
|
||||
return True
|
||||
|
||||
async def rollback(self) -> bool:
|
||||
if self.rollback_version == "?" or self.rollback_repo == "?":
|
||||
raise self.server.error("Incomplete Rollback Data")
|
||||
if self.rollback_version == self.version:
|
||||
return False
|
||||
result = await self._fetch_github_version(
|
||||
self.rollback_repo, self.rollback_version
|
||||
)
|
||||
if not result:
|
||||
raise self.server.error("Failed to retrieve release asset data")
|
||||
release_asset: Dict[str, Any] = result.get('assets', [{}])[0]
|
||||
dl_url: str = release_asset.get('browser_download_url', "?")
|
||||
content_type: str = release_asset.get('content_type', "?")
|
||||
size: int = release_asset.get('size', 0)
|
||||
dl_info = (dl_url, content_type, size)
|
||||
return await self.update(dl_info)
|
||||
|
||||
def _extract_release(self,
|
||||
persist_dir: pathlib.Path,
|
||||
release_file: pathlib.Path
|
||||
) -> None:
|
||||
if not persist_dir.exists():
|
||||
os.mkdir(persist_dir)
|
||||
if self.path.is_dir():
|
||||
# find and move persistent files
|
||||
for src_path in self.path.iterdir():
|
||||
fname = src_path.name
|
||||
if fname in self.persistent_files:
|
||||
dest_path = persist_dir.joinpath(fname)
|
||||
dest_dir = dest_path.parent
|
||||
os.makedirs(dest_dir, exist_ok=True)
|
||||
shutil.move(str(src_path), str(dest_path))
|
||||
shutil.rmtree(self.path)
|
||||
self.path.mkdir()
|
||||
with zipfile.ZipFile(release_file) as zf:
|
||||
for zip_entry in zf.filelist:
|
||||
dest = pathlib.Path(zf.extract(zip_entry, str(self.path)))
|
||||
dest.chmod((zip_entry.external_attr >> 16) & 0o777)
|
||||
# Move temporary files back into
|
||||
for src_path in persist_dir.iterdir():
|
||||
dest_path = self.path.joinpath(src_path.name)
|
||||
dest_dir = dest_path.parent
|
||||
os.makedirs(dest_dir, exist_ok=True)
|
||||
shutil.move(str(src_path), str(dest_path))
|
||||
|
||||
def get_update_status(self) -> Dict[str, Any]:
|
||||
return {
|
||||
'name': self.name,
|
||||
'repo_name': self.project_name,
|
||||
'owner': self.owner,
|
||||
'version': self.version,
|
||||
'remote_version': self.remote_version,
|
||||
'rollback_version': self.rollback_version,
|
||||
'configured_type': str(self.type),
|
||||
'channel': str(self.channel),
|
||||
'info_tags': self.info_tags,
|
||||
'last_error': self.last_error,
|
||||
'is_valid': self._valid,
|
||||
'warnings': self.warnings,
|
||||
'anomalies': self.anomalies
|
||||
}
|
||||
Loading…
Reference in New Issue