#!/bin/bash

# J.Kobus 04/2020 ver. 1.00
# modifications: 02/11/2020 26/01/2022 31/01/2022

bn=$(basename $0)

bold=`tput bold`
underline=`tput smul`
normal=`tput sgr0`

pid=$$

# a teacher should set the following variables

asheet=
qsheet=

#asheet=so-exam-1.txt
#qsheet=http://jkob.fizyka.umk.pl/so-exam-1-qs.pdf

#server=ameryk.fizyka.umk.pl
server=localhost
#wwwserver=http://grader.fizyka.umk.pl
wwwserver=http://jkob.fizyka.umk.pl

#############################################################################################

function help {

    cat <<EOF
${bold}NAME${normal}
        ssctl - take, archive at a server and display snapshots of the
                whole screen at randomly generated intervals.

${bold}SYNOPSIS${normal}
        $(basename $0) -h
        $(basename $0) [-r <range>] start
        $(basename $0) -d <dirname> 
        $(basename $0) -g <reponame> 
        $(basename $0) -d <dirname> -u <username> [-s <server>] [-a <answer sheet>] \\
                                         [-q <question sheet>] [-r <range>] start
        $(basename $0) -g <reponame> -u <username> [-s <server>] [-a <answer sheet>] \\
                                         [-q <question sheet>] [-r <range>] start
        $(basename $0) clean|cont|install|show|ss|status|stop


${bold}DESCRIPTION${normal}

        ssctl Bash script can be used to record an exam. It takes, archives
        and displays snapshots of the whole screen at randomly generated
        intervals. If dirname or reponame is defined the snapshots are
        copied into the specified directory on a server together with the
        exam's answer sheet (if specified). In case reponame is defined the
        answer sheet is added to repository and then regularily committed
        and pushed.

        Programs animate, convert, import, mogrify from the ImageMagick
        suit are used to make and display screenshots and manipulate the
        frames.

${bold}COMMANDS${normal}

        clean
              remove all ss/*-${import}.${format} files            


        clone
              clone the repository to the working directory            

  resume|cont 
              continue taking screenshots (and sending them to the repo)
              every $range seconds (on average) 

      convert 
              merge all *-$import.${format} files into the single ${import}.${format} one

      install
              copy $(basename $0) in /usr/local/bin/ and install additional packages 
              (Fedora and Debian/Ubuntu distributions are supported)

	pause 
              suspend taking snapshots but keep the ssh connection to the server

         show
              display the values of several variables: \$user, \$server, \$repo, etc 

           ss 
              begin automatic slideshow; fps variable should be used to adjust 
              the rate of display.

        start 
              begin taking screenshots every $range seconds (on average)

         stop 
              stop taking screenshots 


${bold}OPTIONS${normal}
        -a <answer sheet>
           use this option to define the name of a file to be used by a
           student to write down answers to the questions provided. This
           text file will be copied (at the same time as screenshots) to the
           student's git directory, committed and pushed.


        -d <dirname>
           "ssh -fN -o ControlPath=$controlPath -M <username>@<server>" is
           to be executed to establish a master connection which will
           facilitate the user to login into the server and access the
           specified directory and to upload screenshots to its ss
           subdirectory

        -D <time>
	   use this option to set the duration of a single animation (in seconds).
           The number of files being processed at a time is adjusted according to
           this parameter and the number of frames per second requested.

	-e 
           attempt an exam instead of a quiz    

        -f <fps>
           use this option to adjust the number of frames per second (which
           is passed to annimate) when playing back the snapshots (by default
           fps=3).
	    
        -g <reponame>
           "ssh -fN -o ControlPath=$controlPath -M <username>@<server>" is
           to be executed to establish a master connection which will
           facilitate the user to login into the server and access his Git
           repository and to upload screenshots to its ss subdirectory.

        -G <reponame>
           "ssh -fN -o ControlPath=$controlPath -M <username>@<server>" is
           to be executed to establish a master connection which will
           facilitate the user to login into the server and access his Git
           repository and to upload screenshots to its ss subdirectory.

           Additonaly the repository will be cloned to a current directory.

        -n <portion_of_images>
           use this option to display only a given 20% of all images: 
           1 - first, 2 - second, etc.
         
        -q <question sheet>
           use this option to define the URL location of the question sheet

        -r <range>
           use this option to adjust the frequency of screenshots; the
	              delay between screenshots is calculated as 
           \$((\$((\$RANDOM % <range>))+1))

        -s <server>
           use this option to access user's Git repository on a different
           SSH server than $server

        -u <username>
           use this option if the username of the remote account is
           different from \$USER


${bold}EXAMPLE 1${normal}
        In order to take the screen snapshots on a regular basis just type

            ./ssctl start      

        The snapshots will be saved to ss subdirectory of a current directory. Use
	
            ./ssctl pause

        to stop taking snapshots but keeping the SSH connection open and 

            ./ssctl resume|cont 

        to resume it.

	Use

            ./ssctl stop

        to stop the program.

        Use 

            ./ssctl -f 5 ss
     
        to playback the snapshots at 5 frames per second.


${bold}EXAMPLE 2${normal}
	Let's assume that a student named Kowalski (the index number 123456) has
	cloned /git/so20/kowalski repository into his home directory on the server 
	ameryk.fizyka.umk.pl.

        In order to take a quiz he should run the following command on his home computer: 

           ./ssctl -g kowalski -u 123456 -s ameryk.fizyka.umk.pl start

	and follow the instructions. The snapshots will be saved to ss subdirectory of 
        a current directory and copied to /home/123456/kowalski/ss directory on the server.

${bold}EXAMPLE 3${normal}
	Let's assume that a student named Kowalski (the index number 123456) has
	cloned /git/so20/kowalski repository into his home directory on the server 
	ameryk.fizyka.umk.pl.

        In order to take an exam he should run the following command on his home computer: 

           ./ssctl -e -g kowalski -u 123456 -s ameryk.fizyka.umk.pl start

	and follow the instructions. The snapshots will be saved to ss subdirectory 
        of a current directory and copied to /home/123456/kowalski/ss directory on 
        the server.  The answer sheet will be copied to /home/123456/kowalski/ and 
        committed to the repository.

${bold}EXAMPLE 4${normal} 
        Let's assume that a student named Kowalski (the index number 123456) has 
        no git repository cloned to his home directory on the server ameryk.fizyka.umk.pl.

        In order to take a quiz/exam he should run the following command on his home computer: 

           ./ssctl [-e] -d quiz -u 123456 -s ameryk.fizyka.umk.pl start

	and follow the instructions. The snapshots will be saved to ss subdirectory of 
        a current directory and copied to /home/123456/quiz/ss directory on the server.


EOF
}



function convertImages {
    convert $snapshotDir/*-${import}.${format} -append $snapshotDir/${import}.${format}
}


function checkPkgs4CentOS {
    exitok=
    status=$(rpm -qi ImageMagick |& grep 'is not installed')
    if [[ -n $status ]]
    then
	#echo "convert, import, mogrify are missing ..."
 	if [[ $case == install ]]
	then
	    yum -y install ImageMagick
	else
	    echo "convert, import, mogrify are missing ... install ImageMagick ..."
	    echo "try 'yum -y install ImageMagick ... or 'ssctl install'"
	    exitok=yes
	fi
    fi
    
    status=$(rpm -qi bind-utils |& grep 'is not installed')
    if [[ -n $status ]]
    then
	#echo "package bind-utils is not installed ..."
	if [[ $case == install ]]
	then
	    yum -y install bind-utils
	else
	    echo "package bind-utils is not installed ... "
	    echo "try 'yum -y install bind-utils' or 'ssctl install'"
	    exitok=yes
	fi
    fi
    
    status=$(import |& grep 'unable to open X server')
    [[ -n $status ]] && echo "unable to open X server ..." && exitok=yes
    [[ $exitok == yes ]] && exit 
}

function checkPkgs4Fedora {
    exitok=
    status=$(rpm -qi ImageMagick |& grep 'is not installed')
    if [[ -n $status ]]
    then
	#echo "convert, import, mogrify are missing ..."
 	if [[ $case == install ]]
	then
	    dnf -y install ImageMagick
	else
	    echo "convert, import, mogrify are missing ... install ImageMagick ..."
	    echo "try 'dnf -y install ImageMagick ... or 'ssctl install'"
	    exitok=yes
	fi
    fi
    
    status=$(rpm -qi bind-utils |& grep 'is not installed')
    if [[ -n $status ]]
    then
	#echo "package bind-utils is not installed ..."
	if [[ $case == install ]]
	then
	    dnf -y install bind-utils
	else
	    echo "package bind-utils is not installed ... "
	    echo "try 'dnf -y install bind-utils' or 'ssctl install'"
	    exitok=yes
	fi
    fi
    
    status=$(import |& grep 'unable to open X server')
    [[ -n $status ]] && echo "unable to open X server ..." && exitok=yes
    [[ $exitok == yes ]] && exit 
}

function checkPkgs4Debian {
    exitok=
    status=$(which import)
    if [[ -z $status ]]
    then
	#echo "convert, import, mogrify are missing ... "
	if [[ $case ==  install ]]
	then
	    apt-get update; apt-get install imagemagick
	else
	    echo "convert, import, mogrify are missing ... "
	    echo "try 'apt-get update; apt-get install imagemagick' ... or 'ssctl install'"
	    exitok=yes
	fi
    fi
    status=$(dpkg -s bind9-host |& grep 'is not installed')
    if [[ -n $status ]]
    then
	if [[ $case ==  install ]]
	then
	    apt-get update; apt-get install bind9-host
	else
	    echo "package bind9-host is not installed ..."
	    echo "try 'apt-get install bind9-host' ... or 'ssctl install'"
	    exitok=yes
	fi
    fi
    status=$(import |& grep 'unable to open X server')
    [[ -n $status ]] && echo "unable to open X server ..." &&  exitok=yes
    [[ $exitok == yes ]] && exit 
}

function check4Other {
    exitok=
    status=$(which convert)
    if [[ -z $status ]]
    then
	echo "convert is missing ... "
	exitok=yes
    fi

    status=$(which import)
    if [[ -z $status ]]
    then
	echo "import is missing ... "
	exitok=yes
    fi

    status=$(which mogrify)
    if [[ -z $status ]]
    then
	echo "mogrify is missing ... "
	exitok=yes
    fi

    status=$(which bc)
    if [[ -z $status ]]
    then
	echo "bc is missing ... install bc package"
	exitok=yes
    fi

    status=$(which host)
    if [[ -z $status ]]
    then
	echo "host is missing ..."
	exitok=yes
    fi
    [[ $exitok == yes ]] && exit
    
    status=$(import |& grep 'unable to open X server')
    if [[ -n $status ]]
    then
	echo "unable to open X server ..."
	echo "try using gnome-screenshot instead ..."
	exitok=yes
    fi

    [[ $exitok == yes ]] && exit 
}

function checkOS {
    [[ -d $repo ]] || mkdir -p $repo/ 
    cp /etc/os-release $repo/
    echo "virtualized environment="$(systemd-detect-virt) >> $repo/os-release
    echo "machine-id="$(cat /etc/machine-id) >> $repo/os-release

    if [[ -S $controlPath ]]
    then
	scp -o ControlPath=$controlPath $repo/os-release $user@$server:~/$repo >& /dev/null
	if [[ $gitrepo == yes ]]
	then
	    ssh -o ControlPath=$controlPath $user@$server \
		"cd $repo; git add os-release; git commit -mos-release-4-quiz os-release; git push origin master"  >& /dev/null
	fi
    fi
}

function checkSetLock {
    if [[ -f $lock ]]
    then
	echo -en "lock file detected ... continue? [y/n]"
	read answer
	if [[ $answer == y ]]
	then
	    $0 cont
	else
	    $0 stop
	    $0 start	    
	fi
    fi
}

function checkVirt {

    status=$(virt-what)
    [[ -z $status  ]] && return
    echo "Warning! cannot work in a virtual machine ... quittig" 
    exit
}



function displaySS {

    if [[ $1 == 0 ]]
    then
	cd $snapshotDir
	delay=$(echo "scale=0; 100 / $fps" | bc -l)
	n=$(echo "scale=0; $sad*$fps" | bc -l)
	#echo $n
	#ls | xargs -n $n animate -resize $resize -loop 1 -delay $delay
	ls | xargs -n $n animate  -loop 1 -delay $delay
	#animate -loop 1 -delay $delay -limit disk 200mb *.${format}
	cd - >& /dev/null
    else
	# display only a given portion of images
	cd $snapshotDir
	nimages=$(ls |wc -l)
	let n4split=$nimages/5+1
	echo $n4split
	ls *.png8 | split -l$n4split

	delay=$(echo "scale=0; 100 / $fps" | bc -l)
	n=$(echo "scale=0; $sad*$fps" | bc -l)
	portion=1
	[[ $1 == 1 ]] && portion=xaa
	[[ $1 == 2 ]] && portion=xab
	[[ $1 == 3 ]] && portion=xac
	[[ $1 == 4 ]] && portion=xad	
	[[ $1 == 5 ]] && portion=xae
	animate  -loop 1 -delay $delay $(cat $portion)
	rm -f xa* >& /dev/null
	cd - >& /dev/null
    fi
}


function rmLock {
    rm -f $lock
}

function saveVars {
    cat <<EOF > $ssctlstop
user=$user
server=$server
repo=$repo
ControlPath=$controlPath
pid4stop=$pid 

EOF
    
}

function getAvPngSize {

    avs=$(ls -l $snapshotDir/*.png8 | head -n $1 | awk '{print $5}' \
	      | awk 'BEGIN  {sum=0 } { sum+=$1 } END {printf "%10.0f ", sum/NR}')

}


function startClone {
    #[[ ! -d $repo ]] && return
    rm -rf $repo
    git clone ssh://$user@$server/git/$repo4so/$repo
}



function startImport {
   
    [[ -d $snapshotDir ]] || mkdir $snapshotDir
    if [[ $contImport == no ]]
    then
	last=0
    else
	cd $snapshotDir
	last=$(ls 0*-${import}.${format} 2> /dev/null | sort -nr | cut -d- -f1|head -n1)
	cd - >& /dev/null
    fi

    (
	last=$(echo -n $last | sed -r 's/^0+//')

	while ((1>0)) 
	do
	    let last++
	    if (( $last <= 9 ))
	    then
		lastfn=$(printf "0000%d" $last)
	    elif (( $last <= 99 ))
	    then
		lastfn=$(printf "000%d" $last)
	    elif (( $last <= 999 ))
	    then
		lastfn=$(printf "00%d" $last)
	    elif (( $last <= 9999 ))
	    then
		lastfn=$(printf "0%d" $last)
	    elif (( $last <= 99999 ))
	    then
		lastfn=$(printf "%d" $last)
	    fi

	    delay=$(($(($RANDOM % $range))+1))
	    sleep $delay
	    import -silent -window root  $snapshotDir/$lastfn-${import}.${format}
	    [[ "$resize" == "100%" ]] || mogrify -resize $resize -format $format $snapshotDir/$lastfn-${import}.${format}
	    
	    if [[ -S $controlPath ]]
	    then
		scp -o ControlPath=$controlPath $snapshotDir/$lastfn-${import}.${format} $user@$server:~/$repo/$snapshotDir >& /dev/null


		#set -x
		if [[ -n $asheet ]]
		then
		    [[ -f ${asheet} ]] && scp -o ControlPath=$controlPath \
					      $asheet $user@$server:~/$repo >& /dev/null
		    [[ -f .${asheet}.swp ]] && scp -o ControlPath=$controlPath \
						   .${asheet}.swp $user@$server:~/$repo/ >& /dev/null

		    if [[ $gitrepo == yes ]]
		    then
			if [[ $gitadd == no ]]
			then
			    ssh -o ControlPath=$controlPath $user@$server \
				"cd ~/$repo; git add $asheet; git commit -mInitial-commit--$asheet $asheet; git push origin master"  >& /dev/null
			    gitadd=yes
			else
			    ssh -o ControlPath=$controlPath $user@$server \
				"cd ~/$repo; git commit -mcommit--$asheet $asheet; git push origin master"  >& /dev/null
			fi
		    fi
		fi
		#set +x
	    fi
	    [[ $verbose == yes ]] && echo $lastfn-${import}.${format}
	    if (( $last >= $nf4av ))
	    then
		getAvPngSize $nf4av
		
		(( $avs < 15000 )) && resize=75%
		(( $avs > 55000 )) && resize=25%		
		#echo "last="$last "  avsize="$avs  "resize="$resize
		nf4av=10000000
	    fi
	done
    )&
}




function startPrep {

    if [[ -n $repo ]]
    then
	if [[ $exam == yes ]]
	then
	    message4exam
	else
	    if [[ $clone == no ]]
	    then
		message4quiz
	    else
		message4quizANDclone
	    fi
	fi
    fi
    
    if [[ ! -S $controlPath ]]
    then
	ssh -fN -o ControlPath=$controlPath -M $user@$server
	echo "SSH connection: OK"
	
	if [[ $gitrepo == yes ]]
	then
	    status=$(ssh -o ControlPath=$controlPath $user@$server "cd $repo; git status" |& grep "fatal: not a git repository")
	    if [[ -n $status ]]
	    then
		echo "Error: $repo is not a git repository ... quitting"
		stopSS
	    fi
	fi
	ssh -o ControlPath=$controlPath $user@$server "[[ -d $repo/$snapshotDir ]] || mkdir -p $repo/$snapshotDir"  
	echo "repo $repo: OK"
    fi
    checkOS
}

function stopImport {
    pids=$(ps -elf | grep -P "$bn.*start" | grep -v grep| awk '{print $4}')
    [[ -n $pids ]] && echo $pids | xargs kill

    pids=$(ps -elf | grep -P "$bn.*resume" | grep -v grep| awk '{print $4}')
    [[ -n $pids ]] && echo $pids | xargs kill

    pids=$(ps -elf | grep -P "$bn.*cont" | grep -v grep| awk '{print $4}')
    [[ -n $pids ]] && echo $pids | xargs kill

    exit
}


function stopSS {
    . $ssctlstop
    [[ -S $controlPath ]] && ssh -o ControlPath=$controlPath -O exit $user@$server
    stopImport
    rmLock
}

function message4exam {
    cat <<EOF

You are about to establish a secure connection with $server server using
your account ($user).

This connection will be used to automatically transfer the screenshots
taken at random together with the current version of ${bold}$asheet${normal} 
file. This file should contain your answers to the exam questions available 
at ${bold}${wwwserver}/$qsheet${normal}.

To pause the process run

   ./ssctl pause

and to resume it run

   ./ssctl resume|cont

When you are done run

   ./ssctl stop


${bold}A hint for Emacs users:${normal} Make sure that the auto-save-visited-mode is
enabled (M-x auto-save-visited-mode). You can also add "(auto-save-visited-mode t)" 
into the emacs configuration file (~/.emacs) to enable this mode automatically.

${bold}A hint for Vim users:${normal} vim editor keeps the backup in .${asheet}.swp 
file so in case of a crash you may resume the editing by running "vi -r $asheet" command.

EOF

}	    

function message4quiz {
    cat <<EOF

You are about to establish a secure connection with $server server using
your account ($user). 

It will be used to transfer automatically the screenshots taken at random
plus the identification of your operating system (/etc/os-release) to
record your session.

To pause the process run

   ./ssctl pause

and to resume it run

   ./ssctl resume

And when you are done run

   ./ssctl stop

EOF
}	    


function message4quizANDclone {
    cat <<EOF

You are about to establish a secure connection with $server server using
your account ($user). 

It will be used to transfer automatically the screenshots taken at random
plus the identification of your operating system (/etc/os-release) to
record your session.

Additionally your repository is cloned to the working directory and MUST be
used for modifying old scripts and writing new ones.

To pause the snapshots being taken run

   ./ssctl pause

and to resume it run

   ./ssctl resume

And when you are done run

   ./ssctl stop

EOF
}	    

#############################################################################################

#trap "rmLock; pgrep -f 'ssctl.*start' | xargs kill -9 2>/dev/null;  exit" INT

trap "rmLock; pkill -9 -f 'ssctl.*start';" EXIT INT


contImport=no
backup=no
clone=no
exam=no
os=

# duration of a single animation
sad=20
fps=3
range=3
import=import
snapshotDir=ss

repo=repo
gitrepo=no
gitadd=no

resize=50%
#resize=75%
#resize=100%
# adjust the resize variable by examining the average size of $nf4av png8 files 
nf4av=10

verbose=no

# when n is nonzero show only portion of the images
# n=2 >= 20%
# n=4 >= 40%
# n=6 >= 60%
# n=8 >= 80%

sspart=0

repo4so=so21

user=$USER
controlPath=/tmp/$bn-ssh-$user
lock=/tmp/$bn-lock-$user
ssctlstop=/tmp/$bn-stop-$user

#format=png
format=png8


while getopts "a:d:D:ef:g:G:hLn:q:r:s:u:v" option; do
    case $option in
	a ) asheet=$OPTARG;;
	d ) repo=$OPTARG;;
	D ) sad=$OPTARG;;
	e ) exam=yes;;
	f ) fps=$OPTARG;;	
	g ) repo=$OPTARG; gitrepo=yes;;
	G ) repo=$OPTARG; gitrepo=yes; clone=yes;;		
	h ) help;exit;;
	n ) sspart=$OPTARG;;	
	q ) qsheet=$OPTARG;;
	r ) range=$OPTARG;;
	s ) server=$OPTARG;
	    status=$(host -i $server | grep -iP "Host $server not found:")
	    [[ -n $status ]] && echo "host $server not found ... quitting " && exit
	    ;;	
	u ) user=$OPTARG;;
	v ) verbose=yes;;	
    esac
done

shift $((OPTIND-1))
case=$1

#os=$(grep CPE_NAME /etc/os-release | cut -d: -f 4)
os=$(grep PRETTY_NAME= /etc/os-release | sed -r 's/"//g' | cut -d= -f 2  | cut -d' ' -f1)

if [[ $case == install ]]
then
    [[ $USER != root ]] && echo "you must be root to install $(basename $0)" && exit
    cp $0 /usr/local/bin/
    chmod +x /usr/local/bin/$(basename $0)
fi

if [[ "$os" == "Fedora" ]]
then
    checkPkgs4Fedora
elif [[ "$os" =~ "CentOS" ]]
then
    checkPkgs4CentOS

elif [[ "$os" == "Debian" || "$os" =~ "Ubuntu" ]]
then
    checkPkgs4Debian
else
    check4Other
fi

[[ $case == install ]] && exit



case $case in
    show )
	cat <<EOF
range=$range
repo=$repo
gitrepo=$gitrepo
resize=$resize
user=$user
server=$server
	
EOF
	exit 0
	;;

    clean )
        rm -f $repo/os-release
        rm -f $snapshotDir/${import}.${format} $snapshotDir/*-${import}.${format} >& /dev/null
	;;

    clone )
	startClone
	exit
	;;
    
    cont|resume )
	contImport=yes
	. $ssctlstop
	[[ -S $controlPath ]] || ssh -fN -o ControlPath=$controlPath -M $user@$server
	rsync -a $PWD/$snapshotDir $user@${server}:~/$repo/ >& /dev/null
	startImport
	;;

    convert )
        convertImages
	;;


    display )
        displaySS
	;;

    pause )
	stopImport
	;;
    
    ss|ss-start )
        displaySS $sspart
	;;

    status )
	ps -elf | grep -P "$bn\s+start" 
        ls  $snapshotDir/*-${import}.${format} 2>/dev/null| sort -nr
	stat=$(ssh -o ControlPath=$controlPath -O check $user@$server |&  grep "Master running")	
	[[ -n $stat ]] && echo $stat
	;;
    
    start )
	
	checkSetLock
	saveVars
	[[ $clone == yes ]] && startClone
	startPrep
        startImport
	;;
    
    stop )
	stopSS
	;;

    

    *  ) 	
        help; exit
	;;
esac