vagrant-kubevirt 1.0.0

data/lib/vagrant-kubevirt/config.rb

@@ -0,0 +1,60 @@
+require "vagrant"
+require "iniparse"
+
+module VagrantPlugins
+  module Kubevirt
+    class Config < Vagrant.plugin("2", :config)
+
+      attr_accessor :token
+      attr_accessor :hostname
+      attr_accessor :port
+      attr_accessor :namespace
+
+      # Domain specific settings used while creating new machine.
+      attr_accessor :memory
+      attr_accessor :cpus
+      attr_accessor :template
+      attr_accessor :image
+      attr_accessor :pvc
+      attr_accessor :port_node
+
+      def initialize
+      	@token     = UNSET_VALUE
+        @hostname  = UNSET_VALUE
+        @port      = UNSET_VALUE
+        @namespace = UNSET_VALUE
+
+        @memory    = UNSET_VALUE
+        @cpus      = UNSET_VALUE
+        @template  = UNSET_VALUE
+        @image     = UNSET_VALUE
+        @pvc       = UNSET_VALUE
+        @port_node = UNSET_VALUE
+      end
+
+      def finalize!
+      	@token = nil if @token == UNSET_VALUE
+      	@hostname = 'localhost' if @hostname == UNSET_VALUE
+      	@port = '8443' if @port == UNSET_VALUE
+      	@namespace = 'default' if @namespace == UNSET_VALUE
+
+        @memory = 512 if @memory == UNSET_VALUE
+        @cpus = 1 if @cpus == UNSET_VALUE
+        @template = nil if @template == UNSET_VALUE
+        @image = nil if @image == UNSET_VALUE
+        @pvc = nil if @pvc == UNSET_VALUE
+        @port_node = 30000 if @port_node == UNSET_VALUE
+      end
+
+      def validate(machine)
+        errors = _detected_errors
+
+        config = machine.provider_config
+
+        errors << I18n.t("vagrant_kubevirt.config.image_info_required") if config.template.nil?  and config.image.nil? and config.pvc.nil?
+
+        { 'Kubevirt Provider' => errors }
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/errors.rb

@@ -0,0 +1,39 @@
+require "vagrant"
+
+module VagrantPlugins
+  module Kubevirt
+    module Errors
+      class VagrantKubevirtError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_kubevirt.errors")
+      end
+
+      class FogError < VagrantKubevirtError
+        error_key(:fog_error)
+      end
+
+      class NoVMError < VagrantKubevirtError
+        error_key(:no_vm_error)
+      end
+
+      class StartVMError < VagrantKubevirtError
+        error_key(:start_vm_error)
+      end
+
+      class StopVMError < VagrantKubevirtError
+        error_key(:stop_vm_error)
+      end
+
+      class VMReadyTimeout < VagrantKubevirtError
+        error_key(:vm_ready_timeout)
+      end
+
+      class NoNodeError < VagrantKubevirtError
+        error_key(:no_node_error)
+      end
+
+      class NoServiceError < VagrantKubevirtError
+        error_key(:no_service_error)
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant Kubevirt plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "The Vagrant Kubevirt plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module Kubevirt
+    class Plugin < Vagrant.plugin('2')
+      name "Kubevirt"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      Kubevirt machines.
+      DESC
+
+      config(:kubevirt, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:kubevirt, parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", Kubevirt.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_kubevirt")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/provider.rb

@@ -0,0 +1,50 @@
+require "log4r"
+require "vagrant"
+
+module VagrantPlugins
+  module Kubevirt
+    class Provider < Vagrant.plugin("2", :provider)
+      def initialize(machine)
+        @machine = machine
+      end
+
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action.
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+        nil
+      end
+
+      def ssh_info
+        # Run a custom action called "read_ssh_info" which does what it
+        # says and puts the resulting SSH info into the `:machine_ssh_info`
+        # key in the environment.
+        env = @machine.action("read_ssh_info", lock: false)
+        env[:machine_ssh_info]
+      end
+
+      def state
+        # Run a custom action we define called "read_state" which does
+        # what it says. It puts the state in the `:machine_state_id`
+        # key in the environment.
+        env = @machine.action("read_state", lock: false)
+
+        state_id = env[:machine_state_id]
+
+        # Get the short and long description
+        short = I18n.t("vagrant_kubevirt.states.short_#{state_id}")
+        long  = I18n.t("vagrant_kubevirt.states.long_#{state_id}")
+
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, long)
+      end
+
+      def to_s
+        id = @machine.id.nil? ? "new" : @machine.id
+        "Kubevirt (#{id})"
+      end
+    end
+  end
+end

