dotfiles

quik (7378B)

---

 #!/bin/sh
 #
 # quik - mispelt script for deploying vps' quikly
 
 # Copyright (c) 2020 wfnintr (gopher://wfnintr.net)
 # Copyright (c) 2020 haydenh <hayden@haydenvh.com> (gopher://haydenvh.com)
 #
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 #
 # This work is free. You can redistribute it and/or modify it under the      
 # terms of the Do What The Fuck You Want To Public License, Version 2,       
 # as published by Sam Hocevar. See http://www.wtfpl.net/ for more details.   
 
 echo(){
 	printf "%s\n" "$@"
 }
 
 usage(){
 	printf "quik is a script for deploying vps' quickly\n\nusage\n"
 	printf "  quik <command>\n\n"
 	printf "available commands:\n"
 	printf "  auth\t\tauthenticate your digital ocean api key\n"
 	printf "  list\t\tlist options considering budget\n"
 	printf "  list -l\tlist all options\n"
 	printf "  distros\tshow all supported distros\n"
 	printf "  deploy\tdeploy instance\n"
 	printf "  ls\t\tshow all instances\n"
 	printf "  ls-run\tshow running instances\n"
 	printf "  rm\t\tremove instance\n"
 	printf "  rm-all\tremove all instances\n\n"
 	printf "examples:\n"
 	printf "  quik list -l\t\t\t\tlist all options\n" 
 	printf "  quik deploy 1gb 1 void-linux\t\tdeploy 1 instance running void linux\n"
 	printf "  quik deploy 1gb 10 debian-10-x64\tdeploy 10 instances running debian-10-x64\n" 
 	exit 1
 }
 
 findKey() {
 
         echo "$1" | grep -q '[[:alnum:]]' && {
                 ssh_key="$1"
                 return 0
         }
 
         ssh_key="$(find ~/.ssh/ -type f -print 2>/dev/null| grep .*.pub | head -n1)"
 
         echo "$ssh_key" | grep -q '[[:alnum:]]' && {
                 ssh_key="$ssh_key"
                 return 0
         }
 	
 	[ -z "$ssh_key" ] && printf "no key provided\n" && exit 1 
 }
 
 
 doctl_auth(){
 	doctl auth init 2>&1 | grep -q 'Using token' 2>&1 > /dev/null && {
 		return 0 # access token already found
 	}
 
 	echo "$1" | grep -q '[[:alnum:]]' && {
 		KEY="$1"
 	} || {
 		printf 'Enter your API V2 access token: '
 		read "KEY" > /dev/null
 	}
 
 	doctl auth init -t "$KEY" 2>&1 > /dev/null
 
 	echo "$?" | grep -q '0' && {
 		mkdir -p ""${XDG_CONFIG_HOME:-$HOME/.config}/quik""
 		echo "$KEY" > ""${XDG_CONFIG_HOME:-$HOME/.config}"/quik/api"
 		echo "Access token validated!"
 	} || {
 		echo "Access token invalid"
 		return 1
 	}
 
 }
 
 list(){
 	list=$(doctl compute size list)
 	[ "$1" = "-l" ] && echo "$list" && exit
 	[ -z $1 ] || [ -z $2 ] && {
 		printf "quik list - shows all available options, considering budget\n\nusage:\n"
 		printf "  $pname list <max cost> <hours> <number of instances>\n\n"
 		printf "examples:\n  $pname list -l\t\tlist all options\n"
 		printf "  $pname list 1 1 1\tonly show options that fit a budget of 1/USD, 1/hr 1/instance\n"
 		exit 1
 	}
 	n=${3:-1}
 
 	echo "$list" | awk -v "m=$1" -v "h=$2" -v "i=$n" '
 		BEGIN {
 			print "ID/Name	Memory	vCPUs	Cost (total)"
 		}
 
 		/[[:space:]][0-9]/ && (i * ($6 * h)) < m {
 			print $1 "\t" $2 "\t" $3 "\t" (i * ($6 * h))
 		}
 	' | column -t -s "	"
 }
 
 list_all(){
 	doctl compute droplet list --format Status,Name,Region,PublicIPv4,Memory,VCPUs,Disk
 }
 
 listrunning(){
 	doctl compute droplet list --format Status,Name,Region,PublicIPv4,Memory,VCPUs,Disk | awk '
 		BEGIN {
 			OFS="\t"
 			print "Status\tName\tRegion\tIPv4\tMem\tvCPUS\tDisk"
 		}
 
 		$1 == "active" {print $1, $2, $3, $4, $5, $6, $7}' | column -t -s "	"
 }
 
 list_distros(){
 	printf 'quik can deploy any of the following distros:\n\n'
 	printf '  debian-10-x64\n  centos-7-x64\n  ubuntu-18-04-x64\n  void-linux\n\n'
 	printf 'example:\n'
 	printf '  quik deploy 1gb 1 debian-10-x64\n'
 	exit 0
 }
 
 deploy(){
 	[ "$1" = "darkvoid" ] && darkvoid # do not remove, testing drist playbook
 	[ -z "$1" ] || [ -z "$2" ] || [ -z "$3" ] && {
 		printf "quik deploy - deploy an instance, quickly\n\nusage:\n"
 		printf "  $pname deploy <size-slug> <number of instances> <distro> [/path/to/sshpubkey]\n"
 		exit 1
 	}
 	size_slug="$1"
 	instances=$2
 	list -l | awk '{if (NR != 1) {print $1}}' | grep -q "^"$size_slug"$" || {
 		list -l
 		exit
 	}
 
 
 	doctl_auth
 	echo "$?" | grep -q "1" && {
 		exit
 	}
 
 	printf 'importing your ssh key...\n'
 	findKey "$4"
 	doctl compute ssh-key import "$USER" --public-key-file "$ssh_key" > /dev/null 2>&1
 	ssh_key=$(doctl compute ssh-key list | grep "$USER" | awk '{print $3}')
 	printf "deploying %d instances of size %s...\n" "${instances:-1}" "$size_slug" # preferred: deploying num instances with 1vpcu, 1gb ram, 30gb hdd
         image_id=$(doctl compute image list --public | awk "/$3/"'{print $1}')
 	echo "$image_id" | grep -q '[[:alnum:]]' || {
 		list_distros
 		exit
 	}
 
 
 	for void in $(seq ${instances:-1})
 	do
 		(
 			name="$3-$(head -c 1000 /dev/urandom | tr -dc 'A-Za-z0-9' | head -n 1 | cut -zc-10)"
 			
 			# this is better but some regions are restricted
 			# region=${REGION:-$(doctl compute region ls --no-header | sort -R | head -n1 | awk '{print $1}')}
 			region=nyc1
 			
 			doctl compute droplet create "$name" --image "$image_id" --size "$size_slug" --region "$region" --ssh-keys "$ssh_key" 1>/dev/null
 			printf '\ncreating instance %s in region %s' "$name" "$region"
 		) &
 	done
 	sleep 5 #!was 20
 	printf '\n\n' && list_all # !was listrunning
 	printf "\n\nPlease wait a few moments before logging in, to allow the sshd(s) to start, and ssh key(s) to be copied over.\n"
 }	
 
 delete(){
         [ -z "$1" ] && {
 		printf "quik rm - remove an instance, quickly\n\n"
 		list_all
 		printf "\nusage:\n  $pname rm <name or ip> [name2 or ip2] ..."
 	}
 	for nameip in $@
 	do
 		name=$(doctl compute droplet ls --format Name,PublicIPv4 | awk "\$1 == \"$nameip\" || \$2 == \"$nameip\""' {print $1}')
 		[ "$name" != "" ] && doctl compute droplet d "$name" -f || echo "$(tput bold)error:$(tput sgr0) no droplet has name/ip: $nameip"
 	done
 }
 
 rmall(){
 	list=$(doctl compute droplet ls --format Name | awk '$1 != "Name"')
 	for droplet in $list
 	do
 		echo "Deleting $droplet..."
 		doctl compute droplet d "$droplet" -f &
 	done
 }
 
 # do not change, testing
 darkvoid() {
 	printf 'importing your ssh key...\n'
 	findKey $1
 	ssh_key=$(doctl compute ssh-key list | grep "$USER" | awk '{print $3}')
 	printf 'creating instance...\n'
 	image_id=$(doctl compute image list | awk '/darkvoid/{print $1}')
 	doctl compute droplet create "darkvoid" --wait --image "$image_id" --size "s-2vcpu-4gb" --region "nyc1" --ssh-keys "$ssh_key" 1>/dev/null
 	printf 'initializating...\n' && sleep 5 
 	ip=$(doctl compute droplet list --format Name,PublicIPv4 | awk '/darkvoid/{print $2}')
 	printf '+++execute+++\n' && sleep 10
 	ssh-keyscan "$ip" >> ~/.ssh/known_hosts
 	cd playbooks/common
 	printf 'SERVERS = void@%s' "$ip" > config.mk
 	make
 	make clean
 	cd -
 	cd playbooks/offensive
 	printf 'SERVERS = void@%s' "$ip" > config.mk
 	make
 	make clean
 }
 
 
 pname=$(basename $0)
 [ -z $1 ] && usage
 cmd="$1" && shift
 case "$cmd" in
 	list) list $@ ;;
 	-l) list -l;;
 	deploy) deploy $@ ;;
 	rm) delete $@ ;;
 	list-running|ls-run) listrunning ;;
 	ls) list_all ;;
 	rm-all) rmall ;;
 	auth) doctl_auth $@ ;;
 	distros) list_distros ;;
 	*) usage ;;
 esac