#!/bin/sh

# Currently support only MySQL
# php5-fpm-fcgi nginx

# Turn of auto expansion
set -f

# stanv@ :

# This backend uses `augtool'

# set `verbose' to get debug output for `alterator -l -d'

alterator_api_version=1
po_domain="alterator-zabbix-server"

# libshell
verbose=
. shell-error

v() {
    verbose "__DEBUG__" $@
}

readonly Z_SRV_CFG="/etc/zabbix/zabbix_server.conf"

readonly SERVICE_ZABBIX_MYSQL="zabbix_mysql"
readonly SERVICE_ZABBIX_PGSQL="zabbix_pgsql"
readonly SERVICE_DB_MYSQL="mysqld"
readonly SERVICE_WEB_NGINX="nginx"
readonly SERVICE_PHP5_FPM="php5-fpm"

readonly DB_MYSQL_ADMIN_USER="root"
readonly MYSQL_DB_NAME="zabbix"
readonly MYSQL_USER_NAME="zabbix"
readonly Z_PKG_NAME="zabbix-server-mysql"

readonly MYSQL_DB_FORMAT1="schema.sql"
readonly MYSQL_DB_FORMAT2="images.sql"
readonly MYSQL_DB_FORMAT3="data.sql"
readonly ALTLINUX_DB_FORMAT3="/usr/share/zabbix-altlinux/data.sql"

readonly ZABBIX_FRONTEND_CONFIG_DIR="/var/www/webapps/zabbix/frontends/php/conf"
readonly ZABBIX_FRONTEND_CONFIG_IN="zabbix.conf.php.example"
readonly ZABBIX_FRONTEND_CONFIG_OUT="zabbix.conf.php"
readonly NGINX_CONFIG="alterator-zabbix-server.conf"
readonly NGINX_DIR_AVAILABLE="/etc/nginx/webapps-available.d"
readonly NGINX_DIR_ENABLED="/etc/nginx/webapps-ssl-enabled.d"

readonly AUG_PHP_BASE="/files/etc/php"
readonly PHP_FPM_CONFIG="alterator-zabbix-server.ini"

. alterator-sh-functions
. shell-ini-config
. alterator-service-functions
. alterator-postfix-dovecot-functions
. shell-config

readonly msg_no="`_ 'No'`"
readonly msg_yes="`_ 'Yes'`"

