#!/bin/bash
# config-scripts/src/share/svc--gdi-link-tx/gdi-link-tx.sh
#
#  Copyright: ©2009–2014, Güralp Systems Ltd.
#  Author: Laurence Withers <lwithers@guralp.com>
#  License: GPLv3
#

# Handle the navbar query without loading anything
if [ "$1" = "--navbar" ]
then
    echo "servicestop Services"
    echo "servicessub/gdi-link-tx gdi-link-tx"
    echo "gdi-link-tx/$3 $3"
    exit 0
fi

# Load support functions
script_dir=`dirname $0`
. "${script_dir}/functions.sh"
. "${script_dir}/svc_funcs.sh"
. "${script_dir}/gdi-base_link.sh"

name="$2"
sel="$3"

CFGFILE="${CONFIGDIR}/${name}/${sel}.local"
CTLFILE="${CONFIGDIR}/${name}/${sel}.ctl.local"
SRVBASE="${SERVDIR}/${name}"
CLEANDIR="${CONFIGDIR}/directory-cleaner"
DCCFGFILE="${CLEANDIR}/gdi-link-tx.${sel}.local"


do_read() {
    local -i peer_count
    local PEERDIR PEERDIR2 PEERFILE peer_name peer_host peer_service peer_autostart

    # Standard control info
    gcs_svc_read || return 1

    # Now the service type dependant variables

    ## Global defaults
    gcs_var "d_client_name"             ""
    gcs_var "d_host"                    ""
    gcs_var "d_service"                 ""
    gcs_var "d_sensor_control_enabled"  "true"
    gcs_var "d_terminal_enabled"        "false"
    gcs_var "d_backfill_enabled"        "false"
    gcs_var "d_backfill_directory"      "/var/lib/${name}.${sel}"
    gcs_var "d_directory"               "/var/lib/${name}.${sel}"
    gcs_var "d_filesort"                "lexical"
    gcs_var "d_maximum_size"            "50"
    gcs_var "d_maximum_files"           "24"
    ## Global, but not exposed in template
    gcs_var "d_peer_control_socket"     "/var/run/${name}.${sel}.control"

    if [ -r "${CFGFILE}" ]
    then
        ## Global
        gcs_var_o "client_name"
        gcs_var_o "host"
        gcs_var_o "service"
        gcs_var_o "sensor_control_enabled"
        gcs_var_o "terminal_enabled"
        gcs_var_o "backfill_enabled"
        gcs_var_o "backfill_directory"
        gcs_var_o "peer_control_socket"

        if [ -r "${DCCFGFILE}" ]
        then
            directory=`gcs_get_varcf "directory" "$DCCFGFILE"`
            [ -n $directory ] && echo "o_directory=\"$directory\""
            filesort=`gcs_get_varcf "filesort" "$DCCFGFILE"`
            [ -n $filesort ] && echo "o_filesort=\"$filesort\""
            maximum_size=`gcs_get_varcf "maximum_size" "$DCCFGFILE"`
            [ -n $maximum_size ] && echo "o_maximum_size=\"$maximum_size\""
            maximum_files=`gcs_get_varcf "maximum_files" "$DCCFGFILE"`
            [ -n $maximum_files ] && echo "o_maximum_files=\"$maximum_files\""
        fi

        gcs_gdi_base_iselect "`gcs_get_varcf "gdi_socket" "${CFGFILE}"`" "sink"
    else
        gcs_gdi_base_iselect "" "sink"
    fi

    ## Peers
    PEERDIR="/etc/${name}/${sel}.peers.local"
    peer_count=0
    for PEERFILE in "${PEERDIR}"/*
    do
        [ ! -r "${PEERFILE}" ] && continue
        peer_name="${PEERFILE//*\/}"
        peer_host="`gcs_get_varcf "host" "${PEERFILE}"`"
        [ -z "${peer_host}" ] && continue
        peer_service="`gcs_get_varcf "service" "${PEERFILE}"`"
        peer_autostart="`gcs_get_varcf "autostart" "${PEERFILE}"`"

        gcs_var "o_push_peer_name${peer_count}"         "${peer_name}"
        gcs_var "o_push_peer_host${peer_count}"         "${peer_host}"
        gcs_var "o_push_peer_service${peer_count}"      "${peer_service}"
        gcs_var "o_push_peer_autostart${peer_count}"    "${peer_autostart}"
        ((++peer_count))
    done
}



do_check() {
    gcs_read_vars
    gcs_svc_check
    gcs_gdi_base_dereference "sink"
}



do_write() {
    local -i peer_count
    local peer_name peer_host peer_service peer_autostart PEERDIR

    do_check
    if (( gcs_errors > 0 ))
    then
        return
    fi

    PEERDIR="/etc/${name}/${sel}.peers.local"

    if gcs_truefalse "${new_delete:-false}"
    then
        rm -rf "${PEERDIR}"
        gcs_svc_delete "${name}" "${sel}"
    fi

    # Standard service controls
    gcs_ensure_cfgfile_exists "${CTLFILE}"
    gcs_set_varf DESC "${CTLFILE}" "${desc}"

    # Now the service type dependant variables
    gcs_ensure_cfgfile_exists "${CFGFILE}"

    ## Global
    gcs_set_varcf "client_name"                 "${CFGFILE}" "${new_client_name}"
    gcs_set_varcf "host"                        "${CFGFILE}" "${new_host}"
    gcs_set_varcf "service"                     "${CFGFILE}" "${new_service}"
    gcs_set_varcf "sensor_control_enabled"      "${CFGFILE}" "${new_sensor_control_enabled}"
    gcs_set_varcf "terminal_enabled"            "${CFGFILE}" "${new_terminal_enabled}"
    gcs_set_varcf "backfill_enabled"            "${CFGFILE}" "${new_backfill_enabled}"
    gcs_set_varcf "backfill_directory"          "${CFGFILE}" "${new_backfill_directory}"

    # Note these next four are in the directory-cleaner config file so we only do
    # it if backfill is enabled
    if gcs_truefalse "${new_backfill_enabled}"
    then
	# Now we need make sure the directory cleaner file is there
        gcs_ensure_cfgfile_exists "${DCCFGFILE}"

        gcs_set_varcf "directory"               "${DCCFGFILE}" "${new_directory}"
        gcs_set_varcf "filesort"                "${DCCFGFILE}" "${new_filesort/_/}"
        gcs_set_varcf "maximum_size"            "${DCCFGFILE}" "${new_maximum_size}"
        gcs_set_varcf "maximum_files"           "${DCCFGFILE}" "${new_maximum_files}"
    fi

    gcs_set_varcf "peer_directory"              "${CFGFILE}" "${PEERDIR}"
    gcs_set_varcf "peer_control_socket"         "${CFGFILE}" "${new_peer_control_socket}"
    gcs_set_varcf "peer_control_socket_group"   "${CFGFILE}" "data"
    gcs_set_varcf "peer_control_socket_mode"    "${CFGFILE}" "0660"
    gcs_set_varcf "gdi_socket"                  "${CFGFILE}" "${new_gdi_socket}"

    ## Peers
    group_mkdir "${PEERDIR}"
    rm -f "${PEERDIR}"/*
    for (( peer_count = 0 ; peer_count < ${new_push_peers_rows} ; peer_count++ ))
    do
        eval peer_name="\${new_push_peer_name${peer_count}}"
        [ -z "${peer_name}" ] && continue
        eval peer_host="\${new_push_peer_host${peer_count}}"
        eval peer_service="\${new_push_peer_service${peer_count}}"
        [ -z "${peer_service}" ] && peer_service="gdi_link_rx"
        eval peer_autostart="\${new_push_peer_autostart${peer_count}}"
        cat > "${PEERDIR}/${peer_name}" <<EOF
# Generated by gcs, `isodate -se`
host = ${peer_host}
service = ${peer_service}
autostart = ${peer_autostart:-False}
EOF
    done

    # Update the service script
    gcs_update_svc "${name}" "${sel}" "${enable}" "${desc}" "${CFGFILE}" \
            "${CTLFILE}" "${SRVBASE}" "${new_socket}"
    gcs_svc_reload "${name}" "${sel}"
}



case "$1" in
--check)
    do_check
    ;;

--write)
    do_write
    ;;

--read)
    do_read
    ;;

*)
    exit 1
    ;;
esac

gcs_cleanup
exit 0

# vim: ts=4:sw=4:expandtab