vagrant-rimu 0.0.1

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

@@ -0,0 +1,91 @@
+require 'log4r'
+require 'vagrant'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class Create
+        include Vagrant::Util::Retryable
+        def initialize(app, env)
+          @app = app
+          @client = env[:rimu_api]
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::rimu::create')
+        end
+
+        def call(env)
+          env[:ui].info I18n.t('vagrant_rimu.creating')
+          params = {
+            :billing_oid => @machine.provider_config.billing_id,
+            :dc_location => @machine.provider_config.data_centre,
+            :host_server_oid => @machine.provider_config.host_server_id,
+            :instantiation_options => {
+                :domain_name => @machine.provider_config.host_name,
+                :password => @machine.provider_config.root_password,
+                :distro => @machine.provider_config.distro_code,
+                :control_panel => @machine.provider_config.control_panel,
+            },
+            :instantiation_via_clone_options => {
+                :domain_name => @machine.provider_config.host_name,
+                :vps_order_oid_to_clone => @machine.provider_config.vps_to_clone,
+            },
+            :ip_request => {
+                :extra_ip_reason => @machine.provider_config.extra_ip_reason,
+                :num_ips => @machine.provider_config.num_ips,
+                :requested_ips => @machine.provider_config.private_ips,
+            },
+            :is_just_minimal_init => @machine.provider_config.minimal_init,
+            :vps_parameters => {
+                :disk_space_mb => @machine.provider_config.disk_space_mb,
+                :memory_mb => @machine.provider_config.memory_mb,
+                :disk_space_2_mb => @machine.provider_config.disk_space_2_mb,
+            },
+            :vps_type => @machine.provider_config.vps_type,
+          }
+          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)
+          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
+          result = @client.servers.create(params)
+          @machine.id = result.order_oid
+          env[:ui].info I18n.t('vagrant_rimu.ip_address', {:ip => result.allocated_ips["primary_ip"]})
+          switch_user = @machine.provider_config.setup?
+          user = @machine.config.ssh.username
+          if switch_user
+            @machine.config.ssh.username = 'root'
+            @machine.config.ssh.password = root_pass
+          end
+          if params.has_key?(:instantiation_options)
+            retryable(:tries => 120, :sleep => 10) do
+              next if env[:interrupted]
+              raise 'not ready' if !@machine.communicate.ready?
+            end
+          end
+          @machine.config.ssh.username = user
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env['vagrant.error'].is_a?(Vagrant::Errors::VagrantError)
+          if @machine.state.id != :not_created
+            terminate(env)
+          end
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Actions.destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class IsCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id != :not_created
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class IsStopped
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:result] = env[:machine].state.id == :stopped
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class ListDistributions
+        def initialize(app, env)
+          @app = app
+          @client = env[:rimu_api]
+        end
+
+        def call(env)
+          env[:ui].info '%-6s %s' % ['Distro Code', 'Distro Description']
+          @client.distributions.each do |dist|
+            env[:ui].info '%-6s %s' % [dist.distro_code, dist.distro_description]
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class ListServers
+        def initialize(app, env)
+          @app = app
+          @client = env[:rimu_api]
+        end
+
+        def call(env)
+          env[:ui].info '%-8s %-30s %-20s %-10s %-9s' % ['ID', 'Hostname', 'Data Centre', 'Host Server', 'Status']
+          @client.orders.orders.each do |o|
+            env[:ui].info '%-8s %-30s %-20s %-10s %-9s' % [o.order_oid, o.domain_name, o.location["data_center_location_code"], o.host_server_oid, o.running_state]
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class MessageAlreadyCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_rimu.already_status', :status => 'created'))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class MessageAlreadyOff
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_rimu.already_status", :status => :off))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class MessageNotCreated
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_rimu.not_created'))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t('vagrant_rimu.will_not_destroy', {:name => @machine.name}))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class ModifyProvisionPath
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::rimu::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]
+
+          # change ownership of the provisioning path recursively to the
+          # ssh user
+          #
+          @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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class Move
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = client
+          @logger = Log4r::Logger.new('vagrant::rimu::move')
+        end
+
+        def call(env)
+          env[:ui].info I18n.t('vagrant_rimu.move')
+          fail 'not implemented'
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'log4r'
+
+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
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @client = env[:rimu_api]
+          @logger = Log4r::Logger.new("vagrant_rimu::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(@client, @machine)
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(client, machine)
+          return nil if machine.id.nil?
+
+          # Find the machine
+          server = client.orders.order(machine.id.to_i)
+          if server.nil?
+            # The machine can't be found
+            @logger.info("Machine couldn't be found, assuming it got destroyed.")
+            machine.id = nil
+            return nil
+          end
+
+          return {
+            :host => server.allocated_ips["primary_ip"],
+            :port => 22,
+            :username => "root"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class ReadState
+        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]}'"
+          @app.call(env)
+        end
+
+        def read_state(client, machine)
+          return :not_created if machine.id.nil?
+          server = client.servers.status(machine.id.to_i)
+          return :not_created if server.nil?
+          status = server.running_state
+          return :not_created if status.nil?
+          states = {
+            'RUNNING' => :active,
+            'NOTRUNNING' => :off,
+            'RESTARTING' => :shutting_down,
+            'POWERCYCLING' => :shutting_down,
+          }
+          states[status.to_s]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class Rebuild
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app = app
+          @client = env[:rimu_api]
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::rimu::rebuild')
+        end
+
+        def call(env)
+          env[:ui].info I18n.t('vagrant_rimu.rebuilding')
+          params = {
+            :instantiation_options => {
+                :domain_name => @machine.provider_config.host_name,
+                :password => @machine.provider_config.root_password,
+                :distro => @machine.provider_config.distro_code,
+                :control_panel => @machine.provider_config.control_panel,
+            },
+            :instantiation_via_clone_options => {
+                :domain_name => @machine.provider_config.host_name,
+                :vps_order_oid_to_clone => @machine.provider_config.vps_to_clone,
+            },
+            :is_just_minimal_init => @machine.provider_config.minimal_init,
+            :vps_parameters => {
+                :disk_space_mb => @machine.provider_config.disk_space_mb,
+                :memory_mb => @machine.provider_config.memory_mb,
+                :disk_space_2_mb => @machine.provider_config.disk_space_2_mb,
+            },
+          }
+          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)
+          switch_user = @machine.provider_config.setup?
+          user = @machine.config.ssh.username
+          @machine.config.ssh.username = 'root' if switch_user
+          retryable(:tries => 120, :sleep => 10) do
+            next if env[:interrupted]
+            raise 'not ready' if !@machine.communicate.ready?
+          end
+          @machine.config.ssh.username = user
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class Reload
+        def initialize(app, env)
+          @app = app
+          @client = env[:rimu_api]
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::rimu::reload')
+        end
+
+        def call(env)
+          env[:ui].info I18n.t('vagrant_rimu.reloading')
+          @client.servers.reboot(@machine.id.to_i)
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class SetupSudo
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::rimu::setup_sudo')
+        end
+
+        def call(env)
+          # check if setup is enabled
+          return @app.call(env) unless @machine.provider_config.setup?
+
+          # override ssh username to root
+          user = @machine.config.ssh.username
+          @machine.config.ssh.username = 'root'
+
+          # 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')
+
+            # 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
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class SetupUser
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::rimu::setup_user')
+        end
+
+        def call(env)
+          # check if setup is enabled
+          return @app.call(env) unless @machine.provider_config.setup?
+
+          # check if a username has been specified
+          return @app.call(env) unless @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_rimu.creating_user', {
+            :user => user
+          })
+
+          # create user account
+          @machine.communicate.execute(<<-BASH)
+            if ! (grep ^#{user}: /etc/passwd); then
+              useradd -m -s /bin/bash #{user};
+            fi
+          BASH
+
+          # grant user sudo access with no password requirement
+          @machine.communicate.execute(<<-BASH)
+            if ! (grep #{user} /etc/sudoers); then
+              echo "#{user} ALL=(ALL:ALL) NOPASSWD: ALL" >> /etc/sudoers;
+            else
+              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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      class StartInstance
+        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)
+          env[:ui].info I18n.t('vagrant_rimu.starting')
+          begin
+            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
+            raise Errors::ApiError, {:stderr=>e}
+          end
+          env[:ui].info(I18n.t("vagrant_rimu.ready"))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      # This stops the running instance.
+      class StopInstance
+        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
+            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)
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Rimu
+    module Actions
+      # This terminates the running server, if there is one.
+      class TerminateInstance
+        def initialize(app, env)
+          @app = app
+          @client = env[:rimu_api]
+          @logger = Log4r::Logger.new("vagrant_rimu::action::terminate_instance")
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t("vagrant_rimu.terminating"))
+            @client.servers.cancel(env[:machine].id.to_i)
+            env[:machine].id = nil
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end