init paths before copy

geos-trame/src/geos/trame/app/io/hpc_tools.py

@@ -15,7 +15,7 @@ def compute( n_unknowns: int,
                  memory_per_unknown_bytes: int,
                  node_memory_gb: int,
                  cores_per_node: int,
-                 min_unknowns_per_rank: int = 10,
+                 min_unknowns_per_rank: int = 10000,
                  strong_scaling: bool = True ) -> list[ dict ]:
         """Suggests node/rank distribution for a cluster computation.
 

geos-trame/src/geos/trame/app/io/simulation.py

@@ -85,6 +85,28 @@ def run_simulation() -> None:
             # if server.state.access_granted and server.state.sd and server.state.simulation_xml_filename:
             if server.state.access_granted and server.state.simulation_xml_filename and server.state.decomposition:
                 if Authentificator.ssh_client:
+                    # create remote path
+                    try:
+                        sftp = Authentificator.ssh_client.open_sftp()
+                        sftp.stat( server.state.simulation_remote_path )
+                    except FileNotFoundError:
+                        import posixpath
+                        jpart = '/'
+                        for part in server.state.simulation_remote_path.split('/')[1:]:
+                            try:
+                                jpart = posixpath.join(jpart,part)
+                                sftp.stat( str(jpart) )  # exists?
+                            except FileNotFoundError:
+                                sftp.mkdir( str(jpart) )
+                            except PermissionError:
+                                print( f"Permission error creating root folder at {jpart}")
+                                raise
+                            except:
+                                print( f"Error creating root folder at {jpart}")
+                                raise
+
+                    # create local path
+                    os.makedirs(server.state.simulation_dl_path, exist_ok=True)
 
                     Authentificator._sftp_copy_tree( Authentificator.ssh_client,
                                                      Simulation.gen_tree( server.state.simulation_xml_filename ),
@@ -158,52 +180,42 @@ def _start_result_streams( self ) -> None:
     def check_jobs( self ) -> None:
         """Check on running jobs and update their names and progresses."""
         if Authentificator.ssh_client:
-            try:
-                jid = self._server.state.job_ids
-                for index, job in enumerate( jid ):
-                    job_id = job[ 'job_id' ]
+            jid = self._server.state.job_ids
+            for index, job in enumerate( jid ):
+                job_id = job[ 'job_id' ]
+                _, sout, _ = Authentificator._execute_remote_command(
+                    Authentificator.ssh_client, f'sacct -j {job_id} -o JobID,JobName,State --noheader' )
+                job_line = sout.strip().split( "\n" )[ -1 ]
+
+                jid[ index ][ 'status' ] = job_line.split()[ 2 ]
+                jid[ index ][ 'name' ] = job_line.split()[ 1 ]
+
+                if ( jid[ index ][ 'status' ] == 'RUNNING' ):
+                    _, sout, _ = Authentificator._execute_remote_command(
+                        Authentificator.ssh_client,
+                        f"sacct -j {job_id} -o ElapsedRaw,TimelimitRaw --noheader --parsable2 | head -n 1 " )
+                    progress_line = sout.strip().split( "|" )
+                    jid[ index ][ 'slprogress' ] = str(
+                        float( progress_line[ 0 ] ) / float( progress_line[ 1 ] ) / 60 * 100 )
+
+                    # getthe completed status
+                    pattern = re.compile( r'\((\d+(?:\.\d+)?)%\s*completed\)' )
                     _, sout, _ = Authentificator._execute_remote_command(
-                        Authentificator.ssh_client, f'sacct -j {job_id} -o JobID,JobName,State --noheader' )
-                    job_line = sout.strip().split( "\n" )[ -1 ]
-
-                    jid[ index ][ 'status' ] = job_line.split()[ 2 ]
-                    jid[ index ][ 'name' ] = job_line.split()[ 1 ]
-
-                    if ( jid[ index ][ 'status' ] == 'RUNNING' ):
-                        _, sout, _ = Authentificator._execute_remote_command(
-                            Authentificator.ssh_client,
-                            f"sacct -j {job_id} -o ElapsedRaw,TimelimitRaw --noheader --parsable2 | head -n 1 " )
-                        progress_line = sout.strip().split( "|" )
-                        jid[ index ][ 'slprogress' ] = str(
-                            float( progress_line[ 0 ] ) / float( progress_line[ 1 ] ) / 60 * 100 )
-
-                        # getthe completed status
-                        pattern = re.compile( r'\((\d+(?:\.\d+)?)%\s*completed\)' )
-                        _, sout, _ = Authentificator._execute_remote_command(
-                            Authentificator.ssh_client,
-                            f"grep \"completed\" {self._server.state.simulation_remote_path}/job_GEOS_{job_id}.out | tail -1"
-                        )
-                        m = pattern.search( sout.strip() )
-                        if m:
-                            jid[ index ][ 'simprogress' ] = str( m.group( 1 ) )
-
-                    print(
-                        f"{job_line}-{job_id}\n job id:{jid[index]['job_id']}\n status:{jid[index]['status']}\n name:{jid[index]['name']} \n --- \n"
+                        Authentificator.ssh_client,
+                        f"grep \"completed\" {self._server.state.simulation_remote_path}/job_GEOS_{job_id}.out | tail -1"
                     )
-                self._server.state.job_ids = jid
-                self._server.state.dirty( "job_ids" )
-                self._server.state.flush()
-
-            except PermissionError as e:
-                print( f"Permission error: {e}" )
-            except IOError as e:
-                print( f"Error accessing remote file or path: {e}" )
-            except Exception as e:
-                print( f"An error occurred during SFTP: {e}" )
-
-            return None
-        else:
-            return None
+                    m = pattern.search( sout.strip() )
+                    if m:
+                        jid[ index ][ 'simprogress' ] = str( m.group( 1 ) )
+
+                print(
+                    f"{job_line}-{job_id}\n job id:{jid[index]['job_id']}\n status:{jid[index]['status']}\n name:{jid[index]['name']} \n --- \n"
+                )
+            self._server.state.job_ids = jid
+            self._server.state.dirty( "job_ids" )
+            self._server.state.flush()
+
+        return None
 
     @staticmethod
     def render_and_run( template_name: str, dest_name: str, server: Server, **kwargs: Any ) -> str:
@@ -289,4 +301,6 @@ def gen_tree( xml_filename: Any ) -> dict:
                 }
             }
         }
+
+        print( f"Generated FILE_TREE: {FILE_TREE}" )
         return FILE_TREE

geos-trame/src/geos/trame/app/io/ssh_tools.py

@@ -84,22 +84,34 @@ def dfs_tree( node: list | dict, path: str, sftp: paramiko.SFTPClient, remote_ro
         if isinstance( node, list ):
             for file in node:
                 print( f"copying {lp/Path(file.get('name'))} to {rp/Path(file.get('name'))}" )
-                with sftp.file( str( rp / Path( file.get( 'name' ) ) ), 'w' ) as f:
-                    f.write( file.get( 'content' ) )
+                try:
+                    with sftp.file( str( rp / Path( file.get( 'name' ) ) ), 'w' ) as f:
+                        f.write( file.get( 'content' ) )
+                except:
+                    print( f"Error copying {lp/Path(file.get('name'))} to {rp/Path(file.get('name'))}")
+                    raise
         elif isinstance( node, dict ):
             if "files" in node:
                 files = node[ 'files' ]
                 for file in files:
                     print( f"copying {lp/Path(file.get('name'))} to {rp/Path(file.get('name'))}" )
-                    with sftp.file( str( rp / Path( file.get( 'name' ) ) ), 'w' ) as f:
-                        f.write( file.get( 'content' ) )
+                    try:
+                        with sftp.file( str( rp / Path( file.get( 'name' ) ) ), 'w' ) as f:
+                            f.write( file.get( 'content' ) )
+                    except:
+                        print( f"Error copying {lp/Path(file.get('name'))} to {rp/Path(file.get('name'))}")
+                        raise
             if "subfolders" in node:
                 for subfolder, content in node[ "subfolders" ].items():
                     try:
                         sftp.stat( str( rp / Path( subfolder ) ) )
                     except FileNotFoundError:
-                        print( f"creating {rp/Path(subfolder)}" )
-                        sftp.mkdir( str( rp / Path( subfolder ) ) )
+                        try:
+                            print( f"creating {rp/Path(subfolder)}" )
+                            sftp.mkdir( str( rp / Path( subfolder ) ) )
+                        except:
+                            print( f"Error creating {rp/Path(subfolder)} on remote.")
+                            raise
                     Authentificator.dfs_tree( content, str( lp / Path( subfolder ) ), sftp, remote_root )
 
             for folder, content in node.items():
@@ -108,7 +120,11 @@ def dfs_tree( node: list | dict, path: str, sftp: paramiko.SFTPClient, remote_ro
                         sftp.stat( str( rp / Path( folder ) ) )
                     except FileNotFoundError:
                         print( f"creating {rp/Path(folder)}" )
-                        sftp.mkdir( str( rp / Path( folder ) ) )
+                        try:
+                            sftp.mkdir( str( rp / Path( folder ) ) )
+                        except:
+                            print( f"Error creating {rp/Path(subfolder)} on remote.")
+                            raise
                     Authentificator.dfs_tree( content, str( lp / Path( folder ) ), sftp, remote_root )
 
     @staticmethod
@@ -226,9 +242,15 @@ def _execute_remote_command( client: paramiko.SSHClient, command: str ) -> tuple
 
             print( f"Command exited with status: {exit_status}" )
             return ( exit_status, stdout_data, stderr_data )
-
+
+        except PermissionError as e:
+            print( f"Permission error: {e}" )
+            return ( -1, "", "" )
+        except IOError as e:
+            print( f"Error accessing remote file or path: {e}" )
+            return ( -1, "", "" )
         except Exception as e:
-            print( f"Error executing command: {e}" )
+            print( f"An error occurred during SFTP: {e}" )
             return ( -1, "", "" )
 
     @staticmethod

geos-trame/src/geos/trame/app/ui/simulation_view.py

@@ -207,7 +207,6 @@ def run_remove_jobfile( index_to_remove: int ) -> None:
             server.state.simulation_xml_filename = []
             server.state.selected_cluster_names = [ cluster.name for cluster in Authentificator.sim_constants ]
             # server.state.decompositions = []
-            # server.state.sd = None
 
             vuetify.VDivider( vertical=True, thickness=5, classes="mx-4" )
             with vuetify.VCol( cols=1 ):