cat <<-EOS

healbitrot - Automatic check and self-healing for bitrot

USAGE: $self [-h|--help] [<dir>...]

<dir>: directory to check; only if none given, the file in \$BITROT_DIRS

is read, one directory per line. Bitrot data is stored in \$BITROT_DATA.

-h/--help: display this help text

BITROT_DIRS: $BITROT_DIRS

BITROT_DATA: $BITROT_DATA

EOS

# Reading: files_par2 createlog repairlog max_files max_block_count redundancy

local -a target_files

local target_dir=$(readlink -e "$1")

local source_dir=$BITROT_DATA/${target_dir:1}

local par2_files=$source_dir/$files_par2

local local_options

Err(){

echo -e "$@\nFor errors, see:"

[[ -f $createlog ]] && echo "$createlog"

[[ -f $repairlog ]] && echo "$repairlog"

exit 4

}

echo "----------------------------------"

echo "Generating par2 files for $target_dir"

# $target_dir could have been deleted/renamed, so no abort

[[ ! -d $target_dir ]] && echo "$target_dir not a dir or not found" &&

return

mkdir -p $source_dir || Err "Couldn't create $source_dir"

echo "Change local directory to $target_dir"

cd "$target_dir" || Err "Couldn't cd into $target_dir "

# Check the number of dir files

local total_files=$(find . -maxdepth 1 -type f | wc -l)

((total_files>max_files)) &&

Err "Number of files in $target_dir: $total_files > $max_files"

# Check that there aren't more than $max_block_count in $target_dir

if ((total_files>max_block_count))

then

local size=$(du -bs $target_dir |cut -f1)

# Block size for percentage of redundancy

local target_dir_tam=$((size*redundancy/100))

# Size in MB of $target_dir, in blocks of 4

local block_size=$((target_dir_tam*4/max_block_count))

echo "Increasing the default block size for $target_dir to $block_size bytes"

local_options+=" -s$block_size"

fi

for file in $(find . -maxdepth 1 -type f ! -size 0)

do

target_files+=("$file")

done

