pacman/contrib/paccache.in

#!/bin/bash
#
# pacache - flexible pacman cache cleaning
#
# Copyright (C) 2011 Dave Reisner <dreisner@archlinux.org>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


shopt -s extglob

declare -r myname='paccache'

declare -a candidates=() cmdopts=() whitelist=() blacklist=()
declare -i delete=0 dryrun=0 filecount=0 move=0 needsroot=0 totalsaved=0 verbose=0
declare    cachedir=@localstatedir@/cache/pacman/pkg delim=$'\n' keep=3 movedir= scanarch=

msg() {
	local mesg=$1; shift
	printf "==> $mesg\n" "$@"
} >&2

error() {
	local mesg=$1; shift
	printf "==> ERROR: $mesg\n" "$@"
} >&2

die() {
	error "$@"
	exit 1
}

# reads a list of files on stdin and prints out deletion candidates
pkgfilter() {
	# there's whitelist and blacklist parameters passed to this
	# script after the block of awk.

	awk -v keep="$1" -v scanarch="$2" '
	function parse_filename(filename,     parts, count, i, pkgname, arch) {

		count = split(filename, parts, "-")

		i = 1
		pkgname = parts[i++]
		while (i <= count - 3) {
			pkgname = pkgname "-" parts[i++]
		}

		arch = substr(parts[count], 1, index(parts[count], ".") - 1)

		# filter on whitelist or blacklist
		if (wlen && !whitelist[pkgname]) return
		if (blen && blacklist[pkgname]) return

		if ("" == packages[pkgname,arch]) {
			packages[pkgname,arch] = filename
		} else {
			packages[pkgname,arch] = packages[pkgname,arch] SUBSEP filename
		}
	}

	BEGIN {
		# create whitelist
		wlen = ARGV[1]; delete ARGV[1]
		for (i = 2; i < 2 + wlen; i++) {
			whitelist[ARGV[i]] = 1
			delete ARGV[i]
		}

		# create blacklist
		blen = ARGV[i]; delete ARGV[i]
		while (i++ < ARGC) {
			blacklist[ARGV[i]] = 1
			delete ARGV[i]
		}

		# read package filenames
		while (getline < "/dev/stdin") {
			parse_filename($0)
		}

		for (pkglist in packages) {
			# idx[1,2] = idx[pkgname,arch]
			split(pkglist, idx, SUBSEP)

			# enforce architecture match if specified
			if (!scanarch || scanarch == idx[2]) {
				count = split(packages[idx[1], idx[2]], pkgs, SUBSEP)
				for(i = 1; i <= count - keep; i++) {
					print pkgs[i]
				}
			}
		}
	}' "${@:3}"
}

size_to_human() {
	awk -v size="$1" '
	BEGIN {
		suffix[1] = "B"
		suffix[2] = "KiB"
		suffix[3] = "MiB"
		suffix[4] = "GiB"
		suffix[5] = "TiB"
		count = 1

		while (size > 1024) {
			size /= 1024
			count++
		}

		sizestr = sprintf("%.2f", size)
		sub(/\.?0+$/, "", sizestr)
		printf("%s %s", sizestr, suffix[count])
	}'
}

runcmd() {
	if (( needsroot )); then
		msg "Privilege escalation required"
		if sudo -v &>/dev/null && sudo -l &>/dev/null; then
			sudo "$@"
		else
			printf '%s ' 'root'
			su -c "$(printf '%q ' "$@")"
		fi
	else
		"$@"
	fi
}

summarize() {
	local -i filecount=$1; shift
	local seenarch= seen= arch= name=
	local -r pkg_re='(.+)-[^-]+-[0-9]+-([^.]+)\.pkg.*'

	if (( delete )); then
		printf -v output 'finished: %d packages removed' "$filecount"
	elif (( move )); then
		printf -v output "finished: %d packages moved to \`%s'" "$filecount" "$movedir"
	elif (( dryrun )); then
		if (( verbose )); then
			msg "Candidate packages:"
			while read -r pkg; do
				if (( verbose >= 3 )); then
					[[ $pkg =~ $pkg_re ]] && name=${BASH_REMATCH[1]} arch=${BASH_REMATCH[2]}
					if [[ -z $seen || $seenarch != "$arch" || $seen != "$name" ]]; then
						seen=$name seenarch=$arch
						printf '%s (%s):\n' "$name" "$arch"
					fi
					printf '  %s\n' "$pkg"
				elif (( verbose >= 2 )); then
					printf "$PWD/%s$delim" "$pkg"
				else
					printf "%s$delim" "$pkg"
				fi
			done < <(printf '%s\n' "$@" | pacsort)
		fi
		printf -v output 'finished dry run: %d candidates' "$filecount"
	fi

	printf '\n' >&2
	msg "$output (diskspace saved: %s)" "$(size_to_human "$totalsaved")"
}

