Merge pull request #521 from ElliotChong/patch-1

Adding note re: pushing to master for deployments.

.gitignore

@@ -1 +1,3 @@
 .vagrant
+.DS_Store
+stack.tgz

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "buildstep"]
-	path = buildstep
-	url = https://github.com/progrium/buildstep.git

.s3cfg

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

.travis.yml

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

AUTHORS

@@ -1,6 +1,19 @@
-# This file lists all individuals having contributed content to the repository.
 # If you're submitting a patch, please add your name here in alphabetical order as part of the patch.
+# This file lists all individuals having contributed content to the repository.
 #
+Alexander <iam.asm89@gmail.com>
+Alexander Beletsky <alexander.beletsky@gmail.com>
+Alexis Gavoty <kload@kload.fr>
+Felipe Coury <felipe.coury@gmail.com>
 Jeff Lindsay <progrium@gmail.com>
-Richard North <rich.north@gmail.com>
+Jose Diaz-Gonzalez <dokku@josediazgonzalez.com>
 Leo Unbekandt <leo@unbekandt.eu>
+Ludovic Perrine <jazzzz@gmail.com>
+Luigi Maselli <grigio.org@gmail.com>
+Martin Weiss <kornnflake@gmail.com>
+Paul Lietar <paul@lietar.net>
+Rajiv Makhijani <rajiv@blue-tech.org>
+rhy-jot <rhy-jot@myeml.net>
+Richard North <rich.north@gmail.com>
+Sebastian Götte <github@jaseg.net>
+Silas Baronda <silas.baronda@gmail.com>

HISTORY.md

@@ -1,9 +1,30 @@
 # History
 
+## 0.3.0 (in progress)
+
+* Added git submodules support
+
+## 0.2.0 (2013-11-24)
+
+* Added DOKKU_TRACE variable for verbose trace information
+* Added an installer (for pre-built images)
+* Application config (environment variable management)
+* Backup/import plugin
+* Basic hooks/plugin system
+* Cache dir is preserved across builds
+* Command to delete an application
+* Exposed commands over SSH using sshcommand
+* Git handling is moved to a plugin
+* Integration test coverage
+* Pulled nginx vhosts out into plugin
+* Run command
+* Separated dokku and buildstep more cleanly
+* Uses latest version of Docker again
+
 ## 0.1.0 (2013-06-15)
 
  * First release
    * Bootstrap script for Ubuntu system
    * Basic push / deploy with git
    * Hostname support with Nginx
-   * Support for Java, Ruby, Node.js buildpacks
+   * Support for Java, Ruby, Node.js buildpacks

LICENSE

@@ -1,7 +1,7 @@
-Copyright (C) 2013 Jeff Lindsay
+Copyright (C) 2014 Jeff Lindsay
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Makefile

@@ -1,29 +1,72 @@
-GITRECEIVE_URL = https://raw.github.com/progrium/gitreceive/master/gitreceive
-SSHCOMMAND_URL = https://raw.github.com/progrium/sshcommand/master/sshcommand
+DOKKU_VERSION = master
 
-all: install
+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-03-08/2014-03-08_429d4a9deb.tar.gz
+DOKKU_ROOT ?= /home/dokku
 
-install: submodule gitreceive sshcommand
+.PHONY: all install copyfiles version plugins dependencies sshcommand pluginhook docker aufs stack count
+
+all:
+	# Type "make install" to install.
+
+install: dependencies stack copyfiles plugins version
+
+copyfiles: addman
 	cp dokku /usr/local/bin/dokku
