packageAutoUpdater

#!/bin/bash

# This script keeps Venus modification packages up to date
# It looks on GitHub for package updates
# The timestamp of the current tag on GitHub is compatred to the one that was last installed
# if GitHub is newer, the local copy is updated and the package is reinstalled
#
# This script also checks for updates on a USB stick and gives priority to that location
#
# An automatic update will only occur if the package is installed and the autoUpdate setup option is set
#
# the script runs as a service so any updates that also update this script will restart automatically

# get the full, unambiguous path to this script
scriptDir="$( cd "$(dirname $0)" >/dev/null 2>&1 ; /bin/pwd -P )"
packageame=$(basename "$scriptDir")
shortScriptName=$(basename "$scriptDir")/$(basename "$0")

source "/data/SetupHelper/EssentialResources"
source "/data/SetupHelper/LogHandler"

# this flag is tested by LogHandler to determine if messages should be output to the console
logToConsole=false

source "/data/SetupHelper/UpdateResources"
source "/data/SetupHelper/DbusSettingsResources"

# updates status message on GUI
# $1 is the message identifier (not the actual message

lastMessage=''
lastPackage=''

updateStatus ()
{
    updateDbus=false
    checkPackage=false
    if [[ $1 == 'IDLE' ]] ; then
        message="Fast updates: 10 sec/pkg, Normal updates: 10 min/pkg"
    elif [[ $1 == 'USB_DISABLED' ]] ; then
        message="USB/SD updates disabled auto GitHub updates"
    elif [[ $1 == 'CHECKING' ]] ; then
        message="checking $package"
        checkPackage=true
    elif [[ $1 == 'WAIT' ]] ; then
        message="waiting to check $package"
        checkPackage=true
    elif [[ $1 == 'USB_CHECK' ]] ; then
        message="Checking USB/SD for updates"
    else
        message=""
    fi
    if [[ $1 != $lastMessage ]]; then
        updateDbus=true
    elif $checkPackage && [[ $package != $lastPackage ]]; then
        updateDbus=true
    fi
    # update GUI status message
    if $updateDbus ; then
        updateDbusStringSetting "/Settings/PackageVersion/CheckingPackage" "$message"
    fi
    lastMessage=$1
    lastPackage=$package
}


#### main code starts here

# wait until dbus settings are active
while [ $(dbus -y | grep -c "com.victronenergy.settings") == 0 ]; do
    logMessage "waiting for dBus settings"
    sleep 1
done

logMessage "starting up"

usbCheck=false
mediaDetected=false
lastUpdateTime=0
checkingPackage=false
updateSetupHelper=false


# 10 minutes between GitHub checks to minimize network traffic
gitHubSlowCheckDelay=600
# 10 seconds for first pass
gitHubFastCheckDelay=10
gitHubCheckDelay=0

lastGitHubUpdateSetting=0

