vagrant-rimu 0.0.1 → 0.0.6

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

@@ -1,20 +1,22 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
       # This action reads the SSH info for the machine and puts it into the
       # `:machine_ssh_info` key in the environment.
-      class ReadSSHInfo
+      class ReadSSHInfo < AbstractAction
         def initialize(app, env)
           @app = app
           @machine = env[:machine]
-          @client = env[:rimu_api]
-          @logger = Log4r::Logger.new("vagrant_rimu::action::read_ssh_info")
+          @logger = Log4r::Logger.new('vagrant_rimu::action::read_ssh_info')
         end
 
-        def call(env)
-          env[:machine_ssh_info] = read_ssh_info(@client, @machine)
+        def execute(env)
+          client = env[:rimu_api]
+          env[:machine_ssh_info] = read_ssh_info(client, @machine)
 
           @app.call(env)
         end
@@ -32,9 +34,10 @@ module VagrantPlugins
           end
 
           return {
-            :host => server.allocated_ips["primary_ip"],
+            :host => server.allocated_ips['primary_ip'],
             :port => 22,
-            :username => "root"
+            :username => 'root',
+            :private_key_path => machine.config.ssh.private_key_path,
           }
         end
       end

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]
-          @client = env[:rimu_api]
           @logger = Log4r::Logger.new('vagrant_rimu::action::read_state')
         end
 
-        def call(env)
-          env[:machine_state] = read_state(@client, @machine)
-          @logger.info "Machine state is '#{env[:machine_state]}'"
+        def execute(env)
+          client = env[:rimu_api]
+          env[:machine_state] = read_state(client, @machine)
+          @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,20 +1,25 @@
 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
-          @client = env[:rimu_api]
           @machine = env[:machine]
           @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
-          @client = env[:rimu_api]
           @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,28 +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 = Rimu.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
       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,20 +1,22 @@
 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
-          @client = env[:rimu_api]
           @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
-            result = @client.servers.start(@machine.id.to_i)
+            result = client.servers.start(@machine.id.to_i)
             raise StandardError, "No response from the API" if result.nil?
             raise StandardError, "VPS is not be running" if result.running_state != 'RUNNING'
           rescue StandardError => e

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

@@ -1,25 +1,36 @@
 require 'log4r'
 
+require 'vagrant-rimu/actions/abstract_action'
+
 module VagrantPlugins
   module Rimu
     module Actions
       # This stops the running instance.
-      class StopInstance
-        def initialize(app, env)
+      class StopInstance < AbstractAction
+        def initialize(app, _env)
           @app    = app
-          @client = env[:rimu_api]
           @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.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