Skryptowe języki programowania

Do wykonania jedno, dowolne zadanie.

Cel zadania (~20 min)

Stwórz skrypt analizator.sh, który analizuje wskazany katalog i zbiera szczegółowe statystyki: liczbę plików, sumaryczny rozmiar, średnią wielkość pliku oraz największy plik z pełną ścieżką.

Wymagania

Poproś użytkownika o ścieżkę katalogu do analizy; jeśli nie podano – użyj bieżącego (.).
Sprawdź czy katalog istnieje ([[ -d ]]) – jeśli nie, wyświetl błąd i zakończ z kodem 1.
Użyj find z -print0 i while read -d '' do bezpiecznej iteracji po plikach (obsługa nazw ze spacjami).
Dla każdego pliku pobierz rozmiar (stat --format="%s"), zsumuj, znajdź największy.
Wyświetl czytelny raport z podziałem na MB/KB dla dużych wartości.

Wskazówki

find "$DIR" -type f -print0 znajduje wszystkie pliki i zwraca je z separatorem null (bezpieczne dla nazw ze spacjami). stat --format="%s" zwraca rozmiar w bajtach. Do konwersji użyj dzielenia w $((...)) z scale przez bc dla precyzji w MB.

Efekt działania

Skrypt wypisuje czytelny raport: liczbę plików, sumę bajtów (w MB/KB), średni rozmiar pliku oraz nazwę i rozmiar największego pliku.

#!/bin/bash

read -p "Podaj katalog do analizy: " TARGET
TARGET=${TARGET:-.}

if [[ ! -d "$TARGET" ]]; then
    echo "BLAD: Katalog '$TARGET' nie istnieje!"
    exit 1
fi

echo "Analizuje: $TARGET..."
echo "Prosze czekac..."

count=0
total=0
max_size=0
max_file=""

while IFS= read -r -d '' file; do
    size=$(stat --format="%s" "$file" 2>/dev/null)
    if [[ -n "$size" ]]; then
        ((count++))
        ((total+=size))
        if ((size > max_size)); then
            max_size=$size
            max_file="$file"
        fi
    fi
done < <(find "$TARGET" -type f -print0 2>/dev/null)

clear
echo "======================================"
echo "         RAPORT Z ANALIZY KATALOGU"
echo "======================================"
echo
echo " Sciezka:      $TARGET"
echo " Plikow:       $count"
echo " Suma:         $total bajtow"

if ((total > 1073741824)); then
    echo "               ($((total / 1073741824)) GB)"
elif ((total > 1048576)); then
    echo "               ($((total / 1048576)) MB)"
elif ((total > 1024)); then
    echo "               ($((total / 1024)) KB)"
fi

if ((count > 0)); then
    echo " Srednio:      $((total / count)) bajtow/plik"
fi
echo
if [[ -n "$max_file" ]]; then
    echo " Najwiekszy:   $max_file"
    echo " Rozmiar:      $max_size bajtow"
fi
echo
echo "======================================"

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./analizator.sh
Podaj katalog do analizy: /home/student/Dokumenty
Analizuje: /home/student/Dokumenty
Prosze czekac...

======================================
         RAPORT Z ANALIZY KATALOGU
======================================

 Sciezka:      /home/student/Dokumenty
 Plikow:       47
 Suma:         12589456 bajtow
               (12 MB)
 Srednio:      267861 bajtow/plik

 Najwiekszy:   /home/student/Dokumenty/raport.pdf
 Rozmiar:      2456789 bajtow

======================================

Cel zadania (~20 min)

Napisz skrypt raport.sh, który automatycznie zbiera informacje o systemie: nazwę hosta, wersję jądra, pamięć RAM, użycie dysku, czas pracy, i zapisuje je do pliku raportu oraz wyświetla na ekranie.

Wymagania

Wygeneruj plik raport_systemu.txt z datą i godziną w nagłówku.
Zapisz do pliku: nazwę hosta (hostname), wersję jądra (uname -a), użytkownika ($USER), katalog domowy ($HOME).
Dodaj informacje o pamięci RAM (free -h) i dysku (df -h /).
Dodaj czas pracy systemu (uptime).
Użyj bloku { ... } > plik do grupowania przekierowań (jedno otwarcie pliku).
Po zapisie wyświetl zawartość raportu poleceniem cat.

Wskazówki

Grupowanie poleceń w { polecenie1; polecenie2; } > plik zapisuje wyjście wszystkich poleceń do jednego pliku. free -h wyświetla pamięć w czytelnym formacie (GB/MB). df -h / pokazuje użycie partycji głównej.

Efekt działania

Skrypt tworzy kompletny raport systemowy w pliku i wyświetla go na ekranie. Użytkownik poznaje kluczowe polecenia diagnostyczne Linuksa.

#!/bin/bash

RAPORT="raport_systemu.txt"

echo "======================================"
echo "    GENERATOR RAPORTU SYSTEMOWEGO"
echo "======================================"
echo

{
    echo "=================================="
    echo "RAPORT SYSTEMOWY"
    echo "Data: $(date)"
    echo "=================================="
    echo
    echo "--- Informacje podstawowe ---"
    echo "Host:       $(hostname)"
    echo "Uzytkownik: $USER"
    echo "Katalog:    $HOME"
    echo
    echo "--- System operacyjny ---"
    uname -a
    echo
    echo "--- Pamiec RAM ---"
    free -h
    echo
    echo "--- Uzycie dysku ---"
    df -h /
    echo
    echo "--- Czas pracy systemu ---"
    uptime
} > "$RAPORT"

