Una comunicación eficaz es vital para los profesionales de TI, sobre todo cuando gestionan múltiples sistemas y usuarios. Una necesidad común es enviar notificaciones o recordatorios a los usuarios sobre actualizaciones del sistema, mantenimiento u otras acciones críticas. Este post profundiza en un versátil script de Bash diseñado para crear pop-ups en sistemas Linux, una herramienta útil para administradores de TI y proveedores de servicios gestionados (MSP).
Contexto
En el dinámico mundo de las TI, una comunicación a tiempo puede evitar la pérdida de datos y garantizar que los usuarios estén bien informados sobre las actividades del sistema. El script Bash que vamos a comentar hoy está adaptado a entornos Linux y es compatible con los escritorios X11 KDE y X11 Gnome. Este script no sólo envía mensajes a todos los terminales conectados, sino que también crea una ventana emergente visual en la pantalla del usuario, lo que garantiza que las notificaciones importantes se vean con prontitud.
El script para crear pop-ups en sistemas Linux
#!/usr/bin/env bash
#
# Description: Outputs messages on all connected terminals and creates a popup window on the end-user's screen. The popup requires ImageMagick and supports X11 KDE & X11 Gnome environments; other environments will only display the terminal message. Use the "Restart Reminder" feature to trigger a generic restart prompt.
# By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
# Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms.
# Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party.
# Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider.
# Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations.
# Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks.
# Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script.
# EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).
#
# Preset Parameter: --restartreminder
# Displays a generic restart PopUp. Can be overridden with parameters. Equivalent to the below parameters.
# --title 'NinjaOne Rmm'
# --message 'Your IT Administrator has scheduled a restart of your computer in the next 15 minutes. Please save your work as soon as possible to prevent data loss.'
# --timeoutaction 'shutdown -r'
#
# Preset Parameter: --title 'ReplaceWithYourDesiredHeader'
# Replace the text encased in quotes to replace the text in the title bar of the popup window (defaults to 'NinjaOne RMM').
#
# Preset Parameter: --message 'ReplaceWithYourPopUpMessage'
# Replace the text encased in quotes to put some text inside of the PopUp Window.
#
# Preset Parameter: --iconpath 'A URL or /a/path/to/an/image.png'
# Replace the text encased in quotes with either a url to an image or a filepath to an icon. The script uses the NinjaOne Logo by default.
# For best results use a 128px x 128px png. Though other formats and sizes will work.
# Highly recommend keeping a 1:1 ratio for the width and height.
# Supported formats: png, jpg, jpeg, webp, bmp, ico and gif (will not be animated in popup)
# If you have a base64 encoding of your image you could also replace the default base64 on line 37.
#
# Preset Parameter: --timeout 'ReplaceWithAnumberofSeconds'
# Replace the text encased in quotes with the number of seconds you'd like the PopUp to display for.
#
# Preset Parameter: --okbuttonaction 'ReplaceWithYourDesiredAction(Executes in Bash)'
# Replace the text encased in quotes with the command you'd like to run when the left button is clicked by the user (executes in bash).
#
# Preset Parameter: --exitbuttonaction 'ReplaceWithYourDesiredAction(Executes in Bash)'
# Replace the text encased in quotes with the command you'd like to run when the popup window is closed (executes in bash).
#
# Preset Parameter: --timeoutaction 'ReplaceWithYourDesiredAction(Executes in Bash)'
# Replace the text encased in quotes with the command you'd like to run when the dialog box times out (executes in bash).
# You can replace the below line with iconbase64='ReplaceThisWithYourBase64encodedimageEncasedInQuotes' and the script will decode the image and use it in the popup window.
iconbase64='iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAAJFBMVEUARF0Apc0AmL8ApM0Aos0Aps7///8Am8ia1ug9rtLd8/jw+/2tMDHwAAAABXRSTlMBrBTIcce4nvwAAAIeSURBVHic7dvrcoMgEAXgiOAivv/7Fm+JBpCLwk7bsz86rcNkPw+Y0Gl5vd4lGtbLKSG7vmF18mwQnWpe3YcghP2Z1svU8OtbIOihm8op25M2gWBov9UqYJj/vSRzAGsEkhMglxngWINbdbxLAAAAAAAAAAAAAKAI8Oz2KRtApPWThEyAbT8NZwDZGpeav6sLIKXNMBwAtuGotTGTvTpMRms9qkxEBsDe/dz+A7B3rufeS/utrCKPkAywzfYmK8BeOHY+lBkzBImALfwDgA4XnNLphCTA4e43AKmL9vNMJD8pCQAna20nP5D+SfkQgJyp1qS9PYsEKQDnpVP627WYJCgBmGj+GRmUAFIraSXWBAwDcwJJk1AXMIzcgHgElQHxCGoDohHcBsybgIvPpei70S2A0csuaNkTBRBTbA7uAOb271E0+gWxOSgHfG87yD+wGsCz7fGONNf9iwGTb89DnlkwkUVQCPD2t1sXz9A6gMDT5YsgsggKARljI/vTMkDo7cU3B1USCL+oOwdVAMGF5RlcAxB+tBoBwq/JDlDcAPYEAGgDuPiNBwkgASSABJAAEkACSAAJIAEkgASQABL4JwlcA9w/9N4GTOZcl1OQMTgRoEannhv9O/+PCAAAAAAAAAAAAACAPwhgP+7HeOCR1jOfjBHI9dBrz9W/34/d9jyHLvvPweP2GdCx/3zyvLlAfZ8+l13LktJzAJ+nfgAP50EVLvPsRgAAAABJRU5ErkJggg=='
workingdir="/tmp/ninjaone-rmm-popup"
die() {
local _ret="${2:-1}"
test "${_PRINT_HELP:-no}" = yes && print_help >&2
echo "$1" >&2
exit "${_ret}"
}
# THE DEFAULTS INITIALIZATION - OPTIONALS
_arg_title="NinjaOne RMM"
_arg_message=
_arg_iconpath=
_arg_obuttonaction=
_arg_ebuttonaction=
_arg_timeoutaction=
_arg_timeout=900
_arg_restartreminder="off"
# The function will print out some help text if the user entered in something wrong
print_help() {
printf '\t%s\n\n' 'Usage: [-t|--title <arg>] [-m|-msg|--message <arg>] [-i|-icon|--iconpath <arg>] [-ea | -ebtnact | -extbtnaction | --exitbuttonaction <arg>] [-oa | -okbtnact | -okbtnaction | --okbuttonaction <arg>] [-to | --timeout <arg>] [-toa | -toact| --timeoutaction <arg>] [ -restart | --restartreminder] [-h|--help]'
printf '%s\n' "Preset Parameter: --restartreminder"
printf '\t%s\n' "Displays a generic restart PopUp. Can be overridden with parameters. Equivelant to the below parameters."
printf '\t%s\n' "--title 'NinjaOne Rmm'"
printf '\t%s\n' "--message 'Your IT Administrator has scheduled a restart of your computer in the next 15 minutes. Please save your work as soon as possible to prevent data loss.'"
printf '\t%s\n' "--timeoutaction 'shutdown -r'"
printf '%s\n' "Preset Parameter: --title 'ReplaceWithYourDesiredHeader'"
printf '\t%s\n' "Replace the text encased in quotes to replace the text in the title bar of the popup window (defaults to 'NinjaOne RMM')"
printf '%s\n' "Preset Parameter: --message 'ReplaceWithYourPopUpMessage'"
printf '\t%s\n' "Replace the text encased in quotes to put some text inside of the PopUp Window"
printf '%s\n' "Preset Parameter: --iconpath 'A URL or /a/path/to/an/image.png'"
printf '\t%s\n' "Replace the text encased in quotes with either a url to an image or a filepath to an icon. The script uses the NinjaOne Logo by default."
printf '%s\n' "Preset Parameter: --timeout 'ReplaceWithAnumberofSeconds'"
printf '\t%s\n' "Replace the text encased in quotes with the number of seconds you'd like the PopUp to display for."
printf '%s\n' "Preset Parameter: --okbuttonaction 'ReplaceWithYourDesiredAction(Executes in Bash)'"
printf '\t%s\n' "Replace the text encased in quotes with the command you'd like to run when the ok button is clicked by the user (executes in bash)."
printf '%s\n' "Preset Parameter: --exitbuttonaction 'ReplaceWithYourDesiredAction(Executes in Bash)'"
printf '\t%s\n' "Replace the text encased in quotes with the command you'd like to run when the user closes the dialog (executes in bash)."
printf '%s\n' "Preset Parameter: --timeoutaction 'ReplaceWithYourDesiredAction(Executes in Bash)'"
printf '\t%s\n' "Replace the text encased in quotes with the command you'd like to run when the dialog box times out (executes in bash)."
}
# decipher's the parameters given and stores them as variables
parse_commandline() {
while test $# -gt 0; do
_key="$1"
case "$_key" in
-t | --title)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_title="$2"
shift
;;
--title=*)
_arg_title="${_key##--title=}"
;;
-m | -msg | --message)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_message="$2"
shift
;;
--message=*)
_arg_message="${_key##--message=}"
;;
--msg=*)
_arg_message="${_key##--msg=}"
;;
-i | -icon | --iconpath)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_iconpath="$2"
shift
;;
--iconpath=*)
_arg_iconpath="${_key##--iconpath=}"
;;
--icon=*)
_arg_iconpath="${_key##--icon=}"
;;
-ea | -ebtnact | -extbtnaction | --exitbuttonaction)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_ebuttonaction="$2"
shift
;;
--exitbuttonaction=*)
_arg_ebuttonaction="${_key##--ebuttonaction=}"
;;
-oa | -okbtnact | -okbtnaction | --okbuttonaction)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_obuttonaction="$2"
shift
;;
--okbuttonaction=*)
_arg_obuttonaction="${_key##--obuttonaction=}"
;;
-to | --timeout)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_timeout="$2"
shift
;;
--timeout=*)
_arg_timeout="${_key##--timeout=}"
;;
-toa | -toact | --timeoutaction)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_timeoutaction="$2"
shift
;;
--timeoutaction=*)
_arg_timeoutaction="${_key##--timeoutaction=}"
;;
-restart | --restartreminder)
_arg_restartreminder="on"
;;
-h | --help)
print_help
exit 0
;;
-h*)
print_help
exit 0
;;
*)
_PRINT_HELP=yes die "FATAL ERROR: Got an unexpected argument '$1'" 1
;;
esac
shift
done
}
# Initializes parameter processing
parse_commandline "$@"
if [[ -n $title ]]; then
_arg_title=$title
fi
if [[ -n $message ]]; then
_arg_message=$message
fi
if [[ -n $iconPath ]]; then
_arg_iconpath=$iconPath
fi
if [[ -n $timeout ]]; then
_arg_timeout=$timeout
fi
if [[ -n $timeoutAction ]]; then
_arg_timeoutaction=$timeoutAction
fi
if [[ -n $okButtonAction ]]; then
_arg_obuttonaction=$okButtonAction
fi
if [[ -n $exitButtonAction ]]; then
_arg_ebuttonaction=$exitButtonAction
fi
if [[ -n $restartReminder && $restartReminder == "true" ]]; then
_arg_restartreminder="on"
fi
# If --restartreminder was selected we'll want to preset some of the parameters
if [[ $_arg_restartreminder == "on" ]]; then
if [[ -z $_arg_message ]]; then
_arg_message="Your IT Administrator has scheduled a restart of your computer in the next 15 minutes. Please save your work as soon as possible to prevent data loss."
fi
if [[ -z $_arg_timeoutaction ]]; then
_arg_timeoutaction='shutdown -r'
fi
fi
# Grabbing information about the current setup
activeUsers=$(loginctl list-sessions | grep seat | sed 's/[0-9]\+//g' | sed 's/seat//g' | sed 's/tty//g' | xargs)
activeDisplay=$(w -oush | grep -Eo ' :[0-9]+' | uniq | head -1 | xargs)
GNOME=$(command -v zenity)
KDE=$(command -v kdialog)
imageMagick=$(command -v convert)
# Must give a number
pattern='^[0-9]+$'
if [[ ! $_arg_timeout =~ $pattern ]]; then
_PRINT_HELP=no die "FATAL ERROR: --timeout requires a number of seconds in order to work. ex. '60' for 60 seconds." 1
fi
# No matter what we're going to send a message to all connected terminals
echo "Sending message to all connected terminals."
wall "$_arg_message"
if [[ -z $imageMagick ]]; then
echo "WARNING: Image Magick is not installed. This script will be unable to display a popup without it. This script will still be able to send a message to all ssh connected terminals."
fi
# If not on a supported desktop environment or simply nobodies logged in skip this whole block.
if [[ (-n $GNOME || -n $KDE) && -n $activeDisplay && -n $activeUsers && -n $imageMagick ]]; then
# Create's a working directory if it doesn't already exist
if [[ ! -d "$workingdir" ]]; then
mkdir $workingdir
fi
# If given a url attempt to download the image file
pattern="https?://.*"
if [[ $_arg_iconpath =~ $pattern ]]; then
wget -q "$_arg_iconpath" -O "$workingdir/downloadedimg" -t 7 --random-wait
_arg_iconpath=$workingdir/downloadedimg
fi
# If a base64 icon is provided and no other iconpath was specified use that.
if [[ -n $iconbase64 && -z $_arg_iconpath ]]; then
base64 -d <<<$iconbase64 >$workingdir/base64img
_arg_iconpath=$workingdir/base64img
# If an iconpath was provided copy it to the working directory
elif [[ ! $_arg_iconpath == "$workingdir/downloadedimg" ]]; then
cp "$_arg_iconpath" "$workingdir/downloadedimg"
_arg_iconpath="$workingdir/downloadedimg"
fi
# Dobule check that we were given an image and find it's extension
mimetype=$(file --mime-type -b "$_arg_iconpath" | grep "image")
extension=$(file --extension -b "$_arg_iconpath" | sed 's/\/.*//g')
# If the mimetype indicates its not an image error out
if [[ -z $mimetype ]]; then
_PRINT_HELP=no die "FATAL ERROR: No image found!" 1
# If it's not a png we'll need to convert it to one and it'll need to be 128x128.
elif [[ ! $extension == "png" ]]; then
cp "$_arg_iconpath" "$workingdir/img.$extension"
convert -resize 128x128! -background none -coalesce "$workingdir/img.$extension" "$workingdir/img.png"
# Some image types ex. .ico files will have multiple pngs embeded in it. This ensures only one is selected.
_arg_iconpath=$(find $workingdir/img*.png | tail -1)
fi
# If post conversion we don't have an image we can use error out
if [[ -n $_arg_iconpath ]]; then
mv "$_arg_iconpath" "$workingdir/$_arg_title.png"
convert "$workingdir/$_arg_title.png" -resize 128x128! "/usr/share/pixmaps/$_arg_title.png"
_arg_iconpath="/usr/share/pixmaps/$_arg_title.png"
else
_PRINT_HELP=no die "FATAL ERROR: Image missing after converting to png?" 1
fi
# If using the Gnome Desktop enviornment we'll need to use zenity otherwise we can use kdialog.
if [[ -n $GNOME ]]; then
export DISPLAY="$activeDisplay"
for user in $activeUsers; do
popup=$(
$popup
su "$user" -c 'xhost local:'"$user"'; zenity --window-icon "'"$_arg_iconpath"'" --title "'"$_arg_title"'" --icon-name "'"$_arg_title"'" --info --text "'"$_arg_message"'" --timeout "'"$_arg_timeout"'"'
echo -e "\n$?"
)
done
elif [[ -n $KDE ]]; then
export DISPLAY="$activeDisplay"
for user in $activeUsers; do
popup=$(
$popup
# kdialog doesn't seem to have an option for an actual dialog to time out so we'll make a popup message instead
su "$user" -c 'xhost local:'"$user"'; kdialog --icon "'"$_arg_iconpath"'" --title "'"$_arg_title"'" --passivepopup "'"$_arg_message"'" '"$_arg_timeout"''
echo -e "\n$?"
)
done
fi
# This grabs the exitcode for each time the dialog was ran
results=$(echo "$popup" | grep -Eo '[0-9]')
for result in $results; do
if [[ $result == -1 || $result == 254 ]]; then
_PRINT_HELP=no die "FATAL ERROR: Unable to display popup?" 1
fi
# Kdialog will give an exit code of 2 when exiting while Gnome will give an exit code of 1
if [[ -n $_arg_ebuttonaction && ($result == 1 || $result == 2) ]]; then
echo "Exit Button Clicked"
eval "$_arg_ebuttonaction"
elif [[ $result == 1 || $result == 2 ]]; then
echo "Exit Button Clicked"
fi
if [[ -n $_arg_obuttonaction && $result == 0 && -n $GNOME ]]; then
echo "OK Button Clicked"
eval "$_arg_obuttonaction"
elif [[ $result == 0 && -n $GNOME ]]; then
echo "OK Button Clicked"
fi
if [[ -n $_arg_timeoutaction && $result == 5 || (-n $KDE && $result == 0) ]]; then
echo "Pop-up has timed out! Executing timeout action...."
eval "$_arg_timeoutaction"
elif [[ $result == 5 || (-n $KDE && $result == 0) ]]; then
echo "Pop-up has timed out!"
fi
done
# Removes the old icon
rm "$_arg_iconpath"
else
echo "No active X11 displays using GNOME or KDE were found. This script will display a terminal message only."
if [[ ! $_arg_timeout == 0 ]]; then
echo "Sleeping for $_arg_timeout seconds..."
sleep "$_arg_timeout"
fi
if [[ -n $_arg_timeoutaction ]]; then
echo "Executing timeout action."
eval "$_arg_timeoutaction"
fi
fi
Análisis detallado
El script está diseñado con la flexibilidad en mente, ofreciendo varios parámetros para personalizar los mensajes emergentes. Aquí tienes un desglose paso a paso de cómo funciona:
- Inicialización y función de ayuda: el script comienza definiendo valores por defecto para varios parámetros, como el título, el mensaje, la ruta del icono, la duración del tiempo de espera y las acciones para los botones Aceptar y Salir. También incluye una función de ayuda para orientar a los usuarios sobre cómo utilizar el script de forma eficaz.
- Análisis de parámetros: la función parse_commandline procesa los argumentos de entrada, permitiendo a los usuarios anular los valores por defecto. Los parámetros son –title, –message, –iconpath, –timeout, –okbuttonaction, –exitbuttonaction y –timeoutaction.
- Configuración del entorno: el script comprueba la configuración actual para determinar los usuarios activos y los entornos de visualización. Es compatible con los escritorios Gnome y KDE, y aprovecha herramientas como zenity y kdialog para crear pop-ups.
- Gestión de los iconos: si se proporciona una URL de icono, el script descarga la imagen. También admite imágenes codificadas en base64, que pueden descodificarse y utilizarse en la ventana emergente. El script se asegura de que la imagen está en formato PNG y la redimensiona a 128×128 píxeles si es necesario.
- Creación de la ventana emergente: dependiendo del entorno de escritorio, el script utiliza zenity o kdialog para mostrar el mensaje emergente. Gestiona varias acciones basadas en las interacciones del usuario, como hacer clic en los botones Aceptar o Salir o cuando se agota el tiempo de espera de la ventana emergente.
- Fallback para mensajes de terminal: si no se encuentra un entorno de escritorio adecuado, el script vuelve a enviar mensajes a todos los terminales conectados, asegurándose de que se sigue comunicando la notificación.
Posibles casos de uso
Imagina a un profesional de TI que gestiona una red de ordenadores en un entorno corporativo. Hay una necesidad urgente de reiniciar varias máquinas debido a una actualización crítica. Con este script, el administrador de TI puede enviar un mensaje emergente a todos los usuarios, informándoles del inminente reinicio e instándoles a guardar su trabajo. Esto garantiza que los usuarios estén al tanto de la acción y puedan prepararse en consecuencia, minimizando las interrupciones y la pérdida de datos.
Comparaciones
Otros métodos para notificar a los usuarios son las alertas por correo electrónico, los mensajes de chat o incluso las llamadas telefónicas. Sin embargo, estos métodos pueden no ser tan inmediatos o perceptibles como un mensaje emergente directamente en la pantalla del usuario. Este script ofrece un método de notificación directo e ineludible, garantizando que los mensajes importantes se vean con prontitud.
FAQ
1) ¿Cómo personalizo el mensaje emergente?
Puedes personalizar el mensaje utilizando el parámetro –message seguido del texto que quieras.
2) ¿Puedo utilizar una imagen en la ventana emergente?
Sí, puedes especificar una URL de imagen o una ruta de archivo utilizando el parámetro –iconpath.
3) ¿Qué ocurre si el script se ejecuta en un sistema sin GNOME o KDE?
El script seguirá enviando mensajes a todos los terminales conectados, pero no creará una ventana emergente.
4) ¿Cómo establezco la duración de la ventana emergente?
Utiliza el parámetro –timeout seguido del número de segundos que deseas que aparezca la ventana emergente.
5) ¿Es posible ejecutar un comando cuando se agota el tiempo de espera de la ventana emergente?
Sí, puedes especificar un comando para que se ejecute cuando se agote el tiempo de espera utilizando el parámetro –timeoutaction.
Implicaciones
El uso de este script mejora la seguridad informática al garantizar que no se pierdan las notificaciones críticas. Ya se trate de un reinicio del sistema, un recordatorio de mantenimiento o una alerta de seguridad, el script garantiza que los usuarios estén puntualmente informados, reduciendo el riesgo de pérdida de datos y asegurando la integridad del sistema.
Recomendaciones
Al utilizar este script, es importante:
- Probar el script en un entorno controlado antes de desplegarlo ampliamente.
- Asegurarte de que ImageMagick está instalado para la gestión de imágenes.
- Personalizar los parámetros para adaptarlos a las necesidades específicas de la organización.
Reflexiones finales
Unas herramientas de comunicación eficaces son esenciales para la gestión de las TI. Este script de Bash proporciona una forma fiable de enviar mensajes emergentes a los usuarios de Linux, garantizando que las notificaciones críticas se vean y se actúe en consecuencia. Para los profesionales de TI y los MSP, este tipo de herramientas tienen un valor incalculable a la hora de mantener la integridad del sistema y garantizar el cumplimiento por parte de los usuarios de las actualizaciones y acciones importantes.