#!/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-rx gdi-link-rx"
    echo "gdi-link-rx/$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}"


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_backfill_enabled"            "False"
    gcs_var "d_backfill_directory"          "/var/lib/${name}.${sel}"
    ## 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 "backfill_enabled"
        gcs_var_o "backfill_directory"
        gcs_var_o "peer_control_socket"

        gcs_gdi_base_iselect "`gcs_get_varcf "gdi_socket" "${CFGFILE}"`" "source"
    else
        gcs_gdi_base_iselect "" "source"
    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}"`"
        peer_channel_filter="`gcs_get_varcf "channel_filter" "${PEERFILE}"`"
        peer_max_sample_rate="`gcs_get_varcf "max_sample_rate" "${PEERFILE}"`"
        peer_channel_names="`gcs_get_varcf "channel_names" "${PEERFILE}"`"

        gcs_var "o_pull_peer_name${peer_count}"             "${peer_name}"
        gcs_var "o_pull_peer_host${peer_count}"             "${peer_host}"
        gcs_var "o_pull_peer_service${peer_count}"          "${peer_service}"
        gcs_var "o_pull_peer_autostart${peer_count}"        "${peer_autostart}"
        gcs_var "o_pull_peer_channel_filter${peer_count}"   "${peer_channel_filter}"
        gcs_var "o_pull_peer_max_sample_rate${peer_count}"  "${peer_max_sample_rate}"
        gcs_var "o_pull_peer_channel_names${peer_count}"    "${peer_channel_names}"
        ((++peer_count))
    done
}



do_check() {
    local -i peer_count
    local peer_name peer_filter

    gcs_read_vars

    # Standard service control/info vars
    gcs_svc_check

    # Service dependant variables
    # Most of the checks are done by the main engine

    gcs_gdi_base_dereference "source"

    for (( peer_count = 0 ; peer_count < ${new_pull_peers_rows} ; peer_count++ ))
    do
        eval peer_name="\${new_pull_peer_name${peer_count}}"
        [ -z "${peer_name}" ] && continue
        eval peer_filter="\${new_pull_peer_channel_filter${peer_count}}"
        case "${peer_filter}" in
        sample_rate)
            eval peer_filter="\${new_pull_peer_max_sample_rate${peer_count}}"
            ;;
        name)
            eval peer_filter="\${new_pull_peer_channel_names${peer_count}}"
            ;;
        esac
        if [ -z "${peer_filter}" ]
        then
            gcs_err "pull_peers" "Must set sample rate/channel names for filter."
        fi
    done
}



do_write() {
    local -i peer_count
    local PEER_FILE peer_name peer_host peer_service peer_autostart peer_filter 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 "backfill_enabled"            "${CFGFILE}" "${new_backfill_enabled}"
    gcs_set_varcf "backfill_directory"          "${CFGFILE}" "${new_backfill_directory}"
    gcs_set_varcf "backfill_directory_group"    "${CFGFILE}" "data"
    gcs_set_varcf "backfill_directory_mode"     "${CFGFILE}" "02775"
    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_pull_peers_rows} ; peer_count++ ))
    do
        eval peer_name="\${new_pull_peer_name${peer_count}}"
        [ -z "${peer_name}" ] && continue
        eval peer_host="\${new_pull_peer_host${peer_count}}"
        eval peer_service="\${new_pull_peer_service${peer_count}}"
        [ -z "${peer_service}" ] && peer_service="gdi_link_tx"
        eval peer_autostart="\${new_pull_peer_autostart${peer_count}}"
        eval peer_filter="\${new_pull_peer_channel_filter${peer_count}}"

        PEER_FILE="${PEERDIR}/${peer_name}"
        cat > "${PEER_FILE}" <<EOF
# Generated by gcs, `isodate -se`
host = ${peer_host}
service = ${peer_service}
autostart = ${peer_autostart:-False}
channel_filter = ${peer_filter}
EOF

        eval peer_filter="\${new_pull_peer_max_sample_rate${peer_count}}"
        [ -n "${peer_filter}" ] && echo "max_sample_rate = ${peer_filter}" >> "${PEER_FILE}"
        eval peer_filter="\${new_pull_peer_channel_names${peer_count}}"
        [ -n "${peer_filter}" ] && echo "channel_names = ${peer_filter}" >> "${PEER_FILE}"
    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