fission 0.4.0 → 0.5.0.beta.1

data/lib/fission/command_line_parser.rb

@@ -0,0 +1,189 @@
+module Fission
+
+  class CommandLineParser
+
+    # Internal: Creates a new Fission::CommandLineParser object.
+    #
+    # args - The command line arguments to parse.  This is expected to be in the
+    # same format of ARGV (Array) (default: ARGV).
+    #
+    # Examples:
+    #
+    #   CommandLineParser.new ['foo', 'bar']
+    #
+    #   CommandLineParser.new
+    #
+    # Returns a Fission::CommandLineParser object.
+    def initialize(args=ARGV)
+      @args = args
+
+      gather_commands_and_summaries
+
+      setup_options_parser
+    end
+
+    # Internal: Parses the command line arguments.  If the arguments are
+    # invalid, the appropriate help will be output and then will exit.  If the
+    # arguments are valid, then the @command variable will be set to a new
+    # instance of the determined command class.
+    #
+    # Examples:
+    #
+    #   @command_line_parser.parse
+    #
+    # Returns nothing.
+    def parse
+      @options_parser.order! @args
+
+      determine_command_provided
+      self
+    rescue OptionParser::InvalidOption => e
+      ui.output e
+      show_all_help
+      exit 1
+    end
+
+    # Internal: Accessor for an instance of the determined command. This is set
+    # by running the parse method.
+    #
+    # Examples:
+    #
+    #   @command_line_parser.command
+    #
+    # Returns an instance of the determined command if the arguments are valid.
+    # Returns nil if the parse command has not yet been run.
+    def command
+      @command
+    end
+
+    private
+    # Internal: Sets up the base option parser.
+    #
+    # Examples:
+    #
+    #   @cli.setup_option_parser
+    #
+    # Returns nothing.  This will set the @option_parser instance variable.
+    def setup_options_parser
+      @options_parser = OptionParser.new do |opts|
+        opts.banner = "\nUsage: fission [options] COMMAND [arguments]"
+
+        opts.on_head('-v', '--version', 'Output the version of fission') do
+          ui.output VERSION
+          exit 0
+        end
+
+        opts.on_head('-h', '--help', 'Displays this message') do
+          show_all_help
+          exit 0
+        end
+      end
+    end
+
+    # Internal: Provides the help of all of the known commands.
+    #
+    # Examples
+    #
+    #   @cli.commands_help
+    #
+    # Outputs the summary text for all known commands.
+    def commands_help
+      longest_cmd = @commands.inject do |longest, cmd_name|
+        longest.length > cmd_name.length ? longest : cmd_name
+      end
+
+      ui.output "\nCommands:"
+
+      Hash[@command_names_and_summaries.sort].each_pair do |name, summary|
+        ui.output_printf "%-#{longest_cmd.length}s      %s\n", name, summary
+      end
+    end
+
+    # Internal: Determines all of the available commands and their summaries.
+    #
+    # Examples
+    #
+    #   @cli.command_names_and_summaries
+    #   # => { 'clone' => 'Clones a VM', 'stop' => 'Stops a VM' }
+    #
+    # Returns nothing.  This will set the @command_names_and_summaries instance
+    # variable with the result.
+    def gather_commands_and_summaries
+      @command_names_and_summaries = Command.descendants.inject({}) do |result, klass|
+        cmd = klass.new
+        result[cmd.command_name] = cmd.summary
+        result
+      end
+
+      @commands = @command_names_and_summaries.keys.sort
+    end
+
+    # Internal: Determines the command that has been provided.  If it is
+    # determined that an invalid command is provided, then the help/usage will
+    # be displayed and it will exit.
+    #
+    # Examples:
+    #
+    #   @cli.determine_command_to_execute
+    #
+    # Returns nothing.  This will set the @command instance variable to an instance
+    # of the appropriate command class (assuming it is valid).
+    def determine_command_provided
+      if @commands.include? @args.first
+        @command = Command.const_get(@args.first.capitalize).new @args.drop 1
+      elsif is_snapshot_command?
+        klass = @args.take(2).map {|c| c.capitalize}.join('')
+        @command = Command.const_get(klass).new @args.drop 2
+      else
+        show_all_help
+        exit 1
+      end
+    end
+
+    # Internal: Determines if the provided command is a snapshot related
+    # command.  This will use the @args instance variable to make the
+    # determination.
+    #
+    # Examples
+    #
+    #   @cli.is_snapshot_command? ['foo', 'bar']
+    #   # => false
+    #
+    #   @cli.is_snapshot_command? ['snapshot', 'list']
+    #   # => true
+    #
+    # Returns a Boolean of whether a snapshot command was given or not.
+    def is_snapshot_command?
+      @args.first == 'snapshot' &&
+      @args.count > 1 &&
+      @commands.include?(@args.take(2).join(' '))
+    end
+
+    # Internal: Outputs the usage as well as the known commands and their
+    # summaries.
+    #
+    # Examples
+    #
+    #   @cli.show_all_help
+    #   # => 'fission options command arguments ....'
+    #
+    # Returns nothing.
+    def show_all_help
+      ui.output @options_parser
+      commands_help
+    end
+
+    # Internal: Helper method for outputting text to the ui
+    #
+    # Examples
+    #
+    #   @cli.ui.output 'foo'
+    #
+    # Returns a UI instance.
+    def ui
+      @ui ||= UI.new
+    end
+
+  end
+
+end

