Release 0.3.14

first stab at a common functions library. include argument parsing and a few definitions wired up. closes #932. closes #945

.gitignore

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

AUTHORS

@@ -12,6 +12,7 @@ Leo Unbekandt <leo@unbekandt.eu>
 Ludovic Perrine <jazzzz@gmail.com>
 Luigi Maselli <grigio.org@gmail.com>
 Martin Weiss <kornnflake@gmail.com>
+Michael Hobbs <github@psudo.net>
 Paul Lietar <paul@lietar.net>
 Rajiv Makhijani <rajiv@blue-tech.org>
 rhy-jot <rhy-jot@myeml.net>

HISTORY.md

@@ -1,5 +1,56 @@
 # History
 
+## 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
+- #858: @josegonzalez Disable server tokens in nginx. Closes #857
+- #859: @josegonzalez Pass command being executed when retrieving DOCKER_ARGS via pluginhook.
+- #861: @josegonzalez Default DOKKU_ROOT to ~dokku if unspecified. Closes #587
+- #863: @josegonzalez Add missing properties to the php composer.json
+- #864: @michaelhobbs bind docker container to internal port if using vhosts
+- #867: @michaelhobbs silent grep stderr. closes #862
+- #868: @michaelhobbs use circleci for automated testing
+- #872: @michaelhobbs fix/enable multi buildpack test
+- #873: @michaelhobbs support pre deployment usage of domains plugin. fixes interface binding issue
+- #874: @josegonzalez Add advanced installation docs that were removed in #706. Closes #869
+- #876: @vincentfretin give CACHE_PATH env variable for forward compatibility with herokuish
+- #877: @michaelhobbs add MH to AUTHORS
+- #880: @michaelhobbs disable VHOST deployment if global VHOST file is missing and an app domain has not been added
+- #881: @jomo troubleshooting typo: 64 != 46
+- #884: @michaelhobbs IP and PORT are likely to get clobbered. rename them
+- #885: @michaelhobbs test deploy node app without procfile
+
 ## 0.3.12
 
 - #846: @michaelhobbs add certificate CN to app VHOST if it's not already

Makefile

@@ -4,7 +4,6 @@ SSHCOMMAND_URL ?= https://raw.github.com/progrium/sshcommand/master/sshcommand
 PLUGINHOOK_URL ?= https://s3.amazonaws.com/progrium-pluginhook/pluginhook_0.1.0_amd64.deb
 STACK_URL ?= https://github.com/progrium/buildstep.git
 PREBUILT_STACK_URL ?= https://github.com/progrium/buildstep/releases/download/2014-12-16/2014-12-16_42bd9f4aab.tar.gz
-DOKKU_ROOT ?= /home/dokku
 PLUGINS_PATH ?= /var/lib/dokku/plugins
 
 # If the first argument is "vagrant-dokku"...
@@ -18,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
@@ -33,14 +45,15 @@ 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:
-	git describe --tags > ${DOKKU_ROOT}/VERSION  2> /dev/null || echo '~${DOKKU_VERSION} ($(shell date -uIminutes))' > ${DOKKU_ROOT}/VERSION
+	git describe --tags > ~dokku/VERSION  2> /dev/null || echo '~${DOKKU_VERSION} ($(shell date -uIminutes))' > ~dokku/VERSION
 
 plugin-dependencies: pluginhook
 	dokku plugins-install-dependencies
@@ -48,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}
@@ -79,12 +95,14 @@ 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:"

README.md

@@ -1,4 +1,4 @@
-# Dokku [![Build Status](https://app.wercker.com/status/029900380b7e5f31bbf4392725067769/s/master "Build Status")](https://app.wercker.com/project/bykey/029900380b7e5f31bbf4392725067769)
+# 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/).
 
@@ -10,7 +10,7 @@ Docker powered mini-Heroku. The smallest PaaS implementation you've ever seen. S
 
 To install the latest stable version of dokku, you can run the following bootstrapper command:
 
-    $ wget -qO- https://raw.github.com/progrium/dokku/v0.3.12/bootstrap.sh | sudo DOKKU_TAG=v0.3.12 bash
+    $ wget -qO- https://raw.github.com/progrium/dokku/v0.3.14/bootstrap.sh | sudo DOKKU_TAG=v0.3.14 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,29 @@ 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 => "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 /root/.ssh/authorized_keys && mv /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

@@ -0,0 +1,29 @@
+machine:
+  services:
+    - docker
+dependencies:
+  cache_directories:
+    - "~/docker"
+  override:
+    # 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 }
+    - 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/
+    - sudo chown -R root:root ~root/.ssh/
+    - sudo sed -e 's:/home/ubuntu:/root:g' ~root/.ssh/config
+    ####
+    - sudo -E make -e setup-deploy-tests
+  post:
+    - sudo -E make -e lint
+    - sudo -E make -e unit-tests
+test:
+  override:
+    ### 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 }

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.12"
+version   = "v0.3.14"
 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,112 @@
-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)
+
+function random_number() {
+  [[ -n "$1" ]] && RANGE="$1"
+  if [[ -n "$RANGE" ]];then
+    number=$RANDOM
+    let "number %= $RANGE"
+  else
+    number=$RANDOM
+  fi
+  echo $number
+}
+
+function 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"
+}
+
+function 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
+  function _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
+
+    [[ -z "$verb" ]] && verb=$1
+    shift
+    ssh "dokku@$DOKKU_HOST" "$verb" "$appname" "$@"
+  }
+
+  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"
+      ]
+    }
+  ]
+}

deb.mk

@@ -0,0 +1,159 @@
+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 "--> Installing docker gpg key"
+	curl --silent https://get.docker.io/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` apt-transport-https
+
+	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
+	cp 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
+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,28 @@
+#!/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
+
+    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,37 @@
+#!/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
+    ;;
+
+  abort-upgrade)
+    ;;
+
+  *)
+    echo "preinst called with unknown argument \`$1'" >&2
+    exit 1
+    ;;
+esac
+
+exit 0