-	cp receiver /home/git/receiver
-	cp deploystep /home/git/deploystep
-	cp buildstep/buildstep /home/git/buildstep
-	cp nginx-app-conf /home/git/nginx-app-conf
-	cp nginx-reloader.conf /etc/init/nginx-reloader.conf
-	echo "include /home/git/*/nginx.conf;" > /etc/nginx/conf.d/dokku.conf
+	mkdir -p /var/lib/dokku/plugins
+	cp -r plugins/* /var/lib/dokku/plugins
 
-submodule:
-	git submodule init
-	git submodule update
+addman:
+	mkdir -p /usr/local/share/man/man1
+	cp dokku.1 /usr/local/share/man/man1/dokku.1
+	mandb
 
-gitreceive:
-	wget -qO /usr/local/bin/gitreceive ${GITRECEIVE_URL}
-	chmod +x /usr/local/bin/gitreceive
-	gitreceive init
+version:
+	git describe --tags > ${DOKKU_ROOT}/VERSION  2> /dev/null || echo '~${DOKKU_VERSION} ($(shell date -uIminutes))' > ${DOKKU_ROOT}/VERSION
+
+plugins: pluginhook docker
+	dokku plugins-install
+
+dependencies: sshcommand pluginhook docker stack
 
 sshcommand:
 	wget -qO /usr/local/bin/sshcommand ${SSHCOMMAND_URL}
 	chmod +x /usr/local/bin/sshcommand
+	sshcommand create dokku /usr/local/bin/dokku
+
+pluginhook:
+	wget -qO /tmp/pluginhook_0.1.0_amd64.deb ${PLUGINHOOK_URL}
+	dpkg -i /tmp/pluginhook_0.1.0_amd64.deb
+
+docker: aufs
+	egrep -i "^docker" /etc/group || groupadd docker
+	usermod -aG docker dokku
+	curl https://get.docker.io/gpg | apt-key add -
+	echo deb http://get.docker.io/ubuntu docker main > /etc/apt/sources.list.d/docker.list
+	apt-get update
+ifdef DOCKER_VERSION
+	apt-get install -y lxc-docker-${DOCKER_VERSION}
+else
+	apt-get install -y lxc-docker
+endif
+	sleep 2 # give docker a moment i guess
+
+aufs:
+	lsmod | grep aufs || modprobe aufs || apt-get install -y linux-image-extra-`uname -r`
+
+stack:
+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 -L ${PREBUILT_STACK_URL} | gunzip -cd | docker import - progrium/buildstep
+endif
 
 count:
-	cat receiver deploystep bootstrap.sh nginx-app-conf nginx-reloader.conf | wc -l
+	@echo "Core lines:"
+	@cat dokku bootstrap.sh | wc -l
+	@echo "Plugin lines:"
+	@find plugins -type f | xargs cat | wc -l
+	@echo "Test lines:"
+	@find tests -type f | xargs cat | wc -l

README.md

@@ -2,102 +2,180 @@
 
 Docker powered mini-Heroku. The smallest PaaS implementation you've ever seen.
 
+[![Build Status](https://travis-ci.org/progrium/dokku.png?branch=master)](https://travis-ci.org/progrium/dokku)
+
 ## Requirements
 
-Assumes Ubuntu 13 right now. Ideally have a domain ready to point to your host. It's designed for and is probably
+Assumes Ubuntu 13 or 12.04 x64 right now. Ideally have a domain ready to point to your host. It's designed for and is probably
 best to use a fresh VM. The bootstrapper will install everything it needs.
 
+**Note: There are known issues with docker and Ubuntu 13.10 ([1](https://github.com/dotcloud/docker/issues/1300), [2](https://github.com/dotcloud/docker/issues/1906)) - use of 12.04 is recommended until these issues are resolved.**
+
 ## Installing
 
-    $ wget -qO- j.mp/dokku-bootstrap | bash
+### Stable
+
+    $ wget -qO- https://raw.github.com/progrium/dokku/v0.2.2/bootstrap.sh | sudo DOKKU_TAG=v0.2.2 bash
+
+**Note**: Users on 12.04 will need to run `apt-get install -y python-software-properties` before bootstrapping stable.
+
+### Development
+
+    $ wget -qO- https://raw.github.com/progrium/dokku/master/bootstrap.sh | sudo bash
 
 This may take around 5 minutes. Certainly better than the several hours it takes to bootstrap Cloud Foundry.
 
+You may also wish to take a look at the [advanced installation](http://progrium.viewdocs.io/dokku/advanced-installation) document for additional installation options.
+
 ## Configuring
 
-Set up a domain and a wildcard domain pointing to that host. Make sure `/home/git/DOMAIN` is set to this domain. 
-By default it's set to whatever the hostname the host has.
+Set up a domain and a wildcard domain pointing to that host. Make sure `/home/dokku/VHOST` is set to this domain. By default it's set to whatever hostname the host has. This file is only created if the hostname can be resolved by dig (`dig +short $(hostname -f)`). Otherwise you have to create the file manually and set it to your preferred domain. If this file still is not present when you push your app, dokku will publish the app with a port number (i.e. `http://example.com:49154` - note the missing subdomain).
 
-You'll have to add a public key associated with a username as it says at the end of the bootstrapper. You'll do something
-like this from your local machine:
+You'll have to add a public key associated with a username by doing something like this from your local machine:
 
-    $ cat ~/.ssh/id_rsa.pub | ssh root@progriumapp.com "gitreceive upload-key progrium"
+    $ cat ~/.ssh/id_rsa.pub | ssh progriumapp.com "sudo sshcommand acl-add dokku progrium"
 
 That's it!
 
 ## Deploy an App
 
-Right now Buildstep supports the Node.js, Ruby, and Java buildpacks. It's not hard to add more, [go add more](https://github.com/progrium/buildstep#adding-buildpacks)! Let's deploy
-the Heroku Node.js sample app. All you have to do is add a remote to name the app. It's created on-the-fly.
+Now you can deploy apps on your Dokku. Let's deploy the [Heroku Node.js sample app](https://github.com/heroku/node-js-sample). All you have to do is add a remote to name the app. It's created on-the-fly.
 
     $ cd node-js-sample
-    $ git remote add progrium git@progriumapp.com:node-js-app
+    $ git remote add progrium dokku@progriumapp.com:node-js-app
     $ git push progrium master
     Counting objects: 296, done.
     Delta compression using up to 4 threads.
     Compressing objects: 100% (254/254), done.
     Writing objects: 100% (296/296), 193.59 KiB, done.
     Total 296 (delta 25), reused 276 (delta 13)
-    remote: -----> Building node-js-app ...
-    remote:        Node.js app detected
-    remote: -----> Resolving engine versions
-    
+    -----> Building node-js-app ...
+           Node.js app detected
+    -----> Resolving engine versions
+
     ... blah blah blah ...
-    
-    remote: -----> Application deployed:
-    remote:        http://node-js-app.progriumapp.com
+
+    -----> Application deployed:
+           http://node-js-app.progriumapp.com
 
 You're done!
 
-## Advanced installation (for development)
+Dokku only supports deploying from its master branch, so if you'd like to deploy a different local branch use: ```git push progrium <local branch>:master``` 
 
-The bootstrap script allows source URLs to be overridden to include customizations from your own 
-repositories. The GITRECEIVE_URL and DOKKU_REPO environment variables
-may be set to override the defaults (see the bootstrap.sh script for how these apply). Example:
+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.
+
+## Remote commands
+
+Dokku commands can be run over ssh. Anywhere you would run `dokku <command>`, just run `ssh -t dokku@progriumapp.com <command>`
+The `-t` is used to request a pty. It is highly recommended to do so.
+To avoid the need to type the `-t` option each time, simply create/modify a section in the `.ssh/config` on the client side, as follows :
+
+    Host progriumapp.com
+    RequestTTY yes
+
+## Run a command in the app environment
+
+It's possible to run commands in the environment of the deployed application:
+
+    $ dokku run node-js-app ls -alh
+    $ dokku run <app> <cmd>
+
+## Plugins
+
+Dokku itself is built out of plugins. Checkout the wiki for information about
+creating your own and a list of existing plugins:
+
+https://github.com/progrium/dokku/wiki/Plugins
+
+## Removing a deployed app
+
+SSH onto the server, then execute:
+
+    $ dokku delete myapp
+
+## Environment variable management
+
+Typically an application will require some environment variables to run properly. Environment variables may contain private data, such as passwords or API keys, so it is not recommend to store them in your application's repository.
+
+The `config` plugin provides the following commands to manage your variables:
+```
+config <app> - display the config vars for an app  
+config:get <app> KEY - display a config value for an app  
+config:set <app> KEY1=VALUE1 [KEY2=VALUE2 ...] - set one or more config vars
+config:unset <app> KEY1 [KEY2 ...] - unset one or more config vars
+```
+
+## TLS/SPDY support
+
+Dokku provides easy TLS/SPDY support out of the box. This can be done app-by-app or for all subdomains at once. Note that whenever TLS support is enabled SPDY is also enabled.
+
+### 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.
+
+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).
+
+### All Subdomains
+
+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 #):
+
+    ssl_certificate /home/dokku/tls/server.crt;
+    ssl_certificate_key /home/dokku/tls/server.key;
+
+The nginx configuration will need to be reloaded in order for the updated TLS configuration to be applied. This can be done either via the init system or by re-deploying the application. Once TLS is enabled, the application will be accessible by `https://` (redirection from `http://` is applied as well).
+
+**Note**: TLS will not be enabled unless the application's VHOST matches the certificate's name. (i.e. if you have a cert for *.example.com TLS won't be enabled for something.example.org or example.net)
+
+### HSTS Header
+
+The [HSTS header](https://en.wikipedia.org/wiki/HTTP_Strict_Transport_Security) is an HTTP header that can inform browsers that all requests to a given site should be made via HTTPS. dokku does not, by default, enable this header. It is thus left up to you, the user, to enable it for your site.
+
+Beware that if you enable the header and a subsequent deploy of your application results in an HTTP deploy (for whatever reason), the way the header works means that a browser will not attempt to request the HTTP version of your site if the HTTPS version fails.
 
-    $ wget j.mp/dokku-bootstrap
-    $ chmod +x bootstrap.sh
-    $ DOKKU_REPO=https://github.com/yourusername/dokku.git bootstrap.sh
-    
 ## Upgrading
 
 Dokku is in active development. You can update the deployment step and the build step separately.
+
+**Note**: If you are upgrading from a revision prior to [27d4bc8c3c](https://github.com/progrium/dokku/commit/27d4bc8c3c19fe580ef3e65f2f85b85101cd83e4), follow the instructions in [this wiki entry](https://github.com/progrium/dokku/wiki/Migrating-to-Dokku-0.2.0).
+
 To update the deploy step (this is updated less frequently):
 
     $ cd ~/dokku
     $ git pull origin master
-    $ make install
-    
-More frequently, the build step is updated. This is where the app "stack" lives and where buildpacks
-are supported. You can update this by running:
-
-    $ cd ~/dokku/buildstep
-    $ git pull origin master
-    $ make build
+    $ sudo make install
 
 Nothing needs to be restarted. Changes will take effect on the next push / deployment.
 
+To update the build step:
+
+    $ git clone https://github.com/progrium/buildstep.git
+    $ cd buildstep
+    $ git pull origin master
+    $ sudo make build
+
+This will build a fresh Ubuntu Quantal image, install a number of packages, and
+eventually replace the Docker image for buildstep.
+
+## 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)
+
 ## Components
 
  * [Docker](https://github.com/dotcloud/docker) - Container runtime and manager
  * [Buildstep](https://github.com/progrium/buildstep) - Buildpack builder
- * [gitreceive](https://github.com/progrium/gitreceive) - Git push interface
+ * [pluginhook](https://github.com/progrium/pluginhook) - Shell based plugins and hooks
  * [sshcommand](https://github.com/progrium/sshcommand) - Fixed commands over SSH
 
-## Ideas for Improvements
-
- * Custom domain support for apps
- * HTTPS support on default domain
- * Support more buildpacks (see Buildstep)
- * Use dokku as the system user instead of git
- * Heroku-ish commands to be run via SSH (like [Dokuen](https://github.com/peterkeen/dokuen#available-app-sub-commands))
-
 Looking to keep codebase as simple and hackable as possible, so try to keep your line count down.
 
 ## Things this project won't do
 
- * **Multi-host.** Not a huge leap, but this isn't the project for it. Maybe as Super Dokku.
- * **Multitenancy.** It's ready for it, but again, probably for Super Dokku.
+ * **Multi-host.** Not a huge leap, but this isn't the project for it. Have a look at [Flynn](https://flynn.io/).
+ * **Multitenancy.** It's ready for it, but again, have a look at [Flynn](https://flynn.io/).
  * **Client app.** Given the constraints, running commands remotely via SSH is fine.
 
 ## License

Vagrantfile

@@ -2,19 +2,32 @@
 # vi: set ft=ruby :
 
 BOX_NAME = ENV["BOX_NAME"] || "raring"
-BOX_URI = ENV["BOX_URI"] || "http://cloud-images.ubuntu.com/vagrant/raring/current/raring-server-cloudimg-amd64-vagrant-disk1.box"
+BOX_URI = ENV["BOX_URI"] || "https://cloud-images.ubuntu.com/vagrant/raring/current/raring-server-cloudimg-amd64-vagrant-disk1.box"
+BOX_MEMORY = ENV["BOX_MEMORY"] || "512"
 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
+
+make_cmd = "make install"
+if PREBUILT_STACK_URL
+  make_cmd = "PREBUILT_STACK_URL='#{PREBUILT_STACK_URL}' #{make_cmd}"
+end
 
 Vagrant::configure("2") do |config|
   config.vm.box = BOX_NAME
   config.vm.box_url = BOX_URI
-  config.vm.provision :shell, :path => "bootstrap.sh"
+  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"]
+    # Ubuntu's Raring 64-bit cloud image is set to a 32-bit Ubuntu OS type by
+    # default in Virtualbox and thus will not boot. Manually override that.
+    vb.customize ["modifyvm", :id, "--ostype", "Ubuntu_64"]
+    vb.customize ["modifyvm", :id, "--memory", BOX_MEMORY]
   end
+
+  config.vm.provision :shell, :inline => "apt-get -y install git && cd /root/dokku && #{make_cmd}"
 end

bootstrap.sh

@@ -1,19 +1,31 @@
-DOKKU_REPO=${DOKKU_REPO:-"https://github.com/progrium/dokku.git"}
+#!/usr/bin/env bash
+set -eo pipefail
+export DEBIAN_FRONTEND=noninteractive
+export DOKKU_REPO=${DOKKU_REPO:-"https://github.com/progrium/dokku.git"}
 
-apt-get install -y linux-image-extra-`uname -r` software-properties-common
-add-apt-repository -y ppa:dotcloud/lxc-docker
-apt-get update && apt-get install -y lxc-docker git ruby nginx make
+if ! which apt-get &>/dev/null
+then
+  echo "This installation script requires apt-get. For manual installation instructions, consult https://github.com/progrium/dokku ."
+  exit 1
+fi
 
-cd ~ && git clone ${DOKKU_REPO}
-cd dokku && make install
-cd buildstep && make build
+apt-get update
+apt-get install -y git make curl software-properties-common
 
-/etc/init.d/nginx start
-start nginx-reloader
+[[ `lsb_release -sr` == "12.04" ]] && apt-get install -y python-software-properties
 
-[[ $(dig +short $HOSTNAME) ]] && HOSTFILE=DOMAIN || HOSTFILE=HOSTNAME
-echo $HOSTNAME > /home/git/$HOSTFILE
+cd ~ && test -d dokku || git clone $DOKKU_REPO
+cd dokku
+git fetch origin
+
+if [[ -n $DOKKU_BRANCH ]]; then
+  git checkout origin/$DOKKU_BRANCH
+elif [[ -n $DOKKU_TAG ]]; then
+  git checkout $DOKKU_TAG
+fi
+
+make install
 
 echo
-echo "Be sure to upload a public key for your user:"
-echo "  cat ~/.ssh/id_rsa.pub | ssh root@$HOSTNAME \"gitreceive upload-key progrium\""
+echo "Almost done! For next steps on configuration:"
+echo "  https://github.com/progrium/dokku#configuring"

contrib/dokku-installer.rb

@@ -0,0 +1,122 @@
+#!/usr/bin/env ruby
+require "sinatra"
+require "open3"
+
+if ARGV[0] == "onboot"
+	File.open("/etc/init/dokku-installer.conf", "w") do |f|
+		f.puts "start on runlevel [2345]"
+		f.puts "exec #{File.absolute_path(__FILE__)} selfdestruct"
+	end
+	File.open("/etc/nginx/conf.d/dokku-installer.conf", "w") do |f|
+		f.puts "upstream dokku-installer { server 127.0.0.1:2000; }"
+		f.puts "server {"
+  		f.puts "	listen      80;"
+  		f.puts "	location    / {"
+    	f.puts "		proxy_pass  http://dokku-installer;"
+  		f.puts "	}"
+		f.puts "}"
+	end
+	`rm /etc/nginx/sites-enabled/*`
+	puts "Installed Upstart service and default Nginx virtualhost for installer to run on boot."
+	exit
+end
+
+version 	= "v0.2.1"
+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
+template 	= DATA.read
+
+set :port, 2000
+set :environment, :production
+disable :protection
+
+get "/" do
+	ERB.new(template).result binding
+end
+
+post "/setup" do
+	if params[:vhost] == "true"
+		File.open("#{dokku_root}/VHOST", "w") {|f| f.write params[:hostname] }
+	else
+		`rm #{dokku_root}/VHOST`
+	end
+	File.open("#{dokku_root}/HOSTNAME", "w") {|f| f.write params[:hostname] }
+	Open3.capture2("sshcommand acl-add dokku admin", :stdin_data => params[:key])
+	Thread.new {
+		`rm /etc/nginx/conf.d/dokku-installer.conf && /etc/init.d/nginx stop && /etc/init.d/nginx start`
+		`rm /etc/init/dokku-installer.conf && stop dokku-installer`
+	}.run if ARGV[0] == "selfdestruct"
+end
+
+__END__
+<html>
+<head>
+	<title>Dokku Setup</title>
+	<link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css" />
+	<script src="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
+</head>
+<body>
+	<div class="container" style="width: 640px;">
+	<form id="form" role="form">
+		<h1>Dokku Setup <small><%= version %></small></h1>
+		<div class="form-group">
+			<h3><small style="text-transform: uppercase;">Admin Access</small></h3>
+			<label for="key">Public Key</label><br />
+			<textarea class="form-control" name="key" rows="7" id="key"><%= admin_key %></textarea>
+		</div>
+		<div class="form-group">
+			<h3><small style="text-transform: uppercase;">Hostname Configuration</small></h3>
+			<div class="form-group">
+				<label for="hostname">Hostname</label>
+				<input class="form-control" type="text" id="hostname" name="hostname" value="<%= hostname %>" />
+			</div>
+			<div class="checkbox">
+				<label><input id="vhost" name="vhost" type="checkbox" value="true"> Use <abbr title="Nginx will be run on port 80 and backend to your apps based on hostname">virtualhost naming</abbr> for apps</label>
+			</div>
+			<p>Your app URLs will look like:</p>
+			<pre id="example">http://hostname:port</pre>
+		</div>
+		<button type="button" onclick="setup()" class="btn btn-primary">Finish Setup</button> <span style="padding-left: 20px;" id="result"></span>
+	</form>
+	</div>
+	<div id="error-output"></div>
+	<script>
+		function setup() {
+			if ($.trim($("#key").val()) == "") {
+				alert("Your admin public key cannot be blank.")
+				return
+			}
+			if ($.trim($("#hostname").val()) == "") {
+				alert("Your hostname cannot be blank.")
+				return
+			}
+			data = $("#form").serialize()
+			$("input,textarea,button").prop("disabled", true);
+			$.post('/setup', data)
+				.done(function() {
+					$("#result").html("Success!")
+					window.location.href = "https://github.com/progrium/dokku#deploy-an-app";
+				})
+				.fail(function(data) {
+					$("#result").html("Something went wrong...")
+					$("#error-output").html(data.responseText)
+				});
+		}
+		function update() {
+			if ($("#vhost").is(":checked") && $("#hostname").val().match(/^(\d{1,3}\.){3}\d{1,3}$/)) {
+				alert("In order to use virtualhost naming, the hostname must not be an IP but a valid domain name.")
+				$("#vhost").prop('checked', false);
+			}
+			if ($("#vhost").is(':checked')) {
+				$("#example").html("http://&lt;app-name&gt;."+$("#hostname").val())
+			} else {
+				$("#example").html("http://"+$("#hostname").val()+":&lt;app-port&gt;")
+			}
+		}
+		$("#vhost").change(update);
+		$("#hostname").change(update);
+		update();
+	</script>
+</body>
+</html>

deploystep

@@ -1,25 +0,0 @@
-#!/bin/bash
-APP="$1"; CONTAINER="$2"
-
-if [[ ! -f "$HOME/$APP/PORT" ]]; then
-  # First deploy
-  ID=$(docker run -d -p 5000 -e PORT=5000 $CONTAINER /bin/bash -c "/start web")
-  echo $ID > "$HOME/$APP/CONTAINER"
-  PORT=$(docker inspect $ID | ruby -e 'require"json";puts JSON.parse(STDIN.read)["NetworkSettings"]["PortMapping"]["5000"]')
-  echo $PORT > "$HOME/$APP/PORT"
-  if [[ -f "$HOME/DOMAIN" ]]; then
-    HOSTNAME="${APP/\//-}.$(< "$HOME/DOMAIN")"
-    $HOME/nginx-app-conf ${APP/\//-} $PORT $HOSTNAME > $HOME/$APP/nginx.conf
-    nc -U $HOME/reload-nginx
-  else
-    HOSTNAME="$(< "$HOME/HOSTNAME"):$PORT"
-  fi
-  echo $HOSTNAME > "$HOME/$APP/HOSTNAME"
-else
-  # Regular deploy
-  OLDID=$(< "$HOME/$APP/CONTAINER")
-  docker kill $OLDID > /dev/null
-  PORT=$(< "$HOME/$APP/PORT")
-  ID=$(docker run -d -p ":$PORT" -e "PORT=$PORT" $CONTAINER /bin/bash -c "/start web")
-  echo $ID > "$HOME/$APP/CONTAINER"
-fi

docs/advanced-installation.md

@@ -0,0 +1,38 @@
+#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:
+
+    $ 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:
+
+    $ 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:
+
+    $ 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] component by
+default. If you want to build your own version you can specify that with an env
+variable.
+
+    $ git clone https://github.com/progrium/dokku.git
+    $ cd dokku
+    $ sudo BUILD_STACK=true make install
+
+[buildstep]: https://github.com/progrium/buildstep

docs/index.md

@@ -0,0 +1,3 @@
+# Dokku Documentation
+
+Docs go here.

dokku

@@ -0,0 +1,114 @@
+#!/usr/bin/env bash
+set -eo pipefail
+export DOKKU_ROOT=${DOKKU_ROOT:="/home/dokku"}
+export PLUGIN_PATH=${PLUGIN_PATH:="/var/lib/dokku/plugins"}
+
+[[ -f $DOKKU_ROOT/dokkurc ]] && source $DOKKU_ROOT/dokkurc
+
+[[ $DOKKU_TRACE ]] && set -x
+
+if [[ $(id -un) != "dokku" && $1 != "plugins-install" ]]; then
+  sudo -u dokku -H $0 "$@"
+  exit
+fi
+
+case "$1" in
+  receive)
+    APP="$2"; IMAGE="dokku/$APP"
+    echo "-----> Cleaning up ..."
+    dokku cleanup
+    echo "-----> Building $APP ..."
+    cat | dokku build $APP
+    echo "-----> Releasing $APP ..."
+    dokku release $APP
+    echo "-----> Deploying $APP ..."
+    dokku deploy $APP
+    echo "=====> Application deployed:"
+    echo "       $(dokku url $APP)"
+    echo
+    ;;
+
+  build)
+    APP="$2"; IMAGE="dokku/$APP"; CACHE_DIR="$DOKKU_ROOT/$APP/cache"
+    id=$(cat | docker run -i -a stdin progrium/buildstep /bin/bash -c "mkdir -p /app && tar -xC /app")
+    test $(docker wait $id) -eq 0
+    docker commit $id $IMAGE > /dev/null
+    [[ -d $CACHE_DIR ]] || mkdir $CACHE_DIR
+    pluginhook pre-build $APP
+    id=$(docker run -d -v $CACHE_DIR:/cache $IMAGE /build/builder)
+    docker attach $id
+    test $(docker wait $id) -eq 0
+    docker commit $id $IMAGE > /dev/null
+    pluginhook post-build $APP
+    ;;
+
+  release)
+    APP="$2"; IMAGE="dokku/$APP"
+    pluginhook pre-release $APP
+    if [[ -f "$DOKKU_ROOT/$APP/ENV" ]]; then
+      id=$(cat "$DOKKU_ROOT/$APP/ENV" | docker run -i -a stdin $IMAGE /bin/bash -c "mkdir -p /app/.profile.d && cat > /app/.profile.d/app-env.sh")
+      test $(docker wait $id) -eq 0
+      docker commit $id $IMAGE > /dev/null
+    fi
+    pluginhook post-release $APP
+    ;;
+
+  deploy)
+    APP="$2"; IMAGE="dokku/$APP"
+    pluginhook pre-deploy $APP
+
+    # kill the app when running
+    if [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
+      oldid=$(< "$DOKKU_ROOT/$APP/CONTAINER")
+      docker inspect $oldid &> /dev/null && docker kill $oldid > /dev/null
+    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")
+    echo $id > "$DOKKU_ROOT/$APP/CONTAINER"
+    port=$(docker port $id 5000 | sed 's/0.0.0.0://')
+    echo $port > "$DOKKU_ROOT/$APP/PORT"
+    echo "http://$(< "$DOKKU_ROOT/HOSTNAME"):$port" > "$DOKKU_ROOT/$APP/URL"
+
+    pluginhook post-deploy $APP $port
+    ;;
+
+  cleanup)
+    # delete all non-running container
+    docker ps -a | grep 'Exit' |  awk '{print $1}' | xargs docker rm &> /dev/null &
+    # delete unused images
+    docker images | grep '<none>' |  awk '{print $3}'  | xargs docker rmi &> /dev/null &
+    ;;
+
+  plugins)
+    ls -1 -d $PLUGIN_PATH/*/
+    ;;
+
+  plugins-install)
+    pluginhook install
+    ;;
+
+  # temporary hack for https://github.com/progrium/dokku/issues/82
+  deploy:all)
+    for app in $(ls -d $DOKKU_ROOT/*/); do
+      APP=$(basename $app);
+      dokku deploy $APP
+    done
+    ;;
+
+  help)
+    cat<<EOF | pluginhook commands help | sort
+    help            Print the list of commands
+    plugins         Print active plugins
+    plugins-install Install active plugins
+EOF
+    ;;
+
+  *)
+    for script in $(ls -d /var/lib/dokku/plugins/*/commands); do
+      $script "$@"
+    done
+    ;;
+
+esac

