vmit 0.0.3 → 0.0.3.99

data/lib/vmit/kickstart.rb

@@ -18,17 +18,53 @@
 # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
-require 'vmit'
 require 'erb'
+require 'vmit/unattended_install'
+require 'vmit/vfs'
 
 module Vmit
 
-  class Kickstart
+  class Kickstart < UnattendedInstall
 
-    attr_accessor :install
+    def initialize(location)
+      super(location)
 
-    # ks=floppy
-    def initialize
+      media = Vmit::VFS.from(location)
+      case media
+        when Vmit::VFS::URI
+          @install = location
+        when Vmit::VFS::ISO
+          @install = :cdrom
+          vm.config.configure(:cdrom => location.to_s)
+        else raise ArgumentError.new("Unsupported autoinstallation: #{location}")
+      end
+    end
+
+    def execute_autoinstall(vm, args)
+      vm.config.push!
+      begin
+        vm.config.configure(args)
+        if @install == :cdrom
+          vm.config.configure(:cdrom => location.to_s)
+        end
+
+        Dir.mktmpdir do |floppy_dir|
+          FileUtils.chmod_R 0755, floppy_dir
+          vm.config.floppy = floppy_dir
+          vm.config.add_kernel_cmdline!('ks=floppy')
+          vm.config.add_kernel_cmdline!("repo=#{@install}")
+          vm.config.reboot = false
+
+          File.write(File.join(floppy_dir, 'ks.cfg'), to_ks_script)
+          Vmit.logger.info "Kickstart: 1st stage."
+          vm.up
+          vm.wait_until_shutdown! do
+            vm.vnc
+          end
+        end
+      ensure
+        vm.config.pop!
+      end
     end
 
     def to_ks_script
@@ -41,10 +77,10 @@ keyboard us
 timezone --utc America/New_York
 bootloader --location=mbr --driveorder=sda --append="rhgb quiet"
 install
-<% if install.is_a?(String) || install.is_a?(::URI)%>
-url --url=<%= install.to_s.strip %>
+<% if @install.is_a?(String) || @install.is_a?(::URI)%>
+url --url=<%= @install.to_s.strip %>
 <% else %>
-<%= install %>
+<%= @install %>
 <% end %>
 network --device eth0 --bootproto dhcp
 zerombr yes

data/lib/vmit/libvirt_vm.rb