data/lib/fission/config.rb

@@ -27,7 +27,7 @@ module Fission
 
       load_from_file
 
-      @attributes['vmrun_cmd'] = "#{@attributes['vmrun_bin'].gsub(' ', '\ ')} -T fusion"
+      @attributes['vmrun_cmd'] = "'#{@attributes['vmrun_bin']}' -T fusion"
     end
 
     # Public: Helper method to access config atributes.  This is a shortcut for

data/lib/fission/fusion.rb

@@ -11,10 +11,9 @@ module Fission
     # Returns a Boolean.
     def self.running?
       command = "ps -ef | grep -v grep | grep -c "
-      command << "#{Fission.config['gui_bin'].gsub(' ', '\ ')} 2>&1"
-      output = `#{command}`
-
-      output.strip.to_i > 0
+      command << "'#{Fission.config['gui_bin']}' 2>&1"
+      command_executor = Fission::Action::ShellExecutor.new command
+      command_executor.execute['output'].strip.to_i > 0
     end
 
   end

data/lib/fission/lease.rb

@@ -97,7 +97,8 @@ module Fission
 
       if all_response.successful?
         response = Response.new :code => 0
-        response.data = all_response.data.find { |l| l.mac_address == mac_address }
+        leases = all_response.data.find_all { |l| l.mac_address == mac_address }
+        response.data = leases.sort_by { |l| l.end }.last
       else
         response = all_response
       end

data/lib/fission/metadata.rb

@@ -85,7 +85,12 @@ module Fission
     #
     # Returns nothing.
     def delete_vm_favorite_entry(vm_path)
-      @content['VMFavoritesListDefaults2'].delete_if { |vm| vm['path'] == vm_path }
+      if @content.has_key?('VMFavoritesListDefaults2')
+        @content['VMFavoritesListDefaults2'].delete_if { |vm| vm['path'] == vm_path }
+      end
+      if @content.has_key?('fusionInitialSessions')
+        @content['fusionInitialSessions'].delete_if {|vm| vm['documentPath'] == vm_path}
+      end
     end
 
   end

data/lib/fission/response.rb

@@ -57,18 +57,26 @@ module Fission
       @code == 0
     end
 
-    # Public: Helper method to create a new Response object when running a
-    # command line tool.
+    # Internal: Helper method to create a new Response object when using
+    # executing a command through Fission::Action::ShellExecutor.
     #
-    # cmd_output - This should be the output of the command.
+    # shell_execute_result - This should be the result of running 'execute' on
+    #                        a ShellExecutor object.
+    #
+    # Examples:
+    #
+    #   Response.from_shell_executor shell_execute_result
     #
     # Returns a Response.
-    # The Response's code attribute will be set to the value of '$?'.  The
-    # Response's message attribute will be set to the provided command output
-    # if, and only if, the Response is unsuccessful.
-    def self.from_command(cmd_output)
-      response = new :code => $?.exitstatus
-      response.message = cmd_output unless response.successful?
+    # The code attribute of the Response will be set to the exit_status
+    # attribute of the provided process_status data. The message attribute of
+    # the Response will be set to the output of the provided data if, and only
+    # if, the Response is unsuccessful.
+    def self.from_shell_executor(shell_execute_result)
+      response = new :code => shell_execute_result['process_status'].exitstatus
+      unless response.successful?
+        response.message = shell_execute_result['output']
+      end
       response
     end
 

