Funkce pro výpis aplikací a konfiguráků na Mintu (III. fáze vývoje)

 

Pozor! Je nutné důkladně překontrolovat jestli ChatGPT 4o něco neodstranil z původní verze vývoje II. fáze. Musel jsem ho dvakrát opravovat, protože nejprve úplně zredukoval kód, vypustil řízení zpracování argumentů a funkci compare_apps ... a nehledal koncovky jako .xml, .conf apod. ale jen *název_aplikace* v adresářích.

Nakonec je ale přidáno hledání aplikací v systémových složkách - pozor! nevýhoda je, že pokud ta aplikace je už ve výpisu z Plocha/*.desktop tak se to tam objeví znovu. Ty soubory v bin tam bude spousta programů, které ani nepotřebuju znát, protože mě zajímají spíš balíčky než jednotlivé systémové programy... které jsou roztahány kdoví kde.

# Pro porovnávání mezi systémy musí být přítomno:
# --compare a --mounted_device nebo --external...

show-apps() {
    # Funkce pro načítání .desktop souborů a jejich zpracování
zpracování
#   22-08-2024 12h  Změna pořadí argumentů:
#    Funkci process_desktop_files bychom měli volat s tím, že první argument bude název proměnné (například apps_current_system), a další argumenty budou cesty.

# 22-08-2024 12h Úprava funkce process_desktop_files:
#    Zajistíme, že proměnná app_list_name správně odkazuje na název proměnné, do které se mají ukládat nalezené aplikace.
    process_desktop_files() {
        local app_list_name="$1"
        declare -n app_list="$app_list_name" # název proměnné je zadán v argumentu 1
        shift
        local search_paths=("$@")
        local new_paths=()
        local processed_paths=()

        for path in "${search_paths[@]}"; do
            # Expandovat ~ na domovský adresář
            expanded_path=$(eval echo "$path")

            # Pokud cesta byla již zpracována, přeskočte
            if [[ " ${processed_paths[*]} " == *" $expanded_path "* ]]; then
                continue
            fi

            processed_paths+=("$expanded_path")
            if [[ $compare_style -eq 0 ]]; then
               echo "Prohledávám: $expanded_path"
            fi

            # Vyhledání .desktop souborů v aktuální cestě
            desktop_files=$(find "$expanded_path" -type f -name "*.desktop" | sort )

            for file in $desktop_files; do
                # Zkontrolovat, zda soubor existuje
                if [[ -f "$file" ]]; then
                    if [[ $compare_style -eq 0 ]]; then
                    echo "Nalezen .desktop soubor: $file"
                    fi
                    name=$(grep -m 1 "^Name=" "$file" | cut -d '=' -f 2-)
name=$(grep -m 1 "^Name=" "$file" | cut -d '=' -f 2-)
                    # Kontrola, zda `name` obsahuje mezeru
                    if [[ "$name" == *" "* ]]; then
                        # Kontrola, zda `name` (ne)obsahuje uvozovku
                        if [[ "$name" != *"\""* ]]; then
                            # Pokud `name` obsahuje mezeru, ale neobsahuje uvozovku, zabalte do uvozovek
                            name="\"$name\""
                        fi
                    fi

                    # Zpracování Exec pro odstranění parametrů
                    raw_exec=$(grep -m 1 "^Exec=" "$file" | cut -d '=' -f 2-)
                    exec_path=$(echo "$raw_exec" | sed -e 's/^\"//' -e 's/\"$//' | awk '{print $1}')

                    icon=$(grep -m 1 "^Icon=" "$file" | cut -d '=' -f 2-)
                    categories=$(grep -m 1 "^Categories=" "$file" | cut -d '=' -f 2-)
                    # Filtrování kategorií pro zobrazení pouze KDE, GTK a XFCE
                    filtered_categories=$(echo "$categories" | grep -o -E '(KDE|GTK|XFCE)')

                    # Zvýraznění názvu aplikace světle zelenou barvou
                    if [[ $compare_style -eq 0 ]]; then
                            echo -e "  Název aplikace: \e[92m$name\e[0m"
                        # Kontrola, jestli Exec je cesta, skript, nebo název programu
                        if [[ "$exec_path" == /* ]]; then
                            if [[ "$exec_path" == *.sh ]]; then
                                echo "  Spustitelný skript: \e[93m$exec_path\e[0m"
                            else
                                echo "  Spustitelná cesta: $exec_path"
                            fi
                        else
                            # Zvýraznění spouštěcího příkazu žlutou barvou
                            echo -e "  Spouštění: \e[93m$exec_path\e[0m"
                        fi
                        echo "  Ikona: $icon"
                        echo "  Kategorie: $filtered_categories"
                    fi

                    # Pokud je exec_path skutečná cesta, přidáme ji do nových cest
                    if [[ "$exec_path" == /* && ! " ${processed_paths[*]} " == *" $exec_path "* ]]; then
                        if [ -d "$exec_path" ]; then
                            new_paths+=("$exec_path")
                        else
                            # Přidání aplikace do seznamu
                            app_list+=("$name")
                            exec_dir=$(dirname "$exec_path")
                            if [ -d "$exec_dir" ] && ! [[ " ${processed_paths[*]} " == *" $exec_dir "* ]]; then
                                new_paths+=("$exec_dir")
                            fi
                        fi
                    fi
                    if [[ $compare_style -eq 0 ]]; then
                        echo ""
                    fi
                else
                    if [[ $compare_style -eq 0 ]]; then
                         echo "Přeskočen soubor: $file (soubor neexistuje)"

                    fi
                fi
            done
        done

        # Pokud existují nové cesty, zpracujeme je rekurzivně
        if [ ${#new_paths[@]} -ne 0 ]; then
            process_desktop_files "$app_list_name" "${new_paths[@]}"
        fi
        # Odstranění duplicit až po zpracování všech cest
        remove_duplicates "$app_list_name"
    }

    remove_duplicates() {
        local app_list_name="$1"
        declare -n app_list="$app_list_name" # název proměnné je zadán v argumentu 1
        # Vytvořit nový seznam bez duplicit
        IFS=$'\n'
        local unique_apps=($(printf "%s\n" "${app_list[@]}" | sort -u))
        unset IFS

        # Uložit unikátní seznam do původní proměnné
        app_list=("${unique_apps[@]}")
    }

    # Funkce pro zjištění konfiguračních souborů aplikací
    process_config_files() {
        local app_name="$1"
        config_files=()
        config_files+=( $(find "$HOME/.config" -type f \( -name "*.conf" -o -name "*.ini" -o -name "*.xml" -o -name "*.cfg" -o -name "*.rc" \) 2>/dev/null | sort ) )

        config_files+=( $(find "$HOME/.local" -type f \( -name "*.conf" -o -name "*.ini" -o -name "*.xml" -o -name "*.cfg" -o -name "*.rc" \) 2>/dev/null | sort) )

        if [ ${#config_files[@]} -ne 0 ]; then
            echo "Nalezené konfigurační soubory pro $app_name:"
            for config in "${config_files[@]}"; do
                echo "- $config"
            done
        else
            echo "Nenalezeny žádné konfigurační soubory pro $app_name"
        fi
    }

    # Funkce pro porovnávání aplikací mezi systémy
    compare_apps() {
        local -n apps1="$1" # název proměnné je zadán v argumentu 1
        local -n apps2="$2" # název proměnné je zadán v argumentu 2
        local mode="$3"

        # Ověření, zda jsou předané názvy proměnných platné
        if [[ -z ${apps1+_} ]] || [[ -z ${apps2+_} ]]; then
            echo "Chyba: Neplatný název proměnné pro apps1 nebo apps2."
            return 1
        fi
        echo "Porovnávání aplikací..."
        IFS=$'\n'
        if [[ "$mode" == "normal" ]]; then
            echo "Aplikace pouze na prvním systému:"
            for app in "${apps1[@]}"; do
                if [[ ! " ${apps2[*]} " == *" $app "* ]]; then
                    echo "$app"
                fi
            done
            echo "Aplikace pouze na druhém systému:"
            for app in "${apps2[@]}"; do
                if [[ ! " ${apps1[*]} " == *" $app "* ]]; then
                    echo "$app"
                fi
            done
        elif [[ "$mode" == "reverse" ]]; then
            echo "Aplikace v obou systémech:"
            for app in "${apps1[@]}"; do
                if [[ " ${apps2[*]} " == *" $app "* ]]; then
                    echo "$app"
                fi
            done
        fi
        unset IFS
        # Uložení výsledků do souboru
        save_results "$mode" "${apps1[@]}" "${apps2[@]}"
    }

    # Funkce pro uložení výsledků do souboru
    save_results() {
        local mode="$1"
        shift
        local apps1=("$@")
        shift ${#apps1[@]}
        local apps2=("$@")

        local filename="comparison_result_$(date +%Y%m%d_%H%M%S).txt"

        echo "Ukládání výsledků do $filename..."

        {
            echo "Výsledky porovnávání aplikací ($mode):"
            echo "--------------------------------------"
            IFS=$'\n'
            if [[ "$mode" == "normal" ]]; then
                echo "Aplikace pouze v prvním systému:"
                for app in "${apps1[@]}"; do
                    if [[ ! " ${apps2[*]} " == *" $app "* ]]; then
                        echo "$app"
                    fi
                done

                echo "Aplikace pouze v druhém systému:"
                for app in "${apps2[@]}"; do
                    if [[ ! " ${apps1[*]} " == *" $app "* ]]; then
                        echo "$app"
                    fi
                done
            elif [[ "$mode" == "reverse" ]]; then
                echo "Aplikace v obou systémech:"
                for app in "${apps1[@]}"; do
                    if [[ " ${apps2[*]} " == *" $app "* ]]; then
                        echo "$app"
                    fi
                done
            fi
            unset IFS
        } > "$filename"

        echo "Výsledky byly uloženy do $filename"
    }

    # Inicializace proměnných
    # Inicializace proměnných
    local paths=()
    local root_path="/"
    local home_path="$HOME"
    local external_root=""
    local external_home=""
    local next_external_root=""
    local next_external_home=""
    local compare_mode="normal" # výchozí hodnota (opak je "reverse")
    local compare_style=0

    # Zpracování argumentů
    while [[ "$#" -gt 0 ]]; do    # iteruje přes všechny argumenty, které byly předány skriptu nebo funkci.
        case "$1" in
            all)
                paths=(
                    "$root_path/usr/share/applications"
                    "$home_path/.local/share/applications"
                    "$root_path/opt"
                    "$home_path/Plocha"

                    "$home_path/.local/share/xfce4/helpers"
                )
                ;;
            share)
                paths=(
                    "$root_path/usr/share/applications"
                    "$home_path/.local/share/applications"
                )
                ;;
            system)
                paths=(
                    "$root_path/usr/share/applications"
                )
                ;;
            plocha)
                paths=(
                    "$home_path/Plocha"
                )
                ;;
            opt)
                paths=(
                    "$root_path/opt"
                )
                ;;

# Pokud byste měli argument --mounted-device=/media/toshiba, pak:

# ${1} by obsahovalo --mounted-device=/media/toshiba.

# Výraz ${1#*=} by odstranil vše před a včetně =, takže by výstupem bylo /media/toshiba. 

# Pokud chcete zpracovat více argumentů, musíte se ujistit, že správně iterujete přes všechny argumenty.

            --mounted-device=*)

            if [[ -z "$external_root" ]]; then
                external_root="${1#*=}"
            fi
            if [[ -z "$external_home" ]]; then
                external_home="$external_root/home"  # Nastavení home na /media/toshiba/home
            fi

                ;;
            --mounted-root=*)
                external_root="${1#*=}"
                ;;
            --mounted-home=*)
                external_home="${1#*=}"
                ;;
            --mounted-next-device=*)

            if [[ -z "$next_external_root" ]]; then
                next_external_root="${1#*=}"
            fi
            if [[ -z "$next_external_home" ]]; then
                next_external_home="$next_external_root/home"  # Nastavení home na /media/toshiba/home
            fi

                ;;
            --mounted-next-root=*)
                next_external_root="${1#*=}"
                ;;
            --mounted-next-home=*)
                next_external_home="${1#*=}"
                ;;
            --compare)
                compare_mode="normal"
                compare_style=1
                ;;
            --compare=reverse)
                compare_mode="reverse"
                compare_style=1
                ;;
            *)
                echo "Neplatný argument: $1"
                return 1
                ;;
        esac
        shift
    done

    # Pole pro ukládání aplikací
    declare -a external_system1_apps
    declare -a external_system2_apps

    # Zpracování .desktop souborů na obou systémech
    process_desktop_files external_system1_apps "${paths[@]}"

    # Pokud je připojeno další zařízení, zpracuje se také
    if [[ -n "$external_root" || -n "$external_home" ]]; then
        external_paths=(
            "$external_root/usr/share/applications"
            "$external_home/.local/share/applications"
            "$external_root/opt"
            "$external_home/Plocha"

            "$external_home/.local/share/xfce4/helpers"
        )
        process_desktop_files external_system2_apps "${external_paths[@]}"
    fi

    # Porovnání aplikací, pokud je režim porovnávání specifikován
    if [[ -n "$compare_mode" ]]; then
        compare_apps external_system1_apps external_system2_apps "$compare_mode"
    fi

    # Vyhledání konfiguračních souborů pro každou aplikaci na prvním systému
    IFS=$'\n'
    for app in "${external_system1_apps[@]}"; do
        process_config_files "$app"
    done

    unset IFS

}

Vysvětlení hlavních částí:

1. Zpracování argumentů:

   • Argumenty jako all, share, icons, system, plocha, opt definují, které cesty mají být prohledány pro aplikace a konfigurační soubory.
   • Přidány argumenty pro specifikaci připojených zařízení, kořenového adresáře a domovských složek (--mounted-device, --mounted-root, --mounted-home, --mounted-next-device, --mounted-next-root, --mounted-next-home).
   • Argumenty --compare a --compare=reverse určují, zda se má provést porovnání aplikací mezi systémy.

2. Porovnání aplikací:

   • compare_apps() porovnává aplikace mezi dvěma systémy podle zadaného režimu (normal nebo reverse).
   • Výsledky porovnání se ukládají do textového souboru s časovým razítkem pomocí funkce save_results().

3. Zpracování a ukládání výsledků:

   • Funkce save_results() ukládá výsledky do souboru s názvem, který obsahuje datum a čas, což umožňuje snadné rozlišení mezi různými porovnáními.

Tento skript nyní plně zpracovává argumenty, porovnává aplikace mezi systémy, zpracovává jejich konfigurační soubory, a výsledky porovnání ukládá do souboru. Je navržen tak, aby byl modulární a flexibilní pro různé scénáře použití.

Informace:

Jaké typy souborů se tedy hledají při zadání system? Omezujete to na hledání pouze spustitelných souborů protože je to funkce na hledání souborů .desktop. 

Systémové aplikace

A dále pokud daný balíček má více souborů spustitelných, přijde mi zbytečné je všechny vypisovat. To vidím jako nevýhodu toho výpisu /usr/bin protože tam není jasné k čemu je nebo jakou aplikaci reprezentuje. Tam budou také soubory systémové jako find, grep apod. což nepotřebuji vypisovat, mě spíš šlo o výpis toho co uživatel přiinstalovává pomocí apt a není to běžná součást systému. Nedá se toto zjistit z nějakého konfiguračního souboru který používá apt? Třeba z databáze, kterou bych si načetl pomocí jiného programu a prošel, abych zjistil co ten systém má nainstalované? Dále problém toho all je zdá se v tom, že nerozlišuje co se vlastně hledá jestli ikony, nebo .desktop (plocha) nebo skripty a programy (.sh a spustitelné soubory) a konfiguráky...

Při použití aktuálního skriptu na režim system dochází k omezenému rozlišení, což může vést k zbytečnému výpisu systémových souborů, které nejsou relevantní pro uživatele. Také nerozlišuje různé typy souborů, jako jsou ikony, spustitelné soubory, .desktop soubory a konfigurační soubory. To vše může být upraveno a rozšířeno tak, aby skript lépe splňoval vaše požadavky. Níže jsou možné vylepšení a odpovědi na vaše dotazy.

1. Vyhledávání souborů při použití system:

V aktuálním nastavení skriptu jsou v režimu system prohledávány následující adresáře:

• /usr/share/applications – obsahuje .desktop soubory, které reprezentují grafické aplikace.
• /usr/bin – obsahuje spustitelné soubory, včetně systémových binárek i aplikací nainstalovaných pomocí balíčkovacího systému.

Problém, který zmiňujete, je ten, že v adresáři /usr/bin je mnoho systémových souborů, které nepotřebujete vypsat. Zaměřit se na aplikace nainstalované uživatelem pomocí apt je dobrý nápad.

2. Identifikace uživatelsky nainstalovaných aplikací:

Abychom se vyhnuli vypisování systémových nástrojů a zaměřili se na aplikace instalované uživatelem, můžeme využít informace z balíčkovacího systému dpkg, který je základem pro apt. Seznam nainstalovaných balíčků lze získat z databáze dpkg

3. Návrh budoucí implementace kromě ručního prohledání dpkg  souboru status

show-apps() {
    # Funkce pro načtení aplikací nainstalovaných pomocí APT
    list_installed_apps() {
        dpkg-query -W -f='${binary:Package}\n'  # (ŠPATNĚ!)
    }

    # Funkce pro nalezení spustitelných souborů pro dané balíčky
    find_binaries_for_apps() {
        local apps=("$@")
        local binaries=()

        IFS=$'\n'
        for app in "${apps[@]}"; do
            # Najít všechny soubory související s balíčkem
            package_files=$(dpkg-query -L "$app" | grep "/usr/bin/")
            if [ -n "$package_files" ]; then
                binaries+=("$package_files")
            fi
        done

        unset IFS
        echo "${binaries[@]}"
    }

    # Funkce pro zpracování a zobrazení aplikací
    process_system_apps() {
        echo "Vyhledávání aplikací nainstalovaných pomocí APT..."
        installed_apps=($(list_installed_apps))
        if [ ${#installed_apps[@]} -eq 0 ]; then
            echo "Nenalezeny žádné aplikace nainstalované pomocí APT."
            return
        fi

        echo "Nalezené aplikace:"

        IFS=$'\n'
        for app in "${installed_apps[@]}"; do
            echo "$app"
        done

        unset IFS

        # Najít spustitelné soubory pro každou aplikaci
        echo "Vyhledávání spustitelných souborů pro nalezené aplikace..."
        binaries=$(find_binaries_for_apps "${installed_apps[@]}")
        echo "Spustitelné soubory:"
        for binary in ${binaries[@]}; do
            echo "- $binary"
        done
    }

    # Zpracování argumentů
    while [[ "$#" -gt 0 ]]; do
        case "$1" in
            system)
                process_system_apps
                ;;
            *)
                echo "Neplatný argument: $1"
                return 1
                ;;
        esac
        shift
    done
}

Vysvětlení nového přístupu:

1. list_installed_apps(): Tato funkce využívá dpkg-query k načtení seznamu všech balíčků, které jsou nainstalovány na systému pomocí APT. (NESPRÁVNÉ ŘEŠENÍ, NUTNO PŘIDAT PROHLEDÁNÍ SOUBORU status od dpkg)
   
2. find_binaries_for_apps(): Tato funkce pro každý balíček najde soubory umístěné v /usr/bin, které jsou součástí balíčku. Tím získáte jen spustitelné soubory, které jsou spojeny s uživatelem nainstalovanými aplikacemi. TOTO NEPOTŘEBUJU
   
3. Omezení výpisu: Namísto vypisování všech spustitelných souborů v /usr/bin se nyní soustředíte pouze na ty, které jsou spojeny s aplikacemi instalovanými přes APT. TOTO NEPOTŘEBUJU - PROTOŽE CHCI JEN BALÍČKY - takto detailní výpis spustitelných souborů by se hodil jen s argumentem --name=app-name
   

 

4. Další rozlišení typů souborů v režimu all:

Při použití argumentu all můžete upravit skript tak, aby prohledával a vypisoval různé typy souborů (ikony, .desktop soubory, spustitelné soubory, skripty a konfigurační soubory) odděleně:

• Ikony: Hledat v /usr/share/icons a ~/.local/share/icons. (ani neexistuje!)
  
• .desktop soubory: Hledat v /usr/share/applications a ~/.local/share/applications.
• Skripty a spustitelné soubory: Hledat v /usr/bin a /opt.
• Konfigurační soubory: Hledat v ~/.config a dalších relevantních složkách.

Každý typ souboru může být zpracován samostatně s jasným výpisem, co skript našel.

CHYBA

dpkg-query ale vyhledává jen na aktuálním systému, takže tím se nedostanete k aplikacím na tom externím disku toshiba nebo hp ať /media/toshiba/root nebo /media/toshiba nebo /media/hp nebo /media/hp/root ... podporuje tento dpkg-query zadání konkrétního souboru nebo adresáře s databází, aniž bych musel provést připojení přes --bind a chroot do té složky s externím diskem?

ŘEŠENÍ

dpkg-query standardně pracuje pouze s databází balíčků na aktuálním systému. To znamená, že bez použití chroot nebo připojení souborového systému pomocí --bind není možné přímo použít dpkg-query k dotazování na balíčky na jiném systému nainstalovaném na externím disku.

Nicméně, existuje způsob, jakým můžete získat informace o nainstalovaných balíčcích na jiném systému, aniž byste museli provádět chroot. Tento způsob zahrnuje práci přímo s databázovými soubory dpkg, které jsou obvykle uloženy v /var/lib/dpkg/ na cílovém systému.

1. Ruční přístup k databázi dpkg

Na jiném systému (například na připojeném externím disku) je možné ručně přistupovat k souborům databáze balíčků, které se nacházejí ve složce /var/lib/dpkg/. Konkrétně soubor status obsahuje informace o všech nainstalovaných balíčcích.

Pokud je váš systém připojen například na /media/toshiba/root, pak tento soubor bude na cestě:

/media/toshiba/root/var/lib/dpkg/status

2. Vypsání nainstalovaných balíčků

Můžete číst soubor status přímo, například pomocí příkazu grep nebo vytvořit skript, který by tento soubor zpracoval a zobrazil seznam nainstalovaných balíčků:

bash
grep "Package:" /media/toshiba/root/var/lib/dpkg/status

To vám dá seznam všech nainstalovaných balíčků.

3. Zjištění souborů, které patří balíčkům

Pro nalezení konkrétních souborů, které patří balíčkům, můžete použít data z databázového souboru status. Každý balíček má seznam souborů a jejich cest, což lze zpracovat například pomocí skriptu v jazyce Python nebo jiného nástroje, který dokáže efektivně pracovat s textem.

4. Skript pro načtení nainstalovaných balíčků a jejich souborů

Zde je jednoduchý příklad Bash skriptu, který načte nainstalované balíčky z status souboru na externím disku:

 

 

bash
#!/bin/bash

# Cesta k dpkg status souboru na externím disku
status_file="/media/toshiba/root/var/lib/dpkg/status"

# Funkce pro načtení nainstalovaných balíčků
list_installed_packages() {
    grep "Package:" "$status_file" | awk '{print $2}'
}

# Funkce pro načtení souborů patřících balíčku
list_package_files() {
    local package_name="$1"
    awk -v pkg="$package_name" '
    $0 ~ "^Package: " pkg {found=1}
    found && $0 ~ "^ " {print $0}
    found && $0 == "" {found=0}
    ' "$status_file"
}

# Vypsat všechny nainstalované balíčky
installed_packages=$(list_installed_packages)
echo "Nainstalované balíčky:"
echo "$installed_packages"

# Vypsat soubory patřící k danému balíčku
echo "Zadejte jméno balíčku pro zobrazení jeho souborů:"
read package_name

echo "Soubory patřící balíčku $package_name:"
list_package_files "$package_name"

5. NOVÉ MOŽNOTSTI Souboru status

Ano to je skvělé řešení,  to přináší také nové možnoti.  Uživatel by navíc mohl k show-apps system nebo all přidat další argument --detailed a získal by delší výpis k těm aplikacím co jsou v tom souboru. Normálně by jinak stačil jeden řádek popisu:  
Package: zip
Status: install ok installed
Priority: optional
Section: utils
Installed-Size: 623
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
Architecture: amd64
Multi-Arch: foreign
Version: 3.0-11build1
Depends: libbz2-1.0, libc6 (>= 2.14)
Recommends: unzip
Description: Archiver for .zip files
 This is InfoZIP's zip program. It produces files that are fully
 compatible with the popular PKZIP program; however, the command line
 options are not identical. In other words, the end result is the same,
 but the methods differ. :-)
 .
 This version supports encryption.
Original-Maintainer: Santiago Vila <sanvila@debian.org>
Homepage: http://www.info-zip.org/Zip.html

 Případně by si mohl vyžádat konkrétní popis ke konkrétní aplikaci něco jako show-apps system --name=zip

 Já vám chci ještě ukázat co mě nezajímá a co mě zajímá pro běžný výpis z toho status: Package: zeitgeist-core
Status: deinstall ok config-files
Priority: optional
Section: utils
Installed-Size: 463
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
Architecture: amd64
Source: zeitgeist
Version: 1.0.2-3ubuntu2
Config-Version: 1.0.2-3ubuntu2
Provides: zeitgeist-extension-fts
Source je užitečný, verze je rozhodně důležitá.  Možná i Provides. Installed-Size by byl dobrý ale jen jako ve formátu v megabytech ...MB , Section je užitečná. Priority: Mě asi nezajímá. Následující mě nezajímá: "Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
Architecture: all
Multi-Arch: foreign
"  Homepage mě taky nezajímá.  .. Následující by mě zajímalo jen v případě detailního výpisu s argumentem --detailed nebo při zadání --name: Depends: libc6 (>= 2.17), liblzma5 (>= 5.2.2)
Breaks: lzip (<< 1.8~rc2)
Conflicts: lzma (<< 9.22-1), xz-lzma

Doplnění argumentů

 

 

Díky za upřesnění, co vás zajímá a co ne. Na základě toho můžeme přizpůsobit skript pro show-apps, aby výstup obsahoval jen potřebné informace, a to jak v běžném, tak detailním výpisu. Zde je, jak bych to provedl:

1. Skript pro show-apps

Budeme mít dvě možnosti výstupu:

• Základní: Vypisuje pouze základní informace.
• Detailní: Zobrazuje podrobnější informace včetně těch, které chcete vidět (s parametrem --detailed).

2. Upravený Skript

Zde je příklad, jak můžete přizpůsobit funkci show-apps ve vašem skriptu. Předpokládáme, že máte funkci pro získání informací o balíčcích a jejich zobrazení.

Příklad základního a detailního výpisu:

 #!/bin/bash

show_apps() {
    local detailed=false
    local name_filter=""

    # Zpracování argumentů
    while [[ "$#" -gt 0 ]]; do
        case "$1" in
            --detailed)
                detailed=true
                ;;
            --name=*)
                name_filter="${1#*=}"
                ;;
            system)
                # Zpracování systému, toto je příklad
                get_installed_packages "$detailed" "$name_filter"
                ;;
            *)
                echo "Neplatný argument: $1"
                return 1
                ;;
        esac
        shift
    done
}

get_installed_packages() {
    local detailed="$1"
    local name_filter="$2"

    # Příkaz pro získání seznamu nainstalovaných balíčků
    local dpkg_query_cmd="dpkg-query -W -f='${name_filter:+${name_filter}\n}${name_filter:+${name_filter} }${detailed:+%p %v %s %d %B %I %c %a %P %o %e}\n'}"

    # Získat balíčky z aktuálního systému
    dpkg-query -W -f='${Package}\n' | while read -r pkg; do
        if [[ -n "$name_filter" && "$pkg" != "$name_filter" ]]; then
            continue
        fi
        if [[ "$detailed" == true ]]; then
            # Získat detailní informace o balíčku
            dpkg-query -W -f='${Package:20} ${Version:10} ${Installed-Size:10}MB ${Provides:20} ${Source}\n' "$pkg"
        else
            # Získat základní informace o balíčku
            dpkg-query -W -f='${Package:20} ${Version}\n' "$pkg"
        fi
    done
}

# Volání funkce
show_apps "$@"

3. Vysvětlení

• Argument --detailed: Aktivuje detailní výstup, který zahrnuje více informací o balíčku.
• Argument --name: Umožňuje filtrovat výstup podle názvu balíčku.
• Funkce get_installed_packages: Získá seznam balíčků a v závislosti na volbě argumentu --detailed vypíše buď základní, nebo detailní informace.

Detailní výpis zahrnuje:

• Package: Název balíčku
• Version: Verze balíčku
• Installed-Size: Velikost balíčku (v MB)
• Provides: Co balíček poskytuje
• Source: Zdroj balíčku

Tento skript je základním příkladem a může být dále upravován podle vašich potřeb. Doufám, že vám to pomůže k dosažení toho, co potřebujete.

K tomu nutno přidat --short a --general --admin --net --introspection --libs --compiz --x11 --xorg-server --devel --fonts --graphics --video --sound --python --php --python --perl --xfce --kde --gnome --xorg-server --kernel a implementovat "Conffiles:" zjištění cest

1)

--short - zajistí jen krátké výpisy show-apps system pomocí grep "package:" ... nevýhoda: vypíší se všechny aplikace co tam jsou nainstalované

2)

--general - zajistí že se nebudou opakovat aplikace patřící pod tentýž balíček. Vyžaduje to parsování celého souboru. Příkladem je popis "Source: avahi", tento popis se opakuje ačkoliv název balíčku se liší: Zde je příklad výpisu:

Package: avahi-autoipd
Status: install ok installed
Priority: optional
Section: net
Installed-Size: 121
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
Architecture: amd64
Source: avahi
Version: 0.7-4ubuntu7.3
Depends: libc6 (>= 2.14), libdaemon0 (>= 0.14), adduser
Recommends: isc-dhcp-client, iproute2
Conflicts: zeroconf
Conffiles:
 /etc/avahi/avahi-autoipd.action 2a6b538cce1bf0abf8d90cb74693a60b
 /etc/dhcp/dhclient-enter-hooks.d/avahi-autoipd eb6a192ce374002226532a7199a7a94a
 /etc/dhcp/dhclient-exit-hooks.d/zzz_avahi-autoipd 911bd916c7aab0ed9b8a6bceb9122a8c
 /etc/network/if-down.d/avahi-autoipd 474077c828246c57e1f453f28dc2cb8c
 /etc/network/if-up.d/avahi-autoipd e810e2f4cf1cea7b36a5cf82467b0a18
Description: ...
Homepage: ...
Original-Maintainer: Utopia Maintenance Team <pkg-utopia-maintainers@lists.alioth.debian.org>

Package: avahi-daemon
Status: install ok installed
Priority: optional
Section: net
Installed-Size: 276
Maintainer: Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>
Architecture: amd64
Multi-Arch: foreign
Source: avahi
Version: 0.7-4ubuntu7.3
Depends: ...
Recommends: libnss-mdns
Suggests: avahi-autoipd
Conffiles:
 ...
Description: ....
Homepage: ...
Original-Maintainer: ...

Package: avahi-utils
Status: install ok installed
Priority: optional
Section: net
Installed-Size: 165
Maintainer: ...
Architecture: amd64
Source: avahi
Version: 0.7-4ubuntu7.3
Depends: ...
Description: ...

Přitom ačkoliv balíček "Package: avahi" neexistuje, je uveden ve zdrojích: "Source: avahi"

takže zdá se že nejprve je nutné projít zdroje a zajistit, že se nebudou opakovat. Jestliže je nalezen název aplikace ze Source: "avahi" pak používat tento název pro tu aplikaci a ne "avahi-tools", "avahi-daemons" apod.

Takže je nejprve hledat v Source: (jedna smyčka), ukončení smyčky. A pak znovu projít soubor smyčkou a zjišťovat jestli je Source definován a pokud ano, jestli jsem už z něj udělal výpis.

3) Konfiguráky... (výpis z dkpg status file)

A dále je možné nasbírat ty informace o konfigurákách.  Conffiles: jen první sloupec obsahuje cestu, následující sloupec už není cesta k souboru.

4) Co nemá defaultní výpis obsahovat:

Dále je nutné, aby defaultní výpis neobsahoval "Section: admin" (ani Section: net. ani Seciton: kernel, ani Section: libs, ani Section: introspection, ani Section: fonts, ani Source: compiz, ani Section: x11, ani Section: xorg-server, ani Section: devel)

protože je tam strašně moc položek, které jsou standardní součástí systému. --admin vypíše pouze administrátorskou sekci

--libs vypíše  jen aplikace ze sekce libs

--net vypíše  jen aplikace ze sekce net

--kernel vypíše  jen aplikace ze sekce kernel

--introspection vypíše jen aplikace ze sekce introspection

--font vypíše jen aplikace nebo balíčky ze sekce fonts

--compiz vypíše jen aplikace nebo balíčky ze sekce compiz

--x11 vypíše jen aplikace nebo balíčky ze sekce x11

--xorg-server vypíše jen aplikace nebo balíčky ze sekce xorg-server

--devel vypíše jen aplikace nebo balíčky ze sekce devel

Dále je nutné, aby defaultní výpis neobsahoval "Section: net"

Dále je nutné, aby defaultní výpis neobsahoval "Section: kernel"

nutné, aby defaultní výpis neobsahoval "Section: libs" 

nutné, aby defaultní výpis neobsahoval "Section: x11" 

nutné, aby defaultní výpis neobsahoval "Section: xorg-server"

nutné, aby defaultní výpis neobsahoval "Section: compiz" 

nutné, aby defaultní výpis neobsahoval "Section: fonts"

nutné, aby defaultní výpis neobsahoval "Section: introspection"

 

Já bych vynechal Section: Net kromě: Filezilla, Samba

Tzn. že z první smyčky se odstraní balíčky s "Section: admin", "Section: net", "Section: kernel", "Section: libs" kromě Filezilla, Samba

balíčky začínající na: google, samba

nebo mající Section: admin, Section: net 

se nezahrnou ale zahrnou se do výsledků při použití --net

Další příklady balíčků které se opakují:

Source: php-symfony-contracts

Source: network-manager

Source: network-manager-applet

Source: python3.8

Source: python3-stdlib-extensions

Source: vlc

Další atribut: --video bude používán jinak než výše uvedené --admin, --net, --kernel, --libs. --video poskytne výpis pouze těch sekcí kde je video, ale pokud --video není uvedeno jako argument, přesto tyto aplikace smí být součástí výpisu.    

Podobně argument --graphics řekne že se mají zobrazit jen aplikace ze sekce sound

Podobně argument --sound řekne že se mají zobrazit jen aplikace ze sekce sound

Podobně argument --xfce řekne že se mají zobrazit jen aplikace ze sekce xFce

Podobně argument --kde řekne že se mají zobrazit jen aplikace ze sekce kde

Podobně argument --gnome řekne že se mají zobrazit jen aplikace ze sekce kde

Podobně argument --web řekne že se mají zobrazit jen aplikace ze sekce web

Podobně argument --php řekne že se mají zobrazit jen aplikace ze sekce php

Podobně argument --python řekne že se mají zobrazit jen aplikace ze sekce python

Podobně argument --perl řekne že se mají zobrazit jen aplikace ze sekce perl

Podobně argument --java řekne že se mají zobrazit jen aplikace ze sekce java

Podobně argument --utils řekne že se mají zobrazit jen aplikace ze sekce utils

Podobně argument --httpd řekne že se mají zobrazit jen aplikace ze sekce httpd

6) Nesmí se zapomenout na to, že Filezilla a Samba mají být součástí defaultního výpisu.

7) Pokud bude probíhat zálohování konfiguráku apod. tak "show-apps system" pouze zálohuje defaultní aplikace z výpisu, ale nový tag --system-all bude zálohovat všechny konfiguráky.