vagrant-rimu 0.0.2 → 0.0.7

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

@@ -1,25 +1,32 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
-      class ReadState
+      class ReadState < AbstractAction
         def initialize(app, env)
           @app = app
           @machine = env[:machine]
           @logger = Log4r::Logger.new('vagrant_rimu::action::read_state')
         end
 
-        def call(env)
+        def execute(env)
           client = env[:rimu_api]
           env[:machine_state] = read_state(client, @machine)
-          @logger.info "Machine state is '#{env[:machine_state]}'"
+          @logger.info I18n.t('vagrant_rimu.states.current_state', {:state => env[:machine_state]})
           @app.call(env)
         end
 
         def read_state(client, machine)
           return :not_created if machine.id.nil?
-          server = client.servers.status(machine.id.to_i)
+          begin
+            server = client.servers.status(machine.id.to_i)
+          rescue ::Rimu::RimuAPI::RimuRequestError, ::Rimu::RimuAPI::RimuResponseError => e
+            @logger.debug(e)
+            return :destroyed
+          end
           return :not_created if server.nil?
           status = server.running_state
           return :not_created if status.nil?
@@ -28,6 +35,7 @@ module VagrantPlugins
             'NOTRUNNING' => :off,
             'RESTARTING' => :shutting_down,
             'POWERCYCLING' => :shutting_down,
+            'DESTROYED' => :destroyed
           }
           states[status.to_s]
         end

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

@@ -1,10 +1,13 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/ssh_utils'
+
 module VagrantPlugins
   module Rimu
     module Actions
-      class Rebuild
+      class Rebuild < AbstractAction
         include Vagrant::Util::Retryable
+        include VagrantPlugins::Rimu::Actions::SshUtils
 
         def initialize(app, env)
           @app = app
@@ -12,9 +15,11 @@ module VagrantPlugins
           @logger = Log4r::Logger.new('vagrant::rimu::rebuild')
         end
 
-        def call(env)
+        # rubocop:disable Metrics/AbcSize
+        def execute(env)
           client = env[:rimu_api]
           env[:ui].info I18n.t('vagrant_rimu.rebuilding')