usage() {
	cat <<EOF
usage: $myname <operation> [options] [targets...]

$myname is a flexible pacman cache cleaning utility, which has numerous
options to help control how much, and what, is deleted from any directory
containing pacman package tarballs.

  Operations:
    -d               perform a dry run, only finding candidate packages.
    -m  <movedir>    move candidate packages to 'movedir'.
    -r               remove candidate packages.

  Options:
    -a  <arch>       scan for 'arch' (default: all architectures).
    -c  <cachedir>   scan 'cachedir' for packages (default: @localstatedir@/cache/pacman/pkg).
    -f               apply force to mv(1) and rm(1) operations.
    -h               display this help message.
    -i  <pkgs>       ignore 'pkgs', which is a comma separated. Alternatively,
                     specify '-' to read package names from stdin, newline delimited.
    -k  <num>        keep 'num' of each package in 'cachedir' (default: 3).
    -u               target uninstalled packages.
    -v               increase verbosity. specify up to 3 times.
    -z               use null delimiters for candidate names (only with -v and -vv)

EOF
}

if (( ! UID )); then
	error "Do not run this script as root. You will be prompted for privilege escalation."
	exit 42
fi

while getopts ':a:c:dfhi:k:m:rsuvz' opt; do
	case $opt in
		a) scanarch=$OPTARG ;;
		c) cachedir=$OPTARG ;;
		d) dryrun=1 ;;
		f) cmdopts=(-f) ;;
		h) usage
			exit 0 ;;
		i) if [[ $OPTARG = '-' ]]; then
				 [[ ! -t 0 ]] && IFS=$'\n' read -r -d '' -a ign
			 else
				 IFS=',' read -r -a ign <<< "$OPTARG"
			 fi
			 blacklist+=("${ign[@]}")
			unset i ign ;;
		k) keep=$OPTARG
			if [[ -z $keep || -n ${keep//[0-9]/} ]]; then
				die 'argument to option -k must be a non-negative integer'
			else
				keep=$(( 10#$keep ))
			fi ;;
		m) move=1 movedir=$OPTARG ;;
		r) delete=1 ;;
		u) IFS=$'\n' read -r -d '' -a ign < <(pacman -Qq)
			 blacklist+=("${ign[@]}")
			 unset ign ;;
		v) (( ++verbose )) ;;
		z) delim='\0' ;;
		:) die "option '--%s' requires an argument" "$OPTARG" ;;
		?) die "invalid option -- '%s'" "$OPTARG" ;;
	esac
done
shift $(( OPTIND - 1 ))

# remaining args are a whitelist
whitelist=("$@")

# sanity checks
case $(( dryrun+delete+move )) in
	0) die "no operation specified (use -h for help)" ;;
	[^1]) die "only one operation may be used at a time" ;;
esac

[[ -d $cachedir ]] ||
	die "cachedir \`%s' does not exist or is not a directory" "$cachedir"

[[ $movedir && ! -d $movedir ]] &&
	die "move-to directory \`%s' does not exist or is not a directory" "$movedir"

if (( move || delete )); then
	# make it an absolute path since we're about to chdir
	[[ ${movedir:0:1} != '/' ]] && movedir=$PWD/$movedir
	[[ ! -w $cachedir || ( $movedir && ! -w $movedir ) ]] && needsroot=1
fi

# unlikely that this will fail, but better make sure
cd "$cachedir" || die "failed to chdir to \`%s'" "$cachedir"

# note that these results are returned in an arbitrary order from awk, but
# they'll be resorted (in summarize) iff we have a verbosity level set.
IFS=$'\n' read -r -d '' -a candidates < \
	<(printf '%s\n' *.pkg.tar?(.+([^.])) | pacsort |
		pkgfilter "$keep" "$scanarch" \
			"${#whitelist[*]}" "${whitelist[@]}" \
			"${#blacklist[*]}" "${blacklist[@]}")

if (( ! ${#candidates[*]} )); then
	msg 'no candidate packages found for pruning'
	exit 1
fi

# grab this prior to signature scavenging
pkgcount=${#candidates[*]}

# copy the list, merging in any found sigs
for cand in "${candidates[@]}"; do
  candtemp+=("$cand")
  [[ -f $cand.sig ]] && candtemp+=("$cand.sig")
done
candidates=("${candtemp[@]}")
unset candtemp

# do this before we destroy anything
totalsaved=$(@SIZECMD@ "${candidates[@]}" | awk '{ sum += $1 } END { print sum }')

# crush. kill. destroy.
(( verbose )) && cmdopts+=(-v)
if (( delete )); then
	runcmd rm "${cmdopts[@]}" "${candidates[@]}"
elif (( move )); then
	runcmd mv "${cmdopts[@]}" "${candidates[@]}" "$movedir"
fi

summarize "$pkgcount" "${candidates[@]}"

# vim: set ts=2 sw=2 noet: