jrun

#!/bin/bash

IDIR="${BASH_SOURCE%/*}"
if [[ ! -d "$IDIR" ]]; then IDIR="$PWD"; fi
source "$IDIR/inc/misc_tools.sh"

# Edit the following locations to provide the
MOSQUITTO=`which mosquitto`
if [ -z $MOSQUITTO ]; then
    MOSQUITTO=/usr/local/sbin/mosquitto
fi
MOSQUITTO_PUB=`which mosquitto_pub`
if [ -z $MOSQUITTO_PUB ]; then
    MOSQUITTO_PUB=/usr/local/bin/mosquitto_pub
fi


# No need to edit below this line unless you find a bug!

die() {
    printf '%s\n' "$1" >&2
    exit 1
}

show_usage() {
    cat << EOF
jrun program.jxe
Runs only the J node of a device with program.jxe
under the application name 'testapp'. To run under a different
app name X, use the --app=X option. Use the --fog option to run at the
J node at the fog level or --cloud option to run at the cloud level.

By default, jrun uses a Redis server running at 127.0.0.1:6379 as the
data store. The Redis server needs to be started before launching the
application. To use a different Redis server use the --data option like
the following command using a Redis at local port 7000.

jrun program.jxe --data=127.0.0.1:7000

To provide a set of tags to the program, use the following command.
jrun program.jxe --tag="param1, param2"

Usage: runj file.jxe [--app=appl_name] [--fog|--cloud]
                            [--data=data-url]
                            [--tags=quoted_list_of_tags]
                            [--group=group_name]

The jrun command creates a run state in the $HOME/__jamrun folder.
EOF
}


writegroup() {

    local port=$1
    local gname=$2

    if [ ! -e $port ]; then
        mkdir $port
    fi
    echo $gname > $port/group
}

checkmosquitto() {

    # Check the required commands..
    if [ ! -e $MOSQUITTO ]; then
        die "Mosquitto MQTT broker $MOSQUITTO not found. Set new location."
    fi
    if [ ! -e $MOSQUITTO_PUB ]; then
        die "Mosquitto tools $MOSQUITTO_PUB not found. Set new location."
    fi
    if [ ! -e $TMUX ]; then
        die "terminal multiplexor $TMUX not found. Set new location."
    fi
}

startmqtt() {
    local port=$1

    # Check whether the MQTT server is running.. if not start it
    $MOSQUITTO_PUB -p $port -t "test" -m "hello"
    if [ $? -ne 0 ]; then
        echo "MQTT is not running at $port"
        echo "Attempting to start MQTT at $port"
        $MOSQUITTO -p $port &
    fi
}

startredis() {

    # Start redis with no protected-mode and at the port
    echo -e "port $1\nprotected-mode no" | redis-server - &
}

waitforredis() {
    local port=$1

    while : ; do
        local present=`ps ax | grep redis-server | grep $port | wc -l`
        if [ $present == "1" ]; then
            break
        fi
        sleep 1
    done
}


resolvedocker() {
    local name=$1

    local host="${name%:*}"
    local port="${name##*:}"

    startredis $port
    waitforredis $port

    if [ $host == "docker" ]; then
        local ipaddr=`hostname -I`
        name=$ipaddr:$port
    fi
    # trim space left behind by hostname -I
    data=$(echo $name | tr -d '[:space:]')
}


dojamout() {
    dojamout_p1 $1 $2 $3
    dojamout_p2 $1 $2 $3
}


dojamout_p1() {
    local type=$1
    local pnum=$2
    local floc=$3

    startmqtt $pnum
    echo $data > $floc/$pnum/dataStore
    echo "process" > $floc/$pnum/class
    echo $SHELLPID > $floc/$pnum/shellpid
    echo "new" > $floc/$pnum/processId
}



dojamout_p2() {
    local type=$1
    local pnum=$2
    local floc=$3

    case $type in
        cloud)
            if [ -z "$tags" ]; then
                node jamout.js --app=$app --cloud --port=$pnum --data=$data
            else
                node jamout.js --app=$app --cloud --port=$pnum --data=$data --tags=$tags
            fi
            ;;
        fog)
            if [ -z "$tags" ]; then
                node jamout.js --app=$app --fog --port=$pnum --data=$data
            else
                node jamout.js --app=$app --fog --port=$pnum --data=$data --tags=$tags
            fi
            ;;
        device)
            if [ -z "$tags" ]; then
                node jamout.js --app=$app --port=$pnum --data=$data
            else
                node jamout.js --app=$app --port=$pnum --data=$data --tags=$tags
            fi
            ;;
    esac
}


# This is always scanning for a command with 'node'
portavailable() {
    local folder=$1
    local port=$2

    if [ -d $folder/$port ]; then
        if [ -e $folder/$port/processId ]; then
            local pid=`cat $folder/$port/processId`
            if [ ! -z $pid ]; then
                porttaken=`ps -p $pid | grep node | wc -l`
            else
                porttaken=0
            fi
        else
            porttaken=0
        fi
    else
        porttaken=0
    fi
}

