Cheatsheet on bash scripting

chmod 740 zintscript.sh
./zintscript.sh

touch mynewfile.org
chmod 740 mynewfile.org

awk '/^\#\+DATE/{print; \
!/^\#\+DATE/{print} \
END {print "this is the end"}' junk.org

for f in 'ls *.md'; do
    pandoc -f markdown -t org -o ${f}.org ${f};
done

#!/bin/bash
while [ True ]; do
 if [ "$1" = "--euler" -o "$1" = "-e" ]; then
     EULER=2718281828459
     shift 1
 else
     break
 fi
 done

 echo $EULER

#!/bin/bash
while [ True ]; do
 if [ "$1" = "--euler" -o "$1" = "-e" ]; then
     EULER=2718281828459
     shift 1
 else
     break
 fi
 done

 echo $EULER

 ARG=( "${@}" )
 for i in ${ARG[@]}; do
     echo $i
 done

#!/bin/bash

# viewing environment variables
echo "The value of the home variable is: "
echo $HOME

# issue a command
echo "The output of the pwd command is: "
pwd

# grab output and make it readable using $(command)
echo "The value of the pwd command is $(pwd)"

# assign command output to a variable ${variable}
output=$(pwd)
echo "The value of the output variable is ${output}"
# ${} reminds you that inside the curlies is a variable

# view data on the command line  $@
echo "I saw $@ on the command line"



# read data from the user
echo "Enter a value: "

read userInput
echo "You just entered $userInput"

# concatenate userinput with command output
echo "Enter a file extension: "
read ext
touch "yourfile.${ext}"

# check to see if a file exists
if [ -d /etc/sysconfig ]; then
        echo "That file is there and a directory"
else
        echo "Not there or not a directory"
fi

for i in {10..30} ; do echo $i ; done | xargs  -I_ touch deletme-file-_.txt

for f in ./deleteme*.*; do
       cat add-a-line >> $f;
done

touch files-{A..G}.data

for FILE in "$@";
   do
      mv "$FILE" ~/Trash/;
   done

#!/bin/bash
# show me how bash special args expand out.  Script is called expan.sh
 export IFS='-'

 cnt=1

 # Printing the data available in $*
 echo "Values of \"\$*\":"
 for arg in "$*"
 do
   echo "Arg #$cnt= $arg"
   let "cnt+=1"
 done

 cnt=1

 # Printing the data available in $@
 echo "Values of \"\$@\":"
 for arg in "$@"
 do
   echo "Arg #$cnt= $arg"
   let "cnt+=1"
 done

SHELL=/usr/local/bin
PATH=/usr/local/sbin:/usr/local/bin/ <continues your PATH>
30 12,15,18 * * 1,2,3,4,5 root export VAR1=value1 && export VAR2=value2 && export VAR3=value3 && export VAR4=value4 /usr/bin/python3 /path_to_script/Kwanty_bez_eng.py

ansible@c8host ~[1174] $
true && echo "ok it worked"
ok it worked

ansible@c8host ~[1175] $
false && echo "ok it worked"

<nothing was echoed here, but that is hard to show, hence this explanation>

ansible@c8host ~[1176] $

cat ".bashrc" ;  echo "this is my profile"
cat ".bashrc" && echo "this is my profile"

ansible@c8host ~[1172] $
false || echo "logical OR says false was false"
logical OR says false was false

ansible@c8host ~[1173] $
true || echo "logical OR says false was false"

ansible@c8host ~[1174] $

sleep 5 ; echo "all done."
sleep 5 & echo "all done."

 if [ $foo -ge 3 ]; then

if test $foo -ge 3; then

# Functions

ipaddr() {

ip addr | egrep '([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})' | grep -v 127.0.0.1 | awk '{printf "%-18s%10s\n", $2, $NF}'

}

update() {

echo "Starting update"
sudo dnf update -y
sudo dnf upgrade -y

}

clean() {

echo "Cleaning up"
sudo dnf clean all
echo "This is what you've got installed"
sudo dnf list installed

}