@@ -0,0 +1,274 @@
+require 'confstruct'
+require 'libvirt'
+require 'nokogiri'
+require 'vmit/workspace'
+
+module Vmit
+
+  class LibvirtVM
+
+    attr_reader :workspace
+    attr_reader :config
+    attr_reader :conn
+
+    def self.from_pwd(opts={})
+      workspace = Vmit::Workspace.from_pwd
+      LibvirtVM.new(workspace, opts)
+    end
+
+    # @param [Vmit::Workspace] workspace to run
+    # @param [Hash] runtime options that override
+    #   the virtual machine options
+    def initialize(workspace, opts={})
+      @workspace = workspace
+      @config = Confstruct::Configuration.new(@workspace.config)
+      @config.configure(opts)
+
+      @conn = ::Libvirt::open("qemu:///system")
+      if not @conn
+        raise 'Can\'t initialize hypervisor'
+      end
+    end
+
+    # @return [Libvirt::Domain] returns the libvirt domain
+    #   or creates one for the workspace if it does not exist
+    def domain
+      conn.lookup_domain_by_name(workspace.name) rescue nil
+    end
+
+    def up
+      unless down?
+        Vmit.logger.error "#{workspace.name} is already up. Run 'vmit ssh' or 'vmit vnc' to access it."
+        return
+      end
+
+      Vmit.logger.debug "\n#{conn.capabilities}"
+      Vmit.logger.info "Starting VM..."
+
+      network = conn.lookup_network_by_name('default')
+      Vmit.logger.debug "\n#{network.xml_desc}"
+      if not network.active?
+        network.create
+      end
+      Vmit.logger.debug "\n#{self.to_libvirt_xml}"
+
+      puts domain.inspect
+      domain.destroy if domain
+      if domain.nil?
+        conn.create_domain_xml(self.to_libvirt_xml)
+      end
+    end
+
+    def state
+      assert_up
+      st, reason = domain.state
+      st_sym = case st
+        when Libvirt::Domain::NOSTATE then :unknown
+        when Libvirt::Domain::RUNNING then :running
+        when Libvirt::Domain::BLOCKED then :blocked
+        when Libvirt::Domain::PAUSED then :paused
+        when Libvirt::Domain::SHUTDOWN then :shutdown
+        when Libvirt::Domain::SHUTOFF then :shutoff
+        when Libvirt::Domain::CRASHED then :crashed
+        when Libvirt::Domain::PMSUSPENDED then :pmsuspended
+      end
+      return st_sym, reason
+    end
+
+    def up?
+      !domain.nil? && domain.active?
+    end
+
+    def assert_up
+      unless up?
+        raise "VM is not running. Try 'vmit up'..."
+      end
+    end
+
+    def assert_down
+      if up?
+        raise "VM is running. Try 'vmit down'..."
+      end
+    end
+
+    def down?
+      !up?
+    end
+
+    def reboot
+      assert_up
+      domain.reboot
+    end
+
+    def shutdown
+      assert_up
+      domain.shutdown
+    end
+
+    def destroy
+      if domain
+        domain.destroy
+      end
+    end
+
+    # Waits until the machine is shutdown
+    # executing the passed block.
+    #
+    # If the machine is shutdown, the
+    # block will be killed. If the block
+    # exits, the machine will be stopped
+    # immediately (domain destroyed)
+    #
+    # @example
+    #   vm.wait_until_shutdown! do
+    #     vm.vnc
+    #   end
+    #
+    def wait_until_shutdown!(&block)
+      chars = %w{ | / - \\ }
+      thread = Thread.new(&block)
+      thread.abort_on_exception = true
+
+      Vmit.logger.info "Waiting for machine..."
+      while true
+        print chars[0]
+
+        if down?
+          Thread.kill(thread)
+          return
+        end
+        if not thread.alive?
+          domain.destroy
+        end
+        sleep(1)
+        print "\b"
+        chars.push chars.shift
+      end
+
+    end
+
+    def ip_address
+      File.open('/var/lib/libvirt/dnsmasq/default.leases') do |f|
+        f.each_line do |line|
+          parts = line.split(' ')
+          if parts[1] == config.mac_address
+            return parts[2]
+          end
+        end
+      end
+      nil
+    end
+
+    def spice_address
+      assert_up
+      doc = Nokogiri::XML(domain.xml_desc)
+      port = doc.xpath("//graphics[@type='spice']/@port")
+      listen = doc.xpath("//graphics[@type='spice']/listen[@type='address']/@address")
+      return listen, port
+    end
+
+    def vnc_address
+      assert_up
+      doc = Nokogiri::XML(domain.xml_desc)
+      port = doc.xpath("//graphics[@type='vnc']/@port")
+      listen = doc.xpath("//graphics[@type='vnc']/listen[@type='address']/@address")
+      "#{listen}:#{port}"
+    end
+
+    # synchronus spice viewer
+    def spice
+      assert_up
+      addr, port = spice_address
+      raise "Can't get the SPICE information from the VM" unless addr
+      system("spicec --host #{addr} --port #{port}")
+    end
+
+    # synchronus vnc viewer
+    def vnc
+      assert_up
+      addr = vnc_address
+      raise "Can't get the VNC information from the VM" unless addr
+      system("vncviewer #{addr}")
+    end
+
+    def [](key)
+      if @runtime_opts.has_key?(key)
+        @runtime_opts[key]
+      else
+        workspace[key]
+      end
+    end
+
+    def to_libvirt_xml
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.domain(:type => 'kvm') {
+          xml.name workspace.name
+          xml.uuid config.uuid
+          match = /([0-9+])([^0-9+])/.match config.memory
+          xml.memory(match[1], :unit => match[2])
+          xml.vcpu 1
+          xml.os {
+            xml.type('hvm', :arch => 'x86_64')
+            if config.lookup!('kernel')
+              xml.kernel config.kernel
+              if config.lookup!('kernel_cmdline')
+                xml.cmdline config.kernel_cmdline.join(' ')
+              end
+            end
+            xml.initrd config.initrd if config.lookup!('initrd')
+            xml.boot(:dev => 'cdrom') if config.lookup!('cdrom')
+          }
+          # for shutdown to work
+          xml.features {
+            xml.acpi
+          }
+          #xml.on_poweroff 'destroy'
+          unless config.lookup!('reboot').nil? || config.lookup!('reboot')
+            xml.on_reboot 'destroy'
+          end
+          #xml.on_crash 'destroy'
+          #xml.on_lockfailure 'poweroff'
+
+          xml.devices {
+            xml.emulator '/usr/bin/qemu-kvm'
+            xml.channel(:type => 'spicevmc') do
+              xml.target(:type => 'virtio', :name => 'com.redhat.spice.0')
+            end
+
+            xml.disk(:type => 'file', :device => 'disk') {
+              xml.driver(:name => 'qemu', :type => 'qcow2')
+              xml.source(:file => workspace.current_image)
+              if config.virtio
+                xml.target(:dev => 'sda', :bus => 'virtio')
+              else
+                xml.target(:dev => 'sda', :bus => 'ide')
+              end
+            }
+            if config.lookup!('cdrom')
+              xml.disk(:type => 'file', :device => 'cdrom') {
+                xml.source(:file => config.cdrom)
+                xml.target(:dev => 'hdc')
+                xml.readonly
+              }
+            end
+            if config.lookup!('floppy')
+              xml.disk(:type => 'dir', :device => 'floppy') {
+                xml.source(:dir => config.floppy)
+                xml.target(:dev => 'fda')
+                xml.readonly
+              }
+            end
+            xml.graphics(:type => 'vnc', :autoport => 'yes')
+            xml.graphics(:type => 'spice', :autoport => 'yes')
+            xml.interface(:type => 'network') {
+              xml.source(:network => 'default')
+              xml.mac(:address => config.mac_address)
+            }
+          }
+        }
+      end
+      builder.to_xml
+    end
+
+  end
+end

