lab 0.2.2 → 0.2.3

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

@@ -1,104 +0,0 @@
-require 'vm_driver'
-
-##
-## $Id$
-##
-
-module Lab
-module Drivers
-class FogDriver < VmDriver
-
-  def initialize(config,fog_config)
-    
-    super(config)
-    @fog_config = fog_config
-
-    # Soft dependency
-    begin
-      require 'fog'
-    rescue LoadError
-      raise "WARNING: Library fog not found. Could not create driver"
-    end
-
-    if @fog_config['fog_type'] == "ec2"
-
-      # AWS / EC2 Base Credential Configuration
-      @aws_cert_file = IO.read(fog_config['fog_aws_cert_file']).chomp if fog_config['fog_aws_cert_file']
-      @aws_private_key_file = IO.read(fog_config['fog_aws_private_key_file']).chomp if fog_config['fog_aws_private_key_file']
-      @ec2_access_key_file = IO.read(fog_config['fog_ec2_access_key_file']).chomp if fog_config['fog_ec2_access_key_file']
-      @ec2_secret_access_key_file = IO.read(fog_config['fog_ec2_secret_access_key_file']).chomp if fog_config['fog_ec2_secret_access_key_file']
-      
-      # Instance Keys
-      @ec2_instance_public_key_file = IO.read(fog_config['fog_ec2_instance_public_key_file']).chomp if fog_config['fog_ec2_instance_public_key_file']
-      @ec2_instance_private_key_file = IO.read(fog_config['fog_ec2_instance_private_key_file']).chomp if fog_config['fog_ec2_instance_private_key_file']
-      
-      # Instance Details
-      @ec2_base_ami = fog_config['fog_ec2_base_ami']
-      @ec2_flavor = fog_config['fog_ec2_flavor']
-      @ec2_user = fog_config['fog_ec2_user']
-      @ec2_region = fog_config['fog_ec2_region']
-          
-      # Set up a connection
-      @compute = Fog::Compute.new(
-        :provider => "Aws",
-        :aws_access_key_id => @aws_access_key_file,
-        :aws_secret_access_key => @aws_secret_access_key_file )
-    else
-      raise "Unsupported fog type"
-    end
-  end
-
-  def start
-    ec2_settings = {
-      :image_id => @ec2_base_ami,
-      :flavor_id =>  @ec2_flavor,
-      :public_key_path => @ec2_instance_public_key_file,
-      :private_key_path => @ec2_instance_private_key_file,
-      :username => @ec2_user}
-    begin
-      @fog_server = @compute.servers.bootstrap(ec2_settings)
-    rescue Fog::Compute::AWS::Error => e
-      raise "Couldn't authenticate to AWS - did you place keys in the creds/ directory?"
-      exit
-    end
-  end
-
-  def stop
-    @fog_server.destroy
-  end
-
-  def suspend
-    raise "unimplemented"
-  end
-
-  def pause
-    raise "unimplemented"
-  end
-
-  def reset
-    raise "unimplemented"
-  end
-
-  def create_snapshot(snapshot)
-    raise "unimplemented"
-  end
-
-  def revert_snapshot(snapshot)
-    raise "unimplemented"
-  end
-
-  def delete_snapshot(snapshot)
-    raise "unimplemented"
-  end
-
-  def cleanup
-    @fog_server.destroy
-  end
-
-  def running?
-    return true #TODO
-  end
-
-end
-end 
-end

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

