Merge pull request #4708 from LmeSzinc/dev

Bug fix

assets/gui/css/alas.css

@@ -314,6 +314,16 @@ pre.rich-traceback-code {
     margin: 0;
 }
 
+.anim-rotate {
+    animation: rotate-keyframes 0.4s linear infinite
+}
+
+@keyframes rotate-keyframes {
+    100% {
+        transform: rotate(360deg)
+    }
+}
+
 #pywebio-scope-contents {
     margin-top: 0;
     overflow-y: auto;

deploy/atomic.py

@@ -5,8 +5,13 @@ import string
 import time
 from typing import Union
 
+# Max attempt if another process is reading/writing, effective only on Windows
+WINDOWS_MAX_ATTEMPT = 5
+# Base time to wait between retries (seconds)
+WINDOWS_RETRY_DELAY = 0.05
 
-def random_id(length=6):
+
+def random_id(length: int = 6) -> str:
     """
     Args:
         length (int): 6 random letter (62^6 combinations) would be enough
@@ -17,11 +22,44 @@ def random_id(length=6):
     return ''.join(random.sample(string.ascii_letters + string.digits, length))
 
 
+def is_tmp_file(filename: str) -> bool:
+    """
+    Check if a filename is tmp file
+    """
+    # Check suffix first to reduce regex calls
+    if not filename.endswith('.tmp'):
+        return False
+    # Check temp file format
+    res = re.match(r'.*\.[a-zA-Z0-9]{6,}\.tmp$', filename)
+    if not res:
+        return False
+    return True
+
+
+def to_tmp_file(filename: str) -> str:
+    """
+    Convert a filename or directory name to tmp
+    """
+    suffix = random_id(6)
+    return f'{filename}.{suffix}.tmp'
+
+
+def windows_attempt_delay(attempt: int) -> float:
+    """
+    Exponential Backoff if file is in use on Windows
+
+    Args:
+        attempt: Current attempt, starting from 0
+
+    Returns:
+        float: Seconds to wait
+    """
+    return 2 ** attempt * WINDOWS_RETRY_DELAY
+
+
 def atomic_write(
         file: str,
         data: Union[str, bytes],
-        max_attempt=5,
-        retry_delay=0.05,
 ):
     """
     Atomic file write with minimal IO operation
