Nel mondo IT, l’automazione delle attività ripetitive può far risparmiare tempo e ridurre gli errori. Una di queste operazioni consiste nel verificare la presenza di file o cartelle specifiche in più directory. Che si tratti di conformità, monitoraggio del sistema o risoluzione dei problemi, disporre di un metodo automatico per verificare la presenza di file può essere prezioso per i professionisti IT e i provider di servizi gestiti (MSP). In questo articolo analizzeremo uno script Bash progettato per semplificare questo processo, garantendo efficienza e affidabilità nella gestione dei file.
Background
Questo script è particolarmente utile per i professionisti IT che devono verificare la presenza di file o cartelle critiche regolarmente. Fornisce una soluzione automatizzata per la ricerca nelle directory, offrendo un modo per verificare la presenza di file importanti o di individuare le eventuali mancanze. Questa capacità è fondamentale in vari scenari, come la convalida delle posizioni di backup, la garanzia della presenza di file di configurazione o la conferma della distribuzione di applicazioni critiche.
Lo script per verificare la presenza di file
#!/usr/bin/env bash
# Description: Alert if a specified file or folder is found in a directory or subdirectory you specify.
#
# Release Notes: Initial Release
# 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).
#
# Below are all the (case sensitive) valid parameters for this script.
# Only the path to search and name of file or folder are required!
#
# Parameter: --path "/opt/NinjaRMM/programdata"
# Required
# Base path to search for files or folders.
#
# Parameter: --name "ninjarmm-cli"
# Required
# Name of the file or folder to search for.
# Notes:
# If the name is not provided, the script will search for the path only.
# This is case sensitive and accepts wildcards.
#
# Parameter: --type "Files Or Folders"
# Required
# Search for files or folders.
#
# Parameter: --type "Files Only"
# Required
# Searches for files only.
#
# Parameter: --type "Folders Only"
# Required
# Searches for folder only.
#
# Parameter: --timeout 10
# Optional and defaults to 30 minutes
# Time in minutes to wait for the search to complete before timing out.
#
# Parameter: --customfield "myCustomField"
# Optional
# Custom Field to save the search results to.
die() {
local _ret="${2:-1}"
test "${_PRINT_HELP:-no}" = yes && print_help >&2
echo "$1" >&2
exit "${_ret}"
}
begins_with_short_option() {
local first_option all_short_options='h'
first_option="${1:0:1}"
test "$all_short_options" = "${all_short_options/$first_option/}" && return 1 || return 0
}
# Initize arguments
_arg_path=
_arg_name=
_arg_type=
_arg_timeout=30
_arg_customfield=
print_help() {
printf '%s\n' "Check existence of a file or folder"
printf 'Usage: %s [--path <arg>] [--name <arg>] [--type <"Files Only"|"Folders Only"|"Files Or Folders">] [--timeout <30>] [--customfield <arg>] [-h|--help]\n' "$0"
printf '\t%s\n' "-h, --help: Prints help"
}
parse_commandline() {
while test $# -gt 0; do
_key="$1"
case "$_key" in
--path)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_path="$2"
shift
;;
--path=*)
_arg_path="${_key##--path=}"
;;
--name)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_name="$2"
shift
;;
--name=*)
_arg_name="${_key##--name=}"
;;
--type)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_type="$2"
shift
;;
--type=*)
_arg_type="${_key##--type=}"
;;
--timeout)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_timeout="$2"
shift
;;
--timeout=*)
_arg_timeout="${_key##--timeout=}"
;;
--customfield)
test $# -lt 2 && die "Missing value for the optional argument '$_key'." 1
_arg_customfield="$2"
shift
;;
--customfield=*)
_arg_customfield="${_key##--customfield=}"
;;
-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
}
parse_commandline "$@"
function SetCustomField() {
customfieldName=$1
customfieldValue=$2
if [ -f "${NINJA_DATA_PATH}/ninjarmm-cli" ]; then
if [ -x "${NINJA_DATA_PATH}/ninjarmm-cli" ]; then
if "$NINJA_DATA_PATH"/ninjarmm-cli get "$customfieldName" >/dev/null; then
# check if the value is greater than 10000 characters
if [ ${#customfieldValue} -gt 10000 ]; then
echo "[Warn] Custom field value is greater than 10000 characters"
fi
if ! echo "${customfieldValue::10000}" | "$NINJA_DATA_PATH"/ninjarmm-cli set --stdin "$customfieldName"; then
echo "[Warn] Failed to set custom field"
else
echo "[Info] Custom field value set successfully"
fi
else
echo "[Warn] Custom Field ($customfieldName) does not exist or agent does not have permission to access it"
fi
else
echo "[Warn] ninjarmm-cli is not executable"
fi
else
echo "[Warn] ninjarmm-cli does not exist"
fi
}
if [ ! "$(command -v timeout)" ]; then
notimeout=true
# If the timeout command does not exist, create a function to mimic the timeout command
function timeout() { perl -e 'alarm shift; exec @ARGV' "$@"; }
fi
parentSearchPath=$_arg_path
leafSearchName=$_arg_name
searchType=$_arg_type
timeout=$_arg_timeout
customField=$_arg_customfield
# Get values from Script Variables
if [[ -n "${pathToSearch}" ]]; then
parentSearchPath="${pathToSearch}"
fi
if [[ -n "${nameOfFileOrFolder}" ]]; then
leafSearchName="${nameOfFileOrFolder}"
fi
if [[ -n "${filesOrFolders}" && "${filesOrFolders}" != "null" ]]; then
searchType="${filesOrFolders}"
fi
if [[ -n "${searchTimeout}" && "${searchTimeout}" != "null" ]]; then
timeout="${searchTimeout}"
fi
if [[ -n "${customFieldName}" && "${customFieldName}" != "null" ]]; then
customField="${customFieldName}"
fi
# Check if parentSearchPath is a link and replace it with the resolved path
if [ -L "${parentSearchPath}" ]; then
echo "[Info] Path to Search is a link: ${parentSearchPath} -> $(readlink -f "${parentSearchPath}")"
echo "[Info] Will use the resolved path to search"
parentSearchPath=$(readlink -f "${parentSearchPath}")
fi
if [[ -z "${parentSearchPath}" ]]; then
echo "[Error] Path to Search is empty"
exit 1
fi
# Check if path exists
if [ -e "${parentSearchPath}" ]; then
echo "[Info] Path ${parentSearchPath} exists"
else
echo "[Error] Path to Search ${parentSearchPath} does not exist or is an invalid path"
exit 1
fi
# Check if timeout is a number
if ! [[ "${timeout}" =~ ^[0-9]+$ ]]; then
echo "[Error] Timeout is not a number"
exit 1
fi
# Check if timeout is not in the range of 1 to 120
if [[ "${timeout}" -lt 1 || "${timeout}" -gt 120 ]]; then
echo "[Error] Timeout is not in the range of 1 to 120"
exit 1
fi
# Check if search type is valid
if $notimeout; then
# If the timeout command does not exist, convert the timeout to minutes
timeout=$((timeout * 60))
else
# If the timeout command does exist, add m to the end of the string
timeout="${timeout}m"
fi
if [[ $OSTYPE == 'darwin'* ]]; then
if ! plutil -lint /Library/Preferences/com.apple.TimeMachine.plist >/dev/null; then
echo "This script requires ninjarmm-macagent to have Full Disk Access."
echo "Add ninjarmm-macagent to the Full Disk Access list in System Preferences > Security & Privacy, quit the app, and re-run this script."
exit 1
fi
fi
# Search for files or folders
if [[ -n "${leafSearchName}" && "${leafSearchName}" != "null" ]]; then
if [[ "${searchType}" == *"Files"* && "${searchType}" == *"Only"* ]]; then
echo "[Info] Searching for files only"
# Search for files only
# Use timeout to prevent the find command from running indefinitely
foundPath=$(timeout "${timeout}" find "$parentSearchPath" -type f -name "$leafSearchName" 2>/dev/null)
exitcode=$?
if [[ $exitcode -eq 0 || $exitcode -eq 124 ]]; then
if [[ -n $foundPath ]]; then
echo "[Alert] File Found"
fi
fi
elif [[ "${searchType}" == *"Folders"* && "${searchType}" == *"Only"* ]]; then
echo "[Info] Searching for folders only"
# Search for folders only
# Use timeout to prevent the find command from running indefinitely
foundPath=$(timeout "${timeout}" find "$parentSearchPath" -type d -name "$leafSearchName" 2>/dev/null)
exitcode=$?
if [[ $exitcode -eq 0 || $exitcode -eq 124 ]]; then
if [[ -n $foundPath ]]; then
echo "[Alert] File Found"
fi
fi
elif [[ "${searchType}" == *"Files"* && "${searchType}" == *"Folders"* ]]; then
echo "[Info] Searching for files or folders"
# Search for files or folders
# Use timeout to prevent the find command from running indefinitely
foundPath=$(timeout "${timeout}" find "$parentSearchPath" -name "$leafSearchName" 2>/dev/null)
exitcode=$?
if [[ $exitcode -eq 0 || $exitcode -eq 124 ]]; then
if [[ -n $foundPath ]]; then
echo "[Alert] File Found"
fi
fi
else
echo "[Error] Invalid search type"
echo "Valid search types: Files Only, Folders Only, Files Or Folders"
exit 1
fi
elif [[ -z "${leafSearchName}" ]]; then
echo "[Info] Searching in path only"
# Search in path only
# Use timeout to prevent the find command from running indefinitely
foundPath=$(timeout "${timeout}" find "$parentSearchPath")
exitcode=$?
if [[ $exitcode -eq 0 || $exitcode -eq 124 ]]; then
if [[ -n $foundPath ]]; then
echo "[Alert] File Found"
fi
fi
fi
# Check exit code
if [[ -n $foundPath ]]; then
# Split the string into an array
IFS=$'\n' read -rd '' -a foundPathArray <<<"${foundPath}"
# Print each element of the array
for element in "${foundPathArray[@]}"; do
echo "[Alert] ${element} exists"
done
elif [[ -z $foundPath ]]; then
echo "[Warn] Could not find a file or folder"
exit 1
else
# If the find command fails to find the file or folder
# Figure out the grammer for the search type
if [[ "${searchType}" == *"Only"* ]]; then
if [[ "${searchType}" == *"Files"* ]]; then
searchTypeInfo="file"
elif [[ "${searchType}" == *"Folders"* ]]; then
searchTypeInfo="folder"
fi
elif [[ "${searchType}" == *"Files"* && "${searchType}" == *"Folders"* ]]; then
searchTypeInfo="file or folder"
fi
echo "[Info] Could not find a ${searchTypeInfo} in the path ${parentSearchPath} with the name containing: ${leafSearchName}"
fi
# If foundPath contains "Alarm clock:" then the command timed out
if [[ "${foundPath}" == *"Alarm clock:"* ]]; then
echo "[Alert] Timed out searching for file or folder"
# Remove "Alarm clock: *" from the string
foundPath=${foundPath/Alarm clock: [0-9]*//}
fi
# If command times out
if [[ $exitcode -ge 124 && $exitcode -le 127 || $exitcode -eq 137 ]]; then
echo "[Alert] Timed out searching for file or folder"
echo "timeout exit code: $exitcode"
echo " 124 if COMMAND times out, and --preserve-status is not specified"
echo " 125 if the timeout command itself fails"
echo " 126 if COMMAND is found but cannot be invoked"
echo " 127 if COMMAND cannot be found"
echo " 137 if COMMAND (or timeout itself) is sent the KILL (9) signal (128+9)"
echo "find command result: $foundPath"
exit 1
fi
# Save to custom field
if [[ -n "${customField}" && "${customField}" != "null" ]]; then
SetCustomField "${customField}" "${foundPath}"
fi
Analisi dettagliata
Lo script per verificare la presenza di file o cartelle opera prendendo diversi parametri per personalizzare il processo di ricerca. Ecco una descrizione dettagliata delle sue funzionalità:
1. Parametri e inizializzazione:
- –path: Specifica la directory di base in cui effettuare la ricerca.
- –name: Definisce il nome del file o della cartella da cercare, supportando i caratteri jolly.
- –type: Determina se cercare file, cartelle o entrambi.
- —timeout: Imposta il tempo massimo per l’operazione di ricerca, per impostazione predefinita 30 minuti.
- –customfield: Consente di salvare il risultato della ricerca in un campo personalizzato.
2. Parsing degli argomenti: Lo script per verificare la presenza di file o cartelle analizza gli argomenti della riga di comando per inizializzare i parametri di ricerca. Se manca un parametro richiesto, lo script genera un messaggio di errore ed esce.
3. Esecuzione della ricerca:
- Lo script per verificare la presenza di file risolve eventuali collegamenti simbolici nel percorso di ricerca.
- Verifica che il percorso specificato esista e sia valido.
- Assicura che il timeout sia compreso nell’intervallo accettabile (da 1 a 120 minuti).
4. Ricerca di file o cartelle: A seconda del tipo specificato (file, cartelle o entrambi), lo script per verificare la presenza di file utilizza il comando find con un timeout per individuare gli elementi desiderati. Se viene trovato qualcosa di rilevante, lo script avvisa l’utente e, facoltativamente, salva il risultato in un campo personalizzato.
5. Gestione e segnalazione degli errori: Lo script per verificare la presenza di file o cartelle include una gestione completa degli errori, assicurando che problemi come percorsi non validi, valori di timeout errati o file/cartelle inesistenti vengano segnalati chiaramente all’utente.
Casi d’uso potenziali
Caso di studio: verifica della conformità IT
Un professionista IT è responsabile di garantire che i file critici di configurazione della sicurezza siano presenti su tutti i server. Utilizzando questo script, può automatizzare il processo per verificare la presenza di file o cartelle in ambiente macOS:
1. Setup:
- –path: /etc/security
- –name: security.conf
- –type: Solo file
- —timeout: 10
2. Esecuzione: Lo script per verificare la presenza di file cerca il file security.conf nel percorso specificato entro il periodo di timeout impostato. In caso di rilevamento, viene registrato un avviso; in caso contrario, viene inviata una notifica al professionista IT, consentendo una rapida correzione.
Confronti
Rispetto alla verifica manuale o all’uso di comandi di shell di base, questo script per verificare la presenza di file offre diversi vantaggi:
- Automazione: Riduce la necessità di controlli manuali.
- Gestione dei timeout: Impedisce ricerche prolungate imponendo un timeout.
- Reporting personalizzato: Consente di salvare i risultati in campi personalizzati per un’ulteriore elaborazione o per la stesura di report di conformità.
Altri metodi, come l’uso di ls o dei comandi di test in Bash, non dispongono di queste caratteristiche avanzate, dunque questo script si rivela essere una soluzione più affidabile ed efficiente.
Domande frequenti
- Cosa succede se lo script per verificare la presenza di file va in timeout?
Lo script per verificare la presenza di file segnala un timeout ed esce con un codice di errore appropriato, assicurando che l’utente sia consapevole che la ricerca è stata incompleta. - Posso cercare più tipi di file contemporaneamente?
No, attualmente lo script per verificare la presenza di file supporta la ricerca di file o cartelle in base a un singolo modello di nome alla volta. - Come posso gestire i collegamenti simbolici nel percorso di ricerca?
Lo script per verificare la presenza di file risolve automaticamente i collegamenti simbolici, assicurando che la ricerca venga effettuata nella directory corretta.
Implicazioni
L’uso di questo script può migliorare in modo significativo la sicurezza informatica, verificando la presenza di file e cartelle critici. Verificare la presenza di file o cartelle in modo automatizzato aiuta a mantenere la conformità con i criteri di sicurezza e riduce il rischio di perdere file importanti, cosa che potrebbero portare a vulnerabilità o guasti del sistema.
Raccomandazioni
- Effettua audit regolari: Pianifica l’esecuzione regolare dello script per verificare la presenza di file per mantenere aggiornata la verifica dei file critici.
- Utilizza campi personalizzati: Sfrutta l’opzione dei campi personalizzati per tracciare e segnalare sistematicamente i risultati della ricerca.
- Impostazioni di timeout: Regola il parametro di timeout in base alle dimensioni previste della directory e alle prestazioni del sistema per evitare inutili ritardi.
Considerazioni finali
Questo script Bash è un potente strumento per i professionisti IT, che fornisce un metodo automatico e affidabile per verificare la presenza di file e cartelle. Integrando questo script per verificare la presenza di file nei controlli di routine, gli MSP possono garantire una maggiore efficienza e sicurezza nelle loro operazioni. Strumenti come NinjaOne possono migliorare ulteriormente questo processo offrendo soluzioni di gestione IT complete, che facilitano l’implementazione, il monitoraggio e la gestione degli script su più sistemi.
L’adozione dell’automazione nella gestione dei file non solo fa risparmiare tempo, ma migliora anche l’accuratezza, garantendo che i file critici siano sempre al loro posto.