echo "[OK] Raport zapisany do: $RAPORT"
echo
echo "=== PODGLAD RAPORTU ==="
echo
cat "$RAPORT"

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./raport.sh
======================================
    GENERATOR RAPORTU SYSTEMOWEGO
======================================

[OK] Raport zapisany do: raport_systemu.txt

=== PODGLAD RAPORTU ===

==================================
RAPORT SYSTEMOWY
Data: Mon Apr 15 14:35:22 CEST 2026
==================================

--- Informacje podstawowe ---
Host:       laptop-student
Uzytkownik: student
Katalog:    /home/student

--- System operacyjny ---
Linux laptop-student 6.8.0-45-generic #46-Ubuntu SMP ...

--- Pamiec RAM ---
              total        used        free      shared
Mem:           7.6Gi       3.2Gi       4.4Gi       256Mi
Swap:          2.0Gi       0.0Gi       2.0Gi

--- Uzycie dysku ---
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1       235G   45G  190G  20% /

--- Czas pracy systemu ---
 14:35:22 up 3 days,  2:15,  2 users,  load average: 0.45, 0.30, 0.25

Cel zadania (~20 min)

Stwórz skrypt procesy.sh, który wyświetla listę procesów posortowaną według użycia pamięci, filtruje procesy według nazwy i umożliwia zakończenie wybranego procesu po podaniu PID.

Wymagania

Wyświetl 20 procesów zużywających najwięcej pamięci (ps aux --sort=-%mem | head -20).
Zapytaj użytkownika o fragment nazwy procesu do filtrowania.
Użyj grep -i do filtrowania listy procesów według podanej nazwy.
Wyświetl PID każdego procesu – zapytaj użytkownika o PID do zabicia.
Wykonaj kill $PID i sprawdź $? – poinformuj o wyniku.
Obsłuż przypadki: brak procesów pasujących do filtra, brak uprawnień do zabicia.

Wskazówki

ps aux wyświetla wszystkie procesy z szczegółami. --sort=-%mem sortuje malejąco według pamięci. kill bez -9 wysyła sygnał TERM (grzeczne zamknięcie). Sprawdź $? po kill aby potwierdzić sukces.

Efekt działania

Skrypt wyświetla procesy, umożliwia filtrowanie po nazwie i bezpieczne zakończenie procesu. Student uczy się zarządzania procesami w Linux.

#!/bin/bash

echo "======================================"
echo "       MENEDZER PROCESOW SYSTEMU"
echo "======================================"
echo

echo "[1] 20 procesow zuzywajacych najwiecej pamieci:"
echo "----------------------------------------------"
ps aux --sort=-%mem | head -20
echo "----------------------------------------------"
echo

read -p "[2] Filtruj po nazwie (ENTER = pomin): " FILTER
if [[ -n "$FILTER" ]]; then
    echo
    echo "Procesy pasujace do '$FILTER':"
    echo "----------------------------------------------"
    ps aux | grep -i "$FILTER" | grep -v grep
    echo "----------------------------------------------"
fi
echo

read -p "[3] Podaj PID do zabicia (ENTER = pomin): " PID
if [[ -n "$PID" ]]; then
    kill "$PID" 2>/dev/null
    if [[ $? -eq 0 ]]; then
        echo "[OK] Proces $PID zakonczony."
    else
        echo "[BLAD] Nie udalo sie zabic procesu $PID (brak uprawnien? zly PID?)."
    fi
fi
echo
echo "Gotowe."

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./procesy.sh
======================================
       MENEDZER PROCESOW SYSTEMU
======================================

[1] 20 procesow zuzywajacych najwiecej pamieci:
----------------------------------------------
USER       PID %CPU %MEM    VSZ   RSS TTY
student   1234  2.5  8.2 245678 120456 ?   Ssl  chrome
student    567  1.2  4.5 189456  65432 ?   Ssl  code
root       890  0.8  2.1 123456  32100 ?   Ss   snapd
...
----------------------------------------------

[2] Filtruj po nazwie (ENTER = pomin): chrome

Procesy pasujace do 'chrome':
student   1234  2.5  8.2 245678 120456 ?   Ssl  chrome
student   5678  0.3  1.2 123456  18000 ?   Ssl  chrome --type=renderer

[3] Podaj PID do zabicia (ENTER = pomin): 5678
[OK] Proces 5678 zakonczony.

Gotowe.

Cel zadania (~20 min)

Stwórz skrypt backup.sh, który wykonuje kopię zapasową katalogu w formacie tar.gz, generuje sumy kontrolne MD5 dla każdego pliku, a następnie weryfikuje integralność archiwum.

Wymagania

Poproś o katalog źródłowy i nazwę archiwum wynikowego.
Sprawdź czy katalog źródłowy istnieje; jeśli nie – zakończ z błędem.
Utwórz archiwum tar czf nazwa.tar.gz katalog.
Wygeneruj plik z sumami MD5 (md5sum) dla wszystkich plików w źródle.
Zweryfikuj sumy kontrolne (md5sum -c) – pokaż liczbę plików zgodnych i błędnych.
Wyświetl podsumowanie: rozmiar archiwum, liczba plików, wynik weryfikacji.

