vagrant-kvm 0.1.7 → 0.1.8

data/lib/vagrant-kvm/action/customize.rb

@@ -0,0 +1,44 @@
+module VagrantPlugins
+  module ProviderKvm
+    module Action
+      class Customize
+        def initialize(app, env, event)
+          @app = app
+          @event = event
+          @logger = Log4r::Logger.new("vagrant::kvm::action::customize")
+        end
+
+        def call(env)
+          customizations = []
+          env[:machine].provider_config.customizations.each do |event, command|
+            if event == @event
+              customizations << command
+            end
+          end
+
+          if !customizations.empty?
+            @logger.info("customize.running")
+
+            # Execute each customization command.
+            customizations.each do |command|
+              processed_command = command.collect do |arg|
+                arg = env[:machine].id if arg == :id
+                arg.to_s
+              end
+
+              result = env[:machine].provider.driver.execute_command(processed_command)
+              if result.exit_code != 0
+                raise Vagrant::Errors::VMCustomizationFailed, {
+                  :command => processed_command.inspect,
+                  :error   => result.stderr
+                }
+              end
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-kvm/action/import.rb

@@ -35,17 +35,53 @@ module VagrantPlugins
             :cpu_model     => provider_config.cpu_model,
             :machine_type  => provider_config.machine_type,
             :network_model => provider_config.network_model,
-            :video_model   => provider_config.video_model
+            :video_model   => provider_config.video_model,
+            :virtio_rng    => provider_config.virtio_rng
           }.merge(args)
 
+          args[:disk_bus]   = provider_config.disk_bus if provider_config.disk_bus
+
+          # Permission/Security Model detection
+          driver = @env[:machine].provider.driver
+          # defaults
+          args[:userid] = Process.uid.to_s
+          args[:groupid] = Process.gid.to_s
+          args[:dirmode] = '0775'
+          args[:filemode] = '0664'
+          args[:label] = 'virt_image_t'
+          args[:secmodel] = nil
+          # Optional security label
+          if provider_config.seclabel == 'on'
+            # OS specific
+            if driver.host_redhat?
+              # on Redhat/Fedora, permission is controlled
+              # with only SELinux
+              args[:secmodel] = 'selinux'
+              args[:dirmode]  = '0777'
+              args[:filemode] = '0666'
+            elsif driver.host_arch?
+              # XXX: should be configurable
+              args[:secmodel] = 'dac'
+            elsif driver.host_ubuntu?
+              args[:secmodel] = 'apparmor'
+              args[:groupid] = Etc.getgrnam('kvm').gid.to_s
+            elsif driver.host_debian?
+              # XXX: should be configurable
+              args[:secmodel] = 'dac'
+              args[:groupid] = Etc.getgrnam('kvm').gid.to_s
+            end
+          end
+
           # Import the virtual machine
-          storage_path = File.join(@env[:tmp_path],"/storage-pool")
+
+          # Get storage pool directory
+          storage_path = @env[:machine].provider.driver.storage_pool_path
           box_file = @env[:machine].box.directory.join("box.xml").to_s
           raise Errors::KvmBadBoxFormat unless File.file?(box_file)
 
           # check pool migration neccesary?
           if @env[:machine].provider.driver.pool_migrate
-            @env[:ui].output "Your vagrant-kvm environment should be fixed. see README"
+            @env[:ui].output I18n.t("vagrant_kvm.kvm_spool_problem_inform")
           end
 
           # repair directories permission
@@ -92,22 +128,15 @@ module VagrantPlugins
             box_name = @env[:machine].config.vm.box
             driver = @env[:machine].provider.driver
             userid = Process.uid.to_s
-            groupid = Process.gid.to_s
-            modes = {:dir => '0775', :file => '0664'}
-            label = 'virt_image_t'
-            if driver.host_redhat?
-              # on Redhat/Fedora, permission is controlled
-              # with only SELinux
-              modes = {:dir => '0777',:file => '0666'}
-            elsif driver.host_debian?
-              groupid = Etc.getgrnam('kvm').gid.to_s
-            else
-              # XXX: default
+            begin
+              # vagrant 1.5+
+              box_version = @env[machine].config.vm.box_version
+              pool_name = 'vagrant_' + userid + '_' + box_name + '_' + box_version.to_s
+            rescue
+              # before varant 1.5
+              pool_name = 'vagrant_' + userid + '_' + box_name
             end