# augtool for this backend
# load only necessary modules
# See available modules at: /usr/share/augeas/lenses/dist
# and # augtool match '/augeas/load/*'
# Prints results to STDOUT
aug() {
    v "invoke augtool with: $@"
    augtool -A -i << _EOF_
set /augeas/load/Nginx/lens nginx.lns
set /augeas/load/Nginx/incl[1] /etc/nginx/nginx.conf

set /augeas/load/MySQL/lens mysql.lns
set /augeas/load/MySQL/incl[1] /etc/my.cnf
set /augeas/load/MySQL/incl[2] /etc/mysql/conf.d/*.cnf
set /augeas/load/MySQL/incl[3] /etc/mysql/my.cnf

set /augeas/load/Simplevars/lens simplevars.lns
set /augeas/load/Simplevars/incl[1] /etc/zabbix/*.conf

set /augeas/load/PHP/lens php.lns
set /augeas/load/PHP/incl[last()+1] /etc/php/*/fpm/php.d/*.ini

set /augeas/load/Phpvars/lens phpvars.lns
set /augeas/load/Phpvars/incl[last()+1] /var/www/webapps/zabbix/frontends/php/conf/zabbix.conf.php

load

$@

save
quit
_EOF_
    return $?
}


# AUGEAS: REMOVE PATH
aug_rm() {
    local file="$1"
    local entry="$2"

    if [ -z "$file" -o -z "$entry" ]; then
        v "aug_rm() wrong invocation"
        return
    fi

    local path="/files/$file/$entry"

    v "aug_rm() path = $path"

    aug "rm" "$path"
}


# AUGEAS: TEST EXISTENCE
aug_present() {
    local file="$1"
    local entry="$2"

    if [ -z "$file" -o -z "$entry" ]; then
        v "aug_present() wrong invocation"
        return
    fi

    local path="/files/$file/$entry"

    v "aug_present() path = $path"

    local result="$(aug "get" "$path")"

    v "aug_present() key value = $result"

    if [ -z "${result##*\(o\)}" ]; then
        v "aug_present() key $path isn't present"
        return 1
    fi

    v "aug_present() key $path is present"
    return 0
}


# HELPER TO DISPLAY DEBUG DATA IN FRONTEND IN ONE LINE
print_info() {
    echo ' '
    echo "# $@"
    $@ 2>&1
    echo ' '
}


# WRITE ANY DEBUG INFORMATION TO FRONTEND
write_debug_info() {
        local info=

        info="${info}$(print_info "lsof -c "$SERVICE_DB_MYSQL" -a -iTCP -sTCP:LISTEN")"
        info="${info}$(print_info "lsof -c "$SERVICE_WEB_NGINX" -a -iTCP -sTCP:LISTEN")"
        info="${info}$(print_info "lsof -c "$SERVICE_ZABBIX_MYSQL" -a -iTCP -sTCP:LISTEN")"
        info="${info}$(print_info "lsof -c "$SERVICE_ZABBIX_PGSQL" -a -iTCP -sTCP:LISTEN")"
        write_string_param "information" "$info"
}


# PRINT STATUS: ZABBIX
print_status_zabbix() {
    v "print_status_zabbix() -- entered"

    local active="$msg_no"
    local status="`_ 'There are no RPM packages installed'`"
    local known=""

    if service_control "$SERVICE_ZABBIX_MYSQL" "is-active"; then
        v "$SERVICE_ZABBIX_MYSQL is active"
        status="`_ "service $SERVICE_ZABBIX_MYSQL is active"`"
        active="$msg_yes"
        known="1"
    fi

    if [ -z "$known" ] && service_exists "$SERVICE_ZABBIX_MYSQL"; then
        v "$SERVICE_ZABBIX_MYSQL is installed, but is not configured"
        status="`_ "$SERVICE_ZABBIX_MYSQL is not configured"`"
        known="1"
    fi

    write_string_param "label_status_z_enabled" "$active"
    write_string_param "label_status_z_info" "$status"
}


# PRINT STATUS: WEB
print_status_web() {
    v "print_status_web() -- entered"

    local active="$msg_no"
    local status="`_ 'There are no RPM packages installed'`"
    local known=""

    if service_control "$SERVICE_WEB_NGINX" "is-active"; then
        v "$SERVICE_WEB_NGINX is active"
        status="`_ "service $SERVICE_WEB_NGINX is active"`"
        active="$msg_yes"
        known="1"
    fi

    if [ -z "$known" ] && service_exists "$SERVICE_WEB_NGINX"; then
        v "$SERVICE_WEB_NGINX is installed, but is not configured"
        status="`_ "$SERVICE_WEB_NGINX is not configured"`"
        known="1"
    fi

    if service_control "$SERVICE_PHP5_FPM" "is-active"; then
        v "$SERVICE_PHP5_FPM is active"
        local add="`_ ", service $SERVICE_PHP5_FPM is active"`"
        status="${status}${add}"
        known="1"
    fi

    write_string_param "label_status_web_enabled" "$active"
    write_string_param "label_status_web_info" "$status"
}


# PRINT STATUS: DB
print_status_db() {
    v "print_status_db() -- entered"

    local active="$msg_no"
    local status="`_ 'There are no RPM packages installed'`"
    local known=""

    if service_control "$SERVICE_DB_MYSQL" "is-active"; then
        v "$SERVICE_DB_MYSQL is active"
        status="`_ "service $SERVICE_DB_MYSQL is active"`"
        active="$msg_yes"
        known="1"
    fi

    if [ -z "$known" ] && service_exists "$SERVICE_DB_MYSQL"; then
        v "$SERVICE_DB_MYSQL is installed, but is not configured"
        status="`_ "$SERVICE_DB_MYSQL is not configured"`"
        known="1"
    fi

    write_string_param "label_status_db_enabled" "$active"
    write_string_param "label_status_db_info" "$status"
}


# LIST POSSIBLE ZABBIX CHOICES
list_zabbix_mode() {
  v "list_zabbix_choices() -- entered"

  if service_exists "$SERVICE_ZABBIX_MYSQL"; then
    v "$SERVICE_ZABBIX_MYSQL - list as available"
    write_enum_item "zabbix_local_mysql" "`_ 'Zabbix server for local MySQL server'`"
  fi

  write_enum_item "off" "`_ 'Do not use Zabbix server'`"
}


# HAS THE INITIAL CONFIGURATION BEEN DONE ?
chk_initial_mysql_cfg_done() {
    v "chk_initial_cfg_done() -- enter"

    # no
    local setup_done=

    aug_present "$Z_SRV_CFG" "DBName" &&
        aug_present "$Z_SRV_CFG" "DBUser" &&
        aug_present "$Z_SRV_CFG" "DBPassword"
    setup_done=$?

    v "chk_initial_cfg_done() -- result: $setup_done"
    return $setup_done
}


# PRING GENERAL CONFIG STATUS
print_cfg_status() {
    v "print_cfg_status() -- enter"

    local bool=0
    local mode="off"

    if chk_initial_mysql_cfg_done; then
        v "print_cfg_status() -- configuration done for local MySQL"
        mode="zabbix_local_mysql"
        bool=1
    fi

    write_string_param "list_zabbix_mode" "$mode"
    write_bool_param "cfg_done" "$bool"
}


# MYSQL: EXEC COMMAND
db_mysql_run_cmd() {
    v "db_mysql_run_cmd() -- enter"
    v "db_mysql_run_cmd command: $@"

    local p=

    if [ -n "$in_mysql_admin_pass" ]; then
      p="$in_mysql_admin_pass"
    elif [ -n "$in_mysql_admin_pass2" ]; then
      p="$in_mysql_admin_pass2"
    fi

    if [ -n "$p" ]; then
        echo "$@" | mysql --user="$DB_MYSQL_ADMIN_USER" --silent --password="$p" 2>/dev/null
    else
        echo "$@" | mysql --user="$DB_MYSQL_ADMIN_USER" --silent 2>/dev/null
    fi
}


# MYSQL: CHECK MYSQL IS ACCESSIBLE
mysql_have_access() {
    v "mysql_have_access() -- entered"
    # db is accessible
    local required=0
    local result=

    db_mysql_run_cmd "show databases;" | grep -s -q "mysql"
    result=$?

    if [ $result -ne 0 ]; then
        # db isn't accessible
        required=1
    fi

    return $required
}


# MYSQL: PRINT ADMIN REQUIRES PASSWORD
print_mysql_pass_is_required() {
    v "print_mysql_pass_is_required() -- entered"

    # password is not required
    local required=0

    if ! mysql_have_access; then
        required=1
    fi

    v "bool_mysql_pass_required = $required"
    write_bool_param "bool_mysql_pass_required" "$required"
}


# MYSQL: RUN COMMANDS FROM FILE FOR $MYSQL_DB_NAME
db_mysql_run_file_zabbix_db() {

    v "db_mysql_run_file_zabbix_db() -- enter"

    local file="$1"

    if ! [ -r "$file" ]; then
        v "db_mysql_run_file_zabbix_db() -- can't find $ff"
        return
    fi

    v "db_mysql_run_file_zabbix_db(): apply $file for $MYSQL_DB_NAME"

    if [ -z "$in_mysql_admin_pass" ]; then
        v "db_mysql_run_file_zabbix_db() -- do not use password"
        cat "$file" | mysql --user="$DB_MYSQL_ADMIN_USER" "$MYSQL_DB_NAME"
    else
        v "db_mysql_run_file_zabbix_db() -- use password"
        cat "$file" | mysql --user="$DB_MYSQL_ADMIN_USER" --password="$in_mysql_admin_pass" "$MYSQL_DB_NAME"
    fi
}


# PROCEED BASIC INITIALIZATION: MYSQL
do_basic_initialization_mysql() {
    v "do_basic_initialization_mysql() - enter"

    if ! service_control "$SERVICE_DB_MYSQL" "is-active"; then
        v "$SERVICE_DB_MYSQL is not active. Activate it"
        service_start_wait "$SERVICE_DB_MYSQL" "start"
    fi

    if service_control "$SERVICE_ZABBIX_MYSQL" "is-active"; then
        v "$SERVICE_ZABBIX_MYSQL is active. Stop it"
        service_control "$SERVICE_ZABBIX_MYSQL" "stop"
    fi

    if ! mysql_have_access; then
        local reason="Can't access MySQL BD."
        v "$reason"
        write_error "$reason"
        return
    fi

    # create DB in MySQL
    local MYSQL_PASS="$(pwgen -1)"
    db_mysql_run_cmd "drop database $MYSQL_DB_NAME;"
    db_mysql_run_cmd "create database $MYSQL_DB_NAME character set utf8;"
    db_mysql_run_cmd "grant all privileges on $MYSQL_DB_NAME.* to $MYSQL_USER_NAME identified by '$MYSQL_PASS';"
    db_mysql_run_cmd "grant all privileges on $MYSQL_DB_NAME.* to '$MYSQL_USER_NAME'@'localhost' identified by '$MYSQL_PASS';"
    db_mysql_run_cmd "flush privileges;"

    # fill up DB format
    local db_format_path="$(rpm -ql "$Z_PKG_NAME" | grep "$MYSQL_DB_FORMAT1" | head -1)"
    db_format_path="$(dirname "$db_format_path")"

    # apply db format file
    local ff=

    # apply mysql tables from altlinux-zabbix-data package if exists
    if [ -f "$ALTLINUX_DB_FORMAT3" ];then 
	db_mysql_run_file_zabbix_db "$ALTLINUX_DB_FORMAT3"
    else
	for f in "$MYSQL_DB_FORMAT1" "$MYSQL_DB_FORMAT2" "$MYSQL_DB_FORMAT3"; do
    	    ff="$db_format_path/$f"
    	    db_mysql_run_file_zabbix_db "$ff"
	done
    fi

    # zabbix server config
    aug_rm "$Z_SRV_CFG" "ListenIP"
    aug_rm "$Z_SRV_CFG" "DBHost"
    aug "set" "/files/$Z_SRV_CFG/DBName" "$MYSQL_DB_NAME"
    aug "set" "/files/$Z_SRV_CFG/DBUser" "$MYSQL_USER_NAME"
    aug "set" "/files/$Z_SRV_CFG/DBPassword" "$MYSQL_PASS"

    # zabbix server restart
    service_start_wait "$SERVICE_ZABBIX_MYSQL" "restart"
}


# PROCEED BASIC INITIALIZATION: ZABBIX FRONTEND
do_basic_initialization_frontend() {
    v "do_basic_initialization_frontend() -- enter"

    # zabbix frontend sample config
    local fc_in="$ZABBIX_FRONTEND_CONFIG_DIR/$ZABBIX_FRONTEND_CONFIG_IN"
    if ! [ -e "$fc_in" ]; then
        v "do_basic_initialization_frontend() -- sample config is missing $fc_in"
        return
    fi

    local fc="$ZABBIX_FRONTEND_CONFIG_DIR/$ZABBIX_FRONTEND_CONFIG_OUT"
    if [ -e "$fc" ]; then
        v "do_basic_initialization_frontend() -- rm frontend zabbix config $fc"
        rm -f "$fc"
    fi

    cp "$fc_in" "$fc"

    v "do_basic_initialization_nginx() -- read DB settings"
    local db_name="$(aug_get "/files/$Z_SRV_CFG/DBName")"
    local db_user="$(aug_get "/files/$Z_SRV_CFG/DBUser")"
    local db_pass="$(aug_get "/files/$Z_SRV_CFG/DBPassword")"

    aug "set" "/files/$fc/\$DB[@arraykey = '[\"USER\"]']" "\'$db_user\'"
    aug "set" "/files/$fc/\$DB[@arraykey = '[\"PASSWORD\"]']" "\'$db_pass\'"
    aug "set" "/files/$fc/\$DB[@arraykey = '[\"DATABASE\"]']" "\'$db_name\'"
}


# PROCEED BASIC INITIALIZATION: NGINX
do_basic_initialization_nginx() {
    v "do_basic_initialization_nginx() -- enter"

    # nginx config
    if ! [ -e "$NGINX_DIR_AVAILABLE/$NGINX_CONFIG" ]; then
        v "do_basic_initialization_nginx() -- can't find $NGINX_DIR_AVAILABLE/$NGINX_CONFIG"
        return 1
    fi

    if [ -e "$NGINX_DIR_ENABLED/$NGINX_CONFIG" ]; then
        v "$NGINX_DIR_ENABLED/$NGINX_CONFIG exists, remove it"
        rm -f "$NGINX_DIR_ENABLED/$NGINX_CONFIG"
    fi

    v "do_basic_initialization_nginx -- create link $NGINX_DIR_ENABLED/$NGINX_CONFIG"

    ln -s "$NGINX_DIR_AVAILABLE/$NGINX_CONFIG" "$NGINX_DIR_ENABLED/$NGINX_CONFIG"

    service_start_wait "$SERVICE_WEB_NGINX" "restart"

    if ! service_control "$SERVICE_WEB_NGINX" "is-active"; then
        v "$SERVICE_WEB_NGINX is not active. Fail."
        return 1
    fi

    # fpm php config
    aug "set" "$AUG_PHP_BASE/*/fpm/php.d/$PHP_FPM_CONFIG/PHP/memory_limit" "256M"
    aug "set" "$AUG_PHP_BASE/*/fpm/php.d/$PHP_FPM_CONFIG/PHP/post_max_size" "32M"
    aug "set" "$AUG_PHP_BASE/*/fpm/php.d/$PHP_FPM_CONFIG/PHP/max_execution_time" "600"
    aug "set" "$AUG_PHP_BASE/*/fpm/php.d/$PHP_FPM_CONFIG/PHP/max_input_time" "600"
    aug "set" "$AUG_PHP_BASE/*/fpm/php.d/$PHP_FPM_CONFIG/PHP/safe_mode" "Off"
    aug "set" "$AUG_PHP_BASE/*/fpm/php.d/$PHP_FPM_CONFIG/Date/date.timezone" "Europe/Moscow"

    service_start_wait "$SERVICE_PHP5_FPM" "restart"
}