Wskazówki

tar czf tworzy skompresowane archiwum (c=create, z=gzip, f=file). find ... -exec md5sum {} \; generuje sumy dla każdego pliku. md5sum -c weryfikuje zgodność; kod wyjścia 0 oznacza sukces. Dla dużych katalogów rozważ pigz (szybsze kompresowanie).

Efekt działania

Skrypt tworzy archiwum backupu z sumami kontrolnymi i weryfikuje jego integralność. Student poznaje narzędzia do archiwizacji i weryfikacji danych.

#!/bin/bash

echo "======================================"
echo "    BACKUP Z WERYFIKACJA - TAR + MD5"
echo "======================================"
echo

read -p "Podaj katalog do backupu: " SOURCE
read -p "Podaj nazwe archiwum (bez rozszerzenia): " ARCHIVE

if [[ ! -d "$SOURCE" ]]; then
    echo "BLAD: Katalog '$SOURCE' nie istnieje!"
    exit 1
fi

if [[ -z "$ARCHIVE" ]]; then
    ARCHIVE="backup_$(date +%Y%m%d_%H%M%S)"
fi

echo
echo "[1] Tworzenie archiwum..."
tar czf "${ARCHIVE}.tar.gz" "$SOURCE" 2>/dev/null
if [[ $? -eq 0 ]]; then
    echo "  OK: ${ARCHIVE}.tar.gz"
else
    echo "  BLAD podczas tworzenia archiwum!"
    exit 1
fi

echo "[2] Generowanie sum MD5..."
find "$SOURCE" -type f -exec md5sum {} \; > "${ARCHIVE}.md5"
echo "  OK: ${ARCHIVE}.md5 ($(wc -l < "${ARCHIVE}.md5") plikow)"

echo "[3] Weryfikacja sum..."
echo "  Wynik:"
md5sum -c "${ARCHIVE}.md5" 2>/dev/null | grep -c "OK"
echo "  plikow zgodnych"
md5sum -c "${ARCHIVE}.md5" 2>/dev/null | grep -c "FAILED"
echo "  plikow blednych"

echo
echo "=== PODSUMOWANIE ==="
echo "  Archiwum: ${ARCHIVE}.tar.gz"
echo "  Rozmiar:  $(du -h "${ARCHIVE}.tar.gz" | cut -f1)"
echo "  Sumy MD5: ${ARCHIVE}.md5"
echo "  Backup zakonczony."

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./backup.sh
======================================
    BACKUP Z WERYFIKACJA - TAR + MD5
======================================

Podaj katalog do backupu: /home/student/Dokumenty
Podaj nazwe archiwum (bez rozszerzenia): moje_dokumenty

[1] Tworzenie archiwum...
  OK: moje_dokumenty.tar.gz

[2] Generowanie sum MD5...
  OK: moje_dokumenty.md5 (47 plikow)

[3] Weryfikacja sum...
  Wynik:
47 plikow zgodnych
0 plikow blednych

=== PODSUMOWANIE ===
  Archiwum: moje_dokumenty.tar.gz
  Rozmiar:  2.3M
  Sumy MD5: moje_dokumenty.md5
  Backup zakonczony.

Cel zadania (~20 min)

Stwórz skrypt genhtml.sh, który generuje stronę HTML z danymi systemowymi i listą plików w bieżącym katalogu. Nauczysz się generować pliki HTML z poziomu basha, wstrzykiwać dane do szablonu i otwierać wyniki w przeglądarce.

Wymagania

Wygeneruj plik raport.html z kompletnym szkieletem HTML5.
Umieść w nagłówku tytuł: "Raport systemowy – data".
W treści strony zapisz: nazwę komputera, użytkownika, datę, uptime.
Dodaj tabelę z listą plików w bieżącym katalogu (nazwa, rozmiar, data modyfikacji).
Użyj heredoc (<<EOF) do czytelnego generowania HTML.
Na końcu otwórz plik w przeglądarce (xdg-open).

Wskazówki

Heredoc z cat > plik <<EOF pozwala na czytelne zapisanie bloku HTML. Wewnątrz heredoca zmienne bash ($HOSTNAME) są rozwijane. Pętla for f in * generuje wiersze tabeli. stat --format="%s" i stat --format="%y" dają rozmiar i datę pliku.

Efekt działania

Przeglądarka otwiera się z profesjonalnie wyglądającą stroną HTML z danymi systemowymi i listą plików.

#!/bin/bash

FILE="raport.html"
DATE=$(date "+%Y-%m-%d %H:%M:%S")

echo "======================================"
echo "      GENERATOR STRONY HTML"
echo "======================================"
echo