helpme() {

cat << _MYEOF_

So, you need help.  Ok, very simply, this program shows you how to
use functions.  shown above is the who to write the functions, then 
to call, i.e. use, the functions simply use the fucntion name in your script.

update
clean
helpme

_MYEOF_

}

leave() {
echo "=================="
echo "Ok, see you around"
echo "Ok, see you around"
echo "=================="
exit

}

# Main program

echo "Zintis maintenance script, - Oct 2020 \n"

if [ "$1" == "--clean"]; then
   update
   clean
   leave
fi

if [ "$1" == "--help"]; then
   helpme
   leave
fi

if [ -n "$1" ]; then
   echo " Error: needs an argument.  Please run this script with one of:"
   echo "  --help, --clean, --update"
fi

update
leave

mcd () {
    mkdir -p "$1"
    cd "$1"
}

echo "Hello"
Hello
echo $?
0

   foo=$(pwd)

echo "We are in $(pwd)"

mkdir foo bar
touch {foo,bar}/{a..d}

touch bar{,1,2,a,b}

touch home{1,2}/bin/python/test{1,2,3}.py

   export PS4="\$LINENO: "
set -xv

command << HERESTRING
    text1
    text2
    ...
    textn
HERESTRING

#!/usr/bin/env bash
cat << EOF
   0th argument is: $0
   1st argument is: $1
   2nd argument is: $2
EOF

0th argument is: Apples
1st argument is: oranges
2nd argument is: peaches

ftp -n << MYFTP 2> /dev/null
       open ftp.acme.com
       user anonymous zintis@cisco.com
       ascii
       prompt
       cd folderofgoodstuff
       mget file1 file2 file3
       bye
MYFTP

#!/usr/bin/env bash
cat << 'EOF' 
   0th argument is: $0
   1st argument is: $1
   2nd argument is: $2
EOF

#!/bin/env bash
OLDIFS=$IFS
IFS=","
... do you thing with inputs that are separated with single tics
IFS=$OLDIFS

#!/bin/env bash
OLDIFS=$IFS
IFS=","

while read user job uid location
# first four fields in a csv file
  do
    echo -e "\e[1;33m$user \
    ==================\e[0m\n\
    Role : \t $job\n\
    ID : \t $uid\n\
    Site : \t $location\n"
  done < $1

IFS=$OLDIFS

do
   echo -e "\e[1;33m$user  ==================\e[0m\n Role : \t $job\n ID : \t $uid\n Site : \t $location\n"
 done

#!/bin/bash
# with input redirection < hello.txt
file="/usr/home/user1/somegoodfile.txt"
while read line
do
   echo "${line}"
   echo $line
done < "${file}"

#!/bin/bash
# with cat into a pipe (read into a single variable and print that)
cat hello.txt | while read p
do
    echo $p
done

#!/bin/bash
# Use IFF the input field seperator
while IFS=' ' read -r line
do
    echo $line
done < hello.txt

#!/bin/bash
filename='peptides.txt'
exec 4<"$filename"
echo Start
while read -u4 p ; do
    echo "$p"
done

cut -d$'\n' -f1 file.cut

for word in $(cat peptides.txt); do echo $word; done

OLDIFS=$IFS; IFS=$'\n';\
    for line in $(cat peptides.txt); \
    do cmd_a.sh $line; cmd_b.py $line; \
    done > outfile.txt; IFS=$OLDIFS

#!/bin/bash
# Jason Carman; Jasonmcarman@gmail.com
# Created: February 2012
# Updated: August 2013
# Purpose: To automate virtual machine back up and restoration
# Version: 3.1

# script should be run as ./vs [options]
#
# possible options:
#       -b  - Backup
#       -r  - Restore
#       -f  - Restore on Fresh Install of Host OS
#       -o  - Run on one vm, not all

# NOTE: This script should be run as root