dokku.1

@@ -0,0 +1,58 @@
+.TH DOKKU 1 2014-03-08
+.\"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 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
+.BI delete " <app>"
+Delete an application.
+.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
+.B plugins-install
+Install 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.

nginx-app-conf

@@ -1,10 +0,0 @@
-#!/bin/bash
-APP="$1"; PORT="$2"; HOSTNAME="$3"
-cat<<EOF
-upstream $APP { server 127.0.0.1:$PORT; }
-server { 
-  listen      80;
-  server_name $HOSTNAME;
-  location    / { proxy_pass  http://$APP; }
-}
-EOF

nginx-reloader.conf

@@ -1,4 +0,0 @@
-script
-  echo | sudo -u git nc -l -U /home/git/reload-nginx && /etc/init.d/nginx reload
-end script
-respawn

plugins/00_dokku-standard/backup-check

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+VERSION="$1"
+IMPORT_DIR="$2"
+TARGET_DIR="$3"
+APPS="$(< $4 )"
+
+ret=0
+
+for app in $APPS; do
+  if [[ -d $TARGET_DIR/$app ]]; then
+    ret=1
+    echo "Trying to import application $app which already exists." 2>&1
+  fi
+done
+
+exit $ret
+

plugins/00_dokku-standard/backup-export

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+VERSION="$1"
+BASE_DIR="$2"
+
+cat;
+[[ -f $BASE_DIR/.sshcommand ]] && echo "$BASE_DIR/.sshcommand"
+[[ -f $BASE_DIR/.ssh/authorized_keys ]] && echo "$BASE_DIR/.ssh/authorized_keys"
+[[ -f $BASE_DIR/HOSTNAME ]] && echo "$BASE_DIR/HOSTNAME"
+[[ -f $BASE_DIR/VHOST ]] && echo "$BASE_DIR/VHOST"

plugins/00_dokku-standard/backup-import

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+VERSION="$1"
+IMPORT_DIR="$2"
+TARGET_DIR="$3"
+
+[[ -f $IMPORT_DIR/.sshcommand ]] && mv $IMPORT_DIR/.sshcommand $TARGET_DIR/.sshcommand
+if [[ -f $IMPORT_DIR/.ssh/authorized_keys ]]; then
+    mkdir -p $TARGET_DIR/.ssh
+    cat $IMPORT_DIR/.ssh/authorized_keys $TARGET_DIR/.ssh/authorized_keys | uniq > $TARGET_DIR/.ssh/authorized_keys
+    chmod 0700 $TARGET_DIR/.ssh
+    chmod 0600 $TARGET_DIR/.ssh/*
+fi
+[[ -f $IMPORT_DIR/HOSTNAME ]] && mv $IMPORT_DIR/HOSTNAME $TARGET_DIR/HOSTNAME
+[[ -f $IMPORT_DIR/VHOST ]] && mv $IMPORT_DIR/VHOST $TARGET_DIR/VHOST

plugins/00_dokku-standard/commands

@@ -0,0 +1,97 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+case "$1" in
+  delete)
+    if [[ -z $2 ]]; then
+        echo "Please specify an app to delete"
+        exit 1
+    fi
+    APP="$2"; IMAGE="dokku/$APP";
+    if [[ ! -d "$DOKKU_ROOT/$APP" ]]; then
+        echo "App does not exist"
+        exit 1
+    fi
+
+    pluginhook pre-delete $APP
+    if [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
+      ID=$(< "$DOKKU_ROOT/$APP/CONTAINER")
+
+      docker stop $ID > /dev/null || true
+      docker rm $ID  > /dev/null || true
+    fi
+
+    docker images | grep $IMAGE | awk '{print $3}' | xargs docker rmi &> /dev/null &
+
+    pluginhook post-delete $APP
+    ;;
+
+  logs)
+    if [[ -z $2 ]]; then
+        echo "Please specify an app to run the command on"
+        exit 1
+    fi
+    APP="$2";
+    if [[ ! -d "$DOKKU_ROOT/$APP" ]]; then
+        echo "App $APP does not exist"
+        exit 1
+    fi
+
+    if [[ -f "$DOKKU_ROOT/$APP/CONTAINER" ]]; then
+      CONTAINER=$(<$DOKKU_ROOT/$APP/CONTAINER)
+      if [[ $3 == "-t" ]]; then
+        docker logs --follow $CONTAINER
+      else
+        docker logs $CONTAINER | tail -n 100
+      fi
+    else
+      echo "Application's container not found"
+    fi
+    ;;
+
+  run)
+    if [[ -z $2 ]]; then
+        echo "Please specify an app to run the command on"
+        exit 1
+    fi
+    APP="$2"; IMAGE="dokku/$APP"
+    if [[ ! -d "$DOKKU_ROOT/$APP" ]]; then
+        echo "App $APP does not exist"
+        exit 1
+    fi
+    shift 2
+
+    DOCKER_ARGS=$(: | pluginhook docker-args $APP)
+    docker run -i -t $DOCKER_ARGS $IMAGE /exec "$@"
+    ;;
+
+  url)
+    APP="$2";
+    if [[ ! -d "$DOKKU_ROOT/$APP" ]]; then
+        echo "App $APP does not exist"
+        exit 1
+    fi
+
+    if [[ -f "$DOKKU_ROOT/$APP/URL" ]]; then
+      echo $(< "$DOKKU_ROOT/$APP/URL")
+    fi
+    ;;
+
+  version)
+    cat "$DOKKU_ROOT/VERSION" || {
+      echo "Unable to determine dokku's version" 2>&1
+      exit 1
+    }
+    ;;
+
+  help)
+    cat && cat<<EOF
+    delete <app>                                    Delete an application
+    logs <app> [-t]                                 Show the last logs for an application (-t follows)
+    run <app> <cmd>                                 Run a command in the environment of an application
+    url <app>                                       Show the URL for an application
+    version                                         Print dokku's version
+EOF
+    ;;
+
+esac
+

plugins/00_dokku-standard/install

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+if [[ ! -f  "$DOKKU_ROOT/HOSTNAME" ]]; then
+    echo $(hostname -f) > $DOKKU_ROOT/HOSTNAME
+fi
+
+# temporary hack for https://github.com/progrium/dokku/issues/82
+# redeploys all apps after a reboot
+cat<<EOF > /etc/init/dokku-redeploy.conf
+description "Dokku app redeploy service"
+
+start on (started docker)
+
+script
+  sleep 2 # give docker some time
+  sudo -i -u dokku /usr/local/bin/dokku deploy:all
+end script
+EOF

plugins/00_dokku-standard/post-delete

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+[[ -n $1 ]] && rm -r "$DOKKU_ROOT/$1" > /dev/null

plugins/00_dokku-standard/pre-delete

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+APP="$1"
+IMAGE=dokku/"$1"
+CACHE_DIR="$DOKKU_ROOT/$APP/cache"
+
+docker run -v $CACHE_DIR:/cache $IMAGE find /cache -depth -mindepth 1 -maxdepth 1 -exec rm -Rf {} \;
+
+

plugins/WARNING

@@ -0,0 +1,2 @@
+
+Please note that the hooks in Dokku are experimental and are likely to change quite a bit.

plugins/backup/commands

@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+CURRENT_BACKUP_VERSION=1
+set -e; case "$1" in
+  backup:export)
+    OUTPUT_FILE="$2"
+    BACKUP_DIR="$DOKKU_ROOT"
+
+    BACKUP_TMP_DIR=$(mktemp -d)
+    BACKUP_TMP_FILE="$BACKUP_TMP_DIR/backup.tar"
+
+    : | pluginhook backup-export 1 $BACKUP_DIR | tar -cf $BACKUP_TMP_FILE --files-from -
+
+    pushd $BACKUP_DIR > /dev/null
+    ls -d */ | grep -oE '[^/]+' > "$BACKUP_TMP_DIR/.dokku_backup_apps"
+    popd > /dev/null
+
+    # we want to insert the files in the root of the tar
+    pushd $BACKUP_TMP_DIR > /dev/null
+    echo $CURRENT_BACKUP_VERSION > .dokku_backup_version
+    tar --append -f $BACKUP_TMP_FILE .dokku_backup_version
+    tar --append -f $BACKUP_TMP_FILE .dokku_backup_apps
+    popd > /dev/null
+
+    # if no file specified, output to stdout
+    if [[ -z $OUTPUT_FILE ]]; then
+        cat $BACKUP_TMP_FILE
+    else
+        mv $BACKUP_TMP_FILE $OUTPUT_FILE
+    fi
+
+    rm -rf $BACKUP_TMP_DIR
+    ;;
+
+  backup:import)
+    if [[ $2 == "-f" ]]; then
+      force=true
+      shift
+    else
+      force=false
+    fi
+
+    INPUT_FILE="$2"
+    [[ -z $INPUT_FILE ]] && INPUT_FILE="-"
+
+    BACKUP_TMP_DIR=$(mktemp -d)
+
+    tar xf $INPUT_FILE --directory=$BACKUP_TMP_DIR
+
+    if [[ ! -f $BACKUP_TMP_DIR/.dokku_backup_version ]]; then
+        echo "Unable to determine backup version"
+        exit 1
+    fi
+
+    VERSION=$(< $BACKUP_TMP_DIR/.dokku_backup_version)
+    if [[ $VERSION -ne 1 ]]; then
+        echo "Unknown format version $VERSION"
+        exit 1
+    fi
+
+    echo "Importing a version $VERSION backup..."
+
+    BACKUP_ROOT="$BACKUP_TMP_DIR""$DOKKU_ROOT"
+    TARGET_DIR="$DOKKU_ROOT"
+
+    if ! pluginhook backup-check $VERSION "$BACKUP_ROOT" "$TARGET_DIR" "$BACKUP_TMP_DIR/.dokku_backup_apps"; then
+      if $force; then
+        echo "-f used. Ignoring warnings."
+      else
+        echo "Archive did not pass sanity checks. Use -f to import anyway" >&2
+        exit 1
+      fi
+    fi
+
+    # create all the app directories
+    while read app; do mkdir "$TARGET_DIR/$app"; echo "Imported $app"; done < $BACKUP_TMP_DIR/.dokku_backup_apps
+
+    # have the plugins import their stuff
+    pluginhook backup-import $VERSION "$BACKUP_ROOT" $TARGET_DIR "$BACKUP_TMP_DIR/.dokku_backup_apps"
+
+    rm -rf $BACKUP_TMP_DIR
+
+    echo "Import complete."
+    ;;
+
+  help)
+    cat && cat<<EOF
+    backup:export [file]                            Export dokku configuration files
+    backup:import [file]                            Import dokku configuration files
+EOF
+    ;;
+
+esac
+

