mirror of
https://github.com/Telecominfraproject/wlan-lanforge-scripts.git
synced 2025-10-31 10:48:02 +00:00
753 lines
20 KiB
Bash
Executable File
753 lines
20 KiB
Bash
Executable File
#!/bin/bash
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
# Check for large files and purge many of the most inconsequencial #
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
# set -x
|
|
# set -e
|
|
# these are default selections
|
|
selections=()
|
|
deletion_targets=()
|
|
show_menu=1
|
|
verbose=0
|
|
quiet=0
|
|
starting_dir="$PWD"
|
|
|
|
USAGE="$0 # Check for large files and purge many of the most inconsequencial
|
|
-a # automatic: disable menu and clean automatically
|
|
-b # remove extra kernels and modules
|
|
-c # remove all core files
|
|
-d # remove old LANforge downloads
|
|
-h # help
|
|
-k # remove ath10k crash files
|
|
-l # remove old files from /var/log, truncate /var/log/messages
|
|
-m # remove orphaned fileio items in /mnt/lf
|
|
-q # quiet
|
|
-r # compress .csv data in /home/lanforge
|
|
-t # remove /var/tmp files
|
|
-v # verbose
|
|
|
|
"
|
|
|
|
eyedee=`id -u`
|
|
if (( eyedee != 0 )); then
|
|
echo "$0: Please become root to use this script, bye"
|
|
exit 1
|
|
fi
|
|
|
|
debug() {
|
|
if [[ x$verbose = x ]] || (( $verbose < 1 )); then return; fi
|
|
echo ": $1"
|
|
}
|
|
|
|
note() {
|
|
if (( $quiet > 0 )); then return; fi
|
|
echo "# $1"
|
|
}
|
|
|
|
function contains () {
|
|
if [[ x$1 = x ]] || [[ x$2 = x ]]; then
|
|
echo "contains wants ARRAY and ITEM arguments: if contains name joe; then... }$"
|
|
exit 1
|
|
fi
|
|
# these two lines below are important to not modify
|
|
local tmp="${1}[@]"
|
|
local array=( ${!tmp} )
|
|
|
|
# if [[ x$verbose = x1 ]]; then
|
|
# printf "contains array %s\n" "${array[@]}"
|
|
# fi
|
|
if (( ${#array[@]} < 1 )); then
|
|
return 1
|
|
fi
|
|
local item
|
|
for item in "${array[@]}"; do
|
|
# debug "contains testing $2 == $item"
|
|
[[ "$2" = "$item" ]] && return 0
|
|
done
|
|
return 1
|
|
}
|
|
|
|
#opts=""
|
|
opts="abcdhklmqrtv"
|
|
while getopts $opts opt; do
|
|
case "$opt" in
|
|
a)
|
|
verbose=0
|
|
quiet=1
|
|
selections+=($opt)
|
|
show_menu=0
|
|
;;
|
|
b)
|
|
selections+=($opt)
|
|
;;
|
|
c)
|
|
selections+=($opt)
|
|
;;
|
|
d)
|
|
selections+=($opt)
|
|
;;
|
|
h)
|
|
echo "$USAGE"
|
|
exit 0
|
|
;;
|
|
k)
|
|
selections+=($opt)
|
|
;;
|
|
l)
|
|
selections+=($opt)
|
|
;;
|
|
m)
|
|
selections+=($opt)
|
|
;;
|
|
r)
|
|
selections+=($opt)
|
|
;;
|
|
q)
|
|
quiet=1
|
|
verbose=0
|
|
;;
|
|
t)
|
|
selections+=($opt)
|
|
;;
|
|
v)
|
|
quiet=0
|
|
verbose=1
|
|
;;
|
|
*)
|
|
echo "unknown option: $opt"
|
|
echo "$USAGE"
|
|
exit 1
|
|
;;
|
|
esac
|
|
done
|
|
|
|
#if (( ${#selections} < 1 )); then
|
|
# echo "$USAGE"
|
|
# exit 0
|
|
#fi
|
|
|
|
HR=" ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----"
|
|
function hr() {
|
|
echo "$HR"
|
|
}
|
|
|
|
declare -A totals=(
|
|
[b]=0
|
|
[c]=0
|
|
[d]=0
|
|
[k]=0
|
|
[l]=0
|
|
[m]=0
|
|
[r]=0
|
|
[t]=0
|
|
)
|
|
declare -A desc=(
|
|
[b]="kernel files"
|
|
[c]="core files"
|
|
[d]="lf downloads"
|
|
[k]="lf/ath10 files"
|
|
[l]="/var/log"
|
|
[m]="/mnt/lf files"
|
|
[n]="DNF cache"
|
|
[r]="/home/lanforge/report_data"
|
|
[t]="/var/tmp"
|
|
)
|
|
declare -A surveyors_map=(
|
|
[b]="survey_kernel_files"
|
|
[c]="survey_core_files"
|
|
[d]="survey_lf_downloads"
|
|
[k]="survey_ath10_files"
|
|
[l]="survey_var_log"
|
|
[m]="survey_mnt_lf_files"
|
|
[n]="survey_dnf_cache"
|
|
[r]="survey_report_data"
|
|
[t]="survey_var_tmp"
|
|
)
|
|
|
|
declare -A cleaners_map=(
|
|
[b]="clean_old_kernels"
|
|
[c]="clean_core_files"
|
|
[d]="clean_lf_downloads"
|
|
[k]="clean_ath10_files"
|
|
[l]="clean_var_log"
|
|
[m]="clean_mnt_lf_files"
|
|
[n]="clean_dnf_cache"
|
|
[r]="compress_report_data"
|
|
[t]="clean_var_tmp"
|
|
)
|
|
|
|
kernel_to_relnum() {
|
|
#set -euxv
|
|
local hunks=()
|
|
# 1>&2 echo "KERNEL RELNUM:[$1]"
|
|
local my1="${1/*[^0-9+]-/}" # Dang, this is not intuitive to a PCRE user
|
|
#1>&2 echo "KERNEL [$1] REGEX:[$my1]"
|
|
if [[ $my1 =~ ^[^0-9] ]]; then
|
|
1>&2 echo "BAD SERIES: [$1]"
|
|
exit 1
|
|
fi
|
|
IFS="." read -ra hunks <<< "$my1"
|
|
IFS=
|
|
local tmpstr
|
|
local max_width=8
|
|
local last_len=0
|
|
local expandos=()
|
|
for i in 0 1 2; do
|
|
if (( $i < 2 )); then
|
|
#1>&2 echo "HUNK $i: [${hunks[$i]}]"
|
|
expandos+=( $(( 100 + ${hunks[$i]} )) )
|
|
else
|
|
tmpstr="00000000${hunks[i]}"
|
|
last_len=$(( ${#tmpstr} - $max_width ))
|
|
expandos+=( ${tmpstr:$last_len:${#tmpstr}} )
|
|
#1>&2 echo "TRIMMED ${tmpstr:$last_len:${#tmpstr}}"
|
|
fi
|
|
done
|
|
|
|
set +x
|
|
#1>&2 echo "EXPANDO: ${expandos[0]}${expandos[1]}${expandos[2]}"
|
|
echo "k${expandos[0]}${expandos[1]}${expandos[2]}"
|
|
|
|
}
|
|
|
|
clean_old_kernels() {
|
|
echo ""
|
|
echo ""
|
|
note "Cleaning old CT kernels..."
|
|
sleep 2
|
|
local f
|
|
for f in "${removable_packages[@]}"; do
|
|
echo "$f\*"
|
|
done | xargs /usr/bin/rpm -hve
|
|
|
|
for f in "${removable_kernels[@]}"; do
|
|
echo "r m $f"
|
|
done
|
|
for f in "${removable_libmod_dirs[@]}"; do
|
|
echo "r m /lib/modules/$f"
|
|
done
|
|
echo ""
|
|
echo ""
|
|
}
|
|
|
|
clean_core_files() {
|
|
note "Cleaning core files..."
|
|
if (( ${#core_files[@]} < 1 )); then
|
|
debug "No core files ?"
|
|
return 0
|
|
fi
|
|
local counter=0
|
|
for f in "${core_files[@]}"; do
|
|
echo -n "-"
|
|
rm -f "$f"
|
|
counter=$(( counter + 1 ))
|
|
if (( ($counter % 100) == 0 )); then
|
|
sleep 0.2
|
|
fi
|
|
done
|
|
echo ""
|
|
}
|
|
|
|
clean_lf_downloads() {
|
|
if (( ${#lf_downloads[@]} < 1 )); then
|
|
note "No /home/lanforge/downloads files to remove"
|
|
return 0
|
|
fi
|
|
note "Clean LF downloads..."
|
|
if (( $verbose > 0 )); then
|
|
echo "Would Delete: "
|
|
printf "[%s] " "${lf_downloads[@]}" | sort
|
|
fi
|
|
cd /home/lanforge/Downloads
|
|
for f in "${lf_downloads[@]}"; do
|
|
[[ "$f" = "/" ]] && echo "Whuuut? this is not good, bye." && exit 1
|
|
# echo "Next:[$f]"
|
|
sleep 0.02
|
|
rm -f "$f"
|
|
done
|
|
cd "$starting_dir"
|
|
}
|
|
|
|
clean_ath10_files() {
|
|
note "clean_ath10_files WIP"
|
|
if (( $verbose > 0 )); then
|
|
printf "%s\n" "${ath10_files[@]}"
|
|
fi
|
|
}
|
|
|
|
clean_var_log() {
|
|
note "Vacuuming journal..."
|
|
journalctl --vacuum-size 1M
|
|
if (( ${#var_log_files[@]} < 1 )); then
|
|
note "No notable files in /var/log to remove"
|
|
return
|
|
fi
|
|
local vee=""
|
|
if (( $verbose > 0 )); then
|
|
printf "%s\n" "${var_log_files[@]}"
|
|
vee="-v"
|
|
fi
|
|
cd /var/log
|
|
while read file; do
|
|
if [[ $file = /var/log/messages ]]; then
|
|
echo "" > /var/log/messages
|
|
else
|
|
rm -f $vee "$file"
|
|
fi
|
|
done <<< "${var_log_files[@]}"
|
|
cd "$starting_dir"
|
|
}
|
|
|
|
clean_dnf_cache() {
|
|
local yum="dnf"
|
|
which --skip-alias dnf &> /dev/null
|
|
(( $? < 0 )) && yum="yum"
|
|
debug "Purging $yum cache"
|
|
$yum clean all
|
|
}
|
|
|
|
clean_mnt_lf_files() {
|
|
note "clean mnt lf files WIP"
|
|
if (( $verbose > 0 )); then
|
|
printf "%s\n" "${mnt_lf_files[@]}"
|
|
fi
|
|
|
|
}
|
|
|
|
compress_report_data() {
|
|
note "compress report data WIP"
|
|
if (( $verbose > 0 )); then
|
|
printf "%s\n" "${report_data_dirs[@]}"
|
|
fi
|
|
}
|
|
|
|
clean_var_tmp() {
|
|
note "clean var tmp"
|
|
if (( $verbose > 0 )); then
|
|
printf " %s\n" "${var_tmp_files[@]}"
|
|
sleep 1
|
|
fi
|
|
for f in "${var_tmp_files[@]}"; do
|
|
rm -f "$f"
|
|
sleep 0.2
|
|
done
|
|
}
|
|
|
|
kernel_files=() # temp
|
|
lib_module_dirs=() # temp
|
|
declare -a kernel_sort_names
|
|
declare -a pkg_sort_names
|
|
declare -a libmod_sort_names
|
|
removable_kernels=() # these are for CT kernels
|
|
removable_libmod_dirs=() # these are for CT kernels
|
|
removable_packages=() # these are for Fedora kernels
|
|
removable_pkg_series=()
|
|
survey_kernel_files() {
|
|
removable_kernels=()
|
|
removable_libmod_dirs=()
|
|
removable_packages=()
|
|
kernel_sort_names=()
|
|
declare -A pkg_sort_names=()
|
|
libmod_sort_names=()
|
|
note "Surveying Kernel files"
|
|
mapfile -t kernel_files < <(find /boot -maxdepth 1 -type f -a \( \
|
|
-iname "System*" -o -iname "init*img" -o -iname "vm*" -o -iname "ct*" \) \
|
|
2>/dev/null | grep -v rescue | sort)
|
|
mapfile -t lib_module_dirs < <(find /lib/modules -mindepth 1 -maxdepth 1 -type d 2>/dev/null | sort)
|
|
local booted=`uname -r`
|
|
|
|
local g
|
|
debug "** You are running kernel $booted **"
|
|
|
|
for f in "${kernel_files[@]}"; do
|
|
[[ $f = /boot/init* ]] || continue
|
|
[[ $f =~ *.fc*.x86_64 ]] || continue
|
|
f=${f#/boot/init*-}
|
|
f=${f%.img}
|
|
|
|
if [[ $f =~ $booted ]]; then
|
|
debug "ignoring CT kernel $f"
|
|
else
|
|
g=$( kernel_to_relnum $f )
|
|
# debug "f[$f] g[$g]"
|
|
kernel_sort_names[$g]="$f"
|
|
removable_kernels+=($f)
|
|
fi
|
|
done
|
|
if (( $verbose > 0 )) && (( ${#kernel_sort_names[@]} > 0 )); then
|
|
echo "Removable CT kernels:"
|
|
while read g; do
|
|
printf " [%s]\n" "${kernel_sort_names[$g]}"
|
|
done < <(echo "${!kernel_sort_names[@]}" | sort | head -n -1)
|
|
fi
|
|
|
|
note "Module directories elegible for removal: "
|
|
for f in "${lib_module_dirs[@]}"; do
|
|
# echo " [$f]"
|
|
f=${f#/lib/modules/}
|
|
#f=${f%.img}
|
|
#f=${f%.fc*}
|
|
if [[ $f =~ $booted ]]; then
|
|
debug "Ignoring booted module directory $f"
|
|
continue
|
|
elif [[ $f = *.fc??.x86_64 ]]; then
|
|
debug "Ignoring Fedora module directory $f"
|
|
continue
|
|
else
|
|
g=$( kernel_to_relnum $f )
|
|
debug "MODULE f[$f] g[$g] booted [$booted]"
|
|
# removable_libmod_dirs+=($f)
|
|
libmod_sort_names[$g]="$f"
|
|
fi
|
|
done
|
|
if (( $verbose > 0 )) && (( ${#libmod_sort_names[@]} > 0 )); then
|
|
echo "Removable libmod dirs: "
|
|
while read f; do
|
|
if [[ $f =~ $booted ]]; then
|
|
debug "Ignoring booted $booted module directory $f"
|
|
continue
|
|
fi
|
|
removable_libmod_dirs+=(${libmod_sort_names[$f]})
|
|
echo " [${libmod_sort_names[$f]}]"
|
|
done < <( printf "%s\n" "${!libmod_sort_names[@]}" | sort | head -n -1)
|
|
fi
|
|
|
|
local boot_image_sz=$(du -hc "${kernel_files[@]}" | awk '/total/{print $1}')
|
|
local lib_dir_sz=$(du -hc "${lib_module_dirs[@]}" | awk '/total/{print $1}')
|
|
totals[b]="kernels: $boot_image_sz, modules: $lib_dir_sz"
|
|
|
|
local pkg
|
|
local k_pkgs=()
|
|
#local k_ver=()
|
|
removable_pkg_series=()
|
|
|
|
# need to avoid most recent fedora kernel
|
|
if [ ! -x /usr/bin/rpm ]; then
|
|
note "Does not appear to be an rpm system."
|
|
return 0
|
|
fi
|
|
local ur=$( uname -r )
|
|
#local current_relnum=$( kernel_to_relnum $ur )
|
|
local kern_pkgs=( $( rpm -qa 'kernel*' | sort ) )
|
|
local ser
|
|
local zpkg
|
|
declare -A pkg_to_ser
|
|
for pkg in "${kern_pkgs[@]}"; do
|
|
if [[ $pkg = kernel-tools-* ]] \
|
|
|| [[ $pkg = kernel-headers-* ]] \
|
|
|| [[ $pkg = kernel-devel-* ]] ; then
|
|
continue
|
|
fi
|
|
if [[ $pkg =~ $booted ]]; then
|
|
debug "avoiding current kernel [$pkg]"
|
|
continue
|
|
fi
|
|
k_pkgs+=( $pkg )
|
|
done
|
|
|
|
for pkg in "${k_pkgs[@]}"; do
|
|
zpkg="$pkg"
|
|
zpkg=${pkg##kernel-modules-extra-}
|
|
zpkg=${pkg##kernel-modules-}
|
|
zpkg=${pkg##kernel-core-}
|
|
zpkg=${pkg%.fc??.x86_64}
|
|
|
|
if [[ $zpkg =~ $booted ]]; then
|
|
#echo "ignoring k pkg $zpkg cuz $booted"
|
|
continue
|
|
fi
|
|
kernel_series=$( kernel_to_relnum ${zpkg##kernel-} )
|
|
#1>&2 echo "....... ....... Kernel series[$kernel_series]"
|
|
pkg_to_ser[$pkg]="$kernel_series"
|
|
pkg_sort_names[$kernel_series]=1
|
|
done
|
|
|
|
while read ser; do
|
|
debug " can remove series [$ser] "
|
|
removable_pkg_series+=($ser)
|
|
done < <( printf "%s\n" "${!pkg_sort_names[@]}" | sort | head -n -1)
|
|
# for ser in "${!pkg_sort_names[@]}"; do
|
|
# debug " can remove series [$ser] "
|
|
# #removable_pkg_series+=($ser)
|
|
# done
|
|
|
|
for pkg in "${k_pkgs[@]}"; do
|
|
pkg=${pkg%.fc??.x86_64}
|
|
ser=$( kernel_to_relnum $pkg )
|
|
# echo " $pkg -> $ser"
|
|
for zpkg in "${removable_pkg_series[@]}"; do
|
|
#debug " $zser ~~ $ser ~~ $pkg"
|
|
if (( $ser == $zpkg )); then
|
|
# echo " removable: $ser, $zpkg >> $pkg"
|
|
removable_packages+=($pkg)
|
|
#else
|
|
# echo " no"
|
|
fi
|
|
done
|
|
done
|
|
|
|
set +x
|
|
if (( $quiet < 1 )); then
|
|
if (( ${#removable_packages[@]} > 0 )); then
|
|
printf "Would remove packages %s\n" "${removable_packages[@]}"
|
|
fi
|
|
if (( ${#removable_kernels[@]} > 0 )); then
|
|
printf "Would remove CT Kernels %s\n" "${removable_kernels[@]}"
|
|
fi
|
|
if (( ${#removable_libmod_dirs[@]} > 0 )); then
|
|
printf "Would remove CT modules %s\n" "${removable_libmod_dirs[@]}"
|
|
fi
|
|
fi
|
|
} # ~survey_kernel_files
|
|
|
|
# Find core files
|
|
core_files=()
|
|
survey_core_files() {
|
|
debug "Surveying core files"
|
|
cd /
|
|
mapfile -t core_files < <(ls /core* /home/lanforge/core* 2>/dev/null) 2>/dev/null
|
|
if [[ $verbose = 1 ]] && (( ${#core_files[@]} > 0 )); then
|
|
printf " %s\n" "${core_files[@]}" | head
|
|
fi
|
|
if (( ${#core_files[@]} > 0 )); then
|
|
totals[c]=$(du -hc "${core_files[@]}" | awk '/total/{print $1}')
|
|
fi
|
|
#set +x
|
|
[[ x${totals[c]} = x ]] && totals[c]=0
|
|
cd "$starting_dir"
|
|
}
|
|
|
|
# downloads
|
|
lf_downloads=()
|
|
survey_lf_downloads() {
|
|
debug "Surveying /home/lanforge downloads"
|
|
[ ! -d "/home/lanforge/Downloads" ] && note "No downloads folder " && return 0
|
|
cd /home/lanforge/Downloads
|
|
mapfile -t lf_downloads < <(ls *gz *z2 *-Installer.exe *firmware* kinst_* *Docs* 2>/dev/null)
|
|
totals[d]=$(du -hc "${lf_downloads[@]}" | awk '/total/{print $1}')
|
|
[[ x${totals[d]} = x ]] && totals[d]=0
|
|
cd "$starting_dir"
|
|
}
|
|
|
|
# Find ath10k crash residue
|
|
ath10_files=()
|
|
survey_ath10_files() {
|
|
debug "Sureyinig ath10 crash files"
|
|
mapfile -t ath10_files < <(ls /home/lanforge/ath10* 2>/dev/null)
|
|
totals[k]=$(du -hc "${ath10_files}" 2>/dev/null | awk '/total/{print $1}')
|
|
[[ x${totals[k]} = x ]] && totals[k]=0
|
|
}
|
|
|
|
# stuff in var log
|
|
var_log_files=()
|
|
survey_var_log() {
|
|
debug "Surveying var log"
|
|
mapfile -t var_log_files < <(find /var/log -type f -size +35M \
|
|
-not \( -path '*/journal/*' -o -path '*/sa/*' -o -path '*/lastlog' \) 2>/dev/null)
|
|
totals[l]=$(du -hc "${var_log_files}" 2>/dev/null | awk '/total/{print $1}' )
|
|
[[ x${totals[l]} = x ]] && totals[l]=0
|
|
}
|
|
|
|
# stuff in var tmp
|
|
var_tmp_files=()
|
|
survey_var_tmp() {
|
|
debug "Surveying var tmp"
|
|
mapfile -t var_tmp_files < <(find /var/tmp -type f 2>/dev/null)
|
|
totals[t]=$(du -sh "${var_tmp_files}" 2>/dev/null | awk '/total/{print $1}' )
|
|
[[ x${totals[t]} = x ]] && totals[t]=0
|
|
}
|
|
|
|
# Find size of /mnt/lf that is not mounted
|
|
mnt_lf_files=()
|
|
survey_mnt_lf_files() {
|
|
[ ! -d /mnt/lf ] && return 0
|
|
debug "Surveying mnt lf"
|
|
mapfile -t mnt_lf_files < <(find /mnt/lf -type f --one_filesystem 2>/dev/null)
|
|
totals[m]=$(du -xhc "${mnt_lf_files[@]}" 2>/dev/null | awk '/total/{print $1}')
|
|
[[ x${totals[m]} = x ]] && totals[m]=0
|
|
}
|
|
|
|
survey_dnf_cache() {
|
|
local yum="dnf"
|
|
which --skip-alias dnf &> /dev/null
|
|
(( $? < 0 )) && yum="yum"
|
|
debug "Surveying $yum cache"
|
|
totals[n]=$(du -hc '/var/cache/{dnf,yum}' 2>/dev/null | awk '/total/{print $1}')
|
|
}
|
|
|
|
## Find size of /lib/modules
|
|
# cd /lib/modules
|
|
# mapfile -t usage_libmod < <(du -sh *)
|
|
|
|
# Find how many kernels are installed
|
|
# cd /boot
|
|
# mapfile -t boot_kernels < <(ls init*)
|
|
# boot_usage=`du -sh .`
|
|
|
|
report_files=()
|
|
survey_report_data() {
|
|
debug "Surveying for lanforge report data"
|
|
cd /home/lanforge
|
|
local fnum=$( find -type f -name '*.csv' 2>/dev/null | wc -l )
|
|
local fsiz=$( find -type f -name '*.csv' 2>/dev/null | xargs du -hc | awk '/total/{print $1}')
|
|
totals[r]="$fsiz"
|
|
[[ x${totals[r]} = x ]] && totals[r]=0
|
|
report_files=("CSV files: $fnum tt $fsiz")
|
|
cd "$starting_dir"
|
|
}
|
|
|
|
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
# gather usage areas
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
survey_areas() {
|
|
local area
|
|
note "Surveying..."
|
|
for area in "${!surveyors_map[@]}"; do
|
|
if (( $quiet < 1 )) && (( $verbose < 1 )); then
|
|
echo -n "#"
|
|
fi
|
|
${surveyors_map[$area]}
|
|
done
|
|
if (( $quiet < 1 )) && (( $verbose < 1 )); then
|
|
echo ""
|
|
fi
|
|
}
|
|
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
# report sizes here #
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
disk_usage_report() {
|
|
for k in "${!totals[@]}"; do
|
|
echo -e "\t${desc[$k]}:\t${totals[$k]}"
|
|
done
|
|
}
|
|
survey_areas
|
|
disk_usage_report
|
|
|
|
if (( ${#core_files[@]} > 0 )); then
|
|
hr
|
|
note "${#core_files[@]} Core Files detected:"
|
|
filestr=""
|
|
declare -A core_groups
|
|
# set -e
|
|
# note that the long pipe at the bottom of the loop is the best way to get
|
|
# the system to operate with thousands of core files
|
|
while read group7; do
|
|
(( $verbose > 0 )) && echo -n '+'
|
|
group7="${group7%, *}"
|
|
group7="${group7//\'/}"
|
|
[[ ${core_groups[$group7]+_} != _ ]] && core_groups[$group7]=0
|
|
core_groups[$group7]=$(( ${core_groups[$group7]} + 1 ))
|
|
done < <(echo "${core_files[@]}" | xargs file | awk -F": " '/execfn:/{print $7}')
|
|
echo ""
|
|
echo "These types of core files were found:"
|
|
for group in "${!core_groups[@]}"; do
|
|
echo "${core_groups[$group]} files of $group"
|
|
done | sort -n
|
|
hr
|
|
(( ${#core_files[@]} > 0 )) && selections+=("c")
|
|
fi
|
|
|
|
#echo "Usage of /mnt: $usage_mnt"
|
|
#echo "Usage of /lib/modules: $usage_libmod"
|
|
#echo "Boot usage: $boot_usage"
|
|
|
|
#if (( ${#boot_kernels[@]} > 1 )); then
|
|
# echo "Boot ramdisks:"
|
|
# hr
|
|
# printf ' %s\n' "${boot_kernels[@]}"
|
|
# hr
|
|
#fi
|
|
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
# delete extra things now #
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
|
|
if contains "selections" "a" ; then
|
|
note "Automatic deletion will include: "
|
|
printf "%s\n" "${selections[@]}"
|
|
debug "Doing automatic cleanup"
|
|
for z in "${selections[@]}"; do
|
|
debug "Will perform ${desc[$z]}"
|
|
${cleaners_map[$z]}
|
|
done
|
|
survey_areas
|
|
disk_usage_report
|
|
exit 0
|
|
fi
|
|
|
|
if (( ${#selections[@]} > 0 )) ; then
|
|
debug "Doing selected cleanup: "
|
|
printf " %s\n" "${selections[@]}"
|
|
sleep 1
|
|
for z in "${selections[@]}"; do
|
|
debug "Performing ${desc[$z]}"
|
|
${cleaners_map[$z]}
|
|
selections=("${selections[@]/$z}")
|
|
done
|
|
survey_areas
|
|
disk_usage_report
|
|
else
|
|
debug "No selections present"
|
|
fi
|
|
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
# ask for things to remove if we are interactive #
|
|
# ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- #
|
|
choice=""
|
|
while [[ $choice != q ]]; do
|
|
hr
|
|
#abcdhklmqrtv
|
|
echo "Would you like to delete? "
|
|
echo " b) old kernels ${totals[b]}"
|
|
echo " c) core crash files ${totals[c]}"
|
|
echo " d) old LANforge downloads ${totals[d]}"
|
|
echo " k) ath10k crash files ${totals[k]}"
|
|
echo " l) old /var/log files ${totals[l]}"
|
|
echo " m) orphaned /mnt/lf files ${totals[m]}"
|
|
echo " n) purge dnf/yum cache ${totals[n]}"
|
|
echo " r) compress .csv report files ${totals[r]}"
|
|
echo " t) clean /var/tmp ${totals[t]}"
|
|
echo " q) quit"
|
|
read -p "[1-5] or q ? " choice
|
|
|
|
case "$choice" in
|
|
b )
|
|
clean_old_kernels
|
|
;;
|
|
c )
|
|
clean_core_files
|
|
;;
|
|
d )
|
|
clean_lf_downloads
|
|
;;
|
|
k )
|
|
clean_ath10_files
|
|
;;
|
|
l )
|
|
clean_var_log
|
|
;;
|
|
m )
|
|
clean_mnt_lf_files
|
|
;;
|
|
r )
|
|
compress_report_data
|
|
;;
|
|
t )
|
|
clean_var_tmp
|
|
;;
|
|
q )
|
|
break
|
|
;;
|
|
* )
|
|
echo "not an option [$choice]"
|
|
;;
|
|
esac
|
|
survey_areas
|
|
disk_usage_report
|
|
done
|
|
|
|
|
|
echo bye
|