mirror of
https://github.com/limosek/zaf.git
synced 2024-11-14 06:29:07 +01:00
472 lines
11 KiB
Bash
472 lines
11 KiB
Bash
|
|
# Hardcoded variables
|
|
ZAF_VERSION="1.2"
|
|
ZAF_GITBRANCH="1.2"
|
|
ZAF_URL="https://github.com/limosek/zaf"
|
|
ZAF_RAW_URL="https://raw.githubusercontent.com/limosek/zaf"
|
|
|
|
############################################ Common routines
|
|
|
|
zaf_msg() {
|
|
echo $@
|
|
}
|
|
zaf_trc() {
|
|
[ "$ZAF_DEBUG" -ge "3" ] && logger -p user.info -s -t zaf-trace -- $@
|
|
}
|
|
zaf_dbg() {
|
|
[ "$ZAF_DEBUG" -ge "2" ] && logger -p user.debug -s -t zaf-debug -- $@
|
|
}
|
|
zaf_wrn() {
|
|
[ "$ZAF_DEBUG" -ge "1" ] && logger -p user.warn -s -t zaf-warning -- $@
|
|
}
|
|
zaf_err() {
|
|
logger -s -p user.err -t zaf-error -- $@
|
|
logger -s -p user.err -t zaf-error "Exiting with error!"
|
|
exit 1
|
|
}
|
|
# Help option
|
|
# $1 - key
|
|
# $2 -
|
|
zaf_hlp() {
|
|
local kl
|
|
local dl
|
|
local cols
|
|
|
|
cols=$COLUMNS
|
|
[ -z "$cols" ] && cols=120
|
|
kl=$(expr $cols / 3)
|
|
dl=$(expr $cols - $kl)
|
|
printf %-${kl}s%-${dl}s%b "$1" "$2" "\n"
|
|
}
|
|
|
|
zaf_version(){
|
|
echo $ZAF_VERSION
|
|
}
|
|
|
|
# Fetch url to stdout
|
|
# $1 url
|
|
# It supports real file, file:// and other schemes known by curl
|
|
zaf_fetch_url() {
|
|
local scheme
|
|
local uri
|
|
local insecure
|
|
local out
|
|
|
|
if zaf_fromcache "$1"; then
|
|
return
|
|
fi
|
|
scheme=$(echo $1|cut -d ':' -f 1)
|
|
uri=$(echo $1|cut -d '/' -f 3-)
|
|
if [ "$1" = "$scheme" ]; then
|
|
cat "$1"
|
|
fi
|
|
case $scheme in
|
|
http|https|ftp|file)
|
|
[ "$scheme" != "file" ] && [ -n "$ZAF_OFFLINE" ] && zaf_err "Cannot download $1 in offline mode!"
|
|
[ "${ZAF_CURL_INSECURE}" = "1" ] && insecure="-k"
|
|
zaf_dbg curl $insecure -f -s -L -o - $1
|
|
curl $insecure -f -s -L -o - "$1" | zaf_tocache_stdin "$1" 120
|
|
;;
|
|
esac
|
|
}
|
|
|
|
# Find and replace string
|
|
zaf_far(){
|
|
local f
|
|
local t
|
|
local sedcmd="sed"
|
|
i=1
|
|
while [ "$i" -lt "$#" ];
|
|
do
|
|
eval f=\$${i}
|
|
i=$(expr $i + 1)
|
|
eval t=\$${i}
|
|
i=$(expr $i + 1)
|
|
sedcmd="$sedcmd -e 's~$f~$t~g'"
|
|
done
|
|
eval $sedcmd
|
|
}
|
|
|
|
# Limit concurrent processes or continue
|
|
zaf_bglimit(){
|
|
local maxbg
|
|
local maxnumber
|
|
local cnumber
|
|
[ -z "$BASH_VERSION" ] && { zaf_dbg "Job server not available. Use bash!"; return 1; }
|
|
if [ $# -eq 0 ] ; then
|
|
maxbg=5
|
|
else
|
|
maxbg=$1
|
|
fi
|
|
maxnumber=$((0 + ${1:-0}))
|
|
while true; do
|
|
cnumber=$(jobs | wc -l)
|
|
if [ $cnumber -lt $maxnumber ]; then
|
|
break
|
|
fi
|
|
zaf_dbg "Limiting next job due to $maxbg limit of bg jobs"
|
|
sleep 1
|
|
done
|
|
}
|
|
|
|
# Initialises discovery function
|
|
zaf_discovery_begin(){
|
|
cat <<EOF
|
|
{
|
|
"data":[
|
|
EOF
|
|
}
|
|
|
|
# Add row(s) to discovery data
|
|
zaf_discovery_add_row(){
|
|
local rows
|
|
local row
|
|
|
|
rows=$1
|
|
row=$2
|
|
shift;shift
|
|
echo " {"
|
|
while [ -n "$1" ]; do
|
|
echo -n ' "'$1'":"'$2'" '
|
|
shift;shift
|
|
if [ -n "$1" ]; then
|
|
echo ","
|
|
else
|
|
echo ""
|
|
fi
|
|
done
|
|
if [ "$row" -lt "$rows" ]; then
|
|
echo " },"
|
|
else
|
|
echo " }"
|
|
fi
|
|
}
|
|
|
|
# Dumps json object
|
|
zaf_discovery_end(){
|
|
cat <<EOF
|
|
]
|
|
}
|
|
EOF
|
|
}
|
|
|
|
# Read standard input as discovery data. Columns are divided by space.
|
|
# Arguments are name of variables to discovery.
|
|
# Dumps json to stdout
|
|
zaf_discovery(){
|
|
local tmpfile
|
|
local rows
|
|
local a b c d e f g h i j row
|
|
|
|
tmpfile="${ZAF_TMP_DIR}/disc$$"
|
|
cat >$tmpfile
|
|
rows=$(wc -l <$tmpfile)
|
|
local a b c d e f g h i j;
|
|
zaf_discovery_begin
|
|
row=1
|
|
while read a b c d e f g h i j; do
|
|
zaf_discovery_add_row "$rows" "$row" "$1" "${1:+${a}}" "$2" "${2:+${b}}" "$3" "${3:+${c}}" "$4" "${4:+${d}}" "$5" "${5:+${e}}" "$6" "${6:+${f}}" "$7" "${7:+${g}}" "$8" "${8:+${h}}" "$9" "${9:+${i}}"
|
|
row=$(expr $row + 1)
|
|
done <$tmpfile
|
|
zaf_discovery_end
|
|
rm -f $tmpfile
|
|
}
|
|
|
|
############################################ Zaf internal routines
|
|
|
|
# Restart zabbix agent
|
|
zaf_restart_agent() {
|
|
zaf_wrn "Restarting agent (${ZAF_AGENT_RESTART})"
|
|
${ZAF_AGENT_RESTART} || zaf_err "Cannot restart Zabbix agent (${ZAF_AGENT_RESTART}). Try $ZAF_AGENT_BIN -f !";
|
|
}
|
|
|
|
# Check if zaf.version item is populated
|
|
zaf_check_agent_config() {
|
|
zaf_restart_agent
|
|
${ZAF_AGENT_BIN} -t zaf.version
|
|
}
|
|
|
|
# Update repo
|
|
zaf_update_repo() {
|
|
[ "$ZAF_GIT" != 1 ] && { zaf_err "Git is disabled or is not installed. Exiting."; }
|
|
if [ -z "${ZAF_REPO_GITURL}" ] || [ -z "${ZAF_REPO_DIR}" ]; then
|
|
zaf_err "This system is not configured for git repository."
|
|
else
|
|
[ ! -d "${ZAF_REPO_DIR}" ] && git clone "${ZAF_REPO_GITURL}" "${ZAF_REPO_DIR}"
|
|
(cd ${ZAF_REPO_DIR} && git pull)
|
|
fi
|
|
}
|
|
|
|
# Construct url from plugin name
|
|
# It can be http[s]://url
|
|
# /path (from file)
|
|
# name (to try from repo)
|
|
zaf_get_plugin_url() {
|
|
local url
|
|
|
|
if echo "$1" | grep -q '/'; then
|
|
url="$1" # plugin with path - from directory
|
|
else
|
|
if echo "$1" | grep -q ^http; then
|
|
url="$1" # plugin with http[s] url
|
|
else
|
|
if [ -d "${ZAF_REPO_DIR}/$1" ]; then
|
|
url="${ZAF_REPO_DIR}/$1"
|
|
else
|
|
if [ -n "${ZAF_PREPACKAGED_DIR}" ] && [ -d "${ZAF_PREPACKAGED_DIR}/$1" ]; then
|
|
url="${ZAF_PREPACKAGED_DIR}/$1"
|
|
else
|
|
if [ -n "${ZAF_REPO_URL}" ]; then
|
|
url="${ZAF_REPO_URL}/$1"
|
|
else
|
|
zaf_err "Cannot find plugin $1"
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
fi
|
|
echo $url
|
|
}
|
|
|
|
# $1 - control
|
|
zaf_plugin_info() {
|
|
local control="$1"
|
|
|
|
! [ -f "$control" ] && zaf_err "Control file $control not found."
|
|
plugin=$(zaf_ctrl_get_global_block <"${control}" | zaf_block_get_option Plugin)
|
|
pdescription=$(zaf_ctrl_get_global_block <"${control}" | zaf_block_get_moption Description)
|
|
pmaintainer=$(zaf_ctrl_get_global_block <"${control}" | zaf_block_get_option Maintainer)
|
|
pversion=$(zaf_ctrl_get_global_block <"${control}" | zaf_block_get_option Version)
|
|
purl=$(zaf_ctrl_get_global_block <"${control}" | zaf_block_get_option Url)
|
|
phome=$(zaf_ctrl_get_global_block <"${control}" | zaf_block_get_option Home)
|
|
pitems=$(zaf_ctrl_get_items <"${control}")
|
|
echo
|
|
echo -n "Plugin '$plugin' "; [ -n "$pversion" ] && echo -n "version ${pversion}"; echo ":"
|
|
echo "$pdescription"; echo
|
|
[ -n "$pmaintainer" ] && echo "Maintainer: $pmaintainer"
|
|
[ -n "$purl" ] && echo "Url: $purl"
|
|
[ -n "$phome" ] && echo "Home: $phome"
|
|
echo
|
|
if zaf_is_plugin "$(basename $plugin)"; then
|
|
echo -n "Defined items: "; zaf_list_plugin_items $plugin
|
|
echo -n "Test items: "; zaf_list_plugin_items $plugin test
|
|
echo -n "Precache items: "; zaf_list_plugin_items $plugin precache
|
|
else
|
|
echo "Items: $pitems"
|
|
fi
|
|
echo
|
|
}
|
|
|
|
# Prepare plugin into dir
|
|
# $1 is url, directory or plugin name (will be searched in default plugin dir).
|
|
# $2 is directory to prepare.
|
|
zaf_prepare_plugin() {
|
|
local url
|
|
local plugindir
|
|
local control
|
|
|
|
url=$(zaf_get_plugin_url "$1")/control.zaf || exit $?
|
|
plugindir="$2"
|
|
control=${plugindir}/control.zaf
|
|
zaf_install_dir "$plugindir"
|
|
zaf_dbg "Fetching control file from $url ..."
|
|
if zaf_fetch_url "$url" >"${control}"; then
|
|
zaf_ctrl_check_deps "${control}"
|
|
else
|
|
zaf_err "prepare_plugin: Cannot fetch or write control file $control from url $url!"
|
|
fi
|
|
}
|
|
|
|
zaf_install_plugin() {
|
|
local url
|
|
local plugin
|
|
local plugindir
|
|
local control
|
|
local version
|
|
|
|
if zaf_prepare_plugin "$1" "${ZAF_TMP_DIR}/plugin"; then
|
|
url=$(zaf_get_plugin_url "$1")
|
|
control="${ZAF_TMP_DIR}/plugin/control.zaf"
|
|
plugin=$(zaf_ctrl_get_global_option $control Plugin)
|
|
version=$(zaf_ctrl_get_global_option $control Version)
|
|
plugindir="${ZAF_PLUGINS_DIR}"/$plugin
|
|
if [ -n "$plugin" ] && zaf_prepare_plugin "$1" $plugindir; then
|
|
zaf_wrn "Installing plugin $plugin version $version"
|
|
zaf_dbg "Source url: $url, Destination dir: $plugindir"
|
|
control=${plugindir}/control.zaf
|
|
[ "$ZAF_DEBUG" -gt 1 ] && zaf_plugin_info "${control}"
|
|
zaf_ctrl_check_deps "${control}"
|
|
zaf_ctrl_sudo "$plugin" "${control}" "${plugindir}"
|
|
zaf_ctrl_cron "$plugin" "${control}" "${plugindir}"
|
|
zaf_ctrl_generate_cfg "${control}" "${plugin}" \
|
|
| zaf_far '{PLUGINDIR}' "${plugindir}" >${ZAF_AGENT_CONFIGD}/zaf_${plugin}.conf
|
|
zaf_dbg "Generated ${ZAF_AGENT_CONFIGD}/zaf_${plugin}.conf"
|
|
zaf_ctrl_install "$url" "${control}" "${plugindir}"
|
|
else
|
|
zaf_err "Cannot install plugin '$plugin' to $plugindir!"
|
|
fi
|
|
else
|
|
zaf_err "Cannot prepare plugin $1"
|
|
fi
|
|
}
|
|
|
|
# List installed plugins
|
|
# $1 - plugin
|
|
zaf_list_plugins() {
|
|
local cfile
|
|
local plugin
|
|
ls -1 ${ZAF_PLUGINS_DIR} | while read p; do
|
|
zaf_is_plugin "$(basename $p)" && echo $p
|
|
done
|
|
}
|
|
|
|
zaf_is_plugin() {
|
|
[ -d "$ZAF_PLUGINS_DIR/$1" ] && [ -f "$ZAF_PLUGINS_DIR/$1/control.zaf" ] && return
|
|
false
|
|
}
|
|
|
|
zaf_discovery_plugins() {
|
|
zaf_list_plugins | zaf_discovery '{#PLUGIN}'
|
|
}
|
|
|
|
# $1 plugin
|
|
# $2 ctrl_option
|
|
zaf_plugin_option() {
|
|
local plugindir
|
|
local cfile
|
|
|
|
if [ -z "$1" ]; then
|
|
zaf_err "Missing plugin name.";
|
|
fi
|
|
if zaf_is_plugin "$1"; then
|
|
plugindir="${ZAF_PLUGINS_DIR}/$1"
|
|
cfile="$plugindir/control.zaf"
|
|
zaf_ctrl_get_global_option $cfile $2
|
|
else
|
|
zaf_err "Plugin $1 not installed."
|
|
fi
|
|
}
|
|
|
|
zaf_plugin_version() {
|
|
zaf_plugin_option "$1" Version
|
|
}
|
|
zaf_plugin_maintainer() {
|
|
zaf_plugin_option "$1" Maintainer
|
|
}
|
|
zaf_plugin_url() {
|
|
zaf_plugin_option "$1" Url
|
|
}
|
|
zaf_plugin_web() {
|
|
zaf_plugin_option "$1" Web
|
|
}
|
|
zaf_plugin_template_url() {
|
|
echo $(zaf_plugin_option "$1" Url)/template.xml
|
|
}
|
|
|
|
# $1 plugin
|
|
# $2 test to get test items, precache to get items to precache
|
|
zaf_list_plugin_items() {
|
|
local items
|
|
local i
|
|
local p
|
|
local key
|
|
local testparms
|
|
local precache
|
|
|
|
if ! zaf_is_plugin "$1"; then
|
|
zaf_err "Missing plugin name or plugin $1 unknown. ";
|
|
fi
|
|
plugindir="${ZAF_PLUGINS_DIR}/$1"
|
|
cfile="$plugindir/control.zaf"
|
|
items=$(zaf_ctrl_get_items <$cfile)
|
|
for i in $items; do
|
|
p=$(zaf_ctrl_get_item_option $cfile $i "Parameters")
|
|
testparms=$(zaf_ctrl_get_item_option $cfile $i "Testparameters")
|
|
precache=$(zaf_ctrl_get_item_option $cfile $i "Precache")
|
|
if [ -n "$p" ]; then
|
|
if [ -n "$testparms" ] && [ "$2" = "test" ]; then
|
|
for tp in $testparms; do
|
|
echo -n "$1.$i[$tp] "
|
|
done
|
|
else
|
|
if [ -n "$precache" ] && [ "$2" = "precache" ]; then
|
|
for tp in $precache; do
|
|
echo -n "$1.$i[$tp] "
|
|
done
|
|
fi
|
|
[ "$2" != "test" ] && key="$1.$i[]"
|
|
fi
|
|
else
|
|
key="$1.$i"
|
|
fi
|
|
[ "$2" != "precache" ] && echo -n "$key "
|
|
done
|
|
echo
|
|
}
|
|
|
|
zaf_list_items() {
|
|
for p in $(zaf_list_plugins); do
|
|
echo $p: $(zaf_list_plugin_items $p)
|
|
done
|
|
}
|
|
|
|
zaf_get_item() {
|
|
if which zabbix_get >/dev/null; then
|
|
zaf_dbg zabbix_get -s localhost -k "'$1'"
|
|
(zabbix_get -s localhost -k "$1" | tr '\n' ' '; echo) || zaf_wrn "Cannot reach agent on localhost. Please localhost to Server list."
|
|
return 11
|
|
else
|
|
zaf_wrn "Please install zabbix_get binary to check items over network."
|
|
return 11
|
|
fi
|
|
}
|
|
|
|
zaf_test_item() {
|
|
if $ZAF_AGENT_BIN -t "$1" | grep ZBX_NOTSUPPORTED; then
|
|
return 1
|
|
else
|
|
$ZAF_AGENT_BIN -t "$1" | tr '\n' ' '
|
|
echo
|
|
fi
|
|
}
|
|
|
|
zaf_precache_item() {
|
|
cmd=$(grep "^UserParameter=$item" $ZAF_AGENT_CONFIGD/zaf*.conf | cut -d ',' -f 2- | sed -e "s/_cache/_nocache/")
|
|
zaf_wrn "Precaching item $item[$(echo $*| tr ' ' ',')] ($cmd)"
|
|
eval $cmd
|
|
}
|
|
|
|
zaf_remove_plugin() {
|
|
! zaf_is_plugin $1 && { zaf_err "Plugin $1 not installed!"; }
|
|
zaf_wrn "Removing plugin $1 (version $(zaf_plugin_version $1))"
|
|
rm -rf ${ZAF_PLUGINS_DIR}/$1
|
|
rm -f ${ZAF_AGENT_CONFIGD}/zaf_$1.conf ${ZAF_CROND}/zaf_$1 ${ZAF_SUDOERSD}/zaf_$1
|
|
}
|
|
|
|
zaf_tolower() {
|
|
tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'
|
|
}
|
|
|
|
zaf_toupper() {
|
|
tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
|
|
}
|
|
|
|
# Return simplified key with discarded special chars.
|
|
zaf_stripctrl() {
|
|
echo $1 | tr '[]*&;:.-' '________'
|
|
}
|
|
|
|
# Unescape string on stdin
|
|
# $1 - list of chars to unescape
|
|
zaf_strunescape() {
|
|
sed -e 's#\\\(['"$1"']\)#\1#g'
|
|
}
|
|
|
|
|
|
# Escape string on stdin
|
|
# $1 - list of chars to escape
|
|
zaf_strescape() {
|
|
sed -e 's#\(['"$1"']\)#\\\1#g'
|
|
}
|
|
|