contrib-munin/tools/munin-cli/munin

#!/bin/bash
# Munin CLI
# Found on http://munin.scarydevilmonastery.net/

# ----- munin plugin management script -----
# munin [ restart | permissions | active | available | bak | help]
# munin [ <enable | disable | edit | purge> <plugin>]
# munin [ run <plugin [command]>]

# munin restart                  reloads munin config, through init.d script
# munin permissions              edit /etc/munin/plugin-conf.d/munin-node
# munin active                   list enabled plugins
# munin available                list all plugins from repositiories except the active ones
# munin run plugin               execute plugin through munin-run
# munin run plugin config        execute config section of plugin through munin-run
# munin run plugin autoconf      execute config section of plugin through munin-run
# munin enable plugin            symlink to plugin and reload munin config
# munin disable plugin           remove symlink to plugin and reload munin config
# munin purge plugin             remove symlin to plugin, its .rrd files and the associated .html files
# munin edit plugin              open plugin in editor
# munin export plugin            copy plugin to other server(s)
# munin bak                      remove *~ files from plugin repository directories
# munin template plugin          start editing a new plugin
# munin pack                     create archive, containing plugins
# munin help                     print overview of commands
# munin                          print overview of commands

# multiple plugin repositories are supported. 
# running without arguments shows a command overview

# depends on external programs:
# stat, sed, find, sort, uniq.

versions="yes"
plugins=(/usr/local/share/munin/plugins /usr/share/munin/plugins)      # where are plugins kept? First path is local, where new plugins from template are added
munin="/etc/munin/plugins"                                             # munin enabled plugins (symlinks to plugins) are here
trash="$HOME/.Trash"                                                   # where to move files of purged plugins to?
host="localhost"
domain="localdomain"
servers=""                                                             # list of machines to export plugins to
muninlib="/var/lib/munin/$domain"                                      # rrd files store
muninweb="/var/www/munin/$domain"                                      # html files store
muninhost=$host.$domain                                                
permissions="/etc/munin/plugin-conf.d/munin-node"
archive="/var/www/plugins/munin-plugins.tgz"                           # munin pack updates this archive, for downloading through web server
autopack="no"                                                          # update $archive after edit

plugin="$2"
wildcard="$3"

# editor choice:  if not specified in environment variable EDIT, use environment variables EDITOR, then  VISUAL
# if still no success, try executable "editor", and if still no editor found, hardcode to /usr/bin/vi. I know that
# this looks funny, but these are legal bashisms.
: ${EDIT:=${EDITOR:-${VISUAL:-"$(which editor)"}}}
: ${EDIT:="/usr/bin/vi"}



# -------------------------------------------------------------------------

required="chase sort grep sed uniq find stat munin-run scp"
# chase instead of readlink -f because it can handle wildcards

for require in $required; do
   type -t $require > /dev/null ||
   echo "warning: required program $require not found"
done

checkin()  {
    [[ $versions == yes ]] && mkdir -p $(dirname $1)/RCS && ci -l -mautocheckin $1
}

