1163 lines
36 KiB
YAML
1163 lines
36 KiB
YAML
---
|
|
# Create and configure default users for all machines.
|
|
|
|
## Variables ##
|
|
|
|
- name: General | Account Management | Users | Use BASH (Default)
|
|
set_fact:
|
|
user_shell: "{{ bash_exec.stdout }}"
|
|
|
|
- name: General | Account Management | Users | Allow BASH (Arch)
|
|
lineinfile:
|
|
path: /etc/shells
|
|
regexp: "{{ bash_exec.stdout }}"
|
|
line: "{{ bash_exec.stdout }}"
|
|
insertbefore: "# End of file"
|
|
backup: yes
|
|
create: no
|
|
state: present
|
|
when: ansible_distribution == "Archlinux"
|
|
|
|
#- name: General | Account Management | Users | Use ZSH (Arch+Manjaro)
|
|
# set_fact:
|
|
# user_shell: "{{ zsh_exec.stdout }}"
|
|
# when: ansible_distribution == "Archlinux"
|
|
#
|
|
#- name: General | Account Management | Users | Allow ZSH (Arch)
|
|
# lineinfile:
|
|
# path: /etc/shells
|
|
# regexp: "{{ zsh_exec.stdout }}"
|
|
# line: "{{ zsh_exec.stdout }}"
|
|
# insertbefore: "# End of file"
|
|
# backup: yes
|
|
# create: no
|
|
# state: present
|
|
# when: ansible_distribution == "Archlinux"
|
|
|
|
|
|
## Root ##
|
|
|
|
- name: General | Account Management | Users | Root
|
|
user:
|
|
name: root
|
|
shell: "{{ bash_exec.stdout }}"
|
|
create_home: yes
|
|
generate_ssh_key: yes
|
|
register: user_root
|
|
|
|
|
|
## Scheduler ##
|
|
|
|
- name: General | Account Management | Users | Ansible
|
|
user:
|
|
name: ansible
|
|
comment: Ansible
|
|
system: yes
|
|
register: user_ansible
|
|
|
|
|
|
## Superuser ##
|
|
|
|
- name: General | Account Management | Users | User
|
|
user:
|
|
name: "{{ user }}"
|
|
comment: "{{ user_desc }}"
|
|
groups:
|
|
- sudo
|
|
- video
|
|
- render
|
|
- wheel
|
|
append: yes
|
|
shell: "{{ user_shell }}"
|
|
create_home: yes
|
|
generate_ssh_key: yes
|
|
register: user_user
|
|
|
|
- name: General | Account Management | Users | User | Test Logging In
|
|
shell: "echo SUCCESS"
|
|
args:
|
|
executable: "{{ user_shell }}"
|
|
become_user: "{{ user }}"
|
|
|
|
|
|
## Folders ##
|
|
|
|
- name: General | Account Management | Users | Root | Create Folders
|
|
file:
|
|
path: "{{ item }}"
|
|
state: directory
|
|
mode: '0755'
|
|
loop:
|
|
- "{{ user_root.home }}/bin"
|
|
- "{{ user_root.home }}/Downloads"
|
|
- "{{ user_root.home }}/TRASH"
|
|
when: user_root.home != ""
|
|
|
|
- name: General | Account Management | Users | User | Create Folders
|
|
file:
|
|
path: "{{ item }}"
|
|
state: directory
|
|
mode: '0755'
|
|
loop:
|
|
- "{{ user_user.home }}/bin"
|
|
- "{{ user_user.home }}/TRASH"
|
|
- "{{ user_user.home }}/Downloads"
|
|
- "{{ user_user.home }}/Reports"
|
|
become_user: "{{ user }}"
|
|
when: user_user.home != ""
|
|
|
|
- name: General | Account Management | Users | User | Create Folders | Coding
|
|
file:
|
|
path: "{{ item }}"
|
|
state: directory
|
|
mode: '0755'
|
|
loop:
|
|
- "{{ user_user.home }}/Code"
|
|
become_user: "{{ user }}"
|
|
when: user_user.home != "" and coding == true
|
|
|
|
- name: General | Account Management | Users | Home Permissions
|
|
shell: "chmod 700 {{ user_user.home }}/../*"
|
|
|
|
|
|
## Files ##
|
|
|
|
- name: General | Account Management | Users | Files | RC Variables
|
|
set_fact:
|
|
alias_cp: alias cp='cp -v'
|
|
alias_mv: alias mv='mv -v'
|
|
alias_rm: alias rm='echo "Use mv ~/TRASH/ instead!"'
|
|
export_path_additions: export PATH="~/bin:"{{ global_bin }}":$PATH"
|
|
function_wttr: |
|
|
function weather() {
|
|
# 20210301 - Someone showed me an awesome weather API! Had to implement it!
|
|
if [[ "$1" == "-"* || $2 != "" ]]; then
|
|
echo 'USAGE: weather [location]
|
|
Any "-" paramaters call the usage since this function does not take any options.
|
|
Location is optional since the API can determine your connection'"'"'s location.
|
|
Useful location types:
|
|
$zip_code | Ex: 12345
|
|
$city,$state | Ex: Austin,Texas
|
|
@$domain_dot_extension | Ex: @gitea.com
|
|
~$special_location | Ex: ~Manitou Incline
|
|
Full documentation: https://github.com/chubin/wttr.in'
|
|
return 1
|
|
fi
|
|
curl "https://wttr.in/${1//\ /+}"
|
|
}
|
|
export_PS1: export PS1='[\u@\h \w]\$ '
|
|
alias_remount: |
|
|
alias remount='
|
|
sudo umount /mnt/*
|
|
sudo umount /mnt/*/*
|
|
sudo mount -a
|
|
echo -e "\nRemount completed!"
|
|
mount | grep /mnt
|
|
'
|
|
function_update: |
|
|
function update() {
|
|
PROG=$FUNCNAME
|
|
usage="Usage: $PROG [-y] [-g] [-s] [-f]
|
|
$PROG is used to run all the system's package manager commands
|
|
in one swoop. Flow stops if any command returns a failure code.
|
|
The hope is to run something as easy as 'pacman -Syyu'.
|
|
-y : Assume yes to any prompts.
|
|
-g : Goodbye - Shutdown after updating.
|
|
-s : System updates only, no Flatpaks.
|
|
-f : Flatpaks only, no system updates."
|
|
|
|
unset OPTIND
|
|
unset accept
|
|
unset shutdown
|
|
unset only_sys
|
|
unset only_flat
|
|
|
|
while getopts ":hygsf" opt; do
|
|
case $opt in
|
|
h) echo -e "$usage"
|
|
return 0 ;;
|
|
y) accept="-y" ;;
|
|
g) shutdown="Y" ;;
|
|
s) only_sys="Y" ;;
|
|
f) only_flat="Y" ;;
|
|
*) echo "ERROR: -$OPTARG is not a recognized option." >&2
|
|
echo -e "$usage"
|
|
return 1 ;;
|
|
esac
|
|
done
|
|
|
|
if [[ "$only_flat" == "Y" ]]; then
|
|
echo -e "\n*** Only Flatpaks - Skipping System Updates ***\n\n"
|
|
else
|
|
{{ update_package_manager }}
|
|
fi
|
|
|
|
if [[ "$shutdown" == "Y" && "{{ battery }}" == "True" ]]; then
|
|
echo -e "\n*** Only System Updates - Skipping Flatpak ***\n\n"
|
|
elif [[ "$only_sys" == "Y" ]]; then
|
|
echo -e "\n*** Manually Skipping Flatpak ***\n\n"
|
|
else
|
|
{{ update_flatpak }}
|
|
fi
|
|
|
|
echo "*** Completed Successfully ***"
|
|
|
|
if [[ $shutdown == "Y" ]]; then
|
|
shopt -s expand_aliases
|
|
bye
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
function_update_firmware: |
|
|
function update-firmware() {
|
|
PROG=$FUNCNAME
|
|
usage="Usage: $PROG [-y]
|
|
$PROG is used to run the firmware updater in one swoop. Flow stops if
|
|
any command returns a failure code. The hope is to run something as
|
|
easy as 'pacman -Syyu' but for non-Arch systems.
|
|
-y : Assume yes to any prompts."
|
|
|
|
unset OPTIND
|
|
unset accept
|
|
while getopts ":hy" opt; do
|
|
case $opt in
|
|
h) echo -e "$usage"
|
|
return 0 ;;
|
|
y) accept="-y" ;;
|
|
*) echo "ERROR: -$OPTARG is not a recognized option." >&2
|
|
echo -e "$usage"
|
|
return 1 ;;
|
|
esac
|
|
done
|
|
|
|
{{ update_firmware }}
|
|
echo "*** Completed Successfully ***"
|
|
return 0
|
|
}
|
|
alias firmware-update="update-firmware"
|
|
alias firmware-updater="update-firmware"
|
|
alias_sync: alias sync='date && echo "Syncing!" && sync && date'
|
|
export_editor: export EDITOR='vi'
|
|
init_aliases: |
|
|
alias init-video='
|
|
mkdir -v raw
|
|
mkdir -v exports
|
|
cp ~/Templates/*video* ./
|
|
'
|
|
alias init-vid=init-video
|
|
alias init-program='
|
|
echo "#!/usr/bin/env bash"
|
|
echo "# `date +%Y-%m-%d` Hyperling"
|
|
echo ""
|
|
echo "exit 0"
|
|
'
|
|
alias init-prog=init-program
|
|
bye_aliases: |
|
|
function bye {
|
|
{{ shutdown_command }}
|
|
}
|
|
function goodbye {
|
|
update -yg
|
|
}
|
|
metasploit_aliases: |
|
|
alias metasploit="msfconsole"
|
|
alias hax="metasploit"
|
|
show_config_aliases: |
|
|
alias show-config-gen="cat {{ gen_file }}"
|
|
alias show-config-wrk="cat {{ wrk_file }}"
|
|
alias show-config-mnr="cat {{ mnr_file }}"
|
|
alias show-config-srv="cat {{ srv_file }}"
|
|
alias show-config-all="
|
|
show-config-gen &&
|
|
echo '' &&
|
|
show-config-wrk &&
|
|
echo '' &&
|
|
show-config-mnr &&
|
|
echo '' &&
|
|
show-config-srv
|
|
"
|
|
alias show-config="show-config-all"
|
|
edit_config_aliases: |
|
|
alias edit-config-gen="sudo $EDITOR {{ gen_file }}"
|
|
alias edit-config-wrk="sudo $EDITOR {{ wrk_file }}"
|
|
alias edit-config-mnr="sudo $EDITOR {{ mnr_file }}"
|
|
alias edit-config-srv="sudo $EDITOR {{ srv_file }}"
|
|
function_clean_trashed: |
|
|
function clean-trashed {
|
|
dir="$1"
|
|
if [[ -z $dir ]]; then
|
|
dir="./"
|
|
fi
|
|
cd $dir
|
|
dir="`pwd`"
|
|
echo "Removing '.trashed*' files in '$dir'."
|
|
find "$dir" -name ".trashed*" -exec du -h {} \; -delete | sort -h
|
|
}
|
|
alias trashed-cleanup="clean-trashed"
|
|
alias trashed-clean="clean-trashed"
|
|
function_check_trash: |
|
|
function check-trash() {
|
|
unset OPTIND
|
|
unset clean
|
|
unset network
|
|
du_params="-ha"
|
|
while (( $# > 0 )); do
|
|
case $1 in
|
|
-c | -y | --clean )
|
|
clean="Y" ;;
|
|
-n | -net | --network )
|
|
network="Y" ;;
|
|
-s | -sum | --summarize )
|
|
du_params="-sh" ;;
|
|
* )
|
|
echo "
|
|
ERROR: Option '$1' with value '$2' not recognized.
|
|
$PROG [-c | -y | --clean] [-n | -net | --network] \
|
|
[-s | -sum | --summarize]
|
|
" >&2
|
|
return 1
|
|
;;
|
|
esac
|
|
shift
|
|
done
|
|
echo "clean=$clean"
|
|
echo "network=$network"
|
|
echo "Grabbing sudo permissions..."
|
|
sudo echo "Success! Starting search..."
|
|
function dirs_to_check {
|
|
echo "/root 0"
|
|
echo "/home 4"
|
|
echo "/media 0"
|
|
}
|
|
dirs_to_check | while read dir depth; do
|
|
if [[ "$depth" != 0 ]]; then
|
|
maxdepth="-maxdepth $depth"
|
|
fi
|
|
sudo="sudo"
|
|
if [[ "$dir" == "/media" ]]; then
|
|
sudo=""
|
|
dir="$dir/$LOGNAME"
|
|
fi
|
|
echo "Checking $dir..."
|
|
$sudo find $dir -name TRASH | while read trash; do
|
|
if [[ "$trash" != "" && `$sudo ls -a $trash` ]]; then
|
|
echo "Found $trash:"
|
|
$sudo du $du_params $trash | sort -h
|
|
if [[ "$clean" == "Y" ]]; then
|
|
echo "Cleaning trash..."
|
|
$sudo sh -c "cd $trash; rm -rfv ..?* .[!.]* *"
|
|
fi
|
|
fi
|
|
done
|
|
$sudo find $dir $maxdepth -name "*"Trash"*" | while read trash; do
|
|
if [[ "$trash" != "" && `$sudo ls -a $trash` ]]; then
|
|
echo "Found $trash:"
|
|
$sudo du $du_params $trash | sort -h
|
|
if [[ "$clean" == "Y" ]]; then
|
|
echo "Cleaning trash..."
|
|
$sudo sh -c "cd $trash; rm -rfv ..?* .[!.]* *"
|
|
fi
|
|
fi
|
|
done
|
|
done
|
|
if [[ "$network" == "Y" ]]; then
|
|
function network_to_check {
|
|
find /mnt -maxdepth 1 -mindepth 1
|
|
}
|
|
network_to_check | while read dir; do
|
|
echo "Checking $dir..."
|
|
sudo find $dir -name TRASH | while read trash; do
|
|
if [[ "$trash" != "" && `sudo ls -a $trash` ]]; then
|
|
echo "Found $trash:"
|
|
sudo du $du_params $trash | sort -h
|
|
if [[ "$clean" == "Y" ]]; then
|
|
echo "Cleaning trash..."
|
|
sudo sh -c "cd $trash; rm -rfv ..?* .[!.]* *"
|
|
fi
|
|
fi
|
|
done
|
|
sudo find $dir -name .Trash"*" | while read trash; do
|
|
if [[ "$trash" != "" && `sudo ls -a $trash` ]]; then
|
|
echo "Found $trash:"
|
|
sudo du $du_params $trash | sort -h
|
|
if [[ "$clean" == "Y" ]]; then
|
|
echo "Cleaning trash..."
|
|
sudo sh -c "cd $trash; rm -rfv ..?* .[!.]* *"
|
|
fi
|
|
fi
|
|
done
|
|
done
|
|
fi
|
|
echo "Checking but not cleaning /var/mail..."
|
|
du -ha /var/mail | sort -h
|
|
if [[ $clean == "Y" ]]; then
|
|
clean-trashed "~/"
|
|
fi
|
|
return 0
|
|
}
|
|
alias check_trash="check-trash"
|
|
alias_clean_trash: alias clean-trash='check-trash --clean'
|
|
alias_trash_check: alias trash-check='check-trash'
|
|
alias_trash_clean: alias trash-clean='trash-check --clean'
|
|
alias_clean_dir: |
|
|
function clean-dir() {
|
|
sudo du -hs
|
|
clean_dir="`date '+%Y%m%d_%H%M%S'`_CLEANED"
|
|
trash_dir="$HOME/TRASH/$clean_dir"
|
|
curr_dir="`pwd`"
|
|
mkdir -pv "$trash_dir"
|
|
echo "$curr_dir is being cleaned at `date`." | tee "$trash_dir"/INFO.txt
|
|
mv -v ..?* .[!.]* * "$trash_dir"/ | tee -a "$trash_dir"/INFO.txt
|
|
sudo du -hs
|
|
}
|
|
function_clean: |
|
|
function clean() {
|
|
clean-trash
|
|
clean-code
|
|
clean-backups
|
|
}
|
|
function_flatpak_usage: |
|
|
function flatpak-usage() {
|
|
flatpak list --columns=application | while read app; do
|
|
size=`flatpak info -s $app 2>/dev/null`
|
|
if [[ ! -z $size ]]; then
|
|
mb=$(( size / (1000*1000) ))
|
|
echo "${mb} MB, $size Bytes, $app"
|
|
fi
|
|
done | sort -n
|
|
}
|
|
alias flatpak-info="flatpak-usage"
|
|
alias flatpak-space="flatpak-usage"
|
|
alias flatpak-size="flatpak-usage"
|
|
alias flatpak-sizes="flatpak-usage"
|
|
function_flatpak_purge: |
|
|
function flatpak-purge() {
|
|
flatpak remove --all --delete-data &&
|
|
flatpak repair &&
|
|
echo -n "Finished purging all Flatpak apps. " &&
|
|
echo "Executable may still need uninstalled." &&
|
|
return
|
|
echo "ERROR: Something went wrong while removing Flatpak apps!" >&2
|
|
}
|
|
alias_vim: alias vi=vim
|
|
alias_here: alias here='ls -alh `pwd`/*'
|
|
function_docker_reload: |
|
|
function docker-reload() {
|
|
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
|
|
cat <<- EOF
|
|
Usage: docker-reload [container_name]
|
|
Providing the container name starts a log follow after the command.
|
|
A reload is characterized by a DOWN, BUILD, and UP.
|
|
EOF
|
|
return 0
|
|
fi
|
|
|
|
docker compose down &&
|
|
docker compose build &&
|
|
docker compose up -d
|
|
|
|
if [[ -n "$1" ]]; then
|
|
echo "Following logs of '$1':"
|
|
docker logs -f $1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
function_docker_update: |
|
|
function docker-update() {
|
|
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
|
|
cat <<- EOF
|
|
Usage: docker-update [container_name]
|
|
Providing the container name starts a log follow after the command.
|
|
An update is characterized by a DOWN, PULL, BUILD, and UP.
|
|
EOF
|
|
return 0
|
|
fi
|
|
|
|
docker compose down &&
|
|
docker compose pull &&
|
|
docker compose build &&
|
|
docker compose up -d
|
|
|
|
if [[ -n "$1" ]]; then
|
|
echo "Following logs of '$1':"
|
|
docker logs -f $1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
function_docker_upgrade: |
|
|
function docker-upgrade() {
|
|
# Wrapper for a full-scale upgrade and log view of a container.
|
|
|
|
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
|
|
cat <<- EOF
|
|
Usage: docker-upgrade [container_name]
|
|
Providing the container name starts a log follow after the command.
|
|
An upgrade is characterized by a DOWN, PULL, BUILD, and UP.
|
|
EOF
|
|
return 0
|
|
fi
|
|
|
|
# Parameters:
|
|
# 1) Container ID or Container Name, as seen in 'docker ps' command.
|
|
container=$1
|
|
if [[ -z $container ]]; then
|
|
echo "ERROR: Container name or ID is required." >&2
|
|
return;
|
|
fi
|
|
if [[ -n $2 ]]; then
|
|
echo "ERROR: A second parameter is not expected, aborting." >&2
|
|
return;
|
|
fi
|
|
# Ensure the container exists. Should be found even if stopped.
|
|
exists=`docker ps | grep -c $container`
|
|
if [[ $exists != "1" ]]; then
|
|
echo "ERROR: Container '$container' was not found." >&2
|
|
echo "Please choose from the available list:"
|
|
docker ps
|
|
return;
|
|
fi
|
|
echo "*** Going Down ***" &&
|
|
docker compose down &&
|
|
echo "*** Upgrading Images ***" &&
|
|
docker compose pull &&
|
|
echo "*** Building Containers ***" &&
|
|
docker compose build &&
|
|
echo "*** Starting Daemons ***" &&
|
|
docker compose up -d &&
|
|
echo "*** Following Log ***" &&
|
|
echo "Press ^C to escape." &&
|
|
docker logs -f $container
|
|
|
|
return 0
|
|
}
|
|
function_docker_restart: |
|
|
function docker-restart() {
|
|
if [[ "$1" == "-h" || "$1" == "--help" ]]; then
|
|
cat <<- EOF
|
|
Usage: docker-restart [container_name]
|
|
Providing the container name starts a log follow after the command.
|
|
A restart is characterized by a DOWN and UP.
|
|
EOF
|
|
return 0
|
|
fi
|
|
|
|
docker compose down &&
|
|
docker compose up -d
|
|
|
|
if [[ -n "$1" ]]; then
|
|
echo "Following logs of '$1':"
|
|
docker logs -f $1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
alias_code_check: |
|
|
alias code-check='
|
|
echo "Checking ~/Code directory for git changes."
|
|
ls -d ~/Code/* | while read project; do
|
|
if [[ ! -d $project ]]; then
|
|
continue
|
|
fi
|
|
echo -e "\n*** `basename $project` ***"
|
|
cd $project
|
|
if [[ -d .git ]]; then
|
|
git ls-remote --exit-code --heads origin dev
|
|
dev_exists="$?"
|
|
if [[ "$dev_exists" == 0 ]]; then
|
|
git switch dev
|
|
elif [[ "$dev_exists" == 2 ]]; then
|
|
git switch main
|
|
else
|
|
echo "ERROR: Unknown status for dev_exists, '$dev_exists'."
|
|
continue
|
|
fi
|
|
git pull
|
|
git push
|
|
else
|
|
echo "Not a Git project, skipping!"
|
|
fi
|
|
done
|
|
echo -e "\nDone!"
|
|
'
|
|
alias code-sync='code-check'
|
|
alias_code_reset: |
|
|
alias code-reset='
|
|
ls -d ~/Code/* | while read project
|
|
do echo "*** `basename $project` ***"
|
|
cd $project
|
|
git stash
|
|
git switch main
|
|
git pull
|
|
git branch -D dev
|
|
git checkout dev
|
|
done
|
|
'
|
|
function_code_reseed: |
|
|
function git_projects_to_sync {
|
|
# Projects should be followed by the current development branch name.
|
|
cat <<- EOF
|
|
env-ansible dev
|
|
env-docker dev
|
|
env-termux dev
|
|
env-obtainium-hyperling dev
|
|
nodejs-website dev
|
|
ebook-health-protocol dev
|
|
ebook-freedom-flyer dev
|
|
ebook-technology-alternatives dev
|
|
ebook-narcissism-healing dev
|
|
ebook-forest-howto dev
|
|
ebook-template main
|
|
flutter-expense-tracker dev
|
|
flutter-social-traveler-app dev
|
|
nodejs-social-traveler-server dev
|
|
misc-spare-change main
|
|
flutter-buddy-website dev
|
|
flutter-sunset-alarm dev
|
|
android-infinite-timer dev
|
|
android-carb-up dev
|
|
android-hypergames dev
|
|
android-45-minute-rule dev
|
|
android-tictactoe dev
|
|
hugo-jackanope dev
|
|
hugo-website dev
|
|
EOF
|
|
}
|
|
function code-reseed {
|
|
# Unseed current projects.
|
|
echo -e "\n*** Move old projects to TRASH ***"
|
|
unseed_dir="$HOME/TRASH/`date +%Y%m%d_%H%M%S`_UnseededCodeProjects"
|
|
mkdir -pv "$unseed_dir"
|
|
mv -v ~/Code/* "$unseed_dir"/ 2>/dev/null
|
|
|
|
# Git repo information.
|
|
git_repo_ssh={{ git_repo_ssh }}
|
|
git_main_project={{ git_project }}
|
|
git_repo_ssh_basename=${git_repo_ssh//$git_main_project/}
|
|
|
|
# Loop over project list.
|
|
git_projects_to_sync | while read git_project git_branch; do
|
|
echo -e "\n*** $git_project ***"
|
|
|
|
# Project folder manipulation.
|
|
dest_folder="$git_project"
|
|
if [[ "$dest_folder" == "flutter-"* ]]; then
|
|
echo "Using '_' for Flutter Project"
|
|
dest_folder="${dest_folder//-/_}"
|
|
fi
|
|
|
|
# Download of the project.
|
|
git clone ${git_repo_ssh_basename}${git_project} \
|
|
--branch $git_branch ~/Code/$dest_folder
|
|
done
|
|
}
|
|
function_clean_filenames: |
|
|
function clean-filenames() {
|
|
# Must provide the directory you'd like to clean all the filenames in.
|
|
# Otherwise defaults to the current directory and all of its files.
|
|
dir="$1"
|
|
if [[ -z $dir ]]; then
|
|
echo -e "Using current directory."
|
|
dir="."
|
|
fi
|
|
ls "$dir" | while read file; do
|
|
clean="${file//IMG/}"
|
|
clean="${clean//_/}"
|
|
clean="${clean//-/}"
|
|
clean="${clean// /}"
|
|
if [[ "$file" != "$clean" && ! -d "$file" ]]; then
|
|
mv -v "$dir"/"$file" "$dir"/"$clean"
|
|
fi
|
|
done
|
|
}
|
|
function_clean_filenames_tree: |
|
|
function clean-filenames-tree() {
|
|
find ./ | while read folder; do
|
|
if [[ -d "$folder" ]]; then
|
|
echo -e "\n*** Checking '$folder' ***"
|
|
clean-filenames "$folder"
|
|
fi
|
|
done
|
|
echo -e "\nDone!\n"
|
|
}
|
|
alias_clone: |
|
|
alias clone="rsync -auPhz --delete --exclude '.gradle' --exclude 'app/build'"
|
|
export_hyperling: |
|
|
export HYPERLING6="2a07:e03:3:80::1"
|
|
export HYPERLING4="185.130.47.173"
|
|
export HYPERLING="$HYPERLING4"
|
|
source_docker_env: |
|
|
DOCKER_SOURCE="/opt/Docker/source.env"
|
|
if [[ -e $DOCKER_SOURCE && $LOGNAME == "root" ]]; then
|
|
source $DOCKER_SOURCE
|
|
fi
|
|
alias_scan: |
|
|
alias scan="nmap -A -p- --script=vuln"
|
|
alias_prod: |
|
|
alias prod="ssh -p {{ prod_port }} {{ prod_user }}@{{ prod_host }}"
|
|
function_clean_code: |
|
|
function clean-code {
|
|
echo -e "******* Android *******\n*** Build Caches ***"
|
|
find ~/Code/android-*/app -maxdepth 1 -type d -name "build" \
|
|
-exec du -hs {} \; -exec rm -rf {} \;
|
|
echo -e "\n*** Gradle Caches ***"
|
|
find ~/Code/android-*/ -maxdepth 1 -type d -name ".gradle" \
|
|
-exec du -hs {} \; -exec rm -rf {} \;
|
|
|
|
echo -e "******* Flutter *******"
|
|
ls ~/Code | grep flutter | while read project; do
|
|
cd ~/Code/$project
|
|
pwd
|
|
flutter clean
|
|
echo -e "\n"
|
|
done
|
|
cd
|
|
|
|
echo -e "******* PDFs *******"
|
|
find ~/Code/ebook-* -name "*.pdf" -exec du -h {} \; -delete | sort -h
|
|
|
|
echo -e "\n*** Done! ***"
|
|
}
|
|
alias code-clean="clean-code"
|
|
alias_kill_battery: |
|
|
alias kill-battery="stress -c 1k"
|
|
alias waste-battery="kill-battery"
|
|
alias battery-killer="kill-battery"
|
|
alias battery-waster="kill-battery"
|
|
alias_kill_system: |
|
|
alias kill-system="stress -c 1k -i 1k -m 1k -d 1k"
|
|
alias die="kill-system"
|
|
alias lockup="kill-system"
|
|
alias freeze="kill-system"
|
|
alias system-killer="kill-system"
|
|
function_update_sdks: |
|
|
if [[ "$workstation" == "true" && "$coding" == "true" ]]; then
|
|
function update-sdks {
|
|
echo -e "******* Update SDKs *******\n*** Android - START ***"
|
|
yes | sdkmanager --update
|
|
yes | sdkmanager --licenses
|
|
echo -ne "*** Android - END ***"
|
|
|
|
echo -e "\n*** Flutter - START ***"
|
|
flutter upgrade
|
|
yes | flutter doctor --android-licenses
|
|
echo -ne "*** Flutter - END ***"
|
|
|
|
echo -e "\n******* Done! *******"
|
|
}
|
|
alias update-sdk="update-sdks"
|
|
alias sdk-update="update-sdks"
|
|
alias sdk-updater="update-sdks"
|
|
fi
|
|
function_ansible_vars: |
|
|
function ansible-var-list {
|
|
cat << EOF
|
|
provision
|
|
battery
|
|
workstation
|
|
coding
|
|
editing
|
|
gaming
|
|
mobile
|
|
server
|
|
domain
|
|
EOF
|
|
}
|
|
function ansible-vars {
|
|
ansible-var-list | while read var; do
|
|
echo "$var = ${!var}"
|
|
done
|
|
}
|
|
alias_permission_commands: |
|
|
alias chown='chown -c'
|
|
alias chmod='chmod -c'
|
|
alias_iftop: |
|
|
alias iftop='sudo iftop'
|
|
alias_ls: |
|
|
alias l='ls'
|
|
alias ll='ls -alh'
|
|
alias lh='ls -ash'
|
|
alias_progs: |
|
|
alias progs='ps -ef'
|
|
alias_nethogs: |
|
|
alias nethogs='sudo nethogs'
|
|
alias_ansible_facts: |
|
|
alias ansible-facts='ansible localhost -m setup --connection=local'
|
|
function_now: |
|
|
function now {
|
|
date "+%Y%m%d-%H%M%S"
|
|
}
|
|
function today {
|
|
date "+%Y%m%d"
|
|
}
|
|
function_backup: |
|
|
export BACKUP_DIR="/srv/backup"
|
|
function backup {
|
|
/usr/local/bin/backup_system.sh
|
|
}
|
|
alias backup-system="backup"
|
|
alias system-backup="backup"
|
|
alias check-backups="ll $BACKUP_DIR"
|
|
function clean-backup {
|
|
sh -c "rm -rfv $BACKUP_DIR/*"
|
|
}
|
|
alias clean-backups="clean-backup"
|
|
function_pull_prod_backups: |
|
|
export DOCKER="Docker"
|
|
export SYSTEM="System"
|
|
function pull_prod_backup {
|
|
if [[ -z "$1" || ("$1" != "$DOCKER" && "$1" != "$SYSTEM") ]]; then
|
|
echo "ERROR: Parameter 1 not correct, expecting '$DOCKER' or '$SYSTEM'."
|
|
return 1
|
|
fi
|
|
backup_type="$1"
|
|
echo "Looking for '*${backup_type}*.zip'"
|
|
ls -lh *${backup_type}*.zip 2>/dev/null
|
|
status="$?"
|
|
if [[ "$status" == "0" ]]; then
|
|
echo "File already downloaded, skipping."
|
|
return 0
|
|
else
|
|
echo "File still needed, downloading to local tmp/."
|
|
fi
|
|
mkdir -pv tmp
|
|
scp -P {{ prod_port }} \
|
|
{{ prod_user }}@{{ prod_host }}:"$BACKUP_DIR/*${backup_type}*.zip" \
|
|
tmp/
|
|
if [[ "$?" == "0" ]]; then
|
|
echo "Succeeded!"
|
|
mv -v tmp/*.zip ./
|
|
rmdir -v tmp
|
|
else
|
|
echo "Failed!"
|
|
mv tmp ~/TRASH/"tmp_`now`"
|
|
fi
|
|
}
|
|
function pull_prod_backups {
|
|
dir="ProductionBackups-Pulled`today`"
|
|
mkdir -pv "$dir"
|
|
cd "$dir"
|
|
pull_prod_backup "$DOCKER"
|
|
pull_prod_backup "$SYSTEM"
|
|
du -h *.zip | sort -h
|
|
status="$?"
|
|
cd ..
|
|
if [[ "$status" != 0 ]]; then
|
|
echo "Failed to find zip files, removing folder."
|
|
rmdir -v "$dir"
|
|
return 1
|
|
fi
|
|
echo "Done!"
|
|
}
|
|
alias pull-prod-backups="pull_prod_backups"
|
|
alias pull-backups="pull_prod_backups"
|
|
alias prod-backups="pull_prod_backups"
|
|
alias prod-backup="pull_prod_backups"
|
|
alias pull-prod="pull_prod_backups"
|
|
alias prod-pull="pull_prod_backups"
|
|
function_log: |
|
|
function log {
|
|
echo -e "$1"
|
|
}
|
|
function blog {
|
|
echo -e "\n\n$1\n\n"
|
|
}
|
|
function_debian_upgrade: |
|
|
function debian-upgrade {
|
|
typeset -l OLD NEW
|
|
OLD="$1"
|
|
NEW="$2"
|
|
blog "*** Upgrading from '$OLD' to '$NEW' ***"
|
|
if [[ -z "$OLD" || -z "$NEW" ]]; then
|
|
echo -n "ERROR: Please pass the OLD and NEW version names"
|
|
echo ", such as 'debian-upgrade bookworm trixie'. "
|
|
return 1
|
|
fi
|
|
|
|
blog "*** Running 'backup' before starting upgrade. ***"
|
|
sleep 1
|
|
|
|
backup
|
|
|
|
blog "*** Listing the current apt listing for '$OLD' ***"
|
|
sudo grep "$OLD" /etc/apt/sources.list /etc/apt/sources.list.d/*
|
|
|
|
echo -en "\nAre these the entries you'd like changed to '$NEW'? (y/N) "
|
|
typeset -u confirm_change
|
|
read confirm_change
|
|
|
|
if [[ -z "$confirm_change" || "$confirm_change" == "N"* ]]; then
|
|
blog "*** Aborting upgrade, change rejected. ***"
|
|
return 1
|
|
fi
|
|
unset confirm_change
|
|
|
|
blog "*** Continuing with upgrade. ***"
|
|
sudo sed -i "s/$OLD/$NEW/g" /etc/apt/sources.list
|
|
find /etc/apt/sources.list.d/ -name "*.list" \
|
|
-exec sudo sed -i "s/$OLD/$NEW/g" {} \;
|
|
find /etc/apt/sources.list.d/ -name "*.sources" \
|
|
-exec sudo sed -i "s/$OLD/$NEW/g" {} \;
|
|
|
|
sudo grep $OLD /etc/apt/sources.list /etc/apt/sources.list.d/*.{list,sources}
|
|
sudo grep $NEW /etc/apt/sources.list /etc/apt/sources.list.d/*.{list,sources}
|
|
|
|
echo -en "\nDo the source files look correct? (y/N) "
|
|
typeset -u confirm_correct
|
|
read confirm_correct
|
|
|
|
if [[ -z "$confirm_correct" || "$confirm_correct" == "N"* ]]; then
|
|
blog "*** Aborting upgrade, confirmation rejected. ***"
|
|
return 1
|
|
fi
|
|
unset confirm_correct
|
|
|
|
blog "*** Starting the upgrade. ***"
|
|
sleep 1
|
|
|
|
sudo apt update
|
|
sudo apt upgrade --without-new-pkgs
|
|
|
|
blog -e "*** Upgrades complete, now add new packages. ***"
|
|
sleep 1
|
|
sudo apt full-upgrade
|
|
|
|
blog "*** New packages complete, clean apt files. ***"
|
|
sleep 1
|
|
sudo apt autoremove --purge
|
|
sudo apt clean
|
|
|
|
blog "*** All done! '$OLD' is now '$NEW'. Please reboot. ***"
|
|
sleep 1
|
|
unset OLD NEW
|
|
}
|
|
alias upgrade-debian="debian-upgrade"
|
|
function_ebook_convert: |
|
|
# Regenerate all eBook projects at once.
|
|
function ebook-convert {
|
|
find ~/Code/ebook-* -name "*.pdf" -print -delete
|
|
find ~/Code/ebook-* -name convert.sh -print -exec bash "{}" \;
|
|
}
|
|
alias ebooks="ebook-convert"
|
|
alias convert="ebook-convert"
|
|
alias_sudo: |
|
|
# Allows for alias expansions when using sudo, such as doing "sudo ll".
|
|
alias sudo="sudo "
|
|
function_load_branch: |
|
|
# Change a branch to point at another.
|
|
function load-branch {
|
|
rcvr="$1" # branch which we want to modify
|
|
base="$2" # branch with the changes we want
|
|
|
|
if [[ "$rcvr" == "main" ]]; then
|
|
echo "*** ERROR: Are you nuts, fool!? Not main! Do it manually! ***"
|
|
exit 1
|
|
fi
|
|
|
|
if [[ -z "$base" ]]; then
|
|
if [[ "$rcvr" == "prod" ]]; then
|
|
base="stage"
|
|
elif [[ "$rcvr" == "stage" ]]; then
|
|
base="dev"
|
|
else
|
|
echo "* Unsure which branch to use for '$rcvr'. Please specify."
|
|
exit 1
|
|
fi
|
|
echo "* Base was not specified, using '$base' for '$rcvr'."
|
|
else
|
|
echo "* Requested pointing '$rcvr' branch to '$base'."
|
|
fi
|
|
|
|
echo -e "\n* Ensuring we are on base branch '$base'." &&
|
|
git switch "$base" &&
|
|
echo -e "\n* Changing pointer for '$rcvr' to '$base'." &&
|
|
git branch -f "$rcvr" "$base" &&
|
|
#echo -e "\n* Switching to branch '$rcvr'." &&
|
|
#git switch "$rcvr" &&
|
|
echo -e "\n* Forcing push on branch '$rcvr'." &&
|
|
git push --force --set-upstream origin "$rcvr" &&
|
|
echo -e "\n* Done! Displaying list of remote branches." &&
|
|
git ls-remote --heads | sort
|
|
|
|
if [[ "$base" != "dev" ]]; then
|
|
echo -e "\n* Checking if a dev branch exists."
|
|
git ls-remote --exit-code --heads origin dev
|
|
dev_exists="$?"
|
|
if [[ "$dev_exists" == 0 ]]; then
|
|
echo -e "\n* Switching back to dev."
|
|
git switch dev
|
|
elif [[ "$dev_exists" == 2 ]]; then
|
|
echo -e "\n* Switching back to main."
|
|
git switch main
|
|
else
|
|
echo "*** ERROR: Unknown status for dev_exists, '$dev_exists'. ***"
|
|
fi
|
|
fi
|
|
|
|
echo -e "\n* Verifying which branch we're on."
|
|
git branch
|
|
}
|
|
alias load-prod="load-branch prod"
|
|
alias load-stage="load-branch stage"
|
|
alias rollback-prod="load-branch prod main"
|
|
alias rollback-stage="load-branch stage prod"
|
|
alias rollback-dev="load-branch dev stage"
|
|
alias reset-prod="load-branch prod main"
|
|
alias reset-stage="load-branch stage main"
|
|
alias reset-dev="load-branch dev main"
|
|
alias_reload_bash: |
|
|
alias reload-bash="source ~/.bashrc"
|
|
alias bash-reload="reload-bash"
|
|
alias shell-reload="reload-bash"
|
|
alias reload-shell="reload-bash"
|
|
alias reload="reload-bash"
|
|
|
|
- name: General | Account Management | Users | Files | Common Variable
|
|
set_fact:
|
|
rc_common: |
|
|
# Fixes "command not found" when using aliases within functions.
|
|
shopt -s expand_aliases
|
|
|
|
# Variables for conditionals and quickly checking system setup.
|
|
typeset -l provision battery workstation coding editing gaming mobile server domain
|
|
export provision="{{ provision }}"
|
|
export battery="{{ battery }}"
|
|
export workstation="{{ workstation }}"
|
|
export coding="{{ coding }}"
|
|
export editing="{{ editing }}"
|
|
export gaming="{{ gaming }}"
|
|
export mobile="{{ mobile }}"
|
|
export server="{{ server }}"
|
|
export domain="{{ domain }}"
|
|
|
|
{{ export_path_additions }}
|
|
{{ alias_cp }}
|
|
{{ alias_mv }}
|
|
{{ alias_rm }}
|
|
{{ alias_clean_dir }}
|
|
{{ alias_clean_trash }}
|
|
{{ function_wttr }}
|
|
{{ export_PS1 }}
|
|
{{ alias_remount }}
|
|
{{ function_update }}
|
|
{{ function_update_firmware }}
|
|
{{ alias_sync }}
|
|
{{ export_editor }}
|
|
{{ init_aliases }}
|
|
{{ bye_aliases }}
|
|
{{ metasploit_aliases }}
|
|
{{ show_config_aliases }}
|
|
{{ edit_config_aliases }}
|
|
{{ function_clean_trashed }}
|
|
{{ function_check_trash }}
|
|
{{ function_clean }}
|
|
{{ function_flatpak_usage }}
|
|
{{ function_flatpak_purge }}
|
|
{{ alias_vim }}
|
|
{{ alias_here }}
|
|
{{ function_docker_reload }}
|
|
{{ function_docker_update }}
|
|
{{ function_docker_upgrade }}
|
|
{{ function_docker_restart }}
|
|
{{ alias_code_check }}
|
|
{{ alias_code_reset }}
|
|
{{ function_code_reseed }}
|
|
{{ function_clean_filenames }}
|
|
{{ function_clean_filenames_tree }}
|
|
{{ alias_clone }}
|
|
{{ export_hyperling }}
|
|
{{ source_docker_env }}
|
|
{{ alias_scan }}
|
|
{{ alias_prod }}
|
|
{{ function_clean_code }}
|
|
{{ alias_kill_battery }}
|
|
{{ alias_kill_system }}
|
|
{{ function_update_sdks }}
|
|
{{ function_ansible_vars }}
|
|
{{ alias_permission_commands }}
|
|
{{ alias_iftop }}
|
|
{{ alias_ls }}
|
|
{{ alias_progs }}
|
|
{{ alias_nethogs }}
|
|
{{ alias_ansible_facts }}
|
|
{{ function_now }}
|
|
{{ function_backup }}
|
|
{{ function_pull_prod_backups }}
|
|
{{ function_log }}
|
|
{{ function_debian_upgrade }}
|
|
{{ function_ebook_convert }}
|
|
{{ alias_sudo }}
|
|
{{ function_load_branch }}
|
|
{{ alias_reload_bash }}
|
|
|
|
- name: General | Account Management | Users | Files | .bashrc
|
|
blockinfile:
|
|
path: "{{ item }}/.bashrc"
|
|
block: |
|
|
{{ rc_common }}
|
|
[[ $(whoami) != "root" ]] &&
|
|
echo "`date` - Ansible .bashrc loaded successfully!"
|
|
marker: '# {mark} MANAGED BY ANSIBLE | Aliases'
|
|
state: present
|
|
create: yes
|
|
backup: yes
|
|
loop:
|
|
- "{{ user_root.home }}"
|
|
- "{{ user_user.home }}"
|
|
ignore_errors: yes
|
|
when: user_root.home != "" and user_user.home != ""
|
|
|
|
- name: General | Account Management | Users | Files | .zshrc
|
|
blockinfile:
|
|
path: "{{ item }}/.zshrc"
|
|
block: |
|
|
{{ rc_common }}
|
|
[[ $(whoami) != "root" ]] &&
|
|
echo "`date` - Ansible .zshrc loaded successfully!"
|
|
marker: '# {mark} MANAGED BY ANSIBLE | Aliases'
|
|
state: present
|
|
create: yes
|
|
backup: yes
|
|
loop:
|
|
- "{{ user_root.home }}"
|
|
- "{{ user_user.home }}"
|
|
ignore_errors: yes
|
|
when: user_root.home != "" and user_user.home != ""
|
|
|
|
- name: General | Account Management | Users | Files | .vimrc
|
|
blockinfile:
|
|
path: "{{ item }}/.vimrc"
|
|
block: |
|
|
" Turn off syntax, flashy lights, etc. Make VIM into a basic editor.
|
|
syntax off
|
|
set nohlsearch
|
|
set noautoindent noautowrite noshowmatch wrapmargin=0 report=1 ts=3
|
|
set ignorecase
|
|
|
|
" Turn off auto-commenting.
|
|
autocmd Filetype * set fo-=c fo-=r fo-=o
|
|
|
|
" qq shortcut for immediately exiting all files without saving.
|
|
nnoremap qq :qa!<cr>
|
|
marker: '" {mark} MANAGED BY ANSIBLE | vimrc'
|
|
state: present
|
|
create: yes
|
|
backup: yes
|
|
loop:
|
|
- "{{ user_root.home }}"
|
|
- "{{ user_user.home }}"
|
|
ignore_errors: yes
|
|
when: user_root.home != "" and user_user.home != ""
|
|
|
|
- name: General | Account Management | Users | Files | Ownership
|
|
file:
|
|
path: "{{ user_user.home }}/{{ item }}"
|
|
owner: "{{ user }}"
|
|
mode: '0755'
|
|
loop:
|
|
- .bashrc
|
|
- .zshrc
|
|
- .vimrc
|