veewee 0.2.3 → 0.3.0.alpha1

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

@@ -0,0 +1,135 @@
+##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 transaction(step_name,checksums,&block)
+
+        current_step_nr=step_name.split("-")[0].to_i
+
+        vm=VirtualBox::VM.find(@box_name)  
+        snapnames=Array.new
+
+        #If vm exists , look for snapshots
+        if !vm.nil?
+          start_snapshot=vm.root_snapshot
+          snapshot=start_snapshot
+          counter=0
+
+          while (snapshot!=nil)
+            #env.ui.info "#{counter}:#{snapshot.name}"
+            snapnames[counter]=snapshot.name
+            counter=counter+1  
+            snapshot=snapshot.children[0]
+          end 
+        end
+
+        #find the last snapshot matching the state
+        counter=[snapnames.length, checksums.length].min-1
+        last_good_state=counter
+        for c in 0..counter do
+          #env.ui.info "#{c}- #{snapnames[c]} - #{checksums[c]}"
+          if !snapnames[c].match("#{c}.*-#{checksums[c]}")
+            #        env.ui.info "we found a bad state"
+            last_good_state=c-1
+            break
+          end  
+        end
+        #env.ui.info "Last good state: #{last_good_state}"
+
+        if (current_step_nr < last_good_state)
+          #env.ui.info "fast forwarding #{step_name}"
+          return
+        end
+
+        #env.ui.info "Current step: #{current_step_nr}"
+        if (current_step_nr == last_good_state)
+          if vm.running?
+            vm.stop
+          end
+
+          #invalidate later snapshots
+          #env.ui.info "remove old snapshots"
+
+          for s in (last_good_state+1)..(snapnames.length-1)
+            env.ui.info "Removing step [#{s}] snapshot as it is no more valid"
+            snapshot=vm.find_snapshot(snapnames[s])
+            snapshot.destroy
+            #env.ui.info snapshot
+          end
+
+          vm.reload
+          env.ui.info "Loading step #{current_step_nr} snapshots as it has not changed"
+          sleep 2
+          goodsnap=vm.find_snapshot(snapnames[last_good_state])
+          goodsnap.restore
+          sleep 2
+          #TODO:Restore snapshot!!!
+          vm.start
+          sleep 4
+          env.ui.info "Starting machine"
+        end
+
+        #env.ui.info "last good state #{last_good_state}"
+
+
+        if (current_step_nr > last_good_state)
+
+          if (last_good_state==-1)
+            #no initial snapshot is found, clean machine!
+            vm=VirtualBox::VM.find(@box_name) 
+
+            if !vm.nil?
+              if vm.running?
+                env.ui.info "Stopping machine"
+                vm.stop
+                while vm.running?
+                  sleep 1
+                end
+              end
+
+              #detaching cdroms (used to work in 3.x)
+              #              vm.medium_attachments.each do |m|
+              #                if m.type==:dvd
+              #                  #env.ui.info "Detaching dvd"
+              #                  m.detach
+              #                end
+              #              end
+
+              vm.reload
+              env.ui.info "We found no good state so we are destroying the previous machine+disks"
+              destroy
+            end
+
+          end
+
+          #env.ui.info "(re-)executing step #{step_name}"
+
+
+          yield
+
+          #Need to look it up again because if it was an initial load
+          vm=VirtualBox::VM.find(@box_name) 
+          env.ui.info "Step [#{current_step_nr}] was succesfully - saving state"
+          vm.save_state
+          sleep 2 #waiting for it to be ok
+          #env.ui.info "about to snapshot #{vm}"
+          #take snapshot after succesful execution
+          vm.take_snapshot(step_name,"snapshot taken by veewee")
+          sleep 2 #waiting for it to be started again
+          vm.start
+        end   
+
+        #pp snapnames
+      end
+      
+      def transaction(step_name,checksums,&block)
+        yield
+      end
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,62 @@
+require 'veewee/util/scancode'
+require 'veewee/util/tcp'
+require 'veewee/util/shell'
+
+module Veewee
+  module Builder
+    module Virtualbox
+      module BoxHelper
+      def console_type(sequence)
+        send_virtualbox_sequence(sequence)
+      end
+      
+      def send_virtualbox_sequence(sequence)
+
+        env.ui.info ""
+
+        counter=0
+        sequence.each { |s|
+          counter=counter+1
+
+          env.ui.info "Typing:[#{counter}]: "+s
+
+          keycodes=Veewee::Util::Scancode.string_to_keycode(s)
+
+          # VBox seems to have issues with sending the scancodes as one big
+          # .join()-ed string. It seems to get them out or order or ignore some.
+          # A workaround is to send the scancodes one-by-one.
+          codes=""
+          for keycode in keycodes.split(' ') do           
+            unless keycode=="wait"
+              send_keycode(keycode)    
+              sleep 0.01                  
+            else
+              sleep 1
+            end
+          end
+          #sleep after each sequence (needs to be param)
+          sleep 0.5
+        }
+
+        env.ui.info "Done typing."
+        env.ui.info ""
+
+      end
+
+      def send_keycode(keycode)
+        command= "#{@vboxcmd} controlvm '#{name}' keyboardputscancode #{keycode}"
+        env.logger.info "#{command}"
+        sshresult=shell_exec("#{command}",{:mute => true})
+        unless sshresult.stdout.index("E_ACCESSDENIED").nil?
+          env.ui.error "There was an error typing the commands on the console"
+          env.ui.error "Probably the VM did not get started."
+          env.ui.error ""
+          env.ui.error "#{sshresult.stdout}"
+          exit -1
+        end
+      end
+      
+end #Module
+end #Module
+end #Module
+end #Module

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

