apr v2.0.0

logic rewritten for mcdr 2.13

Author: Fallen-Breath

auto_plugin_reloader/common.py

@@ -1,16 +1,16 @@
 from typing import TYPE_CHECKING
 
 from mcdreforged.api.rtext import RTextMCDRTranslation
-from mcdreforged.api.types import ServerInterface
+from mcdreforged.api.types import ServerInterface, PluginServerInterface
 
 if TYPE_CHECKING:
-	from auto_plugin_reloader.config import Configure
+	from auto_plugin_reloader.config import Configuration
 	from auto_plugin_reloader.reloader import PluginReloader
 
 
-server_inst = ServerInterface.get_instance().as_plugin_server_interface()
+server_inst: PluginServerInterface = ServerInterface.psi()
 metadata = server_inst.get_self_metadata()
-config: 'Configure'
+config: 'Configuration'
 reloader: 'PluginReloader'
 
 
@@ -19,8 +19,8 @@ def tr(key: str, *args, **kwargs) -> RTextMCDRTranslation:
 
 
 def load_common():
-	from auto_plugin_reloader.config import Configure
+	from auto_plugin_reloader.config import Configuration
 	from auto_plugin_reloader.reloader import PluginReloader
 	global config, reloader
-	config = Configure.load()
+	config = Configuration.load()
 	reloader = PluginReloader()

auto_plugin_reloader/config.py

@@ -6,7 +6,7 @@
 from auto_plugin_reloader import common
 
 
-class Configure(Serializable):
+class Configuration(Serializable):
 	enabled: bool = True
 	permission: int = PermissionLevel.PHYSICAL_SERVER_CONTROL_LEVEL
 	detection_interval_sec: float = 10
@@ -18,7 +18,7 @@ def get_psi() -> PluginServerInterface:
 		return common.server_inst
 
 	@classmethod
-	def load(cls) -> 'Configure':
+	def load(cls) -> 'Configuration':
 		return cls.get_psi().load_config_simple(target_class=cls)
 
 	def save(self):

auto_plugin_reloader/reloader.py

@@ -1,29 +1,55 @@
+import contextlib
+import dataclasses
+import enum
 import os
+import threading
 import time
+from pathlib import Path
 from threading import Thread, Lock
-from typing import List, NamedTuple, Dict, Iterable, Optional
+from typing import List, Dict, Iterable, Optional, Set
 
 from mcdreforged.api.rtext import *
+from mcdreforged.api.types import PluginType
 
 from auto_plugin_reloader import common
 from auto_plugin_reloader.common import tr, metadata, server_inst
 
-ModifyTimeMapping = Dict[str, int]
 PLUGIN_FILE_SUFFIXES = ['.py', '.mcdr', '.pyz']
 
 
-class Difference(NamedTuple):
-	file_path: str
-	reason: RTextBase
+@dataclasses.dataclass(frozen=True)
+class PluginFileInfo:
+	plugin_id: Optional[str]
+	path: Path
+	mtime: Optional[int]
+
+
+@dataclasses.dataclass(frozen=True)
+class ScanResult:
+	files: Dict[Path, PluginFileInfo] = dataclasses.field(default_factory=dict)
+	plugin_files: Dict[str, PluginFileInfo] = dataclasses.field(default_factory=dict)
+
+
+class DiffReason(enum.Enum):
+	file_added = enum.auto()
+	file_modified = enum.auto()
+	file_deleted = enum.auto()
+
+
+@dataclasses.dataclass(frozen=True)
+class Difference:
+	file_path: Path
+	reason: DiffReason
+	plugin_id: Optional[str]
 
 
 class PluginReloader:
 	def __init__(self):
-		self.__stop_flag = False
+		self.__stop_flag = threading.Event()
 		self.last_detection_time = 0
 		self.logger = server_inst.logger
