vagrant-chassis-digitalocean 1.0.0

data/lib/vagrant-chassis-digitalocean/commands/rebuild.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module VagrantPlugins
+  module DigitalOcean
+    module Commands
+      class Rebuild < Vagrant.plugin('2', :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant rebuild [vm-name]'
+          end
+
+          argv = parse_options(opts)
+
+          with_target_vms(argv) do |machine|
+            machine.action(:rebuild)
+          end
+
+          0
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-chassis-digitalocean/config.rb

@@ -0,0 +1,62 @@
+module VagrantPlugins
+  module DigitalOcean
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :client_id
+      attr_accessor :api_key
+      attr_accessor :image
+      attr_accessor :region
+      attr_accessor :size
+      attr_accessor :private_networking
+      attr_accessor :backups_enabled
+      attr_accessor :ca_path
+      attr_accessor :ssh_key_name
+      attr_accessor :setup
+
+      alias_method :setup?, :setup
+
+      def initialize
+        @client_id          = UNSET_VALUE
+        @api_key            = UNSET_VALUE
+        @image              = UNSET_VALUE
+        @region             = UNSET_VALUE
+        @size               = UNSET_VALUE
+        @private_networking = UNSET_VALUE
+        @backups_enable     = UNSET_VALUE
+        @ca_path            = UNSET_VALUE
+        @ssh_key_name       = UNSET_VALUE
+        @setup              = 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.3 x64' if @image == UNSET_VALUE
+        @region             = 'New York 2' if @region == UNSET_VALUE
+        @size               = '512MB' if @size == UNSET_VALUE
+        @private_networking = false if @private_networking == UNSET_VALUE
+        @backups_enabled    = false if @backups_enabled == UNSET_VALUE
+        @ca_path            = nil if @ca_path == UNSET_VALUE
+        @ssh_key_name       = 'Vagrant' if @ssh_key_name == UNSET_VALUE
+        @setup              = true if @setup == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = []
+        errors << I18n.t('vagrant_digital_ocean.config.client_id') if !@client_id
+        errors << I18n.t('vagrant_digital_ocean.config.api_key') if !@api_key
+
+        key = machine.config.ssh.private_key_path
+				key = key[0] if key.is_a?(Array)
+        if !key
+          errors << I18n.t('vagrant_digital_ocean.config.private_key')
+        elsif !File.file?(File.expand_path("#{key}.pub", machine.env.root_path))
+          errors << I18n.t('vagrant_digital_ocean.config.public_key', {
+            :key => "#{key}.pub"
+          })
+        end
+
+        { 'Digital Ocean Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-chassis-digitalocean/errors.rb

@@ -0,0 +1,37 @@
+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
+
+      class CertificateError < DigitalOceanError
+        error_key(:certificate)
+      end
+
+      class LocalIPError < DigitalOceanError
+        error_key(:local_ip)
+      end
+
+      class PublicKeyError < DigitalOceanError
+        error_key(:public_key)
+      end
+
+      class RsyncError < DigitalOceanError
+        error_key(:rsync)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'vagrant-digitalocean/helpers/result'
+require 'faraday'
+require 'json'
+
+module VagrantPlugins
+  module DigitalOcean
+    module Helpers
+      module Client
+        def client
+          @client ||= ApiClient.new(@machine)
+        end
+      end
+
+      class ApiClient
+        include Vagrant::Util::Retryable
+
+        def initialize(machine)
+					@logger = Log4r::Logger.new('vagrant::digitalocean::apiclient')
+          @config = machine.provider_config
+          @client = Faraday.new({
+            :url => 'https://api.digitalocean.com/',
+            :ssl => {
+              :ca_file => @config.ca_path
+            }
+          })
+        end
+
+        def request(path, params = {})
+          begin
+						@logger.info "Request: #{path}"
+            result = @client.get(path, params = params.merge({
+              :client_id => @config.client_id,
+              :api_key => @config.api_key
+            }))
+          rescue Faraday::Error::ConnectionFailed => e
+            # TODO this is suspect but because farady wraps the exception
+            #      in something generic there doesn't appear to be another
+            #      way to distinguish different connection errors :(
+            if e.message =~ /certificate verify failed/
+              raise Errors::CertificateError
+            end
+
+            raise e
+          end
+
+          # remove the api key in case an error gets dumped to the console
+          params[:api_key] = 'REMOVED'
+
+          begin
+            body = JSON.parse(result.body)
+						@logger.info "Response: #{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
+
+        def wait_for_event(env, id)
+          retryable(:tries => 120, :sleep => 10) do
+            # stop waiting if interrupted
+            next if env[:interrupted]
+
+            # check event status
+            result = self.request("/events/#{id}")
+
+            yield result if block_given?
+            raise 'not ready' if result['event']['action_status'] != 'done'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-chassis-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-chassis-digitalocean/plugin.rb

@@ -0,0 +1,26 @@
+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
+        require_relative 'provider'
+        Provider
+      end
+
+      command(:rebuild) do
+        require_relative 'commands/rebuild'
+        Commands::Rebuild
+      end
+    end
+  end
+end

data/lib/vagrant-chassis-digitalocean/provider.rb

@@ -0,0 +1,100 @@
+require 'vagrant-digitalocean/actions'
+
+module VagrantPlugins
+  module DigitalOcean
+    class Provider < Vagrant.plugin('2', :provider)
+
+      # This class method caches status for all droplets within
+      # the Digital Ocean account. A specific droplet's status
+      # may be refreshed by passing :refresh => true as an option.
+      def self.droplet(machine, opts = {})
+        client = Helpers::ApiClient.new(machine)
+
+        # load status of droplets if it has not been done before
+        if !@droplets
+          result = client.request('/droplets')
+          @droplets = result['droplets']
+        end
+
+        if opts[:refresh] && machine.id
+          # refresh the droplet status for the given machine
+          @droplets.delete_if { |d| d['id'].to_s == machine.id }
+          result = client.request("/droplets/#{machine.id}")
+          @droplets << droplet = result['droplet']
+        else
+          # lookup droplet status for the given machine
+          droplet = @droplets.find { |d| d['id'].to_s == machine.id }
+        end
+
+        # if lookup by id failed, check for a droplet with a matching name
+        # and set the id to ensure vagrant stores locally
+        # TODO allow the user to configure this behavior
+        if !droplet
+          name = machine.config.vm.hostname || machine.name
+          droplet = @droplets.find { |d| d['name'] == name.to_s }
+          machine.id = droplet['id'].to_s if droplet
+        end
+
+        droplet ||= {'status' => 'not_created'}
+      end
+
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        return Actions.send(name) if Actions.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.
+      def ssh_info
+        droplet = Provider.droplet(@machine)
+
+        return nil if droplet['status'].to_sym != :active
+
+        return {
+          :host => droplet['ip_address'],
+          :port => '22',
+          :username => 'root',
+          :private_key_path => nil
+        }
+      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.
+      def state
+        state = Provider.droplet(@machine)['status'].to_sym
+        long = short = state.to_s
+        Vagrant::MachineState.new(state, short, long)
+      end
+    end
+  end
+end

data/lib/vagrant-chassis-digitalocean/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module DigitalOcean
+    VERSION = '1.0.0'
+  end
+end

data/locales/en.yml

@@ -0,0 +1,84 @@
+en:
+  vagrant_digital_ocean:
+    info:
+      off: "Droplet is off"
+      not_created: "Droplet has not been created"
+      already_active: "Droplet is already active"
+      already_off: "Droplet is already off"
+      creating: "Creating a new droplet..."
+      droplet_ip: "Assigned IP address: %{ip}"
+      droplet_private_ip: "Private IP address: %{ip}"
+      destroying: "Destroying the droplet..."
+      powering_off: "Powering off the droplet..."
+      powering_on: "Powering on the droplet..."
+      rebuilding: "Rebuilding the droplet..."
+      reloading: "Rebooting the droplet..."
+      creating_user: "Creating user account: %{user}..."
+      modifying_sudo: "Modifying sudoers file to remove tty requirement..."
+      using_key: "Using existing SSH key: %{name}"
+      creating_key: "Creating new SSH key: %{name}..."
+      trying_rsync_install: "Rsync not found, attempting to install with yum..."
+      rsyncing: "Rsyncing folder: %{hostpath} => %{guestpath}..."
+    config:
+      client_id: "Client ID is required"
+      api_key: "API key is required"
+      private_key: "SSH private key path is required"
+      public_key: "SSH public key not found: %{key}"
+    errors:
+      public_key: |-
+        There was an issue reading the public key at:
+
+        Path: %{path}
+
+        Please check the file's permissions.
+      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}
+      rsync: |-
+        There was an error when attemping to rsync a share folder.
+        Please inspect the error message below for more info.
+
+        Host path: %{hostpath}
+        Guest path: %{guestpath}
+        Error: %{stderr}
+      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.
+      certificate: |-
+        The secure connection to the Digital Ocean API has failed. Please
+        ensure that your local certificates directory is defined in the
+        provider config.
+
+            config.vm.provider :digital_ocean do |vm|
+              vm.ca_path = "/path/to/ssl/ca/cert.crt"
+            end
+
+        This is generally caused by the OpenSSL configuration associated
+        with the Ruby install being unaware of the system specific ca
+        certs.
+      local_ip: |-
+        The Digital Ocean provider was unable to determine the host's IP.