+          
           params = {
             :instantiation_options => {
                 :domain_name => @machine.provider_config.host_name,
@@ -35,15 +40,38 @@ module VagrantPlugins
           }
           params.delete(:instantiation_via_clone_options) if @machine.provider_config.vps_to_clone.nil?
           params.delete(:instantiation_options) if params.has_key?(:instantiation_via_clone_options)
-          client.servers.reinstall(@machine.id.to_i, params)
+          if @machine.provider_config.root_password
+            root_pass = @machine.provider_config.root_password
+          else
+            root_pass = Digest::SHA2.new.update(@machine.provider_config.api_key).to_s
+          end
+          if params.has_key?(:instantiation_options)
+            params[:instantiation_options][:password] = root_pass
+          end
+
+          begin
+            client.servers.reinstall(@machine.id.to_i, params)
+          rescue ::Rimu::RimuAPI::RimuRequestError, ::Rimu::RimuAPI::RimuResponseError => e
+            raise Errors::ApiError, {:stderr=>e}
+          end
+          
           switch_user = @machine.provider_config.setup?
           user = @machine.config.ssh.username
-          @machine.config.ssh.username = 'root' if switch_user
+          if switch_user
+            @machine.config.ssh.username = 'root'
+            @machine.config.ssh.password = root_pass
+          end
+
           retryable(:tries => 120, :sleep => 10) do
             next if env[:interrupted]
-            raise 'not ready' if !@machine.communicate.ready?
+            raise 'not ready' unless @machine.communicate.ready?
           end
+
+          # upload root ssh key
+          upload_key(env)
+
           @machine.config.ssh.username = user
+          
           @app.call(env)
         end
       end

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

@@ -1,19 +1,26 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
-      class Reload
+      class Reload < AbstractAction
         def initialize(app, env)
           @app = app
           @machine = env[:machine]
           @logger = Log4r::Logger.new('vagrant::rimu::reload')
         end
 
-        def call(env)
+        def execute(env)
           client = env[:rimu_api]
           env[:ui].info I18n.t('vagrant_rimu.reloading')
-          client.servers.reboot(@machine.id.to_i)
+
+          begin
+            client.servers.reboot(@machine.id.to_i)
+          rescue ::Rimu::RimuAPI::RimuRequestError, ::Rimu::RimuAPI::RimuResponseError => e
+            raise Errors::ApiError, {:stderr=>e}
+          end
 
           @app.call(env)
         end

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

@@ -1,16 +1,18 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
-      class SetupSudo
+      class SetupSudo < AbstractAction
         def initialize(app, env)
           @app = app
           @machine = env[:machine]
           @logger = Log4r::Logger.new('vagrant::rimu::setup_sudo')
         end
 
-        def call(env)
+        def execute(env)
           # check if setup is enabled
           return @app.call(env) unless @machine.provider_config.setup?
 
@@ -18,10 +20,20 @@ module VagrantPlugins
           user = @machine.config.ssh.username
           @machine.config.ssh.username = 'root'
 
+          # modify the sudoers file
+          modify_sudo(env)
+          
+          # reset ssh username
+          @machine.config.ssh.username = user
+
+          @app.call(env)
+        end
+        
+        def modify_sudo(env)
           # check for guest name available in Vagrant 1.2 first
           guest_name = @machine.guest.name if @machine.guest.respond_to?(:name)
           guest_name ||= @machine.guest.to_s.downcase
-
+          
           case guest_name
           when /redhat/
             env[:ui].info I18n.t('vagrant_rimu.modifying_sudo')
@@ -31,11 +43,6 @@ module VagrantPlugins
               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-rimu/actions/setup_user.rb

@@ -1,16 +1,22 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/ssh_utils'
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
-      class SetupUser
+      class SetupUser < AbstractAction
+        include VagrantPlugins::Rimu::Actions::SshUtils
+
         def initialize(app, env)
           @app = app
           @machine = env[:machine]
           @logger = Log4r::Logger.new('vagrant::rimu::setup_user')
         end
 
-        def call(env)
+        # rubocop:disable Metrics/AbcSize
+        def execute(env)
           # check if setup is enabled
           return @app.call(env) unless @machine.provider_config.setup?
 
@@ -21,11 +27,40 @@ module VagrantPlugins
           user = @machine.config.ssh.username
           @machine.config.ssh.username = 'root'
 
+          # create user account
+          create_user(env, user)
+
+          # create the .ssh directory in the users home
+          @machine.communicate.execute("su #{user} -c 'mkdir -p ~/.ssh'")
+
+          # add the specified key to the authorized keys file
+          upload_key(env, user)
+
+          # reset username
+          @machine.config.ssh.username = user
+
+          @app.call(env)
+        end
+        
+        # def upload_key(user)
+        #   path = @machine.config.ssh.private_key_path
+        #   path = path[0] if path.is_a?(Array)
+        #   path = File.expand_path(path, @machine.env.root_path)
+        #   pub_key = public_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
+        #
+        #     chown -R #{user} /home/#{user}/.ssh;
+        #   BASH
+        # end
+        
+        def create_user(env, user)
           env[:ui].info I18n.t('vagrant_rimu.creating_user', {
             :user => user
           })
-
-          # create user account
+          
           @machine.communicate.execute(<<-BASH)
             if ! (grep ^#{user}: /etc/passwd); then
               useradd -m -s /bin/bash #{user};
@@ -40,34 +75,13 @@ module VagrantPlugins
               sed -i -e "/#{user}/ s/=.*/=(ALL:ALL) NOPASSWD: ALL/" /etc/sudoers;
             fi
           BASH
-
-          # create the .ssh directory in the users home
-          @machine.communicate.execute("su #{user} -c 'mkdir -p ~/.ssh'")
-
-          # add the specified key to the authorized keys file
-          path = @machine.config.ssh.private_key_path
-          path = path[0] if path.is_a?(Array)
-          path = File.expand_path(path, @machine.env.root_path)
-          pub_key = public_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
-
-            chown -R #{user} /home/#{user}/.ssh;
-          BASH
-
-          # reset username
-          @machine.config.ssh.username = user
-
-          @app.call(env)
         end
         
-        def public_key(private_key_path)
-          File.read("#{private_key_path}.pub")
-        rescue
-          raise Errors::PublicKeyError, :path => "#{private_key_path}.pub"
-        end
+        # def public_key(private_key_path)
+        #   File.read("#{private_key_path}.pub")
+        # rescue
+        #   raise Errors::PublicKeyError, :path => "#{private_key_path}.pub"
+        # end
       end
     end
   end

data/lib/vagrant-rimu/actions/ssh_utils.rb

@@ -0,0 +1,44 @@
+require 'pathname'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      module SshUtils
+
+        # rubocop:disable Metrics/AbcSize
+        def upload_key(env, user=nil)
+          path = env[:machine].config.ssh.private_key_path
+          path = path[0] if path.is_a?(Array)
+          path = File.expand_path(path, env[:machine].env.root_path)
+          pub_key = public_key(path)
+          if user.nil?
+            env[:machine].communicate.execute(<<-BASH)
+              if [ ! -d /root/.ssh ]; then
+                mkdir /root/.ssh;
+                chmod 0700 /root/.ssh;
+              fi
+              if ! grep '#{pub_key.chomp}' /root/.ssh/authorized_keys; then
+                echo '#{pub_key}' >> /root/.ssh/authorized_keys;
+              fi
+            BASH
+          else
+            env[:machine].communicate.execute(<<-BASH)
+              if ! grep '#{pub_key.chomp}' /home/#{user}/.ssh/authorized_keys; then
+                echo '#{pub_key}' >> /home/#{user}/.ssh/authorized_keys;
+              fi
+
+              chown -R #{user} /home/#{user}/.ssh;
+            BASH
+          end
+        end
+        
+        def public_key(private_key_path)
+          File.read("#{private_key_path}.pub")
+        rescue
+          raise Errors::PublicKeyError, :path => "#{private_key_path}.pub"
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+  end
+end

data/lib/vagrant-rimu/actions/start_instance.rb

@@ -1,16 +1,18 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
-      class StartInstance
+      class StartInstance < AbstractAction
         def initialize(app, env)
           @app = app
           @machine = env[:machine]
           @logger = Log4r::Logger.new("vagrant_rimu::action::start_instance")
         end
 
-        def call(env)
+        def execute(env)
           client = env[:rimu_api]
           env[:ui].info I18n.t('vagrant_rimu.starting')
           begin

data/lib/vagrant-rimu/actions/stop_instance.rb

@@ -1,26 +1,36 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
       # This stops the running instance.
-      class StopInstance
+      class StopInstance < AbstractAction
         def initialize(app, _env)
           @app    = app
           @logger = Log4r::Logger.new('vagrant_rimu::action::stop_instance')
         end
 
-        def call(env)
-          if env[:machine].state.id == :stopped
+        def execute(env)
+          if env[:machine].state.id == :off
             env[:ui].info(I18n.t('vagrant_rimu.already_status', :status => env[:machine].state.id))
           else
-            env[:ui].info(I18n.t('vagrant_rimu.stopping'))
-            client = env[:rimu_api]
-            client.servers.shutdown(env[:machine].id.to_i)
+            shutdown(env)
           end
           
           @app.call(env)
         end
+        
+        def shutdown(env)
+          env[:ui].info(I18n.t('vagrant_rimu.stopping'))
+          client = env[:rimu_api]
+          begin
+            client.servers.shutdown(env[:machine].id.to_i)
+          rescue ::Rimu::RimuAPI::RimuRequestError, ::Rimu::RimuAPI::RimuResponseError => e
+            raise Errors::ApiError, {:stderr=>e}
+          end
+        end
       end
     end
   end

data/lib/vagrant-rimu/actions/terminate_instance.rb

@@ -1,21 +1,27 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
       # This terminates the running server, if there is one.
-      class TerminateInstance
+      class TerminateInstance < AbstractAction
         def initialize(app, _env)
           @app = app
           @logger = Log4r::Logger.new("vagrant_rimu::action::terminate_instance")
         end
 
-        def call(env)
+        def execute(env)
           if env[:machine].id
             env[:ui].info(I18n.t("vagrant_rimu.terminating"))
             client = env[:rimu_api]
-            client.servers.cancel(env[:machine].id.to_i)
-            env[:machine].id = nil
+            begin
+              client.servers.cancel(env[:machine].id.to_i)
+              env[:machine].id = nil
+            rescue ::Rimu::RimuAPI::RimuRequestError, ::Rimu::RimuAPI::RimuResponseError => e
+              raise Errors::ApiError, {:stderr=>e}
+            end
           end
 
           @app.call(env)