veewee 0.2.3 → 0.3.0.alpha1

data/lib/veewee/builder/core/builder/transaction.rb

@@ -0,0 +1,25 @@
+##Note: this is currently not used anymore, it seems no one is using it
+
+module Veewee
+  class Transaction
+
+  def transaction(name,params, &block)
+  end
+
+  def transaction2(name,options= { :checksum => "nochecksum"}, &block)
+     if snapshot_exists(@vmname,name+"-"+options[:checksum])
+        load_snapshot_vmachine(@vmname,name+"-"+options[:checksum])
+      else
+        if snapshot_version_exists(@vmname,name)
+          rollback_snapshot(@vmname,name)
+          #rollback to snapshot prior to this one
+        end
+        yield
+        create_snapshot_vmachine(@vmname,name+"-"+options[:checksum])
+      end
+    #end
+  end
+
+
+end
+end

data/lib/veewee/builder/core/builder/tunnel.rb

@@ -0,0 +1,46 @@
+#require 'net/ssh/multi'
+
+module Veewee
+  module Builder
+    module Core
+      module BuilderCommand
+
+
+      def ssh_tunnel_start(forwardings)
+        #ssh_options={ :keys => [ vm.private_key ], :paranoid => false, :keys_only => true}
+
+        ssh_options={ :paranoid => false}
+        host=@connection.uri.host
+        user=@connection.uri.user
+
+        env.ui.info "Enabling tunneling"
+        @forward_threads=Array.new
+        @forward_threads<< Thread.new {
+          Net::SSH.start(host, user, ssh_options) do |ssh_session|
+          forwardings.each do |forwarding|
+            begin
+              env.ui.info "Forwarding remote port #{forwarding[:remote_port]} from #{box_name} to local port #{forwarding[:local_port]}"
+              env.ui.info host
+              env.ui.info user
+              env.ui.info ""
+              ssh_session.forward.local(forwarding[:local_port], "127.0.0.1",forwarding[:remote_port])
+            rescue Errno::EACCES
+              env.ui.info "  Error - Access denied to forward remote port #{forwarding[:remote_port]} from #{name} to local port #{forwarding[:local_port]}"
+            end
+          end
+          ssh_session.loop {true}
+          end
+        }
+        env.ui.info @forward_threads.first.status
+        @forward_threads.first.run
+        env.ui.info @forward_threads.first.status
+
+      end
+
+      def ssh_tunnel_stop
+        Thread.kill(@forward_threads.first)
+      end
+    end
+    end
+  end
+end

data/lib/veewee/builder/kvm/box.rb

