Shell Scripts – Shell Script to Toggle Between Two Commands

scripts

I need help creating a shell script to toggle between two commands.
When it is run command1 is executed then if it is run again it executes command2 and so on…

Best Answer

One good way of accomplishing this is for the script to create a blank "configuration file":

The 1st time the script runs, it sees the file doesn't exist, creates it, and runs command1.
The 2nd time the script runs, it sees the file does exist, deletes it, and runs command2.
The 3rd time the script runs, it sees the file doesn't exist, creates it, and runs command1.
The 4th time the script runs, it sees the file does exist, deletes it, and runs command2.

And so forth.

Here's a script that does that:

#!/bin/sh
# This shell script is PUBLIC DOMAIN. You may do whatever you want with it.

TOGGLE=$HOME/.toggle

if [ ! -e $TOGGLE ]; then
    touch $TOGGLE
    command1
else
    rm $TOGGLE
    command2
fi

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.

Best Answer

Related Solutions

Ubuntu – Combine Two Commands In a Script

How to Send Commands to Specific Terminal Windows

How it works in practice

How to set up

The script

Notes

Related Question