dockerfunc

#!/bin/bash
# bash wrappers for docker run commands
# refs:
# https://github.com/jfrazelle/dotfiles
# https://blog.jessfraz.com/post/docker-containers-on-the-desktop/



#
# container aliases
#

# aircraft communication addressing/reporting system
acarsdec(){
	del_stopped acarsdec

	docker run -d \
		--device=/dev/bus/usb \
		--name acarsdec \
		mitchtech/rpi-acarsdec -v -g 450 -r 0 130.025 131.550
}
# amazon alexa client
alexapi(){
	del_stopped alexapi

	docker run -d \
		--net host \
		-p 5000:5000 \
		--device /dev/snd \
		--device=/dev/bus/usb \
		--name alexapi \
		mitchtech/rpi-alexapi
}
# search for files within apt packages
apt_file(){
	docker run --rm -it \
		--name apt-file \
		mitchtech/rpi-apt-file
}
alias apt-file="apt_file"
# adb, fastboot
android-tools(){
	docker run --rm -it \
		--device=/dev/bus/usb \
		--name android-tools \
		mitchtech/rpi-android-tools
}
# arduino
arduino(){
	del_stopped arduino
	xhost +

	docker run -d \
		--device=/dev/bus/usb \
		-e DISPLAY=unix:0 \
		-v $PWD:/sketchbook \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		--name arduino \
		mitchtech/rpi-arduino
}
# beacon bluetooth low energy
# beacon(){}
# cli tool for bladerf sdr
bladerf-cli(){
	docker run -it --rm \
		--device=/dev/bus/usb \
		--name bladerf-cli \
		mitchtech/rpi-bladerf bladeRF-cli -i
}
# video and photo webcam capture
cheese(){
	del_stopped cheese

	docker run -d \
		-v /etc/localtime:/etc/localtime:ro \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		-e DISPLAY=unix$DISPLAY \
		-v $HOME/Pictures:/root/Pictures \
		--device /dev/video0 \
		--device /dev/snd \
		--device /dev/dri \
		--name cheese \
		mitchtech/rpi-cheese
}
# web browser
# chromium(){}
# movies via nzbs & torrents
couchpotato(){
	del_stopped couchpotato

	docker run -d \
		-v /etc/localtime:/etc/localtime:ro \
		-v $HOME/.sonarr:/config \
		-v $HOME/Downloads:/downloads \
		-v $HOME/movies:/movies \
		-p 5050:5050 \
		--restart=always \
		--name couchpotato \
		mitchtech/rpi-couchpotato
}
# ruby-based web dashboard
dashing(){
	del_stopped dashing

	docker run -d \
		-p 3030:3030 \
		--name dashing \
		mitchtech/rpi-dashing
}
# web interface for docker
dockerui(){
	del_stopped dockerui

	docker run -d \
		-p 9000:9000 \
		-v /var/run/docker.sock:/var/run/docker.sock \
		--name dockerui \
		hypriot/rpi-dockerui
}
# adsb decoder for rtl-sdr
dump1090(){
	del_stopped dump1090

	docker run -d \
		--net host \
		-p 8080:8080 \
		--device=/dev/bus/usb \
		--name dump1090 \
		mitchtech/rpi-dump1090 --interactive --net
}
# dns, dhcp, network infrastructure
dnsmasq(){
	del_stopped dnsmasq

	docker run -d \
		-p=53:53/udp
		-v .dnsmasq:/dnsmasq \
		--name dnsmasq \
		mitchtech/rpi-dnsmasq
}
# lightweight web brower
epiphany(){
	del_stopped epiphany
	xhost +

	docker run -d \
		--net host \
		-e DISPLAY=unix:0 \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		--name epiphany \
		mitchtech/rpi-epiphany "$@"
		# --privileged \
		# --restart=on-failure:5 \
}

