Merge origin/main

Author: andy

CMakeLists.txt

@@ -1931,6 +1931,32 @@ if(PYTHON3_EXECUTABLE)
   add_test(NAME transport_local_terminal COMMAND testLocalTerminal)
   set_tests_properties(transport_local_terminal PROPERTIES TIMEOUT 60)
 
+  # Run Management's Tail (TailSource) on a local machine; the same program
+  # runs against the test sshd from tests/transport/sshd/tail_test.sh.
+  add_executable(testTail tests/transport/testTail.C)
+  target_compile_definitions(testTail PRIVATE
+    ECCE_SOURCE_DIR="${CMAKE_SOURCE_DIR}")
+  target_link_libraries(testTail PRIVATE
+    eccecomm eccercmd eccedsi eccedav eccecipc eccefaces eccexml
+    eccetdat ecceutil ${XercesC_LIBRARIES})
+  add_test(NAME transport_tail COMMAND testTail)
+  set_tests_properties(transport_tail PROPERTIES TIMEOUT 120)
+
+  # The Tail window itself on Xvfb, local machine (tail_window_test.sh).
+  add_executable(tailwindow tests/transport/tailwindow.C)
+  target_compile_definitions(tailwindow PRIVATE ${wxWidgets_DEFINITIONS})
+  target_include_directories(tailwindow PRIVATE ${wxWidgets_INCLUDE_DIRS}
+    ${XercesC_INCLUDE_DIRS})
+  target_link_libraries(tailwindow PRIVATE
+    eccewxguicomm eccewxgui eccecomm eccercmd eccedsi eccedav eccecipc
+    eccefaces eccexml eccetdat ecceutil ${wxWidgets_LIBRARIES}
+    ${XercesC_LIBRARIES})
+  add_test(NAME transport_tail_window
+           COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/tests/transport/tail_window_test.sh
+                   $<TARGET_FILE:tailwindow> ${CMAKE_CURRENT_SOURCE_DIR})
+  set_tests_properties(transport_tail_window PROPERTIES TIMEOUT 120
+                       SKIP_RETURN_CODE 77)
+
   # OpenSshTransport against a stand-in ssh script and the real `ssh -G`:
   # process handling, file copies, streams, messages, backend choice.
   add_executable(testOpenSshTransport tests/transport/testOpenSshTransport.C)

docs/claude/services/index.md

@@ -47,3 +47,4 @@ what the deployment mode needs (GETTING_STARTED, "Deployment modes"):
 - [Waiting for login: a lost monitor parks the job, session start catches it up](waiting-for-login.md)
 - [Test suites get a per-run state directory, ports and X display](test-suites-isolate-per-run.md)
 - [Full builds and long suites go to radium/tellurium via tools/offload](long-suites-go-to-offload-hosts.md)
+- [A remote view rides ECCE's own login, not an ssh of its own (Tail)](remote-views-use-ecces-own-login.md)

docs/claude/services/remote-views-use-ecces-own-login.md

@@ -0,0 +1,32 @@
+---
+type: pitfall
+title: "A remote view must ride ECCE's own login, not start an ssh of its own"
+area: services
+section: "Pitfalls"
+paths: ["src/comm/commtools/TailSource.C", "src/wxgui/comm/WxTailWindow.C", "src/comm/commtools/EcceShell.C", "src/comm/rcommand/SshTransport.C", "src/apps/organizer/CalcMgr.C"]
+issues: [204]
+---
+**Anything that shows a remote file runs over the RCommand connection that
+logged in, never through a terminal's own `ssh`.** Run Mgmt > Tail used to
+log in through RCommand (AuthCache, then passdialog) only to check the file,
+then start `xterm -e ssh -t host 'tail -f ...'`: an OpenSSH client that
+knows nothing of the libssh session, so a password-only cluster asked twice
+and a two-factor one wanted a second code.
+
+Tail now opens `WxTailWindow`, fed by `TailSource`: one `RCommand`, a file
+check, then `startStream(script, true)`, which on libssh is
+`SshTransport::openStreamOnLogin` -- an exec channel on the session that
+just authenticated (the ordinary `openStream`, used by the job monitor,
+opens a session of its own and logs in again). Until `closeStream()` that
+session belongs to the stream's pump thread, and `run()`/SFTP on it fail
+with "busy". On OpenSSH (a shared connection) and locally (DirectTransport)
+the plain stream already shares the login. The script ends `tail` when its
+stdin closes (`cat >/dev/null; kill`), so a closed window or a dropped link
+leaves nothing running on the login node.
+
+The terminal route remains behind the `TailInTerminal` preference
+(EcceGlobal) or `ECCE_TAIL_TERMINAL=1`; it passes ECCE's ControlPath
+(`OpenSshTransport::controlArgs`) to the terminal's ssh, so a connection
+ECCE shares is reused, but over libssh it still logs in again.
+Tests: `transport_tail`, `transport_tail_window` (ctest),
+`tests/transport/sshd/tail_test.sh` (one login per Tail, counted).

help/src/first-calculation.md

@@ -170,7 +170,10 @@ in the panel next to the tree.
 To read the files while the job runs, select the calculation and use the
 **Run Mgmt** menu:
 
-- **Tail -f on Output File...** follows the output as it grows.
+- **Tail -f on Output File...** follows the output as it grows, in a
+  window of its own over the login ECCE already has for the machine, so
+  it does not ask for the password again. **Pause** holds the view while
+  new lines keep arriving; **Resume** shows them.
 - **View Output File...** and **View Input file...** open the files.
 - **View Run Log...** shows ECCE's log of the job.
 

help/src/register-machines.md

@@ -310,6 +310,10 @@ Put a command on the **Job script** tab if every code needs it, for
 example `module load openmpi`. Put it on the **Codes** tab if only one
 code does, for example the environment of Gaussian 16.
 
+Commands such as `module load` work in job scripts. Job scripts run under
+`sh`, where the module system is not set up on its own, so ECCE sets it up
+(Lmod or Environment Modules) before the first `module` or `ml` command.
+
 ## Advanced: edit file
 
 On the **Job script** tab, **Advanced: edit file...** opens the machine's

include/comm/EcceShell.H

@@ -46,6 +46,7 @@ class EcceShell
          string frontendMode;   // "forward" (-J) or "nested"; see RCommand::frontEndMode
          string geometry;       // xterm only, e.g. "80x40"
          string remoteCommand;  // as built by remoteCommand()
+         vector<string> sshOptions;  // e.g. ECCE's ControlPath for the host
       };
       // The local argv (terminal, its options, ssh); false with error set.
       static bool terminalArgv(const SshTerminal& t, vector<string>& argv,

include/comm/OpenSshTransport.H

@@ -112,6 +112,11 @@ public:
                                     const std::string& err,
                                     bool sharedConnection = false);
 