data/lib/vmit/plugins/bootstrap.rb

@@ -18,8 +18,6 @@
 # IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #
-require 'vmit/autoyast'
-require 'vmit/kickstart'
 require 'abstract_method'
 require 'clamp'
 require 'net/http'
@@ -46,34 +44,52 @@ module Vmit
         disk_size
       end
 
-      parameter "LOCATION", "Repository URL or ISO image to bootstrap from"
+      option ['-F', '--packages'], "PACKAGES",
+        "Add packages. Either a file with one package name per line or a 
+        comma separated list", :default => [] do |pkgs|
+        case
+          when File.exist?(pkgs)
+            begin
+              File.read(pkgs).each_line.to_a.map(&:strip)
+            rescue
+              raise ArgumentError, "Can't read package list from #{pkgs}"
+            end
+          else
+            list = pkgs.split(',')
+            if list.empty?
+              raise ArgumentError, "Not a valid comma separated list of packages"
+            end
+            list
+        end
+      end
+
+      parameter "LOCATION ...", "Repository URL, ISO image or distribution name"
 
       def execute
         Vmit.logger.info 'Starting bootstrap'
-        curr_dir = File.expand_path(Dir.pwd)
-        vm = Vmit::VirtualMachine.new(curr_dir)
+        workspace = Vmit::Workspace.from_pwd
 
         Vmit.logger.info '  Deleting old images'
         FileUtils.rm_f(Dir.glob('*.qcow2'))
         opts = {}
         opts[:disk_size] = disk_size if disk_size
-        vm.disk_image_init!(opts)
-        vm.save_config!
+        workspace.disk_image_init!(opts)
+        workspace.save_config!
 
-        uri = URI.parse(location)
-        bootstrap = [Vmit::Bootstrap::FromImage,
-                  Vmit::Bootstrap::FromMedia].find do |method|
-          method.accept?(uri)
-        end
+        location = location_list.join(' ')
+        install_media = Vmit::InstallMedia.scan(location)
+
+        Vmit.logger.info "Install media: #{install_media}"
 
-        if bootstrap
-          bootstrap.new(vm, uri).execute
-        else
-          raise "Can't bootstrap from #{location}"
+        packages.each do |pkg|
+          install_media.unattended_install.config.add_packages!(pkg)
         end
 
+        vm = Vmit::LibvirtVM.from_pwd
+        install_media.autoinstall(vm)
+
         Vmit.logger.info 'Creating snapshot of fresh system.'
-        vm.disk_snapshot!
+        workspace.disk_snapshot!
         Vmit.logger.info 'Bootstraping done. Call vmit run to start your system.'
       end
 

