vagrant-digitalocean 0.0.4 → 0.1.0

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

@@ -1,25 +1,32 @@
-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")
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::digitalocean::setup_sudo')
         end
 
         def call(env)
-          env[:ui].info @translator.t("exec")
-          env[:machine].communicate.execute(fix_sudo(env[:machine].guest))
+          # override ssh username to root temporarily
+          user = @machine.config.ssh.username
+          @machine.config.ssh.username = 'root'
 
-          @app.call(env)
-        end
+          case @machine.guest.to_s
+          when /RedHat/
+            env[:ui].info I18n.t('vagrant_digital_ocean.info.modifying_sudo')
 
-        def fix_sudo(guest)
-          read_script("sudo", guest, false)
+            # disable tty requirement for sudo
+            @machine.communicate.execute(<<-'BASH')
+              sed -i'.bk' -e 's/\(Defaults\s\+requiretty\)/# \1/' /etc/sudoers
+            BASH
+          end
+
+          # reset ssh username
+          @machine.config.ssh.username = user
+
+          @app.call(env)
         end
       end
     end

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

@@ -3,56 +3,54 @@ module VagrantPlugins
     module Actions
       class SetupUser
         def initialize(app, env)
-          @app, @env = app, env
-          @translator = Helpers::Translator.new("actions.setup_user")
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::digitalocean::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)
+          # check if a username has been specified
+          return @app.call(env) if !@machine.config.ssh.username
+
+          # override ssh username to root temporarily
+          user = @machine.config.ssh.username
+          @machine.config.ssh.username = 'root'
+
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.creating_user', {
+            :user => user
+          })
+
+          # create user account
+          @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)
+          # grant user sudo access with no password requirement
+          @machine.communicate.execute(<<-BASH)
             if ! (grep #{user} /etc/sudoers); then
-              echo "#{user} ALL=(ALL:ALL) ALL" >> /etc/sudoers;
+              echo "#{user} ALL=(ALL:ALL) NOPASSWD: ALL" >> /etc/sudoers;
             fi
           BASH
 
           # create the .ssh directory in the users home
-          env[:machine].communicate.execute("su #{user} -c 'mkdir -p ~/.ssh'")
+          @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)
+          private_key_path = @machine.ssh_info()[:private_key_path]
+          pub_key = DigitalOcean.public_key(private_key_path)
+          @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
+          # reset username
+          @machine.config.ssh.username = 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

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

@@ -1,40 +1,39 @@
-require "vagrant/util/subprocess"
+require 'vagrant/util/subprocess'
 
 module VagrantPlugins
   module DigitalOcean
     module Actions
-      # This middleware uses `rsync` to sync the folders over to the
-      # Digital Ocean instance. The implementation was lifted from the
-      # vagrant-aws provider plugin.
       class SyncFolders
         def initialize(app, env)
-          @app, @env = app, env
-          @translator = Helpers::Translator.new("actions.sync_folders")
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::digitalocean::sync_folders')
         end
 
         def call(env)
-          @app.call(env)
+          ssh_info = @machine.ssh_info
 
-          ssh_info = env[:machine].ssh_info
+          @machine.config.vm.synced_folders.each do |id, data|
+            next if data[:disabled]
 
-          env[:machine].config.vm.synced_folders.each do |id, data|
             hostpath  = File.expand_path(data[:hostpath], env[:root_path])
             guestpath = data[:guestpath]
 
-            # Make sure there is a trailing slash on the host path to
+            # make sure there is a trailing slash on the host path to
             # avoid creating an additional directory with rsync
             hostpath = "#{hostpath}/" if hostpath !~ /\/$/
 
-            env[:ui].info @translator.t("rsync_folder",
-                                        :hostpath => hostpath,
-                                        :guestpath => guestpath)
+            env[:ui].info I18n.t('vagrant_digital_ocean.info.rsyncing', {
+              :hostpath => hostpath,
+              :guestpath => guestpath
+            })
 
