ttnn-visualizer 0.41.0__py3-none-any.whl → 0.42.0__py3-none-any.whl

ttnn_visualizer/sftp_operations.py

@@ -6,25 +6,29 @@ import json
 import logging
 import re
 import time
+import subprocess
 from pathlib import Path
 from stat import S_ISDIR
 from threading import Thread
 from typing import List, Optional
 
 from flask import current_app
-from paramiko.client import SSHClient
-from paramiko.sftp_client import SFTPClient
 
 from ttnn_visualizer.decorators import remote_exception_handler
 from ttnn_visualizer.enums import ConnectionTestStates
-from ttnn_visualizer.exceptions import NoProjectsException, RemoteConnectionException
+from ttnn_visualizer.exceptions import (
+    NoProjectsException,
+    RemoteConnectionException,
+    SSHException,
+    AuthenticationException,
+    NoValidConnectionsError
+)
 from ttnn_visualizer.models import RemoteConnection, RemoteReportFolder
 from ttnn_visualizer.sockets import (
     FileProgress,
     FileStatus,
     emit_file_status,
 )
-from ttnn_visualizer.ssh_client import get_client
 from ttnn_visualizer.utils import update_last_synced
 
 logger = logging.getLogger(__name__)
@@ -34,6 +38,45 @@ TEST_PROFILER_FILE = "profile_log_device.csv"
 REPORT_DATA_DIRECTORY = Path(__file__).parent.absolute().joinpath("data")
 
 
+def handle_ssh_subprocess_error(e: subprocess.CalledProcessError, remote_connection: RemoteConnection):
+    """
+    Convert subprocess SSH errors to appropriate SSH exceptions.
+
+    :param e: The subprocess.CalledProcessError
+    :param remote_connection: The RemoteConnection object for context
+    :raises: SSHException, AuthenticationException, or NoValidConnectionsError
+    """
+    stderr = e.stderr.lower() if e.stderr else ""
+
+    # Check for authentication failures
+    if any(auth_err in stderr for auth_err in [
+        "permission denied",
+        "authentication failed",
+        "publickey",
+        "password",
+        "host key verification failed"
+    ]):
+        raise AuthenticationException(f"SSH authentication failed: {e.stderr}")
+
+    # Check for connection failures
+    elif any(conn_err in stderr for conn_err in [
+        "connection refused",
+        "network is unreachable",
+        "no route to host",
+        "name or service not known",
+        "connection timed out"
+    ]):
+        raise NoValidConnectionsError(f"SSH connection failed: {e.stderr}")
+
+    # Check for general SSH protocol errors
+    elif "ssh:" in stderr or "protocol" in stderr:
+        raise SSHException(f"SSH protocol error: {e.stderr}")
+
+    # Default to generic SSH exception
+    else:
+        raise SSHException(f"SSH command failed: {e.stderr}")
+
+
 def start_background_task(task, *args):
     with current_app.app_context():
         if current_app.config["USE_WEBSOCKETS"]:
@@ -57,31 +100,55 @@ def resolve_file_path(remote_connection, file_path: str) -> str:
     :return: The resolved file path.
     :raises FileNotFoundError: If no files match the pattern.
     """
-    ssh_client = get_client(remote_connection)
-
     if "*" in file_path:
-        command = f"ls -1 {file_path}"
-        stdin, stdout, stderr = ssh_client.exec_command(command)
-        files = stdout.read().decode().splitlines()
-        ssh_client.close()
+        # Build SSH command to list files matching the pattern
+        ssh_cmd = [
+            "ssh",
+            f"{remote_connection.username}@{remote_connection.host}",
+        ]
 
-        if not files:
-            raise FileNotFoundError(f"No files found matching pattern: {file_path}")
+        # Handle non-standard SSH port
+        if remote_connection.port != 22:
+            ssh_cmd.extend(["-p", str(remote_connection.port)])
 
-        # Return the first file found
-        return files[0]
+        # Add the ls command
+        ssh_cmd.append(f"ls -1 {file_path}")
 
-    return file_path
+        try:
+            result = subprocess.run(
+                ssh_cmd,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+
+            files = result.stdout.strip().splitlines()
 
+            if not files or (len(files) == 1 and files[0] == ""):
+                raise FileNotFoundError(f"No files found matching pattern: {file_path}")
 
-def calculate_folder_size(client: SSHClient, folder_path: str) -> int:
-    """Calculate the total size of the folder before compression."""
-    stdin, stdout, stderr = client.exec_command(f"du -sb {folder_path}")
-    size_info = stdout.read().decode().strip().split("\t")[0]
-    return int(size_info)
+            # Return the first file found
+            return files[0]
 
+        except subprocess.CalledProcessError as e:
+            logger.error(f"SSH command failed: {e}")
+            logger.error(f"stderr: {e.stderr}")
 
-def get_cluster_desc_path(ssh_client) -> Optional[str]:
+            # Check if it's an SSH-specific error (authentication, connection, etc.)
+            if e.returncode == 255:  # SSH returns 255 for SSH protocol errors
+                handle_ssh_subprocess_error(e, remote_connection)
+            else:
+                # File not found or other command error
+                raise FileNotFoundError(f"No files found matching pattern: {file_path}")
+        except Exception as e:
+            logger.error(f"Error resolving file path: {e}")
+            raise FileNotFoundError(f"Error resolving file path: {file_path}")
+
+    return file_path
+
+
+
+def get_cluster_desc_path(remote_connection: RemoteConnection) -> Optional[str]:
     """
     List all folders matching '/tmp/umd_*' on the remote machine, filter for those containing
     'cluster_descriptor.yaml', and return the full path to the most recently modified YAML file.
