virtual_box 0.0.1 → 0.1.0

data/test/tasks/tinycore.rake

@@ -0,0 +1,378 @@
+require 'fileutils'
+
+# Tasks that build the TinyCore ISO used by the integration test.
+
+# Produces TinyCore spins.
+#
+# The implementation is heavily based on the official instructions at
+# http://wiki.tinycorelinux.net/wiki:remastering
+class TinyCore
+  # @return [String] path to the directory holding all the information
+  attr_reader :base
+  # @return [String] path to the vanilla Core ISO
+  attr_reader :iso
+  # @return [String] path to the unpacked version of the vanilla Core ISO
+  attr_reader :cd_fs
+  # @return [String] path to the directory caching extensions
+  attr_reader :pkg
+  # Path to the directory holding the contents of our remix's extension.
+  # @return [String]
+  attr_reader :ext_fs
+  # @return [String] path to the CPIO+GZ file-system in the unpacked Core ISO
+  attr_reader :fs_cpgz
+  # @return [String] path to the unpacked version of the re-mastered ISO
+  attr_reader :cd2_fs
+  # @return [String] path to the CPIO+GZ with our remix's extension.
+  attr_reader :ext_cpgz
+  # @return [String] path to the CPIO+GZ file-system in the remixed Core ISO
+  attr_reader :fs2_cpgz
+  # @return [String] path to the remixed ISO
+  attr_reader :iso2
+
+  def initialize(base_path)
+    @base = base_path
+    recompute_paths
+  end
+  
+  # Computes all the working paths based on the base path. 
+  def recompute_paths
+    @cd_fs = File.join base, 'cd'
+    @cd2_fs = File.join base, 'cd2'
+    @ext_fs = File.join base, 'ext'
+    @pkg = File.join base, 'pkg'
+    
+    @iso = File.join base, 'core.iso'
+    @iso2 = File.join base, 'remix.iso'
+    @fs_cpgz = File.join cd_fs, 'boot/core.gz'
+    @fs2_cpgz = File.join cd2_fs, 'boot/core.gz'
+    @ext_cpgz = File.join pkg, 'remix_ext.gz'
+  end
+  private :recompute_paths
+  
+  # Ensures that the TinyCore CD file-system is unpacked somewhere.
+  #
+  # This method might download the core ISO, and unpack it.
+  #
+  # @return [String] the same path returned by #ext_fs
+  def ensure_cd_fs_available
+    return cd_fs if File.exist? cd_fs
+    
+    download_iso unless File.exist? iso
+    unpack_iso
+    ext_fs
+  end
+  
+  # Downloads the core ISO.
+  #
+  # @raise [RuntimeError] if there's an error downloading the ISO
+  # @return [TinyCore] self, for easy call chaining
+  def download_iso
+    FileUtils.mkdir_p base
+    url = 'http://distro.ibiblio.org/tinycorelinux/4.x/x86/' +
+          'release/Core-current.iso'
+    download_file url, iso
+    self
+  end
+  private :download_iso
+  
+  # Unpacks the core ISO.
+  #
+  # @raise [RuntimeError] if there's an error unpacking the ISO
+  # @return [TinyCore] self, for easy call chaining
+  def unpack_iso
+    FileUtils.mkdir_p cd_fs
+    unless shell "7z x -y -o#{cd_fs} #{iso}"
+      FileUtils.rm_rf cd_fs
+      raise "ISO unpacking failed"
+    end
+    self
+  end
+  private :unpack_iso
+  
+  # Ensures that a TinyCore extension and its dependencies are downloaded.
+  #
+  # @param [String] package_name the name of the package (e.g., "openssh")
+  # @return [String] the file-system path where the package was downloaded
+  def ensure_package_available(package_name)
+    package_file = File.join pkg, "#{package_name}.tcz"
+    return package_file if File.exist?(package_file)
+    
+    # NOTE: The check above relies on the dependencies being installed before
+    #       the package itself.
+    package_deps(package_name).each do |dependency|
+      ensure_package_available dependency
+    end
+    
+    package_url = 'http://distro.ibiblio.org/tinycorelinux/4.x/x86/tcz/' +
+                  "#{package_name}.tcz"
+    FileUtils.mkdir_p pkg
+    download_file package_url, package_file
+  end
+  
+  # The TinyCore packages that a package directly depends on.
+  #
+  # This method downloads the package's .dep file, if it doesn't already exist.
+  #
+  # @param [String] package_name the name of the package (e.g., "openssh")
+  # @return [Array<String>] names of the package's direct dependencies
+  def package_deps(package_name)
+    FileUtils.mkdir_p pkg
+    
+    info_file = File.join pkg, "#{package_name}.tcz.dep"
+    unless File.exist? info_file
+      info_url = 'http://distro.ibiblio.org/tinycorelinux/4.x/x86/tcz/' +
+                 "#{package_name}.tcz.dep"
+      download_file info_url, info_file
+    end
+    
+    deps = []
+    File.read(info_file).split.map do |dep|
+      break unless /\.tcz\Z/ =~ dep
+      deps << dep.sub(/\.tcz\Z/, '')
+    end
+    deps
+  end
+  private :package_deps
+
+  # Installs a TinyCore package and its deps to the extension file-system.
+  #
+  # @param [String] package_name the name of the package (e.g., "openssh")
+  # @raise [RuntimeError] if some package download or decompression fails
+  # @return [TinyCore] the same path returned by #ext_fs
+  def install_package(package_name)
+    ensure_package_available package_name
+    package_transitive_deps(package_name).reverse.each do |dependency|
+      unpack_package dependency
+    end
+    ext_fs
+  end
+  
+  # All the TinyCore packages that a package indirectly depends on.
+  #
+  # This method downloads the referenced .dep files, if they don't already
+  # exist.
+  #
+  # @param [String] package_name the name of the package (e.g., "openssh")
+  # @param [Hash<String, Boolean>] dependencies internal argument that tracks
+  #     the dependency table as it is being built
+  # @return [Array<String>] names of all the packages that the given package
+  #     indirectly depends on, including itself
+  def package_transitive_deps(package_name, dependencies = {})
+    dependencies[package_name] = true
+    package_deps(package_name).each do |dependency|
+      next if dependencies.has_key? dependency
+      package_transitive_deps dependency, dependencies
+    end
+    dependencies.keys
+  end
+  private :package_transitive_deps
+  
+  # Extracts a TinyCore package to the extension file-system.
+  #
+  # @param [String] package_name the name of the package (e.g., "openssh")
+  # @raise [RuntimeError] if the package decompression fails
+  # @return [TinyCore] self, for easy call chaining
+  def unpack_package(package_name)
+    package_tcz = File.expand_path ensure_package_available(package_name)
+    FileUtils.mkdir_p ext_fs
+    out_dir = File.expand_path ext_fs
+    unless shell "unsquashfs -d #{out_dir} -f -n #{package_tcz}"
+      raise "TCZ unpacking failed"
+    end
+    self
+  end
+  private :unpack_package
+  
+  # Runs a block of code in the root of the extension file-system.
+  # @return [Object] the return value of the given block
+  def change_ext_fs(&block)
+    FileUtils.mkdir_p ext_fs
+    Dir.chdir ext_fs do
+      yield self
+    end
+  end
+  
+  # Adds an init.d service to the list of services to be started at boot.
+  # @return [TinyCore] self, for easy call chaining
+  def autoboot_service(service_name)
+    bootlocal = ensure_bootlocal_available
+    
+    path = File.join '/usr/local/etc/init.d', service_name
+    unless File.exist?(ext_fs + path)
+      path = File.join '/etc/init.d', service_name
+    end
+    
+    commands = File.read(bootlocal).split
+    return self if commands.any? { |command| /^#{path}/ =~ command }
+    File.open(bootlocal, 'ab') { |f| f.write "#{path} start\n" }
+    self
+  end
+  
+  # Ensures that the bootlocal.sh file holding startup commands exists.
+  #
+  # If necessary, this method will create the file and its enclosing
+  # directories, and set correct permissions on everything.
+  #
+  # @return [String] the path to the bootlocal.sh file in the unpacked extension
+  #     filesystem
+  def ensure_bootlocal_available
+    opt = File.join ext_fs, 'opt'
+    FileUtils.mkdir_p opt
+    File.chmod 02775, opt
+    
+    bootlocal = File.join opt, 'bootlocal.sh'
+    unless File.exist? bootlocal
+      File.open(bootlocal, 'wb') { |f| f.write "#!/bin/sh\n" }
+    end
+    File.chmod 0775, bootlocal
+    bootlocal
+  end
+  private :ensure_bootlocal_available
+  
+    
+  def remaster
+    ensure_cd2_fs_available
+    build_initrd
+    config_bootldr
+    build_iso
+  end
+  
+  # Ensures that the re-mastered CD file-system exists.
+  #
+  # If necessary, this method can download the Core ISO and unpack it, then
+  # copy the unpacked version over.
+  def ensure_cd2_fs_available
+    return cd2_fs if File.exist?(cd2_fs)
+    
+    ensure_cd_fs_available
+    FileUtils.cp_r cd_fs, cd2_fs
+  end
+  private :ensure_cd2_fs_available
+  
+  # Builds the file used as the initial RAM file-system by the remixed ISO.
+  #
+  # @return [String] the path to the initrd file.
+  def build_initrd
+    ensure_cd2_fs_available
+    build_extension
+    File.open fs2_cpgz, 'wb' do |f|
+      f.write File.read_binary(fs_cpgz)
+      f.write File.read_binary(ext_cpgz)
+    end
+    fs2_cpgz
+  end
+  private :build_initrd
+  
+  # Builds a GZ+CPIO initramfs extension out of the extension file-system.
+  #
+  # @return [String] the path to the GZ+CPIO file
+  def build_extension
+    FileUtils.mkdir_p pkg
+    out_file = File.expand_path ext_cpgz
+    Dir.chdir ext_fs do
+      command = 'find . | cpio -o --format newc --owner=0:0 | ' +
+                "gzip -2 > #{out_file}"
+      unless shell command
+        raise "CP+GZ packing error"
+      end
+      unless shell "advdef --recompress --shrink-insane --quiet #{out_file}"
+        raise "CP+GZ re-compression error"
+      end
+    end
+    ext_cpgz
+  end
+  private :build_extension
+  
+  # Patches the boot-loader configuration on the remixed ISO.
+  #
+  # The patched configuration has the timeout removed, for instant VM booting.
+  #
+  # @return [String] the path to the patched configuration file.
+  def config_bootldr
+    ensure_cd2_fs_available
+    config_file = File.join cd2_fs, 'boot/isolinux/isolinux.cfg'
+    data = File.read config_file
+    data.gsub!(/^prompt .*$/, 'prompt 0')
+    data.gsub!(/^timeout .*$/, 'timeout 0')
+    File.open(config_file, 'w') { |f| f.write data }
+    config_file
+  end
+  
+  # Creates an ISO image out of the unpacked remixed CD file-system.
+  #
+  # @return [String] the path to the newly created ISO file
+  def build_iso
+    ensure_cd2_fs_available
+    
+    label = 'remixed-tc'
+    boot_loader = 'boot/isolinux/isolinux.bin'
+    boot_catalog = 'boot/isolinux/boot.cat'
+    
+    command = "mkisofs -l -J -R -r -V #{label} -no-emul-boot " +
+              "-boot-load-size 4 -quiet " +
+              "-boot-info-table -b #{boot_loader} -c #{boot_catalog} " +
+              "-o #{iso2} #{cd2_fs}"
+    unless shell command
+      raise "ISO creation failed"
+    end
+    iso2
+  end
+  
+  # Helper method for downloading a file over HTTP.
+  #
+  # @param [String] url the URL to download the file from
+  # @param [String] file the file-system path where the file will be saved
+  # @raise [RuntimeError] if there's an error downloading the file
+  # @return [String] the value of the "file argument"
+  def download_file(url, file)
+    return file if shell("curl -o #{file} #{url}")
+    
+    File.unlink file if File.exist?(file)
+    raise "Download failed"
+  end
+  private :download_file
+  
+  # Runs a shell command.
+  # @param [String] command the command to be executed
+  # @return [Boolean] true if the command's exit code was 0, false otherwise
+  def shell(command)
+    Kernel.system command
+  end
+  private :shell
+
+  # Runs a shell command with super-user privileges.
+  # @param [String] command the command to be executed
+  # @return [Boolean] true if the command's exit code was 0, false otherwise
+  def su_shell(command)
+    # TODO(pwnall): use shellwords responsibly
+    Kernel.system "sudo -i \"#{command}\""
+  end
+  private :su_shell
+end
+
+# All TinyCore files will be created here. This should be gitignored.
+tinycore = TinyCore.new 'test/fixtures/tinycore'
+
+file tinycore.iso2 do
+  tinycore.ensure_cd_fs_available
+  tinycore.install_package 'coreutils'
+  tinycore.install_package 'openssh'
+  tinycore.autoboot_service 'openssh'
+    
+  tinycore.change_ext_fs do
+    FileUtils.cp 'usr/local/etc/ssh/ssh_config.example',
+                 'usr/local/etc/ssh/ssh_config'
+    FileUtils.cp 'usr/local/etc/ssh/sshd_config.example',
+                 'usr/local/etc/ssh/sshd_config'
+    data = File.read 'usr/local/etc/ssh/sshd_config'
+    data.gsub!(/^#PasswordAuthentication .*$/, 'PasswordAuthentication yes')
+    data.gsub!(/^#PermitEmptyPasswords .*$/, 'PermitEmptyPasswords yes')
+    File.open 'usr/local/etc/ssh/sshd_config', 'w' do |f|
+      f.write data
+    end
+  end
+  
+  tinycore.remaster
+end
+
+task :fixtures => tinycore.iso2

data/test/virtual_box/board_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../helper.rb', File.dirname(__FILE__))
+
+describe VirtualBox::Board do 
+  describe 'os_types' do
+    before do
+      @types = VirtualBox::Board.os_types
+    end
+    it 'should map linux 2.6' do
+      @types.must_include :linux26
+    end
+    
+    it 'should include linux 2.6 ID' do
+      @types.must_include 'linux26'
+      @types.must_include 'Linux26'
+    end
+
+    it 'should include linux 2.6 description' do
+      @types.must_include 'Linux 2.6'
+    end
+  end
+  
+  describe 'non-standard board specification' do
+    before do
+      @vm = VirtualBox::Vm.new :board => { :os => :fedora, :ram => 768,
+          :cpus => 2, :video_ram => 22, :boot_order => [:dvd, :net, :disk] }
+      @vm.register
+    end
+    after do
+      @vm.unregister
+    end
+    
+    it 'should push/pull specification correctly' do
+      vm = VirtualBox::Vm.new :uid => @vm.uid
+      
+      vm.pull_config
+      vm.board.to_hash.must_equal @vm.board.to_hash
+    end
+  end
+end

data/test/virtual_box/cli_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../helper.rb', File.dirname(__FILE__))
+
+describe 'CLI' do
+  describe 'run_command' do
+    describe 'with hello world echo' do
+      before do
+        @result = VirtualBox.run_command(['echo', 'Hello'])
+      end
+      
+      it 'should report successful completion' do
+        @result.status.must_equal 0
+      end
+      
+      it 'should return echo output' do
+        @result.output.must_equal "Hello\n"
+      end
+    end
+    
+    describe 'with inline ruby script' do
+      before do
+        @result = VirtualBox.run_command(['ruby', '-e', 'print "Hi"; exit 1'])
+      end
+      
+      it 'should return echo output' do
+        @result.output.must_equal 'Hi'
+      end
+      
+      it 'should report exit code 1' do
+        @result.status.must_equal 1
+      end
+    end
+  end
+end

data/test/virtual_box/dhcp_test.rb

@@ -0,0 +1,52 @@
+require File.expand_path('../helper.rb', File.dirname(__FILE__))
+
+describe VirtualBox::Dhcp do
+  describe 'ip 192.168.0.1' do
+    before do
+      @dhcp = VirtualBox::Dhcp.new :ip => '192.168.0.1'
+    end
+    it 'has a default netmask' do
+      @dhcp.netmask.must_equal '255.255.255.0'
+    end
+    it 'computes the IP block start' do
+      @dhcp.start_ip.must_equal '192.168.0.2'
+    end
+    it 'computes the IP block end' do
+      @dhcp.end_ip.must_equal '192.168.0.254'
+    end
+  end
+  
+  describe 'startip 192.168.0.64' do
+    before do
+      @dhcp = VirtualBox::Dhcp.new :start_ip => '192.168.0.64'
+    end    
+    it 'computes the server IP' do
+      @dhcp.ip.must_equal '192.168.0.1'
+    end
+  end
+  
+  describe 'random rule' do
+    before do
+      @dhcp = VirtualBox::Dhcp.new :net_name => 'rbxvbox0', :ip => '10.1.0.1'
+    end
+    
+    it 'is not live' do
+      @dhcp.wont_be :live?
+    end
+    
+    describe 'after being added' do
+      before { @dhcp.add }
+      after { @dhcp.remove }
+      
+      it 'is live' do
+        @dhcp.must_be :live?
+      end
+      
+      it 'shows up on the list of live servers' do
+        servers = VirtualBox::Dhcp.all
+        dhcp = servers.find { |s| s.net_name == @dhcp.net_name }
+        dhcp.to_hash.must_equal @dhcp.to_hash
+      end
+    end
+  end
+end

data/test/virtual_box/disk_test.rb

@@ -0,0 +1,116 @@
+require File.expand_path('../helper.rb', File.dirname(__FILE__))
+
+describe VirtualBox::Disk do
+  describe 'new with ISO' do
+    before do
+      @disk = VirtualBox::Disk.new :file => 'disk.iso'      
+    end
+    
+    it 'should guess media type' do
+      @disk.media.must_equal :dvd
+    end
+    
+    it 'should guess image type' do
+      @disk.format.must_equal :raw
+    end
+  end
+  
+  describe 'create' do
+    describe '16-megabyte VMDK flexible' do
+      let(:vmdk_path) { '/tmp/disk.vmdk' }
+    
+      before do
+        File.unlink vmdk_path if File.exist?(vmdk_path)
+        @disk = VirtualBox::Disk.create :file => vmdk_path, :prealloc => false,
+            :size => 16 * 1024 * 1024
+      end
+      
+      after do
+        File.unlink vmdk_path if File.exist?(vmdk_path)
+      end
+      
+      it 'should create a small file' do
+        File.stat(vmdk_path).size.must_be :<, 256 * 1024
+      end
+      
+      it 'should return a Disk pointing to the file' do
+        @disk.file.must_equal vmdk_path
+      end
+      
+      it 'should return a HDD Disk' do
+        @disk.media.must_equal :disk
+      end
+      
+      it 'should return a VMDK Disk' do
+        @disk.format.must_equal :vmdk
+      end
+    end
+    
+    describe '16-megabyte preallocated' do
+      let(:vdi_path) { '/tmp/disk.vdi' }
+      
+      before do
+        File.unlink vdi_path if File.exist?(vdi_path)
+        @disk = VirtualBox::Disk.create :file => vdi_path, :prealloc => true,
+            :size => 16 * 1024 * 1024
+      end
+      
+      after do
+        File.unlink vdi_path if File.exist?(vdi_path)
+      end
+      
+      it 'should create a 16-megabyte file' do
+        (File.stat(vdi_path).size / (1024 * 1024)).must_equal 16
+      end
+      
+      it 'should return a Disk pointing to the file' do
+        @disk.file.must_equal vdi_path
+      end
+      
+      it 'should return a HDD Disk' do
+        @disk.media.must_equal :disk
+      end
+      
+      it 'should return a VDI Disk' do
+        @disk.format.must_equal :vdi
+      end
+    end
+  end
+  
+  describe 'VM with a bunch of disks' do
+    let(:disk1_file) { '/tmp/disk1.vdi' }
+    let(:disk2_file) { '/tmp/disk2.vdi' }
+    let(:disk3_file) { '/tmp/disk3.vdi' }
+    let(:iso_file) { 'test/fixtures/tinycore/remix.iso' }
+    before do
+      [disk1_file, disk2_file, disk3_file].each do |file|
+        File.unlink file if File.exist?(file)
+        VirtualBox::Disk.create :file => file, :size => 16 * 1024 * 1024
+      end
+    
+      @vm = VirtualBox::Vm.new :io_buses => [
+        { :bus => :sata, :disks => [
+            { :file => disk1_file, :port => 0, :device => 0 },
+            { :file => disk2_file }
+          ]},
+        { :bus => :ide, :disks => [{ :file => iso_file }]},
+        { :bus => :scsi, :disks => [{ :file => disk3_file }] }
+      ]
+      @vm.register
+    end
+    
+    after do
+      @vm.unregister
+      [disk1_file, disk2_file, disk3_file].each do |file|
+        File.unlink file if File.exist?(file)
+      end
+    end
+    
+    it 'should push/pull specs correctly' do
+      vm = VirtualBox::Vm.new :uid => @vm.uid
+      vm.pull_config
+      vm.io_buses.map { |io_bus| io_bus.to_hash }.
+                  must_equal @vm.io_buses.map { |io_bus| io_bus.to_hash }
+    end
+  end
+end

data/test/virtual_box/integration_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path('../helper.rb', File.dirname(__FILE__))
+
+require 'net/ssh'
+
+describe 'VirtualBox' do
+  before do
+    iso_file = 'test/fixtures/tinycore/remix.iso'
+    @net = VirtualBox::Net.new(:ip => '192.168.66.6',
+                               :netmask => '255.255.255.0').add
+    @dhcp = VirtualBox::Dhcp.new(:net_name => @net.name,
+                                 :start_ip => '192.168.66.66').add
+    @vm = VirtualBox::Vm.new(
+        :board => { :ram => 256, :cpus => 1, :video_ram => 16,
+                    :os => :linux26 },
+        :io_buses => [{ :bus => :ide,
+                        :disks => [{ :file => iso_file, :port => 1 }] }],
+        :nics => [{ :mode => :host, :chip => :virtual,
+                    :net_name => @net.if_name }]).register
+  end
+  
+  after do
+    @vm.unregister unless @vm.nil?
+    @dhcp.remove unless @dhcp.nil?
+    @net.remove unless @net.nil?
+  end
+  
+  describe 'after VM start' do
+    before do
+      @vm.start
+      # Give the VM a chance to boot and generate SSH keys.
+      Kernel.sleep 3
+    end
+    
+    after do
+      unless @vm.nil?
+        @vm.stop
+        # Let VirtualBox stop the VM, so that it can be unregistered.
+        Kernel.sleep 0.5
+      end
+    end
+    
+    it 'should respond to a SSH connection' do
+      output = nil
+      Net::SSH.start '192.168.66.66', 'tc', :timeout => 10,
+          :global_known_hosts_file => [], :user_known_hosts_file => [],
+          :paranoid => false, :password => '' do |ssh|
+        output = ssh.exec!('ifconfig')
+      end
+      
+      output.wont_be_nil
+    end
+  end
+end