-            # Create the guest path
-            env[:machine].communicate.sudo("mkdir -p #{guestpath}")
-            env[:machine].communicate.sudo(
+            # create the guest path
+            @machine.communicate.sudo("mkdir -p #{guestpath}")
+            @machine.communicate.sudo(
               "chown -R #{ssh_info[:username]} #{guestpath}")
 
-            # Rsync over to the guest path using the SSH info
+            # rsync over to the guest path using the ssh info
             command = [
               "rsync", "--verbose", "--archive", "-z",
               "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path]}'",
@@ -49,6 +48,8 @@ module VagrantPlugins
                 :stderr => r.stderr
             end
           end
+
+          @app.call(env)
         end
       end
     end

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

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

data/lib/vagrant-digitalocean/config.rb

@@ -1,52 +1,49 @@
 module VagrantPlugins
   module DigitalOcean
-    class Config < Vagrant.plugin("2", :config)
-      attr_accessor :client_id, :api_key, :image, :region, :size, :ca_path,
-                    :ssh_key_name, :ssh_private_key_path, :ssh_username
+    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 :ca_path
+      attr_accessor :ssh_key_name
 
       def initialize
-        @client_id            = UNSET_VALUE
-        @api_key              = UNSET_VALUE
-        @image                = UNSET_VALUE
-        @region               = UNSET_VALUE
-        @size                 = UNSET_VALUE
-        @ca_path              = UNSET_VALUE
-        @ssh_key_name         = UNSET_VALUE
-        @ssh_private_key_path = UNSET_VALUE
-        @ssh_username         = UNSET_VALUE
-
-        @translator = Helpers::Translator.new("config")
+        @client_id    = UNSET_VALUE
+        @api_key      = UNSET_VALUE
+        @image        = UNSET_VALUE
+        @region       = UNSET_VALUE
+        @size         = UNSET_VALUE
+        @ca_path      = UNSET_VALUE
+        @ssh_key_name = 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
-        @ca_path               = nil if @ca_path == UNSET_VALUE
-        @ssh_key_name          = "Vagrant" if @ssh_key_name == UNSET_VALUE
-        @ssh_private_key_path  = nil if @ssh_private_key_path == UNSET_VALUE
-        @ssh_username          = "root" if @ssh_username == UNSET_VALUE
+        @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 x64 Server' if @image == UNSET_VALUE
+        @region       = 'New York 1' if @region == UNSET_VALUE
+        @size         = '512MB' if @size == UNSET_VALUE
+        @ca_path      = nil if @ca_path == UNSET_VALUE
+        @ssh_key_name = 'Vagrant' if @ssh_key_name == UNSET_VALUE
       end
 
       def validate(machine)
         errors = []
-        errors << @translator.t(:client_id_required) if !@client_id
-        errors << @translator.t(:api_key_required) if !@api_key
-
-        key = @ssh_private_key_path
-        key = machine.config.ssh.private_key_path if !@ssh_private_key_path
+        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
         if !key
-          errors << @translator.t(:private_key_required) if !key
-        elsif !File.file?(File.expand_path(key, machine.env.root_path))
-          errors << @translator.t(:private_key_missing, { :key => key })
+          errors << I18n.t('vagrant_digital_ocean.config.private_key')
         elsif !File.file?(File.expand_path("#{key}.pub", machine.env.root_path))
-          errors << @translator.t(:public_key_missing, { :key => key })
+          errors << I18n.t('vagrant_digital_ocean.config.public_key', {
+            :key => "#{key}.pub"
+          })
         end
 
-        { "Digital Ocean Provider" => errors }
+        { 'Digital Ocean Provider' => errors }
       end
     end
   end

data/lib/vagrant-digitalocean/errors.rb

@@ -1,5 +1,3 @@
-require "vagrant"
-
 module VagrantPlugins
   module DigitalOcean
     module Errors

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

@@ -1,24 +1,23 @@
-require "vagrant-digitalocean/helpers/result"
-require "faraday"
-require "json"
+require 'vagrant-digitalocean/helpers/result'
+require 'faraday'
+require 'json'
 
 module VagrantPlugins
   module DigitalOcean
     module Helpers
       module Client
         def client
-          @client ||= ApiClient.new(@env)
+          @client ||= ApiClient.new(@machine)
         end
       end
 
       class ApiClient
         include Vagrant::Util::Retryable
 
-        def initialize(env)
-          @env = env
-          @config = env[:machine].provider_config
+        def initialize(machine)
+          @config = machine.provider_config
           @client = Faraday.new({
-            :url => "https://api.digitalocean.com/",
+            :url => 'https://api.digitalocean.com/',
             :ssl => {
               :ca_file => @config.ca_path
             }
@@ -43,7 +42,7 @@ module VagrantPlugins
           end
 
           # remove the api key in case an error gets dumped to the console
-          params[:api_key] = "REMOVED"
+          params[:api_key] = 'REMOVED'
 
           begin
             body = JSON.parse(result.body)
@@ -56,11 +55,11 @@ module VagrantPlugins
             })
           end
 
-          if body["status"] != "OK"
+          if body['status'] != 'OK'
             raise(Errors::APIStatusError, {
               :path => path,
               :params => params,
-              :status => body["status"],
+              :status => body['status'],
               :response => body.inspect
             })
           end
@@ -68,17 +67,16 @@ module VagrantPlugins
           Result.new(body)
         end
 
-        def wait_for_event(id)
+        def wait_for_event(env, id)
           retryable(:tries => 30, :sleep => 10) do
             # stop waiting if interrupted
-            next if @env[: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"
+            raise 'not ready' if result['event']['action_status'] != 'done'
           end
         end
       end

data/lib/vagrant-digitalocean/plugin.rb

@@ -1,33 +1,24 @@
-require "i18n"
-require "vagrant-digitalocean/helpers/translator"
-
 module VagrantPlugins
   module DigitalOcean
-    class Plugin < Vagrant.plugin("2")
-      name "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"
+        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"
-
+        require_relative 'provider'
         Provider
       end
 
       command(:rebuild) do
-        require_relative "commands/rebuild"
+        require_relative 'commands/rebuild'
         Commands::Rebuild
       end
     end

data/lib/vagrant-digitalocean/provider.rb

@@ -1,24 +1,49 @@
-require "vagrant-digitalocean/action"
+require 'vagrant-digitalocean/actions'
 
 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.
+    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
-        @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)
+        return Actions.send(name) if Actions.respond_to?(name)
         nil
       end
 
@@ -49,38 +74,27 @@ module VagrantPlugins
       # 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
+        droplet = Provider.droplet(@machine)
 
-        # TODO remove when defect in vagrant chef provisioner is fixed
-        @machine.config.ssh.username = @machine.provider_config.ssh_username
+        return nil if droplet['status'].to_sym != :active
 
+        # TODO remove config.ssh.username reference when Vagrant 1.2 is released
         return {
-          :host => state["ip_address"],
-          :port => "22",
-          :username => @machine.provider_config.ssh_username,
-          :private_key_path => @machine.provider_config.ssh_private_key_path
+          :host => droplet['ip_address'],
+          :port => '22',
+          :username => @machine.config.ssh.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.
-      #
-      # @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)
+        state = Provider.droplet(@machine)['status'].to_sym
+        long = short = state.to_s
+        Vagrant::MachineState.new(state, short, long)
       end
     end
   end