vagrant-digitalocean 0.0.4 → 0.1.0

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

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class CheckState
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::digitalocean::check_state')
+        end
+
+        def call(env)
+          env[:machine_state] = @machine.state.id
+          @logger.info "Machine state is '#{@machine.state.id}'"
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -1,49 +1,64 @@
-require "vagrant-digitalocean/helpers/client"
+require 'vagrant-digitalocean/helpers/client'
 
 module VagrantPlugins
   module DigitalOcean
     module Actions
       class Create
-        include Vagrant::Util::Retryable
         include Helpers::Client
+        include Vagrant::Util::Retryable
 
         def initialize(app, env)
-          @app, @env = app, env
+          @app = app
+          @machine = env[:machine]
           @client = client
-          @translator = Helpers::Translator.new("actions.create")
+          @logger = Log4r::Logger.new('vagrant::digitalocean::create')
         end
 
         def call(env)
           ssh_key_id = env[:ssh_key_id]
 
           size_id = @client
-            .request("/sizes")
-            .find_id(:sizes, :name => env[:machine].provider_config.size)
+            .request('/sizes')
+            .find_id(:sizes, :name => @machine.provider_config.size)
 
           image_id = @client
-            .request("/images", { :filter => "global" })
-            .find_id(:images, :name => env[:machine].provider_config.image)
+            .request('/images', { :filter => 'global' })
+            .find_id(:images, :name => @machine.provider_config.image)
 
           region_id = @client
-            .request("/regions")
-            .find_id(:regions, :name => env[:machine].provider_config.region)
+            .request('/regions')
+            .find_id(:regions, :name => @machine.provider_config.region)
 
-          env[:ui].info @translator.t("create_droplet")
-
-          result = @client.request("/droplets/new", {
+          # submit new droplet request
+          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",
+            :name => @machine.config.vm.hostname || @machine.name,
             :ssh_key_ids => ssh_key_id
           })
 
-          env[:ui].info @translator.t("wait_active")
-          @client.wait_for_event(result["droplet"]["event_id"])
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.creating') 
+          @client.wait_for_event(env, result['droplet']['event_id'])
 
           # assign the machine id for reference in other commands
-          env[:machine].id = result["droplet"]["id"].to_s
+          @machine.id = result['droplet']['id'].to_s
+
+          # refresh droplet state with provider and output ip address
+          droplet = Provider.droplet(@machine, :refresh => true)
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.droplet_ip', {
+            :ip => droplet['ip_address']
+          })
+
+          # wait for ssh to be ready using the root user account
+          user = @machine.config.ssh.username
+          @machine.config.ssh.username = 'root'
+          retryable(:tries => 30, :sleep => 10) do
+            next if env[:interrupted]
+            raise 'not ready' if !@machine.communicate.ready?
+          end
+          @machine.config.ssh.username = user
 
           @app.call(env)
         end
@@ -51,9 +66,9 @@ module VagrantPlugins
         # 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)
+          return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)
 
-          if env[:machine].state.id != :not_created
+          if @machine.state.id != :not_created
             terminate(env)
           end
         end
@@ -63,7 +78,7 @@ module VagrantPlugins
           destroy_env.delete(:interrupted)
           destroy_env[:config_validate] = false
           destroy_env[:force_confirm_destroy] = true
-          env[:action_runner].run(Action.new.destroy, destroy_env)
+          env[:action_runner].run(Actions.destroy, destroy_env)
         end
       end
     end

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

@@ -1,26 +1,28 @@
-require "vagrant-digitalocean/helpers/client"
+require 'vagrant-digitalocean/helpers/client'
 
 module VagrantPlugins
   module DigitalOcean
     module Actions
       class Destroy
-        include Vagrant::Util::Retryable
         include Helpers::Client
 
         def initialize(app, env)
-          @app, @env = app, env
+          @app = app
+          @machine = env[:machine]
           @client = client
