Torna ai risultati
  • Linux

Guida completa: come utilizzare uno script Linux per verificare la presenza di file o cartelle

  • di Team Ninja

Verificare la presenza di file e directory critici e la loro integrità è fondamentale nella gestione IT. Che tu sia un professionista IT o un provider di servizi gestiti (MSP), tenere traccia dei file di sistema essenziali o delle directory di applicazioni specifiche può aiutarti a mantenere la stabilità, la sicurezza e la conformità del sistema. È qui che entrano in gioco gli script di automazione, in particolare quello che può verificare la presenza di file e avvisare se vengono trovati un file o una cartella specifica all’interno di una directory o sottodirectory.

Background

Lo script per verificare la presenza di file o cartelle fornito offre una soluzione solida per la ricerca e l’invio di avvisi in base all’esistenza di file o cartelle all’interno di un percorso specificato. Questo tipo di automazione è fondamentale in vari scenari, come la verifica del successo dell’implementazione, il monitoraggio delle modifiche non autorizzate o la garanzia della presenza di configurazioni critiche. Per i professionisti IT e gli MSP, l’utilizzo di script come questo può migliorare l’efficienza operativa e ridurre le attività di monitoraggio manuale.

Lo script per verificare la presenza di file o cartelle

#!/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
}

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

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