+  // The Control* options ECCE adds for this host, so that another ssh (a
+  // terminal) rides the connection already logged in to; empty when the
+  // user's own configuration does the sharing or nothing is shared.
+  std::vector<std::string> controlArgs() const;
+
 private:
   OpenSshTransport(const OpenSshTransport&);
   OpenSshTransport& operator=(const OpenSshTransport&);

include/comm/RCommand.H

@@ -83,6 +83,9 @@ public:
     // "libssh" or "openssh" when an ssh transport serves this connection
     // (OpenSSH for hosts whose ssh config shares connections), else "".
     string sshBackend() const;
+    // ssh options that let another OpenSSH client (a terminal) reuse this
+    // connection's shared login; empty when there is none to add.
+    vector<string> terminalSshOptions() const;
 
     bool hop(const string& hopMachine, const string& locShell="bash",
              const string& userName="", const string& password="",
@@ -92,8 +95,11 @@ public:
     // The monitor stream.  startStream() runs the command on pipes (over
     // ssh, on a session and thread of its own); streamFd()/streamWrite() then
     // address it, and \003 sent through exec() becomes SIGINT to its process
-    // group.  streamFd() is -1 when no stream is open.
-    bool startStream(const string& command);
+    // group.  streamFd() is -1 when no stream is open.  onThisLogin runs an
+    // ssh stream on this connection's own login instead (no second password
+    // or one-time code); the connection then runs nothing else until
+    // stopStream().
+    bool startStream(const string& command, bool onThisLogin=false);
     void stopStream(int graceMs=2000);
 
     bool streamWrite(const string& command);

include/comm/RemoteTransport.H

@@ -51,6 +51,13 @@ public:
   // with the env set.  Reading EOF means the script or the connection ended.
   virtual RemoteStream* openStream(const std::string& script, int& fd,
                                    std::string& error) = 0;
+  // The same, on the login this connection already made, so that nothing
+  // asks for credentials again.  Until closeStream() the connection serves
+  // only this stream.  A transport whose streams already share its login
+  // (the OpenSSH client on a shared connection) needs nothing more.
+  virtual RemoteStream* openStreamOnLogin(const std::string& script, int& fd,
+                                          std::string& error)
+  { return openStream(script, fd, error); }
   // Asks the script to stop, as ^C would.
   virtual void interruptStream(RemoteStream* s) = 0;
   // Sends EOF, gives the script graceMs to finish, then ends it and frees s.

include/comm/SshTransport.H

@@ -105,6 +105,8 @@ public:
   virtual RemoteStream* openStream(const std::string& script, int& fd,
                                    std::string& error);
   // SIGINT to the script's shell (the session has no tty for ^C).
+  virtual RemoteStream* openStreamOnLogin(const std::string& script, int& fd,
+                                          std::string& error);
   virtual void interruptStream(RemoteStream* s);
   // Sends EOF, gives the script graceMs to finish, closes everything and
   // joins the thread.  Frees s.
@@ -155,6 +157,7 @@ private:
   bool p_nested, p_forwardWorked, p_authFailed;
   SshJump* p_link;
   ssh_session_struct* p_session;
+  bool p_lent;   // p_session belongs to an openStreamOnLogin() stream
   sftp_session_struct* p_sftp;
 };