accli 2.0.7__tar.gz → 2.0.13__tar.gz

{accli-2.0.7 → accli-2.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: accli
-Version: 2.0.7
+Version: 2.0.13
 Summary: IIASA Accelerator Client
 Author-email: Wrufesh S <wrufesh@gmail.com>
 License: The MIT License (MIT)

{accli-2.0.7 → accli-2.0.13}/accli/AcceleratorTaskDispatcher.py

@@ -4,6 +4,9 @@ import hashlib
 import shutil
 import tempfile
 import fnmatch
+import concurrent.futures
+import json
+from pathlib import Path
 from typing import Optional, Dict, List
 
 import requests
@@ -50,9 +53,13 @@ def get_file_sha1(file_path):
 
 
 def copy_tree(src, dst, include=None, exclude=None, root_src=None):
-    """Recursively copy from src to dst, excluding .git folders."""
+    """Recursively copy from src to dst, excluding .git folders. Includes override excludes."""
     if root_src is None:
         root_src = src
+        
+    excludes = [e.strip() for e in exclude.split(',') if e.strip()] if exclude else []
+    includes = [i.strip() for i in include.split(',') if i.strip()] if include else []
+        
     for item in os.listdir(src):
         src_path = os.path.join(src, item)
         dst_path = os.path.join(dst, item)
@@ -61,24 +68,54 @@ def copy_tree(src, dst, include=None, exclude=None, root_src=None):
         if os.path.isdir(src_path):
             if item == '.git':
                 continue
-            if exclude:
-                excludes = [e.strip() for e in exclude.split(',') if e.strip()]
-                if any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in excludes):
-                    continue
+            
+            is_excluded = any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in excludes)
+            # Traverse even if excluded as long as includes exist, to find exceptions
+            if is_excluded and not includes:
+                continue
+                
             os.makedirs(dst_path, exist_ok=True)
             copy_tree(src_path, dst_path, include, exclude, root_src)
         else:
-            if exclude:
-                excludes = [e.strip() for e in exclude.split(',') if e.strip()]
-                if any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in excludes):
-                    continue
-            if include:
-                includes = [i.strip() for i in include.split(',') if i.strip()]
-                if not any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in includes):
-                    continue
+            is_excluded = any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in excludes)
+            is_included = any(fnmatch.fnmatch(rel_path, p) or fnmatch.fnmatch(item, p) for p in includes)
+            
+            if is_included:
+                pass # Included files override exclude
+            elif is_excluded:
+                continue # Skipped by exclude
+            elif includes and not excludes:
+                continue # If ONLY includes list is provided, act as whitelist
+                
             shutil.copy2(src_path, dst_path)
 
 
+def _upload_cas_file_worker(args):
+    rel_path, file_path, term_cli_project_service, project_slug = args
+    file_hash = get_file_sha1(file_path)
+    blob_name = f"cas_{file_hash}.blob"
+    
+    print(f"Checking {rel_path} (hash: {file_hash[:8]})...")
+    presigned_push_url = term_cli_project_service.get_jobstore_push_url(
+        project_slug, blob_name
+    )
+    if presigned_push_url:
+        print(f"Uploading {rel_path}...")
+        with open(file_path, 'rb') as f:
+            res = requests.put(
+                presigned_push_url,
+                data=f,
+                verify=False,
+            )
+            res.raise_for_status()
+        print(f"Uploaded {rel_path}.")
+    else:
+        print(f"Skipped {rel_path} (already in jobstore).")
+    
+    mode = os.stat(file_path).st_mode
+    return {"path": rel_path, "hash": file_hash, "mode": mode}
+
+
 @lru_cache(maxsize=None)
 def push_folder_job(directory, include=None, exclude=None):
     server_url = get_server_url()
@@ -97,19 +134,32 @@ def push_folder_job(directory, include=None, exclude=None):
     if os.path.isfile(f'{repo_dir}/wkube.py'):
         os.remove(f'{repo_dir}/wkube.py')
 
-    temp_zip_path = f"{repo_dir}/temp.zip"
-    compress_folder(repo_dir, temp_zip_path)
-
-    sha256_hash = get_file_sha1(temp_zip_path)
-    final_zip_path = f"{repo_dir}/{sha256_hash}.zip"
-    os.rename(temp_zip_path, final_zip_path)
-
+    manifest = {"type": "cas_manifest", "files": []}
+    
+    upload_args = []
+    for root, dirs, files in os.walk(repo_dir):
+        for file in files:
+            file_path = os.path.join(root, file)
+            rel_path = Path(file_path).relative_to(repo_dir).as_posix()
+            upload_args.append((rel_path, file_path, term_cli_project_service, project_slug))
+            
+    with concurrent.futures.ThreadPoolExecutor(max_workers=30) as executor:
+        for result in executor.map(_upload_cas_file_worker, upload_args):
+            manifest["files"].append(result)
+            
+    manifest_path = os.path.join(repo_dir, "manifest.json")
+    with open(manifest_path, "w") as f:
+        json.dump(manifest, f)
+        
+    manifest_hash = get_file_sha1(manifest_path)
+    manifest_name = f"manifest_{manifest_hash}.json"
+    
     presigned_push_url = term_cli_project_service.get_jobstore_push_url(
-        project_slug, f"{sha256_hash}.zip"
+        project_slug, manifest_name
     )
