vagrant-digitalocean 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# TODO switch on release
+gem "vagrant", :git => "git://github.com/mitchellh/vagrant.git"
+
+# Specify your gem's dependencies in vagrant-digitalocean.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 John Bender
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,72 @@
+# Vagrant Digital Ocean
+
+`vagrant-digitalocean` is a provider plugin for Vagrant that allows the management of [Digital Ocean](https://www.digitalocean.com/) droplets (instances).
+
+## INSECURE
+
+As of this writing there is no support for custom keys on the droplets created by this provider. That means anyone with the vagrant keys and the IP of your droplet has root on your machine.
+
+*Do not use this plugin with sensitive projects*
+
+## Status
+
+As of this writing the provider implementation is geared entirely toward a development workflow. That is, Digital Ocean droplets are meant to be used as a replacement for VirtualBox in a server developers workflow.
+
+## Supported Guests/Hosts
+
+This project is primarily to support my workflow wich currently only involves Ubuntu and CentOS. It's likely that any unix host will work but I've not tested it. Guests require porting of the nfs, chef, and sudo setup scripts.
+
+Hosts:
+
+* Ubuntu 12.04
+
+Guests:
+
+* Ubuntu 12.04
+* CentOS 6
+
+## Supported Provisioners
+
+The shell provisioner is supported by default but other provisioners require bootstrapping on the server. Chef is currently the only supported provisioner. Adding support for puppet and others requires adding the install scripts.
+
+## Installation
+
+Installation is performed in the prescribed manner for Vagrant 1.1 plugins.
+
+    vagrant plugin install vagrant-digitalocean
+
+In addition to installing the plugin the default box associated with the provider needs to be installed.
+
+    vagrant box add digital_ocean https://raw.github.com/johnbender/vagrant-digitalocean/master/box/digital_ocean.box
+
+## Usage
+
+To use the Digital Ocean provider you will need to visit the [API access page](https://www.digitalocean.com/api_access) to retrieve the client identifier and API key associated with your account.
+
+### Config
+
+Supported provider configuration options are as follows:
+
+```ruby
+Vagrant.configure("2") do |config|
+  config.vm.box = "digital_ocean"
+
+  config.vm.provider :digital_ocean do |vm|
+    vm.client_id = ENV["DO_CLIENT_ID"]
+    vm.api_key = ENV["DO_API_KEY"]
+    vm.image = "Ubuntu 12.04 x32 Server"
+    vm.region = "New York 1"
+    vm.size = "512MB"
+  end
+end
+```
+
+Note that the example contains the default value. The client identifier and API key are pulled from the environment and the other values are the string representations of the droplet configuration options as provided by the [Digital Ocean API](https://www.digitalocean.com/api).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+namespace "dev" do
+  task "build" do
+    system "bash bin/build.sh"
+  end
+end

data/bin/build.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+# build the gem
+gem build *.gemspec
+
+# make the gem available for installation as a vagrant plugin
+gem install *.gem
+
+# make sure bsdtar is installed
+if ! `which bsdtar > /dev/null`; then
+  echo "!! Install bsdtar"
+  exit 1
+fi
+
+# install the plugin
+vagrant plugin install vagrant-digitalocean
+
+# move into the dummy box dir
+cd box
+
+# create the dummy box
+tar cvzf digital_ocean.box ./metadata.json
+
+# remove an old version of the dummy box
+if `vagrant box list | grep -q digital_ocean`; then
+  vagrant box remove digital_ocean digital_ocean
+fi
+
+# add the new version of the dummy box
+vagrant box add digital_ocean digital_ocean.box
+
+# back out of the box dir
+cd -

data/box/Vagrantfile

@@ -0,0 +1,15 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "digital_ocean"
+  config.vm.synced_folder ".", "/vagrant", :nfs => true
+
+  config.vm.provider :digital_ocean do |vm|
+    vm.client_id = ENV["DO_CLIENT_ID"]
+    vm.api_key = ENV["DO_API_KEY"]
+    vm.image = "Ubuntu 12.04 x32 Server"
+    vm.region = "New York 1"
+    vm.size = "512MB"
+  end
+end

data/box/metadata.json

@@ -0,0 +1,3 @@
+{
+  "provider": "digital_ocean"
+}

data/lib/vagrant-digitalocean/action.rb

@@ -0,0 +1,77 @@
+require "vagrant-digitalocean/actions/destroy"
+require "vagrant-digitalocean/actions/read_state"
+require "vagrant-digitalocean/actions/setup_provisioner"
+require "vagrant-digitalocean/actions/setup_nfs"
+require "vagrant-digitalocean/actions/setup_sudo"
+require "vagrant-digitalocean/actions/setup_user"
+require "vagrant-digitalocean/actions/create"
+
+module VagrantPlugins
+  module DigitalOcean
+    class Action
+      # Include the built-in callable actions, eg SSHExec
+      include Vagrant::Action::Builtin
+
+      def action(name)
+        send(name)
+      end
+
+      def destroy
+        return Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Actions::Destroy
+        end
+      end
+
+      def read_state
+        return Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use Actions::ReadState
+        end
+      end
+
+      def ssh
+        return Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+          builder.use SSHExec
+        end
+      end
+
+      def provision
+        return Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+
+          # sort out sudo for redhat, etc
+          builder.use Actions::SetupSudo
+
+          # sort out sudo for redhat, etc
+          builder.use Actions::SetupUser
+
+          # execute provisioners
+          builder.use Provision
+
+          # setup provisioners, comes after Provision to force nfs folders
+          builder.use Actions::SetupProvisioner
+        end
+      end
+
+      def up
+        # TODO figure out when to exit if the vm is created
+        return Vagrant::Action::Builder.new.tap do |builder|
+          builder.use ConfigValidate
+
+          # build the vm if necessary
+          builder.use Actions::Create
+
+          builder.use provision
+
+          # set the host and remote ips for NFS
+          builder.use Actions::SetupNFS
+
+          # mount the nfs folders which should be all shared folders
+          builder.use NFS
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/actions/create.rb

@@ -0,0 +1,103 @@
+require "vagrant-digitalocean/helpers/client"
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class Create
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app, @env = app, env
+          @client = Helpers::Client.new
+          @translator = Helpers::Translator.new("actions.create")
+        end
+
+        def call(env)
+          # if the machine state is created skip
+          if env[:machine].state.id == :active
+            env[:ui].info @translator.t("skip")
+            return @app.call(env)
+          end
+
+          # TODO check the content of the key to see if it's changed
+          # TODO use the directory / vm name to qualify the key name
+          begin
+            ssh_key_id = @client
+              .request("/ssh_keys/")
+              .find_id(:ssh_keys, :name => "Vagrant Insecure")
+          rescue Errors::ResultMatchError
+            env[:ui].info @translator.t("create_key")
+
+            key = DigitalOcean.vagrant_key
+
+            result = @client.request("/ssh_keys/new", {
+              :name => "Vagrant Insecure",
+              :ssh_pub_key => key
+            })
+
+            ssh_key_id = result["ssh_key"]["id"]
+          end
+
+          size_id = @client
+            .request("/sizes")
+            .find_id(:sizes, :name => env[:machine].provider_config.size)
+
+          image_id = @client
+            .request("/images", { :filter => "global" })
+            .find_id(:images, :name => env[:machine].provider_config.image)
+
+          region_id = @client
+            .request("/regions")
+            .find_id(:regions, :name => env[:machine].provider_config.region)
+
+          env[:ui].info @translator.t("create_droplet")
+
+          result = @client.request("/droplets/new", {
+            :size_id => size_id,
+            :region_id => region_id,
+            :image_id => image_id,
+            # TODO use the current directory name as a post fix
+            :name => "vagrant",
+            :ssh_key_ids => ssh_key_id
+          })
+
+          # assign the machine id for reference in other commands
+          env[:machine].id = result["droplet"]["id"]
+
+          env[:ui].info @translator.t("wait_active")
+
+          retryable(:tries => 30, :sleep => 10) do
+            # If we're interrupted don't worry about waiting
+            next if env[:interrupted]
+
+            # Wait for the server to be ready
+            raise "not ready" if env[:machine].state.id != :active
+          end
+
+          # signal that the machine has just been created, used in ReadState
+          env[:machine_just_created] = true
+
+          @app.call(env)
+        end
+
+        # Both the recover and terminate are stolen almost verbatim from
+        # the Vagrant AWS provider up action
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].state.id != :not_created
+            terminate(env)
+          end
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(ActionDispatch.new.destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/actions/destroy.rb

@@ -0,0 +1,44 @@
+require "vagrant-digitalocean/helpers/client"
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class Destroy
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app, @env = app, env
+          @client = Helpers::Client.new
+          @translator = Helpers::Translator.new("actions.destroy")
+        end
+
+        def call(env)
+          # TODO remove the key associated with this machine
+          if [:active, :new].include?(env[:machine].state.id)
+            env[:ui].info @translator.t("destroying")
+            result = @client.request("/droplets/#{env[:machine].id}/destroy")
+
+            env[:ui].info @translator.t("wait_off")
+
+            retryable(:tries => 30, :sleep => 10) do
+              # If we're interrupted don't worry about waiting
+              next if env[:interrupted]
+
+              # Wait for the server to be ready
+              raise "not off" if env[:machine].state.id != :off
+            end
+          else
+            env[:ui].info @translator.t("not_active_or_new")
+          end
+
+          # make sure to remove the export when the machine is destroyed
+          # private in some hosts and requires a send
+          env[:ui].info @translator.t("clean_nfs")
+          env[:host].send(:nfs_cleanup, env[:machine].id)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/actions/read_state.rb

@@ -0,0 +1,31 @@
+require "vagrant-digitalocean/helpers/client"
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class ReadState
+        def initialize(app, env)
+          @app, @env = app, env
+          @client = Helpers::Client.new
+        end
+
+        def call(env)
+          # If we have a machine id ask the api what the state is
+          if env[:machine].id
+            droplet = @client.request("/droplets/#{env[:machine].id}")["droplet"]
+
+            env[:machine_state] = droplet
+          end
+
+          # no id signals that the machine hasn't yet been created
+          env[:machine_state] ||= {"status" => :not_created}
+
+          # TODO there has to be a better way, see UP for when
+          # :machine_just_created is set
+          env[:machine_state][:just_created] = env[:machine_just_created]
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/actions/setup_nfs.rb

@@ -0,0 +1,55 @@
+require "socket"
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class SetupNFS
+        include Helpers::File
+
+        def initialize(app, env)
+          @app, @env = app, env
+          @translator = Helpers::Translator.new("actions.setup_nfs")
+        end
+
+        def call(env)
+          # set the nfs machine ip
+          env[:nfs_machine_ip] = env[:machine].provider.ssh_info[:host]
+          env[:ui].info @translator.t("machine_ip", :ip => env[:nfs_machine_ip])
+
+          # get the host ip from the local adapters
+          env[:nfs_host_ip] = determine_host_ip.ip_address
+          env[:ui].info @translator.t("host_ip", :ip => env[:nfs_host_ip])
+
+          # make sure the nfs server is setup
+          env[:ui].info @translator.t("install")
+          env[:machine].communicate.execute(nfs_install(env[:machine].guest))
+
+          vm = env[:machine].config.vm
+
+          # force all shard folders to use nfs
+          env[:ui].warn @translator.t("force_shared_folders")
+          folders = vm.synced_folders.keys.each do |key|
+            vm.synced_folders[key][:nfs] = true
+          end
+
+          @app.call(env)
+        end
+
+        # http://stackoverflow.com/questions/5029427/ruby-get-local-ip-nix
+        # TODO this is currently *nix only according to the above post
+        def determine_host_ip
+          Socket.ip_address_list.detect do |intf|
+            intf.ipv4? &&
+              !intf.ipv4_loopback? &&
+              !intf.ipv4_multicast? &&
+              !intf.ipv4_private?
+          end
+        end
+
+        def nfs_install(guest)
+          read_script("nfs", guest)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/actions/setup_provisioner.rb

@@ -0,0 +1,30 @@
+require "vagrant-digitalocean/helpers/file"
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class SetupProvisioner
+        include Helpers::File
+
+        def initialize(app, env)
+          @app, @env = app, env
+          @translator = Helpers::Translator.new("actions.setup_provisioner")
+        end
+
+        def call(env)
+          # TODO prevent setup when no chef provisioner declared
+          # TODO catch ssh failure and report back on install issues
+          # TODO first check to see if it's installed and then skip the info
+          env[:ui].info @translator.t("install", :provisioner => "chef-solo")
+          env[:machine].communicate.execute(chef_install(env[:machine].guest))
+
+          @app.call(env)
+        end
+
+        def chef_install(guest)
+          read_script("chef", guest)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/actions/setup_sudo.rb

@@ -0,0 +1,27 @@
+require "vagrant-digitalocean/helpers/file"
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class SetupSudo
+        include Helpers::File
+
+        def initialize(app, env)
+          @app, @env = app, env
+          @translator = Helpers::Translator.new("actions.setup_sudo")
+        end
+
+        def call(env)
+          env[:ui].info @translator.t("exec")
+          env[:machine].communicate.execute(fix_sudo(env[:machine].guest))
+
+          @app.call(env)
+        end
+
+        def fix_sudo(guest)
+          read_script("sudo", guest, false)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/actions/setup_user.rb

@@ -0,0 +1,59 @@
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class SetupUser
+        def initialize(app, env)
+          @app, @env = app, env
+          @translator = Helpers::Translator.new("actions.setup_user")
+        end
+
+        def call(env)
+          # create the user, set the password to username, add to sudoers
+          # NOTE assumes group with username is created with useradd
+          env[:ui].info @translator.t("create", :user => user)
+          env[:machine].communicate.execute(<<-BASH)
+            if ! (grep #{user} /etc/passwd); then
+              useradd -m -s /bin/bash #{user};
+              echo -e "#{user}\n#{user}" | (passwd #{user});
+            fi
+          BASH
+
+          env[:ui].info @translator.t("sudo", :user => user)
+          env[:machine].communicate.execute(<<-BASH)
+            if ! (grep #{user} /etc/sudoers); then
+              echo "#{user} ALL=(ALL:ALL) ALL" >> /etc/sudoers;
+            fi
+          BASH
+
+          # create the .ssh directory in the users home
+          env[:machine].communicate.execute("su #{user} -c 'mkdir -p ~/.ssh'")
+
+          env[:ui].info @translator.t("key")
+          # add the specified key to the authorized keys file
+          env[:machine].communicate.execute(<<-BASH)
+            if ! grep '#{pub_key}' /home/#{user}/.ssh/authorized_keys; then
+              echo '#{pub_key}' >> /home/#{user}/.ssh/authorized_keys;
+            fi
+          BASH
+
+          env[:machine_state] ||= {}
+          env[:machine_state][:user] = user
+
+          @app.call(env)
+        end
+
+        private
+
+        # TODO use a config option to allow for alternate users
+        def user
+          "vagrant"
+        end
+
+        # TODO allow for a custom key to specified
+        def pub_key
+          @key ||= DigitalOcean.vagrant_key
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/config.rb

@@ -0,0 +1,31 @@
+module VagrantPlugins
+  module DigitalOcean
+    class Config < Vagrant.plugin("2", :config)
+      attr_accessor :client_id, :api_key, :image, :region, :size
+
+      def initialize
+        @client_id       = UNSET_VALUE
+        @api_key         = UNSET_VALUE
+        @image           = UNSET_VALUE
+        @region          = UNSET_VALUE
+        @size            = UNSET_VALUE
+      end
+
+      def finalize!
+        @client_id = ENV["DO_CLIENT_ID"] if @client_id == UNSET_VALUE
+        @api_key   = ENV["DO_API_KEY"] if @api_key == UNSET_VALUE
+        @image     = "Ubuntu 12.04 x32 Server" if @image == UNSET_VALUE
+        @region    = "New York 1" if @region == UNSET_VALUE
+        @size      = "512MB" if @size == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+        errors << "Client ID required" if !@client_id
+        errors << "API Key required" if !@api_key
+
+        { "Digital Ocean Provider" => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/errors.rb

@@ -0,0 +1,23 @@
+require "vagrant"
+
+module VagrantPlugins
+  module DigitalOcean
+    module Errors
+      class DigitalOceanError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_digital_ocean.errors")
+      end
+
+      class APIStatusError < DigitalOceanError
+        error_key(:api_status)
+      end
+
+      class JSONError < DigitalOceanError
+        error_key(:json)
+      end
+
+      class ResultMatchError < DigitalOceanError
+        error_key(:result_match)
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/helpers/client.rb

@@ -0,0 +1,48 @@
+require "vagrant-digitalocean/helpers/result"
+require "faraday"
+require "json"
+
+module VagrantPlugins
+  module DigitalOcean
+    module Helpers
+      class Client
+        def initialize
+          @client = Faraday.new(:url => "https://api.digitalocean.com/")
+        end
+
+        def request(path, params = {})
+          # create the key
+          result = @client.get(path, params = params.merge({
+            :client_id => ENV["DO_CLIENT_ID"],
+            :api_key => ENV["DO_API_KEY"]
+          }))
+
+          # remove the api key in case an error gets dumped to the console
+          params[:api_key] = "REMOVED"
+
+          begin
+            body = JSON.parse(result.body)
+          rescue JSON::ParserError => e
+            raise(Errors::JSONError, {
+              :message => e.message,
+              :path => path,
+              :params => params,
+              :response => result.body
+            })
+          end
+
+          if body["status"] != "OK"
+            raise(Errors::APIStatusError, {
+              :path => path,
+              :params => params,
+              :status => body["status"],
+              :response => body.inspect
+            })
+          end
+
+          Result.new(body)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/helpers/file.rb

@@ -0,0 +1,41 @@
+
+
+module VagrantPlugins
+  module DigitalOcean
+    module Helpers
+      module File
+        # TODO the optional exceptions are clumsy
+        def read_file(relative_path, except = true)
+          content = ""
+          path = ::File.join(DigitalOcean.source_root, relative_path)
+
+          begin
+            ::File.open(path) do |file|
+              content = file.read
+            end
+          rescue Errno::ENOENT => e
+            # ignore the missing file if except is false
+            raise(e) if except
+          end
+
+          content
+        end
+
+        # TODO the optional exceptions are clumsy
+        # read a script and match it to the guest operating system
+        def read_script(dir, guest, except = true)
+          script_dir = ::File.join("scripts", dir)
+          guest_name = guest.class.to_s
+
+          if guest_name =~ /Debian/ || guest_name =~ /Ubuntu/
+            read_file(::File.join(script_dir, "debian.sh"), except)
+          elsif guest_name =~ /RedHat/
+            read_file(::File.join(script_dir, "redhat.sh"), except)
+          else
+            raise "unsupported guest operating system" if except
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/helpers/result.rb

@@ -0,0 +1,40 @@
+module VagrantPlugins
+  module DigitalOcean
+    module Helpers
+      class Result
+        def initialize(body)
+          @result = body
+        end
+
+        def [](key)
+          @result[key.to_s]
+        end
+
+        def find_id(sub_obj, search)
+          find(sub_obj, search)["id"]
+        end
+
+        def find(sub_obj, search)
+          key = search.keys.first
+          value = search[key].to_s
+          key = key.to_s
+
+          result = @result[sub_obj.to_s].inject(nil) do |result, obj|
+            obj[key] == value ? obj : result
+          end
+
+          result || error(sub_obj, key, value)
+        end
+
+        def error(sub_obj, key, value)
+          raise(Errors::ResultMatchError, {
+           :key => key,
+           :value => value,
+           :collection_name => sub_obj.to_s,
+           :sub_obj => @result[sub_obj.to_s]
+          })
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/helpers/translator.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module DigitalOcean
+    module Helpers
+      class Translator
+        def self.plugin_namespace=(val)
+          @@plugin_namespace = val
+        end
+
+        def initialize(namespace)
+          @namespace = namespace
+        end
+
+        def t(keys, opts = {})
+          value = I18n.t("#{@@plugin_namespace}.#{@namespace}.#{keys}", opts)
+          opts[:progress] == false ? value : value + " ..."
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/plugin.rb

@@ -0,0 +1,30 @@
+require "i18n"
+require "vagrant-digitalocean/helpers/translator"
+
+module VagrantPlugins
+  module DigitalOcean
+    class Plugin < Vagrant.plugin("2")
+      name "DigitalOcean"
+      description <<-DESC
+        This plugin installs a provider that allows Vagrant to manage
+        machines using DigitalOcean's API.
+      DESC
+
+      config(:digital_ocean, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:digital_ocean) do
+        # Return the provider
+        require_relative "provider"
+
+        I18n.load_path << File.expand_path("locales/en.yml", DigitalOcean.source_root)
+        I18n.reload!
+        Helpers::Translator.plugin_namespace = "vagrant_digital_ocean"
+
+        Provider
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/provider.rb

@@ -0,0 +1,84 @@
+require "vagrant-digitalocean/action"
+
+module VagrantPlugins
+  module DigitalOcean
+    class Provider < Vagrant.plugin("2", :provider)
+      # Initialize the provider to represent the given machine.
+      #
+      # @param [Vagrant::Machine] machine The machine that this provider
+      #   is responsible for.
+      def initialize(machine)
+        @machine = machine
+        @dispatch = Action.new
+      end
+
+      # This should return an action callable for the given name.
+      #
+      # @param [Symbol] name Name of the action.
+      # @return [Object] A callable action sequence object, whether it
+      #   is a proc, object, etc.
+      def action(name)
+        return @dispatch.action(name) if @dispatch.respond_to?(name)
+        nil
+      end
+
+      # This method is called if the underying machine ID changes. Providers
+      # can use this method to load in new data for the actual backing
+      # machine or to realize that the machine is now gone (the ID can
+      # become `nil`). No parameters are given, since the underlying machine
+      # is simply the machine instance given to this object. And no
+      # return value is necessary.
+      def machine_id_changed
+      end
+
+      # This should return a hash of information that explains how to
+      # SSH into the machine. If the machine is not at a point where
+      # SSH is even possible, then `nil` should be returned.
+      #
+      # The general structure of this returned hash should be the
+      # following:
+      #
+      #     {
+      #       :host => "1.2.3.4",
+      #       :port => "22",
+      #       :username => "mitchellh",
+      #       :private_key_path => "/path/to/my/key"
+      #     }
+      #
+      # **Note:** Vagrant only supports private key based authenticatonion,
+      # mainly for the reason that there is no easy way to exec into an
+      # `ssh` prompt with a password, whereas we can pass a private key
+      # via commandline.
+      #
+      # @return [Hash] SSH information. For the structure of this hash
+      #   read the accompanying documentation for this method.
+      def ssh_info
+        state = @machine.action("read_state")[:machine_state]
+
+        return nil if state["status"] == :not_created
+
+        return {
+          :host => state["ip_address"],
+          :port => "22",
+          :username => "root",
+          :private_key_path => Vagrant.source_root + "keys/vagrant"
+        }
+      end
+
+      # This should return the state of the machine within this provider.
+      # The state must be an instance of {MachineState}. Please read the
+      # documentation of that class for more information.
+      #
+      # @return [MachineState]
+      def state
+        state_id = @machine.action("read_state")[:machine_state]["status"].to_sym
+
+        # TODO provide an actual description
+        long = short = state_id.to_s
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+    end
+  end
+end

data/lib/vagrant-digitalocean/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Digitalocean
+    VERSION = "0.0.1"
+  end
+end

data/lib/vagrant-digitalocean.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+require "vagrant-digitalocean/version"
+require "vagrant-digitalocean/plugin"
+require "vagrant-digitalocean/errors"
+
+module VagrantPlugins
+  module DigitalOcean
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+    end
+
+    def self.vagrant_key
+      file = File.open(Vagrant.source_root + "keys/vagrant.pub")
+      key = file.read
+      file.close
+      key
+    end
+  end
+end

data/locales/en.yml

@@ -0,0 +1,53 @@
+en:
+  vagrant_digital_ocean:
+    errors:
+      api_status: |-
+        There was an issue with the request made to the Digital Ocean API at:
+
+        Path: %{path}
+        URI Params: %{params}
+
+        The response status from the API was:
+
+        Status: %{status}
+        Response: %{response}
+      :json: |-
+        There was an issue with the JSON response from the Digital Ocean API at:
+
+        Path: %{path}
+        URI Params: %{params}
+
+        The response JSON from the API was:
+
+        Response: %{response}
+      :result_match: |-
+        The result collection for %{collection_name}:
+
+        %{sub_obj}
+
+        Contained no object with the value "%{value}" for the the key "%{key}".
+        Please ensure that the configured value exists in the collection.
+    actions:
+      create:
+        skip: "Droplet is active, skipping creation"
+        create_key: "Adding key client account"
+        create_droplet: "Creating the droplet"
+        wait_active: "Waiting for the droplet to become active (>= 1 min)"
+      destroy:
+        destroying: "Destroying droplet"
+        not_active_or_new: "Droplet not in the `active` or `new` state"
+        clean_nfs: "Cleaning up NFS exports, may require sudo password"
+        wait_off: "Waiting for the droplet to be destroyed"
+      setup_sudo:
+        exec: "Making alterations to the sudoers file where necessary"
+      setup_nfs:
+        machine_ip: "Droplet IP: %{ip}"
+        host_ip: "Host IP: %{ip}"
+        install: "Installing NFS on the droplet"
+        force_shared_folders: "Forcing shared folders to use NFS where necessary"
+      setup_provisioner:
+        install: "Installing provisioner: %{provisioner} (>= 2 min)"
+      setup_user:
+        create: "Creating user '%{user}' and setting password"
+        sudo: "Enabling sudo for user '%{user}'"
+        key: "Adding public key to authorized_keys"

data/scripts/chef/debian.sh

@@ -0,0 +1,20 @@
+# cargo culted from OpsCode's guide at http://wiki.opscode.com/display/chef/Installing+Chef+Client+on+Ubuntu+or+Debian
+# skip if the keys are present
+if (which chef-solo); then exit 0; fi
+
+# install the basics
+apt-get install -y wget lsb-release;
+
+# add the opscode repo to the sources
+echo "deb http://apt.opscode.com/ `lsb_release -cs`-0.10 main" | sudo tee /etc/apt/sources.list.d/opscode.list;
+
+# setup the gpg key
+mkdir -p /etc/apt/trusted.gpg.d;
+gpg --keyserver keys.gnupg.net --recv-keys 83EF826A;
+gpg --export packages@opscode.com | sudo tee /etc/apt/trusted.gpg.d/opscode-keyring.gpg > /dev/null;
+
+# update the repo to make sure that the package is available from the repo
+apt-get update;
+
+# avoid server url popup
+echo "chef chef/chef_server_url string https://api.opscode.com/organizations/vagrant" | debconf-set-selections && apt-get install chef -y;

data/scripts/chef/redhat.sh

@@ -0,0 +1,21 @@
+# cargo culted from OpsCode's guide at http://wiki.opscode.com/display/chef/Installing+Chef+Client+on+CentOS
+# skip if chef-solo is present
+if (which chef-solo); then exit 0; fi
+
+# add the repo for ruby and other deps
+rpm -Uvh http://rbel.frameos.org/rbel6
+
+# install the pre-reqs
+yum install -y ruby ruby-devel ruby-ri ruby-rdoc ruby-shadow gcc gcc-c++ automake autoconf make curl dmidecode
+
+# install rubygems
+if ! (which gem); then
+  cd /tmp
+  curl -O http://production.cf.rubygems.org/rubygems/rubygems-1.8.10.tgz
+  tar zxf rubygems-1.8.10.tgz
+  cd rubygems-1.8.10
+  ruby setup.rb --no-format-executable
+fi
+
+# install chef via rubygems
+gem install chef --no-ri --no-rdoc

data/scripts/nfs/debian.sh

@@ -0,0 +1,4 @@
+# install the nfs-kernel server
+if !(which nfsstat); then
+  apt-get install -y nfs-kernel-server;
+fi

data/scripts/nfs/redhat.sh

@@ -0,0 +1,11 @@
+if (service --status-all | grep nfs); then exit 0; fi;
+
+# install the nfs-kernel server
+yum install -y nfs-utils nfs-utils-lib;
+
+# add to startup
+chkconfig nfs on;
+
+# make sure it's on after the install
+service rpcbind start;
+service nfs start;

data/scripts/sudo/redhat.sh

@@ -0,0 +1,2 @@
+# fix the default sudoers file to prevent the tty requirement
+sed -i'.bk' -e 's/\(Defaults\s\+requiretty\)/# \1/' /etc/sudoers

data/vagrant-digitalocean.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'vagrant-digitalocean/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "vagrant-digitalocean"
+  gem.version       = VagrantPlugins::Digitalocean::VERSION
+  gem.authors       = ["John Bender"]
+  gem.email         = ["john.m.bender@gmail.com"]
+  gem.description   = %q{Enables Vagrant to manage Digital Ocean droplets}
+  gem.summary       = gem.description
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "faraday", "~> 0.8.6"
+  gem.add_dependency "json", "~> 1.6.6"
+  gem.add_dependency "log4r", "~> 1.1.9"
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-digitalocean
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- John Bender
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.6
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.6
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+description: Enables Vagrant to manage Digital Ocean droplets
+email:
+- john.m.bender@gmail.com
+executables:
+- build.sh
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/build.sh
+- box/Vagrantfile
+- box/digital_ocean.box
+- box/metadata.json
+- lib/vagrant-digitalocean.rb
+- lib/vagrant-digitalocean/action.rb
+- lib/vagrant-digitalocean/actions/create.rb
+- lib/vagrant-digitalocean/actions/destroy.rb
+- lib/vagrant-digitalocean/actions/read_state.rb
+- lib/vagrant-digitalocean/actions/setup_nfs.rb
+- lib/vagrant-digitalocean/actions/setup_provisioner.rb
+- lib/vagrant-digitalocean/actions/setup_sudo.rb
+- lib/vagrant-digitalocean/actions/setup_user.rb
+- lib/vagrant-digitalocean/config.rb
+- lib/vagrant-digitalocean/errors.rb
+- lib/vagrant-digitalocean/helpers/client.rb
+- lib/vagrant-digitalocean/helpers/file.rb
+- lib/vagrant-digitalocean/helpers/result.rb
+- lib/vagrant-digitalocean/helpers/translator.rb
+- lib/vagrant-digitalocean/plugin.rb
+- lib/vagrant-digitalocean/provider.rb
+- lib/vagrant-digitalocean/version.rb
+- locales/en.yml
+- scripts/chef/debian.sh
+- scripts/chef/redhat.sh
+- scripts/nfs/debian.sh
+- scripts/nfs/redhat.sh
+- scripts/sudo/redhat.sh
+- vagrant-digitalocean.gemspec
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Enables Vagrant to manage Digital Ocean droplets
+test_files: []