-		self.scan_result: ModifyTimeMapping = self.scan_files()
-		self.__thread = None  # type: Optional[Thread]
+		self.scan_result: ScanResult = self.__scan_files()
+		self.__thread: Optional[Thread] = None
 		self.__start_stop_lock = Lock()
 
 	def on_config_changed(self):
@@ -46,8 +72,8 @@ def is_running(self):
 	def start(self):
 		with self.__start_stop_lock:
 			if not self.is_running():
-				self.__stop_flag = False
-				self.reset_detection_time()
+				self.__stop_flag.clear()
+				self.__reset_detection_time()
 				self.__thread = Thread(name='APR@{}'.format(self.unique_hex), target=self.thread_loop)
 				self.__thread.start()
 
@@ -58,14 +84,13 @@ def join_thread(self):
 			thread.join()
 
 	def stop(self):
-		with self.__start_stop_lock:
-			self.__stop_flag = True
+		self.__stop_flag.set()
 
 	# ------------------
 	#   Implementation
 	# ------------------
 
-	def reset_detection_time(self):
+	def __reset_detection_time(self):
 		self.last_detection_time = time.time()
 
 	def get_pretty_next_detection_time(self) -> RTextBase:
@@ -75,59 +100,149 @@ def get_pretty_next_detection_time(self) -> RTextBase:
 
 	def thread_loop(self):
 		self.logger.info('{} started'.format(self.unique_name))
-		while not self.__stop_flag:
-			while not self.__stop_flag and time.time() - self.last_detection_time < common.config.detection_interval_sec:
-				time.sleep(0.005)
-			if self.__stop_flag:
+
+		while True:
+			next_detection_time = self.last_detection_time + common.config.detection_interval_sec
+			time_to_wait = max(0.0, next_detection_time - time.time())
+			if self.__stop_flag.wait(time_to_wait):
 				break
+
 			try:
-				self.check()
-			except:
+				self.__check_and_reload_once()
+			except Exception:
 				self.logger.exception('Error ticking {}'.format(metadata.name))
 				self.stop()
 			finally:
-				self.reset_detection_time()
+				self.__reset_detection_time()
+
 		self.logger.info('{} stopped'.format(self.unique_name))
 
-	@staticmethod
-	def scan_files() -> ModifyTimeMapping:
+	def __scan_files(self) -> ScanResult:
+		self.logger.debug('Scan file start')
+		start_time = time.time()
+
 		def has_suffix(text: str, suffixes: Iterable[str]) -> bool:
 			return any(map(lambda sfx: text.endswith(sfx), suffixes))
 
+		def try_get_mtime(p: Path) -> Optional[int]:
+			try:
+				return p.stat().st_mtime_ns
+			except OSError:
+				return None
+
+		result = ScanResult()
+		plugin_paths: Set[Path] = set()
+		for pid in server_inst.get_plugin_list():
+			path = server_inst.get_plugin_file_path(pid)
+			pfmt = server_inst.get_plugin_type(pid)
+			if path is not None and pfmt in [PluginType.solo, PluginType.packed]:
+				path = Path(path).absolute()
+				pfi = PluginFileInfo(plugin_id=pid, path=path, mtime=try_get_mtime(path))
+				result.files[path] = pfi
+				result.plugin_files[pid] = pfi
+				plugin_paths.add(path)
+
 		plugin_directories: List[str] = server_inst.get_mcdr_config()['plugin_directories']