@@ -0,0 +1,130 @@
+require 'veewee/builder/core/box'
+require 'veewee/builder/core/box/vnc'
+
+module Veewee
+  module Builder
+    module Kvm
+      class Box < Veewee::Builder::Core::Box
+
+        include ::Veewee::Builder::Core
+        include ::Veewee::Builder::Kvm
+
+        include ::Veewee::Builder::Core::BoxCommand
+
+        attr_accessor :connection
+
+        def initialize(name,env)
+
+          require 'libvirt'
+          require 'fog'
+
+          super(name,env)
+
+          @connection=::Fog::Compute.new(:provider => "Libvirt",
+          :libvirt_uri => "qemu:///system",
+          :libvirt_ip_command => "arp -an |grep $mac|cut -d '(' -f 2 | cut -d ')' -f 1")
+
+        end
+
+        # Type on the console
+        def console_type(sequence,type_options={})
+                  vnc_port=@connection.servers.all(:name => name).first.vnc_port
+                  display_port=vnc_port.to_i - 5900
+                  env.ui.confirm "Sending keystrokes to VNC port :#{display_port} - TCP port: #{vnc_port}"
+                  vnc_type(sequence,"localhost",display_port)
+        end
+
+
+        # Create a new vm
+        def create(definition)
+          # Assemble the Virtualmachine and set all the memory and other stuff"
+
+          #memory_size,cpu_count, volume_size
+
+          s=@connection.servers.create(
+            :name => name,
+            :memory_size => definition.memory_size.to_i*1024,
+            :cpus => definition.cpu_count.to_i,
+            :volume_capacity => "#{definition.disk_size}M",
+            :network_interface_type => "nat",
+            :iso_file => definition.iso_file,
+            :arch => definition.os_type_id.end_with?("_64") ? "x86_64" : "i686",
+            :iso_dir => env.config.veewee.iso_dir
+            )
+        end
+
+        # Create the volume of a new vm
+        def create_volume
+          # Creating the volume is part of the server creation
+        end
+
+        # Destroy a vm
+        def destroy
+          if @connection.servers.all(:name => name).nil?
+            env.ui.error "Error:: You tried to destroy a non-existing box '#{name}'"
+            exit -1
+          end
+
+          halt if running?
+          destroy_vm if exists_vm?
+
+          vol_exists=!@connection.volumes.all(:name => "#{name}.img").nil?
+          env.logger.info "Volume exists? : #{vol_exists}"
+          destroy_volume if exists_volume?
+        end
+
+        def destroy_vm
+          matched_servers=@connection.servers.all(:name => name)
+          matched_servers.first.destroy() unless matched_servers.nil?
+        end
+
+        def destroy_volume
+          vol=@connection.volumes.all(:name => "#{name}.img").first
+          vol.destroy
+        end
+
+        def start(mode)
+          matched_servers=@connection.servers.all(:name => name)
+          matched_servers.first.start unless matched_servers.nil?
+        end
+
+        def halt
+          matched_servers=@connection.servers.all(:name => name)
+          matched_servers.first.halt unless matched_servers.nil?
+        end
+
+        def stop
+          matched_servers=@connection.servers.all(:name => name)
+          matched_servers.first.stop unless matched_servers.nil?
+        end
+
+        def ip_address
+          ip=@connection.servers.all(:name => "#{name}").first.addresses[:public]
+          return ip.first unless ip.nil?
+          return ip
+        end
+
+        def running?
+          if exists_vm?
+            @connection.servers.all(:name => name).first.ready?
+          else
+            false
+          end
+        end
+
+        def exists?
+          exists_volume? || exists_vm?
+        end
+
+        def exists_volume?
+          !@connection.volumes.all(:name => "#{name}.img").nil?
+        end
+
+        def exists_vm?
+          !@connection.servers.all(:name => name).nil?
+        end
+
+      end # End Class
+    end # End Module
+  end # End Module
+end # End Module

data/lib/veewee/builder/kvm/builder.rb

@@ -0,0 +1,38 @@
+require 'veewee/builder/core/builder'
+
+module Veewee
+  module Builder
+    module Kvm
+      class Builder < Veewee::Builder::Core::Builder
+
+        # Translate the definition ssh options to ssh options that can be passed to Net::Ssh calls
+        # We expect plain ssh for a connection
+
+        def check_requirements
+          ["ruby-libvirt","fog"].each do |gemname|
+            unless gem_available?(gemname)
+              raise Veewee::Error,"The kvm Builder requires the gem '#{gemname}' to be installed\n"    + "gem install #{gemname}"
+            end
+          end
+        end
+
+        def ssh_options(definition)
+          ssh_options={
+            :user => definition.ssh_user,
+            :port => 22,
+            :password => definition.ssh_password,
+            :timeout => definition.ssh_login_timeout.to_i
+          }
+          return ssh_options
+        end
+
+        def build(definition_name,box_name,options)
+
+          super(definition_name,box_name,options)
+
+        end
+
+      end #End Class
+    end # End Module
+  end # End Module
+end # End Module

data/lib/veewee/builder/virtualbox/box.rb