data/lib/fission/version.rb

@@ -1,3 +1,3 @@
 module Fission
-  VERSION = "0.4.0"
+  VERSION = "0.5.0.beta.1"
 end

data/lib/fission/vm.rb

@@ -21,33 +21,23 @@ module Fission
     # If successful, the Response's data attribute will be nil.
     # If there is an error, an unsuccessful Response will be returned.
     def create_snapshot(name)
-      unless exists?
-        return Response.new :code => 1, :message => 'VM does not exist'
-      end
-
-      running_response = running?
-      return running_response unless running_response.successful?
-
-      unless running_response.data
-        message = 'The VM must be running in order to take a snapshot.'
-        return Response.new :code => 1, :message => message
-      end
-
-      conf_file_response = conf_file
-      return conf_file_response unless conf_file_response.successful?
-
-      snapshots_response = snapshots
-      return snapshots_response unless snapshots_response.successful?
-
-      if snapshots_response.data.include? name
-        message = "There is already a snapshot named '#{name}'."
-        return Response.new :code => 1, :message => message
-      end
-
-      command = "#{vmrun_cmd} snapshot "
-      command << "#{conf_file_response.data} \"#{name}\" 2>&1"
+      Fission::Action::Snapshot::Creator.new(self).create_snapshot(name)
+    end
 
-      Response.from_command(`#{command}`)
+    # Public: Deletes a snapshot for a VM.  The snapshot to delete must exist.
+    # If the Fusion GUI is running, then the VM must also be running.
+    #
+    # name - The name of the snapshot to delete.
+    #
+    # Examples
+    #
+    #   @vm.delete_snapshot('foo_snap_1')
+    #
+    # Returns a Response with the result.
+    # If successful, the Response's data attribute will be nil.
+    # If there is an error, an unsuccessful Response will be returned.
+    def delete_snapshot(name)
+      Fission::Action::Snapshot::Deleter.new(self).delete_snapshot(name)
     end
 
     # Public: Reverts the VM to the specified snapshot.  The snapshot to revert
@@ -63,32 +53,7 @@ module Fission
     # If successful, the Response's data attribute will be nil.
     # If there is an error, an unsuccessful Response will be returned.
     def revert_to_snapshot(name)
-      unless exists?
-        return Response.new :code => 1, :message => 'VM does not exist'
-      end
-
-      if Fusion.running?
-        message = 'It looks like the Fusion GUI is currently running.  '
-        message << 'A VM cannot be reverted to a snapshot when the Fusion GUI is running.  '
-        message << 'Exit the Fusion GUI and try again.'
-        return Response.new :code => 1, :message => message
-      end
-
-      conf_file_response = conf_file
-      return conf_file_response unless conf_file_response.successful?
-
-      snapshots_response = snapshots
-      return snapshots_response unless snapshots_response.successful?
-
-      unless snapshots_response.data.include? name
-        message = "Unable to find a snapshot named '#{name}'."
-        return Response.new :code => 1, :message => message
-      end
-
-      command = "#{vmrun_cmd} revertToSnapshot "
-      command << "#{conf_file_response.data} \"#{name}\" 2>&1"
-
-      Response.from_command(`#{command}`)
+      Fission::Action::Snapshot::Reverter.new(self).revert_to_snapshot(name)
     end
 
     # Public: List the snapshots for a VM.
@@ -103,27 +68,28 @@ module Fission
     # snapshot names (String).
     # If there is an error, an unsuccessful Response will be returned.
     def snapshots
-      unless exists?
-        return Response.new :code => 1, :message => 'VM does not exist'
-      end
-
-      conf_file_response = conf_file
-      return conf_file_response unless conf_file_response.successful?
-
-      command = "#{vmrun_cmd} listSnapshots "
-      command << "#{conf_file_response.data} 2>&1"
-      output = `#{command}`
-
-      response = Response.new :code => $?.exitstatus
-
-      if response.successful?
-        snaps = output.split("\n").select { |s| !s.include? 'Total snapshots:' }
-        response.data = snaps.map { |s| s.strip }
-      else
-        response.message = output
-      end
+      Fission::Action::Snapshot::Lister.new(self).snapshots
+    end
 
-      response
+    # Public: Deletes a VM.  The VM must not be running in order to delete it.
+    # As there are a number issues with the Fusion command line tool for
+    # deleting VMs, this is a best effort.  The VM must not be running when this
+    # method is called.  This essentially deletes the VM directory and attempts
+    # to remove the relevant entries from the Fusion plist file.  It's highly
+    # recommended to delete VMs without the Fusion GUI running.  If the Fusion
+    # GUI is running this method should succeed, but it's been observed that
+    # Fusion will recreate the plist data which is deleted.  This leads to
+    # 'missing' VMs in the Fusion GUI.
+    #
+    # Examples
+    #
+    #   @vm.delete
+    #
+    # Returns a Response with the result.
+    # If successful, the Response's data attribute will be nil.
+    # If there is an error, an unsuccessful Response will be returned.
+    def delete
+      Fission::Action::VM::Deleter.new(self).delete
     end
 
     # Public: Starts a VM.  The VM must not be running in order to start it.
@@ -144,36 +110,7 @@ module Fission
     # If successful, the Response's data attribute will be nil.
     # If there is an error, an unsuccessful Response will be returned.
     def start(options={})
-      unless exists?
-        return Response.new :code => 1, :message => 'VM does not exist'
-      end
-
-      running_response = running?
-      return running_response unless running_response.successful?
-
-      if running_response.data
-        return Response.new :code => 1, :message => 'VM is already running'
-      end
-
-      conf_file_response = conf_file
-      return conf_file_response unless conf_file_response.successful?
-
-      unless options[:headless].blank?
-        if Fusion.running?
-          message = 'It looks like the Fusion GUI is currently running.  '
-          message << 'A VM cannot be started in headless mode when the Fusion GUI is running.  '
-          message << 'Exit the Fusion GUI and try again.'
-          return Response.new :code => 1, :message => message
-        end
-      end
-
-      command = "#{vmrun_cmd} start "
-      command << "#{conf_file_response.data} "
-
-      command << (options[:headless].blank? ? 'gui ' : 'nogui ')
-      command << '2>&1'
-
-      Response.from_command(`#{command}`)
+      Fission::Action::VM::Starter.new(self).start(options)
     end
 
     # Public: Stops a VM.  The VM must be running in order to stop it.
@@ -195,26 +132,7 @@ module Fission
     # If successful, the Response's data attribute will be nil.
     # If there is an error, an unsuccessful Response will be returned.
     def stop(options={})
-      unless exists?
-        return Response.new :code => 1, :message => 'VM does not exist'
-      end
-
-      running_response = running?
-      return running_response unless running_response.successful?
-
-      unless running_response.data
-        return Response.new :code => 1, :message => 'VM is not running'
-      end
-
-      conf_file_response = conf_file
-      return conf_file_response unless conf_file_response.successful?
-
-      command = "#{vmrun_cmd} stop "
-      command << "#{conf_file_response.data} "
-      command << 'hard ' unless options[:hard].blank?
-      command << '2>&1'
-
-      Response.from_command(`#{command}`)
+      Fission::Action::VM::Stopper.new(self).stop(options)
     end
 
     # Public: Suspends a VM.  The VM must be running in order to suspend it.
@@ -227,24 +145,35 @@ module Fission
     # If successful, the Response's data attribute will be nil.
     # If there is an error, an unsuccessful Response will be returned.
     def suspend
-      unless exists?
-        return Response.new :code => 1, :message => 'VM does not exist'
-      end
+      Fission::Action::VM::Suspender.new(self).suspend
+    end
 
-      running_response = running?
-      return running_response unless running_response.successful?
+    # Public: Provides virtual hardware info the VM
+    #
+    # Examples:
+    #
+    #   @vm.hardware_info.data
+    #   # => {'cpus' => 2, 'memory' => 1024}
+    #
+    # Returns a Response with the result.
+    # If successful, the Response's data attribute will be a Hash with the
+    # info found.
+    # If there is an error, an unsuccessful Response will be returned.
+    def hardware_info
+      config_response = conf_file_data
+      return config_response unless config_response.successful?
 
-      unless running_response.data
-        return Response.new :code => 1, :message => 'VM is not running'
-      end
+      response = Response.new :code => 0, :data => {}
 