plugins/config/backup-export

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+shopt -s nullglob
+VERSION="$1"
+BASE_DIR="$2"
+
+cat; for i in $BASE_DIR/*/ENV; do echo $i; done

plugins/config/backup-import

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+shopt -s nullglob
+VERSION="$1"
+IMPORT_DIR="$2"
+TARGET_DIR="$3"
+
+cd $IMPORT_DIR
+for file in */ENV; do
+    cp $file "$TARGET_DIR/$file"
+done

plugins/config/commands

@@ -0,0 +1,174 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# Check if name is specified
+if [[ $1 == config ]] || [[ $1 == config:* ]]; then
+  if [[ -z $2 ]]; then
+    echo "You must specify an app name"
+    exit 1
+  else
+    APP="$2"
+    ENV_FILE="$DOKKU_ROOT/$APP/ENV"
+
+    # Check if app exists with the same name
+    if [ ! -d "$DOKKU_ROOT/$APP" ]; then
+      echo "App $APP does not exist"
+      exit 1
+    fi
+
+    [ -f $ENV_FILE ] || {
+      echo "-----> Creating $ENV_FILE"
+      touch $ENV_FILE
+    }
+  fi
+fi
+
+config_styled_hash () {
+  vars=`echo -e "$1"`
+
+  longest=""
+  for word in $vars; do
+    KEY=`echo $word | cut -d"=" -f1`
+    if [ ${#KEY} -gt ${#longest} ]; then
+      longest=$KEY
+    fi
+  done
+
+  for word in $vars; do
+    KEY=`echo $word | cut -d"=" -f1`
+    VALUE=`echo $word | cut -d"=" -f2-`
+
+    num_zeros=$((${#longest} - ${#KEY}))
+    zeros=" "
+    while [ $num_zeros -gt 0 ]; do
+      zeros="$zeros "
+      num_zeros=$(($num_zeros - 1))
+    done
+    echo "$KEY:$zeros$VALUE"
+  done
+}
+
+config_restart_app() {
+  APP="$1";
+
+  echo "-----> Releasing $APP ..."
+  dokku release $APP
+  echo "-----> Release complete!"
+  echo "-----> Deploying $APP ..."
+  dokku deploy $APP
+  echo "-----> Deploy complete!"
+}
+
+case "$1" in
+
+  config)
+    APP="$2"
+
+    if [ ! -f $ENV_FILE ] || [ ! -s $ENV_FILE ] ; then
+      echo "$APP has no config vars"
+      exit 1
+    fi
+
+    VARS=`cat $ENV_FILE | grep -Eo "export ([a-zA-Z_][a-zA-Z0-9_]*=.*)" | cut -d" " -f2`
+
+    for var in "$@"; do
+      if [[ "$var" == "--shell" ]]; then
+        echo $VARS
+        exit 0
+      fi
+    done
+
+    echo "=== $APP config vars ==="
+    config_styled_hash "$VARS"
+  ;;
+
+  config:get)
+    if [[ -z $3 ]]; then
+      echo "Usage: dokku config:get APP KEY"
+      echo "Must specify KEY."
+      exit 1
+    fi
+
+    if [ ! -f $ENV_FILE ] || [ ! -s $ENV_FILE ] ; then
+      exit 1
+    fi
+
+    KEY="$3"
+
+    cat $ENV_FILE | grep -Eo "export ([a-zA-Z_][a-zA-Z0-9_]*=.*)" | cut -d" " -f2 | grep "^$KEY=" | cut -d"=" -f2-
+  ;;
+
+  config:set)
+    if [[ -z "${*:3}" ]]; then
+      echo "Usage: dokku config:set APP KEY1=VALUE1 [KEY2=VALUE2 ...]"
+      echo "Must specify KEY and VALUE to set."
+      exit 1
+    fi
+
+    APP="$2"; APP_DIR="$DOKKU_ROOT/$APP"
+    ENV_ADD=""
+    ENV_TEMP=`cat "${ENV_FILE}"`
+    RESTART=false
+    VARS="${*:3}"
+
+    for var in $VARS; do
+      if [[ $var != *"="* ]]; then
+        echo "Usage: dokku config:set APP KEY1=VALUE1 [KEY2=VALUE2 ...]"
+        echo "Must specify KEY and VALUE to set."
+        exit 1
+      fi
+    done
+
+    for var in $VARS; do
+      KEY=`echo ${var} | cut -d"=" -f1`
+      VALUE=`echo ${var} | cut -d"=" -f2-`
+
+      if [[ $KEY == [a-zA-Z_][a-zA-Z0-9_]* ]]; then
+        RESTART_APP=true
+        ENV_TEMP=$(echo -e "${ENV_TEMP}" | sed "/^export $KEY=/ d")
+        ENV_TEMP="${ENV_TEMP}\nexport ${var}"
+        ENV_ADD=$(echo -e "${ENV_ADD}" | sed "/^$KEY=/ d")
+        ENV_ADD="${ENV_ADD}\n${var}"
+      fi
+    done
+
+    if [ $RESTART_APP ]; then
+      echo "-----> Setting config vars and restarting $APP"
+      config_styled_hash "$ENV_ADD"
+
+      echo -e "$ENV_TEMP" | sed '/^$/d' | sort > $ENV_FILE
+      config_restart_app $APP
+    fi
+  ;;
+
+  config:unset)
+    if [[ -z $3 ]]; then
+      echo "Usage: dokku config:unset APP KEY1 [KEY2 ...]"
+      echo "Must specify KEY to unset."
+      exit 1
+    fi
+
+    APP="$2"; APP_DIR="$DOKKU_ROOT/$APP"
+    ENV_TEMP=`cat "${ENV_FILE}"`
+    VARS="${*:3}"
+
+    for var in $VARS; do
+      echo "-----> Unsetting $var and restarting $APP"
+      ENV_TEMP=$(echo -e "${ENV_TEMP}" | sed "/^export $var=/ d")
+
+      echo -e "$ENV_TEMP" | sed '/^$/d' | sort > $ENV_FILE
+      config_restart_app $APP
+    done
+  ;;
+
+  help)
+    cat && cat<<EOF
+    config <app>                                    display the config vars for an app
+    config:get <app> KEY                            display a config value for an app
+    config:set <app> KEY1=VALUE1 [KEY2=VALUE2 ...]  set one or more config vars
+    config:unset <app> KEY1 [KEY2 ...]              unset one or more config vars
+EOF
+  ;;
+
+esac
+