@@ -0,0 +1,121 @@
+require 'veewee/builder/core/box'
+
+require 'veewee/builder/virtualbox/helper/create'
+require 'veewee/builder/virtualbox/helper/console_type'
+require 'veewee/builder/virtualbox/helper/destroy'
+
+module Veewee
+  module Builder
+    module Virtualbox
+      class Box < Veewee::Builder::Core::Box
+
+        include ::Veewee::Builder::Virtualbox::BoxHelper
+
+        def initialize(name,env)
+
+          require 'virtualbox'
+          @vboxcmd=determine_vboxcmd
+          super(name,env)
+
+        end
+
+      def determine_vboxcmd
+         return "VBoxManage"
+      end
+
+      def exists?
+        vm=VirtualBox::VM.find(name)
+        env.logger.info ("Vm exists? #{!vm.nil?}")
+        return !vm.nil?
+      end
+
+      def running?
+        return
+      end
+
+      def create(definition)
+
+          guessed_port=guess_free_port(definition.ssh_host_port.to_i,definition.ssh_host_port.to_i+40).to_s
+          if guessed_port.to_s!=definition.ssh_host_port
+            env.ui.warn "Changing ssh port from #{definition.ssh_host_port} to #{guessed_port}"
+            definition.ssh_host_port=guessed_port.to_s
+          end
+
+        #Suppress those annoying virtualbox messages
+        suppress_messages
+
+        create_vm(definition)
+
+        # Adds a folder to the vm for testing purposes
+        add_shared_folder(definition)
+
+        #Create a disk with the same name as the box_name
+        create_disk(definition)
+
+        add_ide_controller(definition)
+        attach_isofile(definition)
+
+        add_sata_controller(definition)
+        attach_disk(definition)
+
+        create_floppy(definition)
+        add_floppy_controller(definition)
+        attach_floppy(definition)
+
+        add_ssh_nat_mapping(definition)
+
+      end
+
+      def start(gui_enabled=true)
+        # Once assembled we start the machine
+        env.logger.info "Started the VM with GUI Enabled? #{gui_enabled}"
+        if (gui_enabled)
+          raw.start("gui")
+        else
+          raw.start("vrdp")
+        end
+      end
+
+      def stop
+        # If the vm is not powered off, perform a shutdown
+        if (!raw.nil? && !(raw.powered_off?))
+          env.ui.info "Shutting down vm #{name}"
+          #We force it here, maybe vm.shutdown is cleaner
+          begin
+            raw.stop
+            sleep 3
+          rescue VirtualBox::Exceptions::InvalidVMStateException
+            env.ui.error "There was problem sending the stop command because the machine is in an Invalid state"
+            env.ui.error "Please verify leftovers from a previous build in your vm folder"
+            exit -1
+          end
+        end
+
+      end
+
+      def halt
+        if (!raw.nil? && !(raw.powered_off?))
+          env.ui.info "Halting vm #{name}"
+          #We force it here, maybe vm.shutdown is cleaner
+          # VBoxManage controlvm  'lucid64' poweroff
+          begin
+            raw.halt
+          rescue VirtualBox::Exceptions::InvalidVMStateException
+            env.ui.error "There was problem sending the stop command because the machine is in an Invalid state"
+            env.ui.error "Please verify leftovers from a previous build in your vm folder"
+            exit -1
+          end
+          sleep 3
+        end
+      end
+
+      # Get the IP address of the box
+      def ip_address
+        return "127.0.0.1"
+      end
+
+
+    end # End Class
+end # End Module
+end # End Module
+end # End Module

data/lib/veewee/builder/virtualbox/builder.rb

@@ -0,0 +1,48 @@
+require 'veewee/builder/core/builder'
+require 'veewee/builder/virtualbox/helper/export_vagrant'
+require 'veewee/builder/virtualbox/helper/validate_vagrant'
+
+module Veewee
+  module Builder
+    module Virtualbox
+      class Builder < Veewee::Builder::Core::Builder
+
+        include ::Veewee::Builder::Virtualbox::BuilderHelper
+
+        def check_requirements
+          unless gem_available?("virtualbox")
+            raise Veewee::Error,"The Virtualbox Builder requires the gem 'virtualbox' to be installed"
+          end
+        end
+
+        def ssh_options(definition)
+
+          ssh_options={
+            :user => definition.ssh_user,
+            :port => definition.ssh_host_port,
+            :password => definition.ssh_password,
+            :timeout => definition.ssh_login_timeout.to_i
+          }
+          return ssh_options
+
+        end
+
+        def build_info
+          info=super
+          info << { :filename => ".vbox_version",
+                    :content => "#{VirtualBox::Global.global.lib.virtualbox.version.split('_')[0]}" }
+        end
+
+        def build(definition_name,box_name,options)
+
+          super(definition_name,box_name,options)
+
+          # w00t, we have succesfully reach this point
+          # so we let user know , the vm is ready to be exported
+
+        end
+
+      end #End Class
+    end # End Module
+  end # End Module
+end # End Module

