You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
353 lines
12 KiB
Bash
353 lines
12 KiB
Bash
#! /bin/bash
|
|
# Preamble
|
|
RED=`tput setaf 1`
|
|
BLUE=`tput setaf 4`
|
|
YELLOW=`tput setaf 3`
|
|
ENDCOLOR=`tput sgr0`
|
|
GREEN=`tput setaf 2`
|
|
TICK="[$GREEN+$ENDCOLOR] "
|
|
TICK_MOVE="[$GREEN~>$ENDCOLOR]"
|
|
TICK_BACKUP="[$GREEN<~$ENDCOLOR] "
|
|
TICK_INPUT="[$YELLOW!$ENDCOLOR] "
|
|
TICK_ERROR="[$RED!$ENDCOLOR] "
|
|
CONFIG_PATH=~/.config/autodeploy
|
|
HOST_CONFIG_PATH=~/.config/autodeploy/$(hostname)_config/
|
|
BACKUP_DIR=$HOST_CONFIG_PATH"backup/"
|
|
user=$(hostname)
|
|
selected_config=$HOST_CONFIG_PATH
|
|
|
|
# Prints usage information
|
|
usage() {
|
|
|
|
echo "${GREEN}-------------------------------------------------------------------"$ENDCOLOR
|
|
echo $GREEN"*** $BLUE AutoDeploy - A pure bash configuration management tool$GREEN ***"$ENDCOLOR
|
|
echo $GREEN"-------------------------------------------------------------------"$ENDCOLOR
|
|
echo "
|
|
$BLUE Usage:
|
|
$GREEN autodeploy $BLUE -h
|
|
$GREEN autodeploy $BLUE -e [apps|config|files]
|
|
$GREEN autodeploy $BLUE -u thinkpad_config
|
|
|
|
$BLUE Options:
|
|
$GREEN-a$BLUE [A]pplications found in autodeploy_apps.conf are installed
|
|
$GREEN-b$BLUE [B]acks up files defined in autodeploy_files.conf
|
|
$GREEN-c$BLUE [C]ollect configuration files on the local file system and prepare them for a remote push (-p)
|
|
$GREEN-D$BLUE [D]eletes your configuration files in ~/.config/autodeploy/
|
|
$GREEN-e <File> $BLUE[E]dits autodeploy's configuration files
|
|
-$GREEN apps:$BLUE Configure what apps are installed using apt.
|
|
-$GREEN config:$BLUE Configure autodeploy settings.
|
|
-$GREEN files:$BLUE Configure what config files you want to mark for operations.
|
|
$GREEN-f$BLUE [F]irst time setup
|
|
$GREEN-g$BLUE [G]et files from the remote repository
|
|
$GREEN-h$BLUE Show this [h]elp screen.
|
|
$GREEN-l$BLUE [L]ist available configuration files
|
|
$GREEN-m$BLUE [M]oves dotfiles defined in autodeploy_files.conf to their correct locations on the local machine
|
|
$GREEN-p$BLUE [P]ush files to remote repository
|
|
$GREEN-u <file> $BLUE[U]se a different machine's configuration files
|
|
|
|
"$ENDCOLOR
|
|
exit 0
|
|
}
|
|
|
|
|
|
|
|
first_setup(){
|
|
# This function is run if the the directory ~/.config/autodeploy is not detected
|
|
# It handles creating the configuration directory, establishing the git repository for configuration files, and initializing
|
|
# the ~/.config/autodeploy/ as a git repository
|
|
|
|
echo $TICK$GREEN"Running first time setup"$ENDCOLOR
|
|
echo $TICK$GREEN"Creating Configuration Files in $BLUE~/.config/autodeploy/ "$ENDCOLOR
|
|
mkdir -p ~/.config/autodeploy/
|
|
|
|
echo $TICK$GREEN"Enter your remote git repository URL"$ENDCOLOR
|
|
echo $TICK$GREEN"For example: $BLUE"https://github.com/grahamhelton/DotFiles""$ENDCOLOR
|
|
|
|
echo -n $TICK_INPUT$GREEN"Enter Remote Repository URL: $YELLOW"
|
|
read remote_repo
|
|
echo $ENDCOLOR$TICK$GREEN"Setting Remote Repository to: $YELLOW$remote_repo "$ENDCOLOR
|
|
|
|
cd $CONFIG_PATH
|
|
git init > /dev/null 2>&1;
|
|
git remote add origin $remote_repo > /dev/null 2>&1;
|
|
git checkout -b main > /dev/null 2>&1;
|
|
|
|
echo $ENDCOLOR$TICK$GREEN"First time setup complete, use$BLUE autodeploy -f $GREEN to rerun first time setup"$ENDCOLOR
|
|
}
|
|
|
|
get_posture(){
|
|
# Not currently in use, will need to be used when more package managers are supported but for now APT is the only supported package manager
|
|
# This function is used to determine if the current system has the required dependencies to run AutoDeploy
|
|
|
|
# Change to wget -q --spider $remote_repo then check for return code with $?
|
|
if ping -c 1 8.8.8.8 > /dev/null 2>&1; then
|
|
echo $TICK"Internet Connectivity Detected"$ENDCOLOR
|
|
internet=True
|
|
else
|
|
echo $RED"Internet Connectivity Not Detected"$ENDCOLOR
|
|
internet=false
|
|
fi
|
|
|
|
if apt help install -h > /dev/null 2>&1; then
|
|
echo $TICK"APT is installed"$ENDCOLOR
|
|
apt=true
|
|
else
|
|
echo $RED"APT is NOT installed"$ENDCOLOR
|
|
apt=false
|
|
fi
|
|
|
|
}
|
|
|
|
install_apps(){
|
|
# This function is responsible for installing any applications (using apt) defined in ~/.config/autodeploy/autodeploy_apps.conf
|
|
echo $TICK$BLUE"Please input SUDO password"$ENDCOLOR
|
|
|
|
# Runs sudo apt update and upgrade
|
|
echo $TICK$GREEN"Running apt update and apt upgrade..."$ENDCOLOR ; sudo apt update > /dev/null 2>&1 && sudo apt upgrade -y > /dev/null 2>&1
|
|
echo $TICK$GREEN"Installing applications from $BLUE$CONFIG_PATH/autodeploy_apps.conf"$ENDCOLOR
|
|
|
|
# Install each application listed in $CONFIG_PATH/autodeploy_apps
|
|
grep -v '^#' $CONFIG_PATH/autodeploy_apps.conf | while read -r line; do
|
|
echo $TICK$GREEN"Installing $BLUE$line"$ENDCOLOR
|
|
sudo apt install $line -y > /dev/null 2>&1 #| grep -A 1 "NEW packages" | grep -v "NEW packages"
|
|
done
|
|
echo $TICK$GREEN"Applications installed."$ENDCOLOR
|
|
}
|
|
|
|
list_configs(){
|
|
# Lists the config files found in ~/.config/autodeploy/*.conf
|
|
echo -n $BLUE
|
|
ls $CONFIG_PATH | grep "_config$"
|
|
echo $ENDCOLOR
|
|
}
|
|
|
|
|
|
collect_files(){
|
|
echo $TICK$GREEN"Collecting files from around the system"$ENDCOLOR
|
|
# Pulls files from the remote repository and checks to see if the configuration path already exists
|
|
git -C $CONFIG_PATH pull origin main --allow-unrelated-histories > /dev/null 2>&1
|
|
|
|
# Check if the configuration path already exists
|
|
echo $TICK$GREEN"Moving files"$ENDCOLOR
|
|
if test -d $HOST_CONFIG_PATH;then
|
|
echo $TICK$GREEN"Creating files in $BLUE$CONFIG_PATH/$(hostname)_config"$ENDCOLOR
|
|
else
|
|
mkdir -p $HOST_CONFIG_PATH
|
|
echo $TICK$GREEN"Creating files in $BLUE$CONFIG_PATH/$(hostname)_config"$ENDCOLOR
|
|
fi
|
|
|
|
# Copy each line in $CONFIG_PATH/autodeploy_files.conf to $HOST_CONFIG_PATH
|
|
cd $HOME
|
|
while read line; do
|
|
# Copies all files listed in $HOST_CONFIG_PATH/autodeploy_files.conf recursively, verbosely, and forcefully to the staging area.
|
|
cp -rf --parents $line $HOST_CONFIG_PATH
|
|
echo $TICK_MOVE$GREEN" Copying $BLUE$line$GREEN to $BLUE$HOST_CONFIG_PATH$GREEN if file exists"$ENDCOLOR
|
|
done < $CONFIG_PATH/autodeploy_files.conf | grep -v "^#"
|
|
|
|
cd $CONFIG_PATH
|
|
|
|
echo $TICK$GREEN"Configuration files saved to $BLUE$HOST_CONFIG_PATH$GREEN. Files can be pushed to $BLUE$remote_repo$GREEN with$BLUE autodeploy -p$GREEN"$ENDCOLOR
|
|
|
|
}
|
|
|
|
edit_files() {
|
|
# Edit configuration files in $CONFIG_PATH
|
|
if [ $OPTARG = "apps" ];then
|
|
"${EDITOR:-vi}" $CONFIG_PATH/autodeploy_apps.conf
|
|
elif [ $OPTARG = "config" ];then
|
|
"${EDITOR:-vi}" $CONFIG_PATH/autodeploy_config.conf
|
|
elif [ $OPTARG = "files" ];then
|
|
"${EDITOR:-vi}" $CONFIG_PATH/autodeploy_files.conf
|
|
else
|
|
usage
|
|
fi
|
|
}
|
|
|
|
use_config(){
|
|
if [ -z "$2" ];then
|
|
echo $TICK_ERROR$YELLOW"Please specify the name of the config file you wish to use "$ENDCOLOR
|
|
echo $TICK_ERROR$YELLOW"For example:$BLUE autodeploy -u thinkpad_config$YELLOW listing valid configs:"$ENDCOLOR
|
|
echo $TICK_ERROR$YELLOW"Listing valid configs:"$ENDCOLOR
|
|
list_configs
|
|
#collect_files
|
|
else
|
|
|
|
select_config "$@"
|
|
fi
|
|
|
|
|
|
}
|
|
select_config(){
|
|
selected_config=$2
|
|
if test -d "$CONFIG_PATH/$selected_config";then
|
|
echo $TICK$GREEN"$selected_config selected"$ENDCOLOR
|
|
HOST_CONFIG_PATH=$CONFIG_PATH/$2
|
|
distribute_files
|
|
else
|
|
echo $TICK_ERROR$YELLOW"Please select a valid file name!"$ENDCOLOR
|
|
list_configs
|
|
fi
|
|
|
|
}
|
|
|
|
check_git(){
|
|
# Check if the autodeploy configuration files are are in the current repo. If not, creates them
|
|
if ! test -f "$CONFIG_PATH/autodeploy_files.conf";then
|
|
echo $TICK$GREEN"Config file not found, generating base configuration..."$ENDCOLOR
|
|
echo "config_name=$(hostname)" > $CONFIG_PATH/autodeploy_config.conf $ENDCOLOR
|
|
|
|
# Add $remote_repo to autodeploy_config
|
|
echo "$remote_repo" >> $CONFIG_PATH/autodeploy_config.conf $ENDCOLOR
|
|
|
|
# Add default applications to autodeploy_apps
|
|
echo "curl\nneovim\nzsh" > $CONFIG_PATH/autodeploy_apps.conf$ENDCOLOR
|
|
|
|
# Add default dot files to autodeploy_files.conf
|
|
echo ".tmux.conf" > $CONFIG_PATH/autodeploy_files.conf$ENDCOLOR
|
|
fi
|
|
}
|
|
|
|
get_files(){
|
|
# pulls files from origin
|
|
cd $CONFIG_PATH
|
|
git -C $CONFIG_PATH pull origin main --allow-unrelated-histories > /dev/null 2>&1; # Figure out how to check if repo exists
|
|
check_git
|
|
echo $TICK$GREEN"Pull complete"$ENDCOLOR
|
|
|
|
}
|
|
|
|
remote_push(){
|
|
# Commit and push files to $remote_repo
|
|
cd $CONFIG_PATH
|
|
echo $TICK$GREEN"Adding Files"$ENDCOLOR
|
|
git add . > /dev/null 2>&1
|
|
echo $TICK$GREEN"Commiting"$ENDCOLOR
|
|
git commit -m "Autodeploy from $(hostname) on $(date)" > /dev/null 2>&1
|
|
echo $TICK$GREEN"Pushing..."$ENDCOLOR
|
|
git push -u origin main > /dev/null 2>&1
|
|
echo $TICK$GREEN"Files have been pushed to $YELLOW$remote_repo"$ENDCOLOR
|
|
|
|
}
|
|
|
|
backup_old(){
|
|
# Backs up all the files that will be overwritten by autodeploy
|
|
mkdir -p $HOST_CONFIG_PATH"backup"
|
|
while read line; do
|
|
echo $TICK_BACKUP$GREEN"Backing up $BLUE$line$GREEN to $BLUE$BACKUP_DIR"$ENDCOLOR
|
|
cp -rf $HOME/$line $BACKUP_DIR > /dev/null 2>&1;
|
|
done < $CONFIG_PATH/autodeploy_files.conf
|
|
}
|
|
|
|
new_client(){
|
|
# Pulles files from origin, places files on local machine into $HOST_CONFIG_PATH, and installs apps defined in autodeploy_apps.conf
|
|
get_files
|
|
collect_files
|
|
install_apps
|
|
|
|
}
|
|
|
|
distribute_files(){
|
|
# Places files defined in autodeploy_file.conf to the correct location in the file system
|
|
backup_old
|
|
cd $HOST_CONFIG_PATH
|
|
|
|
|
|
# Need an odd for loop syntax because zsh handles file globs differently than bash
|
|
for f in .[!.]* *; do # <- for each file that does or does not start with a .
|
|
echo $TICK_MOVE$GREEN"Copying $BLUE$f$GREEN from $BLUE$selected_config$green $GREEN to $BLUE$HOME"$ENDCOLOR
|
|
cp -rf `ls -A | grep -v "backup/"` $HOME
|
|
done
|
|
}
|
|
|
|
main(){
|
|
# Check if this is the first time autodeploy is being ran
|
|
if !(test -d $CONFIG_PATH);then
|
|
first_setup
|
|
fi
|
|
|
|
if [ $# -eq 0 ]; then
|
|
usage
|
|
fi
|
|
|
|
# Process command line arugments
|
|
while getopts "D g h u n m c p s f a b l :e:" o; do
|
|
case "${o}" in
|
|
h)
|
|
h=${OPTARG}
|
|
usage
|
|
;;
|
|
D)
|
|
D=${OPTARG}
|
|
echo $TICK_ERROR$RED"DELETING CONFIG FILES IN 5 SECONDS,$YELLOW PRESS CTRL+C TO CANCEL"$ENDCOLOR
|
|
sleep 5
|
|
rm ~/.config/autodeploy/ -rf
|
|
echo $TICK$GREEN"Config files deleted. Run$BLUE autodeploy -f$GREEN to run first time setup."$ENDCOLOR
|
|
|
|
;;
|
|
l)
|
|
l=${OPTARG}
|
|
echo $TICK$GREEN"Listing available configuration files in $CONFIG_PATH"$ENDCOLOR
|
|
list_configs
|
|
;;
|
|
e)
|
|
e=${OPTARG}
|
|
echo $TICK$GREEN"Editing Files"$ENDCOLOR
|
|
edit_files
|
|
;;
|
|
p)
|
|
c=${OPTARG}
|
|
echo $TICK$GREEN"Pushing config to $remote_repo"$ENDCOLOR
|
|
remote_push
|
|
;;
|
|
g)
|
|
g=${OPTARG}
|
|
echo $TICK$GREEN"Getting config from $BLUE$remote_repo"$ENDCOLOR
|
|
get_files
|
|
;;
|
|
c)
|
|
c=${OPTARG}
|
|
echo $TICK$GREEN"Collecting config files and storing them in $BLUE$HOST_CONFIG_PATH"$ENDCOLOR
|
|
collect_files
|
|
;;
|
|
f)
|
|
f=${OPTARG}
|
|
echo $TICK$GREEN"Re-running first time setup"$ENDCOLOR
|
|
|
|
# Add this feature
|
|
;;
|
|
a)
|
|
a=${OPTARG}
|
|
echo $TICK$GREEN"Installing applications"$ENDCOLOR
|
|
install_apps
|
|
;;
|
|
b)
|
|
b=${OPTARG}
|
|
echo $TICK$GREEN"Backing up current dotfiles to $BACKUP_DIR"$ENDCOLOR
|
|
backup_old
|
|
;;
|
|
m)
|
|
m=${OPTARG}
|
|
echo $BOLD$GREEN"Moving files to correct locations"$ENDCOLOR
|
|
distribute_files
|
|
;;
|
|
n)
|
|
n=${OPTARG}
|
|
echo $BOLD$GREEN"Running full new client install"$ENDCOLOR
|
|
new_client
|
|
;;
|
|
u)
|
|
u=${OPTARG}
|
|
echo $TICK$GREEN"Selecting alternate configuration file"$ENDCOLOR
|
|
use_config "$@"
|
|
;;
|
|
?)
|
|
usage
|
|
;;
|
|
esac
|
|
done
|
|
}
|
|
|
|
# Run main funciton and pass it command line arguments
|
|
main "$@"
|
|
|