veewee 0.2.3 → 0.3.0.alpha1

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

@@ -0,0 +1,87 @@
+require 'pathname'
+module Veewee
+  module Builder
+    module Virtualbox
+      module BuilderHelper
+
+      #    Shellutil.execute("vagrant package --base #{vmname} --include /tmp/Vagrantfile --output /tmp/#{vmname}.box", {:progress => "on"})
+
+      def export_vagrant(box_name,options)
+        definition=env.get_definition(box_name)
+        box=get_box(box_name)
+
+        #Check if box already exists
+        unless box.exists?
+          env.ui.info "#{name} is not found, maybe you need to build it first?"
+          exit
+        end
+        #We need to shutdown first
+        if box.raw.state==:running
+          env.ui.info "Vagrant requires the box to be shutdown, before it can export"
+          env.ui.info "Sudo also needs to work for user #{definition.ssh_user}"
+          env.ui.info "Performing a clean shutdown now."
+
+            ssh_exec("localhost","sudo #{definition.shutdown_cmd}",ssh_options(definition))
+
+            #Wait for state poweroff
+            while (box.raw.state==:running) do
+              env.ui.info ".",{:new_line => false} 
+              sleep 1
+            end
+            env.ui.info
+            env.ui.info "Machine #{name} is powered off cleanly"
+          end
+
+          #Vagrant requires a relative path for output of boxes
+
+          #4.0.x. not using boxes as a subdir
+          boxdir=Pathname.new(Dir.pwd)
+
+          full_path=File.join(boxdir,box.name+".box")
+          path1=Pathname.new(full_path)
+          path2=Pathname.new(Dir.pwd)
+          box_path=path1.relative_path_from(path2).to_s
+
+          if File.exists?("#{box_path}")
+            env.ui.info "box #{name}.box already exists"
+            exit
+          end
+
+          env.ui.info "Excuting vagrant voodoo:"
+          export_command="vagrant package --base '#{box_name}' --output '#{box_path}'"
+          env.ui.info "#{export_command}"
+          shell_exec("#{export_command}") #hmm, needs to get the gem_home set?
+          env.ui.info ""
+
+          #add_ssh_nat_mapping back!!!!
+          #vagrant removes the mapping
+          #we need to restore it in order to be able to login again
+          box.add_ssh_nat_mapping(definition)
+
+          env.ui.info "To import it into vagrant type:"
+          env.ui.info "vagrant box add '#{box_name}' '#{box_path}'"
+          env.ui.info ""
+          env.ui.info "To use it:"
+          env.ui.info "vagrant init '#{box_name}'"
+          env.ui.info "vagrant up"
+          env.ui.info "vagrant ssh"
+        end
+
+      end #Module
+    end #Module
+  end #Module
+end #Module
+
+
+  #      #currently vagrant has a problem with the machine up, it calculates the wrong port to ssh to poweroff the system
+  #      thebox.execute("shutdown -h now")
+  #      thebox.wait_for_state("poweroff")
+
+  #      Shellutil.execute("echo 'Vagrant::Config.run do |config|' > /tmp/Vagrantfile")
+  #      Shellutil.execute("echo '   config.ssh.forwarded_port_key = \"ssh\"' >> /tmp/Vagrantfile")
+  #      Shellutil.execute("echo '   config.raw.forward_port(\"ssh\",22,#{host_port})' >> /tmp/Vagrantfile")
+  #      Shellutil.execute("echo 'end' >> /tmp/Vagrantfile")
+
+
+  #vagrant export disables the machine
+  #      thebox.ssh_enable_vmachine({:hostport => host_port , :guestport => 22} )

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

@@ -0,0 +1,35 @@
+module Veewee
+  module Builder
+    module Virtualbox
+      module BuilderHelper
+
+      def validate_vagrant(box_name,options)
+        require 'cucumber'
+
+        require 'cucumber/rspec/disable_option_parser'
+        require 'cucumber/cli/main'
+
+        ENV['veewee_user']=options[:user]
+        feature_path=File.join(File.dirname(__FILE__),"..","..","..","..","..","validation","vagrant.feature")
+
+        features=Array.new
+        features[0]=feature_path
+
+        begin
+          # The dup is to keep ARGV intact, so that tools like ruby-debug can respawn.
+          failure = Cucumber::Cli::Main.execute(features.dup)
+          Kernel.exit(failure ? 1 : 0)
+        rescue SystemExit => e
+          Kernel.exit(e.status)
+        rescue Exception => e
+          env.ui.error("#{e.message} (#{e.class})")
+          env.ui.error(e.backtrace.join("\n"))
+          Kernel.exit(1)
+        end
+
+      end
+    end #Module
+      
+    end #Module
+  end #Module
+end #Module

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