@@ -0,0 +1,210 @@
+module Veewee
+  module Builder
+    module Virtualbox
+      module BoxHelper
+
+        def add_ide_controller(definition)
+          #unless => "${vboxcmd} showvminfo '${vname}' | grep 'IDE Controller' "
+          command ="#{@vboxcmd} storagectl '#{name}' --name 'IDE Controller' --add ide"
+          shell_exec("#{command}")
+        end
+
+        def add_sata_controller(definition)
+          #unless => "${vboxcmd} showvminfo '${vname}' | grep 'SATA Controller' ";
+          command ="#{@vboxcmd} storagectl '#{name}' --name 'SATA Controller' --add sata --hostiocache #{definition.hostiocache} --sataportcount 1"
+          shell_exec("#{command}")
+        end
+
+        def add_ssh_nat_mapping(definition)
+
+          #Map SSH Ports
+          #			command => "${vboxcmd} modifyvm '${vname}' --natpf1 'guestssh,tcp,,${hostsshport},,${guestsshport}'",
+          port = VirtualBox::NATForwardedPort.new
+          port.name = "guestssh"
+          port.guestport = definition.ssh_guest_port.to_i
+          port.hostport = definition.ssh_host_port.to_i
+          raw.network_adapters[0].nat_driver.forwarded_ports << port
+          port.save
+          raw.save
+        end
+
+        def raw
+          vm=VirtualBox::VM.find(name)
+          return vm
+        end
+
+        def add_shared_folder(definition)
+
+          #  command="#{@vboxcmd} sharedfolder add  '#{name}' --name 'veewee-validation' --hostpath '#{File.expand_path(@environment.validation_dir)}' --automount"
+          #  shell_exec("#{command}")
+
+        end
+
+        def get_vm_location
+          command="#{@vboxcmd}  list  systemproperties"
+          shell_results=shell_exec("#{command}",{:mute => true})
+          location=shell_results.stdout.split(/\n/).grep(/Default machine/)[0].split(":")[1].strip
+          return location
+        end
+
+
+        def suppress_messages
+          #Setting this annoying messages to register
+          VirtualBox::ExtraData.global["GUI/RegistrationData"]="triesLeft=0"
+          VirtualBox::ExtraData.global["GUI/UpdateDate"]="1 d, 2009-09-20"
+          VirtualBox::ExtraData.global["GUI/SuppressMessages"]="confirmInputCapture,remindAboutAutoCapture,remindAboutMouseIntegrationOff"
+          VirtualBox::ExtraData.global["GUI/UpdateCheckCount"]="60"
+          update_date=Time.now+86400
+          VirtualBox::ExtraData.global["GUI/UpdateDate"]="1 d, #{update_date.year}-#{update_date.month}-#{update_date.day}, stable"
+          VirtualBox::ExtraData.global.save
+        end
+
+
+        def create_floppy(definition)
+          # Todo Check for java
+          # Todo check output of commands
+
+          # Check for floppy
+          unless definition.floppy_files.nil?
+            require 'tmpdir'
+            temp_dir=Dir.tmpdir
+            definition.floppy_files.each do |filename|
+              full_filename=full_filename=File.join(definition.path,filename)
+              FileUtils.cp("#{full_filename}","#{temp_dir}")
+            end
+            javacode_dir=File.expand_path(File.join(__FILE__,'..','..','java'))
+            floppy_file=File.join(definition.path,"virtualfloppy.vfd")
+            command="java -jar #{javacode_dir}/dir2floppy.jar '#{temp_dir}' '#{floppy_file}'"
+            shell_exec("#{command}")
+          end
+        end
+
+        def create_disk(definition)
+          # Now check the disks
+          # Maybe one day we can use the name, now we have to check location
+          # disk=VirtualBox::HardDrive.find(box_name)
+          location=name+"."+definition.disk_format.downcase
+          found=false
+          VirtualBox::HardDrive.all.each do |d|
+            if !d.location.match(/#{location}/).nil?
+              found=true
+              break
+            end
+          end
+
+          # Sometimes the above doesn't find a registered harddisk, but the vdi files is still there
+          if File.exists?(location)
+            env.ui.info "#{location} file still exists but isn't registered"
+            env.ui.info "Let me clean up that mess for you."
+            FileUtils.rm(location)
+          end
+
+          if !found
+            env.ui.info "Creating new harddrive of size #{definition.disk_size.to_i} "
+
+            #newdisk=VirtualBox::HardDrive.new
+            #newdisk.format=definition[:disk_format]
+            #newdisk.logical_size=definition[:disk_size].to_i
+
+            #newdisk.location=location
+            ##PDB: again problems with the virtualbox GEM
+            ##VirtualBox::Global.global.max_vdi_size=1000000
+            #newdisk.save
+
+            place=get_vm_location
+            command ="#{@vboxcmd} createhd --filename '#{place}/#{name}/#{name}.#{definition.disk_format.downcase}' --size '#{definition.disk_size.to_i}' --format #{definition.disk_format.downcase}"
+            shell_exec("#{command}")
+          end
+
+        end
+
+        def attach_disk(definition)
+
+          place=get_vm_location
+          location=name+"."+definition.disk_format.downcase
+
+          location="#{place}/#{name}/"+location
+          env.ui.info "Attaching disk: #{location}"
+
+          #command => "${vboxcmd} storageattach '${vname}' --storagectl 'SATA Controller' --port 0 --device 0 --type hdd --medium '${vname}.vdi'",
+          command ="#{@vboxcmd} storageattach '#{name}' --storagectl 'SATA Controller' --port 0 --device 0 --type hdd --medium '#{location}'"
+          shell_exec("#{command}")
+
+        end
+
+
+        def attach_isofile(definition)
+          full_iso_file=File.join(env.config.veewee.iso_dir,definition.iso_file)
+          env.ui.info "Mounting cdrom: #{full_iso_file}"
+          #command => "${vboxcmd} storageattach '${vname}' --storagectl 'IDE Controller' --type dvddrive --port 1 --device 0 --medium '${isodst}' ";
+          command ="#{@vboxcmd} storageattach '#{name}' --storagectl 'IDE Controller' --type dvddrive --port 1 --device 0 --medium '#{full_iso_file}'"
+          shell_exec("#{command}")
+        end
+
+
+        def add_floppy_controller(definition)
+          # Create floppy controller
+          unless definition.floppy_files.nil?
+
+            command="#{@vboxcmd} storagectl '#{name}' --name 'Floppy Controller' --add floppy"
+            shell_exec("#{command}")
+          end
+        end
+
+
+        def attach_floppy(definition)
+          unless definition.floppy_files.nil?
+
+            # Attach floppy to machine (the vfd extension is crucial to detect msdos type floppy)
+            floppy_file=File.join(definition.path,"virtualfloppy.vfd")
+            command="#{@vboxcmd} storageattach '#{name}' --storagectl 'Floppy Controller' --port 0 --device 0 --type fdd --medium '#{floppy_file}'"
+            shell_exec("#{command}")
+          end
+        end
+
+        def vbox_os_type_id(veewee_type_id)
+          type=env.config.ostypes[veewee_type_id][:vbox]
+          env.logger.info("Using VBOX os_type_id #{type}")
+          return type
+        end
+
+        def create_vm(definition)
+          command="#{@vboxcmd} createvm --name '#{name}' --ostype '#{vbox_os_type_id(definition.os_type_id)}' --register"
+
+          #Exec and system stop the execution here
+          shell_exec("#{command}")
+
+          env.ui.info "Creating vm #{name} : #{definition.memory_size}M - #{definition.cpu_count} CPU - #{vbox_os_type_id(definition.os_type_id)}"
+
+          #setting cpu's
+          command="#{@vboxcmd} modifyvm '#{name}' --cpus #{definition.cpu_count}"
+          shell_exec("#{command}")
+
+          #setting memory size
+          command="#{@vboxcmd} modifyvm '#{name}' --memory #{definition.memory_size}"
+          shell_exec("#{command}")
+
+          #setting bootorder
+          command="#{@vboxcmd} modifyvm '#{name}' --boot1 disk --boot2 dvd --boot3 none --boot4 none"
+          shell_exec("#{command}")
+
+          # Modify the vm to enable or disable hw virtualization extensions
+          vm_flags=%w{pagefusion acpi ioapic pae hpet hwvirtex hwvirtexcl nestedpaging largepages vtxvpid synthxcpu rtcuseutc}
+
+          vm_flags.each do |vm_flag|
+            if definition.instance_variable_defined?("@#{vm_flag}")
+              vm_flag_value=definition.instance_variable_get("@#{vm_flag}")
+              env.ui.info "Setting VM Flag #{vm_flag} to #{vm_flag_value}"
+              command="#{@vboxcmd} modifyvm #{name} --#{vm_flag.to_s} #{vm_flag_value}"
+              shell_exec("#{command}")
+            end
+          end
+
+
+          raw.reload
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Veewee
+  module Builder
+    module Virtualbox
+      module BoxHelper
+        
+      def destroy
+        
+        if raw.nil?
+          env.ui.error "Error:: You tried to destroy a non-existing box '#{name}'"
+          exit -1
+        end
+        
+        # If it has a save state,remove that first
+        if raw.saved?
+          env.ui.info "Removing save state"
+          raw.discard_state
+          raw.reload
+        end
+        
+        env.logger.info "Checking state: #{raw.state}"
+        if raw.state.to_s=="running"
+          # Poweroff
+          raw.stop
+          # Wait for it to happen
+          sleep 2
+        end
+        #:destroy_medium => :delete,  will delete machine + all media attachments
+        #vm.destroy(:destroy_medium => :delete)
+        ##vm.destroy(:destroy_image => true)
+
+        #VBoxManage unregistervm "test-machine" --delete
+        #because the destroy does remove the .vbox file on 4.0.x
+        #PDB
+        #vm.destroy()
+
+        command="#{@vboxcmd} unregistervm  '#{name}' --delete"    
+        env.ui.info command
+        env.ui.info "Deleting vm #{name}"
+
+        #Exec and system stop the execution here
+        shell_exec("#{command}")
+        sleep 1
+
+        #if the disk was not attached when the machine was destroyed we also need to delete the disk
+        location=name+"."
+        #+definition.disk_format.downcase
+        found=false       
+        VirtualBox::HardDrive.all.each do |d|
+          if d.location.match(/#{location}/)
+
+            if File.exists?(d.location) 
+              command="#{@vboxcmd} closemedium disk '#{d.location}' --delete"
+            else
+              command="#{@vboxcmd} closemedium disk '#{d.location}'"        
+            end
+
+            #command="#{@vboxcmd} closemedium disk '#{d.location}' --delete"
+            env.ui.info "Deleting disk #{d.location}"
+            env.ui.info "#{command}"
+
+            shell_exec("#{command}") 
+
+            if File.exists?(d.location) 
+              env.ui.info "We tried to delete the disk file via virtualbox '#{d.location} but failed"
+              env.ui.info "Removing it manually"
+              FileUtils.rm(d.location)
+              exit -1
+            end 
+            #v.3
+            #d.destroy(true)
+            break
+          end
+        end     
+      end
+
+    end #Module
+  end #Module
+end #Module
+end #Module