diff --git a/.gitignore b/.gitignore
index ea18cd18..db922810 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,7 +23,9 @@ cli/semaphores/signal
 cli/semaphores/unlink
 api/api_generated.go
 api/server/executors/executors_generated.go
-drivers/storage/ebs/tests/.vagrant
+drivers/storage/ebs/tests/.vagrant/
+examples/ec2/vagrant/.vagrant/
+
 
 # Created by https://www.gitignore.io
 
diff --git a/examples/ec2/vagrant/README.md b/examples/ec2/vagrant/README.md
new file mode 100644
index 00000000..e8741acd
--- /dev/null
+++ b/examples/ec2/vagrant/README.md
@@ -0,0 +1,100 @@
+# EC2 Vagrantfile
+This directory includes a Vagrantfile that can be used to bring a libStorage
+server/client installation online using REX-Ray and EC2 instances. For example:
+
+```
+vagrant up --provider=aws --no-parallel
+```
+
+The following sections outline dependencies, settings, and different execution
+scenarios that may be required or useful for using the Vagrantfile.
+
+### Dependencies
+The following dependencies are required in order to bring the EC2 Vagrant
+enviornment online:
+
+  * [Vagrant](https://www.vagrantup.com/) 1.8.5+
+  * [vagrant-aws](https://github.com/mitchellh/vagrant-aws)
+  * [vagrant-hostmanager](https://github.com/devopsgroup-io/vagrant-hostmanager)
+
+Once Vagrant is installed the required plug-ins may be installed with the
+following commands:
+
+```bash
+vagrant plugin install vagrant-aws
+vagrant plugin install vagrant-hostmanager
+```
+
+### Settings
+The following environment variables may be used to configure the `Vagrantfile`.
+
+Environment Variable | Description | Required | Default
+---------------------|-------------|:--------:|--------
+`AWS_AKEY`           | The AWS access key ID. | ✓ |
+`AWS_SKEY`           | The AWS secret key. | ✓ |
+`AWS_KPNM`           | The name of the AWS key pair for instances. | ✓ |
+`AWS_AMI`            | The AMI to use. Defaults to Amazon Linux PV x64 ([AMIs by region](https://aws.amazon.com/amazon-linux-ami/)) | | ami-de347abe
+`AWS_REGN`           | The AWS region. | | us-west-1
+`AWS_ZONE`           | The AWS availability zone. | | a
+`AWS_SSHK`           | Local SSH key used to access AWS instances. | ✓ |
+
+### Nodes
+The `Vagrantfile` which deploys a libStorage server and two clients onto EC2
+instances named:
+
+  * libstorage-server
+  * libstorage-client0
+  * libstorage-client1
+
+### Test Plan Boot Order
+The order in which Vagrant brings the nodes online can vary:
+
+```bash
+vagrant up --provider=aws
+```
+
+The above command will bring all three nodes -- the server and both clients --
+online in parallel since the Vagrant AWS plug-in is configured to support
+the parallel option. However, the Vagrantfile will fail if the server
+is not brought online first. That is why when bringing the Vagrant nodes online
+all at once, the following command should be used:
+
+```bash
+vagrant up --provider=aws --no-parallel
+```
+
+The above command will bring the nodes online in the following order:
+
+  1. libstorage-server
+  2. libstorage-client0
+  3. libstorage-client1
+
+However, another option for starting the environment is to bring up the server
+first and then the clients in parallel. Doing so can duplicate a scenario
+where two clients are contending for storage resources:
+
+```bash
+vagrant up --provider=aws libstorage-server
+vagrant up --provider=aws '/.*client.*/'
+```
+
+### Scripts
+This package includes several test scripts that act as simple ways to execute
+random pieces of logic for a node after it is brought online:
+
+  * `server.sh`
+  * `client0.sh`
+  * `client1.sh`
+
+The above files are copied to their respective instances and executed
+as soon as the instance is online. That means the `server-tests.sh` script is
+executed before the client nodes are even online since the server node is
+brought online first.
+
+### Cleanup
+It's important to remember to clean up any EC2, EBS, & EFS resources that may
+have been created along the way. To do so simply execute the following command:
+
+```bash
+vagrant destroy -f
+```
diff --git a/examples/ec2/vagrant/Vagrantfile b/examples/ec2/vagrant/Vagrantfile
new file mode 100644
index 00000000..d3d88d31
--- /dev/null
+++ b/examples/ec2/vagrant/Vagrantfile
@@ -0,0 +1,590 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+require 'fileutils'
+require 'shellwords'
+require 'fog'
+
+# general config
+$autostart_clients = true # set to false to prevent clients from auto-starting
+
+# aws config
+$aws_akey = ENV['AWS_AKEY']
+$aws_skey = ENV['AWS_SKEY']
+$aws_kpnm = ENV['AWS_KPNM']
+$aws_ami  = ENV['AWS_AMI']  ? ENV['AWS_AMI'] : "ami-ef2af28f"
+$aws_regn = ENV['AWS_REGN'] ? ENV['AWS_REGN'] : "us-west-2"
+$aws_zone = ENV['AWS_ZONE'] ? ENV['AWS_ZONE'] : "a"
+
+# ssh config
+$ssh_user    = "centos"
+$ssh_pkey    = ENV['AWS_SSHK'] # path to SSH private key for AWS
+
+# node info
+$node0_name =       "libstorage-server"
+$node0_itype =      "m4.large"
+$node0_texps =      "server.sh"
+
+$node1_name =       "libstorage-client0"
+$node1_itype =      "m4.large"
+$node1_texps =      "client0.sh"
+
+$node2_name =       "libstorage-client1"
+$node2_itype =      "t2.micro"
+$node2_texps =      "client1.sh"
+
+# Golang information
+$goos   = "linux"
+$goarch = "amd64"
+$gover  = "1.7.1"
+$gotgz  = "go#{$gover}.#{$goos}-#{$goarch}.tar.gz"
+$gourl  = "https://storage.googleapis.com/golang/#{$gotgz}"
+$gopath = "/opt/go"
+
+# project info
+$srcs = "#{$gopath}/src/github.com/codedellemc/libstorage"
+
+# the script to ensure the copied working source is a git repo
+$validate_copied_sources = <<SCRIPT
+git config --global user.name #{$ssh_user}
+git config --global user.email #{$ssh_user}@localhost
+cd #{$srcs}
+git init
+git add -A
+git commit -m v0.0.1
+git tag -a -m v0.0.1 v0.0.1
+SCRIPT
+
+# the script to provision golang
+$provision_golang = <<SCRIPT
+echo installing go#{$gover}.#{$goos}-#{$goarch}
+curl -SLO #{$gourl.shellescape}
+tar -C /usr/local -xzf #{$gotgz.shellescape}
+mkdir -p #{$gopath.shellescape}
+rm -f #{$gotgz.shellescape}
+SCRIPT
+
+# the script to provision an update to the system
+$provision_update_system = <<SCRIPT
+yum update -y
+SCRIPT
+
+# the script to install build tools
+$provision_build_tools = <<SCRIPT
+yum group install -y "Development Tools"
+yum install -y glibc-static glibc-devel.i686
+SCRIPT
+
+# the script to install git on the clients
+$provision_git = <<SCRIPT
+yum install -y git
+SCRIPT
+
+# the script to provision docker
+$provision_docker = <<SCRIPT
+systemctl enable docker
+systemctl start docker
+SCRIPT
+
+# the script to validate the docker install
+$validate_docker = <<SCRIPT
+sudo su - #{$ssh_user} -c 'docker info'
+sudo su - #{$ssh_user} -c 'docker run --rm hello-world'
+SCRIPT
+
+# go-bindata info
+$go_bindata_dir = "#{$gopath}/src/github.com/jteeuwen/go-bindata"
+$go_bindata_url = "https://github.com/akutz/go-bindata"
+$go_bindata_ref = "feature/md5checksum"
+
+# the script to build go-bindata
+$build_go_bindata = <<SCRIPT
+mkdir -p #{$go_bindata_dir.shellescape}
+cd #{$go_bindata_dir.shellescape}
+git clone #{$go_bindata_url.shellescape} .
+git checkout #{$go_bindata_ref.shellescape}
+go get ./...
+go install ./...
+SCRIPT
+
+# rex-ray repo and branch information
+$rexray_dir = "#{$gopath}/src/github.com/codedellemc/rexray"
+$rexray_url = ENV['RR_REPO']  ? ENV['RR_REPO'] : "https://github.com/codedellemc/rexray"
+$rexray_ref = ENV['RR_REF']  ? ENV['RR_REF'] : "master"
+$rexray_bin = "/usr/bin/rexray"
+$rexray_cfg = "/etc/rexray/config.yml"
+
+# the script to build rex-ray
+$build_rexray = <<SCRIPT
+mkdir -p #{$rexray_dir.shellescape}
+cd #{$rexray_dir.shellescape}
+git clone #{$rexray_url.shellescape} .
+git checkout #{$rexray_ref.shellescape}
+sed -e 's/.*# libstorage-version/    ref:     master/g' -i glide.yaml
+sed -e $'s|.*# libstorage-repo|    repo:    file://#{$srcs}\\\n    vcs:     git|g' -i glide.yaml
+rm glide.lock
+make deps
+make -j build-libstorage
+make build
+SCRIPT
+
+# the script to copy the rex-ray binary from the server node to a client node.
+# this script is executed from a client node.
+$copy_rexray = <<SCRIPT
+scp -q -i /home/#{$ssh_user}/.ssh/#{$node0_name}.key \
+    -o StrictHostKeyChecking=no \
+    #{$ssh_user}@#{$node0_name}:#{$rexray_bin.shellescape} \
+    #{$rexray_bin.shellescape}
+SCRIPT
+
+# the script to write rex-ray config file for the server node.
+$write_rexray_server_config = <<SCRIPT
+mkdir -p #{File.dirname($rexray_cfg).shellescape}
+cat << EOF > #{$rexray_cfg.shellescape}
+rexray:
+  logLevel: debug
+libstorage:
+  host:     tcp://127.0.0.1:7979
+  embedded: true
+  service:  ebs
+  logging:
+    level: debug
+    httpRequests: true
+    httpResponses: true
+  server:
+    endpoints:
+      public:
+        address: tcp://:7979
+    services:
+      ebs:
+        driver: ebs
+      efs:
+        driver: efs
+ebs:
+  accessKey: #{$aws_akey}
+  secretKey: #{$aws_skey}
+  region: #{$aws_regn}
+efs:
+  accessKey: #{$aws_akey}
+  secretKey: #{$aws_skey}
+  region: #{$aws_regn}
+EOF
+SCRIPT
+
+# the script to write rex-ray config file for the client node(s).
+$write_rexray_client_config = <<SCRIPT
+mkdir -p #{File.dirname($rexray_cfg).shellescape}
+cat << EOF > #{$rexray_cfg.shellescape}
+rexray:
+  logLevel: debug
+libstorage:
+  host:    tcp://#{$node0_name}:7979
+  service: ebs
+EOF
+SCRIPT
+
+# the script to update the root profile with go info
+$to_root_profile = ">> /root/.bash_profile"
+$update_root_profile_with_go_info = <<SCRIPT
+echo 'alias cde="cd #{$gopath}/src/github.com/codedellemc"' #{$to_root_profile}
+echo 'alias cdr="cd #{$gopath}/src/github.com/codedellemc/rexray"' #{$to_root_profile}
+echo export GOPATH=#{$gopath} #{$to_root_profile}
+echo export PATH=#{$gopath}/bin:/usr/local/go/bin:$PATH #{$to_root_profile}
+SCRIPT
+
+# init the environment variables used when building go source
+$build_env_vars = Hash[
+    "GOPATH" => $gopath.shellescape,
+    "PATH" => "#{$gopath.shellescape}/bin:/usr/local/go/bin:$PATH"
+]
+
+# node_dir returns the directory for a given node
+def node_dir(name)
+    return "#{File.dirname(__FILE__)}/.vagrant/machines/#{name}"
+end
+
+# is_first_up returns a flag indicating whether or not this is the first time
+# 'vagrant up' has been called on a specific node
+def is_first_up(name)
+  return Dir.glob("#{node_dir(name)}/aws/id").empty?
+end
+
+# init_aws initializes the aws config
+def init_aws(aws, name, instance_type)
+  aws.ami =                       $aws_ami
+  aws.access_key_id =             $aws_akey
+  aws.secret_access_key =         $aws_skey
+  aws.keypair_name =              $aws_kpnm
+  aws.region =                    $aws_regn
+  aws.availability_zone =         "#{$aws_regn}#{$aws_zone}"
+  aws.instance_type =             instance_type
+  aws.terminate_on_shutdown =     true
+  aws.unregister_elb_from_az =    true
+  aws.tags =                      {"Name" => name}
+end
+
+# init_node initializes the node information
+def init_node(node, name)
+  node.vm.hostname = name
+end
+
+# machine_id gets the aws machine id from a node name
+def machine_id(name)
+  id_file="#{File.dirname(__FILE__)}/.vagrant/machines/#{name}/aws/id"
+  return File.exists?(id_file) ? File.read(id_file) : nil
+end
+
+# aws cnxn to use to get machines' private ips for hostname resolution
+$aws_cnxn =   Fog::Compute.new(
+    :provider => :aws,
+    :region => $aws_regn,
+    :aws_access_key_id => $aws_akey,
+    :aws_secret_access_key => $aws_skey)
+
+Vagrant.configure("2") do |config|
+  config.vm.box =               "dummy"
+  config.vm.synced_folder ".", "/vagrant", disabled: true
+
+  config.ssh.username =         $ssh_user
+  config.ssh.private_key_path = $ssh_pkey
+
+  # don't modify the host, only guests
+  config.hostmanager.enabled =           true
+  config.hostmanager.manage_host =       false
+  config.hostmanager.manage_guest =      true
+  config.hostmanager.include_offline =   true
+  config.hostmanager.ignore_private_ip = false
+  config.hostmanager.ip_resolver = proc do |vm, resolving_vm|
+    if mid = machine_id(vm.name)
+      $aws_cnxn.servers.get(mid).private_ip_address
+    end
+  end
+
+  # configure node0
+  config.vm.define $node0_name do |node|
+
+    # initialize the node information
+    init_node node, $node0_name
+
+    # initialize the aws config
+    node.vm.provider :aws do |aws|
+      init_aws aws, $node0_name, $node0_itype
+    end
+
+    # only proceed if this is the first time 'vagrant up' has been called
+    # on this node
+    if is_first_up $node0_name
+
+      # update system
+      node.vm.provision "shell" do |s|
+        s.name =   "update-system"
+        s.inline = $provision_update_system
+      end
+
+      # install build tools
+      #node.vm.provision "shell" do |s|
+      #  s.name =   "build-tools"
+      #  s.inline = $provision_build_tools
+      #end
+
+      # copy the working copy of libstorage to the appropriate location in the
+      # node's gopath
+      node.vm.synced_folder "../../..", "#{$srcs}",
+        type: "rsync",
+        rsync__auto: false,
+        rsync__exclude: [
+            "/.git/",
+            "/vendor/",
+            "/glide.lock",
+            "/lss-darwin", "/lss-linux",
+            "/lsx-darwin", "/lsx-linux",
+            "/api/api_generated.go",
+            "/api/server/executors/bin/",
+            "/api/server/executors/executors_generated.go"]
+
+      # validate the copied sources
+      node.vm.provision "shell" do |s|
+        s.name =       "validate-copied-sources"
+        s.inline =     $validate_copied_sources
+      end
+
+      # provision docker - don't use docker provisioner - see
+      # https://github.com/mitchellh/vagrant/issues/7161
+      node.vm.provision "shell" do |s|
+        s.name =   "provision-docker"
+        s.inline = $provision_docker
+      end
+
+      # validate the docker installation
+      node.vm.provision "shell" do |s|
+        s.name =       "validate-docker"
+        s.privileged = false
+        s.inline =     $validate_docker
+      end
+
+      # provision golang
+      node.vm.provision "shell" do |s|
+        s.name   = "golang"
+        s.inline = $provision_golang
+      end
+
+      # build go-bindata
+      node.vm.provision "shell" do |s|
+        s.name   = "go-bindata"
+        s.env    = $build_env_vars
+        s.inline = $build_go_bindata
+      end
+
+      # update root profile with go info
+      node.vm.provision "shell" do |s|
+        s.name   = "update root profile"
+        s.inline = $update_root_profile_with_go_info
+      end
+
+      # build rex-ray
+      node.vm.provision "shell" do |s|
+        s.name   =     "build rex-ray"
+        s.env    =     $build_env_vars
+        s.inline =     $build_rexray
+      end
+
+      # copy rex-ray to /usr/bin
+      node.vm.provision "shell" do |s|
+        s.name   = "copy rex-ray"
+        s.inline = "cp #{$gopath.shellescape}/bin/rexray " +
+                   "#{$rexray_bin.shellescape}"
+      end
+
+      # write rex-ray config file
+      node.vm.provision "shell" do |s|
+        s.name       = "config rex-ray"
+        s.inline     = $write_rexray_server_config
+      end
+
+      # install rex-ray
+      node.vm.provision "shell" do |s|
+        s.name   = "rex-ray install"
+        s.inline = "rexray install"
+      end
+
+      # start rex-ray as a service
+      node.vm.provision "shell" do |s|
+        s.name   = "start rex-ray"
+        s.inline = "systemctl start rexray"
+      end
+
+      # list volume mapping with rex-ray to verify configuration
+      node.vm.provision "shell" do |s|
+        s.name       = "rex-ray volume ls"
+        s.privileged = false
+        s.inline     = "rexray volume ls"
+      end
+
+      # copy the node script
+      node.vm.provision              "file",
+                        source:      "#{$node0_texps}",
+                        destination: "$HOME/#{$node0_texps}"
+
+    end # if is_first_up node.vm.hostname
+
+    # execute node script
+    node.vm.provision "shell", run: "always" do |s|
+      s.name       = "execute-node-script"
+      s.privileged = false
+      s.inline     = "sudo su - #{$ssh_user} -c 'bash /home/#{$ssh_user}/#{$node0_texps}'"
+    end
+
+  end # configure node0
+
+  # configure node1
+  config.vm.define $node1_name, autostart: $autostart_clients do |node|
+
+    # initialize the node information
+    init_node node, $node1_name
+
+    # initialize the aws config
+    node.vm.provider :aws do |aws|
+      init_aws aws, $node1_name, $node1_itype
+    end
+
+    #node.vm.provision :hostmanager
+
+    # only proceed if this is the first time 'vagrant up' has been called
+    # on this node
+    if is_first_up $node1_name
+
+      # update system
+      node.vm.provision "shell" do |s|
+        s.name =   "update-system"
+        s.inline = $provision_update_system
+      end
+
+      # provision docker - don't use docker provisioner - see
+      # https://github.com/mitchellh/vagrant/issues/7161
+      node.vm.provision "shell" do |s|
+        s.name =   "provision-docker"
+        s.inline = $provision_docker
+      end
+
+      # validate the docker installation
+      node.vm.provision "shell" do |s|
+        s.name =       "validate-docker"
+        s.privileged = false
+        s.inline =     $validate_docker
+      end
+
+      # provision git
+      #node.vm.provision "shell" do |s|
+      #   s.name =   "provision-git"
+      #   s.inline = $provision_git
+      #end
+
+      # copy node0's private ssh key to node1 so node1 can ssh to node0 without
+      # being prompted for a password
+      node.vm.provision              "file",
+                        source:      "#{$ssh_pkey}".shellescape,
+                        destination: '"$HOME"/.ssh' +
+                                     "/#{$node0_name.shellescape}.key"
+
+      # scp rex-ray from node0 to node1
+      node.vm.provision "shell" do |s|
+        s.name =   "scp rexray"
+        s.inline = $copy_rexray
+      end
+
+      # write rex-ray config file
+      node.vm.provision "shell" do |s|
+        s.name       = "config rex-ray"
+        s.inline     = $write_rexray_client_config
+      end
+
+      # install rex-ray
+      node.vm.provision "shell" do |s|
+        s.name   = "rex-ray install"
+        s.inline = "rexray install"
+      end
+
+      # start rex-ray as a service
+      node.vm.provision "shell" do |s|
+        s.name   = "start rex-ray"
+        s.inline = "systemctl start rexray"
+      end
+
+      # list volume mapping with rex-ray to verify configuration
+      node.vm.provision "shell" do |s|
+        s.name       = "rex-ray volume ls"
+        s.privileged = false
+        s.inline     = "rexray volume ls"
+      end
+
+      # copy the node script
+      node.vm.provision              "file",
+                        source:      "#{$node1_texps}",
+                        destination: "$HOME/#{$node1_texps}"
+
+    end # if is_first_up node.vm.hostname
+
+    # execute node script
+    node.vm.provision "shell", run: "always" do |s|
+      s.name       = "execute-node-script"
+      s.privileged = false
+      s.inline     = "sudo su - #{$ssh_user} -c 'bash /home/#{$ssh_user}/#{$node1_texps}'"
+    end
+
+  end # configure node1
+
+  # configure node2
+  config.vm.define $node2_name, autostart: $autostart_clients do |node|
+
+    # initialize the node information
+    init_node node, $node2_name
+
+    # initialize the aws config
+    node.vm.provider :aws do |aws|
+      init_aws aws, $node2_name, $node2_itype
+    end
+
+    # only proceed if this is the first time 'vagrant up' has been called
+    # on this node
+    if is_first_up $node2_name
+
+      # update system
+      node.vm.provision "shell" do |s|
+        s.name =   "update-system"
+        s.inline = $provision_update_system
+      end
+
+      # provision docker - don't use docker provisioner - see
+      # https://github.com/mitchellh/vagrant/issues/7161
+      node.vm.provision "shell" do |s|
+        s.name =   "provision-docker"
+        s.inline = $provision_docker
+      end
+
+      # validate the docker installation
+      node.vm.provision "shell" do |s|
+        s.name =       "validate-docker"
+        s.privileged = false
+        s.inline =     $validate_docker
+      end
+
+      # provision git
+      #node.vm.provision "shell" do |s|
+      #   s.name =   "provision-git"
+      #   s.inline = $provision_git
+      #end
+
+      # copy node0's private ssh key to node2 so node2 can ssh to node0 without
+      # being prompted for a password
+      node.vm.provision              "file",
+                        source:      "#{$ssh_pkey}".shellescape,
+                        destination: '"$HOME"/.ssh' +
+                                     "/#{$node0_name.shellescape}.key"
+
+      # scp rex-ray from node0 to node2
+      node.vm.provision "shell" do |s|
+        s.name =   "scp rexray"
+        s.inline = $copy_rexray
+      end
+
+      # write rex-ray config file
+      node.vm.provision "shell" do |s|
+        s.name       = "config rex-ray"
+        s.inline     = $write_rexray_client_config
+      end
+
+      # install rex-ray
+      node.vm.provision "shell" do |s|
+        s.name   = "rex-ray install"
+        s.inline = "rexray install"
+      end
+
+      # start rex-ray as a service
+      node.vm.provision "shell" do |s|
+        s.name   = "start rex-ray"
+        s.inline = "systemctl start rexray"
+      end
+
+      # list volume mapping with rex-ray to verify configuration
+      node.vm.provision "shell" do |s|
+        s.name       = "rex-ray volume ls"
+        s.privileged = false
+        s.inline     = "rexray volume ls"
+      end
+
+      # copy the node script
+      node.vm.provision              "file",
+                        source:      "#{$node2_texps}",
+                        destination: "$HOME/#{$node2_texps}"
+
+    end # if is_first_up node.vm.hostname
+
+    # execute node script
+    node.vm.provision "shell", run: "always" do |s|
+      s.name       = "execute-node-script"
+      s.privileged = false
+      s.inline     = "sudo su - #{$ssh_user} -c 'bash /home/#{$ssh_user}/#{$node2_texps}'"
+    end
+
+  end # configure node2
+
+end
diff --git a/examples/ec2/vagrant/client0.sh b/examples/ec2/vagrant/client0.sh
new file mode 100644
index 00000000..e3346c2a
--- /dev/null
+++ b/examples/ec2/vagrant/client0.sh
@@ -0,0 +1,23 @@
+#!/bin/sh
+
+dir=/tmp/rexray
+src=/go/src
+nme=build-rexray
+img=golang:1.7.1
+pkg=github.com/codedellemc/rexray
+srcpkg=$src/$pkg
+cmd="/sbin/init -D"
+
+function b {
+    mkdir -p $dir && cd $dir
+    git clone https://$pkg .
+    docker run -d -w $srcpkg -v $1:/go -v $dir:$srcpkg --name $nme $img $cmd
+    docker exec -i $nme make
+    sudo chown $2:$2 /var/lib/rexray/volumes/$1/data/bin/rexray
+    sudo cp /var/lib/rexray/volumes/$1/data/bin/rexray .
+    docker stop $nme && docker rm $nme
+}
+
+b builds $(whoami)
+
+if [ ! -x "rexray" ]; then exit 1; fi
diff --git a/examples/ec2/vagrant/client1.sh b/examples/ec2/vagrant/client1.sh
new file mode 100644
index 00000000..c41eae82
--- /dev/null
+++ b/examples/ec2/vagrant/client1.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+
+function b {
+    docker run -d -v $1:/go --name bb busybox tail -f /dev/null
+    sudo cp /var/lib/rexray/volumes/$1/data/bin/rexray .
+    docker stop bb && docker rm bb
+    sudo rexray volume rm --volumeid \
+        $(rexray volume ls --volumename $1 -l error | \
+            grep 'id:' | \
+            awk '{print $2}')
+}
+
+b builds
+
+if [ ! -x "rexray" ]; then exit 1; fi
diff --git a/examples/ec2/vagrant/server.sh b/examples/ec2/vagrant/server.sh
new file mode 100644
index 00000000..4699c72a
--- /dev/null
+++ b/examples/ec2/vagrant/server.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+# create new docker volumes named builds
+docker volume create --driver rexray --name builds