vagrant-kubevirt 1.0.0

data/lib/vagrant-kubevirt/action/create_vm.rb

@@ -0,0 +1,133 @@
+require "log4r"
+require 'json'
+
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module Kubevirt
+    module Action
+      # This creates the virtual machine.
+      class CreateVM
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_kubevirt::action::create_vm")
+        end
+
+        def call(env)
+          # Get config.
+          config = env[:machine].provider_config
+          ssh_info = env[:machine].config.ssh
+
+          vm_name = env[:domain_name]
+          namespace = config.namespace
+          cpus = config.cpus
+          memory_size = config.memory
+          image = config.image
+          pvc = config.pvc
+          port_node = config.port_node
+ 
+          template = config.template
+
+          # Output the settings we're going to use to the user
+          env[:ui].info(I18n.t("vagrant_kubevirt.creating_vm"))
+          env[:ui].info(" -- Name:          #{vm_name}")
+          env[:ui].info(" -- Namespace:     #{namespace}")
+          env[:ui].info(" -- Cpus:          #{cpus}")
+          env[:ui].info(" -- Memory:        #{memory_size}M")
+
+          kubevirt = env[:kubevirt_compute]
+
+          if template == nil
+            volumes = []
+            if !image.nil?
+              volume = Fog::Kubevirt::Compute::Volume.new
+              volume.type = 'containerDisk'
+              volume.info = image
+              volumes << volume
+            end
+            if !pvc.nil?
+              volume = Fog::Kubevirt::Compute::Volume.new
+              volume.type = 'persistentVolumeClaim'
+              volume.info = pvc
+              volumes << volume
+            end
+            provision_vm(kubevirt, vm_name, cpus, memory_size, volumes, ssh_info)
+          else
+            env[:ui].info(" -- Template:      #{template}")
+            provision_from_template(kubevirt, template, vm_name, cpus, memory_size)
+          end
+
+          create_service(kubevirt, vm_name, port_node)
+
+          vm = kubevirt.vms.get(vm_name)
+          env[:machine].id = vm.name
+
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+
+        def recover(env)
+          return if env["vagrant.error"].is_a?(Vagrant::Errors::VagrantError)
+
+          if env[:machine].provider.state.id != :not_created
+            env[:ui].info(I18n.t("vagrant_kubevirt.error_recovering"))
+            terminate(env)
+          end
+        end
+
+        private
+
+        def provision_from_template(kubevirt, template, vm_name, cpus, memory_size)
+          begin
+            temp = kubevirt.templates.get(template)
+            temp.clone(name: vm_name, memory: memory_size, cpu_cores: cpus)
+          rescue Fog::Errors::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+        end
+
+        def provision_vm(kubevirt, vm_name, cpus, memory_size, volumes, ssh_info)
+          begin
+            init = {}
+            userData = ""
+
+            unless ssh_info.username.nil?
+              userData.concat("user: #{ssh_info.username}\n")
+            end
+            unless  ssh_info.password.nil?
+              userData.concat("password: #{ssh_info.password}\n")
+            end
+
+            unless userData.empty?
+              init = {:userData => "#cloud-config\n#{userData}chpasswd: { expire: False }"}
+            end
+
+            kubevirt.vms.create(vm_name: vm_name, cpus: cpus, memory_size: memory_size, volumes: volumes, cloudinit: init)
+          rescue Fog::Errors::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+        end
+
+        def create_service(kubevirt, vm_name, port_node)
+          begin
+            kubevirt.services.create(port: port_node, name: "#{vm_name}-ssh", target_port: 22, vmi_name: vm_name, service_type: "NodePort")
+          rescue Fog::Errors::Error => e
+            raise Errors::FogError, :message => e.message
+          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(Action.action_destroy, destroy_env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/action/destroy_vm.rb

@@ -0,0 +1,30 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Kubevirt
+    module Action
+      class DestroyVM
+        def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_kubevirt::action::destroy_vm")
+          @app = app
+        end
+
+        def call(env)
+          # Destroy the server, remove the tracking ID
+          env[:ui].info(I18n.t("vagrant_kubevirt.destroy_vm"))
+          kubevirt = env[:kubevirt_compute]
+
+          name = env[:machine].id.to_s
+          config = env[:machine].provider_config
+
+          kubevirt.vminstances.destroy(name, config.namespace)
+          kubevirt.services.delete("#{name}-ssh")
+
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/action/is_created.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Kubevirt
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      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-kubevirt/action/is_stopped.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Kubevirt
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is stopped and branch in the middleware.
+      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-kubevirt/action/read_ssh_info.rb

@@ -0,0 +1,54 @@
+require "log4r"
+
+module VagrantPlugins
+  module Kubevirt
+    module Action
+      # 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
+          @logger = Log4r::Logger.new("vagrant_kubevirt::action::read_ssh_info")
+        end
+
+        def call(env)
+          env[:machine_ssh_info] = read_ssh_info(env[:kubevirt_compute], env[:machine])
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(kubevirt, machine)
+          return nil if machine.id.nil?
+
+          vmi_name = machine.id
+
+          # Find the machine
+          vmi = kubevirt.vminstances.get(vmi_name)
+          if vmi.nil?
+            # The machine can't be found
+            @logger.info(I18n.t("vagrant_kubevirt.vm_not_found"))
+            machine.id = nil
+            return nil
+          end
+
+          node_name = vmi.node_name
+          if node_name.nil?
+            @logger.info(I18n.t("vagrant_kubevirt.not_running"))
+            return nil
+          end
+  
+          service = kubevirt.services.get("#{vmi_name}-ssh")
+          if service.nil?
+            raise Errors::NoServiceError, :name => vmi_name
+          end
+
+          info = { :host => vmi.node_name, :port => service.node_port }
+          key_path = machine.config.ssh.private_key_path
+          info[:private_key_path] = key_path unless key_path.nil? || key_path.empty?
+
+          return info
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/action/read_state.rb

@@ -0,0 +1,44 @@
+require "log4r"
+
+module VagrantPlugins
+  module Kubevirt
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_kubevirt::action::read_state")
+        end
+
+        def call(env)
+          env[:machine_state_id] = read_state(env[:kubevirt_compute], env[:machine])
+          @app.call(env)
+        end
+
+        def read_state(kubevirt, machine)
+          return :not_created if machine.id.nil?
+
+          begin
+            # Find the machine
+            vm = kubevirt.vms.get(machine.id)
+          rescue Fog::Kubevirt::Errors::ClientError => e
+            msg = e.message
+
+            unless msg.include? '404'
+              raise Errors::FogError, :message => msg
+            else
+              # The machine can't be found
+              @logger.info(I18n.t("vagrant_kubevirt.vm_not_found"))
+              machine.id = nil
+              return :not_created
+            end
+          end
+
+          # Return the state
+          return vm.status
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/action/set_domain_name.rb

@@ -0,0 +1,33 @@
+module VagrantPlugins
+  module Kubevirt
+    module Action
+
+      # Setup name for domain.
+      class SetDomainName
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:domain_name] = env[:root_path].basename.to_s.dup
+          env[:domain_name].gsub!(/([_.])/, '-')
+
+          # Check if the domain name is not already taken
+          kubevirt = env[:kubevirt_compute]
+          begin
+            kubevirt.vms.get(env[:domain_name])
+          rescue Fog::Kubevirt::Errors::ClientError => e
+            msg = e.message
+
+            unless msg.include? '404'
+              raise Errors::FogError, :message => msg
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+
+    end
+  end
+end