data/lib/vagrant-kubevirt/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module Kubevirt
+    VERSION = '1.0.0'
+  end
+end

data/locales/en.yml

@@ -0,0 +1,69 @@
+en:
+  vagrant_kubevirt:
+    creating_vm: |-
+      Creating VM with the following settings...
+    already_status: |-
+      The VM is already %{status}.
+    error_recovering: |-
+      An error occured. Recovering..
+    starting_vm: |-
+      Starting the VM...
+    wait_for_state: |-
+      Waiting for VM to reach state %{state}
+    not_created: |-
+      Virtual machine is not created. Please run `vagrant up` first.
+    action_failed: |-
+      %{action} failed.
+    stopping: |-
+      Stopping the VM...
+    destroy_vm: |-
+      Removing the VM...
+    vm_not_found: |-
+      The VM not found or terminated, assuming it got destroyed.
+    vm_exists: |-
+      The VM is already created
+    not_running: |-
+      The VM is not running
+    wait_for_boot: |-
+      Waiting for VM to boot
+
+    config:
+      kubevirt_info_required: |-
+        One or more of the needed Kubevirt connection details are missing.
+      image_info_required: |-
+        Either template, pvc or image details are required.
+
+    states:
+      short_not_created: |-
+        not created
+      long_not_created: |-
+        The virtual machine is not created. Run `vagrant up` to create it.
+      short_running: |-
+        running
+      long_running: |-
+        The virtual machine is running. To stop this machine, you can run
+        `vagrant halt`. To destroy the machine, you can run `vagrant destroy`.
+      short_stopped: |-
+        stopped
+      long_stopped: |-
+        The virtual machine is stopped. Run `vagrant up` to start it.
+
+    errors:
+      fog_error: |-
+        There was an error talking to Kubevirt. The error message is shown
+        below:
+
+        %{message}
+      no_vm_error: |-
+        No VM %{vm_name} found.
+      start_vm_error: |-
+        Unable to start VM: %{message}
+      stop_vm_error: |-
+        Unable to stop VM: %{message}
+      vm_ready_timeout: |-
+        The VM never became "ready" in AWS. The timeout currently
+        set waiting for the vm to become ready is %{timeout} seconds.
+      no_node_error: |-
+        The VM is not running on a node.
+      no_service_error: |-
+        No service configured for VM: %{name}

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'vagrant-kubevirt'
+require 'support/environment_helper'
+require 'vagrant-spec/unit'
+
+RSpec.configure do |spec|
+end

data/spec/support/environment_helper.rb

@@ -0,0 +1,18 @@
+class EnvironmentHelper
+
+  def cpus
+    1
+  end
+
+  def memory
+    512
+  end
+
+  def machine
+    self
+  end
+
+  def provider_config
+    self
+  end
+end

data/spec/support/kubevirt_context.rb

@@ -0,0 +1,15 @@
+require 'fog/kubevirt'
+
+shared_context 'kubevirt' do
+  include_context 'unit'
+
+  let(:kubevirt_context) { true }
+  let(:id)               { 'dummy-vagrant_dummy' }
+
+  before (:each) do
+    stub_const('Fog::Kubevirt::Compute', compute)
+    allow(compute).to receive(:new).with(hash_including(:kubevirt_hostname, :kubevirt_port, :kubevirt_token, :kubevirt_namespace, :kubevirt_log)).and_return(compute)
+
+    allow(machine).to receive(:id).and_return(id)
+  end
+end

data/spec/support/sharedcontext.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+shared_context 'unit' do
+  include_context 'vagrant-unit'
+
+  let(:vagrantfile) do
+    <<-EOF
+    Vagrant.configure('2') do |config|
+      config.vm.box = 'kubevirt'
+      config.vm.define :test
+
+      config.vm.provider :kubevirt do |kubevirt|
+        kubevirt.token = 'abc'
+        kubevirt.template = 'working'
+      end
+    end
+    EOF
+  end
+  let(:test_env) do
+    test_env = isolated_environment
+    test_env.vagrantfile vagrantfile
+    test_env
+  end
+  let(:env)              { { env: iso_env, machine: machine, ui: ui, root_path: File.expand_path(File.dirname(__FILE__)),  kubevirt_compute: compute, domain_name: 'Test', action_runner: runner} }
+  let(:conf)             { Vagrant::Config::V2::DummyConfig.new }
+  let(:ui)               { Vagrant::UI::Basic.new }
+  let(:iso_env)          { test_env.create_vagrant_env ui_class: Vagrant::UI::Basic }
+  let(:machine)          { iso_env.machine(:test, :kubevirt) }
+  let(:app)              { ->(env) {} }
+  let(:plugin)           { register_plugin }
+  let(:compute)          { double('compute') }
+  let(:runner)           { double('runner') }
+end