@@ -1,177 +0,0 @@
-require 'vm_driver'
-
-##
-## $Id$
-##
-
-# This driver was built against: 
-# VMware ESXi Host Agent 4.1.0 build-348481
-
-module Lab
-module Drivers
-
-class RemoteEsxiDriver < 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
-
-    super(config)
-    
-    @user = filter_command(config['user'])
-    @host = filter_command(config['host'])
-    @port = config['port']    
-  end
-
-  def start
-    remote_system_command("vim-cmd vmsvc/power.on #{@vmid}")
-  end
-
-  def stop
-    remote_system_command("vim-cmd vmsvc/power.off #{@vmid}")
-  end
-
-  def suspend
-    remote_system_command("vim-cmd vmsvc/power.suspend #{@vmid}")
-  end
-
-  def pause
-    remote_system_command("vim-cmd vmsvc/power.suspend #{@vmid}")
-  end
-
-  def resume
-    remote_system_command("vim-cmd vmsvc/power.suspendResume #{@vmid}")
-  end
-
-  def reset
-    remote_system_command("vim-cmd vmsvc/power.reset #{@vmid}")
-  end
-
-  def create_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    
-    remote_system_command("vim-cmd vmsvc/snapshot.create #{@vmid} #{snapshot} \'lab created snapshot\' 1 true")
-  end
-
-  def revert_snapshot(snapshot)
-
-    snapshots = get_snapshots
-    
-    # Look through our snapshot list, choose the right one based on display_name    
-    snapshots.each do |snapshot_obj|
-    
-      #puts "DEBUG: checking #{snapshot_obj}"
-    
-      if snapshot_obj[:display_name].downcase == snapshot.downcase
-        snapshot_identifier = snapshot_obj[:name].join(" ")
-        
-        #puts "DEBUG: I would revert to #{snapshot_obj}"
-        remote_system_command("vim-cmd vmsvc/snapshot.revert #{@vmid} 0 #{snapshot_identifier}")
-        return true
-      end
-    end
-  
-    # If we got here, the snapshot didn't exist
-    raise "Invalid Snapshot Name"
-  end
-
-  def delete_snapshot(snapshot, remove_children=false)
-    snapshots = get_snapshots
-    
-    # Look through our snapshot list, choose the right one based on display_name    
-    snapshots.each do |snapshot_obj|
-    
-      #puts "DEBUG: checking #{snapshot_obj}"
-    
-      if snapshot_obj[:display_name].downcase == snapshot.downcase
-        snapshot_identifier = snapshot_obj[:name].join(" ")
-        remote_system_command("vim-cmd vmsvc/snapshot.remove #{@vmid} #{remove_children} #{snapshot_identifier}")
-        return true
-      end
-    end
-  
-    # If we got here, the snapshot didn't exist
-    raise "Invalid Snapshot Name"
-  end
-  
-  def delete_all_snapshots
-    remote_system_command("vim-cmd vmsvc/snapshot.removeall #{@vmid}")
-  end
-    
-  def run_command(command)
-    raise "Not Implemented"
-  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 "Not Implemented"
-  end
-
-  def create_directory(directory)
-    raise "Not Implemented"
-  end
-
-  def cleanup
-
-  end
-
-  def running?
-    power_status_string = `ssh #{@user}@#{@host} \"vim-cmd vmsvc/power.getstate #{@vmid}\"`
-    return true if power_status_string =~ /Powered on/
-  false
-  end 
-
-  def get_snapshots
-    # Command take the format: 
-    # vmware-vim-cmd vmsvc/snapshot.revert [vmid: int] [snapshotlevel: int] [snapshotindex: int]
-    output = `ssh #{@user}@#{@host} \"vim-cmd vmsvc/snapshot.get #{@vmid}\"`
-
-    # this keeps track of the snapshots, takes the form:
-    #[ {:name => [0,0], :display_name => "String containing the snapshotname}, 
-    #  {:name => [0,1], :display_name => "String containing the snapshotname}, ]
-    #  ... 
-    snapshots = []
-    
-    # Use these to keep track of the parsing...    
-    current_tree = -1
-    current_num = 0
-    count = 0
-    
-    # Do the parsing & stick the snapshots in the snapshots array
-    output_lines = output.split("\n")
-    output_lines.each do |line|
-      if line.include?("|") # this is a new snapshot
-        if line.include?("ROOT") # it's a root
-          current_num = 0
-          current_tree = current_tree + 1 # new tree
-          snapshots << { :name => [current_num, current_tree], :display_name => output_lines[count+1].split(":").last.strip }
-        else
-          current_num = current_num + 1 # new snapshot in current tree
-          snapshots << { :name => [current_num, current_tree], :display_name => output_lines[count+1].split(":").last.strip }
-        end
-      end
-      count = count+1
-    end
-
-  snapshots
-  end
-
-end
-
-end 
-end

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