-            pool_name = 'vagrant_' + userid + '_' + box_name
-            driver.init_storage_directory(
-                :pool_path => File.dirname(old_path), :pool_name => pool_name,
-                :owner => userid, :group => groupid, :mode => modes[:dir])
+            driver.init_storage_pool(pool_name, File.dirname(old_path), args[:dirmode])
             driver.create_volume(
                 :disk_name => new_disk,
                 :capacity => box.capacity,
@@ -116,10 +145,10 @@ module VagrantPlugins
                 :box_pool => pool_name,
                 :box_path => old_path,
                 :backing => args[:image_backing],
-                :owner => userid,
-                :group => groupid,
-                :mode => modes[:file],
-                :label => label)
+                :owner => args[:userid],
+                :group => args[:groupid],
+                :mode => args[:filemode],
+                :label => args[:label])
             driver.free_storage_pool(pool_name)
           else
             @logger.info "Image type #{args[:image_type]} is not supported"
@@ -139,7 +168,7 @@ module VagrantPlugins
           # check pathes
           [home_path, boxes_path].each do |d|
             s = File::Stat.new(d)
-            @logger.debug("#{d} permission: #{s.mode}")
+            @logger.debug("#{d} permission: #{s.mode.to_s(8)}")
             if (s.mode & 1 == 0)
               @env[:ui].info I18n.t("vagrant_kvm.repair_permission",:directory => d,
                 :old_mode => sprintf("%o",s.mode), :new_mode => sprintf("%o", s.mode|1))

data/lib/vagrant-kvm/action/init_storage_pool.rb

@@ -8,10 +8,11 @@ module VagrantPlugins
         end
 
         def call(env)
-          # Create a storage pool in tmp_path if it doesn't exist
-          userid = Process.uid.to_s
-          groupid = Process.gid.to_s
-          Driver::Driver.new.init_storage(env[:tmp_path], userid, groupid)
+          # Create the storage pool in tmp_path if it doesn't exist
+          pool = env[:machine].provider_config.storage_pool
+          pool_path = File.join(env[:tmp_path], "/storage-pool")
+          env[:machine].provider.driver.init_storage_pool(pool, pool_path)
+          env[:machine].provider.driver.activate_storage_pool(pool)
 
           @app.call(env)
         end

data/lib/vagrant-kvm/action/network.rb

@@ -9,51 +9,148 @@ module VagrantPlugins
         def initialize(app, env)
           @logger = Log4r::Logger.new("vagrant::plugins::kvm::network")
           @app    = app
+          @hosts = []
         end
 
         def call(env)
-          # TODO: Validate network configuration prior to anything below
           @env = env
 
-          options= {}
-          env[:machine].config.vm.networks.each do |type, network_options|
-            options = network_options if type == :private_network
+          @env[:ui].info I18n.t("vagrant.actions.vm.network.preparing")
+          create_or_start_default_network!
+          create_or_update_private_network!
+
+          @app.call(env)
+        end
+
+        private
+
+        def create_or_start_default_network!
+          # default NAT network/nic
+          @env[:machine_ip] = select_default_ip
+          @env[:machine].provider.driver.create_network(
+            :name  => get_network_name(@env[:machine_ip]), 
+            :hosts => [{
+              :mac   => @env[:machine].provider.driver.read_mac_address,
+              :name => get_host_name,
+              :ip   => @env[:machine_ip]
+            }]
+          )
+        end
+
+        def create_or_update_private_network!
+          # enumerate private network options
+          private_network_options = []
+          @env[:machine].config.vm.networks.each do |type, network_options|
+            private_network_options << network_options if type == :private_network
           end
 