cat > "$FILE" <<EOF
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>Raport systemowy - $DATE</title>
    <style>
        body { font-family: Arial; margin: 30px; }
        h1 { color: #2c3e50; border-bottom: 3px solid #e74c3c; }
        table { border-collapse: collapse; width: 100%; }
        th { background: #2c3e50; color: white; padding: 8px; }
        td { border: 1px solid #ddd; padding: 6px; }
        tr:nth-child(even) { background: #f9f9f9; }
    </style>
</head>
<body>
    <h1>Raport systemowy</h1>
    <p>Wygenerowano: $DATE</p>

    <h2>Dane systemowe</h2>
    <table>
        <tr><td>Komputer</td><td>$HOSTNAME</td></tr>
        <tr><td>Uzytkownik</td><td>$USER</td></tr>
        <tr><td>Katalog</td><td>$HOME</td></tr>
        <tr><td>Czas pracy</td><td>$(uptime)</td></tr>
    </table>

    <h2>Lista plikow</h2>
    <table>
        <tr><th>Nazwa</th><th>Rozmiar</th><th>Data modyfikacji</th></tr>
EOF

for f in *; do
    if [[ -f "$f" ]]; then
        size=$(stat --format="%s" "$f" 2>/dev/null)
        mod=$(stat --format="%y" "$f" 2>/dev/null)
        echo "        <tr><td>$f</td><td>$size bajtow</td><td>$mod</td></tr>" >> "$FILE"
    fi
done

cat >> "$FILE" <<EOF
    </table>
</body>
</html>
EOF

echo "[OK] Wygenerowano: $FILE"
echo "  Rozmiar: $(stat --format="%s" "$FILE") bajtow"
echo
echo "Otwieram w przegladarce..."
xdg-open "$FILE" 2>/dev/null || echo "  (zainstaluj xdg-utils lub otworz recznie)"

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./genhtml.sh
======================================
      GENERATOR STRONY HTML
======================================

[OK] Wygenerowano: raport.html
  Rozmiar: 1234 bajtow

Otwieram w przegladarce...

[przegladarka otwiera sie ze strona:]
+---------------------------------------------------+
|  Raport systemowy                                  |
|  Wygenerowano: 2026-04-15 14:35:22                 |
|                                                    |
|  Dane systemowe                                    |
|  +------------+------------------+                |
|  | Komputer   | laptop-student   |                |
|  | Uzytkownik | student          |                |
|  | Katalog    | /home/student    |                |
|  | Czas pracy | up 3 days, 2:15  |                |
|  +------------+------------------+                |
|                                                    |
|  Lista plikow                                      |
|  +-----------+---------+------------+             |
|  | Nazwa     | Rozmiar | Data       |             |
|  +-----------+---------+------------+             |
|  | raport..  | 1234 b  | 15-04-2026 |             |
|  +-----------+---------+------------+             |
+---------------------------------------------------+

Cel zadania (~20 min)

Stwórz skrypt szukaj.sh, który przeszukuje pliki w katalogu (rekurencyjnie) pod kątem zadanego tekstu. Nauczysz się używać grep -r do rekurencyjnego wyszukiwania, opcji ignorowania wielkości liter oraz zliczania wyników.

Wymagania

Poproś użytkownika o katalog do przeszukania i szukany tekst.
Użyj grep -r -l -i do rekurencyjnego szukania (tylko nazwy plików).
Wyświetl listę plików zawierających szukany tekst (posortowaną).
Policz i wyświetl liczbę znalezionych plików.
Zapytaj o opcjonalną maskę plików (np. *.txt) – użyj --include.
Zapisz wyniki do pliku wyniki.txt.

Wskazówki

grep -r (rekurencyjnie) przeszukuje podkatalogi. -l wyświetla tylko nazwy plików (nie linie). -i ignoruje wielkość liter. --include="*.txt" ogranicza do plików o danym wzorcu. Użyj sort do alfabetycznego sortowania wyników.

Efekt działania

Skrypt znajduje wszystkie pliki zawierające zadany tekst, wyświetla posortowaną listę z liczbą wyników i zapisuje raport do pliku.

#!/bin/bash

RESULTS="wyniki_wyszukiwania.txt"

echo "======================================"
echo "    PRZESZUKIWANIE PLIKOW - GREP"
echo "======================================"
echo

read -p "Podaj katalog do przeszukania: " DIR
DIR=${DIR:-.}

if [[ ! -d "$DIR" ]]; then
    echo "BLAD: Katalog '$DIR' nie istnieje!"
    exit 1
fi

read -p "Podaj szukany tekst: " PATTERN
if [[ -z "$PATTERN" ]]; then
    echo "BLAD: Nie podano tekstu do wyszukania!"
    exit 1
fi

read -p "Podaj maske plikow (ENTER = wszystkie): " MASK
MASK=${MASK:-"*"}

echo
echo "Szukam: \"$PATTERN\" w $DIR (mask: $MASK)"
echo

if [[ "$MASK" == "*" ]]; then
    grep -r -l -i "$PATTERN" "$DIR" > "$RESULTS" 2>/dev/null
else
    grep -r -l -i --include="$MASK" "$PATTERN" "$DIR" > "$RESULTS" 2>/dev/null
fi

COUNT=$(wc -l < "$RESULTS" 2>/dev/null)

if [[ "$COUNT" -gt 0 ]]; then
    echo "Znalezione pliki (posortowane):"
    echo "===================================="
    sort "$RESULTS"
    echo "===================================="
    echo
    echo "Znaleziono: $COUNT plikow zawierajacych \"$PATTERN\""
elif [[ -f "$RESULTS" ]]; then
    echo "Nie znaleziono plikow zawierajacych \"$PATTERN\"."
else
    echo "BLAD: Wystapil problem podczas wyszukiwania."
fi

echo
echo "Wyniki zapisano w: $RESULTS"
[[ -f "$RESULTS" ]] && cat "$RESULTS"

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./szukaj.sh
======================================
    PRZESZUKIWANIE PLIKOW - GREP
======================================

Podaj katalog do przeszukania: /home/student/Projekt
Podaj szukany tekst: blad
Podaj maske plikow (ENTER = wszystkie): *.py

Szukam: "blad" w /home/student/Projekt (mask: *.py)

Znalezione pliki (posortowane):
====================================
/home/student/Projekt/src/app.py
/home/student/Projekt/src/utils.py
/home/student/Projekt/tests/test_app.py
====================================

Znaleziono: 3 plikow zawierajacych "blad"

Wyniki zapisano w: wyniki_wyszukiwania.txt
/home/student/Projekt/src/app.py
/home/student/Projekt/src/utils.py
/home/student/Projekt/tests/test_app.py

Cel zadania (~20 min)

Stwórz skrypt loganalizator.sh, który analizuje pliki dziennika (logi), wyodrębnia błędy, ostrzeżenia i informacje, grupuje je, zlicza i generuje czytelny raport. Nauczysz się zaawansowanego przetwarzania plików tekstowych w bashu.

Wymagania

Poproś o katalog z plikami .log i opcjonalną maskę (domyślnie *.log).
Dla każdego pliku .log:
- Policz całkowitą liczbę linii (wc -l).
- Policz linie z "ERROR" lub "BLAD" (grep -ci).
- Policz linie z "WARN" lub "UWAGA" (grep -ci).
Wygeneruj zbiorczy raport analiza_logow.txt.
Wyświetl tabelę z wynikami; posortuj według liczby błędów (malejąco).
Jeśli liczba błędów przekracza próg (np. 5), oznacz plik jako "KRYTYCZNY".

Wskazówki

wc -l zlicza linie. grep -ci "ERROR" plik zlicza linie zawierające ERROR (ignorując wielkość liter). Do sortowania użyj sort -t'|' -k2 -rn. Tymczasowy plik z danymi rozdzielonymi pionową kreską ułatwi sortowanie.

Efekt działania

Skrypt generuje tabelę z nazwami plików, liczbą linii, błędów i ostrzeżeń, oznacza pliki krytyczne i zapisuje raport do pliku.

#!/bin/bash

REPORT="analiza_logow.txt"
THRESHOLD=5
TEMP=$(mktemp)

echo "======================================"
echo "     ANALIZATOR PLIKOW DZIENNIKA"
echo "======================================"
echo

read -p "Podaj katalog z logami: " DIR
DIR=${DIR:-.}

if [[ ! -d "$DIR" ]]; then
    echo "BLAD: Katalog '$DIR' nie istnieje!"
    exit 1
fi

read -p "Podaj maske plikow (ENTER = *.log): " MASK
MASK=${MASK:-"*.log"}

echo
echo "Przetwarzanie plików..."
echo

count=0
for f in "$DIR"/$MASK; do
    if [[ ! -f "$f" ]]; then
        continue
    fi

    ((count++))
    lines=$(wc -l < "$f" 2>/dev/null)
    errors=$(grep -ci "ERROR\|BLAD" "$f" 2>/dev/null)
    warns=$(grep -ci "WARN\|UWAGA" "$f" 2>/dev/null)
    name=$(basename "$f")

    echo "$name|$lines|$errors|$warns" >> "$TEMP"
done

if [[ $count -eq 0 ]]; then
    echo "Brak plikow pasujacych do maski $MASK w $DIR"
    rm -f "$TEMP"
    exit 1
fi

{
    echo "=================================="
    echo "RAPORT ANALIZY LOGOW"
    echo "Data: $(date)"
    echo "Katalog: $DIR"
    echo "=================================="
    echo
    printf "%-20s %8s %8s %8s %s\n" "Plik" "Linie" "Bledy" "Warn" "Status"
    printf "%-20s %8s %8s %8s %s\n" "----" "-----" "-----" "----" "------"
} > "$REPORT"

echo "======================================"
echo "          RAPORT ANALIZY LOGOW"
echo "======================================"
echo
printf "%-20s %8s %8s %8s %s\n" "Plik" "Linie" "Bledy" "Warn" "Status"
printf "%-20s %8s %8s %8s %s\n" "----" "-----" "-----" "----" "------"

sort -t'|' -k3 -rn "$TEMP" | while IFS='|' read name lines errors warns; do
    if [[ "$errors" -ge "$THRESHOLD" ]]; then
        status="KRYTYCZNY"
    else
        status="OK"
    fi

    printf "%-20s %8s %8s %8s %s\n" "$name" "$lines" "$errors" "$warns" "$status"
    printf "%-20s %8s %8s %8s %s\n" "$name" "$lines" "$errors" "$warns" "$status" >> "$REPORT"
done

echo >> "$REPORT"
echo "Przetworzono plikow: $count" >> "$REPORT"
echo "Prog krytyczny: >= $THRESHOLD bledow" >> "$REPORT"
echo
echo "Przetworzono plikow: $count"
echo "Raport zapisano: $REPORT"
rm -f "$TEMP"

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./loganalizator.sh
======================================
     ANALIZATOR PLIKOW DZIENNIKA
======================================

Podaj katalog z logami: /var/log
Podaj maske plikow (ENTER = *.log): *.log

Przetwarzanie plikow...

======================================
          RAPORT ANALIZY LOGOW
======================================

Plik                   Linie   Bledy    Warn Status
----                   -----   -----    ---- ------
syslog                  1200      12       5 KRYTYCZNY
apache2/error.log        450       8       3 KRYTYCZNY
auth.log                 300       2       1 OK
dpkg.log                 150       0       0 OK

Przetworzono plikow: 4
Raport zapisano: analiza_logow.txt

Cel zadania (~20 min)

Stwórz skrypt zmien_nazwy.sh, który umożliwia zbiorczą zmianę nazw plików według różnych reguł: dodanie prefiksu, dodanie sufiksu, zmiana rozszerzenia, zamiana spacji na podkreślenia. Skrypt ma działać bezpiecznie – najpierw pokazać podgląd, potem pytać o potwierdzenie.

Wymagania

Poproś o maskę plików (np. *.jpg) i katalog (domyślnie bieżący).
Wyświetl menu operacji: 1 – dodaj prefiks, 2 – dodaj sufiks, 3 – zmień rozszerzenie, 4 – zamień spacje na _.
Dla opcji 1-2 poproś o tekst do dodania.
Dla opcji 3 poproś o nowe rozszerzenie (bez kropki).
Najpierw wyświetl podgląd zmian (stara nazwa → nowa nazwa) i zapytaj o potwierdzenie.
Dopiero po potwierdzeniu wykonaj faktyczne mv.

Wskazówki

${f%rozszerzenie} usuwa najkrótszy sufiks (extension stripping). ${f// /_} zamienia wszystkie spacje na podkreślenia. basename i dirname pomagają w operacjach na ścieżkach. Użyj pętli for f in "$DIR"/$MASK do iteracji.

Efekt działania

Użytkownik widzi podgląd proponowanych zmian i decyduje czy je zatwierdzić. Pliki są bezpiecznie zmieniane.

#!/bin/bash

echo "======================================"
echo "       ZBIORCZA ZMIANA NAZW PLIKOW"
echo "======================================"
echo

read -p "Podaj katalog (ENTER = biezacy): " DIR
DIR=${DIR:-.}

if [[ ! -d "$DIR" ]]; then
    echo "BLAD: Katalog '$DIR' nie istnieje!"
    exit 1
fi

read -p "Podaj maske plikow (np. *.txt): " MASK
if [[ -z "$MASK" ]]; then
    MASK="*"
fi

files=("$DIR"/$MASK)
if [[ ${#files[@]} -eq 0 || ! -f "${files[0]}" ]]; then
    echo "Brak plikow pasujacych do maski $MASK"
    exit 1
fi

echo
echo "Wybierz operacje:"
echo "  1 - Dodaj prefiks (na poczatek)"
echo "  2 - Dodaj sufiks (przed rozszerzeniem)"
echo "  3 - Zmien rozszerzenie"
echo "  4 - Zamien spacje na podkreslenia"
echo
read -p "Twoj wybor (1-4): " OP
OP=${OP:-1}

case "$OP" in
    1) read -p "Podaj prefiks: " ADD ;;
    2) read -p "Podaj sufiks: " ADD ;;
    3) read -p "Podaj nowe rozszerzenie (bez kropki): " ADD ;;
    4) ADD="" ;;
    *) echo "Nieprawidlowy wybor."; exit 1 ;;
esac

echo
echo "=== PODGLAD ZMIAN ==="
echo "Lp.  Stara nazwa                | Nowa nazwa"
echo "---------------------------------------------"

count=0
old_names=()
new_names=()

for f in "$DIR"/$MASK; do
    [[ ! -f "$f" ]] && continue
    ((count++))
    dir=$(dirname "$f")
    base=$(basename "$f")
    name="${base%.*}"
    ext="${base##*.}"

    case "$OP" in
        1) new="${ADD}${base}" ;;
        2) new="${name}${ADD}.${ext}" ;;
        3) new="${name}.${ADD}" ;;
        4) new="${base// /_}" ;;
    esac

    old_names+=("$f")
    new_names+=("$dir/$new")

    printf "%3d  %-35s | %s\n" "$count" "$base" "$new"
