Release 0.3.16

Deb packaging

.gitignore

@@ -1,3 +1,6 @@
 .vagrant
 .DS_Store
 stack.tgz
+build
+tmp
+*.deb

.s3cfg

@@ -1,38 +0,0 @@
-[default]
-access_key
-secret_key
-bucket_location = US
-cloudfront_host = cloudfront.amazonaws.com
-cloudfront_resource = /2010-07-15/distribution
-default_mime_type = binary/octet-stream
-delete_removed = False
-dry_run = False
-encoding = UTF-8
-encrypt = False
-follow_symlinks = False
-force = False
-get_continue = False
-gpg_command = None
-gpg_decrypt = %(gpg_command)s -d --verbose --no-use-agent --batch --yes --passphrase-fd %(passphrase_fd)s -o %(output_file)s %(input_file)s
-gpg_encrypt = %(gpg_command)s -c --verbose --no-use-agent --batch --yes --passphrase-fd %(passphrase_fd)s -o %(output_file)s %(input_file)s
-gpg_passphrase = 
-guess_mime_type = True
-host_base = s3.amazonaws.com
-host_bucket = %(bucket)s.s3.amazonaws.com
-human_readable_sizes = False
-list_md5 = False
-log_target_prefix = 
-preserve_attrs = True
-progress_meter = True
-proxy_host = 
-proxy_port = 0
-recursive = False
-recv_chunk = 4096
-reduced_redundancy = False
-send_chunk = 4096
-simpledb_host = sdb.amazonaws.com
-skip_existing = False
-socket_timeout = 300
-urlencoding_mode = normal
-use_https = False
-verbosity = WARNING

.travis.yml