plugins/git/backup-import

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+VERSION="$1"
+IMPORT_DIR="$2"
+TARGET_DIR="$3"
+APPS="$4"
+
+while read APP; do 
+    APP_PATH="$TARGET_DIR/$APP"; 
+    git init --bare $APP_PATH > /dev/null
+    PRERECEIVE_HOOK="$APP_PATH/hooks/pre-receive"
+    cat > $PRERECEIVE_HOOK <<EOF
+#!/usr/bin/env bash
+set -e; set -o pipefail;
+cat | DOKKU_ROOT="$DOKKU_ROOT" dokku git-hook $APP
+EOF
+    chmod +x $PRERECEIVE_HOOK
+done < $APPS > /dev/null

plugins/git/commands

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+git_archive_all() {
+    APP=$1; REV=$2
+    TMP_WORK_DIR=$(mktemp -d)
+    chmod 755 $TMP_WORK_DIR
+    unset GIT_DIR GIT_WORK_TREE
+    git clone $DOKKU_ROOT/$APP $TMP_WORK_DIR > /dev/null
+    pushd $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
+}
+
+case "$1" in
+  git-hook)
+    APP=$2
+
+    while read oldrev newrev refname
+    do
+      # 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'"/"
+      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'"
+      fi
+
+    done
+    ;;
+
+  git-*)
+    APP="$(echo $2 | perl -pe 's/(?<!\\)'\''//g' | sed 's/\\'\''/'\''/g')"
+    APP_PATH=$DOKKU_ROOT/$APP
+
+    if [[ $1 == "git-receive-pack" && ! -d "$APP_PATH/refs" ]]; then
+        git init --bare $APP_PATH > /dev/null
+        PRERECEIVE_HOOK="$APP_PATH/hooks/pre-receive"
+        cat > $PRERECEIVE_HOOK <<EOF
+#!/usr/bin/env bash
+set -e; set -o pipefail;
+cat | DOKKU_ROOT="$DOKKU_ROOT" dokku git-hook $APP
+EOF
+        chmod +x $PRERECEIVE_HOOK
+    fi
+
+    args=$@
+    git-shell -c "$args"
+    ;;
+
+  help)
+    cat
+    ;;
+esac
+