@@ -1,197 +0,0 @@
-require 'vm_driver'
-
-##
-## $Id$
-##
-
-module Lab
-module Drivers
-
-class RemoteWorkstationDriver < VmDriver
-
-  attr_accessor :location # among other things
-
-  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
-
-    super(config)
-
-    @user = filter_command(config['user'])
-    @host = filter_command(config['host'])
-  end
-
-  def start
-    remote_system_command("vmrun -T ws start \'#{@location}\' nogui")
-  end
-
-  def stop
-    remote_system_command("vmrun -T ws stop \'#{@location}\' nogui")
-  end
-
-  def suspend
-    remote_system_command("vmrun -T ws suspend \'#{@location}\' nogui")
-  end
-
-  def pause
-    remote_system_command("vmrun -T ws pause \'#{@location}\' nogui")
-  end
-
-  def reset
-    remote_system_command("vmrun -T ws reset \'#{@location}\' nogui")
-  end
-
-  def create_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    remote_system_command("vmrun -T ws snapshot \'#{@location}\' #{snapshot} nogui")
-  end
-
-  def revert_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    remote_system_command("vmrun -T ws revertToSnapshot \'#{@location}\' #{snapshot} nogui")
-  end
-
-  def delete_snapshot(snapshot)
-    snapshot = filter_input(snapshot)
-    remote_system_command("vmrun -T ws deleteSnapshot \'#{@location}\' #{snapshot} nogui" )
-  end
-  
-  def run_command(command)
-    # generate local & remote script paths
-    script_rand_name = rand(10000)
-
-    if @os == "windows"
-      local_tempfile_path = "/tmp/lab_script_#{script_rand_name}.bat"
-      remote_tempfile_path = "C:\\\\lab_script_#{script_rand_name}.bat"
-      remote_run_command = remote_tempfile_path
-    else
-      local_tempfile_path = "/tmp/lab_script_#{script_rand_name}.sh"
-      remote_tempfile_path = "/tmp/lab_script_#{script_rand_name}.sh"
-      remote_run_command = "/bin/sh #{remote_tempfile_path}"
-    end
-
-    # write out our script locally
-    File.open(local_tempfile_path, 'w') {|f| f.write(command) }
-
-    # we really can't filter command, so we're gonna stick it in a script
-    if @tools
-      # copy it to the vm host - this is because we're a remote driver
-      remote_copy_command = "scp #{local_tempfile_path} #{@user}@#{@host}:#{local_tempfile_path}"
-      system_command(remote_copy_command)
-
-      # we have it on the vm host, copy it to the vm guest
-      vmrunstr = "ssh #{@user}@#{@host} \"vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " +
-          "copyFileFromHostToGuest \'#{@location}\' \'#{local_tempfile_path}\' " +
-          "\'#{remote_tempfile_path}\' nogui\""
-      system_command(vmrunstr)
-
-      # now run it on the guest
-      vmrunstr = "ssh #{@user}@#{@host} \"vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " + 
-          "runProgramInGuest \'#{@location}\' -noWait -activeWindow \'#{remote_run_command}\'"
-      system_command(vmrunstr)
-
-      ## CLEANUP
-      # delete it on the guest
-      vmrunstr = "ssh #{@user}@#{@host} \"vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " + 
-          "deleteFileInGuest \'#{@location}\' \'#{remote_tempfile_path}\'"
-      system_command(vmrunstr)
-
-      # and delete it on the vm host
-      vmhost_delete_command = "ssh #{@user}@#{@host} rm #{local_tempfile_path}"
-      system_command(vmhost_delete_command)
-
-      # delete it locally
-      local_delete_command = "rm #{local_tempfile_path}"
-      system_command(local_delete_command)
-    else
-      # since we can't copy easily w/o tools, let's just run it directly :/
-      if @os == "linux"
-        scp_to(local_tempfile_path, remote_tempfile_path)
-        ssh_exec(remote_run_command)
-        ssh_exec("rm #{remote_tempfile_path}")
-      else
-        raise "Not Implemented - Install VmWare Tools"
-      end  
-    end
-  end
-  
-  def copy_from(from, to)
-    from = filter_input(from)
-    to = filter_input(to)
-    
-    # copy it to the vm host - this is because we're a remote driver
-    remote_copy_command = "scp #{from} #{@user}@#{@host}:#{from}"
-    system_command(remote_copy_command)
-
-    if @tools 
-      remote_system_command("ssh #{@user}@#{@host} \"vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " +
-          "copyFileFromGuestToHost \'#{@location}\' \'#{from}\' \'#{to}\' nogui")
-    else
-      scp_from(to,from)
-    end
-  end
-
-  def copy_to(from, to)
-  
-    from = filter_input(from)
-    to = filter_input(to)
-    
-    # copy it to the vm host - this is because we're a remote driver
-    remote_copy_command = "scp #{from} #{@user}@#{@host}:#{from}"
-    system_command(remote_copy_command)
-    
-    if @tools
-      remote_system_command("vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " +
-          "copyFileFromHostToGuest \'#{@location}\' \'#{from}\' \'#{to}\' nogui")
-    else
-      scp_to(from,to)
-    end
-  end
-
-  def check_file_exists(file)
-    
-    if @tools
-      file = filter_input(file)
-      remote_system_command("vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " +
-          "fileExistsInGuest \'#{@location}\' \'{file}\' nogui")
-    else
-      raise "Not Implemented - Install VmWare Tools"
-    end
-  end
-
-  def create_directory(directory)
-    directory = filter_input(directory)
-  
-    if @tools
-      emote_system_command("ssh #{@user}@#{@host} vmrun -T ws -gu #{@vm_user} -gp #{@vm_pass} " +
-          "createDirectoryInGuest \'#{@location}\' \'#{directory}\' nogui")
-      system_command(vmrunstr)
-    else
-      raise "Not Implemented - Install VmWare Tools"
-    end
-  end
-
-  def cleanup
-
-  end
-
-  def running?
-    ## Get running VMs
-    running = `ssh #{@user}@#{@host} \"vmrun list nogui\"`
-    running_array = running.split("\n")
-    running_array.shift
-
-    running_array.each do |vmx|
-      if vmx.to_s == @location.to_s
-        return true
-      end
-    end
-
-    false
-  end
-
-end
-
-end 
-end

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