-		ret = {}
-		for plugin_directory in plugin_directories:
-			if os.path.isdir(plugin_directory):
-				for file_name in os.listdir(plugin_directory):
-					file_path = os.path.join(plugin_directory, file_name)
-					if os.path.isfile(file_path) and has_suffix(file_path, PLUGIN_FILE_SUFFIXES) and file_name not in common.config.blacklist:
-						ret[file_path] = os.stat(file_path).st_mtime_ns
-		return ret
-
-	def check(self):
-		new_scan_result = self.scan_files()
-		diffs: List[Difference] = []
-		for file_path, current_mtime in new_scan_result.items():
-			prev_mtime = self.scan_result.get(file_path, None)
-			if prev_mtime is None:
-				diffs.append(Difference(file_path, tr('file_added')))
-			elif prev_mtime != current_mtime:
-				diffs.append(Difference(file_path, tr('file_modified')))
-		for file_path in self.scan_result.keys():
-			if file_path not in new_scan_result:
-				diffs.append(Difference(file_path, tr('file_deleted')))
-
-		if len(diffs) > 0:
-			time.sleep(common.config.reload_delay_sec)
-			if self.__stop_flag:  # just in case
-				return
-			self.logger.info(tr('triggered.header'))
-			for diff in diffs:
-				self.logger.info('- {}: {}'.format(diff.file_path, diff.reason))
-			self.logger.info(tr('triggered.footer'))
-			self.scan_result = self.scan_files()
-
-			holder = Thread(name='OperationHolder', daemon=True, target=lambda: server_inst.schedule_task(server_inst.refresh_changed_plugins, block=True))
-			holder.start()
-			while holder.is_alive() and not self.__stop_flag:  # stop waiting after being stopped
-				holder.join(timeout=0.01)
+		for plugin_directory in map(Path, plugin_directories):
+			try:
+				files = os.listdir(plugin_directory)
+			except OSError as e:
+				if not isinstance(e, FileNotFoundError):
+					self.logger.warning('Skipping invalid plugin directory {!r}: {}'.format(plugin_directory, e))
+				continue
+
+			for file_name in files:
+				path = (plugin_directory / file_name).absolute()
+				if path in plugin_paths:
+					continue
+				try:
+					if path.is_file() and has_suffix(file_name, PLUGIN_FILE_SUFFIXES) and file_name not in common.config.blacklist:
+						mtime = path.stat().st_mtime_ns
+						result.files[path] = PluginFileInfo(plugin_id=None, path=path, mtime=mtime)
+				except OSError as e:
+					self.logger.warning('Check file {!r} failed: {}'.format(plugin_directory, e))
+
+		self.logger.debug('Scan file end, cost {:.2f}s'.format(time.time() - start_time))
+		return result
+
+	@dataclasses.dataclass(frozen=True)
+	class _CheckOnceResult:
+		scan_result: ScanResult
+		diffs: List[Difference] = dataclasses.field(default_factory=list)
+		to_load: List[Path] = dataclasses.field(default_factory=list)   # paths
+		to_reload: List[str] = dataclasses.field(default_factory=list)  # plugin id
+		to_unload: List[str] = dataclasses.field(default_factory=list)  # plugin id
+
+	def __scan_and_check(self) -> _CheckOnceResult:
+		new_scan_result = self.__scan_files()
+		cor = self._CheckOnceResult(scan_result=new_scan_result)
+
+		for pid, pfi in self.scan_result.plugin_files.items():
+			if (new_pfi := new_scan_result.plugin_files.get(pid)) is None:
+				continue
+			# the plugin exists in both 2 scans
+			# reload if mtime changes, and mcdr also says that it has changes
+			# if pid == 'advanced_calculator':
+			# 	self.logger.info('OLD {}'.format(pfi))
+			# 	self.logger.info('NEW {}'.format(new_pfi))
+			if pfi.mtime != new_pfi.mtime and server_inst.is_plugin_file_changed(pid) is True:
+				if new_pfi.mtime is None:
+					cor.diffs.append(Difference(pfi.path, DiffReason.file_deleted, pid))
+					cor.to_unload.append(pid)
+				else:
+					cor.diffs.append(Difference(pfi.path, DiffReason.file_modified, pid))
+					cor.to_reload.append(pid)
+
+		for path, new_pfi in new_scan_result.files.items():
+			# newly found, not loaded, plugin file
+			if new_pfi.plugin_id is None and ((old_pfi := self.scan_result.files.get(path)) is None or new_pfi.mtime != old_pfi.mtime):
+				cor.diffs.append(Difference(path, DiffReason.file_added, None))
+				cor.to_load.append(path)
+
+		if (cd_len := len(cor.diffs)) > 0:
+			self.logger.info('Found {} plugin file changes'.format(cd_len))
+		return cor
+
+	def __check_and_reload_once(self):
+		# first check
+		check_result = self.__scan_and_check()
+		if len(check_result.diffs) == 0:
+			self.scan_result = check_result.scan_result
+			return
+
+		# wait for a while before the double check
+		if self.__stop_flag.wait(common.config.reload_delay_sec):
+			return
+
+		# second check
+		check_result = self.__scan_and_check()
+		self.scan_result = check_result.scan_result
+		if len(check_result.diffs) == 0:
+			self.logger.info('no diff in second check')
+			return
+
+		self.logger.info(tr('triggered.header'))
+		for diff in check_result.diffs:
+			path = diff.file_path
+			with contextlib.suppress(ValueError):
+				path = path.relative_to(Path('.').absolute())
+			msg = '- {}: {}'.format(path, tr(diff.reason.name))
+			if diff.plugin_id:
+				msg += ' (id={})'.format(diff.plugin_id)
+			self.logger.info(msg)
+		self.logger.info(tr('triggered.footer'))
+
+		def do_auto_reload():
+			try:
+				server_inst.manipulate_plugins(
+					load=[str(p) for p in check_result.to_load],
+					reload=check_result.to_reload,
+					unload=check_result.to_unload,
+				)
+			except Exception:
+				self.logger.exception('Auto plugin reload failed')
+
+		holder = Thread(name='OperationHolder', daemon=True, target=lambda: server_inst.schedule_task(do_auto_reload, block=True))
+		holder.start()
+		while holder.is_alive() and not self.__stop_flag.is_set():  # stop waiting after being stopped
+			holder.join(timeout=0.01)