docs/advanced-installation.md

@@ -0,0 +1,37 @@
+#Advanced installation
+
+## Development
+
+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/gitreceive 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 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
+```

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.

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/index.md

@@ -17,8 +17,8 @@ Docker powered mini-Heroku. The smallest PaaS implementation you've ever seen.
 
 ## 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/).
+ * **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.
  * **Client app.** Given the constraints, running commands remotely via SSH is fine.
 
 ## Sponsors

docs/installation.md

@@ -11,7 +11,7 @@ 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.12/bootstrap.sh | sudo DOKKU_TAG=v0.3.12 bash
+wget -qO- https://raw.github.com/progrium/dokku/v0.3.14/bootstrap.sh | sudo DOKKU_TAG=v0.3.14 bash
 ```
 
 ## Configuring
@@ -95,13 +95,6 @@ sudo BUILD_STACK=true make install
     10.0.0.2 dokku.me
     ```
 
-- Setup SSH Config in `~/.ssh/config`
-
-    ```
-    Host dokku.me
-        Port 2222
-    ```
-
 - Create VM
     ```
     # Optional ENV arguments:
@@ -113,6 +106,12 @@ sudo BUILD_STACK=true make install
     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`
+
+    ```
+    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.
 

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;
@@ -136,3 +136,40 @@ dokku domains:clear myapp
 # remove a custom domain from app
 dokku domains:remove myapp example.com
 ```
+
+### Container network interface binding
+
+> New as of 0.3.13
+
+The deployed docker container running your app's web process will bind to either the internal docker network interface (i.e. `docker inspect --format '{{ .NetworkSettings.IPAddress }}' $CONTAINER_ID`) or an external interface (i.e. 0.0.0.0) depending on dokku's VHOST configuration. Dokku will attempt to bind to the internal docker network interface unless you specifically set NO_VHOST for the given app or your dokku installation is not setup to use VHOSTS (i.e. $DOKKU_ROOT/VHOST is missing or $DOKKU_ROOT/HOSTNAME is set to an IPv4 or IPv6 address)
+
+```shell
+# container bound to docker interface
+root@dokku:~/dokku# docker ps
+CONTAINER ID        IMAGE                      COMMAND                CREATED              STATUS              PORTS               NAMES
+1b88d8aec3d1        dokku/node-js-app:latest   "/bin/bash -c '/star   About a minute ago   Up About a minute                       goofy_albattani
+
+root@dokku:~/dokku# docker inspect --format '{{ .NetworkSettings.IPAddress }}' goofy_albattani
+172.17.0.6
+
+# container bound to all interfaces (previous default)
+root@dokku:/home/dokku# docker ps
+CONTAINER ID        IMAGE                      COMMAND                CREATED              STATUS              PORTS                     NAMES
+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

@@ -35,11 +35,12 @@ The below plugin is a dummy `dokku hello` plugin. If your plugin exposes command
 ```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
-    [[ ! -d "$DOKKU_ROOT/$2" ]] && echo "App $2 does not exist" && exit 1
+    verify_app_name "$2"
     APP="$2";
 
     echo "Hello $APP"
@@ -70,6 +71,29 @@ A few notes:
 - 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
+  ```
 
 ## Community plugins
 
@@ -228,14 +252,15 @@ Note: The following plugins have been supplied by our community and may not have
 
 | Plugin                                                                                            | Author                | Compatibility         |
 | ------------------------------------------------------------------------------------------------- | --------------------- | --------------------- |