# 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}m" 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}m" 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}m" 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
    # Search in path only
    echo "[Info] Searching in path only"
    # Search in path only
    # Use timeout to prevent the find command from running indefinitely
    foundPath=$(timeout "${timeout}m" 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
    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 "[Info] ${foundPath} does not exist"
    fi
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 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

Analizziamo lo script per verificare la presenza di file o cartelle per comprenderne il funzionamento, i parametri e le funzionalità:

Parametri e opzioni

Lo script per verificare la presenza di file o cartelle accetta diversi parametri per personalizzare l’operazione di ricerca:

  • –path “/opt/NinjaRMM/programdata”: Specifica il percorso di base per la ricerca di file o cartelle. Questo parametro è obbligatorio.
  • –name “ninjarmm-cli”: Definisce il nome del file o della cartella da cercare. Anche questo è obbligatorio e supporta la sensibilità alle maiuscole e ai caratteri jolly.
  • –type “Files Or Folders”: Determina se cercare file, cartelle o entrambi. Parametro richiesto con opzioni:
  • Files Only (solo file)
  • Folders Only (solo cartelle)
  • Files Or Folders (file o cartelle)
  • –timeout 10: Un parametro opzionale che specifica il tempo (in minuti) di attesa per il completamento della ricerca prima del timeout; l’impostazione predefinita è 30 minuti.
  • –customfield “myCustomField”: Un parametro opzionale per salvare i risultati della ricerca in un campo personalizzato.

Flusso di esecuzione dello script per verificare la presenza di file o cartelle

1. Argomenti di inizializzazione e parsing: Lo script per verificare la presenza di file o cartelle inizia definendo le funzioni di utilità (die e begins_with_short_option) e inizializzando le variabili degli argomenti. La funzione parse_commandline elabora gli argomenti forniti, convalidandoli e assegnandoli alle rispettive variabili.

2. Funzione SetCustomField: Questa funzione imposta un campo personalizzato con i risultati della ricerca se lo strumento ninjarmm-cli è disponibile ed eseguibile. Controlla varie condizioni, come l’esistenza dello strumento e del campo personalizzato, e gestisce i vincoli di lunghezza del valore.

3. Logica principale:

  • Lo script per verificare la presenza di file o cartelle convalida il parametro percorso richiesto e si assicura che la directory specificata esista.
  • Controlla se il valore di timeout è un numero compreso nell’intervallo accettabile (da 1 a 120 minuti).
  • A seconda del tipo specificato (Solo file, Solo cartelle, File o cartelle), esegue la ricerca utilizzando il comando find con un timeout per evitare un’esecuzione indefinita.
  • I risultati della ricerca vengono gestiti in modo appropriato, avvisando se il file o la cartella vengono trovati e salvando i risultati in un campo personalizzato, se specificato.

Casi d’uso potenziali

  1. Verifica della distribuzione: Verificare la presenza di file critici dopo la distribuzione per confermare il successo dell’installazione dell’applicazione.
  2. Monitoraggio della sicurezza: Rilevare le aggiunte non autorizzate di file o directory, che potrebbero indicare una violazione della sicurezza o dei criteri.
  3. Audit di conformità: Verificare la presenza di file di configurazione o dei log necessari per la conformità agli standard di settore.

Caso di studio ipotetico

Immagina un MSP che gestisce più ambienti di clienti. Distribuendo questo script per verificare la presenza di file o cartelle sui sistemi dei clienti, l’MSP può automatizzare il processo per verificare la presenza di file importanti, come le definizioni antivirus o le configurazioni di sistema, garantendo che siano aggiornati e conformi ai criteri di sicurezza. Se vengono rilevate discrepanze, lo script avvisa l’MSP, consentendo una rapida correzione.

Confronti

I metodi tradizionali per verificare la presenza di file possono comportare comandi manuali o script di base privi di una solida gestione degli errori e di opzioni di personalizzazione. Lo script per verificare la presenza di file o cartelle fornito si distingue per l’ampia parametrizzazione, la gestione dei timeout e l’integrazione con campi personalizzati per l’archiviazione dei risultati. Questo livello di automazione e flessibilità migliora notevolmente l’efficienza operativa quando si tratta di verificare la presenza di file o cartelle.

Domande frequenti

D: Questo script per verificare la presenza di file o cartelle può cercare più file o cartelle contemporaneamente?

R: No, lo script per verificare la presenza di file o cartelle è progettato per cercare un singolo file o una singola cartella specificati. Le ricerche multiple richiedono l’esecuzione di più script.

D: Come gestisce lo script le directory di grandi dimensioni?

R: Lo script per verificare la presenza di file o cartelle utilizza il comando find con un timeout per evitare ricerche troppo lunghe. Questo assicura che non si blocchi per un tempo indefinito in directory di grandi dimensioni.

D: Cosa succede se lo strumento ninjarmm-cli non è disponibile?

R: Lo script per verificare la presenza di file o cartelle registra un avviso e continua a funzionare. La funzionalità del campo personalizzato viene saltata se lo strumento non è eseguibile.

Implicazioni

La possibilità di automatizzare i controlli sull’esistenza di file e cartelle ha implicazioni significative per la sicurezza e la gestione dell’IT. Gli avvisi automatici aiutano a identificare rapidamente modifiche non autorizzate, potenziali violazioni e problemi di conformità. Questo approccio proattivo migliora la sicurezza e l’affidabilità complessiva del sistema.

Raccomandazioni

  • Imposta timeout appropriati: Assicurati che il valore di timeout sia realistico per le dimensioni della directory, per evitare che lo script venga interrotto inutilmente.
  • Aggiorna regolarmente i criteri di ricerca: Adatta i parametri di ricerca in base all’evoluzione dei requisiti, come la presenza di nuovi file o directory critici.
  • Integralo con i sistemi di monitoraggio: Utilizza la funzionalità dei campi personalizzati per integrare lo script con sistemi di monitoraggio e di avvisi più completi, e per ottenere quindi una visione unificata dell’integrità e della conformità del sistema.

Considerazioni finali

Gli script di automazione come quello discusso per verificare la presenza di file o cartelle sono strumenti preziosi per i professionisti IT e gli MSP. Forniscono un metodo efficiente e affidabile per assicurarsi che file e directory critici siano presenti e nelle versioni corrette. Integrando questo script nelle tue pratiche di gestione IT, potrai migliorare la sicurezza, la conformità e l’efficienza operativa. NinjaOne offre una suite di strumenti che possono integrare script come questo, e fornisce soluzioni complete di gestione IT su misura per le tue esigenze.

Passi successivi

La creazione di un team IT efficiente ed efficace richiede una soluzione centralizzata che funga da principale strumento per la fornitura di servizi. NinjaOne consente ai team IT di monitorare, gestire, proteggere e supportare tutti i dispositivi, ovunque essi si trovino, senza la necessità di una complessa infrastruttura locale.

Per saperne di più su NinjaOne Endpoint Management, fai un tour dal vivo, o inizia la tua prova gratuita della piattaforma NinjaOne.

Inizia la tua prova gratuita

Categorie:

  • Monitoraggio

Ti potrebbe interessare anche

×

Guarda NinjaOne in azione!

Inviando questo modulo, accetto La politica sulla privacy di NinjaOne.

Download the script

Termini e condizioni NinjaOne

Cliccando sul pulsante “Accetto” qui sotto, dichiari di accettare i seguenti termini legali e le nostre condizioni d’uso:

  • Diritti di proprietà: NinjaOne possiede e continuerà a possedere tutti i diritti, i titoli e gli interessi relativi allo script (compreso il copyright). NinjaOne ti concede una licenza limitata per l’utilizzo dello script in conformità con i presenti termini legali.
  • Limitazione d’uso: Puoi utilizzare lo script solo per legittimi scopi personali o aziendali interni e non puoi condividere lo script con altri soggetti.
  • Divieto di ripubblicazione: In nessun caso ti è consentito ripubblicare lo script in una libreria di script appartenente o sotto il controllo di un altro fornitore di software.
  • Esclusione di garanzia: Lo script viene fornito “così com’è” e “come disponibile”, senza garanzie di alcun tipo. NinjaOne non promette né garantisce che lo script sia privo di difetti o che soddisfi le tue esigenze o aspettative specifiche.
  • Assunzione del rischio: L’uso che farai dello script è da intendersi a tuo rischio. Riconosci che l’utilizzo dello script comporta alcuni rischi intrinseci, che comprendi e sei pronto ad assumerti.
  • Rinuncia e liberatoria: Non riterrai NinjaOne responsabile di eventuali conseguenze negative o indesiderate derivanti dall’uso dello script e rinuncerai a qualsiasi diritto legale o di equità e a qualsiasi rivalsa nei confronti di NinjaOne in relazione all’uso dello script.
  • EULA: Se sei un cliente NinjaOne, l’uso dello script è soggetto al Contratto di licenza con l’utente finale (EULA) applicabile.
Accetto