mcdreforged.plugin.json

@@ -1,6 +1,6 @@
 {
     "id": "auto_plugin_reloader",
-    "version": "1.1.3",
+    "version": "2.0.0",
     "name": "Auto Plugin Reloader",
     "description": {
         "en_us": "Automatically reload plugins when file changes",
@@ -11,7 +11,7 @@
     ],
     "link": "https://github.com/TISUnion/AutoPluginReloader",
     "dependencies": {
-        "mcdreforged": ">=2.1.0-beta"
+        "mcdreforged": ">=2.13.0"
     },
     "entrypoint": "auto_plugin_reloader.entry",
     "resources": [

readme.md

@@ -3,13 +3,13 @@
 Auto Plugin Reloader
 -----
 
-A [MCDReforged](https://github.com/Fallen-Breath/MCDReforged) (>=2.x) plugin
+A [MCDReforged](https://github.com/Fallen-Breath/MCDReforged) (>=2.13.0) plugin
 
 Automatically trigger plugin reloading when any plugin file (files with extension `.py` and `.mcdr`) in MCDR plugin directories changes
 
 ## Config
 
-Configure file: `config/auto_plugin_reloader/config.json`
+Configuration file: `config/auto_plugin_reloader/config.json`
 
 `enabled`, if the reloader is enabled, default: `true`
 

readme_cn.md

@@ -3,7 +3,7 @@
 Auto Plugin Reloader
 -----
 
-一个 [MCDReforged](https://github.com/Fallen-Breath/MCDReforged) (>=2.x) 插件
+一个 [MCDReforged](https://github.com/Fallen-Breath/MCDReforged) (>=2.13.0) 插件
 
 在 MCDR 插件文件夹中任何插件文件变更时（后缀为 `.py` 或 `.mcdr` 的文件），触发一次插件重载
 

requirements.txt

@@ -1 +1 @@
-# Add your python package requirements here, just like regular requirements.txt
+mcdreforged