`423a8f2`

i forget, but it's stable

Authored by

espadonne 10 months ago

SHA: 423a8f28ea37411e7ef9f05dcf666fa6c1404802
Parents: 1719aa2
Tree: 67d3657

2 changed files

Status	File	+	-
M	`src/wulftp/core/constants.py`	1	1
M	`src/wulftp/models/remote_model.py`	127	13

src/wulftp/core/constants.pymodified

  class AppConfig:
      """Application configuration"""
      # Window settings
 -    WINDOW_TITLE = "wulFTP - Family Backup Tool"
 +    WINDOW_TITLE = "wulFTP"
      WINDOW_X = 100
      WINDOW_Y = 100
      WINDOW_WIDTH = 1200

src/wulftp/models/remote_model.pymodified

      errorOccurred = pyqtSignal(str)    # Emitted on errors
      filesDropped = pyqtSignal(list, str)  # Emitted when files are dropped (files, target_directory)
      rootPathChanged = pyqtSignal(str)  # Emitted when the root path changes
 +    accessDenied = pyqtSignal(str, str)  # Emitted on permission errors (attempted_path, fallback_path)
      def __init__(self, sftp: Optional[SFTPClient] = None, parent: Optional[QObject] = None):
          super().__init__(parent)
          self.sftp = sftp
          self.root_path = "/"
          self.current_root_path = "/"  # The path that's currently shown as root
 +        self.last_valid_path = "/"  # Track last successfully accessed path
 +        self.user_home_path = "/"  # Will be set when connection is established
          # Create a proper root item with valid attributes
          root_attr = SFTPAttributes()
          # Track expanded directories
          self._expanded_paths: Set[str] = set()
++
 +        # Track paths we've had permission errors on
 +        self._permission_denied_paths: Set[str] = set()
      def set_sftp(self, sftp: SFTPClient):
          """Set or update the SFTP connection"""
          self.sftp = sftp
          self._path_cache.clear()
          self._expanded_paths.clear()
 +        self._permission_denied_paths.clear()
          self.root_item.children = None
          self.current_root_path = "/"
 +        self.last_valid_path = "/"
          self.endResetModel()
          if sftp:
 +            # Try to get user's home directory
 +            try:
 +                self.user_home_path = sftp.normalize(".")
 +                self.last_valid_path = self.user_home_path
 +            except:
 +                self.user_home_path = "/"
++
              self.load_directory("/")
      def set_root_path(self, path: str):
          if not self.sftp:
              return
 +        # Don't try to access paths we know are denied
 +        if path in self._permission_denied_paths:
 +            self.errorOccurred.emit(f"Access denied to {path}")
 +            return
++
          # Don't reset if we're already at this path
          if path == self.current_root_path:
              # Just reload the directory without resetting
              self.load_directory(path)
              return
 +        # Store the current path as last valid before attempting change
 +        old_path = self.current_root_path
++
          self.beginResetModel()
          self.current_root_path = path
          self._path_cache.clear()
              self.root_item.full_path = path
              self.root_item.children = None
 -            # Load the directory
 -            self.load_directory(path)
 +            # Try to load the directory
 +            if self.load_directory(path):
 +                # Success - update last valid path
 +                self.last_valid_path = path
 +            else:
 +                # Failed to load - will be handled by load_directory
 +                pass
 +        except PermissionError as e:
 +            self._handle_permission_error(path, old_path, str(e))
          except Exception as e:
 -            self.errorOccurred.emit(f"Failed to change to directory: {str(e)}")
 -            # Restore to root on error
 -            self.current_root_path = "/"
 -            root_attr = SFTPAttributes()
 -            root_attr.st_mode = stat.S_IFDIR | 0o755
 -            root_attr.st_size = 0
 -            root_attr.st_mtime = 0
 -            root_attr.filename = "/"
 -            self.root_item = RemoteFileInfo(root_attr, "/", "")
 -            self.root_item.children = []
 +            self._handle_general_error(path, old_path, str(e))
          self.endResetModel()
          self.rootPathChanged.emit(self.current_root_path)
 +    def _handle_permission_error(self, attempted_path: str, fallback_path: str, error_msg: str):
 +        """Handle permission denied errors"""
 +        # Track this path as denied
 +        self._permission_denied_paths.add(attempted_path)
