Jelajahi Sumber

fear: Add updater

ryland 2 tahun lalu
induk
melakukan
ecf568007e
4 mengubah file dengan 271 tambahan dan 1 penghapusan
  1. 123 0
      module/base/retry.py
  2. 17 0
      module/server/home_router.py
  3. 1 1
      module/server/script_router.py
  4. 130 0
      module/server/updater.py

+ 123 - 0
module/base/retry.py

@@ -0,0 +1,123 @@
+import functools
+import random
+import time
+from functools import partial
+
+from module.logger import logger as logging_logger
+
+"""
+Copied from Alas
+"""
+
+try:
+    from decorator import decorator
+except ImportError:
+    def decorator(caller):
+        """ Turns caller into a decorator.
+        Unlike decorator module, function signature is not preserved.
+
+        :param caller: caller(f, *args, **kwargs)
+        """
+
+        def decor(f):
+            @functools.wraps(f)
+            def wrapper(*args, **kwargs):
+                return caller(f, *args, **kwargs)
+
+            return wrapper
+
+        return decor
+
+
+def __retry_internal(f, exceptions=Exception, tries=-1, delay=0, max_delay=None, backoff=1, jitter=0,
+                     logger=logging_logger):
+    """
+    Executes a function and retries it if it failed.
+
+    :param f: the function to execute.
+    :param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
+    :param tries: the maximum number of attempts. default: -1 (infinite).
+    :param delay: initial delay between attempts. default: 0.
+    :param max_delay: the maximum value of delay. default: None (no limit).
+    :param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
+    :param jitter: extra seconds added to delay between attempts. default: 0.
+                   fixed if a number, random if a range tuple (min, max)
+    :param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
+                   default: retry.logging_logger. if None, logging is disabled.
+    :returns: the result of the f function.
+    """
+    _tries, _delay = tries, delay
+    while _tries:
+        try:
+            return f()
+        except exceptions as e:
+            _tries -= 1
+            if not _tries:
+                # Difference, raise same exception
+                raise e
+
+            if logger is not None:
+                # Difference, show exception
+                logger.exception(e)
+                logger.warning(f'{type(e).__name__}({e}), retrying in {_delay} seconds...')
+
+            time.sleep(_delay)
+            _delay *= backoff
+
+            if isinstance(jitter, tuple):
+                _delay += random.uniform(*jitter)
+            else:
+                _delay += jitter
+
+            if max_delay is not None:
+                _delay = min(_delay, max_delay)
+
+
+def retry(exceptions=Exception, tries=-1, delay=0, max_delay=None, backoff=1, jitter=0, logger=logging_logger):
+    """Returns a retry decorator.
+
+    :param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
+    :param tries: the maximum number of attempts. default: -1 (infinite).
+    :param delay: initial delay between attempts. default: 0.
+    :param max_delay: the maximum value of delay. default: None (no limit).
+    :param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
+    :param jitter: extra seconds added to delay between attempts. default: 0.
+                   fixed if a number, random if a range tuple (min, max)
+    :param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
+                   default: retry.logging_logger. if None, logging is disabled.
+    :returns: a retry decorator.
+    """
+
+    @decorator
+    def retry_decorator(f, *fargs, **fkwargs):
+        args = fargs if fargs else list()
+        kwargs = fkwargs if fkwargs else dict()
+        return __retry_internal(partial(f, *args, **kwargs), exceptions, tries, delay, max_delay, backoff, jitter,
+                                logger)
+
+    return retry_decorator
+
+
+def retry_call(f, fargs=None, fkwargs=None, exceptions=Exception, tries=-1, delay=0, max_delay=None, backoff=1,
+               jitter=0,
+               logger=logging_logger):
+    """
+    Calls a function and re-executes it if it failed.
+
+    :param f: the function to execute.
+    :param fargs: the positional arguments of the function to execute.
+    :param fkwargs: the named arguments of the function to execute.
+    :param exceptions: an exception or a tuple of exceptions to catch. default: Exception.
+    :param tries: the maximum number of attempts. default: -1 (infinite).
+    :param delay: initial delay between attempts. default: 0.
+    :param max_delay: the maximum value of delay. default: None (no limit).
+    :param backoff: multiplier applied to delay between attempts. default: 1 (no backoff).
+    :param jitter: extra seconds added to delay between attempts. default: 0.
+                   fixed if a number, random if a range tuple (min, max)
+    :param logger: logger.warning(fmt, error, delay) will be called on failed attempts.
+                   default: retry.logging_logger. if None, logging is disabled.
+    :returns: the result of the f function.
+    """
+    args = fargs if fargs else list()
+    kwargs = fkwargs if fkwargs else dict()
+    return __retry_internal(partial(f, *args, **kwargs), exceptions, tries, delay, max_delay, backoff, jitter, logger)

+ 17 - 0
module/server/home_router.py

@@ -5,6 +5,7 @@ from fastapi import APIRouter
 
 
 from module.logger import logger
 from module.logger import logger
 from module.server.main_manager import MainManager
 from module.server.main_manager import MainManager