-
+    
     if presigned_push_url:
-        with open(final_zip_path, 'rb') as f:
+        with open(manifest_path, 'rb') as f:
             res = requests.put(
                 presigned_push_url,
                 data=f,
@@ -118,7 +168,7 @@ def push_folder_job(directory, include=None, exclude=None):
             res.raise_for_status()
 
     shutil.rmtree(repo_dir)
-    return f"s3accjobstore://{sha256_hash}.zip", sha256_hash
+    return f"s3accjobstore://{manifest_name}", manifest_hash
 
 
 class JobDispatchModel(BaseModel):

{accli-2.0.7 → accli-2.0.13}/accli/_version.py

@@ -1,3 +1,3 @@
 # Please strictly put double quote to use this info for git tag 
 # Read a developer guide for git tag command with regex
-VERSION = "v2.0.7"
+VERSION = "v2.0.13"

{accli-2.0.7 → accli-2.0.13}/accli/cli.py

@@ -672,6 +672,7 @@ def start_nfs_watcher(mount_point: str, interval: int):
         proc = subprocess.Popen(
             [executable, str(watcher_script), str(mount_point), str(interval)],
             creationflags=creationflags,
+            stdin=subprocess.DEVNULL,
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             close_fds=True
@@ -722,6 +723,167 @@ def stop_nfs_watcher(mount_point: str):
             pass
 
 
+def cleanup_stuck_windows_mount_processes():
+    """Terminate any orphaned mount.exe / umount.exe instances that block Windows NFS client."""
+    import subprocess
+    try:
+        subprocess.run(["taskkill", "/f", "/im", "mount.exe"], capture_output=True)
+    except Exception:
+        pass
+    try:
+        subprocess.run(["taskkill", "/f", "/im", "umount.exe"], capture_output=True)
+    except Exception:
+        pass
+
+
+def is_nfs_daemon_running() -> bool:
+    """Check if hf-mount-nfs.exe is currently running."""
+    import subprocess
+    try:
+        res = subprocess.run(["tasklist", "/FI", "IMAGENAME eq hf-mount-nfs.exe"], capture_output=True, text=True)
+        return "hf-mount-nfs.exe" in res.stdout
+    except Exception:
+        return False
+
+
+def is_nfs_kernel_driver_active() -> bool:
+    """Check if the Windows Client for NFS kernel redirector driver (NfsRdr) is loaded and running."""
+    import subprocess
+    import shutil
+    if not shutil.which("mount.exe") and not os.path.isfile("C:\\Windows\\System32\\mount.exe"):
+        return False
+    try:
+        res = subprocess.run(["sc.exe", "query", "NfsRdr"], capture_output=True, text=True)
+        if "RUNNING" in res.stdout:
+            return True
+        # If stopped, try to start it
+        subprocess.run(["sc.exe", "start", "NfsRdr"], capture_output=True)
+        check = subprocess.run(["sc.exe", "query", "NfsRdr"], capture_output=True, text=True)
+        return "RUNNING" in check.stdout
+    except Exception:
+        return False
+
+
+def wait_for_nfs_portmapper(host: str, port: int, timeout: float) -> bool:
+    """Poll until the NFS daemon's portmapper is accepting TCP connections and is stable."""
+    import socket
+    start = time.time()
+    consecutive_success = 0
+    while time.time() - start < timeout:
+        try:
+            with socket.create_connection((host, port), timeout=0.5):
+                consecutive_success += 1
+                if consecutive_success >= 2:
+                    time.sleep(1.0)
+                    return True
+        except (socket.error, OSError):
+            consecutive_success = 0
+            time.sleep(0.3)
+    return False
+
+
+def ensure_nfs_daemon_stable(timeout: float) -> bool:
+    """
+    Ensure the NFS daemon starts and survives any delayed UMNT packet flushed by Windows NFS client.
+    If the daemon exits due to UMNT, re-triggers the Task Scheduler task to start a fresh daemon.
+    """
+    import subprocess
+    for attempt in range(3):
+        if not wait_for_nfs_portmapper("127.0.0.1", 111, timeout):
+            return False
+
+        # Windows NFS client kernel redirector flushes delayed UMNT within 7-8 seconds of portmapper binding
+        exited = False
+        for _ in range(16):
+            time.sleep(0.5)
+            if not is_nfs_daemon_running():
+                exited = True
+                break
+
+        if not exited:
+            # Daemon remained running and stable without being killed by delayed UMNT
+            return True
+
+        # Daemon consumed the queued UMNT packet and terminated cleanly. Re-trigger task!
+        time.sleep(1.0)
+        subprocess.run(["schtasks", "/run", "/tn", "accli-mount-nfs"], capture_output=True)
+
+    return wait_for_nfs_portmapper("127.0.0.1", 111, timeout)
+
+
+def map_windows_network_drive(mount_point_abs, max_attempts: int) -> tuple[bool, str]:
+    """
+    Attempt to map the NFS share to the requested drive letter using mount.exe.
+    Retries with cleanup if Windows NFS client returns a transient error.
+    """
+    import subprocess
+    target_str = str(mount_point_abs).rstrip("\\/")
+    if re.match(r"^[a-zA-Z]$", target_str):
+        target_str += ":"
+
+    mount_cmd = [
+        "C:\\Windows\\System32\\mount.exe",
+        "-o", "mtype=hard",
+        "-o", "timeout=10",
+        "-o", "rsize=32",
+        "-o", "wsize=32",
+        "-o", "anon",
+        "-o", "nolock",
+        "\\\\127.0.0.1\\!",
+        target_str
+    ]
+
+    last_err = ""
+    drive_root = str(mount_point_abs).rstrip("\\/") + "\\"
+    for attempt in range(1, max_attempts + 1):
+        cleanup_stuck_windows_mount_processes()
+
+        # If daemon died before or between attempts, revive it
+        if not is_nfs_daemon_running():
+            subprocess.run(["schtasks", "/run", "/tn", "accli-mount-nfs"], capture_output=True)
+            wait_for_nfs_portmapper("127.0.0.1", 111, 10.0)
+
+        try:
+            res = subprocess.run(mount_cmd, capture_output=True, text=True, timeout=15)
+            if res.returncode == 0:
+                # Confirm drive is actually mounted and directory listing is populated and queryable
+                drive_ready = False
+                for _ in range(30):
+                    try:
+                        if os.path.exists(drive_root):
+                            entries = os.listdir(drive_root)
+                            if len(entries) > 0:
+                                drive_ready = True
+                                return True, res.stdout.strip()
+                    except OSError:
+                        pass
+                    time.sleep(0.5)
+                if not drive_ready:
+                    last_err = f"mount.exe reported success but drive {drive_root} was empty or not accessible"
+                    # Clean up the stale mount connection so next attempt can remount fresh
+                    subprocess.run(["net", "use", target_str, "/delete", "/y"], capture_output=True)
+            else:
+                last_err = (res.stderr or res.stdout or "").strip()
+                if "85" in last_err or "already in use" in last_err.lower():
+                    # Release stale network drive letter without unmounting the daemon UNC path
+                    subprocess.run(["net", "use", target_str, "/delete", "/y"], capture_output=True)
+                    time.sleep(1.0)
+        except subprocess.TimeoutExpired:
+            last_err = "mount.exe command timed out"
+            cleanup_stuck_windows_mount_processes()
+        except Exception as e:
+            last_err = str(e)
+
+        if attempt < max_attempts:
+            # Check if daemon needs recovery
+            if not is_nfs_daemon_running():
+                subprocess.run(["schtasks", "/run", "/tn", "accli-mount-nfs"], capture_output=True)
+            wait_for_nfs_portmapper("127.0.0.1", 111, 3.0)
+            time.sleep(1.0 + (attempt * 0.5))
+
+    return False, last_err
+
+
 def enable_windows_nfs_features():
     """Automatically check and enable Windows Client for NFS features, registry key, and Task Scheduler gateway if needed."""
     import subprocess
@@ -860,13 +1022,16 @@ def enable_windows_nfs_features():
             
         print("[bold green][OK] Elevated administrative setup completed successfully![/bold green]")
         
-        # Reboot advisory for registry keys or NFS features
-        if not reg_ok or not nfs_ok:
-            print("")
-            print("[bold yellow][WARNING] IMPORTANT: A Windows system restart is required for the new NFS Client features and registry policies to take effect.[/bold yellow]")
-            print("[bold yellow]Please restart your computer, then run 'accli mount start' again to mount your drive passwordlessly![/bold yellow]")
-            print("")
-            raise typer.Exit(0)
+        # Verify if kernel driver is loaded; if active, restart is NOT required and we continue mounting
+        if is_nfs_kernel_driver_active():
+            print("[bold green][OK] Windows NFS kernel redirector is active. Continuing with mount...[/bold green]")
+            return
+
+        print("")
+        print("[bold yellow][WARNING] IMPORTANT: A Windows system restart is required for the new NFS Client features and registry policies to take effect.[/bold yellow]")
+        print("[bold yellow]Please restart your computer, then run 'accli mount start' again to mount your drive passwordlessly![/bold yellow]")
+        print("")
+        raise typer.Exit(0)
             
     except Exception as e:
         if isinstance(e, typer.Exit):
@@ -909,7 +1074,12 @@ def mount_start(
     try:
         token = get_token()
         server_url = get_server_url()
+        if not token:
+            print("[bold red]ERROR: No token found. Please run 'accli login' first.[/bold red]")
+            raise typer.Exit(1)
     except Exception as e:
+        if isinstance(e, typer.Exit):
+            raise e
         print(f"[bold red]ERROR: Could not retrieve login details. Please run 'accli login' first. Details: {e}[/bold red]")
         raise typer.Exit(1)
 
@@ -965,8 +1135,8 @@ def mount_start(
                 print(f"[bold red]ERROR: {e}[/bold red]")
                 raise typer.Exit(1)
         else:
-            mount_point_str = str(mount_point)
-            if re.match(r"^[a-zA-Z]:?\\?$", mount_point_str) or re.match(r"^[a-zA-Z]:/?$", mount_point_str):
+            mount_point_str = str(mount_point).strip()
+            if re.match(r"^[a-zA-Z]:?[\\/]*$", mount_point_str):
                 drive_letter = mount_point_str[0].upper()
                 if os.path.exists(f"{drive_letter}:\\"):
                     print(f"[yellow]Warning: Drive '{drive_letter}:' is already in use.[/yellow]")
@@ -1106,30 +1276,21 @@ def mount_start(
                 run_res = subprocess.run(["schtasks", "/run", "/tn", "accli-mount-nfs"], capture_output=True, text=True)
                 if run_res.returncode == 0:
                     print("[cyan]Waiting for elevated NFS daemon to initialize...[/cyan]")
-                    time.sleep(2.0)
+                    if not ensure_nfs_daemon_stable(15.0):
+                        print("[bold red][ERROR] Timed out waiting for NFS daemon to bind to 127.0.0.1:111.[/bold red]")
+                        raise typer.Exit(1)
                     
                     # Map the network drive in the CURRENT user session (so it is visible in Explorer)
-                    mount_cmd = [
-                        "C:\\Windows\\System32\\mount.exe",
-                        "-o", "mtype=hard",
-                        "-o", "timeout=10",
-                        "-o", "rsize=32",
-                        "-o", "wsize=32",
-                        "-o", "anon",
-                        "-o", "nolock",
-                        "\\\\127.0.0.1\\!",
-                        str(mount_point_abs)
-                    ]
-                    mount_res = subprocess.run(mount_cmd, capture_output=True, text=True)
-                    if mount_res.returncode == 0:
+                    success, err_msg = map_windows_network_drive(mount_point_abs, 5)
+                    if success:
                         start_nfs_watcher(str(mount_point_abs), interval=30)
                         print(f"[bold green][OK] NFS mount successfully mapped at [white]{mount_point_abs}[/white]![/bold green]")
                         print("[cyan]Use 'umount' or 'accli mount stop' to unmount the drive.[/cyan]")
                         return
                     else:
                         print(f"[bold red][ERROR] NFS daemon started, but failed to map drive {mount_point_abs} in user session.[/bold red]")
-                        if mount_res.stderr:
-                            print(f"[red]{mount_res.stderr.strip()}[/red]")
+                        if err_msg:
+                            print(f"[red]{err_msg}[/red]")
                         print("[yellow]Tip: Make sure Windows NFS client feature was fully enabled and the PC was restarted.[/yellow]")
                         raise typer.Exit(1)
                 else:
@@ -1208,29 +1369,20 @@ def mount_start(
                     raise typer.Exit(1)
                     
                 print("[cyan]Waiting for elevated NFS daemon to initialize...[/cyan]")
-                time.sleep(2.0)
+                if not wait_for_nfs_portmapper("127.0.0.1", 111, 15.0):
+                    print("[bold red][ERROR] Timed out waiting for NFS daemon to bind to 127.0.0.1:111.[/bold red]")
+                    raise typer.Exit(1)
                 
                 # Map the network drive in the CURRENT user session (so it is visible in Explorer)
-                mount_cmd = [
-                    "C:\\Windows\\System32\\mount.exe",
-                    "-o", "mtype=hard",
-                    "-o", "timeout=10",
-                    "-o", "rsize=32",
-                    "-o", "wsize=32",
-                    "-o", "anon",
-                    "-o", "nolock",
-                    "\\\\127.0.0.1\\!",
-                    str(mount_point_abs)
-                ]
-                mount_res = subprocess.run(mount_cmd, capture_output=True, text=True)
-                if mount_res.returncode == 0:
+                success, err_msg = map_windows_network_drive(mount_point_abs, 5)
+                if success:
                     start_nfs_watcher(str(mount_point_abs), interval=30)
                     print(f"[bold green][OK] NFS mount successfully mapped at [white]{mount_point_abs}[/white]![/bold green]")
                     print("[cyan]Use 'umount' or 'accli mount stop' to unmount the drive.[/cyan]")
                 else:
                     print(f"[bold red][ERROR] NFS daemon spawned elevated, but failed to map drive {mount_point_abs} in user session.[/bold red]")
-                    if mount_res.stderr:
-                        print(f"[red]{mount_res.stderr.strip()}[/red]")
+                    if err_msg:
+                        print(f"[red]{err_msg}[/red]")
                     raise typer.Exit(1)
         except Exception as e:
             if isinstance(e, typer.Exit):
@@ -1349,10 +1501,17 @@ def mount_stop(
             mount_point_abs = Path.home() / "accelerator" / "mnt" / project_slug
             print(f"[cyan]No mount point specified. Selected default directory: [bold white]{mount_point_abs}[/bold white][/cyan]")
         else:
-            mount_point_abs = mount_point.resolve()
+            mount_point_str = str(mount_point).strip()
+            if sys_name == "Windows" and re.match(r"^[a-zA-Z]:?[\\/]*$", mount_point_str):
+                mount_point_abs = Path(f"{mount_point_str[0].upper()}:")
+            else:
+                mount_point_abs = mount_point.resolve()
 
     if sys_name == "Windows":
-        print(f"[bold cyan]Stopping mount at '[white]{mount_point_abs}[/white]' on Windows...[/bold cyan]")
+        target_str = str(mount_point_abs).rstrip("\\/")
+        if re.match(r"^[a-zA-Z]$", target_str):
+            target_str += ":"
+        print(f"[bold cyan]Stopping mount at '[white]{target_str}[/white]' on Windows...[/bold cyan]")
         import subprocess
         
         # Determine if current user is admin
@@ -1363,13 +1522,16 @@ def mount_stop(
             is_admin = False
 
         # 0. Stop background NFS watcher
-        stop_nfs_watcher(str(mount_point_abs))
+        stop_nfs_watcher(target_str)
 
-        # 1. Unmap the network drive in the user session
-        res = subprocess.run(["C:\\Windows\\System32\\umount.exe", "-f", str(mount_point_abs)], capture_output=True, text=True)
+        # 1. Unmap the network drive in the user session using net use
+        # (Avoids sending RPC UMNT packet via umount.exe which causes kernel NFS redirector to queue stale UMNTs)
+        res = subprocess.run(["net", "use", target_str, "/delete", "/y"], capture_output=True, text=True)
         if res.returncode != 0:
-            # Fallback to force-releasing using net use
-            subprocess.run(["net", "use", str(mount_point_abs), "/delete", "/y"], capture_output=True)
+            res = subprocess.run(["C:\\Windows\\System32\\umount.exe", "-f", target_str], capture_output=True, text=True)
+        subprocess.run(["net", "use", "\\\\127.0.0.1\\!", "/delete", "/y"], capture_output=True)
+
+        cleanup_stuck_windows_mount_processes()
 
         # 2. Terminate the background daemon
         has_umount_task = False
@@ -1390,6 +1552,18 @@ def mount_stop(
                 task_check = subprocess.run(["tasklist", "/FI", "IMAGENAME eq hf-mount-nfs.exe"], capture_output=True, text=True)
                 if "hf-mount-nfs.exe" not in task_check.stdout:
                     break
+            cleanup_stuck_windows_mount_processes()
+            for _ in range(10):
+                sched_check = subprocess.run(["schtasks", "/query", "/tn", "accli-mount-nfs"], capture_output=True, text=True)
+                if "Running" not in sched_check.stdout:
+                    break
+                time.sleep(0.5)
+
+            # Wait until drive letter is released from Windows namespace
+            for _ in range(10):
+                if not os.path.exists(f"{target_str}\\"):
+                    break
+                time.sleep(0.3)
         else:
             # If admin or task scheduler gateway is not registered, stop/kill directly
             if is_admin:
@@ -1425,6 +1599,7 @@ def mount_stop(
         
         if res.returncode == 0 or "successfully" in res.stdout or "successfully" in res.stderr:
             print("[bold green][OK] Mount stopped successfully.[/bold green]")
+            print("[cyan]Note: If mounting again, please allow a few seconds for the Windows NFS network cache to clear.[/cyan]")
         else:
             print("[yellow]Attempted to unmount. Please verify drive status manually using 'umount'.[/yellow]")
             if res.stderr:

{accli-2.0.7 → accli-2.0.13}/accli/gui.py

@@ -88,7 +88,11 @@ class AccliGuiApp(tk.Tk):
         
         # Checkboxes
         self.style.configure("TCheckbutton", background="#1e1e1e", foreground="#ffffff")
-        self.style.map("TCheckbutton", background=[("active", "#1e1e1e")])
+        self.style.map("TCheckbutton",
+            background=[("active", "#1e1e1e")],
+            indicatorbackground=[("selected", "#007acc"), ("!selected", "#2d2d2d")],
+            indicatorforeground=[("selected", "#ffffff"), ("!selected", "#2d2d2d")]
+        )
 
     def create_widgets(self):
         # Top banner
@@ -122,7 +126,7 @@ class AccliGuiApp(tk.Tk):
                 cmd = [sys.executable] + args
             else:
                 # Script mode
-                cmd = [sys.executable, "-m", "accli.cli"] + args
+                cmd = [sys.executable, "-m", "accli"] + args
 
             if elevate and platform.system() != "Windows":
                 import shutil
@@ -162,11 +166,14 @@ class AccliGuiApp(tk.Tk):
                 process.wait()
                 
                 if on_done:
-                    self.after(0, lambda: on_done(process.returncode, "".join(output_lines)))
+                    ret_code = process.returncode
+                    out_text = "".join(output_lines)
+                    self.after(0, lambda: on_done(ret_code, out_text))
             except Exception as e:
-                self.append_log(f"ERROR executing command: {e}\n")
+                err_text = str(e)
+                self.append_log(f"ERROR executing command: {err_text}\n")
                 if on_done:
-                    self.after(0, lambda: on_done(-1, str(e)))
+                    self.after(0, lambda: on_done(-1, err_text))
 
         threading.Thread(target=worker, daemon=True).start()
 
@@ -196,10 +203,26 @@ class AccliGuiApp(tk.Tk):
         self.login_btn = ttk.Button(card, text="Authenticate / Login", command=self.action_login)
         self.login_btn.grid(row=0, column=2, padx=10, pady=5)
         
+        self.debug_mode_val = tk.BooleanVar(value=bool(os.environ.get("ACCLI_DEBUG")))
+        self.debug_check = ttk.Checkbutton(
+            card,
+            text="Debug mode",
+            variable=self.debug_mode_val,
+            command=self.on_debug_toggle
+        )
+        self.debug_check.grid(row=1, column=0, columnspan=3, sticky=tk.W, pady=(5, 0))
+        
         # Connection status details
         self.conn_details_txt = tk.Text(auth_tab, height=12, bg="#2d2d2d", fg="#ffffff", insertbackground="white", font=("Courier New", 10), state=tk.DISABLED)
         self.conn_details_txt.pack(fill=tk.BOTH, expand=True, pady=10)
 
+    def on_debug_toggle(self):
+        if self.debug_mode_val.get():
+            os.environ["ACCLI_DEBUG"] = "1"
+        else:
+            os.environ.pop("ACCLI_DEBUG", None)
+        self.refresh_login_status()
+
     def refresh_login_status(self):
         from accli.token import get_db_path
         from tinydb import TinyDB
@@ -229,13 +252,16 @@ class AccliGuiApp(tk.Tk):
             self.server_entry.configure(state=tk.NORMAL)
             self.status_bar_val.set("Session Status: Disconnected")
             
-        def on_check_done(code, output):
-            self.conn_details_txt.configure(state=tk.NORMAL)
-            self.conn_details_txt.delete("1.0", tk.END)
-            self.conn_details_txt.insert(tk.END, output)
-            self.conn_details_txt.configure(state=tk.DISABLED)
-
-        self.run_cli_async(["status"], on_done=on_check_done, log_to_viewer=False)
+        details = [
+            f"Server URL:     {server_url}",
+            f"Session Status: {'Connected / Logged In' if logged_in else 'Not Logged In'}",
+            f"Token DB Path:  {db_path}",
+            f"Debug Mode:     {'Enabled ($env:ACCLI_DEBUG=\"1\")' if os.environ.get('ACCLI_DEBUG') else 'Disabled'}"
+        ]
+        self.conn_details_txt.configure(state=tk.NORMAL)
+        self.conn_details_txt.delete("1.0", tk.END)
+        self.conn_details_txt.insert(tk.END, "\n".join(details) + "\n")
+        self.conn_details_txt.configure(state=tk.DISABLED)
 
     def action_login(self):
         if hasattr(self, "is_logged_in_state") and self.is_logged_in_state:
@@ -288,7 +314,7 @@ class AccliGuiApp(tk.Tk):
                 response = requests.post(
                     token_endpoint,
                     json={"device_authorization_code": auth_code.strip()},
-                    verify=True
+                    verify=(not bool(os.environ.get("ACCLI_DEBUG")))
                 )
                 
                 if response.status_code == 400:
@@ -306,8 +332,9 @@ class AccliGuiApp(tk.Tk):
                 self.after(0, lambda: messagebox.showinfo("Success", "Successfully logged in!"))
                 self.after(0, self.refresh_login_status)
             except Exception as e:
-                self.append_log(f"Authentication Failed: {e}\n")
-                self.after(0, lambda: messagebox.showerror("Error", f"Authentication failed: {e}"))
+                err_text = str(e)
+                self.append_log(f"Authentication Failed: {err_text}\n")
+                self.after(0, lambda msg=err_text: messagebox.showerror("Error", f"Authentication failed: {msg}"))
                 self.after(0, self.refresh_login_status)
 
         threading.Thread(target=perform_auth, daemon=True).start()
@@ -422,6 +449,9 @@ class AccliGuiApp(tk.Tk):
         
         mount_btn = ttk.Button(btn_frame, text="Start Mount", command=self.action_mount_start)
         mount_btn.pack(side=tk.LEFT, padx=5)
+
+        stop_form_btn = ttk.Button(btn_frame, text="Stop Mount", style="Stop.TButton", command=self.action_mount_stop)
+        stop_form_btn.pack(side=tk.LEFT, padx=5)
         
         # Right Panel (List of mounts)
         list_frame = ttk.LabelFrame(mounts_tab, text="Active Mounts", padding=10)
@@ -501,20 +531,33 @@ class AccliGuiApp(tk.Tk):
         self.run_cli_async(args, on_done=on_done, elevate=True)
 
     def action_mount_stop(self):
-        selected = self.mounts_list.get(tk.ACTIVE)
-        if not selected:
-            messagebox.showwarning("Warning", "Please select a mount to stop from the list.")
-            return
-            
-        # Parse the mount point from the status line
-        # E.g. "W:       \\\\127.0.0.1\\!" -> "W:"
-        # Or parse folder paths
-        parts = selected.split()
-        if not parts:
-            return
-            
-        mount_point = parts[0]
-        args = ["mount", "stop", mount_point]
+        # 1. Check if user selected an item from the active mounts list
+        mount_point = ""
+        selected_indices = self.mounts_list.curselection()
+        if selected_indices:
+            selected = self.mounts_list.get(selected_indices[0])
+            parts = selected.split()
+            if parts:
+                mount_point = parts[0]
+        elif self.mounts_list.size() > 0:
+            selected = self.mounts_list.get(tk.ACTIVE)
+            if selected:
+                parts = selected.split()
+                if parts:
+                    mount_point = parts[0]
+
+        # 2. If nothing selected or list is empty, fallback to the Mount Point / Drive Letter input field
+        if not mount_point:
+            entered_point = self.mount_point_val.get().strip()
+            if entered_point:
+                mount_point = entered_point
+
+        args = ["mount", "stop"]
+        if mount_point:
+            args.append(mount_point)
+            target_desc = mount_point
+        else:
+            target_desc = "active mount"
         
         self.status_bar_val.set("Stopping mount...")
         self.notebook.select(self.log_tab_idx)
@@ -523,10 +566,10 @@ class AccliGuiApp(tk.Tk):
             self.refresh_mounts_list()
             if code == 0:
                 self.status_bar_val.set("Mount Stopped")
-                messagebox.showinfo("Success", f"Successfully stopped mount at {mount_point}.")
+                messagebox.showinfo("Success", f"Successfully stopped mount ({target_desc}).")
             else:
                 self.status_bar_val.set("Stop Failed")
-                messagebox.showerror("Error", f"Failed to stop mount at {mount_point}.")
+                messagebox.showerror("Error", f"Failed to stop mount ({target_desc}). See logs for details.")
 
         self.run_cli_async(args, on_done=on_done, elevate=True)
 

{accli-2.0.7 → accli-2.0.13}/accli/token.py

@@ -3,6 +3,7 @@ import threading
 import time
 import requests
 import typer
+from rich import print
 from tinydb import TinyDB
 
 ACCLI_DEBUG = os.environ.get('ACCLI_DEBUG', False)
@@ -138,6 +139,13 @@ def exchange_refresh_token(project_slug: str) -> tuple[str, str, int]:
             _cached_expires_at = expires_at
 
             return cas_token, access_token, expires_at
+        except requests.exceptions.HTTPError as e:
+            if e.response is not None and e.response.status_code in (400, 401, 403):
+                print("[bold red]ERROR: Your session has expired or the token is invalid.[/bold red]")
+                print("[yellow]Please run 'accli login' to authenticate again.[/yellow]")
+                raise typer.Exit(1)
+            print(f"[bold red]ERROR: Failed to authenticate/exchange refresh token: {e}[/bold red]")
+            raise typer.Exit(1)
         except Exception as e:
             print(f"[bold red]ERROR: Failed to authenticate/exchange refresh token: {e}[/bold red]")
             raise typer.Exit(1)

{accli-2.0.7 → accli-2.0.13}/accli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: accli
-Version: 2.0.7
+Version: 2.0.13
 Summary: IIASA Accelerator Client
 Author-email: Wrufesh S <wrufesh@gmail.com>
 License: The MIT License (MIT)

{accli-2.0.7 → accli-2.0.13}/accli.egg-info/SOURCES.txt

@@ -22,4 +22,5 @@ accli.egg-info/SOURCES.txt
 accli.egg-info/dependency_links.txt
 accli.egg-info/entry_points.txt
 accli.egg-info/requires.txt
-accli.egg-info/top_level.txt
+accli.egg-info/top_level.txt
+tests/test_mount_lifecycle.py

accli-2.0.13/tests/test_mount_lifecycle.py

@@ -0,0 +1,138 @@
+"""
+Test for mounting lifecycle:
+1. Ensure clean initial state (mount stop)
+2. accli mount start <project_slug>
+3. Capture directory structure (ensure not empty) & read any file
+4. accli mount stop
+5. accli mount start <project_slug> again
+6. Capture directory structure (must not be empty) & read any file
+"""
+import os
+import sys
+import time
+import platform
+import subprocess
+import unittest
+from pathlib import Path
+
+
+class TestMountLifecycle(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.project_slug = os.environ.get("ACCLI_TEST_PROJECT", "test")
+        cls.mount_drive = os.environ.get("ACCLI_TEST_DRIVE", "W:")
+        cls.mount_arg = cls.mount_drive.rstrip("\\/")
+        if platform.system() == "Windows" and len(cls.mount_arg) == 1 and cls.mount_arg.isalpha():
+            cls.mount_arg += ":"
+        cls.mount_path = Path(f"{cls.mount_arg}\\") if platform.system() == "Windows" else Path.home() / "accelerator" / "mnt" / cls.project_slug
+
+    def run_cli(self, args: list, timeout: int):
+        cmd = [sys.executable, "-m", "accli"] + args
+        print(f"\n[TEST EXEC] {' '.join(cmd)}")
+        result = subprocess.run(
+            cmd,
+            stdin=subprocess.DEVNULL,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        print(f"[EXIT CODE] {result.returncode}")
+        if result.stdout:
+            print(f"[STDOUT]\n{result.stdout.strip()}")
+        if result.stderr:
+            print(f"[STDERR]\n{result.stderr.strip()}")
+        return result
+
+    def get_structure(self, target_path: Path):
+        """List files and folders at the mounted location and ensure it is not empty."""
+        entries = []
+        for _ in range(10):
+            try:
+                if target_path.exists():
+                    entries = [p.name for p in target_path.iterdir()]
+                    if entries:
+                        break
+            except OSError:
+                pass
+            time.sleep(0.5)
+
+        self.assertTrue(
+            target_path.exists(),
+            f"Mount path '{target_path}' does not exist or drive is not mapped."
+        )
+        print(f"[MOUNT STRUCTURE at {target_path}]: {entries}")
+        return entries
+
+    def read_any_file(self, target_path: Path):
+        """Locate any readable file under the mounted project path and read its content."""
+        search_dirs = [target_path / self.project_slug, target_path]
+        for sdir in search_dirs:
+            if not sdir.exists():
+                continue
+            for root, dirs, files in os.walk(sdir):
+                for file_name in files:
+                    candidate = Path(root) / file_name
+                    try:
+                        print(f"[TEST READ FILE] Attempting to read: {candidate}")
+                        with open(candidate, "rb") as fp:
+                            data = fp.read(1024)
+                        print(f"[TEST READ FILE] Successfully read {len(data)} bytes from '{candidate.name}'.")
+                        return candidate, len(data)
+                    except Exception as e:
+                        print(f"[TEST READ FILE] Skipping unreadable candidate {candidate}: {e}")
+
+        self.fail(f"Could not read any file under mounted path '{target_path}'.")
+
+    def tearDown(self):
+        try:
+            self.run_cli(["mount", "stop", self.mount_arg], 30)
+        except Exception:
+            pass
+
+    def test_mount_start_stop_start_lifecycle(self):
+        # Step 0: Ensure clean initial state
+        print("\n--- Step 0: Ensure clean initial state ---")
+        self.run_cli(["mount", "stop", self.mount_arg], 30)
+        time.sleep(2)
+
+        # Step 1: First mount start
+        print(f"\n--- Step 1: Starting mount for '{self.project_slug}' at '{self.mount_arg}' ---")
+        start1 = self.run_cli(["mount", "start", self.project_slug, self.mount_arg], 60)
+        self.assertEqual(start1.returncode, 0, f"First mount start failed: {start1.stderr or start1.stdout}")
+
+        # Step 2: Check structure is not empty and try to read any file
+        print("\n--- Step 2: Checking structure & reading file after 1st mount ---")
+        structure1 = self.get_structure(self.mount_path)
+        self.assertGreater(
+            len(structure1), 0,
+            f"Expected structure to be not empty after 1st mount, got: {structure1}"
+        )
+        file1, bytes_read1 = self.read_any_file(self.mount_path)
+        self.assertIsNotNone(file1)
+
+        # Step 3: Mount stop (clean)
+        print(f"\n--- Step 3: Stopping mount at '{self.mount_arg}' ---")
+        stop = self.run_cli(["mount", "stop", self.mount_arg], 30)
+        self.assertEqual(stop.returncode, 0, f"Mount stop failed: {stop.stderr or stop.stdout}")
+        time.sleep(3)
+
+        # Step 4: Second mount start
+        print(f"\n--- Step 4: Starting mount for '{self.project_slug}' at '{self.mount_arg}' (2nd time) ---")
+        start2 = self.run_cli(["mount", "start", self.project_slug, self.mount_arg], 120)
+        self.assertEqual(start2.returncode, 0, f"Second mount start failed: {start2.stderr or start2.stdout}")
+
+        # Step 5: Check structure is not empty and try to read any file after clean & remount
+        print("\n--- Step 5: Checking structure & reading file after 2nd mount ---")
+        structure2 = self.get_structure(self.mount_path)
+        self.assertGreater(
+            len(structure2), 0,
+            f"Expected structure to be not empty after 2nd mount, got: {structure2}"
+        )
+        file2, bytes_read2 = self.read_any_file(self.mount_path)
+        self.assertIsNotNone(file2)
+
+        print("\n[SUCCESS] Mount start -> read -> stop -> start -> read lifecycle test completed successfully!")
+
+
+if __name__ == "__main__":
+    unittest.main()