-          @translator = Helpers::Translator.new("actions.destroy")
+          @logger = Log4r::Logger.new('vagrant::digitalocean::destroy')
         end
 
         def call(env)
           # submit destroy droplet request
-          env[:ui].info @translator.t("destroying")
-          result = @client.request("/droplets/#{env[:machine].id}/destroy")
+          result = @client.request("/droplets/#{@machine.id}/destroy")
 
           # wait for request to complete
-          env[:ui].info @translator.t("wait_off")
-          @client.wait_for_event(result["event_id"])
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.destroying')
+          @client.wait_for_event(env, result['event_id'])
+
+          # set the machine id to nil to cleanup local vagrant state
+          @machine.id = nil
 
           @app.call(env)
         end

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

@@ -2,34 +2,32 @@ module VagrantPlugins
   module DigitalOcean
     module Actions
       class ModifyProvisionPath
-        include Vagrant::Util::Counter
-
         def initialize(app, env)
           @app = app
           @machine = env[:machine]
-          @translator =
-            Helpers::Translator.new("actions.modify_provision_path")
+          @logger =
+            Log4r::Logger.new('vagrant::digitalocean::modify_provision_path')
         end
 
         def call(env)
+          # check if provisioning is enabled
+          enabled = true
+          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
+          return @app.call(env) if !enabled
+
           username = @machine.ssh_info()[:username]
-          env[:ui].info @translator.t("modify", { :user => username })
 
-          # modify provisioning paths to enable different users to
-          # provision the same machine
+          # change ownership of the provisioning path recursively to the
+          # ssh user
           #
           # TODO submit patch to vagrant to set appropriate permissions
           # based on ssh username
-          @machine.communicate.execute("mkdir -p /home/#{username}/tmp")
-          env[:global_config].vm.provisioners.each do |prov|
-            if prov.name == :shell
-              prov.config.upload_path =
-                prov.config.upload_path.prepend("/home/#{username}")
-            else
-              counter = get_and_update_counter(:provisioning_path)
-              path = "/home/#{username}/tmp/vagrant-chef-#{counter}"
-              prov.config.provisioning_path = path
-            end
+          @machine.config.vm.provisioners.each do |provisioner|
+            cfg = provisioner.config
+            path = cfg.upload_path if cfg.respond_to? :upload_path
+            path = cfg.provisioning_path if cfg.respond_to? :provisioning_path
+            @machine.communicate.sudo("chown -R #{username} #{path}",
+              :error_check => false)
           end
 
           @app.call(env)

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