+from module.server.updater import Updater
 
 
 home_app = APIRouter(
 home_app = APIRouter(
     prefix="/home",
     prefix="/home",
@@ -43,3 +44,19 @@ async def notify_test(setting: str, title: str, content: str):
 async def kill_server():
 async def kill_server():
     MainManager.signal_kill_server = True
     MainManager.signal_kill_server = True
     return 'success'
     return 'success'
+
+
+@home_app.get('/update_info')
+async def update_info():
+    try:
+        updater = Updater()
+        result = {'is_update': updater.check_update(),
+                  'branch': updater.current_branch(),
+                  'current_commit': updater.current_commit(),
+                  'latest_commit': updater.latest_commit(),
+                  'commit': updater.get_commit(n=15),
+                  }
+        return result
+    except Exception as e:
+        logger.error(e)
+        return None

+ 1 - 1
module/server/script_router.py

@@ -91,7 +91,7 @@ async def script_task(script_name: str, task: str, group: str, argument: str, ty
                 value = TimeDelta(days=day, hours=date_time.hour, minutes=date_time.minute, seconds=date_time.second)
                 value = TimeDelta(days=day, hours=date_time.hour, minutes=date_time.minute, seconds=date_time.second)
             case 'time':
             case 'time':
                 value = datetime.strptime(value, '%H:%M:%S').time()
                 value = datetime.strptime(value, '%H:%M:%S').time()
-            case _:pass
+            case _: pass
     except Exception as e:
     except Exception as e:
         # 类型不正确
         # 类型不正确
         raise HTTPException(status_code=400, detail=f'Argument type error: {e}')
         raise HTTPException(status_code=400, detail=f'Argument type error: {e}')

+ 130 - 0
module/server/updater.py

@@ -0,0 +1,130 @@
+import datetime
+import subprocess
+import threading
+import time
+import requests
+from typing import Generator, List, Tuple
+
+
+from deploy.config import ExecutionError
+from deploy.git import GitManager
+from deploy.pip import PipManager
+from deploy.utils import DEPLOY_CONFIG
+from module.logger import logger
+from module.base.retry import retry
+from module.server.config import DeployConfig
+
+
+class Updater(DeployConfig, GitManager, PipManager):
+    def __init__(self, file=DEPLOY_CONFIG):
+        super().__init__(file=file)
+        self.state = 0
+
+    @property
+    def delay(self):
+        self.read()
+        return int(self.CheckUpdateInterval) * 60
+
+    @property
+    def schedule_time(self):
+        self.read()
+        t = self.AutoRestartTime
+        if t is not None:
+            return datetime.time.fromisoformat(t)
+        else:
+            return None
+
+    def execute_output(self, command) -> str:
+        command = command.replace(r"\\", "/").replace("\\", "/").replace('"', '"')
+        log = subprocess.run(
+            command, capture_output=True, text=True, encoding="utf8", shell=True
+        ).stdout
+        return log
+
+    def get_commit(self, revision="", n=1, short_sha1=False) -> Tuple:
+        """
+        Return:
+            (sha1, author, isotime, message,)
+        """
+        ph = "h" if short_sha1 else "H"
+
+        log = self.execute_output(
+            f'"{self.git}" log {revision} --pretty=format:"%{ph}---%an---%ad---%s" --date=iso -{n}'
+        )
+
+        if not log:
+            return None, None, None, None
+
+        logs = log.split("\n")
+        logs = list(map(lambda log: tuple(log.split("---")), logs))
+
+        if n == 1:
+            return logs[0]
+        else:
+            return logs
+
+    def current_branch(self) -> str:
+        log : str = subprocess.run(
+            'git branch --show-current', capture_output=True, text=True, encoding="utf8", shell=True
+        ).stdout
+        log.replace('\n', '')
+        return log
+
+    def current_commit(self) -> str:
+        return self.get_commit()
+
+    def latest_commit(self) -> str:
+        source = "origin"
+        return self.get_commit(f"{source}/{self.Branch}")
+
+    def check_update(self) -> bool:
+        self.state = "checking"
+
+        # if State.deploy_config.GitOverCdn:
+        #     status = self.goc_client.get_status()
+        #     if status == "uptodate":
+        #         logger.info(f"No update")
+        #         return False
+        #     elif status == "behind":
+        #         logger.info(f"New update available")
+        #         return True
+        #     else:
+        #         # failed, should fallback to `git pull`
+        #         pass
+
+        source = "origin"
+        for _ in range(3):
+            if self.execute(
+                    f'"{self.git}" fetch {source} {self.Branch}', allow_failure=True
+            ):
+                break
+        else:
+            logger.warning("Git fetch failed")
+            return False
+
+        log = self.execute_output(
+            f'"{self.git}" log --not --remotes={source}/* -1 --oneline'
+        )
+        if log:
+            logger.info(
+                f"Cannot find local commit {log.split()[0]} in upstream, skip update"
+            )
+            return False
+
+        sha1, _, _, message = self.get_commit(f"..{source}/{self.Branch}")
+
+        if sha1:
+            logger.info(f"New update available")
+            logger.info(f"{sha1[:8]} - {message}")
+            return True
+        else:
+            logger.info(f"No update")
+            return False
+
+
+if __name__ == "__main__":
+    updater = Updater()
+    print(updater.latest_commit())
+
+
+