data/lib/vagrant-kubevirt/action/start_vm.rb

@@ -0,0 +1,35 @@
+
+require 'log4r'
+
+module VagrantPlugins
+  module Kubevirt
+    module Action
+
+      # Just start the VM.
+      class StartVM
+      	def initialize(app, env)
+          @logger = Log4r::Logger.new("vagrant_kubevirt::action::start_vm")
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_kubevirt.starting_vm"))
+
+          kubevirt = env[:kubevirt_compute]
+          # Start VM.
+          begin
+            vm = kubevirt.vms.get(env[:machine].id.to_s)
+            if vm == nil
+              raise Errors::NoVMError, :vm_name => env[:domain_name]
+            end
+            vm.start
+          rescue Fog::Errors::Error => e
+            raise Errors::StartVMError, :message => e.message
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/action/stop_vm.rb

@@ -0,0 +1,37 @@
+
+require "log4r"
+
+module VagrantPlugins
+  module Kubevirt
+    module Action
+      # This stops the running instance.
+      class StopVM
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_kubevirt::action::stop_vm")
+        end
+
+        def call(env)
+          begin
+            kubevirt = env[:kubevirt_compute]
+            vm = kubevirt.vms.get(env[:machine].id.to_s)
+            if vm == nil
+              raise Errors::NoVMError, :vm_name => env[:domain_name]
+            end
+
+            if vm.status == :stopped
+              env[:ui].info(I18n.t("vagrant_kubevirt.already_status", :status => env[:machine].state.id))
+            else
+              env[:ui].info(I18n.t("vagrant_kubevirt.stopping"))
+              vm.stop
+            end
+          rescue Fog::Errors::Error => e
+            raise Errors::StopVMError, :message => e.message
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/action/wait_for_state.rb

@@ -0,0 +1,64 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module Kubevirt
+    module Action
+      # This action will wait for a machine to reach a specific state or quit by timeout
+      class WaitForState
+        # env[:result] will be false in case of timeout.
+        # @param [Symbol] state Target machine state.
+        # @param [Number] timeout Timeout in seconds.
+        def initialize(app, env, state, timeout)
+          @app     = app
+          @logger  = Log4r::Logger.new("vagrant_kubevirt::action::wait_for_state")
+          @state   = state
+          @timeout = timeout
+        end
+
+
+        def call(env)
+          env[:result] = true
+          vm_name = env[:domain_name]
+          kubevirt = env[:kubevirt_compute]
+
+
+          if @state.to_s == 'running'
+            watch = kubevirt.watch_vminstances
+            kind = 'VirtualMachineInstance'
+            env[:ui].info(I18n.t("vagrant_kubevirt.wait_for_boot"))
+          else
+            watch = kubevirt.watch_vms
+            kind = 'VirtualMachine'
+            env[:ui].info(I18n.t("vagrant_kubevirt.wait_for_state", :state => @state))
+          end
+
+          vm = kubevirt.vms.get(vm_name)
+
+          if vm.status == @state
+            env[:ui].info(I18n.t("vagrant_kubevirt.already_status", :status => @state))
+          else
+            begin
+              Timeout.timeout(@timeout) do
+                watch.each do |notice|
+                  break if notice.kind == kind && notice.name == vm_name && !notice.status.nil? && notice.status.downcase == @state.to_s
+                end
+              end
+            rescue Timeout::Error
+              raise Errors::VMReadyTimeout, timeout: @timeout
+            end
+          end
+          watch.finish
+
+          # wait for sshd to be up
+          if @state.to_s == 'running'
+            wait = env[:machine].config.vm.boot_timeout
+            env[:machine].communicate.wait_for_ready(wait)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end