# AUGEAS: GET NODE VALUE, RETURN EMPTY STRING IN CASE EMPTY NODE
aug_get () {
    local path="$1"

    v "aug_get() -- path = $path"

    local result="$(aug "get" "$path")"

    if [ -z "${result##*\(o\)}" ]; then
        v "aug_get() -- path $path isn't present"
        return 1
    fi

    result="${result##* = }"

    v "aug_get() -- value for $path is $result"

    echo "$result"
    return 0
}


# ZABBIX: PRINT SERVER OPTIONS
print_cfg_zabbix() {
    v "print_cfg_zabbix() -- enter"

    local listenip="$(aug_get "/files/$Z_SRV_CFG/ListenIP")"
    local listenport="$(aug_get "/files/$Z_SRV_CFG/ListenPort")"
    local starttrappers="$(aug_get "/files/$Z_SRV_CFG/StartTrappers")"
    local startpollers="$(aug_get "/files/$Z_SRV_CFG/StartPollers")"
    local startsnmptrapper="$(aug_get "/files/$Z_SRV_CFG/StartSNMPTrapper")"

    write_string_param "input_z_listen_addr" "$listenip"
    write_string_param "input_z_listen_port" "$listenport"
    write_string_param "input_z_num_trappers" "$starttrappers"
    write_string_param "input_z_num_pollers" "$startpollers"
    write_bool_param "bool_z_start_snmp_trapper" "$startsnmptrapper"
}