# In order to work properly this script requires some initial configuration
# for the variables dpath and spath.  Read further, as all the configuration
# occurs at the top of this script immediately following the comment block.

# Error Codes:
#       1 - User provided invalid option
#       2 - User selected both -b and -r
#       3 - User selected neither -b or -r
#       4 - User didn't provide an option
#       5 - Destination path not found
#       6 - Source path not found
#       7 - User provided a vm name but no action to perform (-b or -r)
#       8 - User selected -o but didn't provide a vm name

#########################################################################
## Variable Configuration - change these values to reflect your system ##
#########################################################################

# these path names should reflect your own directory structure and backup storage location
###### IMPORTANT! ######
# For this to work properly the directories contained in the variable must exist.  If you're doing a restore on a fresh install of the host, create the directory contained in dpath and copy the files there before you begin the process.

# destination path:
dpath='/home/jmcarman/Backups'

# source path:
spath='/var/lib/libvirt/images'

# Array to store virtual machine names, to add more virtual machines to this copy the same format.  To change these names to reflect your system, keep the single quotes and change the content inbetween.
#
# format vms=(nameofmachine1 nameofmachine2 nameofmachine3 nameofmachine4) ect....
vms=(centos1 centos2 centos3)

# Variable for log text file for easy reference
logfile=virtualsafety-log.txt

#########################################################################################
## Changes beyond this point not recommended unless you really know what you're doing, ##
## as results may be unpredictable.                                                    ##
#########################################################################################

function backup() {
        # change directory to where the virtual machines are stored as files
        cd $spath

        # use virsh dumpxml to create back ups of the virtual machines
        virsh dumpxml $vm >$dpath/$vm.xml

        # gzip images and store them in back up directory, run in the background
        echo "Creating backup of $vm in $dpath"
        touch $dpath/$vm.backup.gz
        $(gzip <$spath/$vm >$dpath/$vm.backup.gz)&
        progress
        logMsg="$logMsg $vm,"
}

function restore() {
        cd $spath
        echo "Restoring $vm"
        $(gunzip <$dpath/$vm.backup.gz >$spath/$vm)&
        progress
        logMsg="$logMsg $vm,"
        cp $spath/$vm.xml $dpath/$vm.xml
        virsh define $vm.xml
}

function logfile () {
        # check to see if the destination and sourch path exist
        if [ ! -e "$dpath" ]; then
                echo "Destination path: "$dpath" does not exist, please reconfigure your script and run again"
                exit 5
        fi
        if [ ! -e "$spath" ]; then
                echo "Source path: "$dpath" does not exist, please reconfigure your script and run again"
                exit 6
        fi

        logcheck=$(ls $dpath | grep $logfile)
        if [[ "$logcheck" == "" ]]; then # log file doesn't exist, create it
                echo "VIRTUAL SAFETY LOG" > $dpath/$logfile
                echo "FOR: $HOSTNAME" >> $dpath/$logfile
                echo "Backup Source Location: $spath" >> $dpath/$logfile
                echo "Backup Destination Location: $dpath" >> $dpath/$logifle
                echo "Start: " $(date | cut -d" " -f2,3,6) >> $dpath/$logfile
                echo "End: " >> $dpath/$logfile
                echo "--------------------------------------" >> $dpath/$logfile
        else # update the end date
                sed -i "s/End\:.*/End\:\ $(date | cut -d' ' -f2,3,6)/" $dpath/$logfile
        fi
}

function progress() {
        # $! is most recent running process ID, check running processes to see if the backround gzip has completed.  While it's running, print a "#" on the screen every 3 seconds.     
        while [[ $(ps | grep $!) != "" ]]; do 
                echo -n '#'
                sleep 3
        done
        echo "" # To keep messages and prompts aligned properly
}

function completion() {
        if [[ $b == 1 ]]; then
                action=Backup
        elif [[ $r == 1 ]]; then
                action=Restoration
        fi
        # tell the user the backup process has finished
        echo "Automated $action Complete, process logged to $dpath/$logfile"
        # append log time and date to a file for use in future documentation, add a blank line after for easier readability
        logMsg="$logMsg created with virtualsafety script on"
        echo "$logMsg" $(date) >> $dpath/$logfile
        echo "" >> $dpath/$logfile
}