plugins/nginx-vhosts/backup-export

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+shopt -s nullglob
+VERSION="$1"
+BASE_DIR="$2"
+
+cat; for i in $BASE_DIR/*/ssl/server.*; do echo $i; done

plugins/nginx-vhosts/backup-import

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+shopt -s nullglob
+VERSION="$1"
+IMPORT_DIR="$2"
+TARGET_DIR="$3"
+
+cd $IMPORT_DIR
+
+for file in */ssl/server.*; do
+    mkdir -p $(dirname $TARGET_DIR$file)
+    cp $file $TARGET_DIR$file
+done

plugins/nginx-vhosts/commands

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+case "$1" in
+  help)
+    cat
+    ;;
+esac
+

plugins/nginx-vhosts/install

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+
+# latest stable NGINX 1.4.x with websocket support
+add-apt-repository -y ppa:nginx/stable
+apt-get update
+apt-get install -y nginx dnsutils
+
+if ! grep -q dokku-nginx-reload "/etc/sudoers"; then
+  touch /etc/sudoers.tmp
+  cp /etc/sudoers /tmp/sudoers.new
+  echo "%dokku ALL=(ALL)NOPASSWD:/etc/init.d/nginx reload # dokku-nginx-reload" >> /tmp/sudoers.new
+  EDITOR="cp /tmp/sudoers.new" visudo
+  rm /tmp/sudoers.new
+fi
+
+cat<<EOF > /etc/nginx/conf.d/dokku.conf
+include $DOKKU_ROOT/*/nginx.conf;
+
+ssl_session_cache shared:SSL:20m;
+ssl_session_timeout 10m;
+
+ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-RC4-SHA:ECDHE-RSA-AES128-SHA:AES128-GCM-SHA256:RC4:HIGH:!MD5:!aNULL:!EDH:!CAMELLIA;
+ssl_protocols TLSv1.2 TLSv1.1 TLSv1;
+ssl_prefer_server_ciphers on;
+
+#ssl_certificate $DOKKU_ROOT/tls/server.crt;
+#ssl_certificate_key $DOKKU_ROOT/tls/server.key;
+EOF
+sed -i 's/# server_names_hash_bucket_size/server_names_hash_bucket_size/' /etc/nginx/nginx.conf
+
+if [[ ! -f  "$DOKKU_ROOT/VHOST" ]]; then
+  [[ $(dig +short $(< "$DOKKU_ROOT/HOSTNAME")) ]] && cp "$DOKKU_ROOT/HOSTNAME" "$DOKKU_ROOT/VHOST"
+fi
+
+/etc/init.d/nginx start

plugins/nginx-vhosts/post-delete

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+sudo /etc/init.d/nginx reload > /dev/null

plugins/nginx-vhosts/post-deploy

@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+set -eo pipefail; [[ $DOKKU_TRACE ]] && set -x
+APP="$1"; PORT="$2"
+WILDCARD_SSL="$DOKKU_ROOT/tls"
+SSL="$DOKKU_ROOT/$APP/tls"
+
+if [[ -f "$DOKKU_ROOT/VHOST" ]]; then
+  VHOST=$(< "$DOKKU_ROOT/VHOST")
+  SUBDOMAIN=${APP/%\.${VHOST}/}
+  if [[ "$APP" == *.* ]] && [[ "$SUBDOMAIN" == "$APP" ]]; then
+    hostname="${APP/\//-}"
+  else
+    hostname="${APP/\//-}.$VHOST"
+  fi
+
+  if [[ -e "$SSL/server.crt" ]] && [[ -e "$SSL/server.key" ]]; then
+    SSL_INUSE="$SSL"
+    SSL_DIRECTIVES=$(cat <<EOF
+  ssl_certificate     $SSL_INUSE/server.crt;
+  ssl_certificate_key $SSL_INUSE/server.key;
+EOF
+)
+  elif  [[ -e "$WILDCARD_SSL/server.crt" ]] && [[ -e "$WILDCARD_SSL/server.key" ]] && [[ $hostname = `openssl x509 -in $WILDCARD_SSL/server.crt -noout -subject | tr '/' '\n' | grep CN= | cut -c4-` ]]; then
+    SSL_INUSE="$WILDCARD_SSL"
+    SSL_DIRECTIVES=""
+  fi
+
+  # ssl based nginx.conf
+  if [[ -n "$SSL_INUSE" ]]; then
+  cat<<EOF > $DOKKU_ROOT/$APP/nginx.conf
+upstream $APP { server 127.0.0.1:$PORT; }
+server {
+  listen      [::]:80;
+  listen      80;
+  server_name $hostname;
+  return 301 https://\$host\$request_uri;
+}
+
+server {
+  listen      [::]:443 ssl spdy;
+  listen      443 ssl spdy;
+  server_name $hostname;
+$SSL_DIRECTIVES
+
+  keepalive_timeout   70;
+  add_header          Alternate-Protocol  443:npn-spdy/2;
+
+  location    / {
+    proxy_pass  http://$APP;
+    proxy_http_version 1.1;
+    proxy_set_header Upgrade \$http_upgrade;
+    proxy_set_header Connection "upgrade";
+    proxy_set_header Host \$http_host;
+    proxy_set_header X-Forwarded-Proto \$scheme;
+    proxy_set_header X-Forwarded-For \$remote_addr;
+    proxy_set_header X-Forwarded-Port \$server_port;
+    proxy_set_header X-Request-Start \$msec;
+  }
+}
+EOF
+
+  echo "https://$hostname" > "$DOKKU_ROOT/$APP/URL"
+else
+# default nginx.conf
+  cat<<EOF > $DOKKU_ROOT/$APP/nginx.conf
+upstream $APP { server 127.0.0.1:$PORT; }
+server {
+  listen      [::]:80;
+  listen      80;
+  server_name $hostname;
+  location    / {
+    proxy_pass  http://$APP;
+    proxy_http_version 1.1;
+    proxy_set_header Upgrade \$http_upgrade;
+    proxy_set_header Connection "upgrade";
+    proxy_set_header Host \$http_host;
+    proxy_set_header X-Forwarded-Proto \$scheme;
+    proxy_set_header X-Forwarded-For \$remote_addr;
+    proxy_set_header X-Forwarded-Port \$server_port;
+    proxy_set_header X-Request-Start \$msec;
+  }
+}
+EOF
+
+  echo "http://$hostname" > "$DOKKU_ROOT/$APP/URL"
+  fi
+  pluginhook nginx-pre-reload $APP
+  sudo /etc/init.d/nginx reload > /dev/null
+fi

receiver

@@ -1,14 +0,0 @@
-#!/bin/bash
-set -e
-APP="$1"
-CONTAINER="app/$APP"
-
-echo "-----> Building $APP ..."
-cat | $HOME/buildstep $CONTAINER
-echo "-----> Build complete!"
-
-echo "-----> Deploying $APP ..."
-$HOME/deploystep $APP $CONTAINER
-echo "-----> Application deployed:"
-echo "       http://$(< "$HOME/$APP/HOSTNAME")"
-echo

tests/apps/.websocket.disabled/Procfile

@@ -0,0 +1 @@
+web: node app.js

tests/apps/.websocket.disabled/README.md

@@ -0,0 +1 @@
+node websocket demo

tests/apps/.websocket.disabled/app.js

@@ -0,0 +1,75 @@
+var express = require('express')
+  , exphbs  = require('express3-handlebars')
+  , http = require('http')
+  , connect = require('connect')
+  , io = require('socket.io');
+
+
+
+var app = express();
+
+app.engine('handlebars',exphbs({extname: ".html", layoutsDir:"views/", defaultLayout: 'layout'}));
+app.set('view engine', 'handlebars');
+/* NOTE: We'll need to refer to the sessionStore container later. To
+ *       accomplish this, we'll create our own and pass it to Express
+ *       rather than letting it create its own. */
+var sessionStore = new connect.session.MemoryStore();
+/* NOTE: We'll need the site secret later too, so let's factor it out.
+ *       The security implications of this are left to the reader. */
+var SITE_SECRET = 'I am not wearing any pants';
+
+
+// app.configure(function(){
+//     app.set('view engine', 'handlebars');
+//     // app.set("view options", { layout: false }) 
+// });
+
+app.set('views', __dirname + '/views');
+// app.register('.html', require('handlebars'));
+/*
+ * ... skipping some of your app settings ...
+ */
+app.use(express.bodyParser());
+/* NOTE: Pass the cookieParser the site secret. It used to be that
+ *       express.session() got the secret, but in Express 3 that's
+ *       no longer the case. */
+app.use(express.cookieParser(SITE_SECRET));
+/* NOTE: We'll need to know the key used to store the session, so
+ *       we explicitly define what it should be. Also, we pass in
+ *       our sessionStore container here. */
+app.use(express.session({
+    key: 'express.sid'
+  , store: sessionStore
+}));
+
+app.use(express.static('public'));
+/*
+ * ... skipping the rest of your app settings ...
+ */
+
+app.get('/', function(req, res){
+  res.render('index', {socket_url:"ciaourl"});
+});
+
+var server = http.createServer(app);
+
+var app_port = process.env.PORT || 3000;
+server.listen(app_port, function(){
+  console.log("Express server listening on port "+ app_port);
+});
+ 
+/**
+ * Socket.io
+ */
+var sio = io.listen(server);
+ 
+
+sio.sockets.on('connection', function (socket) {
+
+  // temperature
+  setInterval(function () {
+    var val = (new Date).getTime();
+    socket.emit('new value', { val: "I'm a websocket message: "+val });
+  }, 2000);
+
+});