data/lib/veewee/builder/virtualbox/helper/_snapshots.rb

@@ -0,0 +1,105 @@
+##Note: this is currently not used anymore, it seems no one is using it
+
+require 'veewee/util/shell'
+require 'veewee/util/tcp'
+
+module Veewee
+  module Builder
+    module Virtualbox
+
+      def remove_snapshot_vmachine(vmname,snapname)
+        Veewee::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' delete '#{snapname}'")
+      end
+
+      def create_snapshot_vmachine(vmname,snapname)
+        Veewee::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' take '#{snapname}'")
+      end
+
+      def load_snapshot_vmachine(vmname,snapname)
+        #if it running , shutdown first
+        if (state_vmachine(vmname)=="running")
+          stop_vmachine(vmname)
+        end
+
+        Veewee::Shell.execute("#{@vboxcmd} snapshot '#{vmname}' restore '#{snapname}'")
+        #sometimes it takes some time to shutdown
+        sleep 2
+        Veewee::Shell.execute("#{@vboxcmd} startvm '#{vmname}'")
+      end
+
+      def snapshot_exists(vmname,snapname)
+        list_snapshots(vmname).each { |name|
+          if (name==snapname) then
+            return true
+          end
+        }
+        return false
+      end
+
+      def snapshot_version_exists(vmname,snapname)
+        list_snapshots(vmname).each { |name|
+          if name.match(/^#{snapname}-/) then
+            return true
+          end
+        }
+        return false
+      end
+
+      def self.rollback_snapshot(vmname,snapname)
+        delete_flag=false
+        @vboxcmd=Veewee::Environment.determine_vboxcmd
+
+        savestate_recover=false
+        if (state_vmachine(vmname)=="running")
+          Veewee::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' savestate")
+          savestate_recover=true
+        end
+
+        list_snapshots(vmname).each { |name|
+          if name.match(/^#{snapname}-/) then
+            delete_flag=true
+          end
+          if (delete_flag) then
+            remove_snapshot_vmachine(vmname,name)
+            sleep 1
+          end
+        }
+
+
+        sleep 2
+
+        Veewee::Shell.execute("#{@vboxcmd} startvm '#{vmname}'")
+
+        if (savestate_recover)
+          #Recovering from savestate nukes the network! This trick seem to work
+          #Also within the vm /etc/init.d/networking restart , but that is OS specific
+          #http://www.virtualbox.org/ticket/5666
+          #http://www.virtualbox.org/ticket/5654
+          #This is supposed to be fixed: http://www.virtualbox.org/changeset/25205 but alas
+          Veewee::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' nic1 nat")
+          Veewee::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' setlinkstate1 off")
+          Veewee::Shell.execute("#{@vboxcmd} controlvm '#{vmname}' setlinkstate1 on")
+          sleep 2
+
+          #hmmm, virtualbox => when recovering from a restore , it looses the nat settings!!! So we need to do this again!!
+          #thebox.ssh_enable_vmachine({:hostport => host_port , :guestport => 22} )
+          #http://www.virtualbox.org/changeset/25402
+          #[25402]: NAT: re-establish port-forwarding after savestate / restore state
+
+        end
+
+      end
+
+
+      def self.list_snapshots(vmname)
+        @vboxcmd=Veewee::Environment.determine_vboxcmd
+
+        snapshotresult=Veewee::Shell.execute("#{@vboxcmd} showvminfo --machinereadable '#{vmname}' |grep ^SnapshotName| cut -d '=' -f 2").stdout
+        snapshotlist=snapshotresult.gsub(/\"/,'').split(/\n/)
+        return snapshotlist
+      end
+
+    end #Module
+  end #Module
+end #Module
+