Vollständiger Guide: Wie man mit einem Linux-Skript das Vorhandensein von Dateien oder Ordnern überprüft

Die Sicherstellung der Integrität und des Vorhandenseins wichtiger Dateien und Verzeichnisse ist für die IT-Verwaltung von größter Bedeutung. Egal, ob Sie ein IT-Experte oder ein Managed Service Provider (MSP) sind, das Verfolgen wichtiger Systemdateien oder spezifischer Anwendungsordner kann dazu beitragen, die Systemstabilität, Sicherheit und Compliance aufrechtzuerhalten. Hier kommen Automatisierungsskripte ins Spiel, insbesondere eines, das Sie benachrichtigt, wenn eine bestimmte Datei oder ein bestimmter Ordner in einem Verzeichnis oder Unterverzeichnis gefunden wird.

Kontext

Das vorgestellte Skript bietet eine zuverlässige Lösung für die Suche und Benachrichtigung auf der Grundlage des Vorhandenseins von Dateien oder Ordnern innerhalb eines bestimmten Pfads. Diese Art der Automatisierung ist in verschiedenen Szenarien ausschlaggebend, z. B. bei der Überprüfung der erfolgreichen Bereitstellung, der Überwachung nicht autorisierter Änderungen oder der Sicherstellung kritischer Konfigurationen. Für IT-Experten und MSPs kann der Einsatz solcher Skripte die betriebliche Effizienz steigern und den manuellen Überwachungsaufwand reduzieren.

Das Skript zur Überprüfung des Vorhandenseins von Dateien und Ordnern

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

 

Detailansicht

Schauen wir uns das Skript genauer an, um seine Funktionsweise, Parameter und Funktionen zu verstehen:

Parameter und Optionen

Das Skript akzeptiert mehrere Parameter, um den Suchvorgang anzupassen:

• –path ‘/opt/NinjaRMM/programdata’: Gibt den Basispfad für die Suche nach Dateien oder Ordnern an. Dieser Parameter ist erforderlich.

• –name ‘ninjarmm-cli’: Legt den Namen der Datei oder des Ordners fest, nach dem gesucht werden soll. Dies ist ebenfalls erforderlich und unterstützt Groß- und Kleinschreibung sowie Wildcard-Zeichen.

• –type ‘Files Or Folders’: Legt fest, ob nach Dateien, Ordnern oder beidem gesucht werden soll. Erforderlicher Parameter mit Optionen:

• Files Only

• Folders Only

• Files Or Folders

• –timeout 10: Ein optionaler Parameter, der die Zeit (in Minuten) angibt, die auf den Abschluss der Suche gewartet werden soll, bevor die Suche abgebrochen wird; der Standardwert ist 30 Minuten.

• –customfield ‘myCustomField’: Ein optionaler Parameter zum Speichern der Suchergebnisse in einem benutzerdefinierten Feld.

Ablauf der Skriptausführung

1. Initialisierung und Argumente-Parsen: Das Skript beginnt mit der Definition von Hilfsfunktionen (‘die’ und ‘begins_with_short_option’) und der Initialisierung von Argumentvariablen. Die Funktion ‘parse_commandline’ verarbeitet die angegebenen Argumente, validiert sie und weist sie den entsprechenden Variablen zu.

2. Die Funktion ‘SetCustomField’: Diese Funktion setzt ein benutzerdefiniertes Feld mit den Suchergebnissen, wenn das Tool ‘ninjarmm-cli’ verfügbar und ausführbar ist. Es prüft verschiedene Bedingungen, z. B. das Vorhandensein des Tools und des benutzerdefinierten Feldes, und behandelt die Beschränkungen der Wertlänge.

3. Hauptlogik:

• Das Skript überprüft den erforderlichen Pfadparameter und sorgt dafür, dass das angegebene Verzeichnis existiert.

• Es wird geprüft, ob der Timeout-Wert innerhalb des zulässigen Bereichs (1 bis 120 Minuten) liegt.

• Je nach angegebenem Typ (‘Files Only’, ‘Folders Only’, ‘Files Or Folders’) wird die Suche mit dem Befehl ‘find’ durchgeführt, wobei eine Zeitüberschreitung vorgesehen ist, um eine unendliche Ausführung zu verhindern.

• Die Suchergebnisse werden entsprechend gehandhabt, wobei das Skript eine Warnmeldung ausgibt, wenn die Datei oder der Ordner gefunden wird, und speichert die Ergebnisse in einem benutzerdefinierten Feld, falls dies angegeben wurde.

Potenzielle Anwendungsfälle

