#!/bin/bash

# J.Kobus 04/2020 ver. 1.00
# last modification: 02/11/2020

if [[ $1 == 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)
    exit
fi

#MAGICK_AREA_LIMIT=10000mb
#MAGICK_DISK_LIMIT=100bm
#MAGICK_FILE_LIMIT=200
#MAGICK_MEMORY_LIMIT=500mb
#MAGICK_MAP_LIMIT=10000mb
#MAGICK_THREAD_LIMIT=1

#export MAGICK_AREA_LIMIT MAGICK_DISK_LIMIT MAGICK_FILE_LIMIT MAGICK_MEMORY_LIMIT
#export MAGICK_MAP_LIMIT MAGICK_THREAD_LIMIT MAGICK_TIME_LIMIT 

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=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            

  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
              install $(basename $0) in /usr/local/bin/ 

	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
           students to write down answers to questions published at URL
           defined by -q option

        -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.

        -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

        -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 an exam 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 
        no git repository cloned to 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 -d exam -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/exam/ss directory on the server.

EOF
}



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


function checkPkgs4Fedora {
    exitok=
    status=$(rpm -qi ImageMagick |& grep 'is not installed')
    [[ -n $status ]] && echo "convert, import, mogrify are missing ... install ImageMagick ..." && exitok=yes
    status=$(rpm -qi bind-utils |& grep 'is not installed')
    [[ -n $status ]] && echo "package bind-utils is not installed ..." && exitok=yes
    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 ... "
	echo "try 'apt-get update; apt-get install imagemagick' ..."
	exitok=yes
    fi
    status=$(dpkg -s bind9-host |& grep 'is not installed')
    if [[ -n $status ]]
    then
	echo "package bind9-host is not installed ..."
	echo "try 'apt-get install bind9-host' ..."
	exitok=yes
    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"  >& /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 {
    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 -
}

function rmLock {
    rm -f $lock
}

function saveVars {
    cat <<EOF > $ssctlstop
user=$user
server=$server
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 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

	
		if [[ -n $asheet ]]
		then
		    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-of-$asheet $asheet; git push"  >& /dev/null
			else
			    ssh -o ControlPath=$controlPath $user@$server \
				"cd $repo; git commit -mcommit-of-$asheet $asheet; git push"  >& /dev/null
			fi
		    fi
		fi
	    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 [[ -n $asheet ]]
	then
	    message1
	else
	    message2
	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"  >& /dev/null
	echo "repo $repo: OK"
    fi
    checkOS
    
    
    if [[ -n $asheet ]]
    then
	message1c
    else
	message2c
    fi
}

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

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

    pids=$(ps -elf | grep -P "ssctl.*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 massage1 {
    cat <<EOF

You are about to establish a secure connection with $server server using your $user
account. It will be used to transfer automatically the screenshots taken at random
together with the current version of the $asheet file with your answers to the exam
questions (see https://${wwwserver}/so-exam-1.pdf).

EOF
}	    

function message1c {
    cat <<EOF

Now use your favourite editor (emacs or vi) to write down answers to the exam's
questions. 

To pause the process run

   ./ssctl pause

and to resume it run

   ./ssctl resume|cont

When you are done exit the editor and run

   ./ssctl stop

When using emacs editor 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.

In case of vi editor the backup is kept in .${asheet}.swp file and in case of a crash
you may resume the editing by running "vi -r $asheet" command.

EOF
}

function message2 {
    cat <<EOF

You are about to establish a secure connection with $server server using
your $user account. 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 quiz attempt.

EOF
}	    

function message2c {
    cat <<EOF

Now start a browser and attempt a quiz. 

To pause the process run

   ./ssctl pause

and to resume it run

   ./ssctl resume

When you are done run

   ./ssctl stop

EOF
}

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

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

contImport=no
backup=no

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

repo=/tmp/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

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

#format=png
format=png8



while getopts "d:D:f:g:hLr:s:u:v" option; do
    case $option in
	d ) repo=$OPTARG;;
	D ) sad=$OPTARG;;
	f ) fps=$OPTARG;;	
	g ) repo=$OPTARG; gitrepo=yes;;	
	h ) help;exit;;
	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

status=$(which lsb_release)
if [[ -z $status ]]
then
    echo "lsb_release is missing ... "
    echo "Debian/Ubuntu: apt-get update; apt-get install lsb-release"
    echo "       Fedora: dnf install redhat-lsb-core"
    exit 
fi


if [[ "$(lsb_release -i)" =~ "Fedora" ]]
then
    checkPkgs4Fedora
elif [[ "$(lsb_release -i)" =~ "Debian" || "$(lsb_release -i)" =~ "Ubuntu" ]]
then
    checkPkgs4Debian
else
    check4Other
fi

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
	;;

    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
	;;

    install )
        install
	;;

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

    status )
	ps -elf | grep -P "ssctl\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
	startPrep
        startImport
	;;
    
    stop )
	stopSS
	;;

    

    *  ) 	
        help; exit
	;;
esac