# ZABBIX: DEACTIVATE
do_deactivate() {
    v "do_deactivate() -- enter"

    aug_rm "$Z_SRV_CFG" "DBName"
    aug_rm "$Z_SRV_CFG" "DBUser"
    aug_rm "$Z_SRV_CFG" "DBPassword"

    service_control "$SERVICE_ZABBIX_MYSQL" "stop"

    local fc="$ZABBIX_FRONTEND_CONFIG_DIR/$ZABBIX_FRONTEND_CONFIG_OUT"
    if [ -e "$fc" ]; then
        v "do_deactivate() -- rm frontend zabbix config $fc"
        rm -f "$fc"

    fi

    if [ -e "$NGINX_DIR_ENABLED/$NGINX_CONFIG" ]; then
        v "do_deactivate() -- $NGINX_DIR_ENABLED/$NGINX_CONFIG exists, remove it"
        rm -f "$NGINX_DIR_ENABLED/$NGINX_CONFIG"
    fi

    if service_control "$SERVICE_WEB_NGINX" "is-active"; then
        v "$SERVICE_ZABBIX_MYSQL is active"
        status="`_ "service $SERVICE_WEB_NGINX is active, restart it"`"
        service_start_wait "$SERVICE_WEB_NGINX" "restart"
    fi
}