1. Überprüfung der Bereitstellung: Es wird sichergestellt, dass kritische Dateien nach der Bereitstellung vorhanden sind, um die erfolgreiche Installation der Anwendung zu bestätigen.
2. Sicherheitsüberwachung: Man kann nicht autorisierte Datei- oder Verzeichnisergänzungen erkennen, die auf eine Sicherheitsverletzung oder einen Verstoß gegen die Richtlinien hinweisen könnten.
3. Compliance-Audits: Es wird auf das Vorhandensein der notwendigen Konfigurationsdateien oder Protokolle überprüft, die für die Einhaltung der Industriestandards erforderlich sind.

Hypothetische Fallstudie

Stellen Sie sich vor, ein MSP verwaltet mehrere Kundenumgebungen. Durch das Ausrollen dieses Skripts auf den Kundensystemen kann der MSP den Überprüfungsprozess wichtiger Dateien, wie z. B. Antivirendefinitionen oder Systemkonfigurationen, automatisieren. Auf diese Weise sorgt er dafür, dass sie aktuell sind und den Sicherheitsrichtlinien entsprechen. Werden Unstimmigkeiten festgestellt, benachrichtigt das Skript den MSP und ermöglicht so eine schnelle Problemlösung.

Vergleiche

Herkömmliche Methoden zur Überprüfung des Vorhandenseins von Dateien umfassen manuelle Befehle oder einfache Skripte, denen es an robuster Fehlerbehandlung und Anpassungsoptionen mangelt. Das mitgelieferte Skript zeichnet sich durch eine umfassende Parametrisierung, Timeout-Verwaltung und die Integration von benutzerdefinierten Feldern zur Ergebnisspeicherung aus. Dieses Maß an Automatisierung und Flexibilität steigert die betriebliche Effizienz erheblich.

FAQs

F: Kann dieses Skript nach mehreren Dateien oder Ordnern auf einmal suchen?

A: Nein, das Skript ist für die Suche nach einer einzelnen angegebenen Datei oder einem Ordner konzipiert. Mehrere Suchvorgänge würden mehrere Skriptausführungen erfordern.

F: Wie geht das Skript mit großen Verzeichnissen um?

A: Das Skript verwendet den Befehl ‘find’ mit einer Zeitüberschreitung, um langwierige Suchen zu verhindern. Dadurch wird sichergestellt, dass es in großen Verzeichnissen nicht unendlich lange hängen bleibt.

F: Was passiert, wenn das Tool ‘ninjarmm-cli’ nicht verfügbar ist?

A: Das Skript gibt eine Warnmeldung aus und setzt seine Arbeit fort. Die Funktionalität der benutzerdefinierten Felder würde übersprungen, wenn das Tool nicht ausführbar ist.

Folgen

Die Möglichkeit, die Überprüfung auf die Existenz von Dateien und Ordnern zu automatisieren, hat erhebliche Auswirkungen auf die IT-Sicherheit und -Verwaltung. Automatische Warnmeldungen helfen dabei, nicht autorisierte Änderungen, potenzielle Sicherheitsverletzungen und Compliance-Probleme schnell zu erkennen. Dieser proaktive Ansatz erhöht die Sicherheit und Zuverlässigkeit des gesamten Systems.

Empfehlungen

• Angemessene Timeouts einstellen: Vergewissern Sie sich, dass der Timeout-Wert realistisch für die Verzeichnisgröße ist, um unnötige Skriptabbrüche zu vermeiden.

• Regelmäßige Aktualisierung der Suchkriterien: Passen Sie die Suchparameter an sich ändernde Anforderungen an, z. B. neue kritische Dateien oder Verzeichnisse.

• Integration mit Überwachungssystemen: Nutzen Sie die Funktionalität der benutzerdefinierten Felder für die Integration in umfassendere Überwachungs- und Warnsysteme, um einen einheitlichen Überblick über den Systemzustand und die Compliance zu erhalten.

Abschließende Überlegungen

Automatisierungsskripte wie das hier beschriebene sind unschätzbare Tools für IT-Experten und MSPs. Sie bieten eine zuverlässige und effiziente Möglichkeit, um sicherzustellen, dass wichtige Dateien und Verzeichnisse vorhanden und korrekt sind. Wenn Sie dieses Skript in Ihre IT-Verwaltungspraktiken integrieren, können Sie die Sicherheit, die Einhaltung von Vorschriften und die betriebliche Effizienz verbessern. NinjaOne bietet eine Reihe von Tools an, die solche Skripte ergänzen und umfassende, auf Ihre Bedürfnisse zugeschnittene IT-Management-Lösungen bereitstellen können.