veewee 0.3.7 → 0.3.9

data/lib/fission.old/command/suspend.rb

@@ -0,0 +1,67 @@
+module Fission
+  class Command
+    class Suspend < Command
+
+      def initialize(args=[])
+        super
+        @options.all = false
+      end
+
+      def execute
+        option_parser.parse! @args
+
+        if @args.count != 1 && !@options.all
+          Fission.ui.output self.class.help
+          Fission.ui.output ""
+          Fission.ui.output_and_exit "Incorrect arguments for suspend command", 1
+        end
+
+        vms_to_suspend.each do |vm|
+          Fission.ui.output "Suspending '#{vm.name}'"
+          task = vm.suspend
+
+          if task.successful?
+            Fission.ui.output "VM '#{vm.name}' suspended"
+          else
+            Fission.ui.output_and_exit "There was an error suspending the VM.  The error was:\n#{task.output}", task.code
+          end
+        end
+      end
+
+      def vms_to_suspend
+        if @options.all
+          vms=Fission::VM.all_running
+        else
+          vm_name = @args.first
+          vm=Fission::VM.new(vm_name)
+
+          unless vm.exists?
+            Fission.ui.output ''
+            Fission.ui.output_and_exit "VM #{vm_name} does not exist (#{Fission::VM.path(vm_name)})", 1
+          end
+
+          unless vm.running?
+            Fission.ui.output ''
+            Fission.ui.output_and_exit "VM '#{vm_name}' is not running", 1
+          end
+
+          vms = [vm]
+        end
+        vms
+      end
+
+      def option_parser
+        optparse = OptionParser.new do |opts|
+          opts.banner = "\nsuspend usage: fission suspend [vm | --all]"
+
+          opts.on '--all', 'Suspend all running VMs' do
+            @options.all = true
+          end
+        end
+
+        optparse
+      end
+
+    end
+  end
+end

data/lib/fission.old/config.rb

@@ -0,0 +1,34 @@
+module Fission
+  class Config
+    attr_accessor :attributes
+
+    CONF_FILE = File.expand_path '~/.fissionrc'
+
+    def initialize
+      @attributes = {}
+      load_from_file
+
+      if @attributes['vm_dir'].blank?
+        @attributes['vm_dir'] = File.expand_path('~/Documents/Virtual Machines.localized/')
+      end
+
+      if File.exists?('/Library/Application Support/VMware Fusion/vmrun')
+        @attributes['vmrun_bin'] = '/Library/Application Support/VMware Fusion/vmrun'
+      else
+        @attributes['vmrun_bin'] = '/Applications/VMware Fusion.app/Contents/Library/vmrun'
+      end
+
+      @attributes['vmrun_cmd'] = "#{@attributes['vmrun_bin'].gsub(' ', '\ ')} -T fusion"
+      @attributes['plist_file'] = File.expand_path('~/Library/Preferences/com.vmware.fusion.plist')
+      @attributes['gui_bin'] = File.expand_path('/Applications/VMware Fusion.app/Contents/MacOS/vmware')
+    end
+
+    private
+    def load_from_file
+      if File.file?(CONF_FILE)
+        @attributes.merge!(YAML.load_file(CONF_FILE))
+      end
+    end
+
+  end
+end

data/lib/fission.old/core_ext/class.rb

@@ -0,0 +1,5 @@
+class Class
+  def descendants
+    ObjectSpace.each_object(Class).select { |klass| klass < self }
+  end
+end

data/lib/fission.old/core_ext/file.rb