# ZABBIX: WRITE SERVER OPTIONS
write_zabbix_options() {
    v "write_zabbix_options() -- enter"

    local v=
    local o=
    local p="/files/$Z_SRV_CFG"

    # ListenIP
    v="$in_input_z_listen_addr"
    o="ListenIP"
    if [ -z "$v" ]; then
        v "write_zabbix_options() -- $o reset to default"
        aug "rm" "$p/$o"
    else
        v "write_zabbix_options() -- $o set to $v"
        aug "set" "$p/$o" "$v"
    fi

    # ListenPort
    v="$in_input_z_listen_port"
    o="ListenPort"
    if [ -z "$v" ]; then
        v "write_zabbix_options() -- $o reset to default"
        aug "rm" "$p/$o"
    else
        v "write_zabbix_options() -- $o set to $v"
        aug "set" "$p/$o" "$v"
    fi

    # StartTrappers
    v="$in_input_z_num_trappers"
    o="StartTrappers"
    if [ -z "$v" ]; then
        v "write_zabbix_options() -- $o reset to default"
        aug "rm" "$p/$o"
    else
        v "write_zabbix_options() -- $o set to $v"
        aug "set" "$p/$o" "$v"
    fi

    # StartPollers
    v="$in_input_z_num_pollers"
    o="StartPollers"
    if [ -z "$v" ]; then
        v "write_zabbix_options() -- $o reset to default"
        aug "rm" "$p/$o"
    else
        v "write_zabbix_options() -- $o set to $v"
        aug "set" "$p/$o" "$v"
    fi

    # StartSNMPTrapper 0-1, default: 0
    v="$in_bool_z_start_snmp_trapper"
    o="StartSNMPTrapper"
    if [ "$v" = "#t" ]; then
        v "write_zabbix_options() -- $o set to 1"
        aug "set" "$p/$o" "1"
    else
        v "write_zabbix_options() -- $o reset to default"
        aug "rm" "$p/$o"
    fi

    if service_control "$SERVICE_ZABBIX_MYSQL" "is-active"; then
        v "$SERVICE_ZABBIX_MYSQL is active"
        status="`_ "service $SERVICE_ZABBIX_MYSQL is active"`"
        active="$msg_yes"
        known="1"
    fi

    service_start_wait "$SERVICE_ZABBIX_MYSQL" "restart"
}