@@ -1,142 +0,0 @@
-require 'vm_driver'
-require 'nokogiri'
-
-##
-## $Id$
-##
-module Lab
-module Drivers
-  class VirtualBoxDriver < VmDriver
-
-    attr_accessor :location
-
-    def initialize(config)
-
-      super(config)
-
-      ## Check to see if we already know this vm, if not, go on location
-      vmid_list = ::Lab::Controllers::VirtualBoxController::config_list
-      unless vmid_list.include? @vmid
-        raise "Error, no such vm: #{@vmid}" unless @location
-        
-        if !File.exist?(@location)
-          raise ArgumentError,"Error, no vm at: #{@location}"
-        end
-        
-        # Registering @location
-        @vmid = register_and_return_vmid
-      end
-      
-      vmInfo = `VBoxManage showvminfo \"#{@vmid}\" --machinereadable`
-      @location = vmInfo.scan(/CfgFile=\"(.*?)\"/).flatten[0].to_s
-
-      if !File.exist?(@location)
-        raise ArgumentError,"Couldn't find: " + @location
-      end
-
-    end
-
-    def register_and_return_vmid
-      
-      xml = Nokogiri::XML(File.new(@location))
-      vmid = xml.root.xpath("//Machine[@name]")
-      
-      ## only register if we don't already know the vmid
-      if !::Lab::Controllers::VirtualBoxController::config_list.include? vmid
-        system_command("VBoxManage registervm \"#{@location}\"")
-      end
-      
-      return vmid
-      
-    end
-
-    def unregister
-      system_command("VBoxManage unregistervm \"#{@vmid}\"")
-    end
-
-    def start
-      system_command("VBoxManage startvm \"#{@vmid}\"")
-    end
-
-    def stop
-      system_command("VBoxManage controlvm \"#{@vmid}\" poweroff")
-    end
-
-    def suspend
-      system_command("VBoxManage controlvm \"#{@vmid}\" savestate")
-    end
-
-    def pause
-      system_command("VBoxManage controlvm \"#{@vmid}\" pause")
-    end
-
-    def reset
-      system_command("VBoxManage controlvm \"#{@vmid}\" reset")
-    end
-
-    def create_snapshot(snapshot)
-      snapshot = filter_input(snapshot)
-      system_command("VBoxManage snapshot \"#{@vmid}\" take #{snapshot}")
-    end
-
-    def revert_snapshot(snapshot)
-      snapshot = filter_input(snapshot)
-      system_command("VBoxManage snapshot \"#{@vmid}\" restore #{snapshot}")
-    end
-
-    def delete_snapshot(snapshot)
-      snapshot = filter_input(snapshot)
-      system_command("VBoxManage snapshot \"#{@vmid}\" delete  #{snapshot}")
-    end
-
-    def run_command(command, arguments=nil)
-      command = filter_input(command)
-      arguments = filter_input(arguments)
-
-      command = "VBoxManage guestcontrol exec \"#{@vmid}\" \"#{command}\" --username \"#{@vm_user}\"" +
-           " --password \"#{@vm_pass}\" --arguments \"#{arguments}\""
-      system_command(command)
-    end
-  
-    def copy_from(from, to)
-      from = filter_input(from)
-      to = filter_input(to)
-
-      raise "Not supported by Virtual Box"
-    end
-
-    def copy_to(from, to)
-      from = filter_input(from)
-      to = filter_input(to)
-      
-      command = "VBoxManage guestcontrol copyto \"#{@vmid}\" \"#{from}\"  \"#{to}\" " +
-           "--username \"#{@vm_user}\" --password \"#{@vm_pass}\""
-      system_command(command)
-    end
-
-    def check_file_exists(file)
-      file = filter_input(file)
-
-      raise "Not supported by Virtual Box"
-    end
-
-    def create_directory(directory)
-      directory = filter_input(directory)
-
-      command = "VBoxManage guestcontrol createdir \"#{@vmid}\" \"#{directory}\" " + 
-           "--username \"#{@vm_user}\" --password \"#{@vm_pass}\""
-      system_command(command)
-    end
-
-    def cleanup
-
-    end
-
-    def running?
-      ## Get running Vms
-      ::Lab::Controllers::VirtualBoxController::running_list.include? @vmid
-    end
-    
-  end
-end
-end