-      conf_file_response = conf_file
-      return conf_file_response unless conf_file_response.successful?
+      response.data['cpus'] = 1
 
-      command = "#{vmrun_cmd} suspend "
-      command << "#{conf_file_response.data} 2>&1"
+      { 'cpus' => 'numvcpus', 'memory' => 'memsize' }.each_pair do |k,v|
+        unless config_response.data[v].blank?
+          response.data[k] = config_response.data[v].to_i
+        end
+      end
 
-      Response.from_command(`#{command}`)
+      response
     end
 
     # Public: Provides the MAC addresses for a VM.
@@ -297,30 +226,76 @@ module Fission
     # attribute will be an empty Hash.
     # If there is an error, an unsuccessful Response will be returned.
     def network_info
-      conf_file_response = conf_file
-      return conf_file_response unless conf_file_response.successful?
+      config_response = conf_file_data
+      return config_response unless config_response.successful?
 
       response = Response.new :code => 0, :data => {}
 
       interface_pattern = /^ethernet\d+/
       mac_pattern = /(\w\w[:-]\w\w[:-]\w\w[:-]\w\w[:-]\w\w[:-]\w\w)/
 
-      File.open conf_file_response.data, 'r' do |f|
-        f.grep(mac_pattern).each do |line|
-          int = line.scan(interface_pattern)[0]
-          mac = line.scan(mac_pattern)[0].first
-          response.data[int] = {}
-          response.data[int]['mac_address'] = mac
-
+      config_response.data.each_pair do |k,v|
+        if v =~ mac_pattern
+          mac = v
+          int = k.scan(interface_pattern).first
+          response.data[int] = { 'mac_address' => mac }
           lease_response = Fission::Lease.find_by_mac_address mac
           return lease_response unless lease_response.successful?
 
           response.data[int]['ip_address'] = nil
-
           if lease_response.data
             response.data[int]['ip_address'] = lease_response.data.ip_address
           end
+        end
+      end
+
+      response
+    end
+
+    # Public: Provides the Fussion GuestOS profile.
+    #
+    # Examples
+    #
+    #   @vm.guestos.data
+    #   # => 'debian5'
+    #
+    # Returns a Response with the result.
+    # If the Response is successful, the Response's data attribute will
+    # be populated with a string that is the guest operatingsystem used for the
+    # virtual machine.
+    # If there is an error, an unsuccessful Response will be returned.
+    def guestos
+      config_response = conf_file_data
+      return config_response unless config_response.successful?
 
+      response = Response.new :code => 0, :data => {}
+      response.data = config_response.data.fetch 'guestOS', ''
+      response
+    end
+
+    # Public: Provides various uuids associated with a VM.
+    #
+    # Examples
+    #
+    #   @vm.uuids.data
+    #   # => {"bios"=>"56 4d ee 72 3b 7e 47 67-69 aa 65 cb 5e 40 3f 21",
+    #         "location"=>"56 4d 2e 15 f4 ed 00 a7-c5 99 43 32 b8 76 ef d5"}
+    #
+    # Returns a Response with the result.
+    # If the Response is successful, the Response's data attribute will
+    # be populated with a hash that is comprised of the various uuids that are
+    # associated with each VM.  If the VM is newly created they will be the same
+    # but if you selected 'I Moved It' from the Fusion GUI they will differ.
+    # If there is an error, an unsuccessful Response will be returned.
+    def uuids
+      config_response = conf_file_data
+      return config_response unless config_response.successful?
+
+      response = Response.new :code => 0, :data => {}
+
+      { 'bios' => 'uuid.bios', 'location' => 'uuid.location' }.each_pair do |k,v|
+        unless config_response.data[v].blank?
+          response.data[k] = config_response.data[v]
         end
       end
 
@@ -439,6 +414,22 @@ module Fission
       response
     end
 
+    # Public: Provides the configuration data stored in the VM's configuration
+    # file ('.vmx').
+    #
+    # Examples
+    #
+    #   @vm.conf_file_data
+    #
+    # Returns a Response with the result.
+    # If successful, the Response's data attribute with be a Hash of the
+    # configuration data.  All of the keys/values in the configuration data will
+    # be a String.
+    # If there is an error, an unsuccessful Response will be returned.
+    def conf_file_data
+      VMConfiguration.new(self).config_data
+    end
+
     # Public: Determines the path to the VM's config file ('.vmx').
     #
     # Examples