+| [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/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 |
 | [HipChat Notifications](https://github.com/cef/dokku-hipchat)                                     | [cef][]               |                       |
 | [Graphite/statsd](https://github.com/jlachowski/dokku-graphite-plugin)                            | [jlachowski][]        |                       |

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/troubleshooting.md

@@ -22,7 +22,7 @@ http {
 ```
 
 Note that the `server_names_hash_bucket_size` setting defines the maximum domain name length.
-A value of 64 would allow domains with up to 46 characters. Set it to 128 if you need longer ones.
+A value of 64 would allow domains with up to 64 characters. Set it to 128 if you need longer ones.
 
 Save the file and try stopping nginx and starting it again:
 
@@ -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

@@ -4,17 +4,25 @@ shopt -s nullglob
 
 export DOKKU_DISTRO=${DOKKU_DISTRO:="ubuntu"}
 export DOKKU_IMAGE=${DOKKU_IMAGE:="progrium/buildstep"}
-export DOKKU_ROOT=${DOKKU_ROOT:="/home/dokku"}
+export DOKKU_ROOT=${DOKKU_ROOT:=~dokku}
 
 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 "$@"
+for arg in "$@"; do
+  [[ "$arg" =~ ^-.* ]] && shift 1
+done
+! has_tty && DOKKU_QUIET_OUTPUT=1
+
 if [[ $(id -un) != "dokku" && $1 != plugins-install* && $1 != "plugins-update" ]]; then
   sudo -u dokku -E -H $0 "$@"
   exit
@@ -34,15 +42,15 @@ fi
 case "$1" in
   receive)
     APP="$2"; IMAGE="dokku/$APP"
-    echo "-----> Cleaning up ..."
+    dokku_log_info1 "Cleaning up ..."
     dokku cleanup
-    echo "-----> Building $APP ..."
+    dokku_log_info1 "Building $APP ..."
     cat | dokku build $APP
-    echo "-----> Releasing $APP ..."
+    dokku_log_info1 "Releasing $APP ..."
     dokku release $APP
-    echo "-----> Deploying $APP ..."
+    dokku_log_info1 "Deploying $APP ..."
     dokku deploy $APP
-    echo "=====> Application deployed:"
+    dokku_log_info2 "Application deployed:"
          dokku urls $APP | sed "s/^/       /"
     echo
     ;;
@@ -54,18 +62,29 @@ case "$1" in
     docker commit $id $IMAGE > /dev/null
     [[ -d $CACHE_DIR ]] || mkdir $CACHE_DIR
     pluginhook pre-build $APP
-    id=$(docker run -d -v $CACHE_DIR:/cache $IMAGE /build/builder)
+
+    # *DEPRECATED* in v0.4.0: `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
+
     pluginhook post-build $APP
     ;;
 
   release)
     APP="$2"; IMAGE="dokku/$APP"
     pluginhook pre-release $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/app-env.sh" < "$DOKKU_ROOT/$APP/ENV")
+      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
@@ -81,9 +100,20 @@ case "$1" in
     fi
 
     # start the app
-    DOCKER_ARGS=$(: | pluginhook docker-args $APP)
-    id=$(docker run -d -p 5000 -e PORT=5000 $DOCKER_ARGS $IMAGE /bin/bash -c "/start web")
-    port=$(docker port $id 5000 | sed 's/[0-9.]*://')
+    DOCKER_ARGS=$(: | pluginhook docker-args $APP deploy)
+    DOCKER_ARGS+=$(: | pluginhook docker-args-deploy $APP)
+    BIND_EXTERNAL=$(pluginhook bind-external-ip $APP)
+
+    if [[ "$BIND_EXTERNAL" = "false" ]];then
+      port=5000
+      id=$(docker run -d -e PORT=$port $DOCKER_ARGS $IMAGE /bin/bash -c "/start web")
+      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")
+      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 {
@@ -94,23 +124,23 @@ 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
+    dokku_log_info1 "Running pre-flight checks"
+    pluginhook check-deploy $id $APP $port ${ipaddr:-localhost}
 
     # now using the new container
     echo $id > "$DOKKU_ROOT/$APP/CONTAINER"
     echo $port > "$DOKKU_ROOT/$APP/PORT"
     echo "http://$(< "$DOKKU_ROOT/HOSTNAME"):$port" > "$DOKKU_ROOT/$APP/URL"
 
-    echo "-----> Running post-deploy"
-    pluginhook post-deploy  $APP $port
+    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
@@ -147,17 +177,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 [-q|--quiet|-t|--trace|--rm-container|-rm] COMMAND <app> [command-specific-options]"
     echo ""
+    echo "Options:"
 
     cat<<EOF | pluginhook commands help | sort
     help                                            Print the list of commands
@@ -182,8 +211,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,5 +1,6 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
 case "$1" in
   trace)
@@ -26,7 +27,7 @@ case "$1" in
 
   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,18 +44,22 @@ 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)
-    docker run -i -t $DOCKER_ARGS $IMAGE /exec "$@"
+    DOCKER_ARGS=$(: | pluginhook docker-args $APP run)
+    DOCKER_ARGS+=$(: | pluginhook docker-args-run $APP)
+    [[ $DOKKU_RM_CONTAINER ]] && DOKKU_RUN_OPTS="--rm"
+    has_tty && DOKKU_RUN_OPTS+=" -i -t"
+
+    docker run $DOKKU_RUN_OPTS $DOCKER_ARGS $IMAGE /exec "$@"
     ;;
 
   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
+    verify_app_name "$2"
     APP="$2"; 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

plugins/00_dokku-standard/install

@@ -20,7 +20,7 @@ start on (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/apps/pre-delete

@@ -3,5 +3,5 @@ set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
 
 APP="$1"; IMAGE="dokku/$APP"; CACHE_DIR="$DOKKU_ROOT/$APP/cache"
 if [[ -d $CACHE_DIR ]]; then
-  docker run --rm -v "$CACHE_DIR:/cache" "$IMAGE" find /cache -depth -mindepth 1 -maxdepth 1 -exec rm -Rf {} \;
+  docker run --rm -v "$CACHE_DIR:/cache" "$IMAGE" find /cache -depth -mindepth 1 -maxdepth 1 -exec rm -Rf {} \; || true
 fi

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=""
 
@@ -17,7 +18,7 @@ if [[ -f "$DOKKU_ROOT/$APP/ENV" ]]; then
 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")

plugins/checks/check-deploy

@@ -18,6 +18,7 @@ set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
 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/ENV" ]] && source $DOKKU_ROOT/ENV
 [[ -f "$DOKKU_ROOT/$APP/ENV" ]] && source $DOKKU_ROOT/$APP/ENV
 # echo "DOKKU_CHECKS_WAIT is $DOKKU_CHECKS_WAIT"
 FILENAME="$DOKKU_ROOT/$APP/CHECKS"

plugins/common/functions

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+function has_tty() {
+  if [[ "$(/usr/bin/tty || true)" == "not a tty" ]]; then
+    return 1
+  else
+    return 0
+  fi
+}
+
+function dokku_log_info1() {
+  echo "-----> $@"
+}
+
+function dokku_log_info2() {
+  echo "=====> $@"
+}
+
+function dokku_log_info1_quiet() {
+  if [[ -z "$DOKKU_QUIET_OUTPUT" ]];then
+    echo "-----> $@"
+  else
+    return 0
+  fi
+}
+
+function dokku_log_info2_quiet() {
+  if [[ -z "$DOKKU_QUIET_OUTPUT" ]];then
+    echo "=====> $@"
+  else
+    return 0
+  fi
+}
+
+function dokku_log_verbose() {
+  echo "       $@"
+}
+
+function dokku_log_warn() {
+  echo " !    $@"
+}
+
+function dokku_log_fail() {
+  echo "$@" 1>&2
+  exit 1
+}
+
+function verify_app_name() {
+  local APP="$1"
+  [[ ! -d "$DOKKU_ROOT/$APP" ]] && dokku_log_fail "App $APP does not exist"
+  return 0
+}
+
+function parse_args() {
+  for arg in "$@"; do
+    case "$arg" in
+      --quiet|-q)
+        export DOKKU_QUIET_OUTPUT=1
+        ;;
+      --trace|-t)
+        export DOKKU_TRACE=1
+        ;;
+      --rm-container|-rm)
+        export DOKKU_RM_CONTAINER=1
+        ;;
+      --force|-f)
+        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,13 @@ 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
+    dokku ps:restart $APP
   fi
   rm -f $ENV_FILE_TEMP
 }