@@ -94,37 +161,79 @@ def get_cluster_desc_path(ssh_client) -> Optional[str]:
     cluster_desc_file = "cluster_descriptor.yaml"
 
     try:
-        # Command to list all folders matching '/tmp/umd_*'
-        list_folders_command = "ls -1d /tmp/umd_* 2>/dev/null"
-        stdin, stdout, stderr = ssh_client.exec_command(list_folders_command)
+        # Build SSH command to list folders matching '/tmp/umd_*'
+        ssh_cmd = [
+            "ssh",
+            f"{remote_connection.username}@{remote_connection.host}",
+        ]
+
+        # Handle non-standard SSH port
+        if remote_connection.port != 22:
+            ssh_cmd.extend(["-p", str(remote_connection.port)])
+
+        # Add the ls command
+        ssh_cmd.append("ls -1d /tmp/umd_* 2>/dev/null")
+
+        # Execute SSH command to list folders
+        result = subprocess.run(
+            ssh_cmd,
+            capture_output=True,
+            text=True,
+            check=False  # Don't raise exception on non-zero exit (in case no folders found)
+        )
 
         # Get the list of folders
-        folder_paths = stdout.read().decode().splitlines()
+        folder_paths = result.stdout.strip().splitlines() if result.stdout.strip() else []
 
         if not folder_paths:
             logger.info("No folders found matching the pattern '/tmp/umd_*'")
             return None
 
         # Check each folder for 'cluster_descriptor.yaml' and track the most recent one
-        with ssh_client.open_sftp() as sftp:
-            for folder in folder_paths:
-                yaml_file_path = f"{folder}/{cluster_desc_file}"
-                try:
-                    # Check if 'cluster_descriptor.yaml' exists and get its modification time
-                    attributes = sftp.stat(yaml_file_path)
-                    mod_time = attributes.st_mtime  # Modification time
-
-                    # Update the latest file if this one is newer
-                    if mod_time > latest_mod_time:
-                        latest_mod_time = mod_time
-                        latest_yaml_path = yaml_file_path
-                        logger.info(
-                            f"Found newer {cluster_desc_file}': {yaml_file_path}"
-                        )
-
-                except FileNotFoundError:
+        for folder in folder_paths:
+            yaml_file_path = f"{folder}/{cluster_desc_file}"
+
+            # Build SSH command to check if file exists and get its modification time
+            stat_cmd = [
+                "ssh",
+                f"{remote_connection.username}@{remote_connection.host}",
+            ]
+
+            if remote_connection.port != 22:
+                stat_cmd.extend(["-p", str(remote_connection.port)])
+
+            # Use stat to get modification time (seconds since epoch)
+            stat_cmd.append(f"stat -c %Y '{yaml_file_path}' 2>/dev/null")
+
+            try:
+                stat_result = subprocess.run(
+                    stat_cmd,
+                    capture_output=True,
+                    text=True,
+                    check=True
+                )
+
+                mod_time = float(stat_result.stdout.strip())
+
+                # Update the latest file if this one is newer
+                if mod_time > latest_mod_time:
+                    latest_mod_time = mod_time
+                    latest_yaml_path = yaml_file_path
+                    logger.info(
+                        f"Found newer {cluster_desc_file}: {yaml_file_path}"
+                    )
+
+            except subprocess.CalledProcessError as e:
+                # Check if it's an SSH-specific error
+                if e.returncode == 255:  # SSH returns 255 for SSH protocol errors
+                    handle_ssh_subprocess_error(e, remote_connection)
+                else:
+                    # File not found or other command error
                     logger.debug(f"'{cluster_desc_file}' not found in: {folder}")
                     continue
+            except ValueError:
+                logger.debug(f"'{cluster_desc_file}' not found in: {folder}")
+                continue
 
         if latest_yaml_path:
             logger.info(
@@ -142,173 +251,377 @@ def get_cluster_desc_path(ssh_client) -> Optional[str]:
             message=f"Failed to get '{cluster_desc_file}' path",
             status=ConnectionTestStates.FAILED,
         )