@@ -485,8 +476,6 @@ module Fission
         end
       end
 
-      response.data.gsub! ' ', '\ ' if response.successful?
-
       response
     end
 
@@ -519,14 +508,7 @@ module Fission
     # empty Array.
     # If there is an error, an unsuccessful Response will be returned.
     def self.all
-      vm_dirs = Dir[File.join Fission.config['vm_dir'], '*.vmwarevm'].select do |d|
-        File.directory? d
-      end
-
-      response = Response.new :code => 0
-      response.data = vm_dirs.collect { |d| new(File.basename d, '.vmwarevm') }
-
-      response
+      Fission::Action::VM::Lister.new.all
     end
 
     # Public: Provides all of the VMs which are currently running.
@@ -543,25 +525,7 @@ module Fission
     # attribute will be an empty Array.
     # If there is an error, an unsuccessful Response will be returned.
     def self.all_running
-      command = "#{Fission.config['vmrun_cmd']} list"
-
-      output = `#{command}`
-
-      response = 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
-
-        response.data = vms.collect do |vm|
-          new File.basename(File.dirname(vm), '.vmwarevm')
-        end
-      else
-        response.message = output
-      end
-
-      response
+      Fission::Action::VM::Lister.new.all_running
     end
 
     # Public: Provides a list of all of the VMs and their associated status
@@ -576,34 +540,7 @@ module Fission
     # names as keys and their status as the values.
     # If there is an error, an unsuccessful Repsonse will be returned.
     def self.all_with_status
-      all_response = all
-      return all_response unless all_response.successful?
-
-      all_vms = all_response.data
-
-      running_response = all_running
-      return running_response unless running_response.successful?
-
-      response = Response.new :code => 0
-
-      all_running_vm_names = running_response.data.collect { |v| v.name }
-
-      response.data = all_vms.inject({}) do |result, vm|
-        if all_running_vm_names.include? vm.name
-          status = 'running'
-        else
-          if vm.suspend_file_exists?
-            status = 'suspended'
-          else
-            status = 'not running'
-          end
-        end
-
-        result[vm.name] = status
-        result
-      end
-
-      response
+      Fission::Action::VM::Lister.new.all_with_status
     end
 
     # Public: Creates a new VM which is a clone of an existing VM.  As Fusion
@@ -622,189 +559,12 @@ module Fission
     # If successful, the Response's data attribute will be nil.
     # If there is an error, an unsuccessful Response will be returned.
     def self.clone(source_vm_name, target_vm_name)
-      source_vm = new source_vm_name
-      target_vm = new target_vm_name
-
-      unless source_vm.exists?
-        return Response.new :code => 1, :message => 'VM does not exist'
-      end
-
-      if target_vm.exists?
-        return Response.new :code => 1, :message => 'VM already exists'
-      end
-
-      FileUtils.cp_r source_vm.path, target_vm.path
-
-      rename_vm_files source_vm.name, target_vm.name
-      update_config source_vm.name, target_vm.name
-
-      Response.new :code => 0
-    end
-
-    # Public: Deletes a VM.  The VM must not be running in order to delete it.
-    # As there are a number issues with the Fusion command line tool for
-    # deleting VMs, this is a best effort.  The VM must not be running when this
-    # method is called.  This essentially deletes the VM directory and attempts
-    # to remove the relevant entries from the Fusion plist file.  It's highly
-    # recommended to delete VMs without the Fusion GUI running.  If the Fusion
-    # GUI is running this method should succeed, but it's been observed that
-    # Fusion will recreate the plist data which is deleted.  This leads to
-    # 'missing' VMs in the Fusion GUI.
-    #
-    # Examples
-    #
-    #   @vm.delete
-    #
-    # Returns a Response with the result.
-    # If successful, the Response's data attribute will be nil.
-    # If there is an error, an unsuccessful Response will be returned.
-    def delete
-      unless exists?
-        return Response.new :code => 1, :message => 'VM does not exist'
-      end
-
-      running_response = running?
-      return running_response unless running_response.successful?
-
-      if running_response.data
-        message = 'The VM must not be running in order to delete it.'
-        return Response.new :code => 1, :message => message
-      end
-
-      FileUtils.rm_rf path
-      Metadata.delete_vm_info path
-
-      Response.new :code => 0
+      @source_vm = new source_vm_name
+      @target_vm = new target_vm_name
+      Fission::Action::VM::Cloner.new(@source_vm, @target_vm).clone
     end
 
     private