@@ -33,12 +71,8 @@ def atomic_write(
     Args:
         file:
         data:
-        max_attempt: Max attempt if another process is reading,
-            effective only on Windows
-        retry_delay: Base time to wait between retries (seconds)
     """
-    suffix = random_id(6)
-    temp = f'{file}.{suffix}.tmp'
+    temp = to_tmp_file(file)
     if isinstance(data, str):
         mode = 'w'
         encoding = 'utf-8'
@@ -74,9 +108,7 @@ def atomic_write(
     if os.name == 'nt':
         # PermissionError on Windows if another process is reading
         last_error = None
-        if max_attempt < 1:
-            max_attempt = 1
-        for trial in range(max_attempt):
+        for attempt in range(WINDOWS_MAX_ATTEMPT):
             try:
                 # Atomic operation
                 os.replace(temp, file)
@@ -84,7 +116,111 @@ def atomic_write(
                 return
             except PermissionError as e:
                 last_error = e
-                delay = 2 ** trial * retry_delay
+                delay = windows_attempt_delay(attempt)
+                time.sleep(delay)
+                continue
+            except Exception as e:
+                last_error = e
+                break
+    else:
+        # Linux and Mac allow existing reading
+        try:
+            # Atomic operation
+            os.replace(temp, file)
+            # success
+            return
+        except Exception as e:
+            last_error = e
+
+    # Clean up temp file on failure
+    try:
+        os.unlink(temp)
+    except:
+        pass
+    if last_error is not None:
+        raise last_error from None
+
+
+def atomic_stream_write(
+        file: str,
+        data_generator,
+):
+    """
+    Atomic file write with streaming data support.
+    Handles cases where file might be read by another process.
+    os.replace() is an atomic operation among all OS,
+    we write to temp file then do os.replace()
+
+    Only creates a file if the generator yields at least one data chunk.
+    Automatically determines write mode based on the type of first chunk.
+
+    Args:
+        file: Target file path
+        data_generator: An iterable that yields data chunks (str or bytes)
+    """
+    # Convert generator to iterator to ensure we can peek at first chunk
+    data_iter = iter(data_generator)
+
+    # Try to get the first chunk
+    try:
+        first_chunk = next(data_iter)
+    except StopIteration:
+        # Generator is empty, no file will be created
+        return
+
+    # Create temp file path
+    temp = to_tmp_file(file)
+
+    # Determine mode, encoding and newline from first chunk
+    if isinstance(first_chunk, str):
+        mode = 'w'
+        encoding = 'utf-8'
+        newline = ''
+    elif isinstance(first_chunk, bytes):
+        mode = 'wb'
+        encoding = None
+        newline = None
+    else:
+        # Default to text mode for other types
+        mode = 'w'
+        encoding = 'utf-8'
+        newline = ''
+
+    try:
+        # Write temp file
+        with open(temp, mode=mode, encoding=encoding, newline=newline) as f:
+            f.write(first_chunk)
+            for chunk in data_iter:
+                f.write(chunk)
+            # Ensure data flush to disk
+            f.flush()
+            os.fsync(f.fileno())
+    except FileNotFoundError:
+        # Create parent directory
+        directory = os.path.dirname(file)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+        # Write again
+        with open(temp, mode=mode, encoding=encoding, newline=newline) as f:
+            f.write(first_chunk)
+            for chunk in data_iter:
+                f.write(chunk)
+            # Ensure data flush to disk
+            f.flush()
+            os.fsync(f.fileno())
+
+    last_error = None
+    if os.name == 'nt':
+        # PermissionError on Windows if another process is reading
+        for attempt in range(WINDOWS_MAX_ATTEMPT):
+            try:
+                # Atomic operation
+                os.replace(temp, file)
+                # success
+                return
+            except PermissionError as e:
+                last_error = e
+                delay = windows_attempt_delay(attempt)
                 time.sleep(delay)
                 continue
             except Exception as e:
@@ -113,8 +249,6 @@ def atomic_read(
         file: str,
         mode: str = 'r',
         errors: str = 'strict',
-        max_attempt=5,
-        retry_delay=0.05,
 ):
     """
     Atomic file read with minimal IO operation
@@ -124,9 +258,6 @@ def atomic_read(
         file:
         mode: 'r' or 'rb'
         errors: 'strict', 'ignore', 'replace' and any other errors mode in open()
-        max_attempt: Max attempt if another process is reading,
-            effective only on Windows
-        retry_delay: Base time to wait between retries (seconds)
 
     Returns:
         str if mode is 'r'
@@ -141,9 +272,7 @@ def atomic_read(
     if os.name == 'nt':
         # PermissionError on Windows if another process is replacing
         last_error = None
-        if max_attempt < 1:
-            max_attempt = 1
-        for trial in range(max_attempt):
+        for attempt in range(WINDOWS_MAX_ATTEMPT):
             try:
                 with open(file, mode=mode, encoding=encoding, errors=errors) as f:
                     # success
@@ -152,12 +281,9 @@ def atomic_read(
                 return ''
             except PermissionError as e:
                 last_error = e
-                delay = 2 ** trial * retry_delay
+                delay = windows_attempt_delay(attempt)
                 time.sleep(delay)
                 continue
-            except Exception as e:
-                last_error = e
-                break
         if last_error is not None:
             raise last_error from None
     else:
@@ -170,7 +296,39 @@ def atomic_read(
             return ''
 
 
-def atomic_failure_cleanup(path: str):
+def atomic_remove(file: str):
+    """
+    Atomic file remove
+
+    Args:
+        file:
+    """
+    if os.name == 'nt':
+        # PermissionError on Windows if another process is replacing
+        last_error = None
+        for attempt in range(WINDOWS_MAX_ATTEMPT):
+            try:
+                os.unlink(file)
+            except FileNotFoundError:
+                return
+            except PermissionError as e:
+                last_error = e
+                delay = windows_attempt_delay(attempt)
+                time.sleep(delay)
+                continue
+        if last_error is not None:
+            raise last_error from None
+    else:
+        # Linux and Mac allow deleting while another process is reading
+        # The directory entry is removed but the storage allocated to the file is not made available
+        # until the original file is no longer in use.
+        try:
+            os.unlink(file)
+        except FileNotFoundError:
+            return
+
+
+def atomic_failure_cleanup(directory: str, recursive: bool = False):
     """
     Cleanup remaining temp file under given path.
     In most cases there should be no remaining temp files unless write process get interrupted.
@@ -178,24 +336,33 @@ def atomic_failure_cleanup(path: str):
     This method should only be called at startup
     to avoid deleting temp files that another process is writing.
     """
-    with os.scandir(path) as entries:
-        for entry in entries:
-            if not entry.is_file():
-                continue
-            # Check suffix first to reduce regex calls
-            name = entry.name
-            if not name.endswith('.tmp'):
-                continue
-            # Check temp file format
-            res = re.match(r'.*\.[a-zA-Z0-9]{6,}\.tmp$', name)
-            if not res:
-                continue
-            # Delete temp file
-            file = f'{path}{os.sep}{name}'
-            try:
-                os.unlink(file)
-            except PermissionError:
-                # Another process is reading/writing
-                pass
-            except:
-                pass
+    try:
+        with os.scandir(directory) as entries:
+            for entry in entries:
+                if is_tmp_file(entry.name):
+                    # Delete temp file or directory
+                    if entry.is_dir(follow_symlinks=False):
+                        import shutil
+                        shutil.rmtree(entry.path, ignore_errors=True)
+                    else:
+                        try:
+                            os.unlink(entry.path)
+                        except PermissionError:
+                            # Another process is reading/writing
+                            pass
+                        except FileNotFoundError:
+                            # Another process removed current file while iterating
+                            pass
+                        except:
+                            pass
+                else:
+                    if entry.is_dir(follow_symlinks=False):
+                        # Normal directory
+                        if recursive:
+                            atomic_failure_cleanup(entry.path, recursive=True)
+                    # Normal file
+                    # else:
+                    #     pass
+    except FileNotFoundError:
+        # directory to clean up does not exist, no need to clean up
+        pass

module/device/connection.py

@@ -11,6 +11,7 @@ from adbutils import AdbClient, AdbDevice, AdbTimeout, ForwardItem, ReverseItem
 from adbutils.errors import AdbError
 
 from module.base.decorator import Config, cached_property, del_cached_property, run_once
+from module.base.timer import Timer
 from module.base.utils import ensure_time
 from module.config.server import VALID_CHANNEL_PACKAGE, VALID_PACKAGE, set_server
 from module.device.connection_attr import ConnectionAttr
@@ -113,7 +114,7 @@ class Connection(ConnectionAttr):
             self.detect_device()
 
         # Connect
-        self.adb_connect()
+        self.adb_connect(wait_device=False)
         logger.attr('AdbDevice', self.adb)
 
         # Package
@@ -673,8 +674,40 @@ class Connection(ConnectionAttr):
         cmd = ['push', local, remote]
         return self.adb_command(cmd)
 
+    def _wait_device_appear(self, serial, first_devices=None):
+        """
+        Args:
+            serial:
+            first_devices (list[AdbDeviceWithStatus]):
+
+        Returns:
+            bool: If appear
+        """
+        # Wait a little longer than 5s
+        timeout = Timer(5.2).start()
+        first_log = True
+        while 1:
+            if first_devices is not None:
+                devices = first_devices
+                first_devices = None
+            else:
+                devices = self.list_device()
+            # Check if device appear
+            for device in devices:
+                if device.serial == serial and device.status == 'device':
+                    return True
+            # Delay and check later
+            if timeout.reached():
+                break
+            if first_log:
+                logger.info(f'Waiting device appear: {serial}')
+                first_log = False
+            time.sleep(0.05)
+
+        return False
+
     @Config.when(DEVICE_OVER_HTTP=False)
-    def adb_connect(self):
+    def adb_connect(self, wait_device=True):
         """
         Connect to a serial, try 3 times at max.
         If there's an old ADB server running while Alas is using a newer one, which happens on Chinese emulators,
@@ -682,12 +715,14 @@ class Connection(ConnectionAttr):
 
         Args:
             serial (str):
+            wait_device: True to wait emulator-* and android devices appear
 
         Returns:
             bool: If success
         """
         # Disconnect offline device before connecting
-        for device in self.list_device():
+        devices = self.list_device()
+        for device in devices:
             if device.status == 'offline':
                 logger.warning(f'Device {device.serial} is offline, disconnect it before connecting')
                 msg = self.adb_client.disconnect(device.serial)
@@ -700,11 +735,23 @@ class Connection(ConnectionAttr):
             else:
                 logger.warning(f'Device {device.serial} is is having a unknown status: {device.status}')
 
-        # Skip for emulator-5554
+        # Skip connecting emulator-5554 and android phones, as they should be auto connected once plugged in
         if 'emulator-' in self.serial:
+            if wait_device:
+                if self._wait_device_appear(self.serial, first_devices=devices):
+                    logger.info(f'Serial {self.serial} connected')
+                    return True
+                else:
+                    logger.info(f'Serial {self.serial} is not connected')
             logger.info(f'"{self.serial}" is a `emulator-*` serial, skip adb connect')
             return True
         if re.match(r'^[a-zA-Z0-9]+$', self.serial):
+            if wait_device:
+                if self._wait_device_appear(self.serial, first_devices=devices):
+                    logger.info(f'Serial {self.serial} connected')
+                    return True
+                else:
+                    logger.info(f'Serial {self.serial} is not connected')
             logger.info(f'"{self.serial}" seems to be a Android serial, skip adb connect')
             return True
 
@@ -769,7 +816,7 @@ class Connection(ConnectionAttr):
         ev.close()
 
     @Config.when(DEVICE_OVER_HTTP=True)
-    def adb_connect(self):
+    def adb_connect(self, wait_device=True):
         # No adb connect if over http
         return True
 

module/device/method/utils.py

@@ -238,6 +238,11 @@ def handle_adb_error(e):
         # Raised by uiautomator2 when current adb service is killed by another version of adb service.
         logger.error(e)
         return True
+    elif text == 'rest':
+        # AdbError(rest)
+        # Response telling adbd service has reset, client should reconnect
+        logger.error(e)
+        return True
     else:
         # AdbError()
         logger.exception(e)

module/webui/app.py

@@ -113,6 +113,11 @@ class AlasGUI(Frame):
         self.alas_mod = "alas"
         self.alas_config = AzurLaneConfig("template")
         self.initial()
+        # rendered state cache
+        self.rendered_cache = []
+        self.inst_cache = []
+        self.load_home = False
+        self.af_flag = False
 
     @use_scope("aside", clear=True)
     def set_aside(self) -> None:
@@ -122,12 +127,11 @@ class AlasGUI(Frame):
             buttons=[{"label": t("Gui.Aside.Home"), "value": "Home", "color": "aside"}],
             onclick=[self.ui_develop],
         )
-        for name in alas_instance():
-            put_icon_buttons(
-                Icon.RUN,
-                buttons=[{"label": name, "value": name, "color": "aside"}],
-                onclick=self.ui_alas,
-            )
+        put_scope("aside_instance",[
+            put_scope(f"alas-instance-{i}",[])
+            for i, _ in enumerate(alas_instance())
+        ])
+        self.set_aside_status()
         put_icon_buttons(
             Icon.SETTING,
             buttons=[
@@ -140,6 +144,51 @@ class AlasGUI(Frame):
             onclick=[lambda: go_app("manage", new_window=False)],
         )
 
+        current_date = datetime.now().date()
+        if current_date.month == 4 and current_date.day == 1:
+            self.af_flag = True
+
+    @use_scope("aside_instance")
+    def set_aside_status(self) -> None:
+        flag = True       
+        def update(name, seq):
+            with use_scope(f"alas-instance-{seq}", clear=True):
+                icon_html = Icon.RUN
+                rendered_state = ProcessManager.get_manager(inst).state
+                if rendered_state == 1 and self.af_flag:
+                    icon_html = icon_html[:31] + ' anim-rotate' + icon_html[31:]
+                put_icon_buttons(
+                    icon_html,
+                    buttons=[{"label": name, "value": name, "color": "aside"}],
+                    onclick=self.ui_alas,
+                )
+            return rendered_state
+        
+        if not len(self.rendered_cache) or self.load_home:
+            # Reload when add/delete new instance | first start app.py | go to HomePage (HomePage load call force reload)
+            flag = False
+            self.inst_cache.clear()
+            self.inst_cache = alas_instance()
+        if flag:
+            for index, inst in enumerate(self.inst_cache):
+                # Check for state change
+                state = ProcessManager.get_manager(inst).state
+                if state != self.rendered_cache[index]:
+                    self.rendered_cache[index] = update(inst, index)
+                    flag = False
+        else:
+            self.rendered_cache.clear()
+            clear("aside_instance")
+            for index, inst in enumerate(self.inst_cache):
+                self.rendered_cache.append(update(inst, index))
+            self.load_home = False
+        if not flag:
+            # Redraw lost focus, now focus on aside button
+            aside_name = get_localstorage("aside")
+            self.active_button("aside", aside_name)
+        
+        return
+
     @use_scope("header_status")
     def set_status(self, state: int) -> None:
         """
@@ -1049,6 +1098,7 @@ class AlasGUI(Frame):
 
     def show(self) -> None:
         self._show()
+        self.load_home = True
         self.set_aside()
         self.init_aside(name="Home")
         self.dev_set_menu()
@@ -1196,6 +1246,7 @@ class AlasGUI(Frame):
         )
 
         self.task_handler.add(self.state_switch.g(), 2)
+        self.task_handler.add(self.set_aside_status, 2)
         self.task_handler.add(visibility_state_switch.g(), 15)
         self.task_handler.add(update_switch.g(), 1)
         self.task_handler.start()