# command line text-to-speech
festival(){
	del_stopped festival

	docker run --rm -d \
		--name festival \
		--device /dev/snd \
		mitchtech/rpi-festival \
		echo $@ | festival --tts
		#"echo" "$@" "|" "festival" "--tts"
}
# lightweight command line text-to-speech
flite(){
	del_stopped flite

	docker run --rm -d \
		--name festival \
		--device /dev/snd \
		mitchtech/rpi-flite \
		flite -t "$@"
}
# real-time adsb aircraft tracking
# flightaware(){}
# frequency show visual spectrum analyzer
freqshow(){
	docker run --rm -it \
		--privileged \
		--device=/dev/bus/usb \
		-v /var/run/docker.sock:/var/run/docker.sock \
		-e DISPLAY=172.17.42.1:0.0 \
		--name freqshow \
		mitchtech/rpi-freqshow
}
# google talk (xmpp) bot
# gtalkbot(){}
# node.js-based development environment
google-coder(){
	del_stopped google-coder

	docker run -d \
		-p 8080:8080 \
		--name google-coder \
		hypriot/rpi-google-coder
}
# gnuradio suite (osmocom, gqrx)
# gnuradio(){}
# gpio pin mode/state acess
# gpio(){
# 	docker run --rm -it \
# 		--cap-add SYS_RAWIO \
# 		--device /dev/mem \
# 		--name gpio \
# 		mitchtech/rpi-wiringpi "$@"
# }
# physical gmail notification daemon
# gpio-gmail(){}
# video and photo webcam capture
# guvcview(){}
# wifi access point
# hostapd(){}
# minimal busybox http server
httpd(){
	del_stopped httpd

	docker run -d \
		-p 80:80 \
		--name httpd \
		mitchtech/rpi-busybox-httpd
}
# debian firefox web brower
iceweasel(){
	del_stopped iceweasel
	xhost +

	docker run -d \
		--net host \
		-e DISPLAY=unix:0 \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		--name iceweasel \
		mitchtech/rpi-iceweasel "$@"
		# --privileged \
		# --restart=on-failure:5 \
}
# voice control platform
# jasper(){}
# gsm base station scanner
# kalibrate(){}
# kitematic docker gui
kitematic(){
	del_stopped kitematic

	docker run -d \
		--privileged \
		-v /var/run/docker.sock:/var/run/docker.sock \
		-e DISPLAY=172.17.42.1:0.0 \
		--name kitematic \
		mitchtech/rpi-kitematic
}
# kivy graphic info screen
kivy-infoscreen(){
	del_stopped kivy-infoscreen

	docker run -d \
		--privileged \
		-e DISPLAY=172.17.42.1:0.0 \
		--name kivy-infoscreen \
		mitchtech/rpi-kivy-infoscreen
}
# documents, spreadsheets, and slides
libreoffice(){
	xhost +
	del_stopped libreoffice

	docker run -d \
		-v /etc/localtime:/etc/localtime:ro \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		-e DISPLAY=unix$DISPLAY \
		-v $HOME/slides:/root/slides \
		--name libreoffice \
		mitchtech/rpi-libreoffice
		# -e GDK_SCALE \
		# -e GDK_DPI_SCALE \
}
# text-based web browser
lynx(){
	docker run --rm -it \
		--name lynx \
		mitchtech/rpi-lynx "$@"
}
# lightweight web brower
midori(){
	del_stopped midori
	xhost +

	docker run -d \
		--net host \
		-e DISPLAY=unix:0 \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		--name midori \
		mitchtech/rpi-midori "$@"
		# --privileged \
		# --restart=on-failure:5 \
}
# modulation/demodulation over rf
# minimodem(){}
# webcam and motion detection server
motion(){
	del_stopped motion

	docker run -d \
		--device=/dev/video0 \
	    -v $PWD/motion.conf:/etc/motion/motion.conf \
		-p 8080:8080 \
	    -p 8081:8081 \
		--name motion \
		mitchtech/rpi-motion
		# --privileged \
	    # -v ./motion:/var/lib/motion \
}
# digital transmission decoder/demodulator
# multimon-ng(){}
# text-based audio player
mpg123(){
	docker run --rm -it \
		--privileged \
		--device /dev/snd \
		-v $PWD/audio.mp3:/audio.mp3 \
		-v $PWD:/audio \
		--name mpg123 \
		mitchtech/rpi-mpg123
}
# adafruit neopixel leds
neopixel(){
	del_stopped neopixel

	docker run -d \
		--cap-add SYS_RAWIO \
		--device /dev/mem \
		--name neopixel \
		mitchtech/rpi-neopixel
}
# nintendo emulator
# nes(){}
# read and write tcp/ip connections
netcat(){
	docker run --rm -it \
		--net host \
		mitchtech/rpi-netcat "$@"
}
# web and reverse proxy server
nginx(){
	del_stopped nginx

	docker run -d \
		--restart always \
		-v $HOME/.nginx:/etc/nginx \
		--net host \
		--name nginx \
		mitchtech/rpi-nginx
}
# network map port scanner
nmap(){
	docker run --rm -it \
		--net host \
		mitchtech/rpi-nmap "$@"
}
# pdf viewer and presentation tool
okular(){
	del_stopped okular
	xhost +

	docker run -d \
		-e DISPLAY=unix:0 \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		--name okular \
		mitchtech/rpi-okular "$@"
		# --privileged \
}
# smartphone test farm
# openstf(){}
# computer vision
# opencv(){}
# text-based pandora music
pianobar(){
	docker run --rm -it \
		--privileged \
		--net host \
		--device /dev/snd \
		--name pianobar \
		mitchtech/rpi-pianobar
}
# fm radio transmit pifm(sound_file, frequency)
pifm(){
	del_stopped pifm
	local sound_file=$1
	local frequency=$2

	docker run -d \
		--cap-add SYS_RAWIO \
		--device /dev/mem \
		--name pifm \
		mitchtech/rpi-pifm ${sound_file} ${frequency}
}
# fm radio playlist broadcast
pirate-radio(){
	del_stopped pirate-radio

	docker run -d \
		--cap-add SYS_RAWIO \
		--device /dev/mem \
		-v $PWD/pirateradio.conf:/pirateradio/pirateradio.conf \
		-v $PWD:/pirateradio \
		--name pirate-radio \
		mitchtech/rpi-pirate-radio
}
# private web proxy
# privoxy(){}
# audio server and proxy
# pulseaudio(){}
# real-time database engine
rethinkdb(){
	del_stopped rethinkdb

	docker run -d \
		-p 8081:8081 \
		-p 28015:28015 \
		-p 29015:29015 \
		-v $PWD:/data \
		--name rethinkdb \
		mitchtech/rpi-rethinkdb
}
# radio transmitter for am, fm, ssb, sstv, fsq, vfo
rpitx(){
	del_stopped rpitx
	local sound_file=$1
	local frequency=$2

	docker run -d \
		--cap-add SYS_RAWIO \
		--device /dev/mem \
		--name rpitx \
		mitchtech/rpi-rpitx ${sound_file} ${frequency}
}
# rtl-sdr ais boat/ship tracking
rtl-ais(){
	del_stopped rtl-ais

	docker run -d \
		--device=/dev/bus/usb \
		--name rtl-ais \
		mitchtech/rpi-rtl-ais
}
# usenet binary downloader
sabnzbd(){
	del_stopped sabnzbd

	docker run -d \
		-v /etc/localtime:/etc/localtime:ro \
		-v $HOME/.sabnzbd:/config \
		-v $HOME/Downloads:/data \
		-p 8080:8080 \
		--restart=always \
		--name sabnzbd \
		mitchtech/rpi-sabnzbd
}
# pvr for usenet and bittorrent
sickbeard(){
	del_stopped sickbeard

	docker run -d \
		-v /etc/localtime:/etc/localtime:ro \
		-v $HOME/.sickbeard:/config \
		-v $HOME/Downloads:/data/downloads \
		-v $HOME/.nzb:/data/nzb \
		-v $HOME/.torrents:/data/torrents \
		-p 8081:8081 \
		--restart=always \
		--name sickbeard \
		mitchtech/rpi-sickbeard
}
# pvr for usenet and bittorrent
sonarr(){
	del_stopped sonarr

	docker run -d \
		-v /etc/localtime:/etc/localtime:ro \
		-v $HOME/.sonarr:/config \
		-v $HOME/Downloads:/downloads \
		-v $HOME/TV:/tv \
		-p 8080:8080 \
		--name sonarr \
		mitchtech/rpi-sonarr
}
# mouse and keyboard sharing
# synergy
# python-based web dashboard
tipboard(){
	del_stopped tipboard

	docker run -d \
		-p 7272:7272 \
		--name=tipboard \
		mitchtech/rpi-tipboard
		# -v $PWD/settings-local.py:/root/.tipboard/settings-local.py \
		# -v $PWD/layout_config.yaml:/root/.tipboard/layout_config.yaml \
}
# the onion router
# tor(){}
# web browser for tor
# torbrowser(){}
# instant messenger client for tor
# tormessenger(){}
# proxy on top of tor
# torproxy(){}
# bittorrent client
transmission(){
	del_stopped transmission

	docker run -d \
		-v /etc/localtime:/etc/localtime:ro \
		-v $HOME/.transmission:/config \
		-v $HOME/Downloads:/downloads \
		-p 9091:9091 \
		-p 51413:51413 \
		-p 51413:51413/udp \
		--name transmission \
		mitchtech/rpi-transmission
		# -v $HOME/Torrents:/transmission/download \
		# -v $HOME/.transmission:/transmission/config \
		# transmission -v pass -u user
}
# android test automation
uiautomator(){
	del_stopped uiautomator

	docker run -d \
		--privileged \
		-p 2222:2222 \
		-v /dev/bus/usb:/dev/bus/usb \
		-v /etc/localtime:/etc/localtime:ro \
		--name uiautomator \
		mitchtech/uiautomator
}
# android test automation x windows
uiautomatorx(){
	del_stopped uiautomator

	docker run -d \
		--privileged \
		-p 2222:2222 \
		-e DISPLAY=$DISPLAY \
		-v /dev/bus/usb:/dev/bus/usb \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		-v /etc/localtime:/etc/localtime:ro \
		--name uiautomator \
		mitchtech/uiautomator
}
# remote access and control
# vnc(){}
# web browser-based development environment
# webide(){}
# gpio, wiringpi, pyserial
wiringpi(){
	docker run --rm -it \
		--cap-add SYS_RAWIO \
		--device /dev/mem \
		--name wiringpi \
		mitchtech/rpi-wiringpi
}
# x11-apps demo for basic docker x11 setup
xeyes(){
	del_stopped xeyes

	docker run -d \
		--privileged \
		-e DISPLAY=$DISPLAY \
		-v /tmp/.X11-unix:/tmp/.X11-unix \
		--name xeyes \
		mitchtech/x11-apps
}
# sdr base transciever station
yatebts(){
	docker run -it --rm \
		--privileged \
		--device=/dev/bus/usb \
		--net host \
		-v $PWD/ybts.conf:/usr/local/etc/yate/ybts.conf \
		-v $PWD/subscribers.conf:/usr/local/etc/yate/subscribers.conf \
		--name yatebts \
		mitchtech/rpi-bladerf-yatebts
}