data/spec/unit/action/create_vm_spec.rb

@@ -0,0 +1,122 @@
+require 'support/sharedcontext'
+require 'support/kubevirt_context'
+
+require 'vagrant-kubevirt/action/create_vm'
+
+describe VagrantPlugins::Kubevirt::Action::CreateVM do
+  subject { described_class.new(app, env) }
+
+  include_context 'unit'
+  include_context 'kubevirt'
+
+  let(:services) { double('service') }
+  let(:vms) { double('vms') }
+  let(:vm) { double('vm') }
+
+  describe '#call' do
+    before do
+      allow(compute).to receive(:vms).and_return(vms)
+      allow(compute).to receive(:services).and_return(services)
+      allow(services).to receive(:create)
+
+      allow(vms).to receive(:get).and_return(vm)
+      allow(vm).to receive(:name).and_return('Test')
+
+      expect(ui).to receive(:info).with('Creating VM with the following settings...')
+      expect(ui).to receive(:info).with(' -- Name:          Test')
+      expect(ui).to receive(:info).with(' -- Namespace:     default')
+      expect(ui).to receive(:info).with(' -- Cpus:          1')
+      expect(ui).to receive(:info).with(' -- Memory:        512M')
+    end
+
+    context 'when template defined' do
+      let(:templates) { double('templates') }
+      let(:template) { double('template') }
+
+      before do
+        allow(compute).to receive(:templates).and_return(templates)
+        allow(templates).to receive(:get).and_return(template)
+
+        expect(template).to receive(:clone)
+        expect(ui).to receive(:info).with(' -- Template:      working')
+      end
+
+      it 'clones a template' do
+        expect(subject.call(env)).to be_nil
+      end
+
+      it 'recovers after interruption' do
+        env[:interrupted] = true
+        expect(runner).to receive(:run)
+
+        expect(subject.call(env)).to be_nil
+      end
+    end
+
+    context 'when image defined' do
+      let(:vagrantfile) do
+        <<-EOF
+        Vagrant.configure('2') do |config|
+          config.vm.box = 'kubevirt'
+          config.vm.define :test
+
+          config.vm.provider :kubevirt do |kubevirt|
+            kubevirt.token = 'abc'
+            kubevirt.image = 'kubevirt/fedora'
+          end
+        end
+        EOF
+      end
+
+      it 'creates a vm using image' do
+        expect(vms).to receive(:create).with(hash_including(:vm_name => "Test", :cpus => 1, :memory_size => 512, :image => 'kubevirt/fedora', :pvc => nil))
+
+        expect(subject.call(env)).to be_nil
+      end
+    end
+
+    context 'when pvc defined' do
+      let(:vagrantfile) do
+        <<-EOF
+        Vagrant.configure('2') do |config|
+          config.vm.box = 'kubevirt'
+          config.vm.define :test
+
+          config.vm.provider :kubevirt do |kubevirt|
+            kubevirt.token = 'abc'
+            kubevirt.pvc = 'my_disk'
+          end
+        end
+        EOF
+      end
+
+      it 'creates a vm using pvc' do
+        expect(vms).to receive(:create).with(hash_including(:vm_name => "Test", :cpus => 1, :memory_size => 512, :image => nil, :pvc => "my_disk"))
+
+        expect(subject.call(env)).to be_nil
+      end
+    end
+
+    context 'with folders synchronized' do
+      let(:vagrantfile) do
+        <<-EOF
+        Vagrant.configure('2') do |config|
+          config.vm.box = 'kubevirt'
+          config.vm.define :test
+          config.vm.synced_folder "", "/srv/website"
+          config.vm.provider :kubevirt do |kubevirt|
+            kubevirt.token = 'abc'
+            kubevirt.image = 'kubevirt/fedora'
+          end
+        end
+        EOF
+      end
+
+      it 'creates a vm with folder defined' do
+        expect(vms).to receive(:create).with(hash_including(:vm_name => "Test", :cpus => 1, :memory_size => 512, :image => 'kubevirt/fedora', :pvc => nil))
+
+        expect(subject.call(env)).to be_nil
+      end
+    end
+  end
+end