-          options[:ip] = "192.168.123.10" unless options.has_key?(:ip)
-          addr = options[:ip].split(".")
-          addr[3] = "1"
-          base_ip = addr.join(".")
-          addr[3] = "100"
-          start_ip = addr.join(".")
-          addr[3] = "200"
-          end_ip = addr.join(".")
-          range = {
+          private_network_options.each_with_index do |option,index|
+            option = set_private_network_options(option)
+            if check_private_network_segment(option)
+              add_private_network_host(option, index)
+            else
+              @logger.info ("Ignore invalid private network definition.")
+            end
+          end
+        end
+
+        def get_host_name
+          if @env[:machine].provider.driver.name
+            @env[:machine].provider.driver.name
+          elsif @env[:machine].provider_config.name
+            @env[:machine].provider_config.name
+          else
+            "nic-"+Time.now.to_i.to_s
+          end
+        end
+
+        def get_network_name(ip)
+          subnet = ip.split(".")[2].to_s
+          default_subnet = @env[:machine].provider.driver.get_default_ip.split(".")[2].to_s
+          if subnet == default_subnet
+            "vagrant"
+          else
+            "vagrant-"+subnet
+          end
+        end
+
+        def add_private_network_host(option, index)
+            mac = random_mac
+            option[:hosts]= [{
+              :mac => mac,
+              :name => get_host_name,
+              :ip => option[:ip]
+            }]
+            addr = option[:ip].split(".")
+            nic = { :mac => mac,
+                    :name=> "eth"+(index+1).to_s,
+                    :network => "vagrant-"+addr[2].to_s,
+                    :type => 'network',
+                    :model => 'virtio'}
+            @env[:machine].provider.driver.add_nic(nic)
+            @env[:machine].provider.driver.create_network(option)
+        end
+
+        def select_default_ip
+          ip_addresses = @env[:machine].provider.driver.list_default_network_ips
+          candidate = ""
+          loop do
+            candidate = 2 + Random.rand(253)
+            candidate = "192.168.123.%d" % candidate
+           break unless ip_addresses.include?(candidate)
+          end
+          @logger.info("select #{candidate} as default ip address for nic")
+          candidate
+        end
+
+        # check options[:ip] is not reserved?
+        def check_private_network_segment(options)
+          if options.has_key?(:ip)
+            addr = options[:ip].split(".")
+            # except for virbr{0|1} and hostonly network
+            if @env[:machine].provider.driver.host_ubuntu?
+              return false if addr[2] == '122' || addr[2] == '100' || addr[2] == '123'
+            else
+              return false if addr[2] == '123'
+            end
+          end
+        true
+        end
+
+        def set_private_network_options(options)
+          if options.has_key?(:ip)
+            addr = options[:ip].split(".")
+            addr[3] = "1"
+            base_ip = addr.join(".")
+            addr[3] = "100"
+            start_ip = addr.join(".")
+            addr[3] = "200"
+            end_ip = addr.join(".")
+            range = {
               :start => start_ip,
               :end   => end_ip }
-          options = {
+            options = {
               :base_ip => base_ip,
               :netmask => "255.255.255.0",
-              :range   => range
-          }.merge(options)
-
-          hosts = []
-          name = env[:machine].provider_config.name ?
-                      env[:machine].provider_config.name : "default"
-          hosts << {
-            :mac => format_mac(env[:machine].config.vm.base_mac),
-            :name => name,
-            :ip => options[:ip]
-          }
-          options[:hosts] = hosts
-
-          env[:ui].info I18n.t("vagrant.actions.vm.network.preparing")
-          env[:machine].provider.driver.create_network(options)
+              :range   => range,
+              :name    => "vagrant-" + addr[2].to_s,
+              :domain_name => "vagrant.local"
+            }.merge(options)
+          end
+          options
+        end
 
-          @app.call(env)
+        def random_mac
+          rng = Random.new(Time.now.to_i)
+          mac = [0x00, 0x16, 0x3e,
+                rng.rand(128),
+                rng.rand(256),
+                rng.rand(256)]
+          mac.map {|x| "%02x" % x}.join(":")
         end
 
         def format_mac(mac)
+          return nil unless mac
           if mac.length == 12
             mac = mac[0..1] + ":" + mac[2..3] + ":" +
               mac[4..5] + ":" + mac[6..7] + ":" +

data/lib/vagrant-kvm/action/{prepare_gui.rb → prepare_kvmconfig.rb}

@@ -1,7 +1,7 @@
 module VagrantPlugins
   module ProviderKvm
     module Action
-      class PrepareGui
+      class PrepareKvmConfig
         def initialize(app, env)
           @app = app
         end
@@ -12,6 +12,9 @@ module VagrantPlugins
             driver = env[:machine].provider.driver
             driver.set_gui(config.vnc_port, config.vnc_autoport, config.vnc_password)
           end
+          # set disk_bus customize
+          disk_bus = env[:machine].provider_config.disk_bus
+          env[:machine].provider.driver.set_diskbus(disk_bus) if disk_bus
           @app.call(env)
         end
       end

data/lib/vagrant-kvm/action/prepare_nfs_settings.rb

@@ -11,42 +11,35 @@ module VagrantPlugins
           @app.call(env)
           @machine = env[:machine]
 
-          env[:nfs_host_ip]    = read_host_ip(env[:machine])
-          env[:nfs_machine_ip] = read_machine_ip(env[:machine])
+          if using_nfs?
+            env[:nfs_host_ip]    = read_host_ip
+            env[:nfs_machine_ip] = read_machine_ip
+          end
+        end
 
+        def using_nfs?
+            @machine.config.vm.synced_folders.any? { |_, opts| opts[:type] == :nfs }
         end
 
-        # Returns the IP address of the first host only network adapter
+        # Returns the IP address of the host
         #
         # @param [Machine] machine
         # @return [String]
-        def read_host_ip(machine)
-          ip = read_machine_ip(machine)
-          if ip
-            base_ip = ip.split(".")
-            base_ip[3] = "1"
-            return base_ip.join(".")
-          end
-
-          # If no private network configuration, return default ip
-          "192.168.123.1"
+        def read_host_ip
+          ip = read_machine_ip
+          base_ip = ip.split(".")
+          base_ip[3] = "1"
+          base_ip.join(".")
         end
 
         # Returns the IP address of the guest by looking at the first
         # enabled host only network.
         #
         # @return [String]
-        def read_machine_ip(machine)
-          machine.config.vm.networks.each do |type, options|
-            if type == :private_network && options[:ip].is_a?(String)
-              return options[:ip]
-            end
-          end
-
-          # XXX duplicated with network.rb default
-          # If no private network configuration, return default ip
-          "192.168.123.10"
+        def read_machine_ip
+          @machine.provider.driver.read_machine_ip
         end
+
       end
     end
   end

data/lib/vagrant-kvm/action/set_name.rb

@@ -10,18 +10,42 @@ module VagrantPlugins
         def call(env)
           name = env[:machine].provider_config.name
 
+          # If we already set the name before, then don't do anything
+          sentinel = env[:machine].data_dir.join("action_set_name")
+          if !name && sentinel.file?
+            @logger.info("Default name was already set before, not doing it again.")
+            return @app.call(env)
+          end
+
+          # If no name was manually set, then use a default
           if !name
-            prefix = env[:root_path].basename.to_s
+            prefix = "#{env[:root_path].basename.to_s}_#{env[:machine].name}"
             prefix.gsub!(/[^-a-z0-9_]/i, "")
-            name = prefix + "_#{Time.now.to_i}"
+            name = prefix + "_#{(Time.now.to_f * 1000.0).to_i}_#{rand(100000)}"
           end
 
           # @todo raise error if name is taken in kvm
-          # @todo don't set the name if the vm already has a name
+          # Verify the name is not taken
+          # vms = env[:machine].provider.driver.read_vms
+          #raise Vagrant::Errors::VMNameExists, :name => name if \
+          #  vms.has_key?(name) && vms[name] != env[:machine].id
+          #
+          #if vms.has_key?(name)
+          #  @logger.info("Not setting the name because our name is already set.")
+          #else
+          #  env[:ui].info(I18n.t(
+          #    "vagrant.actions.vm.set_name.setting_name", name: name))
+          #  env[:machine].provider.driver.set_name(name)
+          #end
 
           @logger.info("Setting the name of the VM: #{name}")
           env[:machine].provider.driver.set_name(name)
 
+          # Create the sentinel
+          sentinel.open("w") do |f|
+            f.write(Time.now.to_i.to_s)
+          end
+
           @app.call(env)
         end