# INITIAL ZABBIX CONFIGURATION IN MYSQL DB
do_initial_settings_in_mysql_db() {
  v "do_initial_settings_in_mysql_db() -- enter"

  # By default authorization page is in English. To display it in Russian it is
  # necessary to update locale for `guest' user.
  v "Set default locale for login/authentication page"

  db_mysql_run_cmd "UPDATE ${MYSQL_DB_NAME}.users set lang='ru_RU' where alias='guest';"

  # Set language to Russian for Admin in Web GUI
  db_mysql_run_cmd "UPDATE ${MYSQL_DB_NAME}.users set lang='ru_RU' where alias='Admin';"
}


# WRITE ADMIN NEW PASSWORD FOR WEB GUI
write_new_admin_password() {
  v "write_new_admin_password() -- enter"

  local p="$in_input_z_new_admin_password"

  if [ -z "$p" ]; then
    v "write_new_admin_password() -- no password supplied"
    return
  fi

  db_mysql_run_cmd "UPDATE ${MYSQL_DB_NAME}.users set passwd=md5('$p') where alias='Admin';"
}


# MAIN LOOP
on_message() {
    case "$in_action" in

        read)

            write_debug_info

            case "$in__objects" in
                status)
                    # READ CONTROL STATUS FOR USB & SERIAL
                    v "read status"
                    print_cfg_status
                    print_mysql_pass_is_required
                    print_status_zabbix
                    print_status_db
                    print_status_web
                    print_cfg_zabbix
                    ;;

                *)
                    # UNDEFINED READ REQUEST
                    v "undefined read request: $in__objects" 1>&2

                    ;;
            esac
            ;;

        write)

            case "$in__objects" in
                init)
                    # INITIAL CONFIGURATION
                    v "write request: init"
                    do_basic_initialization_nginx &&
                        do_basic_initialization_mysql &&
                        do_basic_initialization_frontend &&
                        do_initial_settings_in_mysql_db

                    ;;

                zabbix)
                    # ZABBIX SERVER
                    v "write request: zabbix"
                    write_zabbix_options

                    ;;

                admin_password)
                    # SET WEB GUI ADMIN PASSWORD
                    write_new_admin_password

                    ;;

                off)
                    # TURN OFF
                    v "write request: off"
                    do_deactivate

                    ;;

                *)
                    # UNDEFINED WRITE REQUEST
                    v "undefined write request: $in__objects" 1>&2

                    ;;

            esac
            ;;

        list)

            case "$in__objects" in

                list_zabbix_mode)
                    # LIST POSSIBLE ZABBIX SERVER MODES
                    v "list available Zabbix server"
                    list_zabbix_mode

                    ;;

                *)
                    # UNDEFINED LIST REQUEST
                    v "undefined list request: $in__objects" 1>&2

                    ;;

            esac
            ;;

        *)
            # UNDEFINED ACTION
            :
            ;;
    esac
}

message_loop

# vim: autoindent tabstop=2 shiftwidth=2 expandtab softtabstop=2 filetype=sh