munin_active()     { stat -c%N $munin/*  ;}                            # show enabled plugins
munin_run()        { munin-run $plugin $wildcard ;}                    # run a plugin with munin-run

munin_restart()    {                                                   # restart munin-node
   echo -n restarting munin node...
   /etc/init.d/munin-node restart &> /dev/null
   echo done
}                                                                      

munin_available()  {                                                   # show available, inactive plugins
   (find ${plugins[*]}  -maxdepth 1 -type f ;
   chase $munin/*) |
   sort | uniq -u
}


munin_disable() {                                                      # removes plugin or link from $munin
   if [[ -z "$plugin" ]]        ; then  munin_active              ; exit 1 ; fi
   if [[ ! -z "$wildcard" ]]    ; then  plugin+="_$wildcard"               ; fi
   if [[ ! -h $munin/$plugin ]] ; then
      if [[ ! -f $munin/$plugin ]] ; then  echo "plugin not enabled" ; exit 1 ; fi
   fi
   echo removing $munin/$plugin ; rm $munin/$plugin && munin_restart
}   

findplugin()  {
   for pluginpath in ${plugins[*]} ; do
      if [[ -f "$pluginpath/$1" ]] ; then
         echo "$pluginpath"
         break
      fi
   done
}


munin_enable() {                                                       # creates a link to plugin in $munin
   if [[ -z "$plugin" ]]      ; then munin_available              ; exit 1 ; fi
   if [[ -f $munin/$plugin ]] ; then echo plugin already enabled  ; exit 0 ; fi
   usepath=$(findplugin "$plugin")
   if [[ -z "$usepath" ]]     ; then echo plugin not found        ; exit 1 ; fi
   source="$plugin"
   chmod +x "${usepath}/${source}"
   if [[ ! -z "$wildcard" ]]  ; then  plugin+="$wildcard"                  ; fi
   ln -s "${usepath}/${source}" "${munin}/${plugin}"
   echo "enabled $(stat -c%N ${munin}/${plugin})"
   echo "-------------------------------------------------------------------"
   echo "plugin output:"
   munin-run "${plugin}"
   echo "-------------------------------------------------------------------"
   munin_restart
}


munin_purge()  {    # move link, web files and rrd file to $trash
   if mkdir -p "$trash" ; then 
      munin_disable $plugin
      cleanplugin="${plugin//.-/_}"
      ls $muninlib/$muninhost-$cleanplugin-*.rrd
      mv $muninlib/$muninhost-$cleanplugin-*.rrd "$trash"
   else
      echo "can't access $trash dir"
      exit 1
   fi
}


munin_pack()  {    # pack all plugins into a tgz archive
   tar cpzf "$archive" ${plugins[@]//plugins/plugins/* }
}

munin_edit()  {    # edit plugin source of an active plugin
   plugintarget=$(chase "$munin/$plugin")
   if [[ -z "$plugintarget" ]] ; then
      pluginpath=$(findplugin "$plugin")
      if [[ -z "$pluginpath" ]] ; then
         echo "plugin not found"
         exit 1   
      fi
      plugintarget="$pluginpath/$plugin"
   fi
   $EDIT "$plugintarget"
   checkin "$plugintarget"
   [[ "$autopack" == "yes" ]] && munin_pack
}   

munin_permissions() {   # edit plugin permissions file
   CHANGED=$(stat -c%Y $permissions)
   $EDIT $permissions
   (( CHANGED == $(stat -c%Y $permissions) )) || munin_restart
}

munin_bak()  {          # remove files ending in ~ as left by joe as backup files
   for pluginpath in ${plugins[*]} ; do
      ls $pluginpath/*~ 2> /dev/null && rm $pluginpath/*~
   done
}



munin_template()  {   # start editing a new plugin, using template
   echo $plugin
   if [[ -f ${plugins}/$plugin ]]; then 
      echo "$plugin already exists"
   else
      cp ${plugins}/template ${plugins}/$plugin
      munin edit $plugin
   fi 
}


munin_migrate() {    # move system plugin to local plugins, relink if necessary
   if [[ -f ${plugins[1]}/$plugin ]]; then
      plugintarget=$(chase "$munin/$plugin")
      [[ $plugintarget ]] && munin disable $plugin
      mv ${plugins[1]}/$plugin ${plugins[0]}
      [[ $plugintarget ]] && munin enable $plugin
   fi
}

# -------------------------------------------------------------------------

munin_help()  {                           # shows this
   grep '^munin_.*().*#' $(which $0) |
   sed 's/().*#/ :   /;s/_/ /'
}
      

# -------------------------------------------------------------------------

munin_${1:-help}

# consider to generate a warning with absolute graph styles:
# grep -i "\.type *absolute"