# loop forever
while true ; do
    rebootNeeded=false
    restartFromFirstPackage=false

    # skip all processing if package list doesn't exist
    # but keep checking
    if [ ! -f "$packageListFile" ]; then
        sleep 10
        continue
    fi

    # loop through packages from package list
    while read -u 9 package gitHubUser gitHubBranch; do
        # skip comments
        if [[ ${package:0:1} == "#" ]] ; then
            continue
        # skip blank/incomplete lines
        elif [ -z $package ] || [ -z $gitHubUser ] || [ -z $gitHubBranch ] ; then
            continue
        fi

        packageDir="/data/$package"
        setupOptionsDir="$setupOptionsRoot"/$package

        # skip uninstalled packages
        if [ ! -f "$installedFlagPrefix"$package ]; then
            continue
        # package has been installed, check for updates
        else
            checkingPackage=true
        fi

        # this loop permits detection of USB media during the long wait for the next GitHub check
        while $checkingPackage ; do
            doUpdate=false

            # pull Git Hub autoupdate mode from dbus
            autoUpdateSetting=$(dbus-send --system --print-reply=literal --dest=com.victronenergy.settings /Settings/PackageVersion/GitHubAutoUpdate\
                    com.victronenergy.BusItem.GetValue 2> /dev/null | awk '{print $3}')
            if [ -z $autoUpdateSetting ]; then
                autoUpdateSetting=0
            fi

            # check for USB / SD media
            mediaList=($(ls /media))
            # no media
            if [ -z $mediaList ] ; then
                mediaDetected=false
                usbCheck=false
            # media first detected, enable USB checks and start loop over
            elif ! $mediaDetected ; then
                mediaDetected=true
                usbCheck=true
                updateStatus 'USB_CHECK'
                checkingPackage=false
                restartFromFirstPackage=true
                break
            fi

            # nothing to do - reset loop and wait
            if (( $autoUpdateSetting == 0 )) && ! $usbCheck ; then
                checkingPackage=false
                restartFromFirstPackage=true
                updateStatus 'IDLE'
                break
            fi

            # USB / SD updates
            if $usbCheck ; then
                for dir in ${mediaList[@]} ; do
                    getFromUsb $package
                    if [ $? -eq 1 ]; then
                        logMessage "found $package on USB"
                        doUpdate=true
                        updateStatus 'CHECKING'
                        break
                    fi
                done
                # done checking for this package, time to move on
                checkingPackage=false
                    
            # Git Hub updates
            elif (( $autoUpdateSetting != 0 )); then
                # if speeding up the loop, start package scan over
                if (( $autoUpdateSetting >= 2 )) && (( $lastGitHubUpdateSetting <= 1 )); then
                    checkingPackage=false
                    restartFromFirstPackage=true
                    lastGitHubUpdateSetting=$autoUpdateSetting
                    break
                fi

                # set update delay based on update mode 
                if (( $autoUpdateSetting >= 2 )) ; then
                    gitHubCheckDelay=$gitHubFastCheckDelay
                else
                    gitHubCheckDelay=$gitHubSlowCheckDelay
                fi

                currentTime=$(date '+%s')              
                # wait between GitHub updates to minimize traffic
                if (( $currentTime >= $lastUpdateTime + $gitHubCheckDelay )) ; then
                    updateStatus 'CHECKING'
                    lastUpdateTime=$currentTime
                    getFromGitHub $package
                    if [ $? -eq 1 ]; then
                        logMessage "found $package on GitHub"
                        doUpdate=true
                    fi
                    checkingPackage=false
                elif (( $autoUpdateSetting != 0 )); then
                    updateStatus 'WAIT'
                fi
            fi
            if $doUpdate ; then
                # do SetupHelper update now since other setup scripts depend on it's resources
                # will end this script which will start up again via supervise
                if [ $package == "SetupHelper" ]; then
                    updateSetupHelper=true
                    break
                # reinstall the package without user interaction
                else
                    # update via unattended reinstall only
                    logMessage "updating $package with $gitHubBranch"
                    doUpdate $package $gitHubBranch
                    if $usbCheck ; then
                        sleep 1
                    fi
                fi
            elif (( $autoUpdateSetting == 0 )); then
                rm -rf "$packageDir-$gitHubBranch"
            fi

            # delay for inner loop
            if $checkingPackage ; then
                if $usbCheck ; then
                    usleep 200000
                else
                    sleep 1
                fi
            fi
        done                    # end while checkingPackage

        if $restartFromFirstPackage || $updateSetupHelper ; then
            break
        else
            sleep 1
        fi
    done 9< "$packageListFile"   # end while read ...

# if not restarting scan, update automatic update state
    if ! $restartFromFirstPackage && ! $updateSetupHelper; then
        # single pass
        if (( $autoUpdateSetting == 3 )) ; then
            setSetting 0 /Settings/PackageVersion/GitHubAutoUpdate
        # end of first pass, switch to slow updates
        elif (( $autoUpdateSetting == 2 )) ; then
            setSetting 1 /Settings/PackageVersion/GitHubAutoUpdate
        fi
    fi
    usbCheck=false

    # continue execution in packageAutoUpdateCleanup
    # so that this script and the service can exit cleanly
    if $updateSetupHelper || $rebootNeeded ; then
        logMessage "continuing in cleanup script - $packageName exiting"
        
        nohup "$scriptDir/packageAutoUpdaterCleanup" $gitHubBranch $updateSetupHelper $rebootNeeded 2>&1 | awk '{print "packageAutoUpdaterCleanup " $0}'| tai64n >> /var/log/SetupHelper &
        
        # shutdown the service which runs this script - this will end this script
        svc -d "/service/SetupHelper"

        # wait here for service to end this script
        sleep 10000
    fi
    sleep 1
done