@@ -0,0 +1,137 @@
+require 'veewee/builder/core/box'
+require 'veewee/builder/core/box/vnc'
+
+require 'veewee/builder/vmfusion/helper/template'
+require 'veewee/builder/vmfusion/helper/create'
+require 'veewee/builder/vmfusion/helper/export_ova'
+require 'veewee/util/tcp'
+
+
+module Veewee
+  module Builder
+    module Vmfusion
+      class Box < Veewee::Builder::Core::Box
+
+        include ::Veewee::Builder::Vmfusion::BoxHelper
+        include ::Veewee::Builder::Core::BoxCommand
+
+        attr_reader :vnc_port
+
+        def initialize(name,env)
+
+          require 'fission'
+
+          super(name,env)
+        end
+
+        # When we create a new box
+        # We assume the box is not running
+        def create(definition)
+
+          @vnc_port=guess_vnc_port
+          create_vm(definition)
+          create_disk(definition)
+        end
+
+        def start(gui_enabled=true)
+          if gui_enabled
+            raw.start unless raw.nil?
+          else
+            raw.start({:headless => true}) unless raw.nil?
+          end
+
+        end
+
+        def stop
+          raw.stop unless raw.nil?
+        end
+
+        def halt
+          raw.halt unless raw.nil?
+        end
+
+        def shutdown
+          # Should be clean shutdown
+          raw.stop unless raw.nil?
+        end
+
+        def destroy
+          unless raw.exists?
+            env.ui.error "Error:: You tried to destroy a non-existing box '#{name}'"
+            exit -1
+          end
+
+          raw.halt if raw.state=="running"
+          ::Fission::VM.delete(name)
+          # remove it from memory
+          @raw=nil
+        end
+
+        # Check if box is running
+        def ready?
+          return false if raw.nil?
+          return raw.running?
+        end
+
+        # Check if the box already exists
+        def exists?
+          return raw.exists?
+        end
+
+        # Get the IP address of the box
+        def ip_address
+          return raw.ip_address
+        end
+
+        # Type on the console
+        def console_type(sequence,type_options={})
+          vnc_type(sequence,"localhost",vnc_display_port)
+
+          # Once this is over, we can remove the vnc port from the config file
+          remove_vnc_port
+        end
+
+        # This tries to guess a port for the VNC Display
+        def guess_vnc_port
+          min_port=5920
+          max_port=6000
+          guessed_port=nil
+
+          for port in (min_port..max_port)
+            unless is_tcp_port_open?("127.0.0.1", port)
+              guessed_port=port
+              break
+            end
+          end
+
+          if guessed_port.nil?
+            env.ui.info "No free VNC port available: tried #{min_port}..#{max_port}"
+            exit -1
+          else
+            env.ui.info "Found VNC port #{guessed_port} available"            
+          end
+
+          return guessed_port
+        end
+
+        def vnc_display_port
+          vnc_port - 5900
+        end
+
+        def remove_vnc_port
+          env.ui.info "Removing vnc_port from #{raw.vmx_path}"
+          lines=File.readlines(raw.vmx_path).reject{|l| l =~ /^RemoteDisplay.vnc/}
+          File.open(raw.vmx_path, 'w') do |f|  
+            f.puts lines 
+          end
+        end
+
+        private
+        def raw
+          @raw=::Fission::VM.new(name)
+        end
+
+      end # End Class
+    end # End Module
+  end # End Module
+end # End Module

data/lib/veewee/builder/vmfusion/builder.rb

@@ -0,0 +1,78 @@
+require 'veewee/builder/core/builder'
+require 'veewee/builder/vmfusion/helper/validate_vmfusion'
+
+
+module Veewee
+  module Builder
+    module Vmfusion
+      class Builder < Veewee::Builder::Core::Builder
+
+        include ::Veewee::Builder::Vmfusion::BuilderHelper
+
+
+        def check_requirements
+          #unless gem_available?("fission")
+            #raise ::Veewee::Error, "The Vmfusion Builder requires the gem 'fission' to be installed\n"+ "gem install fission"
+          #end
+        end
+
+        def build_info
+          info=super
+          command="/Library/Application Support/VMware Fusion/vmrun"
+          output=IO.popen("#{command.shellescape}").readlines
+          info << {:filename => ".vmfusion_version",:content => output[1].split(/ /)[2..3].join.strip}
+
+        end
+
+        # Translate the definition ssh options to ssh options that can be passed to Net::Ssh calls
+        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
+
+
+        #
+
+        # Transfer information provide by the builder to the box
+        #
+        #
+        def transfer_buildinfo(box,definition)
+          super(box,definition)
+
+          # When we get here, ssh is available and no postinstall scripts have been executed yet
+          # So we begin by transferring the ISO file of the vmware tools
+
+          iso_image="/Library/Application Support/VMware Fusion/isoimages/linux.iso"
+          iso_image="/Library/Application Support/VMware Fusion/isoimages/darwin.iso" if definition.os_type_id=~/^Darwin/
+            iso_image="/Library/Application Support/VMware Fusion/isoimages/freebsd.iso" if definition.os_type_id=~/^Free/
+            iso_image="/Library/Application Support/VMware Fusion/isoimages/windows.iso" if definition.os_type_id=~/^Win/
+
+            begin
+              when_ssh_login_works(box.ip_address,ssh_options(definition).merge({:timeout => definition.postinstall_timeout.to_i})) do
+                begin
+                  env.logger.info "About to transfer vmware tools iso buildinfo to the box #{box.name} - #{box.ip_address} - #{ssh_options(definition)}"
+                  ssh_transfer_file(box.ip_address,iso_image,File.basename(iso_image),ssh_options(definition))
+                rescue RuntimeError => ex
+                  env.ui.error "Error transfering vmware tools iso , possible not enough permissions to write? #{ex}"
+                  exit -1
+                end
+              end
+            rescue Net::SSH::AuthenticationFailed
+              env.ui.error "Authentication failure"
+              exit -1
+            end            
+
+        end
+
+
+
+
+      end #End Class
+    end # End Module
+  end # End Module
+end # End Module

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