#
# support aliases
#
# kill all running containers
alias docker-killall='docker kill $(docker ps -q)'

# delete all stopped containers
alias docker-cleanc='printf "\n>>> Deleting stopped containers\n\n" && docker rm $(docker ps -a -q)'

# delete all untagged images
alias docker-cleani='printf "\n>>> Deleting untagged images\n\n" && docker rmi $(docker images -q -f dangling=true)'

# delete dangling volumes
alias docker-cleanv='printf "\n>>> Deleting dangling volumes\n\n" && docker volume rm $(docker volume ls -qf dangling=true)'

# delete stopped containers, untagged images
alias docker-cleanall='dockercleanc || true && dockercleani || true && dockercleanv'

# removes dangling and exited docker containers
dcleanup(){
	docker rm -v $(docker ps --filter status=exited -q 2>/dev/null) 2>/dev/null
	docker rmi $(docker images --filter dangling=true -q 2>/dev/null) 2>/dev/null
}

# delete stopped container
del_stopped(){
	local name=$1
	local state=$(docker inspect --format "{{.State.Running}}" $name 2>/dev/null)

	if [[ "$state" == "false" ]]; then
		docker rm $name
	fi
}
# dependency on another running container
relies_on(){
	local containers=$@

	for container in $containers; do
		local state=$(docker inspect --format "{{.State.Running}}" $container 2>/dev/null)

		if [[ "$state" == "false" ]] || [[ "$state" == "" ]]; then
			echo "$container is not running, starting it for you."
			$container
		fi
	done
}
# enter a running container
enter() {
  local name=${1:?}
  docker exec -it $name sh -c 'exec $(command -v bash || command -v sh)'
}
# helper to identify running containers
__enter() {
  local cur=${COMP_WORDS[COMP_CWORD]}
  for cid in $(docker ps -q)
  do
    local name=$(docker inspect -f '{{.Name}}' $cid)
    name=${name#/}
    if [[ $name = $cur* ]]
    then
      COMPREPLY+=("$name")
    fi
  done
}
# tab completion for entering running containers
complete -F __enter enter