done

echo "---------------------------------------------"
echo
read -p "Wykonac zmiany? (t/n): " CONFIRM
if [[ "$CONFIRM" != "t" && "$CONFIRM" != "T" ]]; then
    echo "Anulowano."
    exit 0
fi

changed=0
for ((i=0; i<${#old_names[@]}; i++)); do
    if mv "${old_names[$i]}" "${new_names[$i]}" 2>/dev/null; then
        ((changed++))
    fi
done

echo "Zmieniono ${changed} z ${count} plikow."

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./zmien_nazwy.sh
======================================
       ZBIORCZA ZMIANA NAZW PLIKOW
======================================

Podaj katalog (ENTER = biezacy):
Podaj maske plikow (np. *.txt): *.jpg

Wybierz operacje:
  1 - Dodaj prefiks (na poczatek)
  2 - Dodaj sufiks (przed rozszerzeniem)
  3 - Zmien rozszerzenie
  4 - Zamien spacje na podkreslenia

Twoj wybor (1-4): 1
Podaj prefiks: wakacje_

=== PODGLAD ZMIAN ===
Lp.  Stara nazwa                | Nowa nazwa
----------------------------------------------
  1  photo1.jpg                 | wakacje_photo1.jpg
  2  photo2.jpg                 | wakacje_photo2.jpg
  3  selfie.jpg                 | wakacje_selfie.jpg
----------------------------------------------

Wykonac zmiany? (t/n): t
Zmieniono 3 z 3 plikow.

Cel zadania (~20 min)

Stwórz skrypt siec.sh, który analizuje aktywne połączenia sieciowe, grupuje je według stanu i portu, wyświetla statystyki oraz umożliwia zapisanie raportu do pliku. Nauczysz się używać ss (lub netstat) do diagnostyki sieci.

Wymagania

Użyj ss -tuna do pobrania aktywnych połączeń TCP i UDP.
Policz i wyświetl połączenia pogrupowane według stanu (LISTEN, ESTAB, TIME-WAIT...).
Wyświetl 10 najczęściej używanych portów docelowych (sortowanie malejąco).
Policz unikalne adresy IP, z którymi nawiązano połączenie.
Zapisz pełny raport do pliku raport_sieci.txt.
Sprawdź czy ss jest dostępny; jeśli nie – użyj netstat.

Wskazówki

ss -tuna (t=TCP, u=UDP, n=numerycznie, a=wszystkie). awk '{print $1}' wyciąga stan połączenia. sort | uniq -c | sort -rn to standardowy potok do grupowania i zliczania. Adres IP w ss jest w kolumnie $5 (format IP:port).

Efekt działania

Skrypt wyświetla zestawienie połączeń sieciowych, najczęściej używane porty i unikalne adresy IP. Student poznaje narzędzia do diagnostyki sieci.

#!/bin/bash

REPORT="raport_sieci.txt"

echo "======================================"
echo "    MONITOROWANIE POLACZEN SIECIOWYCH"
echo "======================================"
echo

CMD=""
if command -v ss &>/dev/null; then
    CMD="ss -tuna"
elif command -v netstat &>/dev/null; then
    CMD="netstat -tuna"
else
    echo "BLAD: Brak narzedzi do monitorowania sieci (ss/netstat)."
    exit 1
fi

echo "Uzywam: $CMD"
echo

{
    echo "=================================="
    echo "RAPORT POLACZEN SIECIOWYCH"
    echo "Data: $(date)"
    echo "=================================="
    echo
    echo "--- Aktywne polaczenia TCP/UDP ---"
    eval "$CMD"
    echo
} > "$REPORT"

echo "=== POLACZENIA WG STANU ==="
eval "$CMD" | awk 'NR>1{print $1}' | sort | uniq -c | sort -rn
echo

echo "=== 10 NAJCZESCIEJ UZYWANYCH PORTOW ==="
eval "$CMD" | awk 'NR>1{
    split($5,a,":")
    port=a[length(a)]
    print port
}' | sort -n | uniq -c | sort -rn | head -10
echo

echo "=== LICZBA UNIKALNYCH ADRESOW IP ==="
unique_ip=$(eval "$CMD" | awk 'NR>1{
    split($5,a,":")
    ip=substr($5,1,length($5)-length(a[length(a)])-1)
    gsub(/\[/,"",ip)
    print ip
}' | sort -u | wc -l)
echo "Unikalnych adresow IP: $unique_ip"
echo

{
    echo "--- Polaczenia wg stanu ---"
    eval "$CMD" | awk 'NR>1{print $1}' | sort | uniq -c | sort -rn
    echo
    echo "--- 10 najczesciej uzywanych portow ---"
    eval "$CMD" | awk 'NR>1{
        split($5,a,":")
        port=a[length(a)]
        print port
    }' | sort -n | uniq -c | sort -rn | head -10
    echo
    echo "Unikalnych adresow IP: $unique_ip"
} >> "$REPORT"

echo "Raport zapisano: $REPORT"

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./siec.sh
======================================
    MONITOROWANIE POLACZEN SIECIOWYCH
======================================

Uzywam: ss -tuna

=== POLACZENIA WG STANU ===
  5 ESTAB
  3 LISTEN
  2 TIME-WAIT
  1 UNCONN

=== 10 NAJCZESCIEJ UZYWANYCH PORTOW ===
  5 443
  3 80
  2 22
  1 53

=== LICZBA UNIKALNYCH ADRESOW IP ===
Unikalnych adresow IP: 8

Raport zapisano: raport_sieci.txt

Cel zadania (~20 min)

Stwórz skrypt projekt.sh, który w interaktywny sposób generuje kompletną strukturę katalogów i plików dla nowego projektu programistycznego. Skrypt będzie pytał o nazwę projektu, wybór języka i tworzył odpowiednie pliki szablonowe z przykładową zawartością.

Wymagania

Poproś o nazwę projektu – utwórz katalog główny o tej nazwie (mkdir -p).
Wyświetl menu wyboru typu projektu: 1 – Python, 2 – HTML, 3 – Bash.
W zależności od wyboru utwórz odpowiednią strukturę:
- Python: src/, docs/, tests/, pliki main.py, requirements.txt
- HTML: css/, js/, img/, pliki index.html, style.css
- Bash: scripts/, logs/, backup/, pliki run.sh, README.md
Utwórz pliki z przykładową zawartością (heredoc lub echo).
Nadaj uprawnienia wykonywania plikom .sh (chmod +x).
Wyświetl wygenerowaną strukturę za pomocą find lub tree.

Wskazówki

mkdir -p katalog/{podkatalog1,podkatalog2} tworzy całą strukturę od razu. Heredoc (cat > plik <<EOF) to czytelny sposób zapisu treści plików. chmod +x dodaje uprawnienia wykonywania. find . -type f | sort wyświetla strukturę plików.

Efekt działania

W bieżącym katalogu powstaje nowy katalog projektu z kompletną strukturą i plikami startowymi. Użytkownik widzi drzewo katalogów.

#!/bin/bash

echo "======================================"
echo "     KREATOR STRUKTURY PROJEKTU"
echo "======================================"
echo

read -p "Podaj nazwe projektu: " PROJECT
if [[ -z "$PROJECT" ]]; then
    echo "BLAD: Nie podano nazwy projektu!"
    exit 1
fi

if [[ -d "$PROJECT" ]]; then
    echo "BLAD: Katalog '$PROJECT' juz istnieje!"
    exit 1
fi

echo
echo "Wybierz typ projektu:"
echo "  1 - Python"
echo "  2 - HTML/CSS/JS"
echo "  3 - Bash/Shell"
echo
read -p "Twoj wybor (1-3): " CHOICE

mkdir -p "$PROJECT"

case "$CHOICE" in
    1)
        mkdir -p "$PROJECT/src" "$PROJECT/docs" "$PROJECT/tests"
        cat > "$PROJECT/src/main.py" < "$PROJECT/requirements.txt"
        echo "# Testy dla $PROJECT" > "$PROJECT/tests/__init__.py"
        echo "$(date) - Projekt $PROJECT utworzony." > "$PROJECT/README.md"
        ;;
    2)
        mkdir -p "$PROJECT/css" "$PROJECT/js" "$PROJECT/img"
        cat > "$PROJECT/index.html" <<EOF
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <title>$PROJECT</title>
    <link rel="stylesheet" href="css/style.css">