-    finally:
-        ssh_client.close()
 
 
 @remote_exception_handler
 def get_cluster_desc(remote_connection: RemoteConnection):
-    client = get_client(remote_connection)
-    cluster_path = get_cluster_desc_path(client)
+    cluster_path = get_cluster_desc_path(remote_connection)
     if cluster_path:
         return read_remote_file(remote_connection, cluster_path)
     else:
         return None
 
 
-def walk_sftp_directory(sftp: SFTPClient, remote_path: str):
-    """SFTP implementation of os.walk."""
-    files, folders = [], []
-    for f in sftp.listdir_attr(remote_path):
-        if S_ISDIR(f.st_mode if f.st_mode else 0):
-            folders.append(f.filename)
-        else:
-            files.append(f.filename)
-    return files, folders
-
-
 def is_excluded(file_path, exclude_patterns):
-    """Check if the file matches any exclusion pattern."""
-    return any(re.search(pattern, file_path) for pattern in exclude_patterns)
+    """Check if a file path should be excluded based on patterns."""
+    for pattern in exclude_patterns:
+        if pattern in file_path:
+            return True
+    return False
 
 
 @remote_exception_handler
 def sync_files_and_directories(
-    client, remote_profiler_folder: str, destination_dir: Path, exclude_patterns=None, sid=None
+    remote_connection: RemoteConnection, remote_profiler_folder: str, destination_dir: Path, exclude_patterns=None, sid=None
 ):
-    """Download files and directories sequentially in one unified loop."""
-    exclude_patterns = (
-        exclude_patterns or []
-    )  # Default to an empty list if not provided
-
-    with client.open_sftp() as sftp:
-        # Ensure the destination directory exists
-        destination_dir.mkdir(parents=True, exist_ok=True)
-        finished_files = 0  # Initialize finished files counter
-
-        # Recursively handle files and folders in the current directory
-        def download_directory_contents(remote_dir, local_dir):
-            # Ensure the local directory exists
-            local_dir.mkdir(parents=True, exist_ok=True)
-
-            # Get files and folders in the remote directory
-            files, folders = walk_sftp_directory(sftp, remote_dir)
-            total_files = len(files)
-
-            # Function to download a file with progress reporting
-            def download_file(remote_file_path, local_file_path, index):
-                nonlocal finished_files
-                # Download file with progress callback
-                logger.info(f"Downloading {remote_file_path}")
-                download_file_with_progress(
-                    sftp,
-                    remote_file_path,
-                    local_file_path,
-                    sid,
-                    total_files,
-                    finished_files,
-                )
-                logger.info(f"Finished downloading {remote_file_path}")
-                finished_files += 1
+    """Download files and directories using SFTP with progress reporting."""
+    exclude_patterns = exclude_patterns or []
 
-            # Download all files in the current directory
-            for index, file in enumerate(files, start=1):
-                remote_file_path = f"{remote_dir}/{file}"
-                local_file_path = Path(local_dir, file)
+    # Ensure the destination directory exists
+    destination_dir.mkdir(parents=True, exist_ok=True)
 
-                # Skip files that match any exclusion pattern
-                if is_excluded(remote_file_path, exclude_patterns):
-                    logger.info(f"Skipping {remote_file_path} (excluded by pattern)")
-                    continue
+    logger.info(f"Starting SFTP sync from {remote_profiler_folder} to {destination_dir}")
 
-                download_file(remote_file_path, local_file_path, index)
+    # First, get list of all files and directories
+    logger.info("Getting remote file and directory lists...")
+    all_files = get_remote_file_list(remote_connection, remote_profiler_folder, exclude_patterns)
+    all_dirs = get_remote_directory_list(remote_connection, remote_profiler_folder, exclude_patterns)
 
-            # Recursively handle subdirectories
-            for folder in folders:
-                remote_subdir = f"{remote_dir}/{folder}"
-                local_subdir = local_dir / folder
-                if is_excluded(remote_subdir, exclude_patterns):
-                    logger.info(
-                        f"Skipping directory {remote_subdir} (excluded by pattern)"
-                    )
-                    continue
-                download_directory_contents(remote_subdir, local_subdir)
+    logger.info(f"Found {len(all_files)} files and {len(all_dirs)} directories to sync")
 
-        # Start downloading from the root folder
-        download_directory_contents(remote_profiler_folder, destination_dir)
+    # Create local directory structure
+    logger.info("Creating local directory structure...")
+    for remote_dir in all_dirs:
+        try:
+            # Calculate relative path from the base remote folder
+            relative_path = Path(remote_dir).relative_to(remote_profiler_folder)
+            local_dir = destination_dir / relative_path
+            local_dir.mkdir(parents=True, exist_ok=True)
+        except ValueError:
+            # Skip if remote_dir is not relative to remote_profiler_folder
+            continue
 