tests/apps/.websocket.disabled/check_deploy

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

tests/apps/.websocket.disabled/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "node-websocket-app",
+  "version": "0.0.0",
+  "description": "a basic webscket demo",
+  "author": "Luigi Maselli",
+  "dependencies": {
+    "express": "3.1.x",
+    "connect": "*",
+    "handlebars": "~1.0.9",
+    "socket.io": "~0.9.13",
+    "express3-handlebars": "~0.2.3"
+  },
+  "engines": {
+    "node": "0.10.x"
+  }
+}

tests/apps/.websocket.disabled/views/index.handlebars

@@ -0,0 +1,5 @@
+<h2>I'm a static HTTP message</h2>
+<h1 id="display">
+  No messages
+</h1>
+<p>If you get many GET messages in your console it isn't websocket but socket.io fallback mode</p>

tests/apps/.websocket.disabled/views/layout.html

@@ -0,0 +1,25 @@
+<html>
+<head>
+  <title>Websocket demo Socket.io</title>
+  <script src="./socket.io/socket.io.js"></script>
+  <script src="./jquery.min.js"></script>
+</head>
+<body>
+<script>
+
+  $(document).ready(function () {
+
+    var socket = io.connect( window.location.origin ); // transparent HTTP / Websocket upgrade
+
+    socket.on('new value', function (data) {
+      console.log("RECV:"+ JSON.stringify(data));
+      $('#display').html(data.val);
+    });
+
+  });
+
+
+</script>
+{{{body}}}
+</body>
+</html>

tests/apps/config/Procfile

@@ -0,0 +1 @@
+web: node web.js

tests/apps/config/check_deploy

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

tests/apps/config/post-deploy

@@ -0,0 +1,8 @@
+#!/bin/bash
+set -ex;
+
+REMOTE=$1
+REPO=$2
+
+ssh $REMOTE config:set $REPO CONFTEST=config-test
+

tests/apps/config/web.js

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

tests/apps/gitsubmodules/Procfile

@@ -0,0 +1 @@
+web: node node-js-sample/web.js

tests/apps/gitsubmodules/check_deploy

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

tests/apps/gitsubmodules/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "node-example",
+  "version": "0.0.1",
+  "dependencies": {
+    "express": "~3.3.4"
+  },
+  "engines": {
+    "node": "0.10.x",
+    "npm": "1.3.x"
+  }
+}

tests/apps/gitsubmodules/pre-commit

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

tests/apps/go/.godir

@@ -0,0 +1 @@
+web

tests/apps/go/Procfile

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

tests/apps/go/check_deploy

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

tests/apps/go/web.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+    "fmt"
+    "net/http"
+    "os"
+)
+
+func main() {
+    http.HandleFunc("/", hello)
+    fmt.Println("listening...")
+    err := http.ListenAndServe(":"+os.Getenv("PORT"), nil)
+    if err != nil {
+      panic(err)
+    }
+}
+
+func hello(res http.ResponseWriter, req *http.Request) {
+    fmt.Fprintln(res, "go")
+}

tests/apps/java/Procfile

@@ -0,0 +1 @@
+web:    java -cp target/classes:target/dependency/* HelloWorld

tests/apps/java/check_deploy

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

tests/apps/java/pom.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>com.example</groupId>
+    <version>1.0-SNAPSHOT</version>
+    <artifactId>helloworld</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>org.eclipse.jetty</groupId>
+            <artifactId>jetty-servlet</artifactId>
+            <version>7.6.0.v20120127</version>
+        </dependency>
+        <dependency>
+            <groupId>javax.servlet</groupId>
+            <artifactId>servlet-api</artifactId>
+            <version>2.5</version>
+        </dependency>
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <version>2.4</version>
+                <executions>
+                    <execution>
+                        <id>copy-dependencies</id>
+                        <phase>package</phase>
+                        <goals><goal>copy-dependencies</goal></goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

tests/apps/java/src/main/java/HelloWorld.java

@@ -0,0 +1,22 @@
+import java.io.IOException;
+import javax.servlet.ServletException;
+import javax.servlet.http.*;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.servlet.*;
+
+public class HelloWorld extends HttpServlet {
+    @Override
+    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
+            throws ServletException, IOException {
+        resp.getWriter().print("Hello from Java!\n");
+    }
+    public static void main(String[] args) throws Exception{
+        Server server = new Server(Integer.valueOf(System.getenv("PORT")));
+        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS);
+        context.setContextPath("/");
+        server.setHandler(context);
+        context.addServlet(new ServletHolder(new HelloWorld()),"/*");
+        server.start();
+        server.join();
+    }
+}

tests/apps/multi/.bowerrc

@@ -0,0 +1,3 @@
+{
+  "directory": "static/components"
+}

tests/apps/multi/.buildpacks

@@ -0,0 +1,3 @@
+https://github.com/heroku/heroku-buildpack-ruby
+https://github.com/heroku/heroku-buildpack-nodejs
+https://github.com/heroku/heroku-buildpack-python

tests/apps/multi/.gitignore

@@ -0,0 +1,6 @@
+node_modules
+static/components
+static/.tmp
+.sass-cache
+.bundle
+.DS_Store

tests/apps/multi/.npmrc

@@ -0,0 +1 @@
+unsafe-perm = true

tests/apps/multi/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+ruby '1.9.3'
+
+gem 'compass'
+gem 'sass-globbing'

tests/apps/multi/Gemfile.lock

@@ -0,0 +1,19 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    chunky_png (1.3.0)
+    compass (0.12.3)
+      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)
+      sass (>= 3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  compass
+  sass-globbing

tests/apps/multi/Gruntfile.js

@@ -0,0 +1,43 @@
+'use strict';
+
+module.exports = function (grunt) {
+
+  require('load-grunt-tasks')(grunt);
+
+  grunt.initConfig({
+
+    compass: {
+      options: {
+        sassDir: 'static/styles',
+        cssDir: 'static/.tmp/styles',
+        generatedImagesDir: 'static/.tmp/images/generated',
+        imagesDir: 'static/images',
+        javascriptsDir: 'static/scripts',
+        fontsDir: 'static/styles/fonts',
+        importPath: 'static/components',
+        httpImagesPath: '/images',
+        httpGeneratedImagesPath: '/images/generated',
+        httpFontsPath: '/styles/fonts',
+        relativeAssets: false,
+        assetCacheBuster: false,
+        bundleExec: true,
+        raw: 'Sass::Script::Number.precision = 10\n'
+      },
+      dist: {
+        options: {
+          // generatedImagesDir: '<%= yeoman.dist %>/static/images/generated'
+        }
+      },
+      server: {
+        options: {
+          debugInfo: false
+        }
+      }
+    }
+  });
+
+  grunt.registerTask('heroku', [
+    'compass:server'
+  ]);
+
+};

tests/apps/multi/Procfile

@@ -0,0 +1 @@
+web: python app.py

tests/apps/multi/README.md

@@ -0,0 +1,3 @@
+This is a sample application to test heroku buildpack multi for integrating with buildstep: https://github.com/progrium/buildstep/pull/75
+
+I am choosing to use the python, nodejs, and ruby buildpacks to create a very simple flask app that performs a bower install and a simple grunt task using compass.

tests/apps/multi/app.py

@@ -0,0 +1,15 @@
+import os
+from flask import Flask, render_template
+from werkzeug.wsgi import SharedDataMiddleware
+
+app = Flask(__name__)
+
+@app.route('/')
+def hello_world():
+    return render_template('index.html')
+
+app.wsgi_app = SharedDataMiddleware(app.wsgi_app, { '/': os.path.join(os.path.dirname(__file__), 'static') })
+app.wsgi_app = SharedDataMiddleware(app.wsgi_app, { '/': os.path.join(os.path.dirname(__file__), 'static/.tmp') })
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', debug=True)

tests/apps/multi/bower.json

@@ -0,0 +1,20 @@
+{
+  "name": "test-buildpack-multi",
+  "version": "0.0.0",
+  "authors": [
+    "Al Johri <al.johri@gmail.com>"
+  ],
+  "license": "MIT",
+  "private": true,
+  "directory": "static/components",
+  "ignore": [
+    "**/.*",
+    "node_modules",
+    "statc/components",
+    "test",
+    "tests"
+  ],
+  "dependencies": {
+    "bootstrap-sass": "twbs/bootstrap-sass#~3.1.1"
+  }
+}

tests/apps/multi/check_deploy

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

tests/apps/multi/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "test-buildpack-multi",
+  "version": "0.0.0",
+  "description": "Test application for heroku multi buildpack.",
+  "author": "Al Johri",
+  "license": "ISC",
+  "dependencies": {
+    "bower": "~1.2.8",
+    "grunt": "~0.4.1",
+    "grunt-cli": "~0.1.13",
+    "load-grunt-tasks": "~0.2.0",
+    "grunt-contrib-compass": "~0.6.0"
+  },
+  "scripts": {
+    "postinstall": "./node_modules/bower/bin/bower --allow-root install && ./node_modules/grunt-cli/bin/grunt heroku"
+  }
+}