-    # Internal: Renames the files of a newly cloned VM.
-    #
-    # from - The VM name that was used as the source of the clone.
-    # to   - The name of the newly cloned VM.
-    #
-    # Examples
-    #
-    #   Fission::VM.rename_vm_files 'foo', 'bar'
-    #
-    # Returns nothing.
-    def self.rename_vm_files(from, to)
-      to_vm = new to
-
-      files_to_rename(from, to).each do |file|
-        text_to_replace = File.basename(file, File.extname(file))
-
-        if File.extname(file) == '.vmdk'
-          if file.match /\-s\d+\.vmdk/
-            text_to_replace = file.partition(/\-s\d+.vmdk/).first
-          end
-        end
-
-        unless File.exists?(File.join(to_vm.path, file.gsub(text_to_replace, to)))
-          FileUtils.mv File.join(to_vm.path, file),
-                       File.join(to_vm.path, file.gsub(text_to_replace, to))
-        end
-      end
-    end
-
-    # Internal: Provides the list of files which need to be renamed in a newly
-    # cloned VM directory.
-    #
-    # from - The VM name that was used as the source of the clone.
-    # to   - The name of the newly cloned VM.
-    #
-    # Examples
-    #
-    #   Fission::VM.files_to_rename 'foo', 'bar'
-    #   # => ['/vms/vm1/foo.vmdk', '/vms/vm1/foo.vmx', 'vms/vm1/blah.other']
-    #
-    # Returns an Array containing the paths (String) to the files to rename.
-    # The paths which match the from name will preceed any other files found in
-    # the newly cloned VM directory.
-    def self.files_to_rename(from, to)
-      to_vm = new to
-
-      files_which_match_source_vm = []
-      other_files = []
-
-      Dir.entries(to_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
-
-    # Internal: Provides the list of file extensions for VM related files.
-    #
-    # Examples
-    #
-    #   Fission::VM.vm_file_extension
-    #   # => ['.nvram', '.vmdk', '.vmem']
-    #
-    # Returns an Array containing the file extensions of VM realted files.
-    # The file extensions returned are Strings and include a '.'.
-    def self.vm_file_extensions
-      ['.nvram', '.vmdk', '.vmem', '.vmsd', '.vmss', '.vmx', '.vmxf']
-    end
-
-    # Internal: Updates config files for a newly cloned VM.  This will update any
-    # files with the extension of '.vmx', '.vmxf', and '.vmdk'.  Any binary
-    # '.vmdk' files will be skipped.
-    #
-    # from - The VM name that was used as the source of the clone.
-    # to   - The name of the newly cloned VM.
-    #
-    # Examples
-    #
-    #   Fission::VM.update_config 'foo', 'bar'
-    #
-    # Returns nothing.
-    def self.update_config(from, to)
-      to_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
-          File.open(file, 'w'){ |f| f.print text }
-        end
-
-        clean_up_conf_file(file) if ext == '.vmx'
-      end
-    end
-
-    # Internal: Cleans up the conf file (*.vmx) for a newly cloned VM.  This
-    # includes removing generated MAC addresses, setting up for a new UUID, and
-    # disable VMware tools warning.
-    #
-    # conf_file_path - Aboslute path to the VM's conf file (.vmx).
-    #
-    # Examples
-    #
-    #   VM.clean_up_conf_file '/vms/foo/foo.vmx'
-    #
-    # Returns nothing.
-    def self.clean_up_conf_file(conf_file_path)
-      conf_items_patterns = [ /^tools\.remindInstall.*\n/,
-                              /^uuid\.action.*\n/,
-                              /^ethernet\.+generatedAddress.*\n/ ]
-
-      content = File.read conf_file_path
-
-      conf_items_patterns.each do |pattern|
-        content.gsub(pattern, '').strip
-      end
-
-      content << "\n"
-      content << "tools.remindInstall = \"FALSE\"\n"
-      content << "uuid.action = \"create\"\n"
-
-      File.open(conf_file_path, 'w') { |f| f.print content }
-    end
-
     # Internal: Helper for getting the configured vmrun_cmd value.
     #
     # Examples