-        # Create a .last-synced file in directory
-        update_last_synced(destination_dir)
+    # Download files with progress reporting
+    total_files = len(all_files)
+    finished_files = 0
 
-        # Emit final status
-        final_progress = FileProgress(
-            current_file_name="",  # No specific file for the final status
-            number_of_files=0,
-            percent_of_current=100,
-            finished_files=finished_files,
-            status=FileStatus.FINISHED,
-        )
+    logger.info(f"Starting download of {total_files} files...")
 
-        if current_app.config["USE_WEBSOCKETS"]:
-            emit_file_status(final_progress, sid)
-        logger.info("All files downloaded. Final progress emitted.")
+    for remote_file in all_files:
+        try:
+            # Calculate relative path from the base remote folder
+            relative_path = Path(remote_file).relative_to(remote_profiler_folder)
+            local_file = destination_dir / relative_path
 
+            # Download the file using SFTP
+            download_single_file_sftp(remote_connection, remote_file, local_file)
 
-def download_file_with_progress(
-    sftp, remote_path, local_path, sid, total_files, finished_files
-):
-    """Download a file and emit progress using FileProgress."""
-    try:
+            finished_files += 1
 
-        def download_progress_callback(transferred, total):
-            percent_of_current = (transferred / total) * 100
+            # Emit progress
             progress = FileProgress(
-                current_file_name=remote_path,
+                current_file_name=str(relative_path),
                 number_of_files=total_files,
-                percent_of_current=percent_of_current,
+                percent_of_current=100,  # We don't get per-file progress with SFTP
                 finished_files=finished_files,
                 status=FileStatus.DOWNLOADING,
             )
-            emit_file_status(progress, sid)
 
-        # Perform the download
-        sftp.get(remote_path, str(local_path), callback=download_progress_callback)
+            if current_app.config["USE_WEBSOCKETS"]:
+                emit_file_status(progress, sid)
+
+            if finished_files % 10 == 0:  # Log every 10 files
+                logger.info(f"Downloaded {finished_files}/{total_files} files")
+
+        except ValueError:
+            # Skip if remote_file is not relative to remote_profiler_folder
+            logger.warning(f"Skipping file outside base folder: {remote_file}")
+            continue
+        except Exception as e:
+            logger.error(f"Failed to download {remote_file}: {e}")
+            # Continue with other files rather than failing completely
+            continue
+
+    # Create a .last-synced file in directory
+    update_last_synced(destination_dir)
+
+    # Emit final status
+    final_progress = FileProgress(
+        current_file_name="",
+        number_of_files=total_files,
+        percent_of_current=100,
+        finished_files=finished_files,
+        status=FileStatus.FINISHED,
+    )
+
+    if current_app.config["USE_WEBSOCKETS"]:
+        emit_file_status(final_progress, sid)
+
+    logger.info(f"SFTP sync completed. Downloaded {finished_files}/{total_files} files.")
+
+
+def get_remote_file_list(remote_connection: RemoteConnection, remote_folder: str, exclude_patterns=None) -> List[str]:
+    """Get a list of all files in the remote directory recursively, applying exclusion patterns."""
+    exclude_patterns = exclude_patterns or []
+
+    # Build SSH command to find all files recursively
+    ssh_cmd = ["ssh"]
+
+    # Handle non-standard SSH port
+    if remote_connection.port != 22:
+        ssh_cmd.extend(["-p", str(remote_connection.port)])
+
+    ssh_cmd.extend([
+        f"{remote_connection.username}@{remote_connection.host}",
+        f"find '{remote_folder}' -type f"
+    ])
+
+    try:
+        result = subprocess.run(
+            ssh_cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=60
+        )
+
+        all_files = result.stdout.strip().splitlines()
+
+        # Filter out excluded files
+        filtered_files = []
+        for file_path in all_files:
+            if not is_excluded(file_path, exclude_patterns):
+                filtered_files.append(file_path.strip())
+
+        return filtered_files
+
+    except subprocess.CalledProcessError as e:
+        if e.returncode == 255:  # SSH protocol errors
+            handle_ssh_subprocess_error(e, remote_connection)
+            return []
+        else:
+            logger.error(f"Error getting file list: {e.stderr}")
+            return []
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout getting file list from: {remote_folder}")
+        return []
+    except Exception as e:
+        logger.error(f"Error getting file list: {e}")
+        return []
+
+
+def get_remote_directory_list(remote_connection: RemoteConnection, remote_folder: str, exclude_patterns=None) -> List[str]:
+    """Get a list of all directories in the remote directory recursively, applying exclusion patterns."""
+    exclude_patterns = exclude_patterns or []
+
+    # Build SSH command to find all directories recursively
+    ssh_cmd = ["ssh"]
+
+    # Handle non-standard SSH port
+    if remote_connection.port != 22:
+        ssh_cmd.extend(["-p", str(remote_connection.port)])
+
+    ssh_cmd.extend([
+        f"{remote_connection.username}@{remote_connection.host}",
+        f"find '{remote_folder}' -type d"
+    ])
+
+    try:
+        result = subprocess.run(
+            ssh_cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=60
+        )
+
+        all_dirs = result.stdout.strip().splitlines()
+
+        # Filter out excluded directories
+        filtered_dirs = []
+        for dir_path in all_dirs:
+            if not is_excluded(dir_path, exclude_patterns):
+                filtered_dirs.append(dir_path.strip())
+
+        return filtered_dirs
 
