Update app.py

app.py

@@ -142,115 +142,114 @@ def monitor_dump_size():
 def run_dump(source_conn: str, file_path: str, options: dict):
     """Run pg_dump in a background thread"""
     try:
+        # Convert to absolute path
+        absolute_file_path = os.path.abspath(file_path)
+        
+        # Log the path conversion
+        log_message(f"Converting path: {file_path} -> {absolute_file_path}", "info")
+        
         # Clear any existing file
-        if os.path.exists(file_path):
-            os.remove(file_path)
-
+        if os.path.exists(absolute_file_path):
+            os.remove(absolute_file_path)
+        
         # Set environment variables for connection
         env = os.environ.copy()
-
+        
         # Build pg_dump command
         format_flag = "-F" + options.get("format", "c")  # Default to custom format
-        cmd = ["pg_dump", source_conn, format_flag, "-v", "-f", file_path]
-
+        cmd = ["pg_dump", source_conn, format_flag, "-v", "-f", absolute_file_path]
+        
         # Add schema if specified
         if options.get("schema"):
             cmd.extend(["-n", options["schema"]])
-
+        
         # Add compression level if specified
         if options.get("compression") and options["compression"] != "default":
             cmd.extend(["-Z", options["compression"]])
-
-        log_message(f"Starting database dump to {file_path}", "info", " ".join(cmd))
-
+        
+        log_message(f"Starting database dump to {absolute_file_path}", "info", " ".join(cmd))
+        
         # Start monitoring thread for file size
         monitor_thread = threading.Thread(target=monitor_dump_size, daemon=True)
         monitor_thread.start()
-
+        
         # Start the dump process
         with migration_lock:
             migration_state["start_time"] = time.time()
             migration_state["running"] = True
             migration_state["operation"] = "dump"
-            migration_state["dump_file"] = file_path
+            migration_state["dump_file"] = absolute_file_path
             migration_state["dump_completed"] = False
-            migration_state["previous_size"] = 0 # Reset previous size
-
-        # Use preexec_fn=os.setsid to create a new process group
-        # This is necessary for the killpg logic in stop_current_process
-        # Note: preexec_fn is Unix-specific. This won't work directly on Windows.
-        preexec_fn_to_use = None
-        if hasattr(os, 'setsid'):
-            preexec_fn_to_use = os.setsid
-
+        
         process = subprocess.Popen(
             cmd,
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             env=env,
-            text=True,
-            bufsize=1, # Line buffering
-            universal_newlines=True,
-            preexec_fn=preexec_fn_to_use # Create a new process group
+            text=True
         )
-
+        
         with migration_lock:
             migration_state["process"] = process
-
+        
         # Process output
-        if process.stderr:
-            for line in iter(process.stderr.readline, ''):
-                line = line.strip()
-                if not line:
-                    continue
-                # Update log with verbose output from pg_dump
-                log_message(line, "info")
-                if "dumping contents of table" in line:
-                    try:
-                        table_name = line.split('"')[1] # Extract table name from quotes
-                        with migration_lock:
-                            migration_state["progress"]["current_table"] = table_name
-                            migration_state["progress"]["tables_completed"] += 1
-                    except IndexError:
-                        logger.warning(f"Could not parse table name from line: {line}")
-                # Check if process is still running
+        for line in process.stderr:
+            if "Dumping" in line and "table" in line:
+                table_name = line.split("Dumping")[1].strip().split(" ")[1]
                 with migration_lock:
-                    if not migration_state["running"]:
-                        break # Stop processing if process was terminated
-
+                    migration_state["progress"]["current_table"] = table_name
+                    migration_state["progress"]["tables_completed"] += 1
+                
+                log_message(f"Dumping table: {table_name}", "info")
+        
         # Wait for process to complete
         stdout, stderr = process.communicate()
         exit_code = process.returncode
-
-        with migration_lock:
-            # Ensure running state is updated based on process completion
-            if migration_state["running"]: # Only update if not stopped manually
-                if exit_code == 0:
-                    # Get final file size
-                    final_size = get_file_size_mb(file_path)
-                    migration_state["dump_file_size"] = final_size
-                    migration_state["progress"]["current_size_mb"] = round(final_size, 2)
+        
+        if exit_code == 0:
+            # Verify file exists and has content
+            if os.path.exists(absolute_file_path):
+                final_size = os.path.getsize(absolute_file_path)
+                
+                with migration_lock:
+                    migration_state["dump_file_size"] = final_size / (1024 * 1024)  # Convert to MB
+                    migration_state["progress"]["current_size_mb"] = round(final_size / (1024 * 1024), 2)
                     migration_state["dump_completed"] = True
                     migration_state["end_time"] = time.time()
-                    total_time = migration_state["end_time"] - migration_state["start_time"]
-                    log_message(
-                        f"Database dump completed successfully. Size: {round(final_size, 2)} MB. Time: {round(total_time, 2)} seconds",
-                        "success"
-                    )
-                else:
-                    error_message = stderr or stdout or "Unknown error during dump"
-                    log_message(f"Database dump failed: {error_message}", "error")
-
+                    migration_state["running"] = False
+                    migration_state["process"] = None
+                
+                total_time = migration_state["end_time"] - migration_state["start_time"]
+                log_message(
+                    f"Database dump completed successfully. Size: {round(final_size / (1024 * 1024), 2)} MB. Time: {round(total_time, 2)} seconds",
+                    "success"
+                )
+                return True
+            else:
+                log_message(f"Dump completed but file not found: {absolute_file_path}", "error")
+                
+                with migration_lock:
+                    migration_state["running"] = False
+                    migration_state["process"] = None
+                
+                return False
+        else:
+            error_message = stderr or "Unknown error during dump"
+            log_message(f"Database dump failed: {error_message}", "error")
+            
+            with migration_lock:
                 migration_state["running"] = False
                 migration_state["process"] = None
-
-        return exit_code == 0
-
+            
+            return False
+    
     except Exception as e:
         log_message(f"Error during database dump: {str(e)}", "error")
+        
         with migration_lock:
             migration_state["running"] = False
             migration_state["process"] = None
+        
         return False
 
 def run_restore(target_conn: str, file_path: str, options: dict):