@@ -0,0 +1,68 @@
+require 'erb'
+
+module Veewee
+  module Builder
+    module Vmfusion
+      module BoxHelper
+        def create_disk(definition)
+          #Disk types:
+          #    0                   : single growable virtual disk
+          #    1                   : growable virtual disk split in 2GB files
+          #    2                   : preallocated virtual disk
+          #    3                   : preallocated virtual disk split in 2GB files
+          #    4                   : preallocated ESX-type virtual disk
+          #    5                   : compressed disk optimized for streaming
+          #    6                   : thin provisioned virtual disk - ESX 3.x and above
+          disk_type=1
+          current_dir=FileUtils.pwd
+          FileUtils.chdir(vm_path)
+          env.ui.info "Creating disk"
+          command="#{fusion_path.shellescape}/vmware-vdiskmanager -c -s #{definition.disk_size}M -a lsilogic -t #{disk_type} #{name}.vmdk"
+          shell_results=shell_exec("#{command}",{:mute => true})
+          FileUtils.chdir(current_dir)
+        end
+
+        def fusion_os_type(type_id)
+          env.logger.info "Translating #{type_id} into fusion type"
+          fusiontype=env.config.ostypes[type_id][:fusion]
+          env.logger.info "Found fusion type #{fusiontype}"
+          return fusiontype
+        end
+
+        def create_vm(definition)
+          fusion_definition=definition.dup
+
+          fusion_definition.os_type_id=fusion_os_type(definition.os_type_id)
+
+          FileUtils.mkdir_p(vm_path)
+          current_dir=FileUtils.pwd
+          FileUtils.chdir(vm_path)
+          aFile = File.new(vmx_file_path, "w")
+          aFile.write(vmx_template(fusion_definition))
+          aFile.close
+          FileUtils.chdir(current_dir)
+        end
+
+        def determine_vmrun_cmd
+          return "#{fusion_path}/vmrun"
+        end
+
+        def vm_path
+          home=ENV['HOME']
+          dir="#{home}/Documents/Virtual Machines.localized/#{name}.vmwarevm"
+          return dir
+        end
+
+        def fusion_path
+          dir="/Library/Application Support/VMware Fusion/"
+          return dir
+        end
+
+        def vmx_file_path
+          return "#{vm_path}/#{name}.vmx"
+        end
+
+      end
+    end
+  end
+end

data/lib/veewee/builder/vmfusion/helper/export_ova.rb

@@ -0,0 +1,26 @@
+require 'tempfile'
+
+module Veewee
+  module Builder
+    module Vmfusion
+      module BoxHelper
+      # This function 'exports' the box based on the definition
+      def export_ova(options)
+        debug="--X:logToConsole=true --X:logLevel=\"verbose\""
+        debug=""
+        flags="--compress=9"
+
+        # Need to check binary first
+        if ready?
+          shutdown
+        end
+        
+        # before exporting the system needs to be shut down
+        
+        # otherwise the debug log will show - The specified virtual disk needs repair
+        shell_exec("#{fusion_path.shellescape}/ovftool/ovftool.bin #{debug} #{flags} #{vmx_file_path.shellescape} #{name}.ova")
+      end
+    end
+    end
+  end
+end

data/lib/veewee/builder/vmfusion/helper/template.rb

@@ -0,0 +1,39 @@
+require 'erb'
+
+module Veewee
+  module Builder
+    module Vmfusion
+
+      module BoxHelper
+      class ErbBinding < OpenStruct
+        def get_binding
+          return binding()
+        end
+      end
+
+      def vmx_template(definition)
+        # We only want specific variables for ERB
+
+        data = {
+          :cpu_count => definition.cpu_count, :memory_size => definition.memory_size,
+          :controller_type => "lsilogic",
+          :fusion_os_type => definition.os_type_id,
+          :mac_addres => "auto generated",
+          :iso_file => "#{File.join(env.config.veewee.iso_dir,definition.iso_file)}",
+          :box_name => name,
+          :vnc_port => vnc_port
+        }
+
+        vars = ErbBinding.new(data)
+        template_path=File.join(File.dirname(__FILE__),"template.vmx.erb")
+        template=File.open(template_path).readlines.join
+        erb = ERB.new(template)
+        vars_binding = vars.send(:get_binding)
+        result=erb.result(vars_binding)
+        return result
+      end
+    end
+
+  end
+end
+end