++
 +        # Determine safe fallback
 +        safe_path = self._get_safe_fallback_path(fallback_path)
++
 +        # Emit signal for UI to show message
 +        self.accessDenied.emit(attempted_path, safe_path)
++
 +        # Navigate to safe path
 +        self.current_root_path = safe_path
 +        try:
 +            attrs = self.sftp.stat(safe_path)
 +            self.root_item = RemoteFileInfo(attrs, os.path.basename(safe_path) if safe_path != "/" else "/",
 +                                          os.path.dirname(safe_path) if safe_path != "/" else "")
 +            self.root_item.full_path = safe_path
 +            self.root_item.children = None
 +            self.load_directory(safe_path)
 +        except:
 +            # Even fallback failed, go to root
 +            self._navigate_to_root()
++
 +    def _handle_general_error(self, attempted_path: str, fallback_path: str, error_msg: str):
 +        """Handle general errors when changing directories"""
 +        self.errorOccurred.emit(f"Failed to access {attempted_path}: {error_msg}")
++
 +        # Try to restore previous path
 +        safe_path = self._get_safe_fallback_path(fallback_path)
 +        self.current_root_path = safe_path
++
 +        try:
 +            attrs = self.sftp.stat(safe_path)
 +            self.root_item = RemoteFileInfo(attrs, os.path.basename(safe_path) if safe_path != "/" else "/",
 +                                          os.path.dirname(safe_path) if safe_path != "/" else "")
 +            self.root_item.full_path = safe_path
 +            self.root_item.children = None
 +            self.load_directory(safe_path)
 +        except:
 +            # Even fallback failed, go to root
 +            self._navigate_to_root()
++
 +    def _get_safe_fallback_path(self, preferred_path: str) -> str:
 +        """Get a safe fallback path to navigate to"""
 +        # Try paths in order: preferred, last valid, user home, root
 +        paths_to_try = [
 +            preferred_path,
 +            self.last_valid_path,
 +            self.user_home_path,
 +            "/"
 +        ]
++
 +        for path in paths_to_try:
 +            if path and path not in self._permission_denied_paths:
 +                try:
 +                    # Quick check if we can access it
 +                    if self.sftp:
 +                        self.sftp.stat(path)
 +                        return path
 +                except:
 +                    continue
++
 +        return "/"  # Ultimate fallback
++
 +    def _navigate_to_root(self):
 +        """Navigate to root directory as last resort"""
 +        self.current_root_path = "/"
 +        root_attr = SFTPAttributes()
 +        root_attr.st_mode = stat.S_IFDIR | 0o755
 +        root_attr.st_size = 0
 +        root_attr.st_mtime = 0
 +        root_attr.filename = "/"
 +        self.root_item = RemoteFileInfo(root_attr, "/", "")
 +        self.root_item.children = []
++
      def rootPath(self) -> str:
          """Get the current root path"""
          return self.current_root_path
              # Normalize path
              path = os.path.normpath(path)
 +            # Check if we've already been denied access
 +            if path in self._permission_denied_paths:
 +                return False
++
              # Fetch directory listing
              attrs = self.sftp.listdir_attr(path)
              self.directoryLoaded.emit(path)
              return True
 +        except PermissionError as e:
 +            # Track permission denied
 +            self._permission_denied_paths.add(path)
 +            # Only emit error if this is the path we're trying to view
 +            if path == self.current_root_path:
 +                self.accessDenied.emit(path, self.last_valid_path)
 +            return False
          except Exception as e:
 -            self.errorOccurred.emit(str(e))
 +            # Only emit error if this is the path we're trying to view
 +            if path == self.current_root_path:
 +                self.errorOccurred.emit(f"Failed to load {path}: {str(e)}")
              return False
      def refresh(self, preserve_state: bool = True):
              # On error, just do a full reload of this directory
              self.load_directory(path)
 +    def clear_permission_cache(self):
 +        """Clear the permission denied cache - useful after reconnecting"""
 +        self._permission_denied_paths.clear()
++
      def _find_item_by_path(self, path: str) -> Optional[RemoteFileInfo]:
          """Find item by path traversing the tree"""
          if path == self.current_root_path: