lab 0.1.5 → 0.2.0

data/src/lib/lab/driver/vm_driver.rb

@@ -0,0 +1,195 @@
+##
+## $Id$
+##
+
+#
+#   !!WARNING!! - All drivers are expected to filter input before running
+#  anything based on it. This is particularly important in the case
+#  of the drivers which wrap a command line to provide functionality.  
+#
+
+module Lab
+module Drivers
+class VmDriver
+
+  attr_accessor :vmid 
+  attr_accessor :location
+  attr_accessor :os
+  attr_accessor :tools
+  attr_accessor :credentials
+  
+  def initialize(config)
+
+    @vmid = filter_command(config["vmid"].to_s)
+    @location = filter_command(config["location"])
+    @credentials = config["credentials"] || []
+    @tools = filter_input(config["tools"])
+    @arch = filter_input(config["arch"])
+    @os = filter_input(config["os"])
+    @hostname = filter_input(config["hostname"]) || filter_input(config["vmid"].to_s)
+
+    # Currently only implemented for the first set
+    if @credentials.count > 0
+      @vm_user = filter_input(@credentials[0]['user'])
+      @vm_pass = filter_input(@credentials[0]['pass'])
+      @vm_keyfile = filter_input(@credentials[0]['keyfile'])
+    end
+  end
+
+  ## This interface must be implemented in a child driver class
+  ## #########################################################
+
+  def register
+    raise "Command not Implemented"
+  end
+    
+  def unregister
+    raise "Command not Implemented"
+  end
+
+  def start
+    raise "Command not Implemented"
+  end
+
+  def stop
+    raise "Command not Implemented"
+  end
+
+  def suspend
+    raise "Command not Implemented"
+  end
+
+  def pause
+    raise "Command not Implemented"
+  end
+
+  def resume
+    raise "Command not Implemented"
+  end
+
+  def reset
+    raise "Command not Implemented"
+  end
+
+  def create_snapshot(snapshot)
+    raise "Command not Implemented"
+  end
+
+  def revert_snapshot(snapshot)
+    raise "Command not Implemented"
+  end
+
+  def delete_snapshot(snapshot)
+    raise "Command not Implemented"
+  end
+
+  def run_command(command)  
+    raise "Command not Implemented"
+  end
+  
+  def copy_from(from, to)
+    raise "Command not Implemented"
+  end
+  
+  def copy_to(from, to)
+    raise "Command not Implemented"
+  end
+
+  def check_file_exists(file)
+    raise "Command not Implemented"
+  end
+
+  def create_directory(directory)
+    raise "Command not Implemented"
+  end
+
+  def cleanup
+    raise "Command not Implemented"
+  end
+
+  ## End Interface
+  ## #########################################################
+
+private
+
+  # The only reason we don't filter here is because we need
+  # the ability to still run clean (controlled entirely by us)
+  # command lines.
+  def system_command(command)
+    puts "DEBUG: system command #{command}"
+    system(command)
+  end
+
+  def remote_system_command(command)
+    puts "DEBUG: remote system command #{command} running with user #{@user}@#{@host}"
+    system_command("ssh #{@user}@#{@host} \"#{command}\"")
+  end
+
+  def scp_to(local,remote)
+    if @vm_keyfile
+      #puts "DEBUG: authenticating to #{@hostname} as #{@vm_user} with key #{@vm_keyfile}"
+      Net::SCP.start(@hostname, @vm_user, :keys => [@vm_keyfile]) do |scp|
+        puts "DEBUG: uploading #{local} to #{remote}"
+        scp.upload!(local,remote)
+      end
+    else
+      Net::SCP.start(@hostname, @vm_user, :password => @vm_pass, :auth_methods => ["password"]) do |scp|
+        puts "DEBUG: uploading #{local} to #{remote}"
+        scp.upload!(local,remote)
+      end
+    end  
+  end
+  
+  def scp_from(remote, local)
+    # download a file from a remote server
+    if @vm_keyfile
+      #puts "DEBUG: authenticating to #{@hostname} as #{@vm_user} with key #{@vm_keyfile}"
+      Net::SCP.start(@hostname, @vm_user, :keys => [@vm_keyfile]) do |scp|
+        puts "DEBUG: downloading #{remote} to #{local}"
+        scp.download!(remote,local)
+      end
+    else
+      Net::SCP.start(@hostname, @vm_user, :password => @vm_pass, :auth_methods => ["password"]) do |scp|
+        puts "DEBUG: downloading #{remote} to #{local}"
+        scp.download!(remote,local)
+      end
+    end
+  end
+  
+  def ssh_exec(command)
+    if @vm_keyfile
+      #puts "DEBUG: authenticating to #{@hostname} as #{@vm_user} with key #{@vm_keyfile}"
+      Net::SSH.start(@hostname, @vm_user, :keys => [@vm_keyfile]) do |ssh|
+        puts "DEBUG: running command: #{command}"
+        ssh.exec!(command)
+      end
+    else
+      Net::SSH.start(@hostname, @vm_user, :password => @vm_pass, :auth_methods => ["password"]) do |ssh|
+        result = ssh.exec!(command)
+      end
+    end
+  end
+
+  def filter_input(string)
+    return "" unless string # nil becomes empty string
+    return unless string.class == String # Allow other types unmodified
+    
+    unless /^[\d\w\s\[\]\{\}\/\\\.\-\"\(\):!]*$/.match string
+      raise "WARNING! Invalid character in: #{string}"
+    end
+  string
+  end
+
+  def filter_command(string)
+    return "" unless string # nil becomes empty string
+    return unless string.class == String # Allow other types unmodified    
+    
+    unless /^[\d\w\s\[\]\{\}\/\\\.\-\"\(\)]*$/.match string
+      raise "WARNING! Invalid character in: #{string}"
+    end
+  string
+  end
+
+end
+end
+end

data/src/lib/lab/driver/vsphere_driver.rb

@@ -0,0 +1,120 @@
+require 'vm_driver'
+
+##
+## $Id$
+##
+
+# This driver was built against: 
+# VMware Vsphere 4.1
+
+module Lab
+module Drivers
+
+class VsphereDriver < VmDriver
+
+  def initialize(config)
+    unless config['user'] then raise ArgumentError, "Must provide a username" end
+    unless config['host'] then raise ArgumentError, "Must provide a hostname" end
+    unless config[''] then raise ArgumentError, "Must provide a password" end
+    super(config)
+
+    @user = filter_command(config['user'])
+    @host = filter_command(config['host'])
+
+    # Soft dependency
+    begin
+      require 'rbvmomi'
+    rescue LoadError
+      raise "WARNING: Library rbvmomi not found. Could not create driver!"
+    end
+
+    vim = RbVmomi::VIM.connect host: @host, user: @user, password: @pass
+    dc = vim.serviceInstance.find_datacenter("datacenter1") or fail "datacenter not found"
+    @vm = dc.find_vm("test") or fail "VM not found"
+  end
+
+  def start
+    @vm.PowerOnVM_Task.wait_for_completion
+  end
+
+  def stop
+    @vm.PowerOffVM_Task.wait_for_completion
+  end
+
+  def suspend
+    @vm.SuspendVM_Task.wait_for_completion
+  end
+
+  def pause
+    raise "Unimplemented"
+  end
+
+  def resume
+    raise "Unimplemented"
+  end
+
+  def reset
+    @vm.ResetVM_Task.wait_for_completion
+  end
+
+  def create_snapshot(snapshot)
+    snapshot = filter_input(snapshot)
+    raise "Unimplemented"
+  end
+
+  def revert_snapshot(snapshot)
+    raise "Unimplemented"
+    # If we got here, the snapshot didn't exist
+    raise "Invalid Snapshot Name"
+  end
+
+  def delete_snapshot(snapshot, remove_children=false)
+    raise "Unimplemented"
+    # If we got here, the snapshot didn't exist
+    raise "Invalid Snapshot Name"
+  end
+  
+  def delete_all_snapshots
+    raise "Unimplemented"
+  end
+    
+  def run_command(command)
+    raise "Unimplemented"
+  end
+  
+  def copy_from(from, to)
+    if @os == "linux"
+      scp_from(from, to)
+    else
+      raise "Unimplemented"
+    end
+  end
+
+  def copy_to(from, to)
+    if @os == "linux"
+      scp_to(from, to)
+    else
+      raise "Unimplemented"
+    end
+  end
+
+  def check_file_exists(file)
+    raise "Unimplemented"
+  end
+
+  def create_directory(directory)
+    raise "Unimplemented"
+  end
+
+  def cleanup
+    raise "Unimplemented"
+  end
+
+  def running?
+    raise "Unimplemented"
+  end 
+
+end
+
+end 
+end

data/src/lib/lab/driver/workstation_driver.rb

@@ -0,0 +1,234 @@
+require 'vm_driver'
+
+##
+## $Id$
+##
+
+module Lab
+module Drivers
+
+class WorkstationDriver < VmDriver
+
+  def initialize(config)
+    super(config)
+    
+    if !File.exist?(@location)
+      raise ArgumentError,"Couldn't find: #{@location}"
+    end
+  end
+
+  def start
+    system_command("vmrun -T ws start " + "\'#{@location}\' nogui")
+  end
+
+  def stop
+    system_command("vmrun -T ws stop " + "\'#{@location}\' nogui")
+  end
+
+  def suspend
+    system_command("vmrun -T ws suspend " + "\'#{@location}\' nogui")
+  end
+
+  def pause
+    system_command("vmrun -T ws pause " + "\'#{@location}\' nogui")
+  end
+
+  def reset
+    system_command("vmrun -T ws reset " + "\'#{@location}\' nogui")
+  end
+
+  def create_snapshot(snapshot)
+    snapshot = filter_input(snapshot)
+    system_command("vmrun -T ws snapshot " + "\'#{@location}\' \'#{snapshot}\' nogui")
+  end
+
+  def revert_snapshot(snapshot)
+    snapshot = filter_input(snapshot)
+    system_command("vmrun -T ws revertToSnapshot " + "\'#{@location}\' \'#{snapshot}\' nogui")
+  end
+
+  def delete_snapshot(snapshot)
+    snapshot = filter_input(snapshot)
+    system_command("vmrun -T ws deleteSnapshot " + "\'#{@location}\' \'#{snapshot}\' nogui" )
+  end
+
+  def run_command(command)
+
+    #
+    # Generate a script name
+    #
+    script_rand_name = rand(1000000)
+
+    #
+    # Configure paths for each OS - We really can't filter command, so we're gonna 
+    # stick it in a script
+    #
+    if @os == "windows"
+      local_tempfile_path = "/tmp/lab_script_#{script_rand_name}.bat"
+      remote_tempfile_path = "C:\\\\lab_script_#{script_rand_name}.bat"
+      remote_output_file = "C:\\\\lab_command_output_#{script_rand_name}"
+      remote_run_command = remote_tempfile_path
+      File.open(local_tempfile_path, 'w') {|f| f.write(command) }
+    else
+      
+      local_tempfile_path = "/tmp/lab_script_#{script_rand_name}.sh"
+      remote_tempfile_path = "/tmp/lab_script_#{script_rand_name}.sh"
+      remote_output_file = "/tmp/lab_command_output_#{script_rand_name}"
+      local_output_file = "/tmp/lab_command_output_#{script_rand_name}"
+      
+      remote_run_command = remote_tempfile_path
+      
+      File.open(local_tempfile_path, 'w') {|f| f.write("#!/bin/sh\n#{command}\n")}
+    end
+    
+    if @tools
+
+      #puts "DEBUG: Running w/ tools"
+
+      #
+      # Copy our local tempfile to the guest
+      #
+      vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " +
+          "copyFileFromHostToGuest \'#{@location}\' \'#{local_tempfile_path}\'" +
+          " \'#{remote_tempfile_path}\'"
+      system_command(vmrunstr)
+
+      if @os == "linux"
+        #
+        # Now run the command directly on the guest (linux - call w/ /bin/sh)
+        #
+        vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " + 
+            "runProgramInGuest \'#{@location}\' /bin/sh #{remote_tempfile_path} > #{remote_output_file}"
+        system_command(vmrunstr)
+      else
+        #
+        # Now run the command directly on the guest (windows)
+        #
+        vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " + 
+            "runProgramInGuest \'#{@location}\' #{remote_tempfile_path} > #{remote_output_file}" 
+        system_command(vmrunstr)
+      end
+      
+      #
+      # Cleanup. Delete it on the guest
+      #
+      vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " + 
+          "deleteFileInGuest \'#{@location}\' \'#{remote_tempfile_path}\'"
+      system_command(vmrunstr)
+
+      #
+      # Delete it locally
+      #
+      local_delete_command = "rm #{local_tempfile_path}"
+      system_command(local_delete_command)
+    else
+
+      #
+      # Use SCP / SSH
+      #
+
+      if @os == "linux"
+        
+        #
+        # Copy it over
+        #
+        scp_to(local_tempfile_path, remote_tempfile_path)
+
+        #
+        # And ... execute it
+        #
+        ssh_exec("/bin/sh #{remote_tempfile_path} > #{remote_output_file}")
+
+        #
+        # Now copy the output back to us
+        #
+        scp_from(remote_output_file, local_output_file)
+
+        # Now, let's look at the output of the command
+        output_string = File.open(local_output_file,"r").read
+
+        #
+        # And clean up
+        #
+        ssh_exec("rm #{remote_output_file}")
+        ssh_exec("rm #{remote_tempfile_path}")
+        
+        `rm #{local_output_file}`
+
+      else
+        raise "Hey, no tools, and windows? can't do nuttin for ya man."
+      end
+      
+    end
+  output_string
+  end
+  
+  def copy_from(from, to)
+    from = filter_input(from)
+    to = filter_input(to)
+    if @tools
+      vmrunstr = "vmrun -T ws -gu \'#{@vm_user}\' -gp \'#{@vm_pass}\' copyFileFromGuestToHost " +
+          "\'#{@location}\' \'#{from}\' \'#{to}\'" 
+    else
+      scp_from(from, to)
+    end
+    system_command(vmrunstr)
+  end
+
+  def copy_to(from, to)
+    from = filter_input(from)
+    to = filter_input(to)
+    if @tools
+      vmrunstr = "vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} copyFileFromHostToGuest " +
+        "\'#{@location}\' \'#{from}\' \'#{to}\'"
+      system_command(vmrunstr)
+    else
+      scp_to(from, to)
+    end
+  end
+
+  def check_file_exists(file)
+    file = filter_input(file)
+    if @tools
+      vmrunstr = "vmrun -T ws -gu \'#{@vm_user}\' -gp \'#{@vm_pass}\' fileExistsInGuest " +
+        "\'#{@location}\' \'#{file}\'"
+      system_command(vmrunstr)
+    else
+      raise "Unsupported"
+    end
+  end
+
+  def create_directory(directory)
+    directory = filter_input(directory)
+    if @tools
+      vmrunstr = "vmrun -T ws -gu \'#{@vm_user}\' -gp \'#{@vm_pass}\' createDirectoryInGuest " +
+          " \'#{@location}\' \'#{directory}\' "
+      system_command(vmrunstr)
+    else
+      raise "Unsupported"
+    end
+  end
+
+  def cleanup
+
+  end
+
+  def running?
+    ## Get running Vms
+    running = `vmrun list`
+    running_array = running.split("\n")
+    running_array.shift
+
+    running_array.each do |vmx|
+      if vmx.to_s == @location.to_s
+        return true
+      end
+    end
+
+    return false
+  end
+
+end
+
+end 
+end