</head>
<body>
    <h1>$PROJECT</h1>
    <script src="js/script.js"></script>
</body>
</html>
EOF
        echo "/* Style dla $PROJECT */" > "$PROJECT/css/style.css"
        echo "// JavaScript dla $PROJECT" > "$PROJECT/js/script.js"
        ;;
    3)
        mkdir -p "$PROJECT/scripts" "$PROJECT/logs" "$PROJECT/backup"
        cat > "$PROJECT/run.sh" < "$PROJECT/README.md"
        echo "Scripts in: scripts/" >> "$PROJECT/README.md"
        ;;
    *)
        echo "Nieprawidlowy wybor. Tworze domyslny katalog."
        ;;
esac

echo
echo "======================================"
echo "  STRUKTURA PROJEKTU: $PROJECT"
echo "======================================"
echo
find "$PROJECT" -type f -o -type d | sort
echo
echo "Projekt zostal utworzony."
echo "  Katalog: $PROJECT"
if [[ -x "$PROJECT/run.sh" ]] || [[ -x "$PROJECT/src/main.py" ]]; then
    echo "  Uruchom: ./$PROJECT/run.sh"
fi

PRZYKLADOWY EKRAN WYNIKOWY:

$ ./projekt.sh
======================================
     KREATOR STRUKTURY PROJEKTU
======================================

Podaj nazwe projektu: MojaAplikacja

Wybierz typ projektu:
  1 - Python
  2 - HTML/CSS/JS
  3 - Bash/Shell

Twoj wybor (1-3): 2

======================================
  STRUKTURA PROJEKTU: MojaAplikacja
======================================

MojaAplikacja
MojaAplikacja/css
MojaAplikacja/css/style.css
MojaAplikacja/img
MojaAplikacja/index.html
MojaAplikacja/js
MojaAplikacja/js/script.js

Projekt zostal utworzony.
  Katalog: MojaAplikacja

Co opanowałeś?

Wykonując powyższe zadania, zdobyłeś praktyczne umiejętności z zakresu:

Zadanie	Kluczowe polecenia	Umiejętność
1	`find`, `stat`, `while read`	Analiza plików, pętle, arytmetyka
2	`uname`, `free`, `df`, `uptime`	Diagnostyka systemu, przekierowania
3	`ps`, `grep`, `kill`	Zarządzanie procesami, filtrowanie
4	`tar`, `md5sum`, `find -exec`	Archiwizacja, sumy kontrolne
5	`cat <<EOF`, `xdg-open`	Generowanie HTML, heredoc
6	`grep -r`, `sort`, `wc -l`	Wyszukiwanie tekstu, maski plików
7	`grep -ci`, `sort -rn`, `basename`	Analiza logów, raportowanie
8	`mv`, `basename`, `${var%}`	Batch rename, manipulacja stringami
9	`ss`, `awk`, `uniq -c`	Diagnostyka sieci, grupowanie
10	`mkdir -p`, `chmod`, heredoc	Struktury katalogów, szablony

Każde zadanie wykorzystuje wyłącznie standardowe polecenia systemu Linux dostępne w każdej dystrybucji bez dodatkowych instalacji.

   bash
  +--------+
  | Zad 1  |  Analiza katalogu
  | Zad 2  |  Diagnostyka systemu
  | Zad 3  |  Zarzadzanie procesami
  | Zad 4  |  Archiwizacja + MD5
  | Zad 5  |  Generator HTML
  | Zad 6  |  Wyszukiwanie tekstu
  | Zad 7  |  Analiza logow
  | Zad 8  |  Zmiana nazw plikow
  | Zad 9  |  Monitorowanie sieci
  | Zad 10 |  Generator projektu
  +--------+
  \   BASH   /
   \        /
    \------/