while getopts brfo: options
do
        case $options in
                b) b=1
                        ;;
                r) r=1
                        ;;
                f) f=1
                        ;;
                o) o=1;vm=$OPTARG
                        ;;
                \?) echo "You have selected an invalid option, please use one of the following: -b for backup, -r for restore and if using -r please use -f if this restore is being done on a fresh install of the host"
                exit 1
                        ;;
        esac
done

if [[ $# == 0 ]]; then
        echo "./vs must be called with at least one argument, -b to back up -r to restore, -f with -r if doing the restoration on a fresh install of the host"
        exit 4
fi

if [[ "$b" == 1 && "$r" == 1 ]]; then
        echo "You must select either backup (-b) or restore (-r), not both"
        exit 2
elif [[ "$b" == 0 && "$r" == 0 ]]; then
        echo "You must select either backup (-b) or restore (-r)"
        exit 3
elif [[ "$b" == 0 || "$r" == 0 && "$o" == 1 ]]; then
        echo "You must select either backup (-b) or restore (-r) with -o"
        exit 7
elif [[ "$o" == 1 && $vm == "" ]]; then
        echo "You must provide the name of a virtual machine with -o"
        exit 8
fi

logfile $dpath $logfile

if [[ "$b" == 1 ]]; then
        # tell the user the back up is in progress
        echo "Begining automated back up..."
        logMsg="Backups of"

        # call the backup function in a for loop refferencing the array set above, passing it the parameters stored in the array $vms and variables $dpath, $spath.
        if [[ "$o" == 1 ]]; then
                backup $vm $dpath $spath
        else
                for vm in "${vms[@]}"; do
                        backup $vm $dpath $spath
                done
                # Call the completion function to log the message to the appropriate file
                completion $b $dpath $logfile $logMsg
        fi      
fi

if [[ "$r" == 1 ]]; then
        logMsg="Restoration of"
        if [[ "$f" == 1 ]]; then
                echo "Installing virtual machine manager and updating the host"
                # Install virtualization software and update the host
                yum -y groupinstall "Virtualization"
                yum -y update

                # Start the virtualization service and enable it to start on boot up
                systemctl start libvirtd
                systemctl enable libvirtd
        else
                echo "Begining automated restoration..."
                if [[ "$o" == 1 ]]; then # restore only one machine
                        restore $vm $dpath $spath
                else
                        # call the restore function in a for loop refferencing the array set above, passing it the parameters stored in the array $vms and variables $dpath, $spath.
                        for vm in "${vms[@]}"; do
                                restore $vm $dpath $spath
                        done
                        # Call the completion function to log the message to the appropriate file
                        completion $r $dpath $logfile $logMsg
                fi              
        fi
fi
vs
Displaying vs.

#!/bin/bash

# ask for an ip address, then add a temporary rule to iptables to allow that
# address to ssh to this host
# temporary because after a reboot, these new addtions will no longer be there
# i.e. they are not permanent.

echo "Current MYSSH iptables are:"
sudo iptables -L MYSSH -n --line-numbers

echo " "
echo " -----------------------------"

echo " Where are you trying to access me from? "
echo " Enter the ip address in the form a.b.c.d or a.b.c.0/24 or any other CIDR block form: "
read myip

echo " "
echo " Do you want to add $myip to your iptables.  (y/n) ? "

read proceedornot

if [ $proceedornot = "y" ]; then
        sudo iptables -I MYSSH 4 -s $myip -p tcp --dport 1963 -j ACCEPT
        # this iptables command inserts (I) into the MYSSH list, position 4
        # the ip address $myip to be accepted on port 1963
        echo " -----------------------------"
        sudo iptables -L MYSSH -n --line-numbers
fi

echo $proceedornot