@@ -0,0 +1,7 @@
+class File
+  # from ptools
+  def self.binary?(file)
+    s = (File.read(file, File.stat(file).blksize) || "").split(//)
+    ((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
+  end
+end

data/lib/fission.old/core_ext/object.rb

@@ -0,0 +1,112 @@
+# this is from active_support
+# github.com/rails/rails/activesupport
+#
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, "", "   ", +nil+, [], and {} are blank.
+  #
+  # This simplifies:
+  #
+  #   if !address.nil? && !address.empty?
+  #
+  # ...to:
+  #
+  #   if !address.blank?
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  # An object is present if it's not <tt>blank?</tt>.
+  def present?
+    !blank?
+  end
+
+  # Returns object if it's <tt>present?</tt> otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to <tt>object.present? ? object : nil</tt>.
+  #
+  # This is handy for any representation of objects where blank is the same
+  # as not present at all.  For example, this simplifies a common check for
+  # HTTP POST/query parameters:
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # ...becomes:
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
+  def blank?
+    false
+  end
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   {:key => 'value'}.blank? # => false
+  #
+  alias_method :blank?, :empty?
+end
+
+class String
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   "".blank?                 # => true
+  #   "   ".blank?              # => true
+  #   " something here ".blank? # => false
+  #
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
+  def blank?
+    false
+  end
+end

data/lib/fission.old/error.rb

@@ -0,0 +1,10 @@
+module Fission
+    class Error < StandardError
+      attr_reader :original
+      def initialize(msg, original=$!)
+        super(msg)
+        @original = original
+      end
+    end
+end
+

data/lib/fission.old/fusion.rb

@@ -0,0 +1,17 @@
+module Fission
+  class Fusion
+
+    def self.running?
+      command = "ps -ef | grep -v grep | grep -c "
+      command << "#{Fission.config.attributes['gui_bin'].gsub(' ', '\ ')} 2>&1"
+      output = `#{command}`
+
+      response = Fission::Response.new :code => 0
+
+      output.strip.to_i > 0 ? response.data = true : response.data = false
+
+      response
+    end
+
+  end
+end

data/lib/fission.old/leasesfile.rb

@@ -0,0 +1,74 @@
+require 'date'
+
+class Lease
+  attr_accessor :name,:mac,:start,:end,:ip
+
+  def initialize(name)
+    @name=name
+    @ip=name
+  end
+
+  def expired?
+    @end < DateTime.now
+  end
+end
+
+class LeasesFile
+
+  attr_reader :leases
+
+  def initialize(filename)
+    @filename=filename
+    @leases=Array.new
+    load
+  end
+
+  def load
+    @leases=Array.new
+    File.open(@filename,"r") do |leasefile|
+      lease=nil
+      while (line = leasefile.gets)
+
+        line=line.lstrip.gsub(';','')
+        case line
+        when /^lease/
+          @leases << lease unless lease.nil?
+          name=line.split(' ')[1]
+          lease=Lease.new(name)
+        when /^hardware/
+          lease.mac=line.split(" ")[2]
+        when /^starts/
+          lease.start=DateTime.parse(line.split(" ")[2..3].join(" "))
+        when /^ends/
+          lease.end=DateTime.parse(line.split(" ")[2..3].join(" "))
+        end
+
+      end
+      @leases << lease unless lease.nil?
+    end
+    return @leases
+  end
+
+  def all_leases
+    return @leases
+  end
+
+  def current_leases
+    hash_list=Hash.new
+    @leases.each do |lease|
+      hash_list[lease.name]=lease
+    end
+    collapsed_list=Array.new
+    hash_list.each do |key,value|
+      collapsed_list << value
+    end
+    return collapsed_list
+  end
+
+  def find_lease_by_mac(mac)
+    matches=current_leases.select{|l| l.mac==mac}
+    return nil if matches.nil?
+    return matches[0]
+  end
+
+end

data/lib/fission.old/metadata.rb

@@ -0,0 +1,39 @@
+module Fission
+  class Metadata
+
+    require 'cfpropertylist'
+
+    attr_accessor :content
+
+    def self.delete_vm_info(vm_path)
+      metadata = new
+      metadata.load
+      metadata.delete_vm_restart_document(vm_path)
+      metadata.delete_vm_favorite_entry(vm_path)
+      metadata.save
+    end
+
+    def load
+      raw_data = CFPropertyList::List.new :file => Fission.config.attributes['plist_file']
+      @content = CFPropertyList.native_types raw_data.value
+    end
+
+    def save
+      new_content = CFPropertyList::List.new
+      new_content.value = CFPropertyList.guess @content
+      new_content.save Fission.config.attributes['plist_file'],
+        CFPropertyList::List::FORMAT_BINARY
+    end
+
+    def delete_vm_restart_document(vm_path)
+      if @content.has_key?('PLRestartDocumentPaths')
+        @content['PLRestartDocumentPaths'].delete_if { |p| p == vm_path }
+      end
+    end
+
+    def delete_vm_favorite_entry(vm_path)
+      @content['VMFavoritesListDefaults2'].delete_if { |vm| vm['path'] == vm_path }
+    end
+
+  end
+end

data/lib/fission.old/response.rb

@@ -0,0 +1,16 @@
+module Fission
+  class Response
+    attr_accessor :code, :output, :data
+
+    def initialize(args={})
+      @code = args.fetch :code, 1
+      @output = args.fetch :output, ''
+      @data = args.fetch :data, nil
+    end
+
+    def successful?
+      @code == 0
+    end
+
+  end
+end

data/lib/fission.old/ui.rb

@@ -0,0 +1,22 @@
+module Fission
+  class UI
+    attr_reader :stdout
+
+    def initialize(stdout=$stdout)
+      @stdout = stdout
+    end
+
+    def output(s)
+      @stdout.puts s
+    end
+
+    def output_printf(string, key, value)
+      @stdout.send :printf, string, key, value
+    end
+
+    def output_and_exit(s, exit_code)
+      output s
+      exit exit_code
+    end
+  end
+end

data/lib/fission.old/version.rb

@@ -0,0 +1,3 @@
+module Fission
+  VERSION = "0.4.0a"
+end

data/lib/fission.old/vm.rb

@@ -0,0 +1,370 @@
+require 'fission/leasesfile'
+require 'shellwords'
+require 'fission/error'
+
+module Fission
+  class VM
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    #####################################################
+    # Path Helpers
+    #####################################################
+    # Returns the topdir of the vm
+    def path
+      File.join Fission.config.attributes['vm_dir'], "#{@name}.vmwarevm"
+    end
+
+    # Returns a string to the path of the config file
+    # There is no guarantee it exists
+    def vmx_path
+      return File.join(path, "#{@name}.vmx")
+    end
+
+
+    ####################################################################
+    # State information
+    ####################################################################
+    def running?
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+
+      command = "#{vmrun_cmd} list"
+      output = `#{command}`
+
+      response = Fission::Response.new :code => $?.exitstatus
+
+      if response.successful?
+        vms = output.split("\n").select do |vm|
+          vm.include?('.vmx') && File.exists?(vm) && File.extname(vm) == '.vmx'
+        end
+        return vms.include?(self.vmx_path)
+      else
+        raise Fission::Error,"Error listing the state of vm #{@name}:\n#{output}"
+      end
+    end
+
+    def suspended?
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+
+      suspend_filename=File.join(File.dirname(vmx_path), File.basename(vmx_path,".vmx")+".vmem")
+      return File.exists?(suspend_filename)
+    end
+
+    # Checks to see if a vm exists
+    def exists?
+      File.exists? vmx_path
+    end
+
+    # Returns the state of a vm
+    def state
+      return "not created" unless self.exists?
+
+      return "suspend" if self.suspended?
+
+      return "running" if self.running?
+
+      return "not running"
+    end
+
+    ####################################################################
+    # VM information
+    ####################################################################
+
+    # Returns an Array of snapshot names
+    def snapshots
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+
+      command = "#{vmrun_cmd} listSnapshots #{vmx_path.shellescape} 2>&1"
+      output = `#{command}`
+
+      raise "There was an error listing the snapshots of #{@name} :\n #{output}" unless  $?.exitstatus==0
+
+      snaps_unfiltered = output.split("\n").select { |s| !s.include? 'Total snapshots:' }
+      snaps=snaps_unfiltered.map { |s| s.strip }
+      return snaps
+    end
+
+    # Retrieve the first mac address for a vm
+    # This will only retrieve the first auto generate mac address
+    def mac_address
+      raise ::Fission::Error,"VM #{@name} does not exist" unless self.exists?
+
+      line=File.new(vmx_path).grep(/^ethernet0.generatedAddress =/)
+      if line.nil?
+        #Fission.ui.output "Hmm, the vmx file #{vmx_path} does not contain a generated mac address "
+        return nil
+      end
+      address=line.first.split("=")[1].strip.split(/\"/)[1]
+      return address
+    end
+
+    # Retrieve the ip address for a vm.
+    # This will only look for dynamically assigned ip address via vmware dhcp
+    def ip_address
+      raise ::Fission::Error,"VM #{@name} does not exist" unless self.exists?
+
+      unless mac_address.nil?
+        lease=LeasesFile.new("/var/db/vmware/vmnet-dhcpd-vmnet8.leases").find_lease_by_mac(mac_address)
+        if lease.nil?
+          return nil
+        else
+          return lease.ip
+        end
+      else
+        # No mac address was found for this machine so we can't calculate the ip-address
+        return nil
+      end
+    end
+
+    ####################################################################
+    # VMS information
+    ####################################################################
+
+    # Returns an array of vm objects
+    def self.all
+      vm_dirs = Dir[File.join Fission.config.attributes['vm_dir'], '*.vmwarevm'].select do |d|
+        File.directory? d
+      end
+
+      vm_names=vm_dirs.map { |d| File.basename d, '.vmwarevm' }
+      vms=[]
+      vm_names.each do |vmname|
+        vm=Fission::VM.new vmname
+        vms << vm
+      end
+
+      return vms
+    end
+
+    # Returns an array of vms that are running
+    def self.all_running
+      running_vms=self.all.select do |vm|
+        vm.state=="running"
+      end
+      return running_vms
+    end
+
+    # Returns an existing vm
+    def self.get(name)
+      return Fission::VM.new(name)
+    end
+
+    #####################################################
+    # VM Class Actions
+    #####################################################
+    def self.clone(source_vm, target_vm)
+      raise Fission::Error,"VM #{source_vm} does not exist" unless Fission::VM.new(source_vm).exists?
+      raise Fission::Error,"VM #{target_vm} already exists" if Fission::VM.new(target_vm).exists?
+
+      FileUtils.cp_r Fission::VM.new(source_vm).path, Fission::VM.new(target_vm).path
+
+      rename_vm_files source_vm, target_vm
+      update_config source_vm, target_vm
+
+      response = Response.new :code => 0
+    end
+
+    def self.delete(vm_name)
+      raise Fission::Error,"VM #{vm_name} does not exist" unless Fission::VM.new(vm_name).exists?
+
+      vm=Fission::VM.new(vm_name)
+      FileUtils.rm_rf vm.path
+      Fission::Metadata.delete_vm_info(vm.path)
+
+      Response.new :code => 0
+    end
+
+
+    #####################################################
+    # VM Instance Actions
+    #####################################################
+    def create_snapshot(name)
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+
+      command = "#{vmrun_cmd} snapshot #{vmx_path.shellescape} \"#{name}\" 2>&1"
+      output = `#{command}`
+
+      response = Fission::Response.new :code => $?.exitstatus
+      response.output = output unless response.successful?
+
+      response
+    end
+
+    def start(args={})
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+      raise Fission::Error,"VM #{@name} is already started" if self.running?
+
+
+      command = "#{vmrun_cmd} start #{vmx_path.shellescape}"
+
+      if !args[:headless].blank? && args[:headless]
+        command << " nogui 2>&1"
+      else
+        command << " gui 2>&1"
+      end
+
+      output = `#{command}`
+
+      response = Fission::Response.new :code => $?.exitstatus
+      response.output = output unless response.successful?
+
+      response
+    end
+
+    def stop
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+      raise Fission::Error,"VM #{@name} is not running" unless self.running?
+
+      command = "#{vmrun_cmd} stop #{vmx_path.shellescape} 2>&1"
+      output = `#{command}`
+
+      response = Fission::Response.new :code => $?.exitstatus
+      response.output = output unless response.successful?
+
+      response
+    end
+
+    def halt
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+      raise Fission::Error,"VM #{@name} is not running" unless self.running?
+
+      command = "#{vmrun_cmd} stop #{vmx_path.shellescape} hard 2>&1"
+      output = `#{command}`
+
+      response = Fission::Response.new :code => $?.exitstatus
+      response.output = output unless response.successful?
+
+      response
+    end
+
+    def resume
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+      raise Fission::Error,"VM #{@name} is already running" if self.running?
+      if self.suspended?
+        self.start
+      end
+    end
+
+    def suspend
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+      raise Fission::Error,"VM #{@name} is not running" unless self.running?
+
+      command = "#{vmrun_cmd} suspend #{vmx_path.shellescape} hard 2>&1"
+      output = `#{command}`
+
+      response = Fission::Response.new :code => $?.exitstatus
+      response.output = output unless response.successful?
+      response
+    end
+
+    # Action to revert to a snapshot
+    # Returns a response object
+    def revert_to_snapshot(name)
+      raise Fission::Error,"VM #{@name} does not exist" unless self.exists?
+
+      command = "#{vmrun_cmd} revertToSnapshot #{vmx_path.shellescape} \"#{name}\" 2>&1"
+      output = `#{command}`
+
+      response = Fission::Response.new :code => $?.exitstatus
+      response.output = output unless response.successful?
+
+      response
+    end
+
+    #####################################################
+    # Helpers
+    #####################################################
+    private
+    def self.rename_vm_files(from, to)
+      to_vm=Fission::VM.new(to)
+
+      files_to_rename(from, to).each do |filename|
+        text_to_replace = File.basename(filename, File.extname(filename))
+
+        if File.extname(filename) == '.vmdk'
+          if filename.match /\-s\d+\.vmdk/
+            text_to_replace = filename.partition(/\-s\d+.vmdk/).first
+          end
+        end
+
+        unless File.exists?(File.join(to_vm.path, filename.gsub(text_to_replace, to)))
+          FileUtils.mv File.join(to_vm.path, filename),
+            File.join(to_vm.path, filename.gsub(text_to_replace, to))
+        end
+      end
+    end
+
+    def self.files_to_rename(from, to)
+      files_which_match_source_vm = []
+      other_files = []
+
+      from_vm=Fission::VM.new(from)
+
+      Dir.entries(from_vm.path).each do |f|
+        unless f == '.' || f == '..'
+          f.include?(from) ? files_which_match_source_vm << f : other_files << f
+        end
+      end
+
+      files_which_match_source_vm + other_files
+    end
+
+    def self.vm_file_extensions
+      ['.nvram', '.vmdk', '.vmem', '.vmsd', '.vmss', '.vmx', '.vmxf']
+    end
+
+    # This is done after a clone has been done
+    # All files are already at the to location
+    # The content of the text files will be substituted with strings from => to
+    def self.update_config(from, to)
+      to_vm=Fission::VM.new(to)
+
+      ['.vmx', '.vmxf', '.vmdk'].each do |ext|
+        file = File.join to_vm.path, "#{to}#{ext}"
+
+        unless File.binary?(file)
+          text = (File.read file).gsub from, to
+          # Force binary mode to prevent windows from putting CR-LF end line style
+          # http://www.ruby-forum.com/topic/60697#58748
+          File.open(file, 'wb'){ |f| f.print text }
+        end
+
+      end
+
+      # Rewrite vmx file to avoid messages
+      new_vmx_file=File.open(File.join(to_vm.vmx_path),'r')
+
+      content=new_vmx_file.read
+
+      # Filter out other values
+      content=content.gsub(/^tools.remindInstall.*\n/, "")
+      content=content.gsub(/^uuid.action.*\n/,"").strip
+
+      # Remove generate mac addresses
+      content=content.gsub(/^ethernet.+generatedAddress.*\n/,"").strip
+
+      # Add the correct values
+      content=content+"\ntools.remindInstall = \"FALSE\"\n"
+      content=content+"uuid.action = \"create\"\n"
+
+      # Now rewrite the vmx file
+      # Force binary mode to prevent windows from putting CR-LF end line style
+      # http://www.ruby-forum.com/topic/60697#58748
+      File.open(new_vmx_file,'wb'){ |f| f.print content}
+
+    end
+
+    def vmrun_cmd
+      if File.exists?("/Library/Application Support/VMware Fusion/vmrun")
+        return("/Library/Application Support/VMware Fusion/vmrun").shellescape
+      end
+      if File.exists?("/Applications/VMware Fusion.app/Contents/Library/vmrun")
+        return("/Applications/VMware Fusion.app/Contents/Library/vmrun").shellescape
+      end
+    end
+
+  end
+end