# Initialize all the option variables.
app=testapp
type=device
data=127.0.0.1:6379
tags=
group="default"

file=$1
shift
fext="${file##*.}"

if [ -z $file ] || [ $file = "-h" ]; then
    show_usage
    exit 1
fi

if [ "$fext" != "jxe" ]; then
    die "Extension on $file is not .jxe"
fi

# Check whether mosquitto tools are there
checkmosquitto


while :; do
    case $1 in
        -h|-\?|--help)
            show_usage      # Display a usage synopsis.
            exit
            ;;
        -a|--app)           # Takes an option argument; ensure it has been specified.
            if [ "$2" ]; then
                app=$2
                shift
            else
                die 'ERROR: "--app" requires a non-empty option argument.'
            fi
            ;;
        --app=?*)
            app=${1#*=}     # Delete everything up to "=" and assign the remainder.
            ;;
        --app=)            # Handle the case of an empty
            die 'ERROR: "--app" requires a non-empty option argument.'
            ;;
        -t|--tags)           # Takes an option argument; ensure it has been specified.
            if [ "$2" ]; then
                tags=$2
                shift
            else
                die 'ERROR: "--tags" requires a non-empty option argument.'
            fi
            ;;
        --tags=?*)
            tags=${1#*=}     # Delete everything up to "=" and assign the remainder.
            ;;
        --tags=)            # Handle the case of an empty
            die 'ERROR: "--tags" requires a non-empty option argument.'
            ;;
        -d|--data)           # Takes an option argument; ensure it has been specified.
            if [ "$2" ]; then
                data=$2
                shift
            else
                die 'ERROR: "--data" requires a non-empty option argument.'
            fi
            ;;
        --data=?*)
            data=${1#*=}     # Delete everything up to "=" and assign the remainder.
            ;;
        --data=)            # Handle the case of an empty
            die 'ERROR: "--data" requires a non-empty option argument.'
            ;;
        -g|--group)           # Takes an option argument; ensure it has been specified.
            if [ "$2" ]; then
                group=$2
                shift
            else
                die 'ERROR: "--group" requires a non-empty option argument.'
            fi
            ;;
        --group=?*)
            group=${1#*=}     # Delete everything up to "=" and assign the remainder.
            ;;
        --group=)            # Handle the case of an empty
            die 'ERROR: "--group" requires a non-empty option argument.'
            ;;
        -f|--fog)
            if [ "$type" != "device" ]; then
                die 'ERROR: "type" cannot be reassigned.'
            else
                type="fog"
            fi
            ;;
        -c|--cloud)
            if [ "$type" != "device" ]; then
                die 'ERROR: "type" cannot be reassigned.'
            else
                type="cloud"
            fi
            ;;
        --)              # End of all options.
            shift
            break
        ;;
        -?*)
            printf 'WARN: Unknown option (ignored): %s\n' "$1" >&2
            ;;
        *)               # Default case: No more options, so break out of the loop.
            break
    esac

    shift
done

echo "Don't use jrun and crun! Use jamrun instead of them."
echo "Exiting."
exit

if [ "$type" != "device" ] && [ -n "$num" ]; then
    die "number of devices can't be speciied for fog/cloud"
fi


resolvedocker $data

if [ -e "$file" ]; then

    # Check whether the global __jamruns folder is there
    jamfolder=$HOME"/__jamruns"
    create_missingdir $jamfolder

    appfolder=$jamfolder/apps
    create_missingdir $appfolder

    # Get the folder
    filenoext="${file%.*}"
    folder=$appfolder/$filenoext"_"$app
    create_missingdir $folder

    # unzip the executable in the folder and run it..
    # We are unzipping the copying the files no matter what!
    unzip -oq $file -d $folder
    if [ $? -ne 0 ]; then
        die "Problem reading file: $file"
    fi

    cd $folder

    if [ -e jamout.js ]; then
        # execute the program.. we are in the folder..
        case $type in
            cloud)
                iport=9883
                while [ : ]; do
                    portavailable $folder $iport
                    [[ $porttaken == 1 ]] || break
                    ((iport++))
                done
                create_missingdir $folder/$iport
                dojamout $type $iport $folder
                ;;
            fog)
                iport=5883
                while [ : ]; do
                    portavailable $folder $iport
                    [[ $porttaken == 1 ]] || break
                    ((iport++))
                done
                create_missingdir $folder/$iport
                dojamout $type $iport $folder
                ;;
            device)
                iport=1883
                while [ : ]; do
                    portavailable $folder $iport
                    [[ $porttaken == 1 ]] || break
                    ((iport++))
                done
                create_missingdir $folder/$iport
                writegroup $iport $group
                dojamout $type $iport $folder
                ;;
        esac
    else
        die "Not a valid .jxe file"
    fi

else
    die ".jxe file not found"
fi