Ubuntu – How to open a new terminal window to ssh into a new computer and execute commands

command linegnomessh

Basically, I have a computer that I have to ssh into and pull up about 8 terminals to monitor various threads and log files. I would like to have a script from my build machine that can do this all for me. For example, if I want to watch the message queues, I'd like to run something like this:

gnome-terminal --window-with-profile=NOCLOSEPROFILE -e "ssh root@IP 'watch ipcs'"

But the ssh command doesn't seem to execute properly. I've tried a dozen iterations of this, with no luck. Here is a screen shot, if that helps.

enter image description here

So basically, I want to have this be something I can put into a script, or even be something commandible, so given an ip address and a command to execute, I'd like a new terminal window to open an ssh connection to that ip and execute the command.

Thanks in advance

**EDIT
I seem to be able to do this and execute most commands with the above command, but the watch command does not work over ssh so perhaps the sytax isn't the problem. Is there a reason watch might not work here, where

gnome-terminal --window-with-profile=NOCLOSEPROFILE -e 'ssh -X root@$IP "tail -f /home/log/alog.log"'

works fine?

Best Answer

Rather than opening up multiple windows and establishing multiple ssh sessions (to the same machine?), take a look at screen. You can ssh to a host, start screen and from there open multiple virtual consoles, one for each command you want to run.

What's really nice about screen, is that if you loose the ssh connection, you can create a new one and reattach to the running screen sessions. It's really cool. There is also tmux, which is a similar program (not sure how available it is on different Linuxes.

Ref: http://en.wikipedia.org/wiki/GNU_Screen

How it works in practice

The solution exists from a script, which can be run with two options -set and -run:

To set up (open) an arbitrary number of terminal windows, in this example 3:
```
target_term -set 3
```
Three new terminals will open up, their window id is remembered in a hidden file:

For clarity reasons I minimized the terminal window I ran the command from :)
Now that I created three windows, I can send commands to either one of them with the run command (e.g.):
```
target_term -run 2 echo "Monkey eats banana since it ran out of peanuts"
```
As shown below, the command ran in the second terminal:

Subsequently, I can send a command to the first terminal:
```
 target_term -run 1 sudo apt-get update
```
making sudo apt-get update run in terminal 1:

and so on...

How to set up

The script needs both wmctrl and xdotool:
```
sudo apt-get install wmctrl xdotool
```
Copy the script below into an empty file, safe it as target_term (no extension!) in ~/bin (create the directory ~/bin if necessary.
Make the script executable (don't forget) and either log out/in or run:
```
source ~/.profile
```
Now setup your terminal windows, with the number of required windows as an argument:
```
target_term -set <number_of_windows>
```
Now you can "send" commands to either one of your terminals with the command:
```
target_term -run <terminal_number> <command_to_run>
```

The script

#!/usr/bin/env python3
import subprocess
import os
import sys
import time
#--- set your terminal below
application = "gnome-terminal"
#---

option = sys.argv[1]
data = os.environ["HOME"]+"/.term_list"

def current_windows():
    w_list = subprocess.check_output(["wmctrl", "-lp"]).decode("utf-8")
    w_lines = [l for l in w_list.splitlines()]
    try:
        pid = subprocess.check_output(["pgrep", application]).decode("utf-8").strip()
        return [l for l in w_lines if str(pid) in l]
    except subprocess.CalledProcessError:
        return []

def arr_windows(n):
    w_count1 = current_windows()
    for requested in range(n):
        subprocess.Popen([application])
    called = []
    while len(called) < n:
        time.sleep(1)
        w_count2 = current_windows()
        add = [w for w in w_count2 if not w in w_count1]
        [called.append(w.split()[0]) for w in add if not w in called]
        w_count1 = w_count2

    return called

def run_intterm(w, command):
    subprocess.call(["xdotool", "windowfocus", "--sync", w])
    subprocess.call(["xdotool", "type", command+"\n"]) 

if option == "-set":
    open(data, "w").write("")
    n = int(sys.argv[2])
    new = arr_windows(n)
    for w in new:
        open(data, "a").write(w+"\n")
elif option == "-run":
    t_term = open(data).read().splitlines()[int(sys.argv[2])-1]
    command = (" ").join(sys.argv[3:])
    run_intterm(t_term, command)

Notes

The script is set for gnome-terminal, but can be used for any terminal (or other program as well) by changing the application in the head section of the script:
```
#--- set your terminal below
application = "gnome-terminal"
#---
```
The commands above can (of course) be run from a script as well in case you'd lile to use it for some kind of a simulation.
The script waits until both the targeted window has focus and the command is done typing, so the command will always land in the right terminal window.
No need to say that the script only works with the terminal setup (windows) that was called by the command:
```
target_term -set
```
The terminal windows will then be "labelled" by the script, like you mention in your question.
In case you start a new target_term session, the hidden file, created by the script will simply be overwritten, so there is no need to remove it otherwise.

Ubuntu – Open terminal with multiple tabs and execute application which uniquely modifies PS1 variable for each tab

As is the case with most programming, solving the problem was extremely hard. I had to study a bunch about Bash variables, and how to use export and source (or the POSIX dot operator, .), and how bash loads, and what interactive -i bash mode was, etc etc.

I found man bash and man test to also be useful. Here's how to do what I want to do, which is:

Write a script to open 3 tabs.
cd into a different folder in each tab (ie: run a unique command).
get each tab to have a unique title by modifying its local PS1 variable
Ensure each tab stays open after the script is run

1st, add this to the bottom of your `~/.bashrc` file:

# Function to allow a user to arbitrarily set the terminal title to anything
# Example: `set-title this is title 1`
set-title() {
    # Set the PS1 title escape sequence; see "Customizing the terminal window title" here: 
    # https://wiki.archlinux.org/index.php/Bash/Prompt_customization#Customizing_the_terminal_window_title
    TITLE="\[\e]2;$@\a\]" 
    PS1=${PS1_BAK}${TITLE}
}

# Back up original PS1 Prompt 1 string when ~/.bashrc is first sourced upon bash opening
if [[ -z "$PS1_BAK" ]]; then # If length of this str is zero (see `man test`)
    PS1_BAK=$PS1 
fi

# Set the title to a user-specified value if and only if TITLE_DEFAULT has been previously set and
# exported by the user. This can be accomplished as follows:
#   export TITLE_DEFAULT="my title"
#   . ~/.bashrc
# Note that sourcing the ~/.bashrc file is done automatically by bash each time you open a new bash 
# terminal, so long as it is an interactive (use `bash -i` if calling bash directly) type terminal
if [[ -n "$TITLE_DEFAULT" ]]; then # If length of this is NONzero (see `man test`)
    set-title "$TITLE_DEFAULT"
fi

2nd, create this script to open 3 unique tabs with 3 unique cd commands and 3 unique titles:

open_tabs.sh:

gnome-terminal --tab -- bash -ic "export TITLE_DEFAULT='title 1'; cd ..; exec bash;"
gnome-terminal --tab -- bash -ic "export TITLE_DEFAULT='title 2'; cd ../..; exec bash;"
gnome-terminal --tab -- bash -ic "export TITLE_DEFAULT='title 3'; cd ../../..; exec bash;"

Now open up a terminal and run the open_tabs.sh script:

./open_tabs.sh

Voila! It's magical! These 3 new tabs are now shown at the top of my terminal, and each has done the proper cd command I set, and each has the proper title I set!

This will all be placed into my dotfiles project: https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles.

Full and final solution: see here: Open Terminal with multiple tabs and execute application

Best Answer

Related Solutions

Ubuntu – How to send commands to specific terminal windows