-    except OSError as e:
-        logger.error(f"Error downloading file {remote_path} to {local_path}: {str(e)}")
-        raise
+    except subprocess.CalledProcessError as e:
+        if e.returncode == 255:  # SSH protocol errors
+            handle_ssh_subprocess_error(e, remote_connection)
+            return []
+        else:
+            logger.error(f"Error getting directory list: {e.stderr}")
+            return []
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout getting directory list from: {remote_folder}")
+        return []
+    except Exception as e:
+        logger.error(f"Error getting directory list: {e}")
+        return []
+
+
+def download_single_file_sftp(remote_connection: RemoteConnection, remote_file: str, local_file: Path):
+    """Download a single file using SFTP."""
+    # Ensure local directory exists
+    local_file.parent.mkdir(parents=True, exist_ok=True)
+
+    # Build SFTP command
+    sftp_cmd = ["sftp"]
+
+    # Handle non-standard SSH port
+    if remote_connection.port != 22:
+        sftp_cmd.extend(["-P", str(remote_connection.port)])
+
+    # Add batch mode and other options
+    sftp_cmd.extend([
+        "-b", "-",  # Read commands from stdin
+        f"{remote_connection.username}@{remote_connection.host}"
+    ])
+
+    # SFTP commands to execute
+    sftp_commands = f"get '{remote_file}' '{local_file}'\nquit\n"
+
+    try:
+        result = subprocess.run(
+            sftp_cmd,
+            input=sftp_commands,
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=300  # 5 minute timeout per file
+        )
+
+        logger.debug(f"Downloaded: {remote_file} -> {local_file}")
+
+    except subprocess.CalledProcessError as e:
+        if e.returncode == 255:  # SSH protocol errors
+            handle_ssh_subprocess_error(e, remote_connection)
+        else:
+            logger.error(f"Error downloading file {remote_file}: {e.stderr}")
+            raise RuntimeError(f"Failed to download {remote_file}")
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout downloading file: {remote_file}")
+        raise RuntimeError(f"Timeout downloading {remote_file}")
+    except Exception as e:
+        logger.error(f"Error downloading file {remote_file}: {e}")
+        raise RuntimeError(f"Failed to download {remote_file}")
 
 
 def get_remote_profiler_folder_from_config_path(
-    sftp: SFTPClient, config_path: str
+    remote_connection: RemoteConnection, config_path: str
 ) -> RemoteReportFolder:
     """Read a remote config file and return RemoteFolder object."""
-    attributes = sftp.lstat(str(config_path))
-    with sftp.open(str(config_path), "rb") as config_file:
-        data = json.loads(config_file.read())
+    try:
+        # Build SSH command to get file modification time
+        stat_cmd = [
+            "ssh",
+            f"{remote_connection.username}@{remote_connection.host}",
+        ]
+
+        # Handle non-standard SSH port
+        if remote_connection.port != 22:
+            stat_cmd.extend(["-p", str(remote_connection.port)])
+
+        # Get modification time using stat command
+        stat_cmd.append(f"stat -c %Y '{config_path}' 2>/dev/null")
+
+        stat_result = subprocess.run(
+            stat_cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+
+        last_modified = int(float(stat_result.stdout.strip()))
 
+        # Build SSH command to read file content
+        cat_cmd = [
+            "ssh",
+            f"{remote_connection.username}@{remote_connection.host}",
+        ]
+
+        if remote_connection.port != 22:
+            cat_cmd.extend(["-p", str(remote_connection.port)])
+
+        # Read file content using cat command
+        cat_cmd.append(f"cat '{config_path}'")
+
+        cat_result = subprocess.run(
+            cat_cmd,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+
+        # Parse JSON data
+        data = json.loads(cat_result.stdout)
         report_name = data.get("report_name")
         logger.info(f"********* report_name: {report_name}")
 
         return RemoteReportFolder(
             remotePath=str(Path(config_path).parent),
             reportName=report_name,
-            lastModified=(
-                int(attributes.st_mtime) if attributes.st_mtime else int(time.time())
-            ),
+            lastModified=last_modified,
+        )
+
+    except subprocess.CalledProcessError as e:
+        logger.error(f"SSH command failed while reading config: {e}")
+        logger.error(f"stderr: {e.stderr}")
+
+        # Check if it's an SSH-specific error (authentication, connection, etc.)
+        if e.returncode == 255:  # SSH returns 255 for SSH protocol errors
+            handle_ssh_subprocess_error(e, remote_connection)
+            # This line never executes as handle_ssh_subprocess_error raises an exception
+            return RemoteReportFolder(
+                remotePath=str(Path(config_path).parent),
+                reportName="",
+                lastModified=int(time.time()),
+            )
+        else:
+            # Fall back to current time if we can't get modification time
+            return RemoteReportFolder(
+                remotePath=str(Path(config_path).parent),
+                reportName="",
+                lastModified=int(time.time()),
+            )
+    except (json.JSONDecodeError, ValueError) as e:
+        logger.error(f"Error parsing config file {config_path}: {e}")
+        # Fall back to current time and no report name
+        return RemoteReportFolder(
+            remotePath=str(Path(config_path).parent),
+            reportName="",
+            lastModified=int(time.time()),
         )
 
 
 def get_remote_performance_folder(
-    sftp: SFTPClient, profile_folder: str
+    remote_connection: RemoteConnection, profile_folder: str
 ) -> RemoteReportFolder:
-    """Read a remote config file and return RemoteFolder object."""
-    attributes = sftp.stat(str(profile_folder))
+    """Get remote performance folder info and return RemoteFolder object."""
     performance_name = profile_folder.split("/")[-1]
     remote_path = profile_folder
-    last_modified = (
-        int(attributes.st_mtime) if attributes.st_mtime else int(time.time())
-    )
+
+    # Get modification time using subprocess SSH command
+    try:
+        ssh_command = ["ssh"]
+        if remote_connection.port != 22:
+            ssh_command.extend(["-p", str(remote_connection.port)])
+        ssh_command.extend([f"{remote_connection.username}@{remote_connection.host}", f"stat -c %Y '{profile_folder}'"])
+
+        result = subprocess.run(ssh_command, capture_output=True, text=True, timeout=30)
+
+        if result.returncode == 0:
+            last_modified = int(result.stdout.strip())
+        else:
+            # If stat fails, handle SSH errors
+            if result.returncode == 255:
+                handle_ssh_subprocess_error(subprocess.CalledProcessError(result.returncode, ssh_command, result.stdout, result.stderr), remote_connection)
+            logger.warning(f"Could not get modification time for {profile_folder}, using current time")
+            last_modified = int(time.time())
+    except (subprocess.TimeoutExpired, subprocess.CalledProcessError, ValueError) as e:
+        logger.warning(f"Error getting modification time for {profile_folder}: {e}, using current time")
+        last_modified = int(time.time())
+
     return RemoteReportFolder(
         remotePath=str(remote_path),
         reportName=str(performance_name),
@@ -321,37 +634,55 @@ def read_remote_file(
     remote_connection,
     remote_path=None,
 ):
-    """Read a remote file."""
-    ssh_client = get_client(remote_connection)
-    with ssh_client.open_sftp() as sftp:
-        if remote_path:
-            path = Path(remote_path)
-        else:
-            path = Path(remote_connection.profilerPath)
+    """Read a remote file using SSH cat command."""
+    if remote_path:
+        path = Path(remote_path)
+    else:
+        path = Path(remote_connection.profilerPath)
 
-        logger.info(f"Opening remote file {path}")
-        directory_path = str(path.parent)
-        file_name = str(path.name)
+    logger.info(f"Reading remote file {path}")
 
-        try:
-            sftp.chdir(path=directory_path)
-            with sftp.open(filename=file_name) as file:
-                content = file.read()
-                return content
-        except FileNotFoundError:
-            logger.error(f"File not found: {path}")
+    # Build SSH command to read the file
+    ssh_cmd = ["ssh"]
+
+    # Handle non-standard SSH port
+    if remote_connection.port != 22:
+        ssh_cmd.extend(["-p", str(remote_connection.port)])
+
+    ssh_cmd.extend([
+        f"{remote_connection.username}@{remote_connection.host}",
+        f"cat '{path}'"
+    ])
+
+    try:
+        result = subprocess.run(
+            ssh_cmd,
+            capture_output=True,
+            check=True,
+            timeout=30
+        )
+        return result.stdout
+    except subprocess.CalledProcessError as e:
+        if e.returncode == 255:  # SSH protocol errors
+            handle_ssh_subprocess_error(e, remote_connection)
             return None
-        except IOError as e:
-            logger.error(f"Error reading remote file {path}: {e}")
+        else:
+            # File not found or other command error
+            logger.error(f"File not found or cannot be read: {path}")
             return None
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout reading remote file: {path}")
+        return None
+    except Exception as e:
+        logger.error(f"Error reading remote file {path}: {e}")
+        return None
 
 
 @remote_exception_handler
 def check_remote_path_for_reports(remote_connection):
     """Check the remote path for config files."""
-    ssh_client = get_client(remote_connection)
     remote_config_paths = find_folders_by_files(
-        ssh_client, remote_connection.profilerPath, [TEST_CONFIG_FILE]
+        remote_connection, remote_connection.profilerPath, [TEST_CONFIG_FILE]
     )
     if not remote_config_paths:
         raise NoProjectsException(
@@ -362,42 +693,131 @@ def check_remote_path_for_reports(remote_connection):
 
 @remote_exception_handler
 def check_remote_path_exists(remote_connection: RemoteConnection, path_key: str):
-    client = get_client(remote_connection)
-    sftp = client.open_sftp()
-    # Attempt to list the directory to see if it exists
+    """Check if a remote path exists using SSH test command."""
+    path = getattr(remote_connection, path_key)
+
+    # Build SSH command to test if path exists
+    ssh_cmd = ["ssh"]
+
+    # Handle non-standard SSH port
+    if remote_connection.port != 22:
+        ssh_cmd.extend(["-p", str(remote_connection.port)])
+
+    ssh_cmd.extend([
+        f"{remote_connection.username}@{remote_connection.host}",
+        f"test -d '{path}'"
+    ])
+
     try:
-        sftp.stat(getattr(remote_connection, path_key))
-    except IOError as e:
-        # Directory does not exist or is inaccessible
-        if path_key == "performancePath":
-            message = "Performance directory does not exist or cannot be accessed"
+        result = subprocess.run(
+            ssh_cmd,
+            capture_output=True,
+            check=True,
+            timeout=10
+        )
+        # If command succeeds, directory exists
+        return True
+    except subprocess.CalledProcessError as e:
+        if e.returncode == 255:  # SSH protocol errors
+            handle_ssh_subprocess_error(e, remote_connection)
         else:
-            message = "Profiler directory does not exist or cannot be accessed"
-
-        logger.error(message)
+            # Directory does not exist or is inaccessible
+            if path_key == "performancePath":
+                message = "Performance directory does not exist or cannot be accessed"
+            else:
+                message = "Profiler directory does not exist or cannot be accessed"
+
+            logger.error(message)
+            raise RemoteConnectionException(
+                message=message, status=ConnectionTestStates.FAILED
+            )
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout checking remote path: {path}")
         raise RemoteConnectionException(
-            message=message, status=ConnectionTestStates.FAILED
+            message=f"Timeout checking remote path: {path}",
+            status=ConnectionTestStates.FAILED
         )
 
 
 def find_folders_by_files(
-    ssh_client, root_folder: str, file_names: List[str]
+    remote_connection: RemoteConnection, root_folder: str, file_names: List[str]
 ) -> List[str]:
     """Given a remote path, return a list of top-level folders that contain any of the specified files."""
     matched_folders: List[str] = []
-    with ssh_client.open_sftp() as sftp:
-        all_files = sftp.listdir_attr(root_folder)
-        top_level_directories = filter(lambda e: S_ISDIR(e.st_mode), all_files)
 
-        for directory in top_level_directories:
-            dirname = Path(root_folder, directory.filename)
-            directory_files = sftp.listdir(str(dirname))
+    # Build SSH command to find directories in root_folder
+    ssh_cmd = ["ssh"]
 
-            # Check if any of the specified file names exist in the directory
-            if any(file_name in directory_files for file_name in file_names):
-                matched_folders.append(str(dirname))
+    # Handle non-standard SSH port
+    if remote_connection.port != 22:
+        ssh_cmd.extend(["-p", str(remote_connection.port)])
 
-    return matched_folders
+    ssh_cmd.extend([
+        f"{remote_connection.username}@{remote_connection.host}",
+        f"find '{root_folder}' -maxdepth 1 -type d -not -path '{root_folder}'"
+    ])
+
+    try:
+        result = subprocess.run(
+            ssh_cmd,
+            capture_output=True,
+            text=True,
+            check=True,
+            timeout=30
+        )
+
+        directories = result.stdout.strip().splitlines()
+
+        # For each directory, check if it contains any of the specified files
+        for directory in directories:
+            directory = directory.strip()
+            if not directory:
+                continue
+
+            # Build SSH command to check for files in this directory
+            file_checks = []
+            for file_name in file_names:
+                file_checks.append(f"test -f '{directory}/{file_name}'")
+
+            # Use OR logic to check if any of the files exist
+            check_cmd = ["ssh"]
+            if remote_connection.port != 22:
+                check_cmd.extend(["-p", str(remote_connection.port)])
+
+            check_cmd.extend([
+                f"{remote_connection.username}@{remote_connection.host}",
+                f"({' || '.join(file_checks)})"
+            ])
+
+            try:
+                check_result = subprocess.run(
+                    check_cmd,
+                    capture_output=True,
+                    check=True,
+                    timeout=10
+                )
+                # If command succeeds, at least one file exists
+                matched_folders.append(directory)
+            except subprocess.CalledProcessError:
+                # None of the files exist in this directory, skip it
+                continue
+
+        return matched_folders
+
+    except subprocess.CalledProcessError as e:
+        if e.returncode == 255:  # SSH protocol errors
+            handle_ssh_subprocess_error(e, remote_connection)
+            # This line should never be reached as handle_ssh_subprocess_error raises an exception
+            return []
+        else:
+            logger.error(f"Error finding folders: {e.stderr}")
+            return []
+    except subprocess.TimeoutExpired:
+        logger.error(f"Timeout finding folders in: {root_folder}")
+        return []
+    except Exception as e:
+        logger.error(f"Error finding folders: {e}")
+        return []
 
 
 @remote_exception_handler
@@ -405,19 +825,22 @@ def get_remote_performance_folders(
     remote_connection: RemoteConnection,
 ) -> List[RemoteReportFolder]:
     """Return a list of remote folders containing a profile_log_device file."""
-    client = get_client(remote_connection)
+    if remote_connection.performancePath is None:
+        error = "Performance path is not configured for this connection"
+        logger.error(error)
+        raise NoProjectsException(status=ConnectionTestStates.FAILED, message=error)
+
     performance_paths = find_folders_by_files(
-        client, remote_connection.performancePath, [TEST_PROFILER_FILE]
+        remote_connection, remote_connection.performancePath, [TEST_PROFILER_FILE]
     )
     if not performance_paths:
         error = f"No profiler paths found at {remote_connection.performancePath}"
         logger.info(error)
         raise NoProjectsException(status=ConnectionTestStates.FAILED, message=error)
     remote_folder_data = []
-    with client.open_sftp() as sftp:
-        for path in performance_paths:
-            remote_folder_data.append(get_remote_performance_folder(sftp, path))
-        return remote_folder_data
+    for path in performance_paths:
+        remote_folder_data.append(get_remote_performance_folder(remote_connection, path))
+    return remote_folder_data
 
 
 @remote_exception_handler
@@ -425,21 +848,19 @@ def get_remote_profiler_folders(
     remote_connection: RemoteConnection,
 ) -> List[RemoteReportFolder]:
     """Return a list of remote folders containing a config.json file."""
-    client = get_client(remote_connection)
     remote_config_paths = find_folders_by_files(
-        client, remote_connection.profilerPath, [TEST_CONFIG_FILE]
+        remote_connection, remote_connection.profilerPath, [TEST_CONFIG_FILE]
     )
     if not remote_config_paths:
         error = f"No projects found at {remote_connection.profilerPath}"
         logger.info(error)
         raise NoProjectsException(status=ConnectionTestStates.FAILED, message=error)
     remote_folder_data = []
-    with client.open_sftp() as sftp:
-        for config_path in remote_config_paths:
-            remote_folder = get_remote_profiler_folder_from_config_path(
-                sftp, str(Path(config_path).joinpath(TEST_CONFIG_FILE))
-            )
-            remote_folder_data.append(remote_folder)
+    for config_path in remote_config_paths:
+        remote_folder = get_remote_profiler_folder_from_config_path(
+            remote_connection, str(Path(config_path).joinpath(TEST_CONFIG_FILE))
+        )
+        remote_folder_data.append(remote_folder)
     return remote_folder_data
 
 
@@ -452,7 +873,6 @@ def sync_remote_profiler_folders(
     sid=None,
 ):
     """Main function to sync test folders, handles both compressed and individual syncs."""
-    client = get_client(remote_connection)
     profiler_folder = Path(remote_folder_path).name
     destination_dir = Path(
         REPORT_DATA_DIRECTORY, path_prefix, remote_connection.host, current_app.config["PROFILER_DIRECTORY_NAME"], profiler_folder
@@ -460,7 +880,7 @@ def sync_remote_profiler_folders(
     destination_dir.mkdir(parents=True, exist_ok=True)
 
     sync_files_and_directories(
-        client, remote_folder_path, destination_dir, exclude_patterns, sid
+        remote_connection, remote_folder_path, destination_dir, exclude_patterns, sid
     )
 
 
@@ -472,7 +892,6 @@ def sync_remote_performance_folders(
     exclude_patterns: Optional[List[str]] = None,
     sid=None,
 ):
-    client = get_client(remote_connection)
     remote_folder_path = profile.remotePath
     profile_folder = Path(remote_folder_path).name
     destination_dir = Path(
@@ -483,7 +902,6 @@ def sync_remote_performance_folders(
         profile_folder,
     )
     destination_dir.mkdir(parents=True, exist_ok=True)
-
     sync_files_and_directories(
-        client, remote_folder_path, destination_dir, exclude_patterns, sid
+        remote_connection, remote_folder_path, destination_dir, exclude_patterns, sid
     )