mirror of
https://github.com/TheLocehiliosan/yadm
synced 2024-10-27 20:34:27 +00:00
a479b70d8a
With the new functionality, when the 'alt' command is called (or automatically triggered), any file with a name ending in '##yadm_tmpl' is treated as a jinja template. The template is processed by envtpl and the result is written to a file without the '##yadm_tmpl' name. The variables passed into the template processing are YADM_CLASS YADM_OS YADM_HOSTNAME YADM_USER These variables are set according to the normal rules for CLASS, OS, HOSTNAME, and USER during the alt processing.
862 lines
22 KiB
Bash
Executable File
862 lines
22 KiB
Bash
Executable File
#!/bin/sh
|
|
# yadm - Yet Another Dotfiles Manager
|
|
# Copyright (C) 2015-2017 Tim Byrne
|
|
|
|
# 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, version 3 of the License.
|
|
|
|
# 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/>.
|
|
|
|
#; execute script with bash (shebang line is /bin/sh for portability)
|
|
if [ -z "$BASH_VERSION" ]; then
|
|
[ "$YADM_TEST" != 1 ] && exec bash "$0" "$@"
|
|
fi
|
|
|
|
VERSION=1.07
|
|
|
|
YADM_WORK="$HOME"
|
|
YADM_DIR="$HOME/.yadm"
|
|
|
|
YADM_REPO="repo.git"
|
|
YADM_CONFIG="config"
|
|
YADM_ENCRYPT="encrypt"
|
|
YADM_ARCHIVE="files.gpg"
|
|
YADM_BOOTSTRAP="bootstrap"
|
|
|
|
GPG_PROGRAM="gpg"
|
|
GIT_PROGRAM="git"
|
|
LS_PROGRAM="/bin/ls"
|
|
|
|
#; flag causing path translations with cygpath
|
|
USE_CYGPATH=0
|
|
|
|
#; flag when something may have changes (which prompts auto actions to be performed)
|
|
CHANGES_POSSIBLE=0
|
|
|
|
#; flag when a bootstrap should be performed after cloning
|
|
#; 0: skip auto_bootstrap, 1: ask, 2: perform bootstrap, 3: prevent bootstrap
|
|
DO_BOOTSTRAP=0
|
|
|
|
function main() {
|
|
|
|
require_git
|
|
|
|
#; create the YADM_DIR if it doesn't exist yet
|
|
[ -d "$YADM_DIR" ] || mkdir -p "$YADM_DIR"
|
|
|
|
#; parse command line arguments
|
|
local retval=0
|
|
internal_commands="^(alt|bootstrap|clean|clone|config|decrypt|encrypt|help|init|list|perms|version)$"
|
|
if [ -z "$*" ] ; then
|
|
#; no argumnts will result in help()
|
|
help
|
|
elif [[ "$1" =~ $internal_commands ]] ; then
|
|
#; for internal commands, process all of the arguments
|
|
YADM_COMMAND="$1"
|
|
YADM_ARGS=()
|
|
shift
|
|
|
|
while [[ $# -gt 0 ]] ; do
|
|
key="$1"
|
|
case $key in
|
|
-a) #; used by list()
|
|
LIST_ALL="YES"
|
|
;;
|
|
-d) #; used by all commands
|
|
DEBUG="YES"
|
|
;;
|
|
-f) #; used by init() and clone()
|
|
FORCE="YES"
|
|
;;
|
|
-l) #; used by decrypt()
|
|
DO_LIST="YES"
|
|
;;
|
|
-w) #; used by init() and clone()
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified work tree"
|
|
fi
|
|
YADM_WORK="$2"
|
|
shift
|
|
;;
|
|
*) #; any unhandled arguments
|
|
YADM_ARGS+=("$1")
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
[ ! -d "$YADM_WORK" ] && error_out "Work tree does not exist: [$YADM_WORK]"
|
|
$YADM_COMMAND "${YADM_ARGS[@]}"
|
|
else
|
|
#; any other commands are simply passed through to git
|
|
git_command "$@"
|
|
retval="$?"
|
|
fi
|
|
|
|
#; process automatic events
|
|
auto_alt
|
|
auto_perms
|
|
auto_bootstrap
|
|
|
|
exit $retval
|
|
|
|
}
|
|
|
|
#; ****** yadm Commands ******
|
|
|
|
function alt() {
|
|
|
|
require_repo
|
|
|
|
local_class="$(config local.class)"
|
|
if [ -z "$local_class" ] ; then
|
|
match_class="%"
|
|
else
|
|
match_class="$local_class"
|
|
fi
|
|
match_class="(%|$match_class)"
|
|
|
|
local_system="$(config local.os)"
|
|
if [ -z "$local_system" ] ; then
|
|
local_system=$(uname -s)
|
|
fi
|
|
match_system="(%|$local_system)"
|
|
|
|
local_host="$(config local.host)"
|
|
if [ -z "$local_host" ] ; then
|
|
local_host=$(hostname)
|
|
local_host=${local_host%%.*} #; trim any domain from hostname
|
|
fi
|
|
match_host="(%|$local_host)"
|
|
|
|
local_user="$(config local.user)"
|
|
if [ -z "$local_user" ] ; then
|
|
local_user=$(id -u -n)
|
|
fi
|
|
match_user="(%|$local_user)"
|
|
|
|
#; regex for matching "<file>##CLASS.SYSTEM.HOSTNAME.USER"
|
|
match1="^(.+)##(()|$match_system|$match_system\.$match_host|$match_system\.$match_host\.$match_user)$"
|
|
match2="^(.+)##($match_class|$match_class\.$match_system|$match_class\.$match_system\.$match_host|$match_class\.$match_system\.$match_host\.$match_user)$"
|
|
|
|
#; process relative to YADM_WORK
|
|
YADM_WORK=$(unix_path "$("$GIT_PROGRAM" config core.worktree)")
|
|
cd "$YADM_WORK" || {
|
|
debug "Alternates not processed, unable to cd to $YADM_WORK"
|
|
return
|
|
}
|
|
|
|
#; only be noisy if the "alt" command was run directly
|
|
[ "$YADM_COMMAND" = "alt" ] && loud="YES"
|
|
|
|
#; build a list of files from YADM_ENCRYPT
|
|
ENC_FILES=()
|
|
index=0
|
|
if [ -f "$YADM_ENCRYPT" ] ; then
|
|
while IFS='' read -r glob || [ -n "$glob" ]; do
|
|
if [[ ! $glob =~ ^# && ! $glob =~ ^[[:space:]]*$ ]] ; then
|
|
# echo "working on ->$glob<-"
|
|
local IFS=$'\n'
|
|
for matching_file in $(eval "$LS_PROGRAM" "$glob" 2>/dev/null); do
|
|
ENC_FILES[$index]="$matching_file"
|
|
((index++))
|
|
done
|
|
fi
|
|
done < "$YADM_ENCRYPT"
|
|
fi
|
|
|
|
#; loop over all "tracked" files
|
|
#; for every file which matches the above regex, create a symlink
|
|
for match in $match1 $match2; do
|
|
last_linked=''
|
|
local IFS=$'\n'
|
|
for tracked_file in $("$GIT_PROGRAM" ls-files | sort) "${ENC_FILES[@]}"; do
|
|
tracked_file="$YADM_WORK/$tracked_file"
|
|
#; process both the path, and it's parent directory
|
|
for alt_path in "$tracked_file" "${tracked_file%/*}"; do
|
|
if [ -e "$alt_path" ] ; then
|
|
if [[ $alt_path =~ $match ]] ; then
|
|
if [ "$alt_path" != "$last_linked" ] ; then
|
|
new_link="${BASH_REMATCH[1]}"
|
|
debug "Linking $alt_path to $new_link"
|
|
[ -n "$loud" ] && echo "Linking $alt_path to $new_link"
|
|
ln -nfs "$alt_path" "$new_link"
|
|
last_linked="$alt_path"
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
done
|
|
done
|
|
|
|
#; loop over all "tracked" files
|
|
#; for every file which is a *##yadm_tmpl create a real file
|
|
local IFS=$'\n'
|
|
local match="^(.+)##yadm_tmpl"
|
|
local envtpl_bin=$(which envtpl)
|
|
for tracked_file in $("$GIT_PROGRAM" ls-files | sort) $(cat "$YADM_ENCRYPT" 2>/dev/null); do
|
|
tracked_file="$YADM_WORK/$tracked_file"
|
|
if [ -e "$tracked_file" ] ; then
|
|
if [[ $tracked_file =~ $match ]] ; then
|
|
if [[ -z "$envtpl_bin" ]]; then
|
|
debug "'envtpl' (pip install envtpl) not available, not creating $real_file from template $tracked_file"
|
|
[ -n "$loud" ] && echo "'envtpl' (pip install envtpl) not available, not creating $real_file from template $tracked_file"
|
|
else
|
|
real_file="${BASH_REMATCH[1]}"
|
|
debug "Creating $real_file from template $tracked_file"
|
|
[ -n "$loud" ] && echo "Creating $real_file from template $tracked_file"
|
|
YADM_CLASS="$local_class" YADM_OS="$local_system" \
|
|
YADM_HOSTNAME="$local_host" YADM_USER="$local_user" \
|
|
$envtpl_bin < $tracked_file > $real_file
|
|
fi
|
|
fi
|
|
fi
|
|
done
|
|
|
|
}
|
|
|
|
function bootstrap() {
|
|
|
|
bootstrap_available || error_out "Cannot execute bootstrap\n'$YADM_BOOTSTRAP' is not an executable program."
|
|
|
|
# GIT_DIR should not be set for user's bootstrap code
|
|
unset GIT_DIR
|
|
|
|
echo "Executing $YADM_BOOTSTRAP"
|
|
exec "$YADM_BOOTSTRAP"
|
|
|
|
}
|
|
|
|
function clean() {
|
|
|
|
error_out "\"git clean\" has been disabled for safety. You could end up removing all unmanaged files."
|
|
|
|
}
|
|
|
|
function clone() {
|
|
|
|
DO_BOOTSTRAP=1
|
|
|
|
clone_args=()
|
|
while [[ $# -gt 0 ]] ; do
|
|
key="$1"
|
|
case $key in
|
|
--bootstrap) #; force bootstrap, without prompt
|
|
DO_BOOTSTRAP=2
|
|
;;
|
|
--no-bootstrap) #; prevent bootstrap, without prompt
|
|
DO_BOOTSTRAP=3
|
|
;;
|
|
*) #; main arguments are kept intact
|
|
clone_args+=("$1")
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
#; clone will begin with a bare repo
|
|
local empty=
|
|
init $empty
|
|
|
|
#; add the specified remote, and configure the repo to track origin/master
|
|
debug "Adding remote to new repo"
|
|
"$GIT_PROGRAM" remote add origin "${clone_args[@]}"
|
|
debug "Configuring new repo to track origin/master"
|
|
"$GIT_PROGRAM" config branch.master.remote origin
|
|
"$GIT_PROGRAM" config branch.master.merge refs/heads/master
|
|
|
|
#; fetch / merge (and possibly fallback to reset)
|
|
debug "Doing an initial fetch of the origin"
|
|
"$GIT_PROGRAM" fetch origin || {
|
|
debug "Removing repo after failed clone"
|
|
rm -rf "$YADM_REPO"
|
|
error_out "Unable to fetch origin ${clone_args[0]}"
|
|
}
|
|
debug "Doing an initial merge of origin/master"
|
|
"$GIT_PROGRAM" merge origin/master || {
|
|
debug "Merge failed, doing a reset and stashing conflicts."
|
|
"$GIT_PROGRAM" reset origin/master
|
|
if cd "$YADM_WORK"; then # necessary because of a bug in Git
|
|
"$GIT_PROGRAM" -c user.name='yadm clone' -c user.email='yadm' stash save Conflicts preserved from yadm clone command 2>&1
|
|
cat <<EOF
|
|
**NOTE**
|
|
Merging origin/master failed.
|
|
|
|
As a result, yadm did 'reset origin/master', and then
|
|
stashed the conflicting data.
|
|
|
|
This likely happened because you had files in \$HOME
|
|
which conflicted with files tracked by origin/master.
|
|
|
|
You can review the stashed conflicts with the
|
|
command 'yadm stash show -p' from within your
|
|
\$HOME directory. If you want to restore the
|
|
stashed data, you can run 'yadm stash apply' or
|
|
'yadm stash pop' and then handle the conflicts
|
|
in another way.
|
|
EOF
|
|
else
|
|
#; skip auto_bootstrap if conflicts could not be stashed
|
|
DO_BOOTSTRAP=0
|
|
cat <<EOF
|
|
**NOTE**
|
|
Merging origin/master failed.
|
|
yadm did 'reset origin/master' instead.
|
|
|
|
yadm did not stash these conflicts beacuse it was unable
|
|
to change to the $YADM_WORK directory.
|
|
|
|
Please review and resolve any differences appropriately
|
|
If you know what you're doing, and want to overwrite the
|
|
tracked files, consider 'yadm reset --hard origin/master'
|
|
EOF
|
|
fi
|
|
}
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function config() {
|
|
|
|
use_repo_config=0
|
|
local_options="^local\.(class|os|host|user)$"
|
|
for option in "$@"; do
|
|
[[ "$option" =~ $local_options ]] && use_repo_config=1
|
|
done
|
|
|
|
if [ -z "$*" ] ; then
|
|
#; with no parameters, provide some helpful documentation
|
|
cat << EOF
|
|
yadm supports the following configurations:
|
|
|
|
local.class
|
|
local.host
|
|
local.os
|
|
local.user
|
|
yadm.auto-alt
|
|
yadm.auto-perms
|
|
yadm.git-program
|
|
yadm.gpg-perms
|
|
yadm.gpg-program
|
|
yadm.gpg-recipient
|
|
yadm.ssh-perms
|
|
|
|
Please read the CONFIGURATION section in the man
|
|
page for more details about configurations, and
|
|
how to adjust them.
|
|
EOF
|
|
elif [ "$use_repo_config" -eq 1 ]; then
|
|
|
|
require_repo
|
|
|
|
#; operate on the yadm repo's configuration file
|
|
#; this is always local to the machine
|
|
git config --local "$@"
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
else
|
|
#; operate on the yadm configuration file
|
|
git config --file="$(mixed_path "$YADM_CONFIG")" "$@"
|
|
|
|
fi
|
|
|
|
}
|
|
|
|
function decrypt() {
|
|
|
|
require_gpg
|
|
require_archive
|
|
|
|
YADM_WORK=$(unix_path "$("$GIT_PROGRAM" config core.worktree)")
|
|
|
|
if [ "$DO_LIST" = "YES" ] ; then
|
|
tar_option="t"
|
|
else
|
|
tar_option="x"
|
|
fi
|
|
|
|
#; decrypt the archive
|
|
if ($GPG_PROGRAM -d "$YADM_ARCHIVE" || echo 1) | tar v${tar_option}f - -C "$YADM_WORK"; then
|
|
[ ! "$DO_LIST" = "YES" ] && echo "All files decrypted."
|
|
else
|
|
error_out "Unable to extract encrypted files."
|
|
fi
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function encrypt() {
|
|
|
|
require_gpg
|
|
require_encrypt
|
|
require_ls
|
|
|
|
#; process relative to YADM_WORK
|
|
YADM_WORK=$(unix_path "$("$GIT_PROGRAM" config core.worktree)")
|
|
cd "$YADM_WORK" || {
|
|
debug "Encryption not processed, unable to cd to $YADM_WORK"
|
|
return
|
|
}
|
|
|
|
#; Build gpg options for gpg
|
|
GPG_KEY="$(config yadm.gpg-recipient)"
|
|
if [ "$GPG_KEY" = "ASK" ]; then
|
|
GPG_OPTS=("--no-default-recipient" "-e")
|
|
elif [ "$GPG_KEY" != "" ]; then
|
|
GPG_OPTS=("-e" "-r $GPG_KEY")
|
|
else
|
|
GPG_OPTS=("-c")
|
|
fi
|
|
|
|
#; build a list of files from YADM_ENCRYPT
|
|
ENC_FILES=()
|
|
index=0
|
|
while IFS='' read -r glob || [ -n "$glob" ]; do
|
|
if [[ ! $glob =~ ^# && ! $glob =~ ^[[:space:]]*$ ]] ; then
|
|
local IFS=$'\n'
|
|
for matching_file in $(eval "$LS_PROGRAM" "$glob" 2>/dev/null); do
|
|
ENC_FILES[$index]="$matching_file"
|
|
((index++))
|
|
done
|
|
fi
|
|
done < "$YADM_ENCRYPT"
|
|
|
|
#; report which files will be encrypted
|
|
echo "Encrypting the following files:"
|
|
"$LS_PROGRAM" -1 "${ENC_FILES[@]}"
|
|
echo
|
|
|
|
#; encrypt all files which match the globs
|
|
if tar -f - -c "${ENC_FILES[@]}" | $GPG_PROGRAM --yes "${GPG_OPTS[@]}" --output "$YADM_ARCHIVE"; then
|
|
echo "Wrote new file: $YADM_ARCHIVE"
|
|
else
|
|
error_out "Unable to write $YADM_ARCHIVE"
|
|
fi
|
|
|
|
#; offer to add YADM_ARCHIVE if untracked
|
|
archive_status=$("$GIT_PROGRAM" status --porcelain -uall "$(mixed_path "$YADM_ARCHIVE")" 2>/dev/null)
|
|
archive_regex="^\?\?"
|
|
if [[ $archive_status =~ $archive_regex ]] ; then
|
|
echo "It appears that $YADM_ARCHIVE is not tracked by yadm's repository."
|
|
echo "Would you like to add it now? (y/n)"
|
|
read -r answer < /dev/tty
|
|
if [[ $answer =~ ^[yY]$ ]] ; then
|
|
"$GIT_PROGRAM" add "$(mixed_path "$YADM_ARCHIVE")"
|
|
fi
|
|
fi
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function git_command() {
|
|
|
|
require_repo
|
|
|
|
#; translate 'gitconfig' to 'config' -- 'config' is reserved for yadm
|
|
if [ "$1" = "gitconfig" ] ; then
|
|
set -- "config" "${@:2}"
|
|
fi
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
#; pass commands through to git
|
|
"$GIT_PROGRAM" "$@"
|
|
return "$?"
|
|
}
|
|
|
|
function help() {
|
|
|
|
cat << EOF
|
|
Usage: yadm <command> [options...]
|
|
|
|
Manage dotfiles maintained in a Git repository. Manage alternate files
|
|
for specific systems or hosts. Encrypt/decrypt private files.
|
|
|
|
Git Commands:
|
|
Any Git command or alias can be used as a <command>. It will operate
|
|
on yadm's repository and files in the work tree (usually \$HOME).
|
|
|
|
Commands:
|
|
yadm init [-f] - Initialize an empty repository
|
|
yadm clone <url> [-f] - Clone an existing repository
|
|
yadm config <name> <value> - Configure a setting
|
|
yadm list [-a] - List tracked files
|
|
yadm alt - Create links for alternates
|
|
yadm bootstrap - Execute \$HOME/.yadm/bootstrap
|
|
yadm encrypt - Encrypt files
|
|
yadm decrypt [-l] - Decrypt files
|
|
yadm perms - Fix perms for private files
|
|
|
|
Files:
|
|
\$HOME/.yadm/config - yadm's configuration file
|
|
\$HOME/.yadm/repo.git - yadm's Git repository
|
|
\$HOME/.yadm/encrypt - List of globs used for encrypt/decrypt
|
|
\$HOME/.yadm/files.gpg - Encrypted data stored here
|
|
|
|
Use "man yadm" for complete documentation.
|
|
EOF
|
|
|
|
exit 1
|
|
|
|
}
|
|
|
|
function init() {
|
|
|
|
#; safety check, don't attempt to init when the repo is already present
|
|
[ -d "$YADM_REPO" ] && [ -z "$FORCE" ] && \
|
|
error_out "Git repo already exists. [$YADM_REPO]\nUse '-f' if you want to force it to be overwritten."
|
|
|
|
#; remove existing if forcing the init to happen anyway
|
|
[ -d "$YADM_REPO" ] && {
|
|
debug "Removing existing repo prior to init"
|
|
rm -rf "$YADM_REPO"
|
|
}
|
|
|
|
#; init a new bare repo
|
|
debug "Init new repo"
|
|
"$GIT_PROGRAM" init --shared=0600 --bare "$(mixed_path "$YADM_REPO")" "$@"
|
|
configure_repo
|
|
|
|
CHANGES_POSSIBLE=1
|
|
|
|
}
|
|
|
|
function list() {
|
|
|
|
require_repo
|
|
|
|
#; process relative to YADM_WORK when --all is specified
|
|
if [ -n "$LIST_ALL" ] ; then
|
|
YADM_WORK=$(unix_path "$("$GIT_PROGRAM" config core.worktree)")
|
|
cd "$YADM_WORK" || {
|
|
debug "List not processed, unable to cd to $YADM_WORK"
|
|
return
|
|
}
|
|
fi
|
|
|
|
#; list tracked files
|
|
"$GIT_PROGRAM" ls-files
|
|
|
|
}
|
|
|
|
function perms() {
|
|
|
|
require_ls
|
|
|
|
#; TODO: prevent repeats in the files changed
|
|
|
|
#; process relative to YADM_WORK
|
|
YADM_WORK=$(unix_path "$("$GIT_PROGRAM" config core.worktree)")
|
|
cd "$YADM_WORK" || {
|
|
debug "Perms not processed, unable to cd to $YADM_WORK"
|
|
return
|
|
}
|
|
|
|
GLOBS=()
|
|
|
|
#; include the archive created by "encrypt"
|
|
[ -f "$YADM_ARCHIVE" ] && GLOBS=("${GLOBS[@]}" "$YADM_ARCHIVE")
|
|
|
|
#; include all .ssh files (unless disabled)
|
|
if [[ $(config --bool yadm.ssh-perms) != "false" ]] ; then
|
|
GLOBS=("${GLOBS[@]}" ".ssh" ".ssh/*")
|
|
fi
|
|
|
|
#; include all gpg files (unless disabled)
|
|
if [[ $(config --bool yadm.gpg-perms) != "false" ]] ; then
|
|
GLOBS=("${GLOBS[@]}" ".gnupg" ".gnupg/*")
|
|
fi
|
|
|
|
#; include globs found in YADM_ENCRYPT (if present)
|
|
if [ -f "$YADM_ENCRYPT" ] ; then
|
|
while IFS='' read -r glob || [ -n "$glob" ]; do
|
|
if [[ ! $glob =~ ^# ]] ; then
|
|
GLOBS=("${GLOBS[@]}" $(eval "$LS_PROGRAM" "$glob" 2>/dev/null))
|
|
fi
|
|
done < "$YADM_ENCRYPT"
|
|
fi
|
|
|
|
#; remove group/other permissions from collected globs
|
|
#shellcheck disable=SC2068
|
|
#(SC2068 is disabled because in this case, we desire globbing)
|
|
chmod -f go-rwx ${GLOBS[@]} >/dev/null 2>&1
|
|
#; TODO: detect and report changing permissions in a portable way
|
|
|
|
}
|
|
|
|
function version() {
|
|
|
|
echo "yadm $VERSION"
|
|
exit 0
|
|
|
|
}
|
|
|
|
#; ****** Utility Functions ******
|
|
|
|
function process_global_args() {
|
|
|
|
#; global arguments are removed before the main processing is done
|
|
MAIN_ARGS=()
|
|
while [[ $# -gt 0 ]] ; do
|
|
key="$1"
|
|
case $key in
|
|
-Y|--yadm-dir) #; override the standard YADM_DIR
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified yadm directory"
|
|
fi
|
|
YADM_DIR="$2"
|
|
shift
|
|
;;
|
|
--yadm-repo) #; override the standard YADM_REPO
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified repo path"
|
|
fi
|
|
YADM_OVERRIDE_REPO="$2"
|
|
shift
|
|
;;
|
|
--yadm-config) #; override the standard YADM_CONFIG
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified config path"
|
|
fi
|
|
YADM_OVERRIDE_CONFIG="$2"
|
|
shift
|
|
;;
|
|
--yadm-encrypt) #; override the standard YADM_ENCRYPT
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified encrypt path"
|
|
fi
|
|
YADM_OVERRIDE_ENCRYPT="$2"
|
|
shift
|
|
;;
|
|
--yadm-archive) #; override the standard YADM_ARCHIVE
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified archive path"
|
|
fi
|
|
YADM_OVERRIDE_ARCHIVE="$2"
|
|
shift
|
|
;;
|
|
--yadm-bootstrap) #; override the standard YADM_BOOTSTRAP
|
|
if [[ ! "$2" =~ ^/ ]] ; then
|
|
error_out "You must specify a fully qualified bootstrap path"
|
|
fi
|
|
YADM_OVERRIDE_BOOTSTRAP="$2"
|
|
shift
|
|
;;
|
|
*) #; main arguments are kept intact
|
|
MAIN_ARGS+=("$1")
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
}
|
|
|
|
function configure_paths() {
|
|
|
|
#; change all paths to be relative to YADM_DIR
|
|
YADM_REPO="$YADM_DIR/$YADM_REPO"
|
|
YADM_CONFIG="$YADM_DIR/$YADM_CONFIG"
|
|
YADM_ENCRYPT="$YADM_DIR/$YADM_ENCRYPT"
|
|
YADM_ARCHIVE="$YADM_DIR/$YADM_ARCHIVE"
|
|
YADM_BOOTSTRAP="$YADM_DIR/$YADM_BOOTSTRAP"
|
|
|
|
#; independent overrides for paths
|
|
if [ -n "$YADM_OVERRIDE_REPO" ]; then
|
|
YADM_REPO="$YADM_OVERRIDE_REPO"
|
|
fi
|
|
if [ -n "$YADM_OVERRIDE_CONFIG" ]; then
|
|
YADM_CONFIG="$YADM_OVERRIDE_CONFIG"
|
|
fi
|
|
if [ -n "$YADM_OVERRIDE_ENCRYPT" ]; then
|
|
YADM_ENCRYPT="$YADM_OVERRIDE_ENCRYPT"
|
|
fi
|
|
if [ -n "$YADM_OVERRIDE_ARCHIVE" ]; then
|
|
YADM_ARCHIVE="$YADM_OVERRIDE_ARCHIVE"
|
|
fi
|
|
if [ -n "$YADM_OVERRIDE_BOOTSTRAP" ]; then
|
|
YADM_BOOTSTRAP="$YADM_OVERRIDE_BOOTSTRAP"
|
|
fi
|
|
|
|
#; use the yadm repo for all git operations
|
|
GIT_DIR=$(mixed_path "$YADM_REPO")
|
|
export GIT_DIR
|
|
|
|
}
|
|
|
|
function configure_repo() {
|
|
|
|
debug "Configuring new repo"
|
|
|
|
#; change bare to false (there is a working directory)
|
|
"$GIT_PROGRAM" config core.bare 'false'
|
|
|
|
#; set the worktree for the yadm repo
|
|
"$GIT_PROGRAM" config core.worktree "$(mixed_path "$YADM_WORK")"
|
|
|
|
#; by default, do not show untracked files and directories
|
|
"$GIT_PROGRAM" config status.showUntrackedFiles no
|
|
|
|
#; possibly used later to ensure we're working on the yadm repo
|
|
"$GIT_PROGRAM" config yadm.managed 'true'
|
|
|
|
}
|
|
|
|
function debug() {
|
|
|
|
[ -n "$DEBUG" ] && echo -e "DEBUG: $*"
|
|
|
|
}
|
|
|
|
function error_out() {
|
|
|
|
echo -e "ERROR: $*"
|
|
exit 1
|
|
|
|
}
|
|
|
|
#; ****** Auto Functions ******
|
|
|
|
function auto_alt() {
|
|
|
|
#; process alternates if there are possible changes
|
|
if [ "$CHANGES_POSSIBLE" = "1" ] ; then
|
|
auto_alt=$(config --bool yadm.auto-alt)
|
|
if [ "$auto_alt" != "false" ] ; then
|
|
[ -d "$YADM_REPO" ] && alt
|
|
fi
|
|
fi
|
|
|
|
}
|
|
|
|
function auto_perms() {
|
|
|
|
#; process permissions if there are possible changes
|
|
if [ "$CHANGES_POSSIBLE" = "1" ] ; then
|
|
auto_perms=$(config --bool yadm.auto-perms)
|
|
if [ "$auto_perms" != "false" ] ; then
|
|
[ -d "$YADM_REPO" ] && perms
|
|
fi
|
|
fi
|
|
|
|
}
|
|
|
|
function auto_bootstrap() {
|
|
|
|
bootstrap_available || return
|
|
|
|
[ "$DO_BOOTSTRAP" -eq 0 ] && return
|
|
[ "$DO_BOOTSTRAP" -eq 3 ] && return
|
|
[ "$DO_BOOTSTRAP" -eq 2 ] && bootstrap
|
|
if [ "$DO_BOOTSTRAP" -eq 1 ] ; then
|
|
echo "Found $YADM_BOOTSTRAP"
|
|
echo "It appears that a bootstrap program exists."
|
|
echo "Would you like to execute it now? (y/n)"
|
|
read -r answer < /dev/tty
|
|
if [[ $answer =~ ^[yY]$ ]] ; then
|
|
bootstrap
|
|
fi
|
|
fi
|
|
|
|
}
|
|
|
|
#; ****** Prerequisites Functions ******
|
|
|
|
function require_archive() {
|
|
[ -f "$YADM_ARCHIVE" ] || error_out "$YADM_ARCHIVE does not exist. did you forget to create it?"
|
|
}
|
|
function require_encrypt() {
|
|
[ -f "$YADM_ENCRYPT" ] || error_out "$YADM_ENCRYPT does not exist. did you forget to create it?"
|
|
}
|
|
function require_git() {
|
|
local alt_git
|
|
alt_git="$(config yadm.git-program)"
|
|
|
|
local more_info
|
|
more_info=""
|
|
|
|
if [ "$alt_git" != "" ] ; then
|
|
GIT_PROGRAM="$alt_git"
|
|
more_info="\nThis command has been set via the yadm.git-program configuration."
|
|
fi
|
|
command -v "$GIT_PROGRAM" >/dev/null 2>&1 || \
|
|
error_out "This functionality requires Git to be installed, but the command '$GIT_PROGRAM' cannot be located.$more_info"
|
|
}
|
|
function require_gpg() {
|
|
local alt_gpg
|
|
alt_gpg="$(config yadm.gpg-program)"
|
|
|
|
local more_info
|
|
more_info=""
|
|
|
|
if [ "$alt_gpg" != "" ] ; then
|
|
GPG_PROGRAM="$alt_gpg"
|
|
more_info="\nThis command has been set via the yadm.gpg-program configuration."
|
|
fi
|
|
command -v "$GPG_PROGRAM" >/dev/null 2>&1 || \
|
|
error_out "This functionality requires GPG to be installed, but the command '$GPG_PROGRAM' cannot be located.$more_info"
|
|
}
|
|
function require_repo() {
|
|
[ -d "$YADM_REPO" ] || error_out "Git repo does not exist. did you forget to run 'init' or 'clone'?"
|
|
}
|
|
function require_ls() {
|
|
if [ ! -f "$LS_PROGRAM" ] ; then
|
|
command -v ls >/dev/null 2>&1 || \
|
|
error_out "This functionality requires 'ls' to be installed at '$LS_PROGRAM' or listed in your \$PATH"
|
|
LS_PROGRAM=ls
|
|
fi
|
|
}
|
|
function bootstrap_available() {
|
|
[ -f "$YADM_BOOTSTRAP" ] && [ -x "$YADM_BOOTSTRAP" ] && return
|
|
return 1
|
|
}
|
|
|
|
#; ****** Directory tranlations ******
|
|
|
|
function test_cygwin() {
|
|
case "$(uname -s)" in
|
|
CYGWIN*)
|
|
git_version=$(git --version 2>/dev/null)
|
|
if [[ "$git_version" =~ windows ]] ; then
|
|
USE_CYGPATH=1
|
|
fi
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
}
|
|
function unix_path() {
|
|
#; for paths used by bash/yadm
|
|
if [ "$USE_CYGPATH" = "1" ] ; then
|
|
cygpath -u "$1"
|
|
else
|
|
echo "$1"
|
|
fi
|
|
}
|
|
function mixed_path() {
|
|
#; for paths used by Git
|
|
if [ "$USE_CYGPATH" = "1" ] ; then
|
|
cygpath -m "$1"
|
|
else
|
|
echo "$1"
|
|
fi
|
|
}
|
|
|
|
#; ****** Main processing (when not unit testing) ******
|
|
|
|
if [ "$YADM_TEST" != 1 ] ; then
|
|
process_global_args "$@"
|
|
test_cygwin
|
|
configure_paths
|
|
main "${MAIN_ARGS[@]}"
|
|
fi
|