@@ -1,16 +0,0 @@
----
-branches:
-  only:
-    - master
-script:
-  - echo "StrictHostKeyChecking=no" >> ~/.ssh/config
-  - export IP=$(curl -s http://dokku-ci.herokuapp.com/hosts | tail -1)
-  - git config --global user.email "travis-ci@exmaple.com"
-  - git config --global user.name "Travis CI"
-  - git checkout --orphan orphan HEAD
-  - git commit -am 'orphaned'
-  - git remote add runner ssh://test@$IP:2022/dokku
-  - sleep 8
-  - git push runner orphan:master
-notifications:
-  irc: "chat.freenode.net#dokku"

HISTORY.md

@@ -1,5 +1,97 @@
 # History
 
+## 0.3.16
+
+- #974: @michaelhobbs Don't use set to guard against pipefail
+- #975: @michaelhobbs Simplify SSL hostname handling and avoid overwriting variables. refs #971
+- #978: @michaelhobbs Add apparmor and cgroup-lite as pre-dependencies for dokku debian package
+- #980: @josegonzalez [docs] Add documentation for pluginhooks
+- #981: @josegonzalez Remove old files
+- #982: @josegonzalez [docs] Add documentation for existing clients. Closes #977
+- #983: @josegonzalez [docs] Update installation documentation
+- #984: @josegonzalez [docs] Clarify installation instructions
+- #988: @josegonzalez [docs] Add deprecated plugins section and where to get help
+- #989: @josegonzalez [docs] Add more clients
+- #986: @josegonzalez Switch to yabawock's static nginx buildpack for tests
+- #987: @techniq Improve Dockerfile example/test
+- #967: @alessio Really clean-up containers and images a-la-Docker
+- #992: @josegonzalez [docs] Fix digital ocean docs. Closes #991
+- #994: @alessio Fix quoting in container termination. Closes #249
+- #996: @pmvieira [docs] Minor typo fix in the pluginhooks documentation
+- #1003: @michaelhobbs Remove quoting around cleanup and disable lint for those lines
+- #1001: @sekjun9878 [docs] Add sekjun9878/dokku-redis-plugin to plugins.md
+- #1004: @michaelhobbs Remove quoting from dockerfile env. closes #1002
+- #1018: @michaelhobbs Confine arg shifting to between dokku and command. closes #1017
+- #1022: @Flink [docs] Add dokku-maintenance to plugins
+- #1008: @lmars Support multiple domains using a wildcard TLS certificate
+- #1013: @lmars Fix URL schemes in `dokku urls` output
+- #1027: @nickstenning [docs] Add webhooks plugin to documentation
+- #1026: @michaelhobbs Ensure we have newlines around our config. closes #1025
+- #1010: @michaelhobbs Don't run create/destroy twice in tests
+- #1028: @Flink [docs] Add rails-logs to plugins
+- #1031: @michaelhobbs Upgrade docker in CI to 1.5.0
+- #1029: @assaf Added several enhancements for CHECKS file:
+  - Specify how long to wait before running first check
+  - Specify timeout for each check
+  - Check specific hosts, e.g. http://signin.example.com
+  - Check both HTTP and HTTPS resources
+- #1032: @cameron-martin Updated dokku-installer to use relative path
+- #1035: @Flink [docs] Add dokku-http-auth to plugins
+- #1040: @ebeigarts [docs] Add dokku-slack plugin information
+- #1038: @michaelhobbs Default container check. closes #1020
+- #1036: @michaelhobbs Create config set/unset without restart. closes #908
+- #1009: @michaelhobbs Extract first port from Dockerfile and set config variable for use in deploy phase. closes #993
+- #1042: @michaelhobbs Update to Support xip.io wildcard DNS as a VHOST
+- #1043: @michaelhobbs Use upstart config from docker docs. closes #1015
+- #1047: @michaelhobbs Show logs on deploy success and failure
+- #1049: @ebeigarts [docs] Change Slack Notifications link
+- #1051: @Flink [docs] Add dokku-airbrake-deploy to plugins
+- #1057: @josegonzalez Updated deb packaging
+
+## 0.3.15
+
+- #950: @michaelhobbs Do not count blank lines in `make count`
+- #952: @michaelhobbs Document cli args over ssh. closes #951
+- #954: @michaelhobbs Dockerfile support
+- #955: @michaelhobbs Quick style refactor
+- #956: @michaelhobbs Comment out skipped tests as we pay the cost for setup() and teardown() anyway
+- #957: @michaelhobbs Implement dokku shell and ls (by @plietar). refs #312
+- #960: @michaelhobbs Use consistent bash shebang. closes #959
+- #962: @josegonzalez Update debian package building due to man page generation changes
+- #964: @michaelhobbs Only look for long args in global space. allows for short args in plugins. closes #963
+- #966: @djelic handle upgrade in debian/preinst script
+
+## 0.3.14
+
+- #891: @josegonzalez Keep existing configuration files when installing nginx. Refs #886
+- #892: @josegonzalez Change documentation on where the ssh config PORT is setup
+- #894: @josegonzalez Dokku client improvements
+- #895: @michaelhobbs Document deploying private git submodules. Closes #644
+- #896: @michaelhobbs Add docker-args pluginhook call to build phase. Closes #515
+- #897: @michaelhobbs Official PS plugin
+- #898: @joliv Update man page for 0.3.13
+- #899: @joliv Use help2man to automatically generate man pages
+- #900: @michaelhobbs Support extracting SANs from SSL certificates and adding them to nginx config
+- #901: @misto Pull new tags when upgrading to update VERSION
+- #904: @michaelhobbs Prevent error on restartall when no apps deployed
+- #905: @vincentfretin robv/dokku-elasticsearch not compatible with latest version
+- #907: @vincentfretin Don't use -o pipefail for plugin
+- #914: @michaelhobbs Conditionally set interactive and tty on dokku run. Closes #552. Closes #913
+- #915: @michaelhobbs Document default sites in nginx. Closes #650
+- #916: @michaelhobbs Document build phase troubleshooting suggestions. Closes #841. Closes #911.
+- #917: @michaelhobbs Document resolvconf troubleshooting step. Closes #649
+- #922: @michaelhobbs Use tty cmd to detect if we have one. Closes #921
+- #925: @michaelhobbs Implement rebuild command that reuses git_archive_all
+- #926: @dyson Update Troubleshooting link in README.md.
+- #927: @michaelhobbs Support both docker-args PHASE and docker-args-PHASE. Closes #906
+- #933: @michaelhobbs Remove references to .pem. Closes #930
+- #936: @michaelhobbs Only execute build stack if we have access to /var/run/docker.sock. Closes #929
+- #938: @vincentfretin Enable ssl_prefer_server_ciphers
+- #940: @michaelhobbs Use valid composer json with specified php runtime
+- #941: @michaelhobbs Source global env prior to app env. Closes #931
+- #942: @michaelhobbs Test clojure app
+- #949: @michaelhobbs Common functions library with simple argument parsing. Closes #932. Closes #945
+
 ## 0.3.13
 
 - #815: @abossard Added wordpress installation helper to plugin index

Makefile

@@ -17,13 +17,26 @@ endif
 .PHONY: all install copyfiles version plugins dependencies sshcommand pluginhook docker aufs stack count dokku-installer vagrant-acl-add vagrant-dokku
 
 include tests.mk
+include deb.mk
 
 all:
 	# Type "make install" to install.
 
 install: dependencies stack copyfiles plugin-dependencies plugins version
 
-copyfiles: addman
+release: deb-all package_cloud packer
+
+package_cloud:
+	package_cloud push dokku/dokku/ubuntu/trusty buildstep*.deb
+	package_cloud push dokku/dokku/ubuntu/trusty sshcommand*.deb
+	package_cloud push dokku/dokku/ubuntu/trusty pluginhook*.deb
+	package_cloud push dokku/dokku/ubuntu/trusty rubygem*.deb
+	package_cloud push dokku/dokku/ubuntu/trusty dokku*.deb
+
+packer:
+	packer build contrib/packer.json
+
+copyfiles:
 	cp dokku /usr/local/bin/dokku
 	mkdir -p ${PLUGINS_PATH}
 	find ${PLUGINS_PATH} -mindepth 2 -maxdepth 2 -name '.core' -printf '%h\0' | xargs -0 rm -Rf
@@ -32,10 +45,11 @@ copyfiles: addman
 		cp -R plugins/$$plugin ${PLUGINS_PATH} && \
 		touch ${PLUGINS_PATH}/$$plugin/.core; \
 		done
+	$(MAKE) addman
 
 addman:
 	mkdir -p /usr/local/share/man/man1
-	cp dokku.1 /usr/local/share/man/man1/dokku.1
+	help2man -Nh help -v version -n "configure and get information from your dokku installation" -o /usr/local/share/man/man1/dokku.1 dokku
 	mandb
 
 version:
@@ -47,7 +61,10 @@ plugin-dependencies: pluginhook
 plugins: pluginhook docker
 	dokku plugins-install
 
-dependencies: sshcommand pluginhook docker stack
+dependencies: sshcommand pluginhook docker stack help2man
+
+help2man:
+	apt-get install -qq -y help2man
 
 sshcommand:
 	wget -qO /usr/local/bin/sshcommand ${SSHCOMMAND_URL}
@@ -62,7 +79,7 @@ docker: aufs
 	apt-get install -qq -y curl
 	egrep -i "^docker" /etc/group || groupadd docker
 	usermod -aG docker dokku
-	curl --silent https://get.docker.io/gpg | apt-key add -
+	curl --silent https://get.docker.com/gpg | apt-key add -
 	echo deb http://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list
 	apt-get update
 ifdef DOCKER_VERSION
@@ -78,20 +95,22 @@ ifndef CI
 endif
 
 stack:
+ifeq ($(shell test -e /var/run/docker.sock && touch -a -c /var/run/docker.sock && echo $$?),0)
 	@echo "Start building buildstep"
 ifdef BUILD_STACK
 	@docker images | grep progrium/buildstep || (git clone ${STACK_URL} /tmp/buildstep && docker build -t progrium/buildstep /tmp/buildstep && rm -rf /tmp/buildstep)
 else
 	@docker images | grep progrium/buildstep || curl --silent -L ${PREBUILT_STACK_URL} | gunzip -cd | docker import - progrium/buildstep
 endif
+endif
 
 count:
 	@echo "Core lines:"
-	@cat dokku bootstrap.sh | wc -l
+	@cat dokku bootstrap.sh | egrep -v "^$$" | wc -l
 	@echo "Plugin lines:"
-	@find plugins -type f | xargs cat | wc -l
+	@find plugins -type f | xargs cat | egrep -v "^$$" | wc -l
 	@echo "Test lines:"
-	@find tests -type f | xargs cat | wc -l
+	@find tests -type f | xargs cat | egrep -v "^$$" |wc -l
 
 dokku-installer:
 	apt-get install -qq -y ruby
@@ -99,7 +118,7 @@ dokku-installer:
 	test -f /var/lib/dokku/.dokku-installer-created || gem install rack-protection -v 1.5.3 --no-rdoc --no-ri
 	test -f /var/lib/dokku/.dokku-installer-created || gem install sinatra -v 1.4.5 --no-rdoc --no-ri
 	test -f /var/lib/dokku/.dokku-installer-created || gem install tilt -v 1.4.1 --no-rdoc --no-ri
-	test -f /var/lib/dokku/.dokku-installer-created || ruby /root/dokku/contrib/dokku-installer.rb onboot
+	test -f /var/lib/dokku/.dokku-installer-created || ruby contrib/dokku-installer.rb onboot
 	test -f /var/lib/dokku/.dokku-installer-created || service dokku-installer start
 	test -f /var/lib/dokku/.dokku-installer-created || service nginx reload
 	test -f /var/lib/dokku/.dokku-installer-created || touch /var/lib/dokku/.dokku-installer-created

README.md

@@ -1,4 +1,4 @@
-# Dokku [![Build Status](https://circleci.com/gh/progrium/dokku/tree/master.svg?style=svg&circle-token=eec5b442dda53a4d229911dd97d4214853acc262 "Build Status")](https://circleci.com/gh/progrium/dokku/tree/master)
+# Dokku [![Build Status](https://circleci.com/gh/progrium/dokku/tree/master.svg?style=svg&circle-token=eec5b442dda53a4d229911dd97d4214853acc262 "Build Status")](https://circleci.com/gh/progrium/dokku/tree/master) [![Ubuntu Package](https://img.shields.io/badge/package-ubuntu-brightgreen.svg?style=flat-square "Ubuntu Package")](https://packagecloud.io/dokku/dokku)
 
 Docker powered mini-Heroku. The smallest PaaS implementation you've ever seen. Sponsored by our friends at [Deis](http://deis.io/).
 
@@ -8,9 +8,9 @@ Docker powered mini-Heroku. The smallest PaaS implementation you've ever seen. S
 
 ## Installing
 
-To install the latest stable version of dokku, you can run the following bootstrapper command:
+To install the latest stable release, you can run the following command as a user that has access to `sudo`:
 
-    $ wget -qO- https://raw.github.com/progrium/dokku/v0.3.13/bootstrap.sh | sudo DOKKU_TAG=v0.3.13 bash
+    wget -qO- https://raw.github.com/progrium/dokku/v0.3.16/bootstrap.sh | sudo DOKKU_TAG=v0.3.16 bash
 
 ### Upgrading
 
@@ -22,7 +22,7 @@ Full documentation - including advanced installation docs - are available online
 
 ## Support
 
-You can use [Github Issues](https://github.com/progrium/dokku/issues), check [Troubleshooting](https://github.com/progrium/dokku/wiki/Troubleshooting) on the wiki, or join us on [freenode in #dokku](https://webchat.freenode.net/?channels=%23dokku)
+You can use [Github Issues](https://github.com/progrium/dokku/issues), check [Troubleshooting](http://progrium.viewdocs.io/dokku/troubleshooting) in the documentation, or join us on [freenode in #dokku](https://webchat.freenode.net/?channels=%23dokku)
 
 ## Sponsors
 

Vagrantfile

@@ -7,6 +7,7 @@ BOX_MEMORY = ENV["BOX_MEMORY"] || "1024"
 DOKKU_DOMAIN = ENV["DOKKU_DOMAIN"] || "dokku.me"
 DOKKU_IP = ENV["DOKKU_IP"] || "10.0.0.2"
 PREBUILT_STACK_URL = File.exist?("#{File.dirname(__FILE__)}/stack.tgz") ? 'file:///root/dokku/stack.tgz' : nil
+PUBLIC_KEY_PATH = "#{Dir.home}/.ssh/id_rsa.pub"
 
 make_cmd = "make install"
 if PREBUILT_STACK_URL
@@ -14,12 +15,11 @@ if PREBUILT_STACK_URL
 end
 
 Vagrant::configure("2") do |config|
+  config.ssh.forward_agent = true
+
   config.vm.box = BOX_NAME
   config.vm.box_url = BOX_URI
   config.vm.synced_folder File.dirname(__FILE__), "/root/dokku"
-  config.vm.network :forwarded_port, guest: 80, host: 8080
-  config.vm.hostname = "#{DOKKU_DOMAIN}"
-  config.vm.network :private_network, ip: DOKKU_IP
 
   config.vm.provider :virtualbox do |vb|
     vb.customize ["modifyvm", :id, "--natdnshostresolver1", "on"]
@@ -29,6 +29,30 @@ Vagrant::configure("2") do |config|
     vb.customize ["modifyvm", :id, "--memory", BOX_MEMORY]
   end
 
-  config.vm.provision :shell, :inline => "apt-get -qq -y install git > /dev/null && cd /root/dokku && #{make_cmd}"
-  config.vm.provision :shell, :inline => "cd /root/dokku && make dokku-installer"
+  config.vm.define "empty", autostart: false
+
+  config.vm.define "dokku", primary: true do |vm|
+    vm.vm.network :forwarded_port, guest: 80, host: 8080
+    vm.vm.hostname = "#{DOKKU_DOMAIN}"
+    vm.vm.network :private_network, ip: DOKKU_IP
+    vm.vm.provision :shell, :inline => "apt-get -qq -y install git > /dev/null && cd /root/dokku && #{make_cmd}"
+    vm.vm.provision :shell, :inline => "cd /root/dokku && make dokku-installer"
+  end
+
+  config.vm.define "dokku-deb", autostart: false do |vm|
+    vm.vm.network :forwarded_port, guest: 80, host: 8080
+    vm.vm.hostname = "#{DOKKU_DOMAIN}"
+    vm.vm.network :private_network, ip: DOKKU_IP
+    vm.vm.provision :shell, :inline => "cd /root/dokku && make install-from-deb"
+  end
+
+  config.vm.define "build", autostart: false do |vm|
+    vm.vm.provision :shell, :inline => "apt-get -qq -y install git > /dev/null && cd /root/dokku && #{make_cmd}"
+    vm.vm.provision :shell, :inline => "cd /root/dokku && make deb-all"
+  end
+
+  if Pathname.new(PUBLIC_KEY_PATH).exist?
+    config.vm.provision :file, source: PUBLIC_KEY_PATH, destination: '/tmp/id_rsa.pub'
+    config.vm.provision :shell, :inline => "rm -f /root/.ssh/authorized_keys && cp /tmp/id_rsa.pub /root/.ssh/authorized_keys"
+  end
 end

bootstrap.sh

@@ -14,7 +14,7 @@ then
 fi
 
 apt-get update
-apt-get install -qq -y git make curl software-properties-common man-db
+apt-get install -qq -y git make curl software-properties-common man-db help2man
 
 [[ $(lsb_release -sr) == "12.04" ]] && apt-get install -qq -y python-software-properties
 

circle.yml

@@ -8,7 +8,7 @@ dependencies:
     # need to add the dokku user to the docker group
     - sudo -E CI=true make -e sshcommand
     - sudo usermod -G docker dokku
-    - sudo -E CI=true DOCKER_VERSION=1.4.1 make -e install: { timeout: 300 }
+    - sudo -E CI=true DOCKER_VERSION=1.5.0 make -e install: { timeout: 300 }
     - make -e ci-dependencies
     #### circle does some weird *expletive* with regards to root and gh auth (needed for gitsubmodules test)
     - sudo rsync -a ~ubuntu/.ssh/ ~root/.ssh/
@@ -16,13 +16,8 @@ dependencies:
     - sudo sed -e 's:/home/ubuntu:/root:g' ~root/.ssh/config
     ####
     - sudo -E make -e setup-deploy-tests
+  post:
+    - sudo -E make -e lint
 test:
   override:
-    - sudo -E make -e lint
-    - sudo -E make -e unit-tests
-    ### deploy tests (against buildstep release) ####
-    - sudo -E make -e deploy-tests: { timeout: 1800 }
-    ### deploy tests (against buildstep master) ####
-    - sudo docker rmi -f progrium/buildstep
-    - sudo -E BUILD_STACK=true make -e stack
-    - sudo -E make -e deploy-tests: { timeout: 1800 }
+    - ./tests/ci/parallel_runner.sh: { parallel: true, timeout: 1800 }

contrib/dokku-installer.rb

@@ -16,12 +16,12 @@ if ARGV[0] == "onboot"
       f.puts "  }"
     f.puts "}"
   end
-  `rm /etc/nginx/sites-enabled/*`
+  `rm -f /etc/nginx/sites-enabled/*`
   puts "Installed Upstart service and default Nginx virtualhost for installer to run on boot."
   exit
 end
 
-version   = "v0.3.13"
+version   = "v0.3.16"
 dokku_root  = ENV["DOKKU_ROOT"] || "/home/dokku"
 admin_key   = `cat /root/.ssh/authorized_keys`.split("\n").first
 hostname  = `bash -c '[[ $(dig +short $HOSTNAME) ]] && echo $HOSTNAME || curl icanhazip.com'`.strip

contrib/dokku_client.sh

@@ -1,32 +1,128 @@
-if [ -z "$DOKKU_HOST" ]
-then
-	function dokku {
-		appname=$(git remote -v 2>/dev/null | grep dokku | head -n 1 | cut -f1 -d' ' | cut -f2 -d':' 2>/dev/null)
-		if [ "$?" != "0" ]
-		then
-			donotshift="YES"
-		fi
-		if [ "$1" = "create" ]
-		then
-			appname=$(echo "print(elfs.GenName())" | lua -l elfs)
-			if git remote add dokku dokku@$DOKKU_HOST:$appname
-			then
-				echo "-----> Dokku remote added at $DOKKU_HOST"
-				echo "-----> Application name is $appname"
-			else
-				echo "!      Dokku remote not added! Do you already have a dokku remote?"
-				return
-			fi
-			git push dokku master
-		else
-			if [ -z "$donotshift" ]
-			then
-				ssh dokku@$DOKKU_HOST $*
-				exit
-			fi
-			verb=$1
-			shift
-			ssh dokku@$DOKKU_HOST "$verb" "$appname" $@
-		fi
-	}
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+MOVES=(ABLE ABNORMA AGAIN AIREXPL ANG ANGER ASAIL ATTACK AURORA AWL BAN BAND BARE BEAT BEATED BELLY BIND BITE BLOC BLOOD BODY BOOK BREATH BUMP CAST CHAM CLAMP CLAP CLAW CLEAR CLI CLIP CLOUD CONTRO CONVY COOLHIT CRASH CRY CUT DESCRI D-FIGHT DIG DITCH DIV DOZ DRE DUL DU-PIN DYE EARTH EDU EG-BOMB EGG ELEGY ELE-HIT EMBODY EMPLI ENGL ERUPT EVENS EXPLOR EYES FALL FAST F-CAR F-DANCE FEARS F-FIGHT FIGHT FIR FIRE FIREHIT FLAME FLAP FLASH FLEW FORCE FRA FREEZE FROG G-BIRD GENKISS GIFT G-KISS G-MOUSE GRADE GROW HAMMER HARD HAT HATE H-BOMB HELL-R HEMP HINT HIT HU HUNT HYPNOSI INHA IRO IRONBAR IR-WING J-GUN KEE KICK KNIF KNIFE KNOCK LEVEL LIGH LIGHHIT LIGHT LIVE L-WALL MAD MAJUS MEL MELO MESS MILK MIMI MISS MIXING MOVE MUD NI-BED NOISY NOONLI NULL N-WAVE PAT PEACE PIN PLAN PLANE POIS POL POWDE POWE POWER PRIZE PROTECT PROUD RAGE RECOR REFLAC REFREC REGR RELIV RENEW R-FIGHT RING RKICK ROCK ROUND RUS RUSH SAND SAW SCISSOR SCRA SCRIPT SEEN SERVER SHADOW SHELL SHINE SHO SIGHT SIN SMALL SMELT SMOK SNAKE SNO SNOW SOU SO-WAVE SPAR SPEC SPID S-PIN SPRA STAM STARE STEA STONE STORM STRU STRUG STUDEN SUBS SUCID SUN-LIG SUNRIS SUPLY S-WAVE TAILS TANGL TASTE TELLI THANK TONKICK TOOTH TORL TRAIN TRIKICK TUNGE VOLT WA-GUN WATCH WAVE W-BOMB WFALL WFING WHIP WHIRL WIND WOLF WOOD WOR YUJA)
+NAMES=(SEED GRASS FLOWE SHAD CABR SNAKE GOLD COW GUIKI PEDAL DELAN B-FLY BIDE KEYU FORK LAP PIGE PIJIA CAML LAT BIRD BABOO VIV ABOKE PIKAQ RYE SAN BREAD LIDEL LIDE PIP PIKEX ROK JUGEN PUD BUDE ZHIB GELU GRAS FLOW LAFUL ATH BALA CORN MOLUF DESP DAKED MIMI BOLUX KODA GELUD MONK SUMOY GEDI WENDI NILEM NILE NILEC KEZI YONGL HUDE WANLI GELI GUAIL MADAQ WUCI WUCI MUJEF JELLY SICIB GELU NELUO BOLI JIALE YED YEDE CLO SCARE AOCO DEDE DEDEI BAWU JIUG BADEB BADEB HOLE BALUX GES FANT QUAR YIHE SWAB SLIPP CLU DEPOS BILIY YUANO SOME NO YELA EMPT ZECUN XIAHE BOLEL DEJI MACID XIHON XITO LUCK MENJI GELU DECI XIDE DASAJ DONGN RICUL MINXI BALIY ZENDA LUZEL HELE5 0FENB KAIL JIAND CARP JINDE LAPU MUDE YIFU LINLI SANDI HUSI JINC OUMU OUMUX CAP KUIZA PUD TIAO FRMAN CLAU SPARK DRAGO BOLIU GUAIL MIYOU MIY QIAOK BEIL MUKEI RIDED MADAM BAGEP CROC ALIGE OUDAL OUD DADA HEHE YEDEA NUXI NUXIN ROUY ALIAD STICK QIANG LAAND PIQI PI PUPI DEKE DEKEJ NADI NADIO MALI PEA ELECT FLOWE MAL MALI HUSHU NILEE YUZI POPOZ DUZI HEBA XIAN SHAN YEYEA WUY LUO KEFE HULA CROW YADEH MOW ANNAN SUONI KYLI HULU HUDEL YEHE GULAE YEHE BLU GELAN BOAT NIP POIT HELAK XINL BEAR LINB MAGEH MAGEJ WULI YIDE RIVE FISH AOGU DELIE MANTE KONMU DELU HELU HUAN HUMA DONGF JINCA HEDE DEFU LIBY JIAPA MEJI HELE BUHU MILK HABI THUN GARD DON YANGQ SANAQ BANQ LUJ PHIX SIEI EGG)
+
+random_number() {
+  [[ -n "$1" ]] && RANGE="$1"
+  if [[ -n "$RANGE" ]];then
+    number=$RANDOM
+    let "number %= $RANGE"
+  else
+    number=$RANDOM
+  fi
+  echo $number
+}
+
+random_name() {
+ NUM1=$(random_number ${#MOVES[@]})
+ NUM2=$(random_number ${#MOVES[@]})
+ NUM3=$(random_number ${#NAMES[@]})
+
+ UPPER_APPNAME="${MOVES[${NUM1}]}-${MOVES[${NUM2}]}-${NAMES[${NUM3}]}"
+
+ [[ "$BASH_VERSION" =~ 4.* ]] && lower_appname=${UPPER_APPNAME,,}
+ [[ -z "$lower_appname" ]] && lower_appname=$(echo $UPPER_APPNAME | tr '[:upper:]' '[:lower:]')
+ echo "$lower_appname"
+}
+
+client_help_msg() {
+  echo "==> Configure the DOKKU_HOST environment variable or run $0 from a repository with a git remote named dokku"
+  echo "--> i.e. git remote add dokku dokku@<dokku-host>:<app-name>"
+  exit 20 # exit with specific status. only used in units tests for now
+}
+
+if [[ -z $DOKKU_HOST ]]; then
+  if [[ -d .git ]] || git rev-parse --git-dir > /dev/null 2>&1; then
+    DOKKU_HOST=$(git remote -v 2>/dev/null | grep -Ei "^dokku" | head -n 1 | cut -f1 -d' ' | cut -f2 -d '@' | cut -f1 -d':' 2>/dev/null || true)
+  else
+    client_help_msg
+  fi
+fi
+
+if [[ ! -z $DOKKU_HOST ]]; then
+  _dokku() {
+    appname=""
+    if [[ -d .git ]] || git rev-parse --git-dir > /dev/null 2>&1; then
+      set +e
+      appname=$(git remote -v 2>/dev/null | grep -Ei "^dokku" | head -n 1 | cut -f1 -d' ' | cut -f2 -d':' 2>/dev/null)
+      set -e
+    else
+      echo "This is not a git repository"
+    fi
+
+    if [[ "$appname" != "" ]] && [[ -n "$*" ]]; then
+      case "$1" in
+        apps|backup*|help|plugins*|ps:restartall|trace|version)
+          true
+          ;;
+        apps:destroy)
+          if [[ -z "$2" ]] || [[ "$2" == "force" ]];then
+            donotshift="YES"
+          fi
+          ;;
+        *)
+          donotshift="YES"
+          ;;
+      esac
+    fi
+
+    if [[ "$1" = "apps:create" ]] && [[ -z "$2" ]]; then
+      appname=$(random_name)
+      counter=0
+      while ssh "dokku@$DOKKU_HOST" apps 2>/dev/null| grep -q "$appname"; do
+        if [[ $counter -ge 100 ]];then
+          echo "Error: could not reasonably generate a new app name. try cleaning up some apps..."
+          ssh "dokku@$DOKKU_HOST" apps
+          exit 1
+        else
+          appname=$(random_name)
+          counter=$((counter+1))
+        fi
+      done
+      if git remote add dokku "dokku@$DOKKU_HOST:$appname"
+      then
+        echo "-----> Dokku remote added at $DOKKU_HOST"
+        echo "-----> Application name is $appname"
+      else
+        echo "!      Dokku remote not added! Do you already have a dokku remote?"
+        return
+      fi
+      git push dokku master
+      return $?
+    fi
+
+    if [[ -z "$donotshift" ]]; then
+      ssh "dokku@$DOKKU_HOST" "$@"
+      exit $?
+    fi
+
+    if [[ -z "$verb" ]]; then
+      if [[ ! "$1" =~ --* ]]; then
+        verb=$1
+        shift
+        args="$*"
+      else
+        long_args="--"
+        for arg in "$@";do
+          if [[ "$arg" =~ --* ]];then
+            long_args+=" $arg"
+            args=("${args[@]/$arg}")
+          else
+             verb="$arg"
+          fi
+        done
+      fi
+    fi
+    # shellcheck disable=SC2086
+    ssh "dokku@$DOKKU_HOST" $long_args "$verb" "$appname" "${args[@]}"
+  }
+
+  if [[ "$0" == "dokku" ]] || [[ "$0" == *dokku_client.sh ]]; then
+    _dokku "$@"
+    exit $?
+  fi
+else
+  client_help_msg
 fi

contrib/packer.json

@@ -0,0 +1,32 @@
+{
+  "builders": [
+    {
+      "type": "digitalocean",
+      "region": "nyc3",
+      "image": "ubuntu-14-04-x64"
+    }
+  ],
+  "provisioners": [
+    {
+      "type": "file",
+      "source": "deb.mk",
+      "destination": "/tmp/Makefile"
+    },
+    {
+      "type": "shell",
+      "inline": [
+        "echo '--> Waiting 30 seconds for core services to be available'",
+        "sleep 30",
+
+        "echo '--> Updating apt repositories'",
+        "sudo apt-get update > /dev/null",
+
+        "echo '--> Installing make requirement'",
+        "sudo apt-get -qq -y install build-essential",
+
+        "cd /tmp && make install-from-deb",
+        "rm /root/.ssh/authorized_keys"
+      ]
+    }
+  ]
+}

contrib/stackscript.sh

@@ -0,0 +1,183 @@
+#!/bin/bash
+# <UDF name="hostname" default="" label="Hostname for dokku instance" example="example.com">
+# <UDF name="ssh_key" default="" label="Public SSH Key for root user" example="Sets the root user's public ssh key, which is also automatically imported into the dokku installer">
+# <UDF name="notify_email" default="" Label="Send Finish Notification To" example="Email address to send notification to when finished." />
+
+function logit {
+  # Simple logging function that prepends an easy-to-find marker '=> ' and a timestamp to a message
+  TIMESTAMP=$(date -u +'%m/%d %H:%M:%S')
+  MSG="=> ${TIMESTAMP} $1"
+  echo ${MSG}
+}
+
+function set_ssh_key {
+  if [ -n "${SSH_KEY}" ]; then
+    logit "Setting root ssh key"
+    mkdir -p /root/.ssh
+    chmod 700 /root/.ssh
+    echo "$SSH_KEY" > /root/.ssh/authorized_keys
+    chmod 600 /root/.ssh/authorized_keys
+    chown -R root:root /root/.ssh
+  fi
+}
+
+function set_passwordless_ssh {
+  logit "Turn off password authentication and root login for SSH"
+  echo 'PasswordAuthentication no' >> /etc/ssh/sshd_config
+  service ssh restart
+}
+
+function system_primary_ip {
+  # returns the primary IP assigned to eth0
+  ifconfig eth0 | awk -F: '/inet addr:/ {print $2}' | awk '{ print $1 }'
+}
+
+function set_hostname {
+  logit "Set up hostname"
+  if [ -n "${HOSTNAME}" ]; then
+    echo $HOSTNAME > /etc/hostname
+    echo $IPADDR $FQDN $HOSTNAME >> /etc/hosts
+  else
+    system_primary_ip > /etc/hostname
+    echo "$(system_primary_ip) localhost" >> /etc/hosts
+  fi
+
+  IPADDR=$(/sbin/ifconfig eth0 | awk '/inet / { print $2 }' | sed 's/addr://')
+  hostname -F /etc/hostname
+}
+
+function postfix_install_loopback_only {
+  logit "Installing and configuring Postfix"
+  # Installs postfix and configure to listen only on the local interface. Also
+  # allows for local mail delivery
+
+  echo "postfix postfix/destinations string localhost.localdomain, localhost" | debconf-set-selections
+  echo "postfix postfix/mailname string localhost" | debconf-set-selections
+  echo "postfix postfix/main_mailer_type select Internet Site" | debconf-set-selections
+  echo "postfix postfix/myhostname string localhost" | debconf-set-selections
+  sudo apt-get install -qq -y postfix > /dev/null 2>&1
+  /usr/sbin/postconf -e "inet_interfaces = loopback-only"
+  #/usr/sbin/postconf -e "local_transport = error:local delivery is disabled"
+
+  touch /tmp/restart-postfix
+}
+
+function notify_install_via_email {
+  if [ -n "${NOTIFY_EMAIL}" ]; then
+    logit "Sending notification email to ${NOTIFY_EMAIL}"
+    /usr/sbin/sendmail "${NOTIFY_EMAIL}" <<EOD
+To: ${NOTIFY_EMAIL}
+Subject: Dokku installation is complete
+From: Dokku StackScript <no-reply@${HOSTNAME}>
+
+Your Dokku installation is complete and now ready to be configured: http://$(system_primary_ip) . Please visit this url to complete the setup of your Dokku instance.
+
+Enjoy using Dokku!
+EOD
+  fi
+}
+
+function notify_restart_via_email {
+  if [ -n "${NOTIFY_EMAIL}" ]; then
+    logit "Sending notification email to ${NOTIFY_EMAIL} of required restart"
+    /usr/sbin/sendmail "${NOTIFY_EMAIL}" <<EOD
+To: ${NOTIFY_EMAIL}
+Subject: Dokku Linode instance must be restarted
+From: Dokku StackScript <no-reply@${HOSTNAME}>
+
+The following linode instance must be restarted:
+
+    ${LINODE_LISHUSERNAME}
+
+Before restarting, please go to this url:
+
+    https://manager.linode.com/linodes/dashboard/${LINODE_LISHUSERNAME}
+
+Then click "Edit" next to the selected configuration profile and make the following changes:
+
+- Change the "Kernel" option to the current "pv-grub" release
+- Set the "Xenify Distro" option to "no"
+
+Then save your changes. Next, reboot the instance from the Linode Dashboard. You'll receive an email once the instance is available to continue the dokku installation.
+EOD
+  fi
+}
+
+function setup_linode {
+  logit "Installing via linode"
+  DEBIAN_FRONTEND=noninteractive apt-get install -qq -y linux-virtual
+  DEBIAN_FRONTEND=noninteractive apt-get purge -qq -y grub2 grub-pc
+  DEBIAN_FRONTEND=noninteractive apt-get install -qq -y grub
+  mkdir -p /boot/grub
+  update-grub -y
+  sed -i 's/kopt=root=UUID=.* ro/kopt=root=\/dev\/xvda console=hvc0 ro quiet/g' /boot/grub/menu.lst
+  sed -i 's/# groot=(hd0,0)/# groot=(hd0)/g' /boot/grub/menu.lst
+  update-grub
+
+  cp /etc/rc.local /etc/rc.local-bak
+  cat << EOF > /etc/rc.local
+#!/bin/sh -e
+sudo apt-get update >> /root/setup_linode.txt 2>&1
+sudo apt-get install -y linux-image-extra-"$(uname -r)" >> /root/setup_linode.txt 2>&1
+modprobe aufs >> /root/setup_linode.txt 2>&1
+
+sudo apt-get install -y apparmor cgroup-lite >> /root/setup_linode.txt 2>&1
+
+sudo apt-get install -y dokku >> /root/setup_linode.txt 2>&1
+
+# Clean up this script so it only runs once
+rm -f /etc/rc.local
+mv /etc/rc.local-bak /etc/rc.local
+exit 0
+EOF
+  chmod +x /etc/rc.local
+}
+
+function install_prerequisites {
+  sudo apt-get install -qq -y curl > /dev/null 2>&1
+
+  logit "Installing docker gpg key"
+  curl --silent https://get.docker.com/gpg 2> /dev/null | apt-key add - > /dev/null 2>&1
+
+  logit "Installing dokku gpg key"
+  curl --silent https://packagecloud.io/gpg.key 2> /dev/null | apt-key add - > /dev/null 2>&1
+
+  logit "Running apt-get update"
+  sudo apt-get update > /dev/null
+
+  logit "Installing pre-requisites"
+  sudo apt-get install -qq -y apt-transport-https > /dev/null 2>&1
+
+  logit "Setting up apt repositories"
+  echo "deb http://get.docker.io/ubuntu docker main" > /etc/apt/sources.list.d/docker.list
+  echo "deb https://packagecloud.io/dokku/dokku/ubuntu/ trusty main" > /etc/apt/sources.list.d/dokku.list
+
+  logit "Running apt-get update"
+  sudo apt-get update > /dev/null
+}
+
+function install_dokku {
+  logit "Installing pre-requisites"
+  sudo apt-get install -qq -y linux-image-extra-"$(uname -r)" > /dev/null 2>&1
+
+  logit "Installing dokku"
+  sudo apt-get install -qq -y dokku > /dev/null 2>&1
+
+  logit "Done!"
+}
+
+exec &> /root/stackscript.log
+
+set_ssh_key
+set_passwordless_ssh
+postfix_install_loopback_only
+set_hostname
+install_prerequisites
+
+if [ -n "$LINODE_ID" ]; then
+  setup_linode
+  notify_restart_via_email
+else
+  install_dokku
+  notify_install_via_email
+fi

deb.mk

@@ -0,0 +1,165 @@
+BUILDSTEP_DESCRIPTION = 'Buildstep uses Docker and Buildpacks to build applications like Heroku'
+BUILDSTEP_REPO_NAME ?= progrium/buildstep
+BUILDSTEP_VERSION ?= 0.0.1
+BUILDSTEP_ARCHITECTURE = amd64
+BUILDSTEP_PACKAGE_NAME = buildstep_$(BUILDSTEP_VERSION)_$(BUILDSTEP_ARCHITECTURE).deb
+
+DOKKU_DESCRIPTION = 'Docker powered mini-Heroku in around 100 lines of Bash'
+DOKKU_REPO_NAME ?= progrium/dokku
+DOKKU_ARCHITECTURE = amd64
+
+PLUGINHOOK_DESCRIPTION = 'Simple dispatcher and protocol for shell-based plugins, an improvement to hook scripts'
+PLUGINHOOK_REPO_NAME ?= progrium/pluginhook
+PLUGINHOOK_VERSION ?= 0.0.1
+PLUGINHOOK_ARCHITECTURE = amd64
+PLUGINHOOK_PACKAGE_NAME = pluginhook_$(PLUGINHOOK_VERSION)_$(PLUGINHOOK_ARCHITECTURE).deb
+
+SSHCOMMAND_DESCRIPTION = 'Turn SSH into a thin client specifically for your app'
+SSHCOMMAND_REPO_NAME ?= progrium/sshcommand
+SSHCOMMAND_VERSION ?= 0.0.1
+SSHCOMMAND_ARCHITECTURE = amd64
+SSHCOMMAND_PACKAGE_NAME = sshcommand_$(SSHCOMMAND_VERSION)_$(SSHCOMMAND_ARCHITECTURE).deb
+
+GEM_ARCHITECTURE = amd64
+
+GOROOT = /usr/lib/go
+GOBIN = /usr/bin/go
+GOPATH = /home/vagrant/gocode
+
+.PHONY: install-from-deb deb-all deb-buildstep deb-dokku deb-gems deb-pluginhook deb-setup deb-sshcommand
+
+install-from-deb:
+	echo "--> Initial apt-get update"
+	sudo apt-get update > /dev/null
+	sudo apt-get install -y apt-transport-https
+
+	echo "--> Installing docker gpg key"
+	curl --silent https://get.docker.com/gpg 2> /dev/null | apt-key add - 2>&1 >/dev/null
+
+	echo "--> Installing dokku gpg key"
+	curl --silent https://packagecloud.io/gpg.key 2> /dev/null | apt-key add - 2>&1 >/dev/null
+
+	echo "--> Setting up apt repositories"
+	echo "deb http://get.docker.io/ubuntu docker main" > /etc/apt/sources.list.d/docker.list
+	echo "deb https://packagecloud.io/dokku/dokku/ubuntu/ trusty main" > /etc/apt/sources.list.d/dokku.list
+
+	echo "--> Running apt-get update"
+	sudo apt-get update > /dev/null
+
+	echo "--> Installing pre-requisites"
+	sudo apt-get install -y linux-image-extra-`uname -r`
+
+	echo "--> Installing dokku"
+	sudo apt-get install -y dokku
+
+	echo "--> Done!"
+
+deb-all: deb-buildstep deb-dokku deb-gems deb-pluginhook deb-sshcommand
+	mv /tmp/*.deb .
+	echo "Done"
+
+deb-setup:
+	echo "-> Updating deb repository and installing build requirements"
+	sudo apt-get update > /dev/null
+	sudo apt-get install -qq -y git ruby1.9.1-dev 2>&1 > /dev/null
+	command -v fpm > /dev/null || sudo gem install fpm --no-ri --no-rdoc
+	ssh -o StrictHostKeyChecking=no git@github.com || true
+
+deb-buildstep: deb-setup
+	rm -rf /tmp/tmp /tmp/build $(BUILDSTEP_PACKAGE_NAME)
+	mkdir -p /tmp/tmp /tmp/build
+
+	echo "-> Creating deb files"
+	echo "#!/usr/bin/env bash" >> /tmp/tmp/post-install
+	echo "sleep 5" >> /tmp/tmp/post-install
+	echo "count=\`sudo docker images | grep progrium/buildstep | wc -l\`" >> /tmp/tmp/post-install
+	echo 'if [ "$$count" -ne 0 ]; then' >> /tmp/tmp/post-install
+	echo "  echo 'Removing old buildstep image'" >> /tmp/tmp/post-install
+	echo "  sudo docker rmi progrium/buildstep" >> /tmp/tmp/post-install
+	echo "fi" >> /tmp/tmp/post-install
+	echo "echo 'Importing buildstep into docker (around 5 minutes)'" >> /tmp/tmp/post-install
+	echo "sudo docker build -t progrium/buildstep /var/lib/buildstep 1> /dev/null" >> /tmp/tmp/post-install
+
+	echo "-> Cloning repository"
+	git clone -q "git@github.com:$(BUILDSTEP_REPO_NAME).git" /tmp/tmp/buildstep > /dev/null
+	rm -rf /tmp/tmp/buildstep/.git /tmp/tmp/buildstep/.gitignore
+
+	echo "-> Copying files into place"
+	mkdir -p "/tmp/build/var/lib"
+	cp -rf /tmp/tmp/buildstep /tmp/build/var/lib/buildstep
+
+	echo "-> Creating $(BUILDSTEP_PACKAGE_NAME)"
+	sudo fpm -t deb -s dir -C /tmp/build -n buildstep -v $(BUILDSTEP_VERSION) -a $(BUILDSTEP_ARCHITECTURE) -p $(BUILDSTEP_PACKAGE_NAME) --deb-pre-depends 'lxc-docker >= 1.4.0' --after-install /tmp/tmp/post-install --url "https://github.com/$(BUILDSTEP_REPO_NAME)" --description $(BUILDSTEP_DESCRIPTION) --license 'MIT License' .
+	mv *.deb /tmp
+
+deb-dokku: deb-setup
+	rm -rf /tmp/tmp /tmp/build dokku_*_$(DOKKU_ARCHITECTURE).deb
+	mkdir -p /tmp/tmp /tmp/build
+
+	cp -r debian /tmp/build/DEBIAN
+	mkdir -p /tmp/build/usr/local/bin
+	mkdir -p /tmp/build/var/lib/dokku
+	mkdir -p /tmp/build/usr/local/share/man/man1
+	mkdir -p /tmp/build/usr/local/share/dokku/contrib
+
+	cp dokku /tmp/build/usr/local/bin
+	cp -r plugins /tmp/build/var/lib/dokku
+	find plugins/ -mindepth 1 -maxdepth 1 -type d -printf '%f\n' | while read plugin; do touch /tmp/build/var/lib/dokku/plugins/$$plugin/.core; done
+	$(MAKE) help2man
+	$(MAKE) addman
+	cp /usr/local/share/man/man1/dokku.1 /tmp/build/usr/local/share/man/man1/dokku.1
+	cp contrib/dokku-installer.rb /tmp/build/usr/local/share/dokku/contrib
+	git describe --tags > /tmp/build/var/lib/dokku/VERSION
+	cat /tmp/build/var/lib/dokku/VERSION | cut -d '-' -f 1 | cut -d 'v' -f 2 > /tmp/build/var/lib/dokku/STABLE_VERSION
+	git rev-parse HEAD > /tmp/build/var/lib/dokku/GIT_REV
+	sed -i "s/^Version: .*/Version: `cat /tmp/build/var/lib/dokku/STABLE_VERSION`/g" /tmp/build/DEBIAN/control
+	dpkg-deb --build /tmp/build "/vagrant/dokku_`cat /tmp/build/var/lib/dokku/STABLE_VERSION`_$(DOKKU_ARCHITECTURE).deb"
+	mv *.deb /tmp
+
+deb-gems: deb-setup
+	rm -rf /tmp/tmp /tmp/build rubygem-*.deb
+	mkdir -p /tmp/tmp /tmp/build
+
+	gem install --quiet --no-verbose --no-ri --no-rdoc --install-dir /tmp/tmp rack -v 1.5.2 > /dev/null
+	gem install --quiet --no-verbose --no-ri --no-rdoc --install-dir /tmp/tmp rack-protection -v 1.5.3 > /dev/null
+	gem install --quiet --no-verbose --no-ri --no-rdoc --install-dir /tmp/tmp sinatra -v 1.4.5 > /dev/null
+	gem install --quiet --no-verbose --no-ri --no-rdoc --install-dir /tmp/tmp tilt -v 1.4.1 > /dev/null
+
+	find /tmp/tmp/cache -name '*.gem' | xargs -rn1 fpm -d ruby -d ruby --prefix /var/lib/gems/1.9.1 -s gem -t deb -a $(GEM_ARCHITECTURE)
+	mv *.deb /tmp
+
+deb-pluginhook: deb-setup
+	rm -rf /tmp/tmp /tmp/build $(PLUGINHOOK_PACKAGE_NAME)
+	mkdir -p /tmp/tmp /tmp/build
+
+	echo "-> Cloning repository"
+	git clone -q "git@github.com:$(PLUGINHOOK_REPO_NAME).git" /tmp/tmp/pluginhook > /dev/null
+	rm -rf /tmp/tmp/pluginhook/.git /tmp/tmp/pluginhook/.gitignore
+
+	echo "-> Copying files into place"
+	mkdir -p /tmp/build/usr/local/bin $(GOPATH)
+	sudo apt-get install -qq -y git golang mercurial 2>&1 > /dev/null
+	export PATH=$(PATH):$(GOROOT)/bin:$(GOPATH)/bin && export GOROOT=$(GOROOT) && export GOPATH=$(GOPATH) && go get "code.google.com/p/go.crypto/ssh/terminal"
+	export PATH=$(PATH):$(GOROOT)/bin:$(GOPATH)/bin && export GOROOT=$(GOROOT) && export GOPATH=$(GOPATH) && cd /tmp/tmp/pluginhook && go build -o pluginhook
+	mv /tmp/tmp/pluginhook/pluginhook /tmp/build/usr/local/bin/pluginhook
+
+	echo "-> Creating $(PLUGINHOOK_PACKAGE_NAME)"
+	sudo fpm -t deb -s dir -C /tmp/build -n pluginhook -v $(PLUGINHOOK_VERSION) -a $(PLUGINHOOK_ARCHITECTURE) -p $(PLUGINHOOK_PACKAGE_NAME) --url "https://github.com/$(PLUGINHOOK_REPO_NAME)" --description $(PLUGINHOOK_DESCRIPTION) --license 'MIT License' .
+	mv *.deb /tmp
+
+deb-sshcommand: deb-setup
+	rm -rf /tmp/tmp /tmp/build $(SSHCOMMAND_PACKAGE_NAME)
+	mkdir -p /tmp/tmp /tmp/build
+
+	echo "-> Cloning repository"
+	git clone -q "git@github.com:$(SSHCOMMAND_REPO_NAME).git" /tmp/tmp/sshcommand > /dev/null
+	rm -rf /tmp/tmp/sshcommand/.git /tmp/tmp/sshcommand/.gitignore
+
+	echo "-> Copying files into place"
+	mkdir -p "/tmp/build/usr/local/bin"
+	cp /tmp/tmp/sshcommand/sshcommand /tmp/build/usr/local/bin/sshcommand
+	chmod +x /tmp/build/usr/local/bin/sshcommand
+
+	echo "-> Creating $(SSHCOMMAND_PACKAGE_NAME)"
+	sudo fpm -t deb -s dir -C /tmp/build -n sshcommand -v $(SSHCOMMAND_VERSION) -a $(SSHCOMMAND_ARCHITECTURE) -p $(SSHCOMMAND_PACKAGE_NAME) --url "https://github.com/$(SSHCOMMAND_REPO_NAME)" --description $(SSHCOMMAND_DESCRIPTION) --license 'MIT License' .
+	mv *.deb /tmp

debian/control

@@ -0,0 +1,10 @@
+Package: dokku
+Version: 0.3.12
+Section: base
+Priority: optional
+Architecture: amd64
+Depends: locales, git, make, curl, software-properties-common, lxc-docker (>= 1.4.0), gcc, python-software-properties, man-db, buildstep, sshcommand, pluginhook
+Pre-Depends: nginx, dnsutils, ruby, ruby-dev, rubygem-rack, rubygem-rack-protection, rubygem-sinatra, rubygem-tilt, apparmor, cgroup-lite
+Provides: dokku
+Maintainer: Jose Diaz-Gonzalez <dokku@josediazgonzalez.com>
+Description: Docker powered mini-Heroku in around 100 lines of Bash

debian/postinst

@@ -0,0 +1,30 @@
+#!/bin/sh
+set -e
+
+case "$1" in
+  abort-upgrade|abort-remove|abort-deconfigure)
+    ;;
+
+  configure)
+    mandb
+    [ ! -x /usr/bin/docker.io ] || ln -sf /usr/bin/docker.io /usr/local/bin/docker
+    modprobe aufs || echo "WARNING: Restart server to finish installing dokku!"
+    sshcommand create dokku /usr/local/bin/dokku
+    egrep -i "^docker" /etc/group || groupadd docker
+    usermod -aG docker dokku
+    dokku plugins-install
+    rm -f /home/dokku/VERSION
+    cp /var/lib/dokku/STABLE_VERSION /home/dokku/VERSION
+
+    if [ -f /etc/init/dokku-installer.conf ] && service dokku-installer status 2> /dev/null | grep waiting; then
+        sudo service dokku-installer start
+    fi
+    ;;
+
+  *)
+    echo "postinst called with unknown argument \`$1'" >&2
+    exit 1
+    ;;
+esac
+
+exit 0

debian/preinst

@@ -0,0 +1,40 @@
+#!/bin/sh
+set -e
+
+case "$1" in
+  install)
+    INIT_CONF="/etc/init/dokku-installer.conf"
+    NGINX_CONF="/etc/nginx/conf.d/dokku-installer.conf"
+
+    rm -f $INIT_CONF
+    touch $INIT_CONF
+    echo 'start on runlevel [2345]' >> $INIT_CONF
+    echo 'exec /usr/local/share/dokku/contrib/dokku-installer.rb selfdestruct' >> $INIT_CONF
+
+    rm -f $NGINX_CONF
+    touch $NGINX_CONF
+    echo 'upstream dokku-installer { server 127.0.0.1:2000; }' >> $NGINX_CONF
+    echo 'server {' >> $NGINX_CONF
+    echo '  listen      80;' >> $NGINX_CONF
+    echo '  location    / {' >> $NGINX_CONF
+    echo '    proxy_pass  http://dokku-installer;' >> $NGINX_CONF
+    echo '  }' >> $NGINX_CONF
+    echo '}' >> $NGINX_CONF
+
+    rm -f /etc/nginx/sites-enabled/*
+    service nginx reload
+    ;;
+
+  upgrade)
+    ;;
+
+  abort-upgrade)
+    ;;
+
+  *)
+    echo "preinst called with unknown argument \`$1'" >&2
+    exit 1
+    ;;
+esac
+
+exit 0

docs/advanced-installation.md

@@ -1,4 +1,10 @@
-#Advanced installation
+# Advanced installation
+
+You can always install dokku straight from the latest - potentially unstable - master release via the following bash command:
+
+```shell
+wget -qO- https://raw.github.com/progrium/dokku/master/bootstrap.sh | sudo bash
+```
 
 ## Development
 
@@ -33,5 +39,21 @@ Dokku ships with a pre-built version of version of the [buildstep](https://githu
 ```shell
 git clone https://github.com/progrium/dokku.git
 cd dokku
-sudo BUILD_STACK=true make install
+sudo BUILD_STACK=true STACK_URL=https://github.com/progrium/buildstep.git make install
 ```
+
+## Configuring
+
+Once dokku is installed, if you are not using the web-installer, you'll want to configure a the virtualhost setup as well as the push user. If you do not, your installation will be considered incomplete and you will not be able to deploy applications.
+
+Set up a domain and a wildcard domain pointing to that host. Make sure `/home/dokku/VHOST` is set to this domain. By default it's set to whatever hostname the host has. This file is only created if the hostname can be resolved by dig (`dig +short $(hostname -f)`). Otherwise you have to create the file manually and set it to your preferred domain. If this file still is not present when you push your app, dokku will publish the app with a port number (i.e. `http://example.com:49154` - note the missing subdomain).
+
+You'll have to add a public key associated with a username by doing something like this from your local machine:
+
+    $ cat ~/.ssh/id_rsa.pub | ssh dokku.me "sudo sshcommand acl-add dokku $USER"
+
+If you are using the vagrant installation, you can use the following command to add your public key to dokku:
+
+    $ cat ~/.ssh/id_rsa.pub | make vagrant-acl-add
+
+That's it!

docs/application-deployment.md

@@ -28,6 +28,16 @@ Dokku only supports deploying from its master branch, so if you'd like to deploy
 Right now Buildstep supports buildpacks for Node.js, Ruby, Python, [and more](https://github.com/progrium/buildstep#supported-buildpacks). It's not hard to add more, [go add more](https://github.com/progrium/buildstep#adding-buildpacks)!
 Please check the documentation for your particular build pack as you may need to include configuration files (such as a Procfile) in your project root.
 
+## Deploying with private git submodules
+
+Dokku uses git locally (i.e. not a docker image) to build its own copy of your app repo, including submodules. This is done as the `dokku` user. Therefore, in order to deploy private git submodules, you'll need to drop your deploy key in `~dokku/.ssh` and potentially add github.com (or your VCS host key) into `~dokku/.ssh/known_hosts`. A decent test like this should help confirm you've done it correctly.
+
+```
+su - dokku
+ssh-keyscan -t rsa github.com >> ~/.ssh/known_hosts
+ssh -T git@github.com
+```
+
 ## Specifying a custom buildpack
 
 If buildpack detection isn't working well for you or you want to specify a custom buildpack for one repository you can create & commit a file in the root of your git repository named `.env` containing `export BUILDPACK_URL=<repository>` before pushing. This will tell buildstep to fetch the specified buildpack and use it instead of relying on the built-in buildpacks & their detection methods.
@@ -106,5 +116,5 @@ Dokku will wait `DOKKU_WAIT_TO_RETIRE` seconds (default: `60`) before stopping t
 SSH onto the server, then execute:
 
 ```shell
-dokku delete myapp
+dokku apps:destroy myapp
 ```

docs/community/clients.md

@@ -0,0 +1,81 @@
+# Clients
+
+Given the constraints, running dokku commands remotely via SSH is fine. For certain configurations, the extra complication of manually invoking ssh can be a burden.
+
+While dokku does not yet have an official client, there are a multitude of ways in which you can interact with your dokku installation. The easiest is to use the **bash** client, though you may wish to use another.
+
+## (bash) `dokku_client.sh`
+
+Of all methods, this is the *most* official method of interacting with your dokku installation. It is a bash script that interacts with a remote dokku installation via ssh. It is available in `contrib/dokku_client.sh` in the root of the dokku repository.
+
+To install, simply clone the dokku repository down and add the `dokku` alias pointing at the script:
+
+```shell
+git clone git@github.com:progrium/dokku.git ~/.dokku
+
+# add the following to either your
+# .bashrc, .bash_profile, or .profile file
+alias dokku='$HOME/.dokku/contrib/dokku_client.sh'
+```
+
+Configure the `DOKKU_HOST` environment variable or run `dokku` from a repository with a git remote named dokku pointed at your dokku host in order to use the script as normal.
+
+## (nodejs) dokku-toolbelt
+
+Dokku-toolbelt is a node-based cli wrapper that proxies requests to the dokku command running on remote hosts. You can install it via the following shell command (assuming you have nodejs and npm installed):
+
+```shell
+npm install -g dokku-toolbelt
+```
+
+See [documentation here](https://www.npmjs.com/package/dokku-toolbelt) for more information.
+
+## (python) dokku-client
+
+dokku-client is an extensible python-based cli wrapper for remote dokku hosts.  You can install it via the following shell command (assuming you have python and pip installed):
+
+```shell
+pip install dokku-client
+```
+
+See [documentation here](https://github.com/adamcharnock/dokku-client) for more information.
+
+## (ruby) Dokku CLI
+
+Dokku CLI is a rubygem that acts as a client for your dokku installation. You can install it via the following shell command (assuming you have ruby and rubygems installed):
+
+```shell
+gem install dokku-cli
+```
+
+See [documentation here](https://github.com/SebastianSzturo/dokku-cli) for more information.
+
+## (ruby) DokkuClient
+
+DokkuClient is another rubygem that acts as a client for your dokku installation with built-in support for certain external plugins. You can install it via the following shell command (assuming you have ruby and rubygems installed):
+
+```shell
+gem install dokku_client
+```
+
+See [documentation here](https://github.com/netguru/dokku_client) for more information.
+
+## (ruby) Dokkufy
+
+Dokkufy is a rubygem that handles automation of certain tasks, such as dokku setup, plugin installation, etc. You can install it via the following shell command (assuming you have ruby and rubygems installed):
+
+```shell
+gem install dokkufy
+```
+
+See [documentation here](https://github.com/cbetta/dokkufy) for more information.
+
+## (ruby) Dockland
+
+Dockland is a rubygem that acts as a client for your dokku installation. You can install it via the following shell command (assuming you have ruby and rubygems installed):
+
+```shell
+gem install dockland
+```
+
+See [documentation here](https://github.com/uetchy/dockland) for more information.

docs/configuration-management.md

@@ -13,4 +13,4 @@ config:unset <app> KEY1 [KEY2 ...] - unset one or more config vars
 
 The variables are available both at at run time and during the application build/compilation step. You no longer need a `user-env` plugin as Dokku handles this functionality in a way equivalent to how Heroku handles it.
 
-> Note: Global `BUILD_ENV` files are currently migrated into a global `ENV` file. Configuring your global `ENV` file is manual, and should be considered potentially dangerous as configuration applies to all applications.
+> Note: Global `BUILD_ENV` files are currently migrated into a global `ENV` file and sourced before app-specific variables. This means that app-specific variables will take precedence over global variables. Configuring your global `ENV` file is manual, and should be considered potentially dangerous as configuration applies to all applications.

docs/development/plugin-creation.md

@@ -0,0 +1,81 @@
+# Plugin Creation
+
+If you create your own plugin:
+
+1. Take a look at the plugins shipped with dokku and hack away!
+2. Upload your plugin to github with a repository name in form of `dokku-<name>` (e.g. `dokku-mariadb`)
+3. Edit [this page](http://progrium.viewdocs.io/dokku/plugins) and add a link to it.
+4. Subscribe to the [dokku development blog](http://progrium.com) to be notified about API changes and releases
+
+### Sample plugin
+
+The below plugin is a dummy `dokku hello` plugin. If your plugin exposes commands, this is a good template for your `commands` file:
+
+```shell
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
+
+case "$1" in
+  hello)
+    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
+    verify_app_name "$2"
+    APP="$2";
+
+    echo "Hello $APP"
+    ;;
+
+  hello:world)
+    echo "Hello world"
+    ;;
+
+  help)
+    cat && cat<<EOF
+    hello <app>                                     Says "Hello <app>"
+    hello:world                                     Says "Hello world"
+EOF
+    ;;
+
+  *)
+    exit $DOKKU_NOT_IMPLEMENTED_EXIT
+    ;;
+
+esac
+```
+
+A few notes:
+
+- You should always support `DOKKU_TRACE` as specified on the 2nd line of the plugin.
+- If your command requires that an application exists, ensure you check for it's existence in the manner prescribed above.
+- A `help` command is required, though it is allowed to be empty.
+- Commands *should* be namespaced.
+- As of 0.3.3, a catch-all should be implemented which exits with a `DOKKU_NOT_IMPLEMENTED_EXIT` code. This allows dokku to output a `command not found` message.
+- Be sure you want the "set -eo pipefail" option. Look at the following example :
+
+    ```shell
+    IMAGE=$(docker images | grep "user/repo" | awk '{print $3}')
+    if [[ -z $IMAGE ]]; then
+        echo "user/repo image not found... Did you run 'dokku plugins-install'?"
+        exit 1
+    fi
+    ```
+
+  In the case where the "user/repo" is not installed, dokku exits just before the awk command,
+  you will never see the message printed with echo. You just want "set -e" in this case.
+
+  Here is the documentation of the 'set -eo pipefail' option:
+  ```
+  help set
+    Options:
+      -e  Exit immediately if a command exits with a non-zero status.
+      -o option-name
+          pipefail     the return value of a pipeline is the status of
+                       the last command to exit with a non-zero status,
+                       or zero if no command exited with a non-zero status
+  ```
+- As some plugins require access to set app config settings and do not want/require the default Heroku-style behavior of a restart, we have the following "internal" commands that provide this functionality :
+
+  ```shell
+  dokku config:set-norestart APP KEY1=VALUE1 [KEY2=VALUE2 ...]
+  dokku config:unset-norestart APP KEY1 [KEY2 ...]
+  ```

docs/development/pluginhooks.md

@@ -0,0 +1,591 @@
+# Pluginhooks
+
+[Pluginhooks](https://github.com/progrium/pluginhook) are a good way to jack into existing dokku infrastructure. You can use them to modify the output of various dokku commands or override internal configuration.
+
+Pluginhooks are simply scripts that are executed by the system. You can use any language you want, so long as the script:
+
+- Is executable
+- Has the proper language requirements installed
+
+For instance, if you wanted to write a pluginhook in PHP, you would need to have `php` installed and available on the CLI prior to pluginhook invocation.
+
+The following is an example for the `nginx-hostname` pluginhook. It reverses the hostname that is provided to nginx during deploys. If you created an executable file named `nginx-hostname` with the following code in your plugin, it would be invoked by dokku during the normal app deployment process:
+
+```shell
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+APP="$1"; SUBDOMAIN="$2"; VHOST="$3"
+
+NEW_SUBDOMAIN=`echo $SUBDOMAIN | rev`
+echo "$NEW_SUBDOMAIN.$VHOST"
+```
+
+## Available Pluginhooks
+
+There are a number of plugin-related pluginhooks. These can be optionally implemented by plugins and allow integration into the standard dokku plugin setup/backup/teardown process.
+
+The following pluginhooks describe those available to a dokku installation. As well, there is an example for each pluginhook that you can use as templates for your own plugin development.
+
+> The example pluginhook code is not guaranteed to be implemented as in within dokkku, and are merely simplified examples. Please look at the dokku source for larger, more in-depth examples.
+
+### `install`
+
+- Description: Used to setup any files/configuration for a plugin.
+- Invoked by: `dokku plugins-install`.
+- Arguments: None
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Sets the hostname of the dokku server
+# based on the output of `hostname -f`
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+if [[ ! -f  "$DOKKU_ROOT/HOSTNAME" ]]; then
+  hostname -f > $DOKKU_ROOT/HOSTNAME
+fi
+```
+
+### `dependencies`
+
+- Description: Used to install system-level dependencies. Invoked by `plugins-install-dependencies`.
+- Invoked by: `dokku plugins-install-dependencies`
+- Arguments: None
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Installs nginx for the current plugin
+# Supports both opensuse and ubuntu
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+case "$DOKKU_DISTRO" in
+  ubuntu)
+    export DEBIAN_FRONTEND=noninteractive
+    apt-get install --force-yes -qq -y nginx
+    ;;
+
+  opensuse)
+    zypper -q in -y nginx
+    ;;
+esac
+```
+
+### `update`
+
+- Description: Can be used to run plugin updates on a regular interval. You can schedule the invoker in a cron-task to ensure your system gets regular updates.
+- Invoked by: `dokku plugins-update`.
+- Arguments: None
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Update the buildstep image from git source
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+cd /root/dokku
+sudo BUILD_STACK=true make install
+```
+
+### `commands help`
+
+- Description: Used to aggregate all plugin `help` output. Your plugin should implement a `help` command in your `commands` file to take advantage of this pluginhook. This must be implemented inside the `commands` pluginhook file.
+- Invoked by: `dokku help`
+- Arguments: None
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Outputs help for the derp plugin
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+case "$1" in
+  help | derp:help)
+    cat && cat<<EOF
+    derp:herp                                       Herps the derp
+    derp:serp [file]                                Shows the file's serp
+EOF
+    ;;
+
+  *)
+    exit $DOKKU_NOT_IMPLEMENTED_EXIT
+    ;;
+
+esac
+```
+
+### `backup-export`
+
+- Description: Used to backup files for a given plugin. If your plugin writes files to disk, this pluginhook should be used to echo out their full paths. Any files listed will be copied by the backup plugin to the backup tar.gz.
+- Invoked by: `dokku backup:export`
+- Arguments: `$VERSION $DOKKU_ROOT`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Echos out the location of every `REDIRECT` file
+# that are used by the apps
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+shopt -s nullglob
+VERSION="$1"
+DOKKU_ROOT="$2"
+
+cat; for i in $DOKKU_ROOT/*/REDIRECT; do echo $i; done
+```
+
+### `backup-check`
+
+- Description: Checks that a backup being imported passes sanity checks.
+- Invoked by: `dokku backup:import`
+- Arguments: `$VERSION $BACKUP_ROOT $DOKKU_ROOT $BACKUP_TMP_DIR/.dokku_backup_apps`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `backup-import`
+
+- Description: Allows a plugin to import specific files from a `$BACKUP_ROOT` to the `DOKKU_ROOT` directory.
+- Invoked by: `dokku backup:import`
+- Arguments: `$VERSION $BACKUP_ROOT $DOKKU_ROOT $BACKUP_TMP_DIR/.dokku_backup_apps`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Copies all redirect files from the backup
+# into the correct app path.
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+shopt -s nullglob
+VERSION="$1"
+BACKUP_ROOT="$2"
+DOKKU_ROOT="$3"
+
+cd $BACKUP_ROOT
+for file in */REDIRECT; do
+  cp $file "$DOKKU_ROOT/$file"
+done
+```
+
+### `pre-build-buildstep`
+
+- Description: Allows you to run commands before the build image is created for a given app. For instance, this can be useful to add env vars to your container. Only applies to applications using buildstep.
+- Invoked by: `dokku build`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `post-build-buildstep`
+
+- Description: Allows you to run commands after the build image is create for a given app. Only applies to applications using buildstep.
+- Invoked by: `dokku build`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `pre-build-dockerfile`
+
+- Description: Allows you to run commands before the build image is created for a given app. For instance, this can be useful to add env vars to your container. Only applies to applications using a dockerfile.
+- Invoked by: `dokku build`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `post-build-dockerfile`
+
+- Description: Allows you to run commands after the build image is create for a given app. Only applies to applications using a dockerfile.
+- Invoked by: `dokku build`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `pre-release-buildstep`
+
+- Description: Allows you to run commands before environment variables are set for the release step of the deploy. Only applies to applications using buildstep.
+- Invoked by: `dokku release`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Installs the graphicsmagick package into the container
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+source "$(dirname $0)/../common/functions"
+
+dokku_log_info1" Installing GraphicsMagick..."
+
+CMD="cat > gm && \
+  dpkg -s graphicsmagick > /dev/null 2>&1 || \
+  (apt-get update && apt-get install -y graphicsmagick && apt-get clean)"
+
+ID=$(docker run -i -a stdin $IMAGE /bin/bash -c "$CMD")
+test $(docker wait $ID) -eq 0
+docker commit $ID $IMAGE > /dev/null
+```
+
+### `post-release-buildstep`
+
+- Description: Allows you to run commands after environment variables are set for the release step of the deploy. Only applies to applications using buildstep.
+- Invoked by: `dokku release`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Installs a package specified by the `CONTAINER_PACKAGE` env var
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+source "$(dirname $0)/../common/functions"
+
+dokku_log_info1" Installing $CONTAINER_PACKAGE..."
+
+CMD="cat > gm && \
+  dpkg -s CONTAINER_PACKAGE > /dev/null 2>&1 || \
+  (apt-get update && apt-get install -y CONTAINER_PACKAGE && apt-get clean)"
+
+ID=$(docker run -i -a stdin $IMAGE /bin/bash -c "$CMD")
+test $(docker wait $ID) -eq 0
+docker commit $ID $IMAGE > /dev/null
+```
+
+### `pre-release-dockerfile`
+
+- Description: Allows you to run commands before environment variables are set for the release step of the deploy. Only applies to applications using a dockerfile.
+- Invoked by: `dokku release`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `post-release-dockerfile`
+
+- Description: Allows you to run commands after environment variables are set for the release step of the deploy. Only applies to applications using a dockerfile.
+- Invoked by: `dokku release`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `check-deploy`
+
+- Description: Allows you to run checks on a deploy before dokku allows the container to handle requests.
+- Invoked by: `dokku deploy`
+- Arguments: `$CONTAINER_ID $APP $INTERNAL_PORT $INTERNAL_IP_ADDRESS`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Disables deploys of containers based on whether the
+# `DOKKU_DISABLE_DEPLOY` env var is set to `true` for an app
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+CONTAINERID="$1"; APP="$2"; PORT="$3" ; HOSTNAME="${4:-localhost}"
+
+[[ -f "$DOKKU_ROOT/$APP/ENV" ]] && source $DOKKU_ROOT/$APP/ENV
+DOKKU_DISABLE_DEPLOY="${DOKKU_DISABLE_DEPLOY:-false}"
+
+if [[ "$DOKKU_DISABLE_DEPLOY" = "true" ]]; then
+  echo -e "\033[31m\033[1mDeploys disabled, sorry.\033[0m"
+  exit 1
+fi
+```
+
+### `pre-deploy`
+
+- Description: Allows the running of code before the container's process is started.
+- Invoked by: `dokku deploy`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Runs gulp in our container
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+source "$(dirname $0)/../common/functions"
+
+APP="$1"
+IMAGE="dokku/$APP"
+
+dokku_log_info1 "Running gulp"
+id=$(docker run -d $IMAGE /bin/bash -c "cd /app && gulp default")
+test $(docker wait $id) -eq 0
+docker commit $id $IMAGE > /dev/null
+dokku_log_info1 "Building UI Complete"
+```
+
+### `post-deploy`
+
+- Description: Allows running of commands after a deploy has completed. Dokku core currently uses this to switch traffic on nginx.
+- Invoked by: `dokku deploy`
+- Arguments: `$APP $INTERNAL_PORT $INTERNAL_IP_ADDRESS`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Notify an external service that a successful deploy has occurred.
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+curl "http://httpstat.us/200"
+```
+
+### `pre-delete`
+
+- Description: Can be used to run commands before an app is deleted.
+- Invoked by: `dokku apps:destroy`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Clears out the gulp asset build cache for applications
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+APP="$1"; IMAGE="dokku/$APP"; GULP_CACHE_DIR="$DOKKU_ROOT/$APP/gulp"
+
+if [[ -d $GULP_CACHE_DIR ]]; then
+  docker run --rm -v "$GULP_CACHE_DIR:/gulp" "$IMAGE" find /gulp -depth -mindepth 1 -maxdepth 1 -exec rm -Rf {} \; || true
+fi
+```
+
+### `post-delete`
+
+- Description: Can be used to run commands after an application is deleted.
+- Invoked by: `dokku apps:destroy`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Runs a command to ensure that an app's
+# postgres installation is removed
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+APP="$1";
+
+dokku postgres:destroy $APP
+```
+
+### `docker-args-build`
+
+- Description:
+- Invoked by: `dokku build`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `docker-args-deploy`
+
+- Description:
+- Invoked by: `dokku deploy`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `docker-args-run`
+
+- Description:
+- Invoked by: `dokku run`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `bind-external-ip`
+
+- Description: Allows you to disable binding to the external box ip
+- Invoked by: `dokku deploy`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Force always binding to the docker ip, no matter
+# what the settings are for a given app.
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+echo false
+```
+
+### `post-domains-update`
+
+- Description: Allows you to run commands once the domain for an application has been updated.
+- Invoked by: `dokku domains:add`, `dokku domains:clear`, `dokku domains:remove`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Reloads haproxy for our imaginary haproxy plugin
+# that replaces the nginx-vhosts plugin
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+sudo service haproxy reload
+```
+
+### `git-pre-pull`
+
+- Description:
+- Invoked by: `dokku git-upload-pack`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `git-post-pull`
+
+- Description:
+- Invoked by: `dokku git-upload-pack`
+- Arguments: `$APP`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# TODO
+```
+
+### `nginx-hostname`
+
+- Description: Allows you to customize the hostname for a given application.
+- Invoked by: `dokku domains:setup`
+- Arguments: `$APP $SUBDOMAIN $VHOST`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Reverses the hostname for the application
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+APP="$1"; SUBDOMAIN="$2"; VHOST="$3"
+
+NEW_SUBDOMAIN=`echo $SUBDOMAIN | rev`
+echo "$NEW_SUBDOMAIN.$VHOST"
+```
+
+### `nginx-pre-reload`
+
+- Description: Run before nginx reloads hosts
+- Invoked by: `dokku nginx:build-config`
+- Arguments: `$APP $INTERNAL_PORT $INTERNAL_IP_ADDRESS`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# Runs a check against all nginx conf files
+# to ensure they are valid
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+nginx -t
+```
+
+### `receive-app`
+
+- Description: Allows you to customize what occurs when an app is received. Normally just triggers an application build.
+- Invoked by: `dokku git-hook`, `dokku ps:rebuild`
+- Arguments: `$APP $REV`
+- Example:
+
+```shell
+#!/usr/bin/env bash
+# For our imaginary mercurial plugin, triggers a rebuild
+
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+APP="$1"; REV="$2"
+
+dokku hg-build $APP $REV
+```

docs/getting-started/install/digitalocean.md

@@ -0,0 +1,7 @@
+# Digital Ocean
+
+On Digital Ocean, there is a pre-made image that can be run for Dokku. You can choose to run this image on any sized droplet, though larger droplets will allow you to run larger applications.
+
+When choosing your Droplet configuration, please disable IPv6 on the droplet. There are known issues with IPv6 on Digital Ocean and Docker, and many have been reported to the Dokku issue tracker.
+
+If you would like to run Dokku on an IPv6 Digital Ocean Droplet, please consult [this guide](https://jeffloughridge.wordpress.com/2015/01/17/native-ipv6-functionality-in-docker/) for modifying Docker to run under the Digital Ocean IPv6 configuration.

docs/getting-started/install/linode.md

@@ -0,0 +1,36 @@
+# Installing on Linode
+
+Due to how Linode installs custom kernels, Linode instances *require* a reboot before they can fully work with Docker/Dokku. The Official Dokku StackScript should take care of this process for you, and will email notify you when the instance is running and you can proceed with installation.
+
+## Using StackScript
+
+Deploy using the following (experimental) Official StackScript:
+
+- https://www.linode.com/stackscripts/view/11348
+
+## Without StackScript
+
+* Build a Ubuntu 13.04 instance
+
+* Follow these instructions: https://www.linode.com/docs/tools-reference/custom-kernels-distros/run-a-distributionsupplied-kernel-with-pvgrub#ubuntu-1304-raring
+
+* If `apt-get update` no longer works:
+
+    * Verify if apt-get is trying to use ipv6 instead of ipv4 (e.g. you read something like "[Connecting to us.archive.ubuntu.com (2001:67c:1562::14)]" and apt-get would not proceed). In that case, follow these instructions: http://unix.stackexchange.com/questions/9940/convince-apt-get-not-to-use-ipv6-method (append "precedence ::ffff:0:0/96  100" to /etc/gai.conf)
+
+    * OR: change `/etc/apt/sources.list` to one mentioned in http://mirrors.ubuntu.com/mirrors.txt
+
+* Run the following commands:
+
+    ```shell
+    apt-get update
+
+    apt-get install lxc wget bsdtar linux-image-extra-$(uname -r)
+
+    modprobe aufs
+    ```
+* After this, you can install dokku the default way:
+
+    ```shell
+    wget -qO- https://raw.github.com/progrium/dokku/master/bootstrap.sh | sudo bash
+    ```

docs/getting-started/install/vagrant.md

@@ -0,0 +1,39 @@
+# Install Dokku using Vagrant
+
+- Download and install [VirtualBox](https://www.virtualbox.org/wiki/Downloads)
+- Download and install [Vagrant](http://www.vagrantup.com/downloads.html)
+- Clone Dokku
+
+    ```
+    git clone https://github.com/progrium/dokku.git
+    ```
+
+- Setup SSH hosts in your `/etc/hosts`
+
+    ```
+    10.0.0.2 dokku.me
+    ```
+
+- Create VM
+    ```
+    # Optional ENV arguments:
+    # - `BOX_NAME`
+    # - `BOX_URI`
+    # - `BOX_MEMORY`
+    # - `DOKKU_DOMAIN`
+    # - `DOKKU_IP`.
+    cd path/to/dokku
+    vagrant up
+    ```
+- Setup SSH Config in `~/.ssh/config`. The port listed here is usually correct, though you may want to verify that it is the same as the one listed in the output of `vagrant ssh-config dokku`
+
+    ```
+    Host dokku.me
+        Port 2222
+    ```
+
+- Copy your SSH key via `cat ~/.ssh/id_rsa.pub | pbcopy` and paste it into the dokku-installer at http://dokku.me . Change the `Hostname` field on the Dokku Setup screen to your domain and then check the box that says `Use virtualhost naming`. Then click *Finish Setup* to install your key. You'll be directed to application deployment instructions from here.
+
+You are now ready to deploy an app or install plugins.
+
+For a different, complete, example see https://github.com/RyanBalfanz/dokku-vagrant-example.

docs/getting-started/where-to-get-help.md

@@ -0,0 +1,25 @@
+# Where to Get Help
+
+If you’re stuck, there are a number of places you can get help:
+
+## The Official Dokku Website
+
+[http://progrium.viewdocs.io/dokku](http://progrium.viewdocs.io/dokku)
+
+The Official Dokku website is always a great place to visit. It features links to oft-used developer tools, community plugins, and guides on using dokku.
+
+## The IRC Channel
+
+IRC Channel on irc.freenode.net:
+
+- #dokku – General Discussion
+
+If you’re stumped, give us a holler in the Dokku IRC channel. Someone from the development team is usually there, especially during the daylight hours for North and South America users. We’d love to hear from you, whether you need some help, want to find users in your area, or would like to donate your brand new sports car.
+
+If [here](http://webchat.freenode.net/?channels=dokku) for a web-based client IRC client.
+
+## Stackoverflow
+
+http://stackoverflow.com/
+
+Tag your questions with `dokku` to enable existing users of stackoverflow to find your questions.

docs/index.md

@@ -2,24 +2,36 @@
 
 Docker powered mini-Heroku. The smallest PaaS implementation you've ever seen.
 
-## Table Of Contents
+### Getting Started
 
 - [Installation](http://progrium.viewdocs.io/dokku/installation)
 - [Upgrading](http://progrium.viewdocs.io/dokku/upgrading)
 - [Troubleshooting](http://progrium.viewdocs.io/dokku/troubleshooting)
-- [Components](http://progrium.viewdocs.io/dokku/components)
+- [Getting Help](http://progrium.viewdocs.io/dokku/getting-started/where-to-get-help)
+
+### Deployment
+
 - [Application Deployment](http://progrium.viewdocs.io/dokku/application-deployment)
-- [Remote commands](http://progrium.viewdocs.io/dokku/remote-commands)
-- [Plugins](http://progrium.viewdocs.io/dokku/plugins)
 - [Configuration management](http://progrium.viewdocs.io/dokku/configuration-management)
+- [Process management](http://progrium.viewdocs.io/dokku/process-management)
+- [DNS Configuration](http://progrium.viewdocs.io/dokku/dns)
 - [Nginx Configuration](http://progrium.viewdocs.io/dokku/nginx)
-- [DNS](http://progrium.viewdocs.io/dokku/dns)
+- [Running Remote commands](http://progrium.viewdocs.io/dokku/remote-commands)
+
+### Community Contributions
+
+- [Clients](http://progrium.viewdocs.io/dokku/community/clients)
+- [Plugins](http://progrium.viewdocs.io/dokku/plugins)
+
+### Development
+
+- [Plugin Creation](http://progrium.viewdocs.io/dokku/development/plugin-creation)
+- [Pluginhooks](http://progrium.viewdocs.io/dokku/development/pluginhooks)
 
 ## Things this project won't do
 
- * **Multi-host.** Not a huge leap, but this isn't the project for it. Have a look at [Deis](http://deis.io/).
- * **Multitenancy.** It's ready for it, but again, have a look at [Deis](http://deis.io/).
- * **Client app.** Given the constraints, running commands remotely via SSH is fine.
+ * **Multi-host.** It runs on one host. If you need more, have a look at [Deis](http://deis.io/).
+ * **Multitenancy.** Multi-app, and loosely multi-user based on SSH keys, but that's it.
 
 ## Sponsors
 

docs/installation.md

@@ -11,145 +11,23 @@ Ubuntu 14.04 x64 x64. Ideally have a domain ready to point to your host. It's de
 To install the latest stable version of dokku, you can run the following bootstrapper command:
 
 ```shell
-wget -qO- https://raw.github.com/progrium/dokku/v0.3.13/bootstrap.sh | sudo DOKKU_TAG=v0.3.13 bash
+# This may need to be run twice
+wget -qO- https://raw.github.com/progrium/dokku/v0.3.16/bootstrap.sh | sudo DOKKU_TAG=v0.3.16 bash
+
+# Install the web installer. See `Configuring` under
+# `Advanced Install Customization` if you wish to perform the
+# rest of the install via CLI
+cd /root/dokku && make dokku-installer
+
+# Go to your server's IP and follow the web installer
 ```
 
-## Configuring
+For various reasons, certain hosting providers may have other steps that should be preferred to the above. If hosted on any of the following popular hosts, please follow the linked to instructions:
 
-Set up a domain and a wildcard domain pointing to that host. Make sure `/home/dokku/VHOST` is set to this domain. By default it's set to whatever hostname the host has. This file is only created if the hostname can be resolved by dig (`dig +short $(hostname -f)`). Otherwise you have to create the file manually and set it to your preferred domain. If this file still is not present when you push your app, dokku will publish the app with a port number (i.e. `http://example.com:49154` - note the missing subdomain).
+- [Digital Ocean Installation Notes](http://progrium.viewdocs.io/dokku/getting-started/install/digitalocean)
+- [Linode Installation Notes](http://progrium.viewdocs.io/dokku/getting-started/install/linode)
 
-You'll have to add a public key associated with a username by doing something like this from your local machine:
+As well, you may wish to customize your installation in some other fashion. or experiment with vagrant. The guides below should get you started:
 
-    $ cat ~/.ssh/id_rsa.pub | ssh dokku.me "sudo sshcommand acl-add dokku $USER"
-
-That's it!
-
-## Advanced installation
-
-### Development via bash script
-
-```shell
-wget -qO- https://raw.github.com/progrium/dokku/master/bootstrap.sh | sudo bash
-```
-
-This may take around 5 minutes. Certainly better than the several hours it takes to bootstrap Cloud Foundry.
-
-You may also wish to take a look at the [advanced installation](http://progrium.viewdocs.io/dokku/advanced-installation) document for additional installation options.
-
-### Development From Source
-
-If you plan on developing dokku, the easiest way to install from your own repository is cloning
-the repository and calling the install script. Example:
-
-```shell
-git clone https://github.com/yourusername/dokku.git
-cd dokku
-sudo make install
-```
-
-The `Makefile` allows source URLs to be overridden to include customizations from your own
-repositories. The `DOCKER_URL`, `PLUGINHOOK_URL`, `SSHCOMMAND_URL` and `STACK_URL`
-environment variables may be set to override the defaults (see the `Makefile` for how these
-apply). Example:
-
-```shell
-sudo SSHCOMMAND_URL=https://raw.github.com/yourusername/sshcommand/master/sshcommand make install
-```
-
-### Bootstrap a server from your own repository
-
-The bootstrap script allows the dokku repository URL to be overridden to bootstrap a host from
-your own clone of dokku using the `DOKKU_REPO` environment variable. Example:
-
-```shell
-wget https://raw.github.com/progrium/dokku/master/bootstrap.sh
-chmod +x bootstrap.sh
-sudo DOKKU_REPO=https://github.com/yourusername/dokku.git ./bootstrap.sh
-```
-
-### Custom buildstep build
-
-Dokku ships with a pre-built version of the [buildstep](https://github.com/progrium/buildstep) component by
-default. If you want to build your own version you can specify that with an env
-variable.
-
-```shell
-git clone https://github.com/progrium/dokku.git
-cd dokku
-sudo BUILD_STACK=true make install
-```
-
-### Install Dokku using Vagrant
-
-- Download and install [VirtualBox](https://www.virtualbox.org/wiki/Downloads)
-- Download and install [Vagrant](http://www.vagrantup.com/downloads.html)
-- Clone Dokku
-
-    ```
-    git clone https://github.com/progrium/dokku.git
-    ```
-
-- Setup SSH hosts in your `/etc/hosts`
-
-    ```
-    10.0.0.2 dokku.me
-    ```
-
-- Setup SSH Config in `~/.ssh/config`
-
-    ```
-    Host dokku.me
-        Port 2222
-    ```
-
-- Create VM
-    ```
-    # Optional ENV arguments:
-    # - `BOX_NAME`
-    # - `BOX_URI`
-    # - `BOX_MEMORY`
-    # - `DOKKU_DOMAIN`
-    # - `DOKKU_IP`.
-    cd path/to/dokku
-    vagrant up
-    ```
-
-- Copy your SSH key via `cat ~/.ssh/id_rsa.pub | pbcopy` and paste it into the dokku-installer at http://dokku.me . Change the `Hostname` field on the Dokku Setup screen to your domain and then check the box that says `Use virtualhost naming`. Then click *Finish Setup* to install your key. You'll be directed to application deployment instructions from here.
-
-You are now ready to deploy an app or install plugins.
-
-For a different, complete, example see https://github.com/RyanBalfanz/dokku-vagrant-example.
-
-### Installing on Linode
-
-#### Using StackScript
-
-Deploy using the following StackScript:
-* https://www.linode.com/stackscripts/view/8552
-
-#### Without StackScript
-
-* Build a Ubuntu 13.04 instance
-
-* Follow these instructions: https://www.linode.com/wiki/index.php/PV-GRUB#Ubuntu_12.04_Precise
-
-* If `apt-get update` no longer works:
-
-    * Verify if apt-get is trying to use ipv6 instead of ipv4 (e.g. you read something like "[Connecting to us.archive.ubuntu.com (2001:67c:1562::14)]" and apt-get would not proceed). In that case, follow these instructions: http://unix.stackexchange.com/questions/9940/convince-apt-get-not-to-use-ipv6-method (append "precedence ::ffff:0:0/96  100" to /etc/gai.conf)
-
-    * OR: change `/etc/apt/sources.list` to one mentioned in http://mirrors.ubuntu.com/mirrors.txt
-
-* Run the following commands:
-
-    ```shell
-    apt-get update
-
-    apt-get install lxc wget bsdtar linux-image-extra-$(uname -r)
-
-    modprobe aufs
-    ```
-* After this, you can install dokku the default way:
-
-    ```shell
-    wget -qO- https://raw.github.com/progrium/dokku/master/bootstrap.sh | sudo bash
-    ```
+- [Vagrant Installation Notes](http://progrium.viewdocs.io/dokku/getting-started/install/vagrant)
+- [Advanced Install Customization](http://progrium.viewdocs.io/dokku/advanced-installation)

docs/nginx.md

@@ -8,7 +8,7 @@ Dokku provides easy TLS/SPDY support out of the box. This can be done app-by-app
 
 ### Per App
 
-To enable TLS connection to to one of your applications, copy or symlink the `.crt`/`.pem` and `.key` files into the application's `/home/dokku/:app/tls` folder (create this folder if it doesn't exist) as `server.crt` and `server.key` respectively.
+To enable TLS connection to to one of your applications, copy or symlink the `.crt` and `.key` files into the application's `/home/dokku/:app/tls` folder (create this folder if it doesn't exist) as `server.crt` and `server.key` respectively.
 
 Redeployment of the application will be needed to apply TLS configuration. Once it is redeployed, the application will be accessible by `https://` (redirection from `http://` is applied as well).
 
@@ -16,7 +16,7 @@ Redeployment of the application will be needed to apply TLS configuration. Once
 
 To enable TLS connections for all your applications at once you will need a wildcard TLS certificate.
 
-To enable TLS across all apps, copy or symlink the `.crt`/`.pem` and `.key` files into the  `/home/dokku/tls` folder (create this folder if it doesn't exist) as `server.crt` and `server.key` respectively. Then, enable the certificates by editing `/etc/nginx/conf.d/dokku.conf` and uncommenting these two lines (remove the #):
+To enable TLS across all apps, copy or symlink the `.crt` and `.key` files into the  `/home/dokku/tls` folder (create this folder if it doesn't exist) as `server.crt` and `server.key` respectively. Then, enable the certificates by editing `/etc/nginx/conf.d/dokku.conf` and uncommenting these two lines (remove the #):
 
 ```
 ssl_certificate /home/dokku/tls/server.crt;
@@ -158,3 +158,18 @@ CONTAINER ID        IMAGE                      COMMAND                CREATED
 d6499edb0edb        dokku/node-js-app:latest   "/bin/bash -c '/star   About a minute ago   Up About a minute   0.0.0.0:49153->5000/tcp   nostalgic_tesla
 
 ```
+
+# Default site
+
+By default, dokku will route any received request with an unknown HOST header value to the lexicographically first site in the nginx config stack. If this is not the desired behavior, you may want to add the following configuration to nginx. This will catch all unknown HOST header values and return a `410 Gone` response.
+
+```
+server {
+  listen 80 default_server;
+  listen [::]:80 default_server;
+
+  server_name _;
+  return 410;
+  log_not_found off;
+}
+```

docs/plugins.md

@@ -21,55 +21,7 @@ dokku plugins-install
 
 ## Creating your own plugin
 
-If you create your own plugin:
-
-1. take a look at the plugins shipped with dokku and hack away!
-2. upload your plugin to github with a repository name in form of `dokku-<name>` (e.g. `dokku-mariadb`)
-3. edit this page and add a link to it below!
-4. subscribe to the [dokku development blog](http://progrium.com) to be notified about API changes and releases
-
-### Sample plugin
-
-The below plugin is a dummy `dokku hello` plugin. If your plugin exposes commands, this is a good template for your `commands` file:
-
-```shell
-#!/usr/bin/env bash
-set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
-
-case "$1" in
-  hello)
-    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
-    APP="$2";
-
-    echo "Hello $APP"
-    ;;
-
-  hello:world)
-    echo "Hello world"
-    ;;
-
-  help)
-    cat && cat<<EOF
-    hello <app>                                     Says "Hello <app>"
-    hello:world                                     Says "Hello world"
-EOF
-    ;;
-
-  *)
-    exit $DOKKU_NOT_IMPLEMENTED_EXIT
-    ;;
-
-esac
-```
-
-A few notes:
-
-- You should always support `DOKKU_TRACE` as specified on the 2nd line of the plugin.
-- If your command requires that an application exists, ensure you check for it's existence in the manner prescribed above.
-- A `help` command is required, though it is allowed to be empty.
-- Commands *should* be namespaced.
-- As of 0.3.3, a catch-all should be implemented which exits with a `DOKKU_NOT_IMPLEMENTED_EXIT` code. This allows dokku to output a `command not found` message.
+[See the full documentation](http://progrium.viewdocs.io/dokku/development/plugin-creation).
 
 ## Community plugins
 
@@ -108,6 +60,7 @@ Note: The following plugins have been supplied by our community and may not have
 [motin]: https://github.com/motin
 [musicglue]: https://github.com/musicglue
 [neam]: https://github.com/neam
+[nickstenning]: https://github.com/nickstenning
 [nornagon]: https://github.com/nornagon
 [ohardy]: https://github.com/ohardy
 [pauldub]: https://github.com/pauldub
@@ -122,6 +75,9 @@ Note: The following plugins have been supplied by our community and may not have
 [thrashr888]: https://github.com/thrashr888
 [wmluke]: https://github.com/wmluke
 [Zenedith]: https://github.com/Zenedith
+[sekjun9878]: https://github.com/sekjun9878
+[Flink]: https://github.com/Flink
+[ribot]: https://github.com/ribot
 
 ### Datastores
 
@@ -147,6 +103,7 @@ Note: The following plugins have been supplied by our community and may not have
 | [Memcached](https://github.com/jlachowski/dokku-memcached-plugin)                                 | [jlachowski][]        | IP & PORT available directly in linked app container env variables (requires link plugin)|
 | [Redis](https://github.com/jezdez/dokku-redis-plugin)                                             | [jezdez][]            | Requires https://github.com/rlaneve/dokku-link; compatible with 0.2.0 |
 | [Redis](https://github.com/luxifer/dokku-redis-plugin)                                            | [luxifer][]           |                       |
+| [Redis](https://github.com/sekjun9878/dokku-redis-plugin)                                         | [sekjun9878][]        | A better Redis plugin with automatic instance creation and Dokku Link support
 | [Redis (single container)](https://github.com/ohardy/dokku-redis)                                 | [ohardy][]            | Compatible with 0.2.0 |
 | [Varnish](https://github.com/Zenedith/dokku-varnish-plugin)                                       | [Zenedith][]          | Varnish cache between nginx and application with base configuration|
 
@@ -162,6 +119,9 @@ Note: The following plugins have been supplied by our community and may not have
 | Plugin                                                                                            | Author                | Compatibility         |
 | ------------------------------------------------------------------------------------------------- | --------------------- | --------------------- |
 | [CouchDB](https://github.com/racehub/dokku-couchdb-plugin)                                        | [RaceHub][]           | Compatible with 0.2.0 |
+| [Elasticsearch](https://github.com/robv/dokku-elasticsearch)                                      | [robv][]              | Not compatible with >= 0.3.0 (still uses /home/git) |
+| [Elasticsearch](https://github.com/jezdez/dokku-elasticsearch-plugin)                             | [jezdez][]            | Compatible with 0.2.0 to 0.3.13 |
+| [Elasticsearch](https://github.com/blag/dokku-elasticsearch-plugin)<sup>1</sup>                   | [blag][]              | Compatible with 0.2.0 |
 | [MongoDB (single container)](https://github.com/jeffutter/dokku-mongodb-plugin)                   | [jeffutter][]         |                       |
 | [RethinkDB](https://github.com/stuartpb/dokku-rethinkdb-plugin)                                   | [stuartpb][]          | 2014-02-22: targeting dokku @ [latest][217d00a]; will fail with Dokku earlier than [28de3ec][]. |
 | [RiakCS (single container)](https://github.com/jeffutter/dokku-riakcs-plugin)                     | [jeffutter][]         | Incompatible with 0.2.0 (checked at [dccee02][]) |
@@ -187,61 +147,74 @@ Note: The following plugins have been supplied by our community and may not have
 | Plugin                                                                                            | Author                | Compatibility         |
 | ------------------------------------------------------------------------------------------------- | --------------------- | --------------------- |
 | [app-url](https://github.com/mikecsh/dokku-app-url)                                               | [mikecsh][]           | Works with 0.2.0      |
-| [Custom Domains](https://github.com/neam/dokku-custom-domains)                                    | [motin][]             | Compatible with 0.2.* |
-| [Debug](https://github.com/heichblatt/dokku-debug)                                                | [heichblatt][]        |                       |
 | [Docker Direct](https://github.com/heichblatt/dokku-docker-direct)                                | [heichblatt][]        |                       |
 | [Docker Options](https://github.com/dyson/dokku-docker-options)                                   | [dyson][]             | dokku >= [c77cbf1][]  |
 | [Dokku Name](https://github.com/alex-sherwin/dokku-name)                                          | [alex-sherwin][]      | dokku >= [c77cbf1][]  |
-| [Dokku Registry](https://github.com/agco-adm/dokku-registry)                                      | [agco-adm][]          |                       |
+| [Dokku Registry](https://github.com/agco-adm/dokku-registry)<sup>1</sup>                          | [agco-adm][]          |                       |
 | [git rev-parse HEAD in env](https://github.com/nornagon/dokku-git-rev)                            | [nornagon][]          | Compatible with 0.2.0 |
 | [HTTP Auth Secure Apps](https://github.com/matto1990/dokku-secure-apps)                           | [matto1990][]         | Works with v0.2.3     |
 | [Host Port binding](https://github.com/stuartpb/dokku-bind-port)                                  | [stuartpb][]          | dokku >= [c77cbf1][]. 2014-02-17: [a043e98][] targeting dokku @ [latest][217d00a] |
 | [Hostname](https://github.com/michaelshobbs/dokku-hostname)                                       | [michaelshobbs][]     |                       |
 | [Link Containers](https://github.com/rlaneve/dokku-link)                                          | [rlaneve][]           | dokku >= [c77cbf1][]  |
 | [Multi-Buildpack](https://github.com/pauldub/dokku-multi-buildpack)                               | [pauldub][]           |                       |
-| [Multiple Domains](https://github.com/wmluke/dokku-domains-plugin)<sup>4</sup>                    | [wmluke][]            | Compatible with 0.2.0 |
 | [Nginx-Alt](https://github.com/mikexstudios/dokku-nginx-alt)                                      | [mikexstudios][]      | Works with v0.2.3     |
 | [Persistent Storage](https://github.com/dyson/dokku-persistent-storage)                           | [dyson][]             | Requires dokku >= [c77cbf1][] |
 | [Ports](https://github.com/heichblatt/dokku-ports)                                                | [heichblatt][]        |                       |
 | [Pre-Deploy Tasks](https://github.com/michaelshobbs/dokku-app-predeploy-tasks)                    | [michaelshobbs][]     |                       |
-| [Rebuild application](https://github.com/scottatron/dokku-rebuild)                                | [scottatron][]        | Compatible with 0.2.x |
 | [SSH Deployment Keys](https://github.com/cedricziel/dokku-deployment-keys)<sup>2</sup>            | [cedricziel][]        | 2014-01-17: compatible with upstream/master |
 | [SSH Hostkeys](https://github.com/cedricziel/dokku-hostkeys-plugin)<sup>3</sup>                   | [cedricziel][]        | 2014-01-17: compatible with upstream/master |
-| [Supply env vars to buildpacks](https://github.com/cameron-martin/dokku-build-env)                | [cameron-martin][]    | Works with v0.2.3     |
 | [VHOSTS Custom Configuration](https://github.com/neam/dokku-nginx-vhosts-custom-configuration)    | [motin][]             | Compatible with 0.3.1 |
 | [Volume (persistent storage)](https://github.com/ohardy/dokku-volume)                             | [ohardy][]            | Compatible with 0.2.0 |
+| [Maintenance mode](https://github.com/Flink/dokku-maintenance)                                    | [Flink][]             |                       |
+| [HTTP Auth](https://github.com/Flink/dokku-http-auth)                                             | [Flink][]             |                       |
 
 [8fca220]: https://github.com/progrium/dokku/commit/8fca2204edb0017796d6915ca9157c05b1238e28
 [217d00a]: https://github.com/progrium/dokku/commit/217d00a1bc47a7e24d8847617bb08a1633025fc7
 [98332de]: https://github.com/dyson/dokku-persistent-storage/commit/98332de4b5b640610bee535f4d5260263074e18b
 [a043e98]: https://github.com/stuartpb/dokku-bind-port/commit/a043e9892f4815b6525c850131e09fd64db5c1fa
 
+<sup>1</sup> On Heroku similar functionality is offered by the [heroku-labs pipeline feature](https://devcenter.heroku.com/articles/labs-pipelines), which allows you to promote builds across multiple environments (staging -> production)
+
 <sup>2</sup> Adds the possibility to add SSH deployment keys to receive private hosted packages
 
 <sup>3</sup> Adds the ability to add custom hosts to the containers known_hosts file to be able to ssh them easily (useful with deployment keys)
 
-<sup>4</sup> Conflicts with [VHOSTS Custom Configuration](https://github.com/neam/dokku-nginx-vhosts-custom-configuration)
-
-<sup>5</sup> On Heroku similar functionality is offered by the [heroku-labs pipeline feature](https://devcenter.heroku.com/articles/labs-pipelines), which allows you to promote builds across multiple environments (staging -> production)
-
-### Other Add-ons
+### Other Plugins
 
 | Plugin                                                                                            | Author                | Compatibility         |
 | ------------------------------------------------------------------------------------------------- | --------------------- | --------------------- |
-| [Wordpress](https://github.com/dudagroup/dokku-wordpress-template)                                                   | [abossard][]         | Dokku dev, mariadb, volume, domains                      |
+| [Wordpress](https://github.com/dudagroup/dokku-wordpress-template)                                | [abossard][]          | Dokku dev, mariadb, volume, domains |
 | [Node](https://github.com/pnegahdar/dokku-node)                                                   | [pnegahdar][]         |                       |
 | [Node](https://github.com/ademuk/dokku-nodejs)                                                    | [ademuk][]            |                       |
 | [Chef cookbooks](https://github.com/fgrehm/chef-dokku)                                            | [fgrehm][]            |                       |
 | [Bower install](https://github.com/alexanderbeletsky/dokku-bower-install)                         | [alexanderbeletsky][] |                       |
 | [Bower/Grunt](https://github.com/thrashr888/dokku-bower-grunt-build-plugin)                       | [thrashr888][]        |                       |
 | [Bower/Gulp](https://github.com/gdi2290/dokku-bower-gulp-build-plugin)                            | [gdi2290][]           |                       |
-| [Elasticsearch](https://github.com/robv/dokku-elasticsearch)                                      | [robv][]              |                       |
-| [Elasticsearch](https://github.com/jezdez/dokku-elasticsearch-plugin)                             | [jezdez][]            | Compatible with 0.2.0 |
-| [Elasticsearch](https://github.com/blag/dokku-elasticsearch-plugin)<sup>1</sup>                   | [blag][]              | Compatible with 0.2.0 |
 | [HipChat Notifications](https://github.com/cef/dokku-hipchat)                                     | [cef][]               |                       |
+| [Slack Notifications](https://github.com/ribot/dokku-slack)                                       | [ribot][]             |                       |
 | [Graphite/statsd](https://github.com/jlachowski/dokku-graphite-plugin)                            | [jlachowski][]        |                       |
 | [APT](https://github.com/F4-Group/dokku-apt)                                                      | [F4-Group][]          |                       |
 | [User ACL](https://github.com/mlebkowski/dokku-acl)                                               | [Maciej Łebkowski][]  |                       |
 | [PrimeCache](https://github.com/darkpixel/dokku-prime-cache)                                      | [darkpixel][]         |                       |
+| [Webhooks](https://github.com/nickstenning/dokku-webhooks)                                        | [nickstenning][]      |                       |
+| [Rails logs](https://github.com/Flink/dokku-rails-logs)                                           | [Flink][]             |                       |
+| [Airbrake deploy](https://github.com/Flink/dokku-airbrake-deploy)                                 | [Flink][]             |                       |
 
 <sup>1</sup> Forked from [jezdez/dokku-elasticsearch-plugin](https://github.com/jezdez/dokku-elasticsearch-plugin): uses Elasticsearch 1.2 (instead of 0.90), doesn't depend on dokku-link, runs as elasticsearch user instead of root, and turns off multicast autodiscovery for use in a VPS environment.
+
+### Deprecated Plugins
+
+The following plugins have been removed as their functionality is now in Dokku Core.
+
+| Plugin                                                                                            | Author                | In Dokku Since            |
+| ------------------------------------------------------------------------------------------------- | --------------------- | ------------------------- |
+| [Custom Domains](https://github.com/neam/dokku-custom-domains)                                    | [motin][]             | v0.3.10 (domains plugin)  |
+| [Debug](https://github.com/heichblatt/dokku-debug)                                                | [heichblatt][]        | v0.3.9 (trace command)    |
+| [Multiple Domains](https://github.com/wmluke/dokku-domains-plugin)<sup>1</sup>                    | [wmluke][]            | v0.3.10 (domains plugin)  |
+| [Rebuild application](https://github.com/scottatron/dokku-rebuild)                                | [scottatron][]        | v0.3.14 (ps plugin)       |
+| [Supply env vars to buildpacks](https://github.com/cameron-martin/dokku-build-env)<sup>2</sup>    | [cameron-martin][]    | v0.3.9 (build-env plugin) |
+| [user-env-compile](https://github.com/musicglue/dokku-user-env-compile)<sup>2</sup>               | [musicglue][]         | v0.3.9 (build-env plugin) |
+| [user-env-compile](https://github.com/motin/dokku-user-env-compile)<sup>2</sup>                   | [motin][]             | v0.3.9 (build-env plugin) |
+
+<sup>1</sup> Conflicts with [VHOSTS Custom Configuration](https://github.com/neam/dokku-nginx-vhosts-custom-configuration)
+<sup>2</sup> Similar to the heroku-labs feature (see https://devcenter.heroku.com/articles/labs-user-env-compile)

docs/process-management.md

@@ -0,0 +1,13 @@
+# Process/Container management
+
+Dokku supports rudimentary process (really container) management via the `ps` plugin.
+
+```
+ps <app>                                        List processes running in app container(s)
+ps:start <app>                                  Start app container(s)
+ps:stop <app>                                   Stop app container(s)
+ps:restart <app>                                Restart app container(s)
+ps:restartall                                   Restart all deployed app containers
+```
+
+*NOTE*: As of v0.3.14, `dokku deploy:all` in now deprecated by `ps:restartall` and will be removed in a future version.

docs/remote-commands.md

@@ -17,3 +17,15 @@ It's possible to run commands in the environment of the deployed application:
 dokku run node-js-app ls -alh
 dokku run <app> <cmd>
 ```
+
+## Behavioral modifiers
+
+Dokku also supports certain command-line arguments that augment it's behavior. If using these over ssh, you must use the form `ssh -t dokku@dokku.me -- <command>`
+in order to avoid ssh interpretting dokku arguments for itself.
+
+```shell
+--quiet                suppress output headers
+--trace                enable DOKKU_TRACE for current execution only
+--rm|--rm-container    remove docker container after successful dokku run <app> <command>
+--force                force flag. currently used in apps:destroy
+```

docs/troubleshooting.md

@@ -56,6 +56,41 @@ This will trace all of dokku's activity. If this does not help you, create a [gi
 
 ***
 
+__Symptom:__ I get the aforementioned error in the build phase (after turning on dokku tracing)
+
+  Most errors that happen in this phase are due to transient network issues (either locally or remotely) buildpack bugs.
+
+__Solution (Less solution, more helpful troubleshooting steps):__
+
+  Find the failed phase's container image (*077581956a92* in this example)
+
+    ```
+    root@dokku:~# docker ps -a  | grep builder
+    94d9515e6d93        077581956a92                "/build/builder"       29 minutes ago      Exited (0) 25 minutes ago                       cocky_bell
+    ```
+
+  Start a new container with the failed image and poke around (i.e. ensure you can access the internet from within the container or attempt the failed command, if known)
+
+    ```
+    root@dokku:~# docker run -ti 077581956a92 /bin/bash
+    root@9763ab86e1b4:/# curl -s -S icanhazip.com
+    192.168.0.1
+    curl http://s3pository.heroku.com/node/v0.10.30/node-v0.10.30-linux-x64.tar.gz -o node-v0.10.30-linux-x64.tar.gz
+    tar tzf node-v0.10.30-linux-x64.tar.gz
+    ...
+    ```
+
+  Sometimes (especially on DO) deploying again seems to get past these seemingly transient issues
+  Additionally we've seen issues if changing networks that have different DNS resolvers. In this case, you can run the following to update your resolv.conf
+
+  ```
+  root@dokku:~# resolvconf -u
+  ```
+
+Please see https://github.com/progrium/dokku/issues/841 and https://github.com/progrium/dokku/issues/649
+
+***
+
 __Symptom:__ I want to deploy my app but I am getting asked for the password of the git user and the error message
 
     fatal: 'NAME' does not appear to be a git repository
@@ -105,3 +140,4 @@ When specifying your port you may want to use something similar to:
     var port = process.env.PORT || 3000
 
 Please see https://github.com/progrium/dokku/issues/282
+

docs/upgrading.md

@@ -8,7 +8,7 @@ To update the deploy step (this is updated less frequently):
 
 ```shell
 cd ~/dokku
-git pull origin master
+git pull --tags origin master
 sudo make install
 ```
 
@@ -60,7 +60,7 @@ There is an upgrade [script](https://gist.github.com/plietar/7201430), which is
 1. run the script as root
 2. `git pull` to get the latest version of dokku
 3. make install
-4. `dokku deploy:all`
+4. `dokku ps:restartall`
 
 TDB.
 

dokku

@@ -10,11 +10,26 @@ export PLUGIN_PATH=${PLUGIN_PATH:="/var/lib/dokku/plugins"}
 export DOKKU_NOT_IMPLEMENTED_EXIT=10
 export DOKKU_VALID_EXIT=0
 
+source "$PLUGIN_PATH/common/functions"
+
 [[ -f $DOKKU_ROOT/dokkurc ]] && source $DOKKU_ROOT/dokkurc
 [[ -d $DOKKU_ROOT/.dokkurc ]] && for f in $DOKKU_ROOT/.dokkurc/*; do source $f; done
 
 [[ $DOKKU_TRACE ]] && set -x
 
+parse_args "$@"
+args=("$@")
+if [[ "${args[0]}" =~ ^--.* ]]; then
+  for arg in "$@"; do
+    if [[ "$arg" =~ ^--.* ]];then
+      shift 1
+    else
+      break
+    fi
+  done
+fi
+! has_tty && DOKKU_QUIET_OUTPUT=1
+
 if [[ $(id -un) != "dokku" && $1 != plugins-install* && $1 != "plugins-update" ]]; then
   sudo -u dokku -E -H $0 "$@"
   exit
@@ -33,45 +48,20 @@ fi
 
 case "$1" in
   receive)
-    APP="$2"; IMAGE="dokku/$APP"
-    echo "-----> Cleaning up ..."
+    APP="$2"; IMAGE="dokku/$APP"; IMAGE_SOURCE_TYPE="$3"; TMP_WORK_DIR="$4"
+    dokku_log_info1 "Cleaning up..."
     dokku cleanup
-    echo "-----> Building $APP ..."
-    cat | dokku build $APP
-    echo "-----> Releasing $APP ..."
-    dokku release $APP
-    echo "-----> Deploying $APP ..."
-    dokku deploy $APP
-    echo "=====> Application deployed:"
-         dokku urls $APP | sed "s/^/       /"
+    dokku_log_info1 "Building $APP from $IMAGE_SOURCE_TYPE..."
+    dokku build "$APP" "$IMAGE_SOURCE_TYPE" "$TMP_WORK_DIR"
+    dokku_log_info1 "Releasing $APP..."
+    dokku release "$APP" "$IMAGE_SOURCE_TYPE"
+    dokku_log_info1 "Deploying $APP..."
+    dokku deploy "$APP"
+    dokku_log_info2 "Application deployed:"
+         dokku urls "$APP" | sed "s/^/       /"
     echo
     ;;
 
-  build)
-    APP="$2"; IMAGE="dokku/$APP"; CACHE_DIR="$DOKKU_ROOT/$APP/cache"
-    id=$(cat | docker run -i -a stdin $DOKKU_IMAGE /bin/bash -c "mkdir -p /app && tar -xC /app")
-    test "$(docker wait $id)" -eq 0
-    docker commit $id $IMAGE > /dev/null
-    [[ -d $CACHE_DIR ]] || mkdir $CACHE_DIR
-    pluginhook pre-build $APP
-    id=$(docker run -d -v $CACHE_DIR:/cache -e CACHE_PATH=/cache $IMAGE /build/builder)
-    docker attach $id
-    test "$(docker wait $id)" -eq 0
-    docker commit $id $IMAGE > /dev/null
-    pluginhook post-build $APP
-    ;;
-
-  release)
-    APP="$2"; IMAGE="dokku/$APP"
-    pluginhook pre-release $APP
-    if [[ -f "$DOKKU_ROOT/$APP/ENV" ]]; then
-      id=$(docker run -i -a stdin $IMAGE /bin/bash -c "mkdir -p /app/.profile.d && cat > /app/.profile.d/app-env.sh" < "$DOKKU_ROOT/$APP/ENV")
-      test "$(docker wait $id)" -eq 0
-      docker commit $id $IMAGE > /dev/null
-    fi
-    pluginhook post-release $APP
-    ;;
-
   deploy)
     APP="$2"; IMAGE="dokku/$APP"
     pluginhook pre-deploy $APP
@@ -82,21 +72,25 @@ case "$1" in
 
     # start the app
     DOCKER_ARGS=$(: | pluginhook docker-args $APP deploy)
+    DOCKER_ARGS+=$(: | pluginhook docker-args-deploy $APP)
     BIND_EXTERNAL=$(pluginhook bind-external-ip $APP)
 
+    is_image_buildstep_based "$IMAGE" && DOKKU_BUILDSTEP=true
+    [[ -n "$DOKKU_BUILDSTEP" ]] && START_CMD="/start web"
+    [[ -z "$DOKKU_BUILDSTEP" ]] && eval "$(grep DOKKU_DOCKERFILE_PORT $DOKKU_ROOT/$APP/ENV)"
+
     if [[ "$BIND_EXTERNAL" = "false" ]];then
-      port=5000
-      id=$(docker run -d -e PORT=$port $DOCKER_ARGS $IMAGE /bin/bash -c "/start web")
+      port=${DOKKU_DOCKERFILE_PORT:=5000}
+      id=$(docker run -d -e PORT=$port $DOCKER_ARGS $IMAGE $START_CMD)
       ipaddr=$(docker inspect --format '{{ .NetworkSettings.IPAddress }}' $id)
     else
-      id=$(docker run -d -p 5000 -e PORT=5000 $DOCKER_ARGS $IMAGE /bin/bash -c "/start web")
+      id=$(docker run -d -p 5000 -e PORT=5000 $DOCKER_ARGS $IMAGE $START_CMD)
       port=$(docker port $id 5000 | sed 's/[0-9.]*://')
       ipaddr=127.0.0.1
     fi
-    echo $ipaddr > "$DOKKU_ROOT/$APP/IP"
 
     # if we can't post-deploy successfully, kill new container
-    function kill_new {
+    kill_new() {
       docker inspect $id &> /dev/null && docker kill $id > /dev/null
       trap - INT TERM EXIT
       kill -9 $$
@@ -104,23 +98,24 @@ case "$1" in
 
     # run checks first, then post-deploy hooks, which switches Nginx traffic
     trap kill_new INT TERM EXIT
-    echo "-----> Running pre-flight checks"
-    pluginhook check-deploy $id $APP $port ${ipaddr:-localhost}
+    dokku_log_info1 "Running pre-flight checks"
+    pluginhook check-deploy  $APP $port $ipaddr $id
+    trap -        INT TERM EXIT
 
     # now using the new container
     echo $id > "$DOKKU_ROOT/$APP/CONTAINER"
+    echo $ipaddr > "$DOKKU_ROOT/$APP/IP"
     echo $port > "$DOKKU_ROOT/$APP/PORT"
     echo "http://$(< "$DOKKU_ROOT/HOSTNAME"):$port" > "$DOKKU_ROOT/$APP/URL"
 
-    echo "-----> Running post-deploy"
+    dokku_log_info1 "Running post-deploy"
     pluginhook post-deploy  $APP $port $ipaddr
-    trap -        INT TERM EXIT
 
     # kill the old container
     if [[ -n "$oldid" ]]; then
       # Let the old container finish processing requests, before terminating it
       WAIT="${DOKKU_WAIT_TO_RETIRE:-60}"
-      echo "-----> Shutting down old container in $WAIT seconds"
+      dokku_log_info1 "Shutting down old container in $WAIT seconds"
       (
         exec >/dev/null 2>/dev/null </dev/null
         trap '' INT HUP
@@ -136,9 +131,11 @@ case "$1" in
 
   cleanup)
     # delete all non-running container
-    docker ps -a | grep 'Exit' | awk '{print $1}' | xargs docker rm &> /dev/null &
+    # shellcheck disable=SC2046
+    docker rm $(docker ps -a -f 'status=exited' -q) &> /dev/null &
     # delete unused images
-    docker images | grep '<none>' | awk '{print $3}' | xargs docker rmi &> /dev/null &
+    # shellcheck disable=SC2046
+    docker rmi $(docker images -f 'dangling=true' -q) &> /dev/null &
     ;;
 
   plugins)
@@ -157,17 +154,16 @@ case "$1" in
     pluginhook update
     ;;
 
-  # temporary hack for https://github.com/progrium/dokku/issues/82
+  # DEPRECATED as of v0.3.14
   deploy:all)
-    for app in $DOKKU_ROOT/*/CONTAINER; do
-      APP=$(basename "$(dirname $app)");
-      dokku deploy $APP
-    done
+      echo "*DEPRECATED* in v0.3.14: deploy:all will be removed in future versions"
+      dokku ps:restartall
     ;;
 
   help|'')
-    echo "Usage: dokku COMMAND <app> [command-specific-options]"
+    echo "Usage: dokku [--quiet|--trace|--rm-container|--rm|--force] COMMAND <app> [command-specific-options]"
     echo ""
+    echo "Options:"
 
     cat<<EOF | pluginhook commands help | sort
     help                                            Print the list of commands
@@ -192,8 +188,8 @@ EOF
     done
 
     if [ "$implemented" -eq 0 ]; then
-      echo " !    \`$*\` is not a dokku command."
-      echo " !    See \`dokku help\` for a list of available commands."
+      dokku_log_warn "\`$*\` is not a dokku command."
+      dokku_log_warn "See \`dokku help\` for a list of available commands."
       exit 1
     fi
     ;;

dokku.1

@@ -1,77 +0,0 @@
-.TH DOKKU 1 2014-11-22
-.\"Make sure to change that date when you commit a change!
-.\"
-.SH NAME
-dokku \- configure and get information from your dokku installation
-.\"
-.SH SYNOPSIS
-.B dokku
-.I <command>
-.\"
-.SH DESCRIPTION
-.B dokku
-is a catch-all command to configure your apps,
-work with plugins and inspect the current state of your server.
-.\"
-.SH OPTIONS
-.TP
-.BI apps:create " <app>"
-Create a new app.
-.TP
-.BI apps:destroy " <app>"
-Permanantly destroy an app.
-.TP
-.B apps
-List your apps.
-.TP
-.BI backup:import " file"
-Import dokku config files.
-.TP
-.BI backup:export " file"
-Export dokku config files.
-.TP
-.BI config " <app>"
-Display the config vars for an app.
-.TP
-.BI config:get " <app> KEY"
-Display a specific config var for an app.
-.TP
-.BI config:set " <app> KEY1=VAL1" \fR\ (KEY2=VAL2\ \.\.\.)
-Set one or more config vars for an app.
-.TP
-.BI config:unset " <app> KEY1" \fR\ (KEY2\ \.\.\.)
-Remove one or more config vars from an app.
-.TP
-.B help
-Print the list of commands.
-.TP
-.B logs \ \fI<app> \fR[\fI-t\fR]
-Show the last logs for an application (-t follows)
-.TP
-.BI nginx:import-ssl " <app>"
-Imports a tarball from stdin which should contain
-server\.crt and server\.key
-.TP
-.B plugins-install
-Install active plugins.
-.TP
-.B plugins-update
-Update active plugins.
-.TP
-.B plugins
-Print active plugins.
-.TP
-.BI run " <app> command"
-Run a command in the environment of an app.
-.TP
-.BI url " <app>"
-Show the url for an app.
-.TP
-.B version
-Print dokku's version.
-.\"
-.SH NOTES
-This man page does not include commands added
-by non-default plugins. To see the full list
-of commands available to your current dokku
-installation, run \fBdokku help\fR.

plugins/00_dokku-standard/commands

@@ -1,7 +1,90 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 case "$1" in
+  build)
+    APP="$2"; IMAGE="dokku/$APP"; IMAGE_SOURCE_TYPE="$3"; TMP_WORK_DIR="$4"
+    CACHE_DIR="$DOKKU_ROOT/$APP/cache"
+
+    pushd "$TMP_WORK_DIR" &> /dev/null
+
+    case "$IMAGE_SOURCE_TYPE" in
+      buildstep)
+        id=$(tar -c . | docker run -i -a stdin $DOKKU_IMAGE /bin/bash -c "mkdir -p /app && tar -xC /app")
+        test "$(docker wait $id)" -eq 0
+        docker commit $id $IMAGE > /dev/null
+        [[ -d $CACHE_DIR ]] || mkdir $CACHE_DIR
+        # *DEPRECATED* in v0.4.0: `pluginhook pre-build` will be removed in future releases
+        pluginhook pre-build "$APP"
+        pluginhook pre-build-buildstep "$APP"
+
+        # *DEPRECATED* in v0.3.14: `pluginhook docker-args` will be removed in future releases
+        # https://github.com/progrium/dokku/issues/896 & https://github.com/progrium/dokku/issues/906
+        DOCKER_ARGS=$(: | pluginhook docker-args $APP build)
+        DOCKER_ARGS+=$(: | pluginhook docker-args-build $APP)
+        id=$(docker run -d -v $CACHE_DIR:/cache -e CACHE_PATH=/cache $DOCKER_ARGS $IMAGE /build/builder)
+        docker attach $id
+        test "$(docker wait $id)" -eq 0
+        docker commit $id $IMAGE > /dev/null
+
+        # *DEPRECATED* in v0.4.0: `pluginhook post-build` will be removed in future releases
+        pluginhook post-build "$APP"
+        pluginhook post-build-buildstep "$APP"
+        ;;
+
+      dockerfile)
+        # extract first port from Dockerfile
+        DOCKERFILE_PORT=$(grep EXPOSE Dockerfile | head -1 | awk '{ print $2 }')
+        [[ -n "$DOCKERFILE_PORT" ]] && dokku config:set-norestart $APP DOKKU_DOCKERFILE_PORT=$DOCKERFILE_PORT
+
+        # sticking with same pattern of building app image before pre-build for now.
+        docker build -t "$IMAGE" .
+        # buildstep pluginhooks don't necessarily make sense for dockerfiles. call the new breed!!!
+        pluginhook pre-build-dockerfile "$APP"
+        pluginhook post-build-dockerfile "$APP"
+        ;;
+
+      *)
+        dokku_log_fail "Building image source type $IMAGE_SOURCE_TYPE not supported!"
+        ;;
+    esac
+    ;;
+
+  release)
+    APP="$2"; IMAGE="dokku/$APP"; IMAGE_SOURCE_TYPE="$3"
+    case "$IMAGE_SOURCE_TYPE" in
+      buildstep)
+        # *DEPRECATED* in v0.4.0: `pluginhook pre-release` will be removed in future releases
+        pluginhook pre-release "$APP"
+        pluginhook pre-release-buildstep "$APP"
+        if [[ -f "$DOKKU_ROOT/ENV" ]]; then
+          id=$(docker run -i -a stdin $IMAGE /bin/bash -c "mkdir -p /app/.profile.d && cat > /app/.profile.d/00-global-env.sh" < "$DOKKU_ROOT/ENV")
+          test "$(docker wait $id)" -eq 0
+          docker commit $id $IMAGE > /dev/null
+        fi
+        if [[ -f "$DOKKU_ROOT/$APP/ENV" ]]; then
+          id=$(docker run -i -a stdin $IMAGE /bin/bash -c "mkdir -p /app/.profile.d && cat > /app/.profile.d/01-app-env.sh" < "$DOKKU_ROOT/$APP/ENV")
+          test "$(docker wait $id)" -eq 0
+          docker commit $id $IMAGE > /dev/null
+        fi
+        # *DEPRECATED* in v0.4.0: `pluginhook post-release` will be removed in future releases
+        pluginhook post-release "$APP"
+        pluginhook post-release-buildstep "$APP"
+        ;;
+
+      dockerfile)
+        # buildstep pluginhooks don't necessarily make sense for dockerfiles. call the new breed!!!
+        pluginhook pre-release-dockerfile "$APP"
+        pluginhook post-release-dockerfile "$APP"
+        ;;
+
+      *)
+        dokku_log_fail "Releasing image source type $IMAGE_SOURCE_TYPE not supported!"
+        ;;
+    esac
+    ;;
+
   trace)
     [[ -d $DOKKU_ROOT/.dokkurc ]] || mkdir -p $DOKKU_ROOT/.dokkurc
     [[ "$2" == "on" ]] || [[ "$2" == "off" ]] || {
@@ -24,9 +107,23 @@ case "$1" in
     dokku apps:destroy $2
     ;;
 
+  ls)
+    apps=$(ls -d $DOKKU_ROOT/*/ 2>/dev/null) || (echo "You haven't depoyed any applications yet" && exit 1)
+
+    dokku_col_log_info2_quiet "App Name" "Container id"
+
+    for app in $apps; do
+      if [[ -f $app/CONTAINER ]]; then
+        dokku_col_log_msg "$(basename $app)" "$(< $app/CONTAINER)"
+      else
+        dokku_col_log_msg "$(basename $app)"
+      fi
+    done
+    ;;
+
   logs)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2";
 
     if [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
@@ -43,36 +140,44 @@ case "$1" in
 
   run)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2"; IMAGE="dokku/$APP"
 
     shift 2
 
     DOCKER_ARGS=$(: | pluginhook docker-args $APP run)
-    docker run -i -t $DOCKER_ARGS $IMAGE /exec "$@"
+    DOCKER_ARGS+=$(: | pluginhook docker-args-run $APP)
+    [[ $DOKKU_RM_CONTAINER ]] && DOKKU_RUN_OPTS="--rm"
+    has_tty && DOKKU_RUN_OPTS+=" -i -t"
+    is_image_buildstep_based "$IMAGE" && EXEC_CMD="/exec"
+
+    docker run $DOKKU_RUN_OPTS $DOCKER_ARGS $IMAGE $EXEC_CMD "$@"
     ;;
 
   url | urls)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
-    APP="$2"; SCHEME="http"; SSL="$DOKKU_ROOT/$APP/tls"; WILDCARD_SSL="$DOKKU_ROOT/tls"
+    verify_app_name "$2"
+    APP="$2";
 
+    if [[ -s "$DOKKU_ROOT/$APP/URLS" ]]; then
+      case "$1" in
+        url)
+          grep "^http" "$DOKKU_ROOT/$APP/URLS" | head -1
+        ;;
+        urls)
+          grep "^http" "$DOKKU_ROOT/$APP/URLS"
+        ;;
+      esac
+
+      exit 0
+    fi
+
+    SCHEME="http"; SSL="$DOKKU_ROOT/$APP/tls"; WILDCARD_SSL="$DOKKU_ROOT/tls"
     if [[ -e "$SSL/server.crt" && -e "$SSL/server.key" ]] || [[ -e "$WILDCARD_SSL/server.crt" && -e "$WILDCARD_SSL/server.key" ]]; then
       SCHEME="https"
     fi
 
-    if [[ -f "$DOKKU_ROOT/$APP/VHOST" ]]; then
-      case "$1" in
-        url)
-          echo "$SCHEME://$(head -n1 "$DOKKU_ROOT/$APP/VHOST")"
-        ;;
-        urls)
-          for vhost in $(< "$DOKKU_ROOT/$APP/VHOST"); do
-            echo "$SCHEME://$vhost"
-          done
-        ;;
-      esac
-    elif [[ -f "$DOKKU_ROOT/VHOST" ]]; then
+    if [[ -f "$DOKKU_ROOT/VHOST" ]]; then
       echo "$SCHEME://$(< "$DOKKU_ROOT/VHOST")"
     else
       echo "$SCHEME://$(< "$DOKKU_ROOT/HOSTNAME"):$(< "$DOKKU_ROOT/$APP/PORT")"
@@ -88,6 +193,7 @@ case "$1" in
 
   help)
     cat && cat<<EOF
+    ls                                              Pretty listing of deployed applications and containers
     logs <app> [-t]                                 Show the last logs for an application (-t follows)
     run <app> <cmd>                                 Run a command in the environment of an application
     url <app>                                       Show the first URL for an application (compatibility)

plugins/00_dokku-standard/install

@@ -16,11 +16,11 @@ case "$DOKKU_DISTRO" in
     cat<<EOF > /etc/init/dokku-redeploy.conf
 description "Dokku app redeploy service"
 
-start on (started docker)
+start on filesystem and started docker
 
 script
   sleep 2 # give docker some time
-  sudo -i -u dokku /usr/local/bin/dokku deploy:all
+  sudo -i -u dokku /usr/local/bin/dokku ps:restartall
 end script
 EOF
     ;;
@@ -34,7 +34,7 @@ After=docker.target
 [Service]
 Type=simple
 User=dokku
-ExecStart=/usr/local/bin/dokku deploy:all
+ExecStart=/usr/local/bin/dokku ps:restartall
 
 [Install]
 WantedBy=multi-user.target

plugins/apps/commands

@@ -1,15 +1,16 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 case "$1" in
   apps)
-    echo "=== My Apps"
+    dokku_log_info2_quiet "My Apps"
     find $DOKKU_ROOT -follow -maxdepth 1 -type d  \( ! -iname ".*" \)  -not -path $DOKKU_ROOT/tls | sed 's|^\./||g' | sed 's|'$DOKKU_ROOT'\/||' | tail -n +2 | sort
     ;;
 
   apps:create)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ -d "$DOKKU_ROOT/$2" ]] && echo " !    Name is already taken" && exit 1
+    [[ -d "$DOKKU_ROOT/$2" ]] && dokku_log_warn "Name is already taken" && exit 1
     APP="$2"
 
     mkdir -p "$DOKKU_ROOT/$APP"
@@ -18,19 +19,22 @@ case "$1" in
 
   apps:destroy)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     [[ "$2" == "tls" ]] && echo "Unable to destroy tls directory" && exit 1
-    APP="$2"; IMAGE="dokku/$APP";
+    APP="$2"; IMAGE="dokku/$APP"
 
-    echo " !    WARNING: Potentially Destructive Action"
-    echo " !    This command will destroy $APP (including all add-ons)."
-    echo " !    To proceed, type \"$APP\""
-    echo ""
+    [[ "$3" == "force" ]] && DOKKU_APPS_FORCE_DELETE=1
+    if [[ -z "$DOKKU_APPS_FORCE_DELETE" ]]; then
+      dokku_log_warn "WARNING: Potentially Destructive Action"
+      dokku_log_warn "This command will destroy $APP (including all add-ons)."
+      dokku_log_warn "To proceed, type \"$APP\""
+      echo ""
 
-    read -p "> " app_name
-    if [[ "$app_name" != "$APP" ]]; then
-      echo " !    Confirmation did not match $APP. Aborted."
-      exit 1
+      read -p "> " app_name
+      if [[ "$app_name" != "$APP" ]]; then
+        dokku_log_warn "Confirmation did not match $APP. Aborted."
+        exit 1
+      fi
     fi
 
     echo "Destroying $APP (including all add-ons)"

plugins/build-env/pre-build

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 APP="$1"; IMAGE="dokku/$APP"; BUILD_ENV=""
 
@@ -10,22 +11,24 @@ APP="$1"; IMAGE="dokku/$APP"; BUILD_ENV=""
 
 if [[ -f "$DOKKU_ROOT/ENV" ]]; then
   BUILD_ENV+=$(< "$DOKKU_ROOT/ENV")
+  BUILD_ENV+=$'\n'
 fi
 if [[ -f "$DOKKU_ROOT/$APP/ENV" ]]; then
-  BUILD_ENV+=" "
+  BUILD_ENV+=$'\n'
   BUILD_ENV+=$(< "$DOKKU_ROOT/$APP/ENV")
+  BUILD_ENV+=$'\n'
 fi
 
 if [[ ! -z "$BUILD_ENV" ]]; then
-  echo "-----> Adding BUILD_ENV to build environment..."
+  dokku_log_info1 "Adding BUILD_ENV to build environment..."
   # create build env files for use in buildpacks like this:
   # https://github.com/niteoweb/heroku-buildpack-buildout/blob/5879fa3418f7d8e079f1aa5816ba1adde73f4948/bin/compile#L34
-  id=$(echo $BUILD_ENV |sed 's@export @@g'| docker run -i -a stdin $IMAGE /bin/bash -c "for ENV_VAR in $(cat); do echo \$ENV_VAR |sed 's@^\([^=]*\)=\(.*\)\$@echo \\\"\2\\\" >/tmp/env/\1@g' >>/tmp/set_env.sh; done && mkdir -p /tmp/env && /bin/bash /tmp/set_env.sh")
+  id=$(echo $BUILD_ENV |sed -e 's@export @@g' -e 's@\\n@ @g' | docker run -i -a stdin $IMAGE /bin/bash -c "for ENV_VAR in $(cat); do echo \$ENV_VAR |sed 's@^\([^=]*\)=\(.*\)\$@echo \\\"\2\\\" >/tmp/env/\1@g' >>/tmp/set_env.sh; done && mkdir -p /tmp/env && /bin/bash /tmp/set_env.sh")
   test "$(docker wait $id)" -eq 0
   docker commit $id $IMAGE > /dev/null
 
   # create build env for 'old style' buildpacks and dokku plugins
-  id=$(echo "$BUILD_ENV" | docker run -i -a stdin $IMAGE /bin/bash -c "cat >> /app/.env")
+  id=$(echo -e "$BUILD_ENV" | docker run -i -a stdin $IMAGE /bin/bash -c "cat >> /app/.env")
   test "$(docker wait $id)" -eq 0
   docker commit $id $IMAGE > /dev/null
 fi

plugins/checks/check-deploy

@@ -1,75 +1,167 @@
 #!/usr/bin/env bash
 
-# Hook to check server against list of checks specified in CHECKS file.  Each
-# check is a relative path and, optionally, expected content.
+# Hook to check server against list of checks specified in CHECKS file.
+#
+# The CHECKS file may contain empty lines, comments (lines starting with #),
+# settings (NAME=VALUE) and check instructions.
+#
+# The format of a check instruction is a path, optionally followed by the
+# expected content.  For example:
 #
-# For example:
 #   /                       My Amazing App
 #   /stylesheets/index.css  .body
 #   /scripts/index.js       $(function()
 #   /images/logo.png
 #
-# Waits 5 seconds, giving server time to start, before running the checks.  For
-# shorter/longer wait, change the DOKKU_CHECKS_WAIT environment variable (value
-# in seconds).
+# To check an application that supports multiple hostnames, use relative URLs
+# that include the hostname, for example:
+#
+#  //admin.example.com     Admin Dashboard
+#  //static.example.com/logo.png
+#
+# You can also specify the protocol to explicitly check HTTPS requests.
+#
+# The default behavior is to wait for 5 seconds before running the first check,
+# and timeout each check to 30 minutes.
+#
+# You can change these by setting WAIT and TIMEOUT to different values, for
+# example:
+#
+#   WAIT=30     # Wait 1/2 minute
+#   TIMEOUT=60  # Timeout after a minute
+#
 
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
+
+APP="$1"; DOKKU_APP_LISTEN_PORT="$2"; DOKKU_APP_LISTEN_IP="$3"; DOKKU_APP_CONTAINER_ID="$4"
+if [[ -z "$DOKKU_APP_LISTEN_PORT" ]] && [[ -f "$DOKKU_ROOT/$APP/PORT" ]]; then
+  DOKKU_APP_LISTEN_PORT=$(< "$DOKKU_ROOT/$APP/PORT")
+fi
+if [[ -z "$DOKKU_APP_LISTEN_IP" ]] && [[ -f "$DOKKU_ROOT/$APP/IP" ]]; then
+  DOKKU_APP_LISTEN_IP=$(< "$DOKKU_ROOT/$APP/IP")
+fi
+if [[ -z "$DOKKU_APP_CONTAINER_ID" ]] && [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
+  DOKKU_APP_CONTAINER_ID=$(< "$DOKKU_ROOT/$APP/CONTAINER")
+fi
 
-CONTAINERID="$1"; APP="$2"; PORT="$3" ; HOSTNAME="${4:-localhost}"
 
 # source in app env to get DOKKU_CHECKS_WAIT and any other necessary vars
-[[ -f "$DOKKU_ROOT/$APP/ENV" ]] && source $DOKKU_ROOT/$APP/ENV
-# echo "DOKKU_CHECKS_WAIT is $DOKKU_CHECKS_WAIT"
-FILENAME="$DOKKU_ROOT/$APP/CHECKS"
+[[ -f "$DOKKU_ROOT/ENV" ]] && source $DOKKU_ROOT/ENV
+
+# Wait this many seconds (default 5) for server to start before running checks.
 WAIT="${DOKKU_CHECKS_WAIT:-5}"
+# Wait this many seconds (default 30) for each response.
+TIMEOUT="${DOKKU_CHECKS_TIMEOUT:-30}"
 
 # try to copy CHECKS from container if not in APP dir & quit gracefully if it doesn't exist
 # docker cp exits with status 1 when run as non-root user when it tries to chown the file
 # after successfully copying the file. Thus, we suppress stderr.
 # ref: https://github.com/dotcloud/docker/issues/3986
-if [[ ! -f "$FILENAME" ]] ; then
-  echo "       check-deploy: $FILENAME not found. attempting to retrieve it from container ..."
-  TMPDIR=$(mktemp -d /tmp/CHECKS.XXXXX)
-  docker cp $CONTAINERID:/app/CHECKS $TMPDIR 2> /dev/null || true
-  if [[ ! -s "${TMPDIR}/CHECKS" ]] ; then
-    echo "       CHECKS file not found in container. skipping checks."
-    rm -rf $TMPDIR
-    exit 0
-  else
-    echo "       CHECKS file found in container"
-    FILENAME=${TMPDIR}/CHECKS
+TMPDIR=$(mktemp -d /tmp/CHECKS.XXXXX)
+docker cp $DOKKU_APP_CONTAINER_ID:/app/CHECKS $TMPDIR 2> /dev/null || true
 
-    function cleanup() {
-      echo "       removing CHECKS file copied from container"
-      rm -rf $TMPDIR
-    }
-    trap cleanup EXIT
-  fi
+FILENAME=${TMPDIR}/CHECKS
+
+cleanup() {
+  rm -rf $TMPDIR
+  dokku_log_info2_quiet             "$APP container output:"
+  dokku_container_log_verbose_quiet $DOKKU_APP_CONTAINER_ID
+  dokku_log_info2_quiet             "end $APP container output"
+}
+trap cleanup EXIT
+
+if [[ ! -s "${TMPDIR}/CHECKS" ]] ; then
+  dokku_log_verbose "CHECKS file not found in container: running simple container check..."
+  rm -rf $TMPDIR
+
+  # simple default check to see if the container stuck around
+  # for more thorough checks, create a CHECKS file
+  DOKKU_DEFAULT_WAIT=$((WAIT+TIMEOUT))
+  dokku_log_info1 "Waiting for $DOKKU_DEFAULT_WAIT seconds ..."
+  sleep $DOKKU_DEFAULT_WAIT
+
+  docker ps -q --no-trunc | grep -q "$DOKKU_APP_CONTAINER_ID" || dokku_log_fail "App container failed to start!!"
+  dokku_log_info1 "Default container check successful!" && exit 0
 fi
 
-echo "Waiting $WAIT seconds ..."
+# Reads name/value pairs, sets the WAIT and TIMEOUT variables
+exec < "$FILENAME"
+while read LINE ; do
+  # Name/value pair
+  if [[ "$LINE" =~ ^.+= ]] ; then
+    TRIM=${LINE%#*}
+    NAME=${TRIM%=*}
+    VALUE=${TRIM#*=}
+    [[ "$NAME" = "WAIT" ]]    && WAIT=$VALUE
+    [[ "$NAME" = "TIMEOUT" ]] && TIMEOUT=$VALUE
+  fi
+done
+
+
+dokku_log_info1 "Waiting for $WAIT seconds ..."
 sleep $WAIT
 
+
 # -q           do not use .curlrc (must come first)
 # --compressed Test compression handled correctly
 # --fail       Fail on server errors (4xx, 5xx)
 # --location   Follow redirects
-CURL_OPTIONS="-q --compressed --fail --location --max-time 30"
+CURL_OPTIONS="-q --compressed --fail --location --max-time $TIMEOUT"
 
-while read PATHNAME EXPECTED; do
+
+exec < "$FILENAME"
+while read CHECK_URL EXPECTED ; do
   # Ignore empty lines and lines starting with #
-  [[ -z "$PATHNAME" || "$PATHNAME" =~ ^# ]] && continue
+  # shellcheck disable=SC1001
+  [[ -z "$CHECK_URL" || "$CHECK_URL" =~ ^\# ]] && continue
+  # Ignore variables
+  [[ "$CHECK_URL" =~ ^.+= ]] && continue
 
-  URL="http://$HOSTNAME:$PORT$PATHNAME"
-
-  echo "checking with: curl $CURL_OPTIONS $URL"
-  HTML=$(curl $CURL_OPTIONS $URL)
-  if [[ -n "$EXPECTED" && ! "$HTML" =~ $EXPECTED ]] ; then
-    echo -e "\033[31m\033[1m$URL: expected to but did not find: \"$EXPECTED\"\033[0m"
-    exit 1
+  if [[ "$CHECK_URL" =~ ^https?: ]] ; then
+    URL_PROTOCOL=${CHECK_URL%:*}
+    CHECK_URL=${CHECK_URL#*:}
   else
-    echo -e "\033[32m\033[1m$URL => \"$EXPECTED\"\033[0m"
+    URL_PROTOCOL="http"
   fi
-done < "$FILENAME"
 
-echo -e "\033[32m\033[1mAll checks successful!\033[0m"
+  if [[ "$CHECK_URL" =~ ^//.+ ]] ; then
+    # To test a URL with specific host name, we still make request to localhost,
+    # but we set Host header to $SEND_HOST.
+    #
+    # The pattern is
+    #   //SEND_HOST/PATHNAME
+    UNPREFIXED=${CHECK_URL#//}
+    URL_HOSTNAME=${UNPREFIXED%%/*}
+    URL_PATHNAME=${UNPREFIXED#$URL_HOSTNAME}
+
+    HEADERS="-H Host:$URL_HOSTNAME"
+  else
+    URL_HOSTNAME=localhost
+    URL_PATHNAME=$CHECK_URL
+  fi
+
+  # This URL will show up in the messages
+  LOG_URL="$URL_PROTOCOL://$URL_HOSTNAME$URL_PATHNAME"
+  # And how we formulate the CURL request
+  CURL_ARGS="$CURL_OPTIONS $URL_PROTOCOL://$DOKKU_APP_LISTEN_IP:$DOKKU_APP_LISTEN_PORT$URL_PATHNAME $HEADERS"
+
+  dokku_log_verbose "CHECKS expected result:"
+  dokku_log_verbose "$LOG_URL => \"$EXPECTED\""
+  [[ $DOKKU_TRACE ]] && dokku_log_verbose "$ curl $CURL_ARGS"
+
+  # Capture HTTP response or CURL error message
+  if OUTPUT=$(curl -# $CURL_ARGS 2>&1) ; then
+    # OUTPUT contains the HTTP response
+    if [[ ! "$OUTPUT" =~ $EXPECTED ]] ; then
+      dokku_log_fail "$LOG_URL: expected to but did not find: \"$EXPECTED\""
+      exit 1
+    fi
+  else
+    # Failed to connect/no response, OUTPUT contains error message
+    dokku_log_fail "$OUTPUT"
+    exit 2
+  fi
+done
+
+dokku_log_info1 "All checks successful!"

plugins/common/functions

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+has_tty() {
+  if [[ "$(/usr/bin/tty || true)" == "not a tty" ]]; then
+    return 1
+  else
+    return 0
+  fi
+}
+
+dokku_log_info1() {
+  echo "-----> $@"
+}
+
+dokku_log_info2() {
+  echo "=====> $@"
+}
+
+dokku_log_info1_quiet() {
+  if [[ -z "$DOKKU_QUIET_OUTPUT" ]];then
+    echo "-----> $@"
+  else
+    return 0
+  fi
+}
+
+dokku_log_info2_quiet() {
+  if [[ -z "$DOKKU_QUIET_OUTPUT" ]];then
+    echo "=====> $@"
+  else
+    return 0
+  fi
+}
+
+dokku_col_log_info1() {
+  printf "%-40s %-40s\n" "-----> $@"
+}
+
+dokku_col_log_info1_quiet() {
+  if [[ -z "$DOKKU_QUIET_OUTPUT" ]];then
+    printf "%-40s %-40s\n" "-----> $@"
+  else
+    return 0
+  fi
+}
+
+dokku_col_log_info2() {
+  printf "%-40s %-40s\n" "=====> $@"
+}
+
+dokku_col_log_info2_quiet() {
+  if [[ -z "$DOKKU_QUIET_OUTPUT" ]];then
+    printf "%-40s %-40s\n" "=====> $@"
+  else
+    return 0
+  fi
+}
+
+dokku_col_log_msg() {
+  printf "%-40s %-40s\n" "$@"
+}
+
+dokku_col_log_msg_quiet() {
+  if [[ -z "$DOKKU_QUIET_OUTPUT" ]];then
+    printf "%-40s %-40s\n" "$@"
+  else
+    return 0
+  fi
+}
+
+dokku_log_verbose_quiet() {
+  if [[ -z "$DOKKU_QUIET_OUTPUT" ]];then
+    echo "       $@"
+  else
+    return 0
+  fi
+}
+
+dokku_log_verbose() {
+  echo "       $@"
+}
+
+dokku_log_warn() {
+  echo " !    $@"
+}
+
+dokku_log_fail() {
+  echo "$@" 1>&2
+  exit 1
+}
+
+dokku_container_log_verbose_quiet() {
+  CID=$1;
+  shift
+
+  OIFS=$IFS
+  IFS=$'\n'
+  for line in $(docker logs $CID 2>&1); do
+    dokku_log_verbose_quiet "$line"
+  done
+  IFS=$OIFS
+}
+
+verify_app_name() {
+  local APP="$1"
+  [[ ! -d "$DOKKU_ROOT/$APP" ]] && dokku_log_fail "App $APP does not exist"
+  IMAGE="dokku/$APP"
+  return 0
+}
+
+is_image_buildstep_based() {
+  # circleci can't support --rm as they run lxc in lxc
+  [[ ! -f "/home/ubuntu/.circlerc" ]] && local DOCKER_ARGS="--rm"
+  docker run --entrypoint="/bin/bash" $DOCKER_ARGS "$@" -c "[[ -f /exec ]]"
+}
+
+parse_args() {
+  for arg in "$@"; do
+    case "$arg" in
+      --quiet)
+        export DOKKU_QUIET_OUTPUT=1
+        ;;
+      --trace)
+        export DOKKU_TRACE=1
+        ;;
+      --rm-container|--rm)
+        export DOKKU_RM_CONTAINER=1
+        ;;
+      --force)
+        export DOKKU_APPS_FORCE_DELETE=1
+        ;;
+    esac
+  done
+  return 0
+}

plugins/config/commands

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 ENV_FILE="$DOKKU_ROOT/$2/ENV"
 ENV_FILE_TEMP="$DOKKU_ROOT/$2/ENV.tmp"
@@ -35,26 +36,12 @@ config_styled_hash () {
   done <<< "$vars"
 }
 
-config_restart_app() {
-  APP="$1";
-
-  if [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
-    echo "-----> Releasing $APP ..."
-    dokku release $APP
-    echo "-----> Release complete!"
-    echo "-----> Deploying $APP ..."
-    dokku deploy $APP
-    echo "-----> Deploy complete!"
-  fi
-}
-
 config_write() {
   ENV_TEMP="$1"
   echo -e "$ENV_TEMP" | sed '/^$/d' | sort > $ENV_FILE_TEMP
   if ! cmp -s $ENV_FILE $ENV_FILE_TEMP; then
     cp -f $ENV_FILE_TEMP $ENV_FILE
     chmod 600 $ENV_FILE
-    config_restart_app $APP
   fi
   rm -f $ENV_FILE_TEMP
 }
@@ -62,7 +49,7 @@ config_write() {
 case "$1" in
   config)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2"
 
     config_create
@@ -77,13 +64,13 @@ case "$1" in
       fi
     done
 
-    echo "=== $APP config vars ==="
+    dokku_log_info2_quiet "$APP config vars"
     config_styled_hash "$VARS"
     ;;
 
   config:get)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2"
 
     if [[ -z $3 ]]; then
@@ -104,7 +91,24 @@ case "$1" in
 
   config:set)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
+    APP="$2"
+
+    if [[ -z "${*:3}" ]]; then
+      echo "Usage: dokku config:set APP KEY1=VALUE1 [KEY2=VALUE2 ...]"
+      echo "Must specify KEY and VALUE to set."
+      exit 1
+    fi
+
+    shift 2
+    dokku config:set-norestart $APP "$@"
+    dokku_log_info1 "Restarting app $APP"
+    dokku ps:restart $APP
+   ;;
+
+  config:set-norestart)
+    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
+    verify_app_name "$2"
     APP="$2"
 
     if [[ -z "${*:3}" ]]; then
@@ -143,7 +147,7 @@ ${var}"
     ENV_ADD=$(echo "$ENV_ADD" | tail -n +2) #remove first empty line
 
     if [ $RESTART_APP ]; then
-      echo "-----> Setting config vars and restarting $APP"
+      dokku_log_info1 "Setting config vars"
       config_styled_hash "$ENV_ADD" "       "
 
       config_write "$ENV_TEMP"
@@ -152,7 +156,24 @@ ${var}"
 
   config:unset)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
+    APP="$2"
+
+    if [[ -z $3 ]]; then
+      echo "Usage: dokku config:unset APP KEY1 [KEY2 ...]"
+      echo "Must specify KEY to unset."
+      exit 1
+    fi
+
+    shift 2
+    dokku config:unset-norestart $APP "$@"
+    dokku_log_info1 "Restarting app $APP"
+    dokku ps:restart $APP
+  ;;
+
+  config:unset-norestart)
+    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
+    verify_app_name "$2"
     APP="$2"
 
     if [[ -z $3 ]]; then
@@ -166,7 +187,7 @@ ${var}"
     VARS="${*:3}"
 
     for var in $VARS; do
-      echo "-----> Unsetting $var and restarting $APP"
+      dokku_log_info1 "Unsetting $var"
       ENV_TEMP=$(echo -e "${ENV_TEMP}" | sed "/^export $var=/ d")
 
       config_write "$ENV_TEMP"

plugins/config/docker-args-deploy

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
+
+STDIN=$(cat); APP="$1"; IMAGE="dokku/$APP"
+DOCKERFILE_ENV_FILE="$DOKKU_ROOT/$APP/DOCKERFILE_ENV_FILE"
+
+if ! is_image_buildstep_based "$IMAGE"; then
+  > "$DOCKERFILE_ENV_FILE"
+  [[ -f "$DOKKU_ROOT/ENV" ]] && sed -e "s:^export ::g" -e "s:=':=:g" -e "s:'$::g" "$DOKKU_ROOT/ENV" > "$DOCKERFILE_ENV_FILE"
+  [[ -f "$DOKKU_ROOT/$APP/ENV" ]] && sed -e "s:^export ::g" -e "s:=':=:g" -e "s:'$::g" "$DOKKU_ROOT/$APP/ENV" >> "$DOCKERFILE_ENV_FILE"
+
+  echo "$STDIN --env-file=$DOCKERFILE_ENV_FILE"
+else
+  echo "$STDIN"
+fi

plugins/config/docker-args-run

@@ -0,0 +1 @@
+docker-args-deploy

plugins/domains/commands

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 RE_IPV4="([0-9]{1,3}[\.]){3}[0-9]{1,3}"
 
@@ -16,33 +17,25 @@ RE_IPV6="${RE_IPV6}fe08:(:[0-9a-fA-F]{1,4}){2,2}%[0-9a-zA-Z]{1,}|"     # TEST: f
 RE_IPV6="${RE_IPV6}::(ffff(:0{1,4}){0,1}:){0,1}${RE_IPV4}|"            # TEST: ::255.255.255.255   ::ffff:255.255.255.255  ::ffff:0:255.255.255.255 (IPv4-mapped IPv6 addresses and IPv4-translated addresses)
 RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,4}:${RE_IPV4}"                # TEST: 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33
 
-domains_restart_app() {
-  APP="$1";
-
-  if [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
-    echo "-----> Releasing $APP ..."
-    dokku release $APP
-    echo "-----> Release complete!"
-    echo "-----> Deploying $APP ..."
-    dokku deploy $APP
-    echo "-----> Deploy complete!"
-  fi
-}
+# Ensure the ip address continues to the end of the line
+# Fixes using a wildcard dns service such as xip.io which allows for *.<ip address>.xip.io
+RE_IPV4="${RE_IPV4}\$"
+RE_IPV6="${RE_IPV6}\$"
 
 case "$1" in
   domains)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2"
 
     dokku domains:setup $APP
-    echo "=== $APP Domain Names"
+    dokku_log_info2_quiet "$APP Domain Names"
     cat "$DOKKU_ROOT/$APP/VHOST"
     ;;
 
   domains:setup)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2"; VHOST_PATH="$DOKKU_ROOT/$APP/VHOST"
 
     if [[ ! -f $VHOST_PATH ]]; then
@@ -56,7 +49,7 @@ case "$1" in
         [[ ! $(grep -q NO_VHOST "$DOKKU_ROOT/$APP/ENV") ]] && echo "export NO_VHOST='1'" >> "$DOKKU_ROOT/$APP/ENV"
       else
         if [[ -f "$DOKKU_ROOT/VHOST" ]]; then
-          echo "-----> Creating new $VHOST_PATH..."
+          dokku_log_info1 "Creating new $VHOST_PATH..."
           SUBDOMAIN=${APP/%\.${VHOST}/}
           hostname=$(: | pluginhook nginx-hostname $APP $SUBDOMAIN $VHOST)
           if [[ ! -n $hostname ]]; then
@@ -75,7 +68,7 @@ case "$1" in
 
   domains:add)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2"
 
     if [[ -z $3 ]]; then
@@ -92,27 +85,27 @@ case "$1" in
     dokku domains:setup $APP
     echo "$3" >> "$DOKKU_ROOT/$APP/VHOST"
     # we need to restart the app to make sure we're binding to the appropriate network interface
-    domains_restart_app $APP
+    dokku ps:restart $APP
     pluginhook post-domains-update $APP
-    echo "-----> Added $3 to $APP"
+    dokku_log_info1 "Added $3 to $APP"
 
     ;;
 
   domains:clear)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2"
 
     rm -f "$DOKKU_ROOT/$APP/VHOST"
     dokku domains:setup $APP
     pluginhook post-domains-update $APP
-    echo "-----> Cleared domains in $APP"
+    dokku_log_info1 "Cleared domains in $APP"
 
     ;;
 
   domains:remove)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2"
 
     if [[ -z $3 ]]; then
@@ -124,7 +117,7 @@ case "$1" in
     dokku domains:setup $APP
     sed -i "/^$3$/d" "$DOKKU_ROOT/$APP/VHOST"
     pluginhook post-domains-update $APP
-    echo "-----> Removed $3 from $APP"
+    dokku_log_info1 "Removed $3 from $APP"
 
     ;;
 

plugins/git/commands

@@ -1,20 +1,30 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
-git_archive_all() {
-  APP=$1; REV=$2
+git_build_app_repo() {
+  verify_app_name "$1"
+  APP="$1"; REV="$2"
+
+  # clean up after ourselves
   TMP_WORK_DIR=$(mktemp -d)
+  trap 'rm -rf "$TMP_WORK_DIR" > /dev/null' RETURN
+
+  # git clone
   chmod 755 $TMP_WORK_DIR
   unset GIT_DIR GIT_WORK_TREE
-  git clone -q $DOKKU_ROOT/$APP $TMP_WORK_DIR &> /dev/null
   pushd $TMP_WORK_DIR > /dev/null
+  git clone -q "$DOKKU_ROOT/$APP" "$TMP_WORK_DIR" &> /dev/null
   git config advice.detachedHead false
-  git checkout $REV &> /dev/null
+  git checkout "$REV" &> /dev/null
   git submodule update --init --recursive &> /dev/null
   find -name .git -prune -exec rm -rf {} \; > /dev/null
-  tar c .
-  popd > /dev/null
-  rm -rf $TMP_WORK_DIR > /dev/null
+
+  if [[ -f Dockerfile ]] && [[ "$([[ -f .env ]] && grep -q BUILDPACK_URL .env; echo $?)" != "0" ]] && [[ ! -f ".buildpacks" ]]; then
+    dokku receive "$APP" "dockerfile" "$TMP_WORK_DIR" | sed -u "s/^/"$'\e[1G'"/"
+  else
+    dokku receive "$APP" "buildstep" "$TMP_WORK_DIR" | sed -u "s/^/"$'\e[1G'"/"
+  fi
 }
 
 case "$1" in
@@ -26,7 +36,8 @@ case "$1" in
       # Only run this script for the master branch. You can remove this
       # if block if you wish to run it for others as well.
       if [[ $refname = "refs/heads/master" ]] ; then
-        git_archive_all $APP $newrev | dokku receive $APP | sed -u "s/^/"$'\e[1G'"/"
+        # broken out into pluginhook so we might support other methods to receive an app
+        pluginhook receive-app $APP $newrev
       else
         echo $'\e[1G\e[K'"-----> WARNING: deploy did not complete, you must push to master."
         echo $'\e[1G\e[K'"-----> for example, try 'git push <dokku> ${refname/refs\/heads\/}:master'"
@@ -41,6 +52,25 @@ case "$1" in
     pluginhook git-post-pull $APP
     ;;
 
+  git-build)
+    APP="$2"; APP_BUILD_LOCK="$DOKKU_ROOT/$APP/.build.lock"
+    APP_BUILD_LOCK_MSG="$APP is currently being deployed or locked. Waiting..."
+    [[ $(flock -n "$APP_BUILD_LOCK" true &>/dev/null ; echo $?) -ne 0 ]] && echo "$APP_BUILD_LOCK_MSG"
+
+    shift 1
+    flock -o "$APP_BUILD_LOCK" dokku git-build-locked "$@"
+    ;;
+
+  git-build-locked)
+    APP="$2"
+    if [[ $# -ge 3 ]];then
+      REF="$3"
+    else
+      REF=$(< "$DOKKU_ROOT/$APP/refs/heads/master")
+    fi
+    git_build_app_repo $APP $REF
+    ;;
+
   git-*)
     APP="$(echo $2 | perl -pe 's/(?<!\\)'\''//g' | sed 's/\\'\''/'\''/g')"
     APP_PATH=$DOKKU_ROOT/$APP

plugins/git/receive-app

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
+
+APP="$1"; REV="$2"
+
+dokku git-build $APP $REV

plugins/nginx-vhosts/bind-external-ip

@@ -2,7 +2,7 @@
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
 
 APP="$1"
-set +e; NO_VHOST=$(dokku config:get $APP NO_VHOST); set -e
+NO_VHOST=$(dokku config:get $APP NO_VHOST || true)
 
 RE_IPV4="([0-9]{1,3}[\.]){3}[0-9]{1,3}"
 
@@ -19,6 +19,12 @@ RE_IPV6="${RE_IPV6}fe08:(:[0-9a-fA-F]{1,4}){2,2}%[0-9a-zA-Z]{1,}|"     # TEST: f
 RE_IPV6="${RE_IPV6}::(ffff(:0{1,4}){0,1}:){0,1}${RE_IPV4}|"            # TEST: ::255.255.255.255   ::ffff:255.255.255.255  ::ffff:0:255.255.255.255 (IPv4-mapped IPv6 addresses and IPv4-translated addresses)
 RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,4}:${RE_IPV4}"                # TEST: 2001:db8:3:4::192.0.2.33  64:ff9b::192.0.2.33
 
+
+# Ensure the ip address continues to the end of the line
+# Fixes using a wildcard dns service such as xip.io which allows for *.<ip address>.xip.io
+RE_IPV4="${RE_IPV4}\$"
+RE_IPV6="${RE_IPV6}\$"
+
 [[ -f "$DOKKU_ROOT/VHOST" ]] && GLOBAL_VHOST=$(< "$DOKKU_ROOT/VHOST")
 
 if [[ -n "$NO_VHOST" ]]; then

plugins/nginx-vhosts/commands

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 restart_nginx () {
   case "$DOKKU_DISTRO" in
@@ -17,6 +18,7 @@ case "$1" in
   nginx:build-config)
     APP="$2"; DOKKU_APP_LISTEN_PORT="$3"; DOKKU_APP_LISTEN_IP="${4}"
     VHOST_PATH="$DOKKU_ROOT/$APP/VHOST"
+    URLS_PATH="$DOKKU_ROOT/$APP/URLS"
     WILDCARD_SSL="$DOKKU_ROOT/tls"
     SSL="$DOKKU_ROOT/$APP/tls"
 
@@ -27,6 +29,7 @@ case "$1" in
       DOKKU_APP_LISTEN_IP=$(< "$DOKKU_ROOT/$APP/IP")
     fi
 
+    [[ -f "$DOKKU_ROOT/ENV" ]] && source $DOKKU_ROOT/ENV
     [[ -f "$DOKKU_ROOT/$APP/ENV" ]] && source $DOKKU_ROOT/$APP/ENV
 
     if [[ ! -n "$NO_VHOST" ]] && [[ -f "$DOKKU_ROOT/$APP/VHOST" ]]; then
@@ -43,57 +46,74 @@ EOF
         SSL_DIRECTIVES=""
       fi
 
-      NGINX_CONF="$PLUGIN_PATH/nginx-vhosts/templates/nginx.conf"
+      NGINX_CONF=$(mktemp -t "nginx.conf.XXXXXX")
       SCHEME="http"
       if [[ -n "$SSL_INUSE" ]]; then
-        NGINX_CONF="$PLUGIN_PATH/nginx-vhosts/templates/nginx.ssl.conf"
         SCHEME="https"
 
         SSL_HOSTNAME=$(openssl x509 -in $SSL_INUSE/server.crt -noout -subject | tr '/' '\n' | grep CN= | cut -c4-)
-        SSL_HOSTNAME=$(echo "$SSL_HOSTNAME" | sed 's|\.|\\.|g' | sed 's/\*/\.\*/g')
+        if [[ -n "$SSL_HOSTNAME" ]]; then
+          SSL_HOSTNAME_REGEX=$(echo "$SSL_HOSTNAME" | sed 's|\.|\\.|g' | sed 's/\*/\[^\.\]\*/g')
+          [[ -z "$(egrep "^${SSL_HOSTNAME_REGEX}$" $VHOST_PATH)" ]] && echo "$SSL_HOSTNAME" >> $VHOST_PATH
+        fi
 
-        [[ -z "$(egrep ^"$SSL_HOSTNAME"$ $VHOST_PATH)" ]] && echo "$SSL_HOSTNAME" | sed 's/\\./\./g' >> $VHOST_PATH
-        SSL_VHOSTS=$(egrep ^"$SSL_HOSTNAME"$ $VHOST_PATH || exit 0)
-        NONSSL_VHOSTS=$(egrep -v ^"$SSL_HOSTNAME"$ $VHOST_PATH || exit 0)
+        SSL_HOSTNAME_ALT=$(openssl x509 -in $SSL_INUSE/server.crt -noout -text | grep --after-context=1 '509v3 Subject Alternative Name:' | tail -n 1 | sed -e "s/[[:space:]]*DNS://g"  | tr ',' '\n' || true)
+        if [[ -n "$SSL_HOSTNAME_ALT" ]]; then
+          SSL_HOSTNAME_ALT_REGEX=$(echo "$SSL_HOSTNAME_ALT" | sed 's|\.|\\.|g' | sed 's/\*/\[^\.\]\*/g')
+          [[ -z "$(egrep "^${SSL_HOSTNAME_ALT_REGEX}$" $VHOST_PATH)" ]] && echo "$SSL_HOSTNAME_ALT" >> $VHOST_PATH
+        fi
 
+        SSL_VHOSTS=$(egrep "^${SSL_HOSTNAME_REGEX}$|^${SSL_HOSTNAME_ALT_REGEX}$" $VHOST_PATH || exit 0)
+        NONSSL_VHOSTS=$(egrep -v "^${SSL_HOSTNAME}$|^${SSL_HOSTNAME_ALT}$" $VHOST_PATH || exit 0)
+
+        NGINX_TEMPLATE="$PLUGIN_PATH/nginx-vhosts/templates/nginx.ssl.conf"
         while read line; do
-          echo "-----> Configuring SSL for $line..."
+          dokku_log_info1 "Configuring SSL for $line..."
           SSL_SERVER_NAME=$line
-          eval "cat <<< \"$(< $NGINX_CONF)\" >> $DOKKU_ROOT/$APP/nginx.conf"
+          NOSSL_SERVER_NAME=$line
+          eval "cat <<< \"$(< $NGINX_TEMPLATE)\" >> $NGINX_CONF"
         done <<< "$SSL_VHOSTS"
       fi
 
+      NOSSL_SERVER_NAME=$(echo $NONSSL_VHOSTS | tr '\n' ' ')
       APP_NGINX_TEMPLATE="$DOKKU_ROOT/$APP/nginx.conf.template"
       if [[ -f $APP_NGINX_TEMPLATE ]]; then
-        echo "-----> Overriding default nginx.conf with detected nginx.conf.template"
-        NGINX_CONF=$APP_NGINX_TEMPLATE
+        dokku_log_info1 "Overriding default nginx.conf with detected nginx.conf.template"
+        eval "cat <<< \"$(< $APP_NGINX_TEMPLATE)\" > $NGINX_CONF"
+      elif [[ -n "$NONSSL_VHOSTS" ]]; then
+        xargs -i echo "-----> Configuring {}..." <<< "$NONSSL_VHOSTS"
+        NGINX_TEMPLATE="$PLUGIN_PATH/nginx-vhosts/templates/nginx.conf"
+        eval "cat <<< \"$(< $NGINX_TEMPLATE)\" >> $NGINX_CONF"
       fi
 
-      xargs -i echo "-----> Configuring {}..." < $VHOST_PATH
-      # Include SSL_VHOSTS so we can redirect http to https on that hostname as well
-      NOSSL_SERVER_NAME=$(echo $NONSSL_VHOSTS $SSL_VHOSTS| tr '\n' ' ')
+      if [[ -n "$DOKKU_APP_LISTEN_PORT" ]] && [[ -n "$DOKKU_APP_LISTEN_IP" ]]; then
+        echo "upstream $APP { server $DOKKU_APP_LISTEN_IP:$DOKKU_APP_LISTEN_PORT; }" >> $NGINX_CONF
+      fi
+
+      dokku_log_info1 "Creating $SCHEME nginx.conf"
+      mv $NGINX_CONF "$DOKKU_ROOT/$APP/nginx.conf"
 
       if [[ -n "$DOKKU_APP_LISTEN_PORT" ]] && [[ -n "$DOKKU_APP_LISTEN_IP" ]]; then
-        echo "-----> Creating $SCHEME nginx.conf"
-        echo "upstream $APP { server $DOKKU_APP_LISTEN_IP:$DOKKU_APP_LISTEN_PORT; }" > $DOKKU_ROOT/$APP/nginx.conf
-        eval "cat <<< \"$(< $NGINX_CONF)\" >> $DOKKU_ROOT/$APP/nginx.conf"
-
-        echo "-----> Running nginx-pre-reload"
+        dokku_log_info1 "Running nginx-pre-reload"
         pluginhook nginx-pre-reload $APP $DOKKU_APP_LISTEN_PORT $DOKKU_APP_LISTEN_IP
 
         echo "       Reloading nginx"
         restart_nginx
       fi
+
+      echo "# THIS FILE IS GENERATED BY DOKKU - DO NOT EDIT, YOUR CHANGES WILL BE OVERWRITTEN" > $URLS_PATH
+      xargs -i echo "https://{}" <<< "${SSL_VHOSTS}" >> $URLS_PATH
+      xargs -i echo "http://{}" <<< "${NONSSL_VHOSTS}" >> $URLS_PATH
     else
       if [[ -f "$DOKKU_ROOT/$APP/VHOST" ]]; then
-        echo "-----> VHOST support disabled, deleting $APP/VHOST"
+        dokku_log_info1 "VHOST support disabled, deleting $APP/VHOST"
         rm "$DOKKU_ROOT/$APP/VHOST"
       fi
       if [[ -f "$DOKKU_ROOT/$APP/nginx.conf" ]]; then
-        echo "-----> VHOST support disabled, deleting nginx.conf"
+        dokku_log_info1 "VHOST support disabled, deleting nginx.conf"
         rm "$DOKKU_ROOT/$APP/nginx.conf"
 
-        echo "-----> VHOST support disabled, reloading nginx after nginx.conf deletion"
+        dokku_log_info1 "VHOST support disabled, reloading nginx after nginx.conf deletion"
         restart_nginx
       fi
     fi
@@ -101,7 +121,7 @@ EOF
 
   nginx:import-ssl)
     [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     [[ -t 0 ]] && echo "Tar archive containing server.crt and server.key expected on stdin" && exit 1
     APP="$2"
 

plugins/nginx-vhosts/dependencies

@@ -1,13 +1,14 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
 
 case "$DOKKU_DISTRO" in
   ubuntu)
+    export DEBIAN_FRONTEND=noninteractive
     [[ -z "$CIRCLECI" ]] && apt-get install -qq -y software-properties-common python-software-properties
     [[ -n "$CIRCLECI" ]] && aptitude install -q -y software-properties-common python-software-properties
     add-apt-repository -y ppa:nginx/stable
     apt-get update
-    apt-get install -qq -y nginx dnsutils
+    apt-get install -o Dpkg::Options::="--force-confdef" -o Dpkg::Options::="--force-confold" --force-yes -qq -y nginx dnsutils
     ;;
 
   opensuse)

plugins/nginx-vhosts/install

@@ -25,9 +25,7 @@ ssl_session_timeout 10m;
 
 ssl_ciphers EECDH+AES128:RSA+AES128:EECDH+AES256:RSA+AES256:EECDH+3DES:RSA+3DES:!MD5;
 ssl_protocols TLSv1.2 TLSv1.1 TLSv1;
-# this is already defined in the base nginx.conf and causes nginx reloads/starts to fail
-# when its defined twice
-# ssl_prefer_server_ciphers on;
+ssl_prefer_server_ciphers on;
 
 # ssl_certificate $DOKKU_ROOT/tls/server.crt;
 # ssl_certificate_key $DOKKU_ROOT/tls/server.key;

plugins/nginx-vhosts/post-deploy

@@ -1,12 +1,12 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 APP="$1"; PORT="$2"; IP="$3"
-
-set +e; NO_VHOST=$(dokku config:get $APP NO_VHOST); set -e
+NO_VHOST=$(dokku config:get $APP NO_VHOST || true)
 
 if [[ -n "$NO_VHOST" ]]; then
-  echo "-----> NO_VHOST config detected"
+  dokku_log_info1 "NO_VHOST config detected"
 elif [[ ! -f "$DOKKU_ROOT/$APP/VHOST" ]]; then
   dokku domains:setup $APP
 fi

plugins/nginx-vhosts/post-domains-update

@@ -1,5 +1,6 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 APP="$1"
 

plugins/ps/commands

@@ -0,0 +1,116 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
+
+release_and_deploy() {
+  source "$(dirname $0)/../common/functions"
+  local APP="$1"; local IMAGE="dokku/$APP"
+
+  if [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
+    if is_image_buildstep_based "$IMAGE"; then
+      IMAGE_SOURCE_TYPE="buildstep"
+    else
+      IMAGE_SOURCE_TYPE="dockerfile"
+    fi
+
+    dokku_log_info1 "Releasing $APP ..."
+    dokku release "$APP" "$IMAGE_SOURCE_TYPE"
+    dokku_log_info1 "Deploying $APP ..."
+    dokku deploy "$APP"
+    dokku_log_info2 "Application deployed:"
+         dokku urls $APP | sed "s/^/       /"
+    echo
+  fi
+}
+
+case "$1" in
+  ps)
+    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
+    verify_app_name "$2"
+
+    APP="$2"; [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]] && CONTAINER_ID=$(< "$DOKKU_ROOT/$APP/CONTAINER")
+    [[ -z "$CONTAINER_ID" ]] && echo "App $APP has not been deployed" && exit 0
+
+    docker exec -ti "$CONTAINER_ID" /bin/bash -c "ps auxwww"
+  ;;
+
+  ps:start)
+    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
+    verify_app_name "$2"
+
+    APP="$2"; [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]] && CONTAINER_ID=$(< "$DOKKU_ROOT/$APP/CONTAINER")
+    [[ -z "$CONTAINER_ID" ]] && echo "App $APP has not been deployed" && exit 0
+
+    if [[ "$(docker ps -q --no-trunc| grep -q $CONTAINER_ID; echo $?)" != "0" ]]; then
+      release_and_deploy $APP
+    else
+      echo "App $APP already running"
+    fi
+  ;;
+
+  ps:stop)
+    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
+    verify_app_name "$2"
+
+    APP="$2"; [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]] && CONTAINER_ID=$(< "$DOKKU_ROOT/$APP/CONTAINER")
+    [[ -z "$CONTAINER_ID" ]] && echo "App $APP has not been deployed" && exit 0
+
+    if [[ "$(docker ps -q --no-trunc| grep -q $CONTAINER_ID; echo $?)" = "0" ]]; then
+      echo "Stopping $APP ..."
+      docker stop $CONTAINER_ID > /dev/null
+    else
+      echo "App $APP already stopped"
+    fi
+  ;;
+
+  ps:rebuild)
+    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
+    verify_app_name "$2"
+    APP="$2"
+
+    pluginhook receive-app $APP
+  ;;
+
+  ps:rebuildall)
+    shopt -s nullglob
+    for app in $DOKKU_ROOT/*/CONTAINER; do
+      APP=$(basename "$(dirname $app)");
+      dokku ps:rebuild $APP
+    done
+  ;;
+
+  ps:restart)
+    [[ -z $2 ]] && echo "Please specify an app to run the command on" && exit 1
+    verify_app_name "$2"
+
+    APP="$2"; [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]] && CONTAINER_ID=$(< "$DOKKU_ROOT/$APP/CONTAINER")
+    [[ -z "$CONTAINER_ID" ]] && echo "App $APP has not been deployed" && exit 0
+
+    release_and_deploy $APP
+  ;;
+
+  ps:restartall)
+    shopt -s nullglob
+    for app in $DOKKU_ROOT/*/CONTAINER; do
+      APP=$(basename "$(dirname $app)");
+      dokku ps:restart $APP
+    done
+  ;;
+
+  help | ps:help)
+    cat && cat<<EOF
+    ps <app>                                        List processes running in app container(s)
+    ps:start <app>                                  Start app container(s)
+    ps:stop <app>                                   Stop app container(s)
+    ps:rebuild <app>                                Rebuild an app
+    ps:rebuildall                                   Rebuild all apps
+    ps:restart <app>                                Restart app container(s)
+    ps:restartall                                   Restart all deployed app containers
+EOF
+    ;;
+
+  *)
+    exit $DOKKU_NOT_IMPLEMENTED_EXIT
+    ;;
+
+esac

plugins/shell/commands

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+case "$1" in
+  shell)
+    INPUTRC="$PLUGIN_ROOT/inputrc"
+    HISTFILE=~/.dokku_history
+
+    history -r || true
+
+    trim()
+    {
+      sed -e 's/^[[:space:]]*//g' -e 's/[[:space:]]*$//g'
+    }
+
+    trap 'history -w' EXIT
+
+    while true; do
+      trap '' SIGINT
+      read -ep "dokku> " line || {
+        echo; true; break
+      }
+      trap - SIGINT
+
+      line=$(echo $line | trim)
+      CMD=$(echo $line | awk '{ print $1 }')
+
+      [ -z $CMD ] && continue
+
+      [[ "$line" != "$(fc -ln -1 | trim)" ]] && history -s "$line"
+
+      case $CMD in
+    # shell builtins
+        clear)
+          clear
+          ;;
+        quit|exit)
+          break
+          ;;
+
+    # Not a built-in, run as regular dokku command
+        *)
+          dokku $line || true
+      esac
+
+    done
+    ;;
+
+  help | shell:help)
+    cat && cat<<EOF
+    shell                                           Spawn dokku shell
+EOF
+    ;;
+
+  *)
+    exit $DOKKU_NOT_IMPLEMENTED_EXIT
+    ;;
+
+esac

plugins/shell/inputrc

@@ -0,0 +1 @@
+set disable-completion on

tests.mk

@@ -56,16 +56,25 @@ lint:
 	# SC2143: Instead of [ -n $(foo | grep bar) ], use foo | grep -q bar - https://github.com/koalaman/shellcheck/wiki/SC2143
 	# SC2001: See if you can use ${variable//search/replace} instead. - https://github.com/koalaman/shellcheck/wiki/SC2001
 	@echo linting...
-	@$(QUIET) find . -not -path '*/\.*' | xargs file | egrep "shell|bash" | awk '{ print $$1 }' | sed 's/://g' | xargs shellcheck -e SC2034,SC2086,SC2143,SC2001
+	@$(QUIET) shellcheck -e SC2029 ./contrib/dokku_client.sh
+	@$(QUIET) find . -not -path '*/\.*' | xargs file | egrep "shell|bash" | grep -v directory | awk '{ print $$1 }' | sed 's/://g' | grep -v dokku_client.sh | xargs shellcheck -e SC2034,SC2086,SC2143,SC2001
 
 unit-tests:
 	@echo running unit tests...
 	@$(QUIET) bats tests/unit
 
+deploy-test-clojure:
+	@echo deploying config app...
+	cd tests && ./test_deploy ./apps/clojure dokku.me
+
 deploy-test-config:
 	@echo deploying config app...
 	cd tests && ./test_deploy ./apps/config dokku.me
 
+deploy-test-dockerfile:
+	@echo deploying dockerfile app...
+	cd tests && ./test_deploy ./apps/dockerfile dokku.me
+
 deploy-test-gitsubmodules:
 	@echo deploying gitsubmodules app...
 	cd tests && ./test_deploy ./apps/gitsubmodules dokku.me
@@ -98,6 +107,10 @@ deploy-test-python-flask:
 	@echo deploying python-flask app...
 	cd tests && ./test_deploy ./apps/python-flask dokku.me
 
+deploy-test-ruby:
+	@echo deploying ruby app...
+	cd tests && ./test_deploy ./apps/ruby dokku.me
+
 deploy-test-scala:
 	@echo deploying scala app...
 	cd tests && ./test_deploy ./apps/scala dokku.me
@@ -110,6 +123,8 @@ deploy-tests:
 	@echo running deploy tests...
 	# @$(QUIET) bats tests/deploy
 	@$(QUIET) $(MAKE) deploy-test-config
+	@$(QUIET) $(MAKE) deploy-test-clojure
+	@$(QUIET) $(MAKE) deploy-test-dockerfile
 	@$(QUIET) $(MAKE) deploy-test-gitsubmodules
 	@$(QUIET) $(MAKE) deploy-test-go
 	@$(QUIET) $(MAKE) deploy-test-java

tests/apps/.websocket.disabled/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; output="$(curl -s -S -i -N -H \"Connection: Upgrade\" -H \"Upgrade: websocket\" -H \"Host: $1\" -H \"Origin: $1\" $1 -m 2)"; echo $output; test "$output" == "bazingaa"

tests/apps/clojure/Procfile

@@ -0,0 +1 @@
+web: lein run

tests/apps/clojure/README.md

@@ -0,0 +1,4 @@
+Hello Clojure/Compojure
+=======================
+
+A minimal Hello World web app in [Clojure](http://clojure.org/), using the [Compojure](https://github.com/weavejester/compojure) web framework.

tests/apps/clojure/check_deploy

@@ -0,0 +1 @@
+set -e; sleep 5; output="$(curl -s -S $1)"; echo $output; test "$output" == "Hello World!"

tests/apps/clojure/project.clj

@@ -0,0 +1,7 @@
+(defproject clojure-sample "1.0.1"
+  :description "Hello World Clojure Web App"
+  :dependencies [[org.clojure/clojure "1.6.0"]
+                 [compojure "1.3.1"]
+                 [ring/ring-jetty-adapter "1.3.2"]]
+  :main ^:skip-aot sample.app
+  :min-lein-version "2.0.0")

tests/apps/clojure/src/sample/app.clj

@@ -0,0 +1,13 @@
+(ns sample.app
+  (:require [ring.adapter.jetty :as jetty]
+            [compojure.core :refer [defroutes GET]]))
+
+(defroutes handler
+  (GET "/" []
+       {:headers {"Content-type" "text/plain; charset=UTF-8"}
+        :body "Hello World!"}))
+
+(defn -main []
+  (jetty/run-jetty handler
+                   {:port (Integer. (or (System/getenv "PORT") "5000"))
+                    :join? false}))

tests/apps/config/check_deploy

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e;
 
 test_url () {

tests/apps/config/post-deploy

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -ex;
 
 REMOTE=$1

tests/apps/dockerfile/CHECKS

@@ -0,0 +1 @@
+/ Hello World!

tests/apps/dockerfile/Dockerfile

@@ -0,0 +1,14 @@
+FROM ubuntu:trusty
+ENV LC_ALL C
+ENV DEBIAN_FRONTEND noninteractive
+ENV DEBCONF_NONINTERACTIVE_SEEN true
+EXPOSE 3000
+
+RUN apt-get install -y software-properties-common && add-apt-repository ppa:chris-lea/node.js && apt-get update
+RUN apt-get install -y build-essential curl postgresql-client-9.3 nodejs git
+
+COPY . /app
+WORKDIR /app
+RUN npm install
+
+CMD npm start

tests/apps/dockerfile/check_deploy

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+set -e; output="$(curl -s -S $1)"; echo $output; test "$output" == "Hello World!"

tests/apps/dockerfile/index.js

@@ -0,0 +1,13 @@
+var express = require('express')
+var app = express();
+
+app.set('port', (process.env.PORT || 5000))
+app.use(express.static(__dirname + '/public'))
+
+app.get('/', function(request, response) {
+  response.send('Hello World!')
+})
+
+app.listen(app.get('port'), function() {
+  console.log("Node app is running at localhost:" + app.get('port'))
+})

tests/apps/dockerfile/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "node-js-sample",
+  "version": "0.1.0",
+  "description": "A sample Node.js app using Express 4",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "express": "^4.0.0"
+  },
+  "engines": {
+    "node": "0.10.x"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/heroku/node-js-sample"
+  },
+  "keywords": [
+    "node",
+    "heroku",
+    "express"
+  ],
+  "author": "Mark Pundsack",
+  "contributors": [
+    "Zeke Sikelianos <zeke@sikelianos.com> (http://zeke.sikelianos.com)"
+  ],
+  "license": "MIT"
+}

tests/apps/gitsubmodules/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; output="$(curl -s -S $1)"; echo $output; test "$output" == "Hello World!"

tests/apps/gitsubmodules/pre-commit

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 git submodule add https://github.com/heroku/node-js-sample.git node-js-sample

tests/apps/go/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; test "$(curl -s -S "$1")" == "go"

tests/apps/multi/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; curl -s -S "$1" | grep -q "Heroku Multi Buildpack on Dokku"

tests/apps/nodejs-express-noprocfile/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; output="$(curl -s -S "$1")"; echo "$output"; test "$output" == "nodejs/express"

tests/apps/nodejs-express/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; output="$(curl -s -S "$1")"; echo "$output"; test "$output" == "nodejs/express"

tests/apps/php/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; output="$(curl -s -S "$1")"; echo "$output"; test "$output" == "<html><h3>php</h3></html>"

tests/apps/php/composer.json

@@ -1,11 +1,13 @@
 {
-  "name": "test-php-app",
   "description": "a test php app for dokku",
+  "name": "test-php-app/0.1",
   "require": {
     "monolog/monolog": "~1.7",
+    "php": ">=5.5.9",
     "silex/silex": "~1.1"
   },
   "require-dev": {
     "heroku/heroku-buildpack-php": "*"
-  }
+  },
+  "license": "MIT"
 }

tests/apps/python-flask/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; output="$(curl -s -S "$1")"; echo "$output"; test "$output" == "python/flask"

tests/apps/ruby/CHECKS

@@ -0,0 +1 @@
+/ Hello, world

tests/apps/ruby/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+ruby '2.1.5'
+
+gem 'sinatra', '~>1.4.4'
+gem 'thin'

tests/apps/ruby/Gemfile.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    daemons (1.1.9)
+    eventmachine (1.0.3)
+    rack (1.5.2)
+    rack-protection (1.5.2)
+      rack
+    sinatra (1.4.4)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    thin (1.6.1)
+      daemons (>= 1.0.9)
+      eventmachine (>= 1.0.0)
+      rack (>= 1.0.0)
+    tilt (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  sinatra (~> 1.4.4)
+  thin

tests/apps/ruby/Procfile

@@ -0,0 +1 @@
+web: bundle exec ruby web.rb -p $PORT

tests/apps/ruby/README.md

@@ -0,0 +1,33 @@
+# ruby-sample
+
+This is a barebones Ruby app using the [Sinatra](http://www.sinatrarb.com) framework.
+
+## Running Locally
+
+Asumming you have [Ruby](https://www.ruby-lang.org), [Bundler](http://bundler.io) and [Heroku Toolbelt](https://toolbelt.heroku.com) installed on your machine:
+
+```sh
+git clone git@github.com:heroku/ruby-sample.git # or clone your own fork
+cd ruby-sample
+bundle
+foreman start
+```
+
+Your app should now be running on [localhost:5000](http://localhost:5000/).
+
+## Deploying to Heroku
+
+```
+heroku create
+git push heroku master
+heroku open
+```
+
+## Documentation
+
+For more information about using Ruby on Heroku, see these Dev Center articles:
+
+- [Ruby on Heroku](https://devcenter.heroku.com/categories/ruby)
+- [Getting Started with Ruby on Heroku](https://devcenter.heroku.com/articles/getting-started-with-ruby)
+- [Getting Started with Rails 4.x on Heroku](https://devcenter.heroku.com/articles/getting-started-with-rails4)
+- [Heroku Ruby Support](https://devcenter.heroku.com/articles/ruby-support)

tests/apps/ruby/check_deploy

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+set -e; output="$(curl -s -S "$1")"; echo "$output"; test "$output" == "Hello, world"

tests/apps/ruby/web.rb

@@ -0,0 +1,5 @@
+require 'sinatra'
+
+get '/' do
+  "Hello, world"
+end

tests/apps/static/.env

@@ -1 +1 @@
-export BUILDPACK_URL=https://github.com/florianheinemann/buildpack-nginx
+export BUILDPACK_URL=https://github.com/yabawock/buildpack-nginx

tests/apps/static/check_deploy

@@ -1,2 +1,2 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -e; output="$(curl -s -S "$1")"; echo "$output"; test "$output" == "<html><h3>Static Page</h3></html>"

tests/ci/parallel_runner.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+
+case "$CIRCLE_NODE_INDEX" in
+  0)
+    echo "=====> make unit-tests"
+    sudo -E make -e unit-tests
+    ;;
+
+  1)
+    echo "=====> make deploy-tests (buildstep release)"
+    sudo -E make -e deploy-tests
+    ;;
+
+  2)
+    echo "=====> make deploy-tests (buildstep master)"
+    docker rmi -f progrium/buildstep && \
+    sudo -E BUILD_STACK=true make -e stack && \
+    sudo -E make -e deploy-tests
+    ;;
+esac

tests/test_deploy

@@ -11,7 +11,6 @@ destroy_app(){
 
 failed(){
   echo "************ $1 failed ************"
-  dokku logs $REPO
   destroy_app
   exit 1
 }
@@ -47,5 +46,4 @@ else
   fi
 fi
 
-dokku logs $REPO
 destroy_app

tests/unit/00_dokku-standard.bats

@@ -9,29 +9,71 @@ setup() {
 teardown() {
   rm -rf /home/dokku/$TEST_APP/tls /home/dokku/tls
   destroy_app
+  disable_tls_wildcard
+}
+
+assert_urls() {
+  urls=$@
+  run dokku urls $TEST_APP
+  echo "output: "$output
+  echo "status: "$status
+  assert_output < <(tr ' ' '\n' <<< "${urls}")
+}
+
+build_nginx_config() {
+  # simulate nginx post-deploy
+  dokku domains:setup $TEST_APP
+  dokku nginx:build-config $TEST_APP
+}
+
+@test "run (with tty)" {
+  deploy_app
+  run /bin/bash -c "dokku run $TEST_APP ls /app/package.json"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "run (without tty)" {
+  deploy_app
+  run /bin/bash -c ": |dokku run $TEST_APP ls /app/package.json"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "run (with --options)" {
+  deploy_app
+  run /bin/bash -c "dokku --force --quiet run $TEST_APP node --version"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
 }
 
 @test "urls (non-ssl)" {
-  run bash -c "dokku urls $TEST_APP | grep dokku.me"
-  echo "output: "$output
-  echo "status: "$status
-  assert_output "http://dokku.me"
+  assert_urls "http://dokku.me"
+  build_nginx_config
+  assert_urls "http://${TEST_APP}.dokku.me"
+  add_domain "test.dokku.me"
+  assert_urls "http://${TEST_APP}.dokku.me" "http://test.dokku.me"
 }
 
 @test "urls (app ssl)" {
-  mkdir -p /home/dokku/$TEST_APP/tls
-  touch /home/dokku/$TEST_APP/tls/server.crt /home/dokku/$TEST_APP/tls/server.key
-  run bash -c "dokku urls $TEST_APP | grep dokku.me"
-  echo "output: "$output
-  echo "status: "$status
-  assert_output "https://dokku.me"
+  setup_test_tls
+  assert_urls "https://dokku.me"
+  build_nginx_config
+  assert_urls "https://node-js-app.dokku.me" "http://${TEST_APP}.dokku.me"
+  add_domain "test.dokku.me"
+  assert_urls "https://node-js-app.dokku.me" "http://${TEST_APP}.dokku.me" "http://test.dokku.me"
 }
 
 @test "urls (wildcard ssl)" {
-  mkdir -p /home/dokku/tls
-  touch /home/dokku/tls/server.crt /home/dokku/tls/server.key
-  run bash -c "dokku urls $TEST_APP | grep dokku.me"
-  echo "output: "$output
-  echo "status: "$status
-  assert_output "https://dokku.me"
+  setup_test_tls_wildcard
+  assert_urls "https://dokku.me"
+  build_nginx_config
+  assert_urls "https://${TEST_APP}.dokku.me"
+  add_domain "test.dokku.me"
+  assert_urls "https://${TEST_APP}.dokku.me" "https://test.dokku.me"
+  add_domain "dokku.example.com"
+  assert_urls "https://${TEST_APP}.dokku.me" "https://test.dokku.me" "http://dokku.example.com"
 }

tests/unit/apps.bats

@@ -19,7 +19,7 @@ APP=lifecycle-app
 }
 
 @test "apps:destroy" {
-  run bash -c "echo $APP | dokku apps:destroy $APP"
+  run bash -c "dokku --force apps:destroy $APP"
   echo "output: "$output
   echo "status: "$status
   assert_success

tests/unit/cleanup.bats

@@ -0,0 +1,36 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  deploy_app
+}
+
+teardown() {
+  destroy_app
+}
+
+@test "remove exited containers" {
+  # make sure we have many exited containers of the same 'type'
+  run bash -c "for cnt in 1 2 3; do dokku run $TEST_APP hostname; done"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "docker ps -a -f 'status=exited' --no-trunc=false | grep '/exec hostname'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run dokku cleanup
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  sleep 5  # wait for dokku cleanup to happen in the background
+  run bash -c "docker ps -a -f 'status=exited' --no-trunc=false | grep '/exec hostname'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_failure
+  run bash -c "docker ps -a -f 'status=exited' -q --no-trunc=false"
+  echo "output: "$output
+  echo "status: "$status
+  assert_output ""
+}

tests/unit/client.bats

@@ -0,0 +1,162 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  export DOKKU_HOST=dokku.me
+  create_app
+}
+
+teardown() {
+  destroy_app
+  unset DOKKU_HOST
+}
+
+@test "dokku client (unconfigured DOKKU_HOST)" {
+  unset DOKKU_HOST
+  run ./contrib/dokku_client.sh apps
+  echo "output: "$output
+  echo "status: "$status
+  assert_exit_status 20
+}
+
+@test "dokku client (no args should print help)" {
+  run /bin/bash -c "./contrib/dokku_client.sh | head -1 | egrep -q '^Usage: dokku \[.+\] COMMAND <app>.*'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "dokku client (apps:create AND apps:destroy)" {
+  setup_client_repo
+  run bash -c "${BATS_TEST_DIRNAME}/../../contrib/dokku_client.sh apps:create"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "${BATS_TEST_DIRNAME}/../../contrib/dokku_client.sh --force apps:destroy"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "dokku client (config:set)" {
+  run ./contrib/dokku_client.sh config:set $TEST_APP test_var=true test_var2=\"hello world\"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run /bin/bash -c "./contrib/dokku_client.sh config:get $TEST_APP test_var2 | grep -q 'hello world'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "dokku client (config:unset)" {
+  run ./contrib/dokku_client.sh config:set $TEST_APP test_var=true test_var2=\"hello world\"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run ./contrib/dokku_client.sh config:get $TEST_APP test_var
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run ./contrib/dokku_client.sh config:unset $TEST_APP test_var
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run /bin/bash -c "./contrib/dokku_client.sh config:get $TEST_APP test_var | grep test_var"
+  echo "output: "$output
+  echo "status: "$status
+  assert_failure
+}
+
+@test "dokku client (domains)" {
+  run bash -c "./contrib/dokku_client.sh domains $TEST_APP | grep -q ${TEST_APP}.dokku.me"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "dokku client (domains:add)" {
+  run ./contrib/dokku_client.sh domains:add $TEST_APP www.test.app.dokku.me
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run ./contrib/dokku_client.sh domains:add $TEST_APP test.app.dokku.me
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "dokku client (domains:remove)" {
+  run ./contrib/dokku_client.sh domains:add $TEST_APP test.app.dokku.me
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run ./contrib/dokku_client.sh domains:remove $TEST_APP test.app.dokku.me
+  echo "output: "$output
+  echo "status: "$status
+  refute_line "test.app.dokku.me"
+}
+
+@test "dokku client (domains:clear)" {
+  run ./contrib/dokku_client.sh domains:add $TEST_APP test.app.dokku.me
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run ./contrib/dokku_client.sh domains:clear $TEST_APP
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+# @test "dokku client (ps)" {
+#   # CI support: 'Ah. I just spoke with our Docker expert --
+#   # looks like docker exec is built to work with docker-under-libcontainer,
+#   # but we're using docker-under-lxc. I don't have an estimated time for the fix, sorry
+#   skip "circleci does not support docker exec at the moment."
+#   deploy_app
+#   run bash -c "${BATS_TEST_DIRNAME}/../../contrib/dokku_client.sh ps $TEST_APP | grep -q 'node web.js'"
+#   echo "output: "$output
+#   echo "status: "$status
+#   assert_success
+# }
+
+@test "dokku client (ps:start)" {
+  deploy_app
+  run bash -c "${BATS_TEST_DIRNAME}/../../contrib/dokku_client.sh ps:stop $TEST_APP"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "${BATS_TEST_DIRNAME}/../../contrib/dokku_client.sh ps:start $TEST_APP"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "docker ps -q --no-trunc | grep -q $(< $DOKKU_ROOT/$TEST_APP/CONTAINER)"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "dokku client (ps:stop)" {
+  deploy_app
+  run bash -c "${BATS_TEST_DIRNAME}/../../contrib/dokku_client.sh ps:stop $TEST_APP"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "docker ps -q --no-trunc | grep -q $(< $DOKKU_ROOT/$TEST_APP/CONTAINER)"
+  echo "output: "$output
+  echo "status: "$status
+  assert_failure
+}
+
+@test "dokku client (ps:restart)" {
+  deploy_app
+  run bash -c "${BATS_TEST_DIRNAME}/../../contrib/dokku_client.sh ps:restart $TEST_APP"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "docker ps -q --no-trunc | grep -q $(< $DOKKU_ROOT/$TEST_APP/CONTAINER)"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}

tests/unit/config.bats

@@ -3,11 +3,13 @@
 load test_helper
 
 setup() {
+  sudo -H -u dokku /bin/bash -c "echo 'export global_test=true' > $DOKKU_ROOT/ENV"
   create_app
 }
 
 teardown() {
   destroy_app
+  rm -f "$DOKKU_ROOT/ENV"
 }
 
 @test "config:set" {
@@ -21,6 +23,7 @@ teardown() {
   run ssh dokku@dokku.me config:set $TEST_APP test_var=true test_var2=\"hello world\"
   echo "output: "$output
   echo "status: "$status
+  assert_success
   run dokku config:get $TEST_APP test_var2
   echo "output: "$output
   echo "status: "$status
@@ -31,14 +34,33 @@ teardown() {
   run ssh dokku@dokku.me config:set $TEST_APP test_var=true test_var2=\"hello world\"
   echo "output: "$output
   echo "status: "$status
+  assert_success
   run dokku config:get $TEST_APP test_var
   echo "output: "$output
   echo "status: "$status
+  assert_success
   run dokku config:unset $TEST_APP test_var
   echo "output: "$output
   echo "status: "$status
+  assert_success
   run dokku config:get $TEST_APP test_var
   echo "output: "$output
   echo "status: "$status
   assert_output ""
 }
+
+@test "global config (buildstep)" {
+  deploy_app
+  run bash -c "dokku run $TEST_APP env | egrep '^global_test=true'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "global config (dockerfile)" {
+  deploy_app dockerfile
+  run bash -c "dokku run $TEST_APP env | egrep '^global_test=true'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}

tests/unit/nginx-vhosts.bats

@@ -12,6 +12,45 @@ teardown() {
   destroy_app
   [[ -f "$DOKKU_ROOT/VHOST.bak" ]] && mv "$DOKKU_ROOT/VHOST.bak" "$DOKKU_ROOT/VHOST"
   [[ -f "$DOKKU_ROOT/HOSTNAME.bak" ]] && mv "$DOKKU_ROOT/HOSTNAME.bak" "$DOKKU_ROOT/HOSTNAME"
+  disable_tls_wildcard
+}
+
+assert_ssl_domain() {
+  local domain=$1
+  assert_app_domain "${domain}"
+  assert_http_redirect "http://${domain}" "https://${domain}/"
+  assert_http_success "https://${domain}"
+}
+
+assert_nonssl_domain() {
+  local domain=$1
+  assert_app_domain "${domain}"
+  assert_http_success "http://${domain}"
+}
+
+assert_app_domain() {
+  local domain=$1
+  run /bin/bash -c "dokku domains $TEST_APP | grep -xF ${domain}"
+  echo "output: "$output
+  echo "status: "$status
+  assert_output "${domain}"
+}
+
+assert_http_redirect() {
+  local from=$1
+  local to=$2
+  run curl -kSso /dev/null -w "%{redirect_url}" "${from}"
+  echo "output: "$output
+  echo "status: "$status
+  assert_output "${to}"
+}
+
+assert_http_success() {
+  local url=$1
+  run curl -kSso /dev/null -w "%{http_code}" "${url}"
+  echo "output: "$output
+  echo "status: "$status
+  assert_output "200"
 }
 
 @test "nginx (no server tokens)" {
@@ -22,27 +61,36 @@ teardown() {
   assert_failure
 }
 
+@test "nginx:build-config (wildcard SSL)" {
+  setup_test_tls_wildcard
+  add_domain "wildcard1.dokku.me"
+  add_domain "wildcard2.dokku.me"
+  add_domain "www.test.dokku.me"
+  deploy_app
+  assert_ssl_domain "wildcard1.dokku.me"
+  assert_ssl_domain "wildcard2.dokku.me"
+  assert_nonssl_domain "www.test.dokku.me"
+}
+
 @test "nginx:build-config (with SSL CN mismatch)" {
   setup_test_tls
   deploy_app
-  run /bin/bash -c "dokku domains $TEST_APP | grep node-js-app.dokku.me"
-  echo "output: "$output
-  echo "status: "$status
-  assert_output "node-js-app.dokku.me"
+  assert_ssl_domain "node-js-app.dokku.me"
+}
+
+@test "nginx:build-config (with SSL and Multiple SANs)" {
+  setup_test_tls_with_sans
+  deploy_app
+  assert_ssl_domain "test.dokku.me"
+  assert_ssl_domain "www.test.dokku.me"
+  assert_ssl_domain "www.test.app.dokku.me"
 }
 
 @test "nginx:build-config (no global VHOST and domains:add)" {
   destroy_app
   rm "$DOKKU_ROOT/VHOST"
   create_app
-  run dokku domains:add $TEST_APP www.test.app.dokku.me
-  echo "output: "$output
-  echo "status: "$status
-  assert_success
+  add_domain "www.test.app.dokku.me"
   deploy_app
-  sleep 5 # wait for nginx to reload
-  run bash -c "response=\"$(curl -s -S www.test.app.dokku.me)\"; echo \$response; test \"\$response\" == \"nodejs/express\""
-  echo "output: "$output
-  echo "status: "$status
-  assert_success
+  assert_nonssl_domain "www.test.app.dokku.me"
 }