@@ -0,0 +1,33 @@
+require 'vagrant-digitalocean/helpers/client'
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class PowerOff
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::digitalocean::power_off')
+        end
+
+        def call(env)
+          # submit power off droplet request
+          result = @client.request("/droplets/#{@machine.id}/power_off")
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.powering_off')
+          @client.wait_for_event(env, result['event_id'])
+
+          # refresh droplet state with provider
+          Provider.droplet(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,34 @@
+require 'vagrant-digitalocean/helpers/client'
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class PowerOn
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::digitalocean::power_on')
+        end
+
+        def call(env)
+          # submit power on droplet request
+          result = @client.request("/droplets/#{@machine.id}/power_on")
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.powering_on') 
+          @client.wait_for_event(env, result['event_id'])
+
+          # refresh droplet state with provider
+          Provider.droplet(@machine, :refresh => true)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -1,4 +1,4 @@
-require "vagrant-digitalocean/helpers/client"
+require 'vagrant-digitalocean/helpers/client'
 
 module VagrantPlugins
   module DigitalOcean
@@ -7,26 +7,26 @@ module VagrantPlugins
         include Helpers::Client
 
         def initialize(app, env)
-          @app, @env = app, env
+          @app = app
+          @machine = env[:machine]
           @client = client
-          @translator = Helpers::Translator.new("actions.rebuild")
+          @logger = Log4r::Logger.new('vagrant::digitalocean::rebuild')
         end
 
         def call(env)
           # look up image id
           image_id = @client
-            .request("/images", { :filter => "global" })
-            .find_id(:images, :name => env[:machine].provider_config.image)
+            .request('/images', { :filter => 'global' })
+            .find_id(:images, :name => @machine.provider_config.image)
 
           # submit rebuild request
-          env[:ui].info @translator.t("rebuild")
-          result = @client.request("/droplets/#{env[:machine].id}/rebuild", {
+          result = @client.request("/droplets/#{@machine.id}/rebuild", {
             :image_id => image_id
           })
 
           # wait for request to complete
-          env[:ui].info @translator.t("wait")
-          @client.wait_for_event(result["event_id"])
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.rebuilding')
+          @client.wait_for_event(env, result['event_id'])
 
           @app.call(env)
         end

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

@@ -0,0 +1,31 @@
+require 'vagrant-digitalocean/helpers/client'
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class Reload
+        include Helpers::Client
+
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::digitalocean::reload')
+        end
+
+        def call(env)
+          # submit reboot droplet request
+          result = @client.request("/droplets/#{@machine.id}/reboot")
+
+          # wait for request to complete
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.reloading')
+          @client.wait_for_event(env, result['event_id'])
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,56 @@
+require 'vagrant-digitalocean/helpers/client'
+
+module VagrantPlugins
+  module DigitalOcean
+    module Actions
+      class SetupKey
+        include Helpers::Client
+  
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::digitalocean::setup_key')
+        end
+
+        # TODO check the content of the key to see if it has changed
+        def call(env)
+          ssh_key_name = @machine.provider_config.ssh_key_name
+
+          begin
+            # assigns existing ssh key id to env for use by other commands
+            env[:ssh_key_id] = @client
+              .request('/ssh_keys/')
+              .find_id(:ssh_keys, :name => ssh_key_name)
+
+            env[:ui].info I18n.t('vagrant_digital_ocean.info.using_key', {
+              :name => ssh_key_name
+            })
+          rescue Errors::ResultMatchError
+            env[:ssh_key_id] = create_ssh_key(ssh_key_name, env)
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def create_ssh_key(name, env)
+          # assumes public key exists on the same path as private key with .pub ext
+          private_key_path = @machine.config.ssh.private_key_path
+          pub_key = DigitalOcean.public_key(private_key_path)
+
+          env[:ui].info I18n.t('vagrant_digital_ocean.info.creating_key', {
+            :name => name
+          }) 
+
+          result = @client.request('/ssh_keys/new', {
+            :name => name,
+            :ssh_pub_key => pub_key
+          })
+          result['ssh_key']['id']
+        end
+      end
+    end
+  end
+end

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

@@ -1,28 +1,39 @@
-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")
+          @app = app
+          @machine = env[:machine]
+          @logger = 
+            Log4r::Logger.new('vagrant::digitalocean::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))
+          # check if provisioning is enabled
+          enabled = true
+          enabled = env[:provision_enabled] if env.has_key?(:provision_enabled)
+          return @app.call(env) if !enabled
 
-          @app.call(env)
-        end
+          # check if a chef provisioner is configured
+          provisioners = @machine.config.vm.provisioners
+          configured = provisioners.reduce(false) do |c, provisioner|
+            provisioner.name =~ /chef/
+          end
+          return @app.call(env) if !configured
 
-        def chef_install(guest)
-          read_script("chef", guest)
+          # check if chef is already installed
+          command = 'which chef-solo'
+          code = @machine.communicate.execute(command, :error_check => false)
+          return @app.call(env) if code == 0
+
+          # install chef
+          key = 'vagrant_digital_ocean.info.installing_provisioner'
+          env[:ui].info I18n.t(key, { :provisioner => 'chef' })
+          command = 'wget -O - http://www.opscode.com/chef/install.sh | bash'
+          @machine.communicate.sudo(command)
+
+          @app.call(env)
         end
       end
     end