@@ -62,7 +50,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 +65,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 +92,7 @@ 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
@@ -143,7 +131,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 and restarting $APP"
       config_styled_hash "$ENV_ADD" "       "
 
       config_write "$ENV_TEMP"
@@ -152,7 +140,7 @@ ${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
@@ -166,7 +154,7 @@ ${var}"
     VARS="${*:3}"
 
     for var in $VARS; do
-      echo "-----> Unsetting $var and restarting $APP"
+      dokku_log_info1 "Unsetting $var and restarting $APP"
       ENV_TEMP=$(echo -e "${ENV_TEMP}" | sed "/^export $var=/ d")
 
       config_write "$ENV_TEMP"

plugins/domains/commands

@@ -1,20 +1,36 @@
 #!/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}"
+
+RE_IPV6="([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|"                    # TEST: 1:2:3:4:5:6:7:8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,7}:|"                         # TEST: 1::                              1:2:3:4:5:6:7::
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|"         # TEST: 1::8             1:2:3:4:5:6::8  1:2:3:4:5:6::8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|"  # TEST: 1::7:8           1:2:3:4:5::7:8  1:2:3:4:5::8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|"  # TEST: 1::6:7:8         1:2:3:4::6:7:8  1:2:3:4::8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|"  # TEST: 1::5:6:7:8       1:2:3::5:6:7:8  1:2:3::8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|"  # TEST: 1::4:5:6:7:8     1:2::4:5:6:7:8  1:2::8
+RE_IPV6="${RE_IPV6}[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|"       # TEST: 1::3:4:5:6:7:8   1::3:4:5:6:7:8  1::8
+RE_IPV6="${RE_IPV6}:((:[0-9a-fA-F]{1,4}){1,7}|:)|"                     # TEST: ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8 ::8       ::
+RE_IPV6="${RE_IPV6}fe08:(:[0-9a-fA-F]{1,4}){2,2}%[0-9a-zA-Z]{1,}|"     # TEST: fe08::7:8%eth0      fe08::7:8%1                                      (link-local IPv6 addresses with zone index)
+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
 
 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
@@ -23,29 +39,31 @@ case "$1" in
       else
         VHOST=$(< "$DOKKU_ROOT/HOSTNAME")
       fi
-      if [[ "$VHOST" =~ ([0-9]{1,3}[\.]){3}[0-9]{1,3} ]];then
-        echo "ip found as hostname. disabling vhost support"
+      if [[ "$VHOST" =~ $RE_IPV4 ]] || [[ "$VHOST" =~ $RE_IPV6 ]];then
+        echo "unsupported vhost config found. disabling vhost support"
         [[ ! $(grep -q NO_VHOST "$DOKKU_ROOT/$APP/ENV") ]] && echo "export NO_VHOST='1'" >> "$DOKKU_ROOT/$APP/ENV"
       else
-        echo "-----> Creating new $VHOST_PATH..."
-        SUBDOMAIN=${APP/%\.${VHOST}/}
-        hostname=$(: | pluginhook nginx-hostname $APP $SUBDOMAIN $VHOST)
-        if [[ ! -n $hostname ]]; then
-          if [[ "$APP" == *.* ]] && [[ "$SUBDOMAIN" == "$APP" ]]; then
-            hostname="${APP/\//-}"
-          else
-            hostname="${APP/\//-}.$VHOST"
+        if [[ -f "$DOKKU_ROOT/VHOST" ]]; then
+          dokku_log_info1 "Creating new $VHOST_PATH..."
+          SUBDOMAIN=${APP/%\.${VHOST}/}
+          hostname=$(: | pluginhook nginx-hostname $APP $SUBDOMAIN $VHOST)
+          if [[ ! -n $hostname ]]; then
+            if [[ "$APP" == *.* ]] && [[ "$SUBDOMAIN" == "$APP" ]]; then
+              hostname="${APP/\//-}"
+            else
+              hostname="${APP/\//-}.$VHOST"
+            fi
           fi
-        fi
 
-        echo "$hostname" > $VHOST_PATH
+          echo "$hostname" > $VHOST_PATH
+        fi
       fi
     fi
     ;;
 
   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
@@ -61,26 +79,28 @@ 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
+    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
@@ -92,7 +112,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

@@ -6,14 +6,13 @@ git_archive_all() {
   TMP_WORK_DIR=$(mktemp -d)
   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 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
 }
 
@@ -26,7 +25,7 @@ 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'"/"
+        dokku git-build $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 +40,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_archive_all $APP $REF | dokku receive $APP | sed -u "s/^/"$'\e[1G'"/"
+    ;;
+
   git-*)
     APP="$(echo $2 | perl -pe 's/(?<!\\)'\''//g' | sed 's/\\'\''/'\''/g')"
     APP_PATH=$DOKKU_ROOT/$APP