if ((${#target_files}>0))

then # Generate new par2 files

echo "Launching par2create"

if ! par2create $default_options $local_options -v $files_par2 "${target_files[@]}" &>"$createlog"

then

rm -f -- *.par2

Err "Couldn't generate par2 files for $target_dir"

fi

# Copy par2 files and bitrot database to $source_dir

echo "Moving par2 files to $source_dir"

if ! mv *.par2 "$source_dir"

then

rm -f -- *.par2

Err "Couldn't copy par2 files and bitrot database to $source_dir"

fi

fi

echo "Done!"

cd "$pwd"

local line temp_file par2_files orig dest full_target

local target_dir=$(readlink -e "$1" 2>/dev/null)

local source_dir=$BITROT_DATA/${target_dir:1}

local regex_bitrot='error: SHA.* mismatch for (.*): expected .*'

shopt -s extglob

local regex_changes='([[:digit:]]* entries in the database. )?([[:digit:]]*) entries (updated|new|missing):'

local regex_moved='([[:digit:]]* entries in the database. )?([[:digit:]]*) entries renamed:'

local regex_dir_changes='(.*)' regex_dir_moved='from (.*) to (.*)'

local com=(find . -type d)

local -A dirs_bitrot=() dirs_change=() dirs_moved=()

local count=0 count_moved=0

Err() {

echo -e "$@\nFor errors, see:"

[[ -f $bitrotlog ]] && echo "$bitrotlog"

[[ -f $createlog ]] && echo "$createlog"

[[ -f $repairlog ]] && echo "$repairlog"

exit 5

}

echo "----------------------------------"

echo "Checking $target_dir for bitrot"

# Check if exists after backups dir check

[[ -d $target_dir ]] || Err "$target_dir not a dir or not found"

# Check if target is just the backups dir

full_target=$target_dir/

[[ ${full_target::$((${#BITROT_DATA}+1))} = $BITROT_DATA/ ]] &&

echo "Not checking: $target_dir is a subdir of $BITROT_DATA" &&

return

cd "$target_dir" || Err "couldn't cd to $target_dir"

if [[ -f $source_dir/.bitrot.db ]]

then

echo "Copying bitrot db files to $PWD"

cp "$source_dir"/.bitrot.* . ||

Err "Couldn't copy $source_dir/.bitrot.* files to $PWD"

fi

echo "Launching bitrot -v"

bitrot -v &>"$bitrotlog"

while read -r

do

if ((count==0 && count_moved==0))

then # No change detected

# Check log for bitrot errors

[[ $REPLY =~ $regex_bitrot ]] &&

temp_file="$target_dir/${BASH_REMATCH[1]:2}" &&

echo "Bitrot detected in file:$temp_file" &&

# Add to unique index (associative array) and save file just in case

dirs_bitrot["${temp_file%/*}/"]="$temp_file"

# Detect new/updated/missing files

[[ $REPLY =~ $regex_changes ]] && count=${BASH_REMATCH[2]}

# Detect renamed files

[[ $REPLY =~ $regex_moved ]] && count_moved=${BASH_REMATCH[2]}

else # Change detected

if ((count))

then

[[ $REPLY =~ $regex_dir_changes ]] &&

file=${BASH_REMATCH[1]} dirs_change["${file%/*}/"]=$file &&

echo "Change detected in:$file" && ((count--))

elif ((count_moved))

then

[[ $REPLY =~ $regex_dir_moved ]] &&

orig=${BASH_REMATCH[1]} dest=${BASH_REMATCH[2]} &&

echo "Move detected from:$orig to:$dest" &&

dirs_moved["${orig%/*}"]=1 dirs_moved["${dest%/*}"]=1 &&

((count_moved--))

fi

fi

done <"$bitrotlog"

for dir in "${!dirs_bitrot[@]}"

do

cd "$dir" || Err "Couldn't cd into $dir "

echo "Recovering from bitrot with par2 files in $dir"

par2_files=$BITROT_DATA/${dir:1}/$files_par2

# If par2 files generated already: copy them

if [[ -f $par2_files ]]

then

echo "Copying $par2_files to $PWD"

! cp "${par2_files%/*}"/*.par2 . &&

rm -f -- *.par2 && Err "Couldn't copy par2 files to $target_dir"

fi

# Purge recovery par2 files if successful

echo "Repairing bitrot files with par2repair"

if ! par2repair -p $files_par2 &>"$repairlog"

then

rm -f -- *.par2

cd "$target_dir" || Err "couldn't cd to $target_dir"

if [[ -e .bitrot.db ]]

then

[[ -d $source_dir ]] || mkdir -p "$source_dir"

echo "Moving bitrot db files to $source_dir"

! mv .bitrot.* "$source_dir" && rm -f -- .bitrot.* &&

Err "Couldn't move bitrot files to $source_dir"

fi

Err "Couldn't repair $dir with par2 files"

else # Update the db for the new changes

cd "$target_dir" || Err "couldn't cd to $target_dir"

echo "Launching bitrot -v after bitrot"

bitrot -v &>"$bitrotlog"

fi

cd - &>/dev/null

done

# Regenerate dir changes

for dir in "${!dirs_change[@]}"

do

cd "$target_dir" || Err "couldn't cd to $target_dir"

echo "Launching generate_par2files in:$dir"

Generate_par2files "${dir}"

done

# Regenerate dir moved

for dir in "${!dirs_moved[@]}"

do

# Not present: just normal in this case

[[ -d $dir ]] || continue

cd "$target_dir" || Err "couldn't cd to $target_dir"

echo "launching generate_par2files in:$dir"

Generate_par2files "${dir}"

done

((${#dirs_bitrot}==0 && ${#dirs_change[@]}==0 && ${#dirs_moved[@]})) &&

echo "No changes detected"

cd "$target_dir" || Err "couldn't cd to $target_dir"

if [[ -e .bitrot.db ]]

then

[[ -d $source_dir ]] || mkdir -p "$source_dir"

echo "Moving bitrot db files to $source_dir"

! mv .bitrot.* "$source_dir" && rm -f -- .bitrot.* &&

Err "Couldn't move bitrot files to $source_dir"

fi

echo "Done!"

# par2 option: use half free memory (in MB not kB)

local mem=$(grep -e '^MemAvailable:' /proc/meminfo |grep -o '[0-9]*')

default_options+=" -m$((mem/2048))"

if ((par2b>6))

then

# par2 option: set number of threads (more than 2 processors: leave 2)

local cpus=$(getconf _NPROCESSORS_ONLN) path

((cpus==2)) && default_options+=" -t1"

((cpus>2)) && default_options+=" -t$((cpus-2))"

fi

if (($#))

then # At least one argument: for each path

for path

do

Split_dir "$path"

done

else # File(s) in $BITROT_DIRS

while IFS= read -r

do

Split_dir "$REPLY"

done <"$BITROT_DIRS"

fi