363 lines
8.8 KiB
Bash
363 lines
8.8 KiB
Bash
export _archive_pattern="_[0-9]{12}-[[:alnum:]]{40}.t[xg]z"
|
|
export _archive_pattern_fast="_[0-9]{12}-[[:alnum:]]{40}.tgz"
|
|
|
|
# Archive directories.
|
|
# All directories by default.
|
|
# Supports .archiveignore exclude file.
|
|
# Usage: archive [DIRS]
|
|
function archive() {
|
|
local IFS=$'\n'
|
|
local targets=(${@})
|
|
[[ "${targets}" = "" ]] && targets=($(_ls_dir))
|
|
|
|
process() {
|
|
local date=$(_archive_date)
|
|
|
|
# Parse name.
|
|
local name=$(parse_pascal ${target})
|
|
|
|
# Exclude support.
|
|
local exclude=""
|
|
[[ -f ".archiveignore" ]] && exclude="--exclude-from=.archiveignore"
|
|
[[ -f "${target}/.archiveignore" ]] && exclude="--exclude-from=${target}/.archiveignore"
|
|
|
|
# create archive.
|
|
local hash=$(tar ${exclude} -c ${target} | pv -s $(/usr/bin/env du -sb ${target} | awk '{print $1}') | xz -9e | tee ${name}.txz | sha1sum | cut -d\ -f1)
|
|
|
|
# append hash to target name.
|
|
local new_name="${name}_${date}-${hash}.txz"
|
|
mv -- ${name}.txz ${new_name} && echo ${new_name}
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Archive using multiple threads. Uses 75% of free RAM.
|
|
# All directories by default.
|
|
# Supports .archiveignore exclude file.
|
|
# Usage: archive_mt [DIRS]
|
|
function archive_mt() {
|
|
local IFS=$'\n'
|
|
local targets=(${@})
|
|
[[ "${targets}" = "" ]] && targets=($(_ls_dir))
|
|
|
|
process() {
|
|
local date=$(_archive_date)
|
|
|
|
# Parse name.
|
|
local name=$(parse_pascal ${target})
|
|
|
|
# Exclude support.
|
|
local exclude=""
|
|
[[ -f ".archiveignore" ]] && exclude="--exclude-from=.archiveignore"
|
|
[[ -f "${target}/.archiveignore" ]] && exclude="--exclude-from=${target}/.archiveignore"
|
|
|
|
# Determine memory limit.
|
|
local mem_free=$(_mem_free)
|
|
local mem_limit=$((mem_free*3/4))
|
|
|
|
# create archive.
|
|
local hash=$(tar ${exclude} -c ${target} | pv -s $(/usr/bin/env du -sb ${target} | awk '{print $1}') | xz -9e --threads=0 --memlimit=${mem_limit}MiB | tee ${name}.txz | sha1sum | cut -d\ -f1)
|
|
|
|
# append hash to target name.
|
|
local new_name="${name}_${date}-${hash}.txz"
|
|
mv -- ${name}.txz ${new_name} && echo ${new_name}
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Archive directories with fast compression.
|
|
# All directories by default.
|
|
# Supports .archiveignore exclude file.
|
|
# Usage: archive_fast [DIRS]
|
|
function archive_fast() {
|
|
local IFS=$'\n'
|
|
local targets=("${@}")
|
|
[[ "${targets}" = "" ]] && targets=($(_ls_dir))
|
|
|
|
process() {
|
|
# Start timestamp.
|
|
local date=$(_archive_date)
|
|
|
|
# Parse name.
|
|
local name=$(parse_pascal "${target}")
|
|
|
|
# Exclude support.
|
|
local exclude=""
|
|
[[ -f ".archiveignore" ]] && exclude="--exclude-from=.archiveignore"
|
|
[[ -f "${target}/.archiveignore" ]] && exclude="--exclude-from=${target}/.archiveignore"
|
|
|
|
# create archive.
|
|
local hash=$(tar ${exclude} -c "${target}" | pv -s $(/usr/bin/env du -sb "${target}" | awk '{print $1}') | gzip -1 | tee "${name}".tgz | sha1sum | cut -d\ -f1)
|
|
|
|
# append hash to target name.
|
|
local new_name="${name}_${date}-${hash}.tgz"
|
|
mv -- "${name}".tgz ${new_name} && echo ${new_name}
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Check archives integrity.
|
|
# Checks all archives by default.
|
|
# Usage: archive_check [FILES]
|
|
function archive_check() {
|
|
local IFS=$'\n'
|
|
local targets=(${@})
|
|
[[ "${targets}" = "" ]] && targets=($(_ls_archive))
|
|
|
|
process() {
|
|
_archive_check "${target}"
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Delete old versions of an archive.
|
|
# All archives with 1 version by default.
|
|
# Usage: archive_prune [NAME] [VERSIONS]
|
|
function archive_prune() {
|
|
local IFS=$'\n'
|
|
local targets=(${1})
|
|
local versions=${2}
|
|
|
|
[[ "${targets}" = "" ]] && targets=($(_archive_names))
|
|
[[ "${versions}" = "" ]] && versions=1
|
|
|
|
if [[ ${#} -gt 2 ]]; then
|
|
help archive_prune
|
|
return 2
|
|
fi
|
|
|
|
process() {
|
|
local prune=($(ls ${target}* | _filter_archive | sort -r | sed -e "1,${versions}d"))
|
|
|
|
for archive in ${prune[@]}; do
|
|
rm -- "${archive}" && echo "${archive}"
|
|
done
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Delete specified or all archive files.
|
|
# Usage: archive_rm [FILES]
|
|
function archive_rm() {
|
|
local IFS=$'\n'
|
|
local targets=(${@})
|
|
[[ "${targets}" = "" ]] && targets=($(_ls_archive))
|
|
|
|
process() {
|
|
rm -- "${target}" && echo "${target}"
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Recompress previously created archive_fast with better compression.
|
|
# Usage: archive_xz [FILES]
|
|
function archive_xz() {
|
|
local IFS=$'\n'
|
|
local targets=(${@})
|
|
[[ "${targets}" = "" ]] && targets=$(_ls_archive_fast)
|
|
|
|
process() {
|
|
local data=($(_archive_parse "${target}"))
|
|
local tmp="${data[0]}.txz"
|
|
|
|
# Check that old format.
|
|
if [[ "${data[3]}" != "tgz" ]]; then
|
|
_error "Not in .tgz format!"
|
|
return 1
|
|
fi
|
|
|
|
# Check integrity.
|
|
_archive_check "${target}" || return 1
|
|
|
|
# Recompress.
|
|
local hash=$(pv "${target}" | gzip -d | xz -9e | tee "${tmp}" | sha1sum | cut -d\ -f1)
|
|
|
|
# Rename.
|
|
local new_name="${data[0]}_${data[1]}-${hash}.txz"
|
|
mv -- ${tmp} ${new_name} && rm ${target} && echo ${new_name}
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Rename archives.
|
|
# If no name specified, it simplifies archive's name.
|
|
# If no archives specified, apply to all archives.
|
|
# Usage: archive_name [ARCHIVE] [NAME]
|
|
function archive_name() {
|
|
local IFS=$'\n'
|
|
local targets="${1}"
|
|
local name="${2}"
|
|
[[ "${targets}" = "" ]] && targets=($(_ls_archive))
|
|
|
|
process() {
|
|
# simplify name by default.
|
|
if [[ "${name}" = "" || ${count} -gt 1 ]]; then
|
|
name="${target%_*}"
|
|
name="$(parse_pascal ${name})"
|
|
fi
|
|
|
|
# remove old name.
|
|
local data="${target##*_}"
|
|
local new_name="${name}_${data}"
|
|
|
|
# check for the same name.
|
|
[[ "${target}" = "${new_name}" ]] && return 0
|
|
|
|
# check for existing target.
|
|
if [[ -f "${new_name}" ]]; then
|
|
_error "${new_name}: Already exists!"
|
|
return 1
|
|
fi
|
|
|
|
# rename.
|
|
mv -- ${target} ${new_name} && echo ${new_name}
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Extract previously created archive with checksum validation.
|
|
# Usage: unarchive [FILES]
|
|
function unarchive() {
|
|
local IFS=$'\n'
|
|
local targets=(${@})
|
|
[[ "${targets}" = "" ]] && targets=$(_ls_archive)
|
|
|
|
process() {
|
|
# Validate.
|
|
# _archive_check "${target}" || return 1
|
|
|
|
# Extract.
|
|
case "${target##*.}" in
|
|
"txz")
|
|
pv ${target} | xz -d | tar -xf -
|
|
;;
|
|
"tgz")
|
|
pv ${target} | gzip -d | tar -xf -
|
|
;;
|
|
esac
|
|
}
|
|
|
|
_iterate_targets process ${targets[@]}
|
|
}
|
|
|
|
# Parse archive file name to get: name, date, hash and format.
|
|
# Usage: _archive_parse <FILENAME>
|
|
function _archive_parse() {
|
|
local input="${1}"
|
|
local name="${input%_*}"
|
|
local format="${input##*.}"
|
|
local data="${input##*_}"; data="${data%.*}"
|
|
local date="${data%%-*}"
|
|
local hash="${data##*-}"
|
|
|
|
echo "${name}"
|
|
echo "${date}"
|
|
echo "${hash}"
|
|
echo "${format}"
|
|
}
|
|
|
|
# Autocomplete for archive_name function.
|
|
# First arg is the archives list, second one is selected archive's current name.
|
|
function _comp_archive_name() {
|
|
local IFS=$'\n'
|
|
COMPREPLY=()
|
|
|
|
local cur="${COMP_WORDS[COMP_CWORD]}"
|
|
local prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
local command="${COMP_WORDS[0]}"
|
|
|
|
if [[ "${prev}" = "${command}" ]]; then
|
|
COMPREPLY=( $(compgen -W "$(ls | grep -E ${_archive_pattern})" -- ${cur}) )
|
|
return 0
|
|
else
|
|
local data=($(_archive_parse ${prev}))
|
|
local name="${data[0]}"
|
|
COMPREPLY=( $(compgen -W "${name}" -- ${cur}) )
|
|
return 0
|
|
fi
|
|
}
|
|
|
|
# Autocomplete with archives in current dir.
|
|
function _comp_archive_grep() {
|
|
_autocomplete_grep ${_archive_pattern}
|
|
}
|
|
|
|
# Autocomplete with fast archives in current dir.
|
|
function _comp_archive_grep_fast() {
|
|
_autocomplete_grep ${_archive_pattern_fast}
|
|
}
|
|
|
|
# Get date for a new archive.
|
|
function _archive_date() {
|
|
date +%Y%m%d%H%M
|
|
}
|
|
|
|
# Get names of all archives.
|
|
function _archive_names() {
|
|
local IFS=$'\n'
|
|
local archives=($(_ls_archive))
|
|
local names=()
|
|
|
|
for archive in ${archives[@]}; do
|
|
local data=($(_archive_parse ${archive}))
|
|
names+=(${data[0]})
|
|
done
|
|
|
|
# Remove copies.
|
|
names=($(printf '%s\n' "${names[@]}" | sort -u))
|
|
|
|
printf '%s\n' "${names[@]}"
|
|
}
|
|
|
|
# Autocomplete with names of all archives.
|
|
function _comp_archive_names() {
|
|
_autocomplete_first $(_archive_names)
|
|
}
|
|
|
|
# Check if file is an archive.
|
|
function _is_archive() {
|
|
local out=$(echo "${*}" | grep -E ${_archive_pattern})
|
|
|
|
[[ "${out}" != "" ]]
|
|
}
|
|
|
|
# List all archives.
|
|
function _ls_archive() {
|
|
ls | grep -E ${_archive_pattern}
|
|
}
|
|
|
|
# List fast archives.
|
|
function _ls_archive_fast() {
|
|
ls | grep -E ${_archive_pattern_fast}
|
|
}
|
|
|
|
# Filter input for archives only.
|
|
function _filter_archive() {
|
|
grep -E ${_archive_pattern}
|
|
}
|
|
|
|
function _archive_check() {
|
|
# extract hash from name.
|
|
local data=($(_archive_parse ${target}))
|
|
local saved=${data[2]}
|
|
|
|
# calculate actual hash.
|
|
local actual=$(pv ${target} | sha1sum | cut -d\ -f1)
|
|
|
|
# compare hashes.
|
|
[[ "${actual}" = "${saved}" ]]
|
|
}
|
|
|
|
complete -o filenames -F _comp_archive_grep archive_check unarchive archive_rm
|
|
complete -o filenames -F _comp_archive_grep_fast archive_xz
|
|
complete -o filenames -F _comp_archive_name archive_name
|
|
complete -o filenames -F _comp_archive_names archive_prune
|