plugins/nginx-vhosts/bind-external-ip

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+APP="$1"
+set +e; NO_VHOST=$(dokku config:get $APP NO_VHOST); set -e
+
+RE_IPV4="([0-9]{1,3}[\.]){3}[0-9]{1,3}"
+
+RE_IPV6="([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|"                    # TEST: 1:2:3:4:5:6:7:8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,7}:|"                         # TEST: 1::                              1:2:3:4:5:6:7::
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|"         # TEST: 1::8             1:2:3:4:5:6::8  1:2:3:4:5:6::8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|"  # TEST: 1::7:8           1:2:3:4:5::7:8  1:2:3:4:5::8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|"  # TEST: 1::6:7:8         1:2:3:4::6:7:8  1:2:3:4::8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|"  # TEST: 1::5:6:7:8       1:2:3::5:6:7:8  1:2:3::8
+RE_IPV6="${RE_IPV6}([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|"  # TEST: 1::4:5:6:7:8     1:2::4:5:6:7:8  1:2::8
+RE_IPV6="${RE_IPV6}[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|"       # TEST: 1::3:4:5:6:7:8   1::3:4:5:6:7:8  1::8
+RE_IPV6="${RE_IPV6}:((:[0-9a-fA-F]{1,4}){1,7}|:)|"                     # TEST: ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8 ::8       ::
+RE_IPV6="${RE_IPV6}fe08:(:[0-9a-fA-F]{1,4}){2,2}%[0-9a-zA-Z]{1,}|"     # TEST: fe08::7:8%eth0      fe08::7:8%1                                      (link-local IPv6 addresses with zone index)
+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
+
+[[ -f "$DOKKU_ROOT/VHOST" ]] && GLOBAL_VHOST=$(< "$DOKKU_ROOT/VHOST")
+
+if [[ -n "$NO_VHOST" ]]; then
+  echo true # bind to external ip. VHOST is disabled
+elif [[ "$GLOBAL_VHOST" =~ $RE_IPV4 ]] || [[ "$GLOBAL_VHOST" =~ $RE_IPV6 ]]; then
+  echo true # bind to external ip. GLOBAL_VHOST is somehow an IPv4 or IPv6 address
+elif [[ -z "$GLOBAL_VHOST" ]] && [[ ! -f "$DOKKU_ROOT/$APP/VHOST" ]]; then
+  echo true # bind to external ip. no GLOBAL_VHOST and no app vhost
+elif [[ -f "$DOKKU_ROOT/$APP/VHOST" ]]; then
+  echo false # bind to docker ip. this app has a vhost defined
+else
+  echo false
+fi

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
@@ -15,15 +16,22 @@ restart_nginx () {
 
 case "$1" in
   nginx:build-config)
-    APP="$2"; PORT="$3"
-    [[ -z "$PORT" ]] && PORT=$(< "$DOKKU_ROOT/$APP/PORT")
+    APP="$2"; DOKKU_APP_LISTEN_PORT="$3"; DOKKU_APP_LISTEN_IP="${4}"
     VHOST_PATH="$DOKKU_ROOT/$APP/VHOST"
     WILDCARD_SSL="$DOKKU_ROOT/tls"
     SSL="$DOKKU_ROOT/$APP/tls"
 
+    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
+
+    [[ -f "$DOKKU_ROOT/ENV" ]] && source $DOKKU_ROOT/ENV
     [[ -f "$DOKKU_ROOT/$APP/ENV" ]] && source $DOKKU_ROOT/$APP/ENV
 
-    if [[ ! -n "$NO_VHOST" ]]; then
+    if [[ ! -n "$NO_VHOST" ]] && [[ -f "$DOKKU_ROOT/$APP/VHOST" ]]; then
       NONSSL_VHOSTS=$(cat $VHOST_PATH)
       if [[ -e "$SSL/server.crt" ]] && [[ -e "$SSL/server.key" ]]; then
         SSL_INUSE="$SSL"
@@ -45,13 +53,17 @@ EOF
 
         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')
-
         [[ -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)
+        SSL_HOSTNAME_ALT=$(echo "$SSL_HOSTNAME_ALT" | sed 's|\.|\\.|g' | sed 's/\*/\.\*/g')
+        [[ -z "$(egrep ^"$SSL_HOSTNAME_ALT"$ $VHOST_PATH)" ]] && echo "$SSL_HOSTNAME_ALT" | sed 's/\\./\./g' >> $VHOST_PATH
+
+        SSL_VHOSTS=$(egrep "^${SSL_HOSTNAME}$|^${SSL_HOSTNAME_ALT}$" $VHOST_PATH || exit 0)
+        NONSSL_VHOSTS=$(egrep -v "^${SSL_HOSTNAME}$|^${SSL_HOSTNAME_ALT}$" $VHOST_PATH || exit 0)
 
         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"
         done <<< "$SSL_VHOSTS"
@@ -59,7 +71,7 @@ EOF
 
       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"
+        dokku_log_info1 "Overriding default nginx.conf with detected nginx.conf.template"
         NGINX_CONF=$APP_NGINX_TEMPLATE
       fi
 
@@ -67,25 +79,27 @@ EOF
       # 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' ' ')
 
-      echo "-----> Creating $SCHEME nginx.conf"
-      echo "upstream $APP { server 127.0.0.1:$PORT; }" > $DOKKU_ROOT/$APP/nginx.conf
-      eval "cat <<< \"$(< $NGINX_CONF)\" >> $DOKKU_ROOT/$APP/nginx.conf"
+      if [[ -n "$DOKKU_APP_LISTEN_PORT" ]] && [[ -n "$DOKKU_APP_LISTEN_IP" ]]; then
+        dokku_log_info1 "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"
-      pluginhook nginx-pre-reload $APP $PORT
+        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
+        echo "       Reloading nginx"
+        restart_nginx
+      fi
     else
       if [[ -f "$DOKKU_ROOT/$APP/VHOST" ]]; then
-        echo "-----> NO_VHOST set, 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 "-----> NO_VHOST set, deleting nginx.conf"
+        dokku_log_info1 "VHOST support disabled, deleting nginx.conf"
         rm "$DOKKU_ROOT/$APP/nginx.conf"
 
-        echo "-----> NO_VHOST set, reloading nginx after nginx.conf deletion"
+        dokku_log_info1 "VHOST support disabled, reloading nginx after nginx.conf deletion"
         restart_nginx
       fi
     fi
@@ -93,7 +107,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

@@ -3,10 +3,12 @@ set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
 
 case "$DOKKU_DISTRO" in
   ubuntu)