tests/apps/multi/requirements.txt

@@ -0,0 +1 @@
+Flask==0.10.1

tests/apps/multi/static/styles/main.scss

@@ -0,0 +1,6 @@
+// override scss variables within bootsrap by delaring them
+// before importing bootstrap
+
+$brand-primary:         #428bca !default;
+
+@import "bootstrap-sass/vendor/assets/stylesheets/bootstrap";

tests/apps/multi/templates/index.html

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="utf-8">
+  <title>Sample Webpage</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="description" content="">
+  <meta name="author" content="">	
+  <link rel="stylesheet" type="text/css" href="/styles/main.css">
+  <script type="text/javascript" src="/components/bootstap-sass/vendor/assets/javascripts/bootstrap/bootstrap.js"></script>
+</head>
+
+<body>
+	<div class="container">
+		<div class="row clearfix">
+			<div class="col-md-12 column">
+				<div class="jumbotron">
+					<h1>
+						Hello, world!
+					</h1>
+					<p>
+						This is a sample website using the Heroku Multi Buildpack on Dokku. It uses the python, ruby, and node buildpacks. The node buildpack is for using bower and grunt. The ruby buildpack is for running compass. And last but not last, the python buildpack is to run the flask application.
+					</p>
+					<p>
+						<a class="btn btn-primary btn-large" href="#">Learn more</a>
+					</p>
+				</div>
+			</div>
+		</div>
+	</div>
+</body>
+
+</html>

tests/apps/nodejs-express/Procfile

@@ -0,0 +1 @@
+web: node web.js

tests/apps/nodejs-express/check_deploy

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

tests/apps/nodejs-express/package.json

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

tests/apps/php/check_deploy

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

tests/apps/php/index.php

@@ -0,0 +1 @@
+<html><?php echo '<h3>php</h3>'; ?></html>

tests/apps/python-flask/Procfile

@@ -0,0 +1 @@
+web: gunicorn hello:app

tests/apps/python-flask/check_deploy

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

tests/apps/python-flask/hello.py

@@ -0,0 +1,8 @@
+import os
+from flask import Flask
+
+app = Flask(__name__)
+
+@app.route('/')
+def hello():
+        return 'python/flask'

tests/apps/python-flask/requirements.txt

@@ -0,0 +1,5 @@
+Flask==0.9
+Jinja2==2.6
+Werkzeug==0.8.3
+gunicorn==0.17.2
+

tests/apps/static/check_deploy

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

tests/apps/static/www/index.html

@@ -0,0 +1 @@
+<html><h3>Static Page</h3></html>

tests/ci/receiver

@@ -0,0 +1,37 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+export PATH=/usr/local/sbin:/usr/sbin:/sbin:/bin:/usr/bin:/usr/local/bin
+unset GIT_DIR
+
+if [[ $2 == *dokku* ]]; then
+  date -uIseconds
+  rm -rf /tmp/build
+  mkdir /tmp/build
+  cd /tmp/build
+  tar -xf -
+  echo "-----> Installing dependencies"
+  DEBIAN_FRONTEND=noninteractive apt-get install -y git make curl software-properties-common
+  echo "-----> Set hostname to dokku.me"
+  hostname dokku.me
+	echo "-----> Enabling tracing"
+	mkdir -p /home/dokku
+	echo "export DOKKU_TRACE=1" >> /home/dokku/dokkurc
+  echo "-----> Running make install"
+  DEBIAN_FRONTEND=noninteractive make install
+  echo "-----> Generating keypair..."
+  echo -e  "y\n" | ssh-keygen -f /root/.ssh/id_rsa -t rsa -N ''
+  echo "-----> Installing SSH public key..."
+  cat /root/.ssh/id_rsa.pub | sudo sshcommand acl-add dokku test
+  echo "-----> Intitial SSH connection to populate known_hosts..."
+  ssh -o StrictHostKeyChecking=no dokku@dokku.me help > /dev/null
+  echo "-----> Running tests"
+  cd tests
+  for app_path in apps/*; do
+    app=$(basename $app_path)
+    echo "-----> Running test deploy of $app..."
+   ./test_deploy $app_path dokku.me $FORWARDED_PORT
+  done
+else
+  echo "-----> Repository invalid."
+fi

tests/ci/setup.sh

@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+export DEBIAN_FRONTEND=noninteractive 
+apt-get install -y git make curl
+
+cd /tmp
+
+wget http://j.mp/godeb
+tar -zxvf ./godeb
+./godeb install 1.1.2
+
+export GOPATH=/root/go
+git clone https://github.com/flynn/gitreceive-next.git
+cd gitreceive-next && make install
+
+ssh-keygen -f $HOME/.ssh/id_rsa -t rsa -N ''
+
+cat<<EOF > /etc/init/gitreceived.conf
+start on runlevel [2345]
+exec /usr/local/bin/gitreceived -p 2022 -n /root/.ssh/id_rsa /tmp/receiver
+EOF
+
+cat<<EOF > /etc/rc.local
+curl https://raw.github.com/progrium/dokku/master/tests/ci/receiver -s > /tmp/receiver
+chmod +x /tmp/receiver
+EOF

tests/nodejs/express/Procfile

@@ -1 +0,0 @@
-web: bin/node web.js

tests/run_ec2

@@ -1,18 +1,19 @@
-#!/bin/bash
+#!/usr/bin/env bash
+set -eo pipefail
 KEYNAME="$1"
 indent() { sed "s/^/       /"; }
 echo "-----> Booting EC2 instance..."
-start=$(ec2-run-instances -k $1 ami-f3d1bb9a 2>/dev/null)
+start=$(ec2-run-instances -k $1 ami-f3d1bb9a 2>&1 )
 if [[ $? > 0 ]]; then
-  echo "$start"
-  exit
+  echo "$start" | indent
+  exit 3
 fi
 INSTANCE=$(echo "$start" | awk '/^INSTANCE/ {print $2}')
 terminate() {
   echo "-----> Terminating $INSTANCE..."
   ec2-terminate-instances $INSTANCE &>/dev/null && echo "       Shutting down"
 }
-trap "terminate" EXIT
+[[ $NOCLEANUP ]] || trap "terminate" EXIT
 sleep 30
 status=""
 while [[ "$status" != "running" ]]; do
@@ -27,6 +28,17 @@ while [[ "$status" != "running" ]]; do
 done
 PUBLIC_IP=$(echo "$info" | awk '{print $14}')
 echo "-----> Waiting for SSH at $PUBLIC_IP..."
-sleep 10
-echo "-----> Connecting and running boostrap script..."
-cat ../bootstrap.sh | ssh -o "StrictHostKeyChecking=no" ubuntu@$PUBLIC_IP "HOSTNAME=$PUBLIC_IP sudo bash" 2>&1 | indent
+while [[ ! $(echo | nc $PUBLIC_IP 22) ]]; do
+  sleep 5
+  echo "       Waiting..."
+done
+set -e
+echo "-----> Connecting and running bootstrap script..."
+cat ../bootstrap.sh | ssh -o "StrictHostKeyChecking=no" ubuntu@$PUBLIC_IP "HOSTNAME=$PUBLIC_IP sudo bash" 2>&1 | indent
+echo "-----> Installing SSH public keys..."
+cat ~/.ssh/id_rsa.pub | ssh -o "StrictHostKeyChecking=no" ubuntu@$PUBLIC_IP "sudo sshcommand acl-add dokku test" > /dev/null
+for app_path in apps/*; do
+  app=$(basename $app_path)
+  echo "-----> Running test deploy of $app..."
+  ./test_deploy $app_path $PUBLIC_IP
+done

tests/run_vagrant

@@ -1,14 +1,26 @@
-#!/bin/bash
+#!/usr/bin/env bash
+set -eo pipefail
 SELF=`which $0`
-VAGRANT_SSH_PORT=${$VAGRANT_SSH_PORT:-"2222"}
-PUBLIC_KEY=${PUBLIC_KEY:-"~/.ssh/id_rsa.pub"}
+VAGRANT_SSH_PORT=${VAGRANT_SSH_PORT:-"2222"}
+PUBLIC_KEY=${PUBLIC_KEY:-"$HOME/.ssh/id_rsa.pub"}
+FORWARDED_PORT=${FORWARDED_PORT:-":8080"}
 indent() { sed "s/^/       /"; }
 if [[ ! $(cat ~/.ssh/config 2>/dev/null | grep dokku.me) ]]; then
   echo "-----> Configuring SSH to use $VAGRANT_SSH_PORT for dokku.me..."
   touch ~/.ssh/config
   echo "Host dokku.me" >> ~/.ssh/config
   echo "    Port $VAGRANT_SSH_PORT" >> ~/.ssh/config
+  echo "    RequestTTY yes" >> ~/.ssh/config
 fi
 echo "-----> Ensuring Vagrant is running..."
 cd "$(dirname $SELF)/.." && vagrant up | indent
-cat $PUBLIC_KEY | ssh -o "StrictHostKeyChecking=no" -i ~/.vagrant.d/insecure_private_key vagrant@dokku.me "sudo gitreceive upload-key test"
+cd "$(dirname $SELF)"
+
+echo "-----> Installing SSH public keys..."
+cat $PUBLIC_KEY | ssh -o "StrictHostKeyChecking=no" -i ~/.vagrant.d/insecure_private_key vagrant@dokku.me "sudo sshcommand acl-add dokku test"
+
+for app_path in apps/*; do
+  app=$(basename $app_path)
+  echo "-----> Running test deploy of $app..."
+  ./test_deploy $app_path dokku.me $FORWARDED_PORT
+done