data/lib/vmit/registry.rb

@@ -0,0 +1,208 @@
+#
+# Copyright (C) 2013 Duncan Mac-Vicar P. <dmacvicar@suse.de>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+# the Software, and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+require 'yaml'
+
+module Vmit
+
+  class Registry
+    include Enumerable
+  end
+
+  # Wraps a registry providing buffered
+  # semantics. All writes are buffered
+  # until +save!+ is called.
+  #
+  # Changes in the wrapped registry for
+  # already read keys are not reflected
+  # until +reload!+ is called.
+  #
+  #   reg = ufferedRegistry.new(backing_registry)
+  #   reg[:key1] = "value" # backing_registry not changed
+  #   reg.save! # backing_registry changed
+  #
+  class BufferedRegistry < Registry
+
+    def initialize(registry)
+      @buffer = Hash.new
+      @registry = registry
+    end
+
+    def [](key)
+      if not @buffer.has_key?(key)
+        @buffer[key] = @registry[key]
+      end
+      @buffer[key]
+    end
+
+    def []=(key, val)
+      @buffer[key] = val
+    end
+
+    def save!
+      @buffer.each do |key, val|
+        @registry[key] = val
+      end
+    end
+
+    def reload!
+      @buffer.keys.each do |key|
+        @buffer[key] = @registry[key]
+      end
+    end
+
+  end
+
+  # Add types to keys
+  # You need to inherit from this class
+  #
+  # @example
+  #   class MyTypes < TypedRegistry
+  #     type :key1, Fixnum
+  #     type :key2, Float
+  #   end
+  #
+  #   reg = MyTypes.new(backing_registry)
+  #
+  class TypedRegistry < Registry
+
+    class << self
+      def type(key, t=nil)
+        @type_info ||= Hash.new
+        @type_info[key] = t unless t.nil?
+        @type_info[key]
+      end
+    end
+
+    def initialize(registry)
+      @registry = registry
+    end
+
+    def type(key)
+      self.class.type(key)
+    end
+
+    def [](key)
+      rawval = @registry[key]
+      case type(key).to_s
+        when 'String' then rawval.to_s
+        when 'Fixnum' then rawval.to_i
+        when 'Float' then rawval.to_f
+        else rawval
+      end
+    end
+
+    def []=(key, val)
+      if type(key)
+        unless val.is_a?(type(key))
+          raise TypeError.new("Expected #{type(key)} for #{key}")
+        end
+      end
+      @registry[key] = val
+    end
+  end
+
+  # Takes configuration options from a yml
+  # file.
+  class YamlRegistry < Registry
+    def initialize(file_path)
+      @file_path = file_path
+      reload!
+    end
+
+    def reload!
+      @data = YAML::load(File.read(@file_path))
+    end
+
+    def save!
+      File.write(@file_path, @data.to_yaml)
+    end
+
+    def [](key)
+      # YAML uses strings for keys
+      # we use symbols.
+      if @data.has_key?(key)
+        @data[key]
+      else
+        @data[key.to_s]
+      end
+    end
+
+    def []=(key, val)
+      @data[key.to_s] = val
+      save!
+      reload!
+    end
+
+    def each(&block)
+      Enumerator.new do |enum|
+        @data.each do |key, val|
+          enum.yield key.to_sym, val
+        end
+      end
+    end
+
+    def keys
+      each.to_a.map(&:first)
+    end
+  end
+
+  # Takes configuration options from a
+  # filesystem tree where the files are
+  # the keys and the content the values
+  class FilesystemRegistry < Registry
+    def initialize(base_path)
+      @base_path = base_path
+    end
+
+    def [](key)
+      begin
+        path = File.join(@base_path, key.to_s)
+        unless File.directory?(path)
+          File.read(path)
+        else
+          return FilesystemRegistry.new(File.join(@base_path, path))
+        end
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+
+    def []=(key, val)
+      File.write(File.join(@base_path, key.to_s), val)
+    end
+
+    def each(&block)
+      Enumerator.new do |enum|
+        Dir.entries(@base_path).reject do |elem|
+          ['.', '..'].include?(elem)
+        end.each do |key|
+          enum.yield key.to_sym, self[key]
+        end
+      end
+    end
+
+    def keys
+      each.to_a.map(&:first)
+    end
+
+  end
+
+end