-    apt-get install -qq -y software-properties-common python-software-properties
+    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;
@@ -44,6 +42,7 @@ events {
 }
 
 http {
+  server_tokens off;
   sendfile on;
   tcp_nopush on;
   tcp_nodelay on;

plugins/nginx-vhosts/post-deploy

@@ -1,14 +1,15 @@
 #!/usr/bin/env bash
 set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+source "$(dirname $0)/../common/functions"
 
-APP="$1"; PORT="$2"
+APP="$1"; PORT="$2"; IP="$3"
 
 set +e; NO_VHOST=$(dokku config:get $APP NO_VHOST); set -e
 
 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
 
-dokku nginx:build-config $APP $PORT
+dokku nginx:build-config $APP $PORT $IP

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,111 @@
+#!/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";
+
+  if [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
+    dokku_log_info1 "Releasing $APP ..."
+    dokku release $APP
+    dokku_log_info1 "Release complete!"
+    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"
+
+    dokku git-build $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

tests.mk

@@ -17,7 +17,7 @@ ifdef ENABLE_DOKKU_TRACE
 	echo "export DOKKU_TRACE=1" >> /home/dokku/dokkurc
 endif
 	@echo "Setting dokku.me in /etc/hosts"
-	sudo /bin/bash -c "[[ `ping -c1 dokku.me > /dev/null 2>&1; echo $$?` -eq 0 ]] || echo \"127.0.0.1  dokku.me *.dokku.me\" >> /etc/hosts"
+	sudo /bin/bash -c "[[ `ping -c1 dokku.me > /dev/null 2>&1; echo $$?` -eq 0 ]] || echo \"127.0.0.1  dokku.me *.dokku.me www.test.app.dokku.me\" >> /etc/hosts"
 
 	@echo "-----> Generating keypair..."
 	mkdir -p /root/.ssh
@@ -39,7 +39,7 @@ endif
 	@echo "-----> Intitial SSH connection to populate known_hosts..."
 	ssh -o StrictHostKeyChecking=no dokku@dokku.me help > /dev/null
 
-ifeq ($(shell grep dokku.me /home/dokku/VHOST),)
+ifeq ($(shell grep dokku.me /home/dokku/VHOST 2>/dev/null),)
 	@echo "-----> Setting default VHOST to dokku.me..."
 	echo "dokku.me" > /home/dokku/VHOST
 endif
@@ -56,12 +56,17 @@ 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" | 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
@@ -75,7 +80,7 @@ deploy-test-go:
 	cd tests && ./test_deploy ./apps/go dokku.me
 
 deploy-test-java:
-	@echo deploying  app...
+	@echo deploying java app...
 	cd tests && ./test_deploy ./apps/java dokku.me
 
 deploy-test-multi:
@@ -83,9 +88,13 @@ deploy-test-multi:
 	cd tests && ./test_deploy ./apps/multi dokku.me
 
 deploy-test-nodejs-express:
-	@echo deploying  app...
+	@echo deploying nodejs-express app...
 	cd tests && ./test_deploy ./apps/nodejs-express dokku.me
 
+deploy-test-nodejs-express-noprocfile:
+	@echo deploying nodejs-express app with no Procfile...
+	cd tests && ./test_deploy ./apps/nodejs-express-noprocfile dokku.me
+
 deploy-test-php:
 	@echo deploying php app...
 	cd tests && ./test_deploy ./apps/php dokku.me
@@ -106,14 +115,13 @@ deploy-tests:
 	@echo running deploy tests...
 	# @$(QUIET) bats tests/deploy
 	@$(QUIET) $(MAKE) deploy-test-config
+	@$(QUIET) $(MAKE) deploy-test-clojure
 	@$(QUIET) $(MAKE) deploy-test-gitsubmodules
 	@$(QUIET) $(MAKE) deploy-test-go
 	@$(QUIET) $(MAKE) deploy-test-java
-	# broken with new buildstep.
-	# ref: https://github.com/progrium/dokku/issues/832
-	# ref: https://github.com/heroku/heroku-buildpack-ruby/pull/319
-	# @$(QUIET) $(MAKE) deploy-test-multi
+	@$(QUIET) $(MAKE) deploy-test-multi
 	@$(QUIET) $(MAKE) deploy-test-nodejs-express
+	@$(QUIET) $(MAKE) deploy-test-nodejs-express-noprocfile
 	@$(QUIET) $(MAKE) deploy-test-php
 	@$(QUIET) $(MAKE) deploy-test-python-flask
 	@$(QUIET) $(MAKE) deploy-test-scala

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/multi/Gemfile

@@ -2,5 +2,5 @@ source "https://rubygems.org"
 
 ruby '1.9.3'
 
-gem 'compass'
+gem 'compass', ">= 1.0.1"
 gem 'sass-globbing'

tests/apps/multi/Gemfile.lock

@@ -1,19 +1,31 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    chunky_png (1.3.0)
-    compass (0.12.3)
+    chunky_png (1.3.3)
+    compass (1.0.1)
       chunky_png (~> 1.2)
-      fssm (>= 0.2.7)
-      sass (= 3.2.14)
-    fssm (0.2.10)
-    sass (3.2.14)
-    sass-globbing (1.1.0)
+      compass-core (~> 1.0.1)
+      compass-import-once (~> 1.0.5)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+      sass (>= 3.3.13, < 3.5)
+    compass-core (1.0.1)
+      multi_json (~> 1.0)
+      sass (>= 3.3.0, < 3.5)
+    compass-import-once (1.0.5)
+      sass (>= 3.2, < 3.5)
+    ffi (1.9.6)
+    multi_json (1.10.1)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    sass (3.4.9)
+    sass-globbing (1.1.1)
       sass (>= 3.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  compass
+  compass (>= 1.0.1)
   sass-globbing

tests/apps/nodejs-express-noprocfile/CHECKS

@@ -0,0 +1 @@
+/ nodejs/express

tests/apps/nodejs-express-noprocfile/check_deploy

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

tests/apps/nodejs-express-noprocfile/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "node-example",
+  "version": "0.0.1",
+  "dependencies": {
+    "express": "2.5.x"
+  },
+  "engines": {
+    "node": "0.8.x",
+    "npm": "1.1.x"
+  },
+  "scripts": {
+    "start": "node web.js"
+  }
+}

tests/apps/nodejs-express-noprocfile/web.js

@@ -0,0 +1,12 @@
+var express = require('express');
+
+var app = express.createServer(express.logger());
+
+app.get('/', function(request, response) {
+  response.send('nodejs/express');
+});
+
+var port = process.env.PORT || 5000;
+app.listen(port, function() {
+  console.log("Listening on " + port);
+});

tests/apps/php/composer.json

@@ -1,9 +1,13 @@
 {
+  "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/test_deploy

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-set -eo pipefail
+set -xeo pipefail
 
 SELF=$(which $0); APP="$1"; TARGET="$2"; FORWARDED_PORT="$3"
 REMOTE="dokku@$TARGET"

tests/unit/00_dokku-standard.bats

@@ -11,6 +11,22 @@ teardown() {
   destroy_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 "urls (non-ssl)" {
   run bash -c "dokku urls $TEST_APP | grep dokku.me"
   echo "output: "$output

tests/unit/client.bats

@@ -0,0 +1,178 @@
+#!/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)" {
+  destroy_app
+  run ./contrib/dokku_client.sh apps:create $TEST_APP
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "dokku client (apps:destroy)" {
+  run ./contrib/dokku_client.sh apps:destroy $TEST_APP force
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  create_app # prevent teardown() failure
+}
+
+@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
+}
+
+@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 apps:destroy force"
+  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,25 @@ 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 "config (global)" {
+  deploy_app
+  run bash -c "dokku run $TEST_APP env | egrep '^global_test=true'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}

tests/unit/domains.bats

@@ -3,7 +3,7 @@
 load test_helper
 
 setup() {
-  deploy_app
+  create_app
 }
 
 teardown() {

tests/unit/nginx-vhosts.bats

@@ -3,18 +3,75 @@
 load test_helper
 
 setup() {
+  [[ -f "$DOKKU_ROOT/VHOST" ]] && cp -f "$DOKKU_ROOT/VHOST" "$DOKKU_ROOT/VHOST.bak"
+  [[ -f "$DOKKU_ROOT/HOSTNAME" ]] && cp -f "$DOKKU_ROOT/HOSTNAME" "$DOKKU_ROOT/HOSTNAME.bak"
   create_app
-  setup_test_tls
-  deploy_app
 }
 
 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"
+}
+
+@test "nginx (no server tokens)" {
+  deploy_app
+  run /bin/bash -c "curl -s -D - $(dokku url $TEST_APP) -o /dev/null | egrep '^Server' | egrep '[0-9]+'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_failure
 }
 
 @test "nginx:build-config (with SSL CN mismatch)" {
-  run /bin/bash -c "dokku domains $TEST_APP | grep node-js-app.dokku.me"
+  setup_test_tls
+  deploy_app
+  run /bin/bash -c "dokku domains $TEST_APP | egrep ^node-js-app\.dokku\.me$"
   echo "output: "$output
   echo "status: "$status
   assert_output "node-js-app.dokku.me"
+  run bash -c "response=\"$(curl -LkSs node-js-app.dokku.me)\"; echo \$response; test \"\$response\" == \"nodejs/express\""
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "nginx:build-config (with SSL and Multiple SANs)" {
+  setup_test_tls_with_sans
+  deploy_app
+  run /bin/bash -c "dokku domains $TEST_APP | egrep ^test\.dokku\.me$"
+  echo "output: "$output
+  echo "status: "$status
+  assert_output "test.dokku.me"
+  run /bin/bash -c "dokku domains $TEST_APP | grep ^www\.test\.dokku\.me$"
+  echo "output: "$output
+  echo "status: "$status
+  assert_output "www.test.dokku.me"
+  run bash -c "response=\"$(curl -LkSs test.dokku.me)\"; echo \$response; test \"\$response\" == \"nodejs/express\""
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "response=\"$(curl -LkSs www.test.dokku.me)\"; echo \$response; test \"\$response\" == \"nodejs/express\""
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "response=\"$(curl -LkSs www.test.app.dokku.me)\"; echo \$response; test \"\$response\" == \"nodejs/express\""
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@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
+  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
 }

tests/unit/ports.bats

@@ -0,0 +1,110 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  [[ -f "$DOKKU_ROOT/VHOST" ]] && cp -f "$DOKKU_ROOT/VHOST" "$DOKKU_ROOT/VHOST.bak"
+  [[ -f "$DOKKU_ROOT/HOSTNAME" ]] && cp -f "$DOKKU_ROOT/HOSTNAME" "$DOKKU_ROOT/HOSTNAME.bak"
+}
+
+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"
+}
+
+@test "port exposure (with global VHOST)" {
+  echo "dokku.me" > "$DOKKU_ROOT/VHOST"
+  deploy_app
+  CONTAINER_ID=$(docker ps --no-trunc| grep dokku/$TEST_APP | grep "start web" | awk '{ print $1 }')
+  run bash -c "docker port $CONTAINER_ID | sed 's/[0-9.]*://' | egrep '[0-9]*'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_failure
+}
+
+@test "port exposure (without global VHOST and real HOSTNAME)" {
+  rm "$DOKKU_ROOT/VHOST"
+  echo "dokku.me" > "$DOKKU_ROOT/HOSTNAME"
+  deploy_app
+  CONTAINER_ID=$(docker ps --no-trunc| grep dokku/$TEST_APP | grep "start web" | awk '{ print $1 }')
+  run bash -c "docker port $CONTAINER_ID | sed 's/[0-9.]*://' | egrep '[0-9]*'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "port exposure (with NO_VHOST set)" {
+  deploy_app
+  dokku config:set $TEST_APP NO_VHOST=1
+  CONTAINER_ID=$(docker ps --no-trunc| grep dokku/$TEST_APP | grep "start web" | awk '{ print $1 }')
+  run bash -c "docker port $CONTAINER_ID | sed 's/[0-9.]*://' | egrep '[0-9]*'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "port exposure (without global VHOST and IPv4 address as HOSTNAME)" {
+  rm "$DOKKU_ROOT/VHOST"
+  echo "127.0.0.1" > "$DOKKU_ROOT/HOSTNAME"
+  deploy_app
+  CONTAINER_ID=$(docker ps --no-trunc| grep dokku/$TEST_APP | grep "start web" | awk '{ print $1 }')
+  run bash -c "docker port $CONTAINER_ID | sed 's/[0-9.]*://' | egrep '[0-9]*'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "port exposure (without global VHOST and IPv6 address as HOSTNAME)" {
+  rm "$DOKKU_ROOT/VHOST"
+  echo "fda5:c7db:a520:bb6d::aabb:ccdd:eeff" > "$DOKKU_ROOT/HOSTNAME"
+  deploy_app
+  CONTAINER_ID=$(docker ps --no-trunc| grep dokku/$TEST_APP | grep "start web" | awk '{ print $1 }')
+  run bash -c "docker port $CONTAINER_ID | sed 's/[0-9.]*://' | egrep '[0-9]*'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "port exposure (pre-deploy domains:add)" {
+  create_app
+  run dokku domains:add $TEST_APP www.test.app.dokku.me
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+
+  deploy_app
+  sleep 5 # wait for nginx to reload
+
+  CONTAINER_ID=$(docker ps --no-trunc| grep dokku/$TEST_APP | grep "start web" | awk '{ print $1 }')
+  run bash -c "docker port $CONTAINER_ID | sed 's/[0-9.]*://' | egrep '[0-9]*'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_failure
+
+  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
+}
+
+@test "port exposure (no global VHOST and domains:add post deploy)" {
+  rm "$DOKKU_ROOT/VHOST"
+  deploy_app
+
+  run dokku domains:add $TEST_APP www.test.app.dokku.me
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+
+  CONTAINER_ID=$(docker ps --no-trunc| grep dokku/$TEST_APP | grep "start web" | awk '{ print $1 }')
+  run bash -c "docker port $CONTAINER_ID | sed 's/[0-9.]*://' | egrep '[0-9]*'"
+  echo "output: "$output
+  echo "status: "$status
+  assert_failure
+
+  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
+}

tests/unit/ps.bats

@@ -0,0 +1,70 @@
+#!/usr/bin/env bats
+
+load test_helper
+
+setup() {
+  deploy_app
+}
+
+teardown() {
+  destroy_app
+}
+
+@test "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."
+  run bash -c "dokku ps $TEST_APP | grep -q \"node web.js\""
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+}
+
+@test "ps:start" {
+  run bash -c "dokku ps:stop $TEST_APP"
+  echo "output: "$output
+  echo "status: "$status
+  assert_success
+  run bash -c "dokku 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 "ps:stop" {
+  run bash -c "dokku 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 "ps:restart" {
+  run bash -c "dokku 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
+}
+
+@test "ps:rebuild" {
+  run bash -c "dokku ps:rebuild $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/test_helper.bash

@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 
 # constants
+DOKKU_ROOT=${DOKKU_ROOT:=~dokku}
 TEST_APP=my-cool-guy-test-app
 
 # test functions
@@ -78,6 +79,10 @@ assert() {
   fi
 }
 
+assert_exit_status() {
+  assert_equal "$status" "$1"
+}
+
 # dokku functions
 create_app() {
   dokku apps:create $TEST_APP
@@ -89,7 +94,7 @@ destroy_app() {
 
 deploy_app() {
   TMP=$(mktemp -d -t "$TARGET.XXXXX")
-  rmdir $TMP && cp -r ./tests/apps/config $TMP
+  rmdir $TMP && cp -r ./tests/apps/nodejs-express $TMP
   cd $TMP
   git init
   git config user.email "robot@example.com"
@@ -102,9 +107,29 @@ deploy_app() {
   git push target master || destroy_app
 }
 
+setup_client_repo() {
+  TMP=$(mktemp -d -t "$TARGET.XXXXX")
+  rmdir $TMP && cp -r ./tests/apps/nodejs-express $TMP
+  cd $TMP
+  git init
+  git config user.email "robot@example.com"
+  git config user.name "Test Robot"
+
+  [[ -f gitignore ]] && mv gitignore .gitignore
+  git add .
+  git commit -m 'initial commit'
+}
+
 setup_test_tls() {
   TLS="/home/dokku/$TEST_APP/tls"
   mkdir -p $TLS
   tar xf $BATS_TEST_DIRNAME/server_ssl.tar -C $TLS
   sudo chown -R dokku:dokku $TLS
 }
+
+setup_test_tls_with_sans() {
+  TLS="/home/dokku/$TEST_APP/tls"
+  mkdir -p $TLS
+  tar xf $BATS_TEST_DIRNAME/server_ssl_sans.tar -C $TLS
+  sudo chown -R dokku:dokku $TLS
+}

wercker.yml

@@ -1,39 +0,0 @@
-box: wercker-labs/docker
-no-response-timeout: 20
-build:
-  steps:
-    - script:
-        name: install os requirements
-        code: |-
-          sudo apt-get update
-          sudo apt-get install -y make software-properties-common git wget man-db
-    - script:
-        name: ci dependencies
-        code: make -e ci-dependencies
-    - script:
-        name: install dokku
-        code: sudo -E CI=true DOCKER_VERSION=1.4.0 make -e install
-    - script:
-        name: setup deploy tests
-        code: sudo -E make -e setup-deploy-tests
-    - script:
-        name: lint
-        code: sudo -E make -e lint
-    - script:
-        name: unit tests
-        code: sudo -E make -e unit-tests
-    - script:
-        name: deploy tests (against buildstep release)
-        code: sudo -E make -e deploy-tests
-    - script:
-        name: deploy tests (against buildstep master)
-        code: |-
-          sudo docker rmi -f progrium/buildstep
-          sudo -E BUILD_STACK=true make -e stack
-          sudo -E make -e deploy-tests
-  after-steps:
-    - wouter/irc-notify:
-       server: irc.freenode.net
-       port: 6667
-       nickname: dokku-wercker
-       channel: dokku