virtualman 1.1.9 → 2.0.0

data/bin/virtualman

@@ -2,7 +2,8 @@
 
 ####Required
 require 'virtualman'
-include Interractive
+
+repl = Virtualman::Interactive::REPL.new
 
 menu = ["clone","cook","ssh","add","delete","bootify","exit"]
 
@@ -11,8 +12,11 @@ choice = "0"
 while choice != "exit"
 	puts "----VirtualMan----"
 	puts "Please select an action to do with your VM."
-	choice = Menu.unic_run(menu)
-	Interractive.send(choice)
+	choice = Virtualman::Interactive::Menu.unic_run(menu)
+
+	if choice != "exit"
+		repl.send(choice)
+	end
 end
 
 puts "Thank you come again!"

data/lib/virtualman.rb

@@ -1,5 +1,8 @@
-require 'virtualman/menu'
-require 'virtualman/vm'
-require 'virtualman/vmlister'
-require 'virtualman/configuration'
-require 'virtualman/interractive'
+module Virtualman
+	require 'virtualman/interactive/helper'
+	require 'virtualman/interactive/menu'
+	require 'virtualman/vm'
+	require 'virtualman/vmlister'
+	require 'virtualman/interactive/configuration'
+	require 'virtualman/interactive/REPL'
+end

data/lib/virtualman/interactive/REPL.rb

@@ -0,0 +1,124 @@
+module Virtualman
+	module Interactive
+		class REPL
+			attr_reader :configuration
+
+			include Virtualman::Interactive::Helper
+
+	    def initialize
+	      @configuration = Virtualman::Interactive::Configuration.new
+	    end
+
+			def clone
+				cloned_vm = self.clone_vm
+				self.start_vm(cloned_vm)
+				self.configuration.add_cloned_vm(cloned_vm)
+			end
+
+			def cook
+				puts "----Cook a clone!----"
+				puts "Which VM do you want to cook?"
+				role_path = self.configuration.options["role_path"]
+				cookbook_path = self.configuration.options["cookbook_path"]
+
+				selected_vm = self.choose_vm "cloned_vms"
+
+				puts "Which role do you want to give?"
+
+				role = self.choose "roles"
+
+				user="root"
+
+				if self.start_vm(selected_vm)
+					cmd = "ssh #{user}@#{selected_vm.ip} '/usr/local/bin/chef-solo -j #{role_path}#{role["name"]}.json -r #{cookbook_path}'"
+					puts cmd
+					Kernel.system(cmd)
+				end
+
+				puts "Thanks!"
+			end
+
+			def ssh
+				puts "----SSH to cloned VM----"
+				puts "Which VM do you want to ssh?"
+
+				selected_vm = self.choose_vm "cloned_vms"
+
+				puts "With which user? [root]"
+				user = Menu.ask
+
+				if user.empty?
+					user = "root"
+				end
+
+				if self.start_vm(selected_vm)
+					cmd = "ssh #{user}@#{selected_vm.ip}"
+					Kernel.exec(cmd)
+				end	
+			end
+
+			def delete
+				puts "----Delete a cloned VM----"
+				puts "Which VM delete?"
+
+				selected_vm = self.choose_vm "cloned_vms"
+
+				puts "!!YOU ARE ABOUT TO DELETE PEMANENTLY DELETE #{selected_vm.name}!!"
+				puts "Are you sure? (yes/[no])"
+
+				choice = Menu.ask
+
+				if choice == "yes"
+					selected_vm.stop!
+
+					selected_vm.manage("unregistervm","--delete")
+
+					self.configuration.delete_cloned_vm(selected_vm)
+				else
+					puts "VM not deleted!"
+				end
+			end
+
+			def add
+				puts "----Add a VM----"
+				puts "Give the path of the OVA file you want to add"
+				puts "(An OVA file represents a Virtual Machine)"
+
+				path = Menu.ask
+
+				cmd = "VBoxManage import #{path}"
+				puts cmd
+				`#{cmd}`
+
+				if $?.exitstatus == 0
+					added_vm = Vm.new(File.basename("#{path}",".*"))
+					self.configuration.add_cloned_vm(added_vm)
+				else
+					puts "There was an error during the import"
+				end
+			end
+
+			def bootify
+				puts "----Start a VM at boot----"
+				puts "Initializing bootify...."
+				self.init_bootify
+				puts "Whcih VM do you want to add to your boot sequence?"
+
+				selected_vm = self.choose_vm "cloned_vms"
+
+				puts "We need to shutdown the VM to add to the boot list."
+				puts "Do you want to procedd now? (yes/[no])"
+
+				choice = Menu.ask
+
+				if choice == "yes"
+					selected_vm.stop!
+					selected_vm.manage("modifyvm", "--autostart-enabled on", "--autostart-delay 10")
+					puts "#{selected_vm.name} added to your boot sequence."
+					start_vm selected_vm
+				end
+			end
+
+		end
+	end
+end

data/lib/virtualman/interactive/configuration.rb

@@ -0,0 +1,55 @@
+require 'yaml'
+
+module Virtualman
+	module Interactive
+		class Configuration
+
+			attr_reader :options, :filepath
+
+			def initialize
+				@filepath = File.join(ENV['HOME'],'.virtualman.rc.yaml')
+
+				if File.exists? @filepath
+				  @options = YAML.load_file(@filepath)
+				else
+					STDERR.puts("No configuration file found here ~/.vm_to_clone.rc.yaml")
+					STDERR.puts("Thanks to create this file before continuing!")
+					STDERR.puts "Config file example:"
+					STDERR.puts "---"
+					STDERR.puts "source_vm:"
+					STDERR.puts " - name: 			Debian"
+					STDERR.puts "   snapshot: 	ready to clone!"
+					STDERR.puts " - name: 			Gentoo"
+					STDERR.puts "   snapshot: 	almost ready"
+					STDERR.puts "role_path: http://path/to/your/role/fodler"
+					STDERR.puts "cookbook_path: http://path/to/your/cookbooks.tar.gz"
+					STDERR.puts "roles:"
+					STDERR.puts "- devtest"
+					STDERR.puts "- devtest_jenkins"
+					STDERR.puts "- build_pkg_devtest_jenkins"
+					Kernel.abort("No configuration file found here ~/.vm_to_clone.rc.yaml")
+				end
+			end
+
+			def record_conf(msg)
+				File.open(@filepath, "w") {|f| f.write(@options.to_yaml) }
+				puts "#{msg} to your configuration file"
+			end
+
+			def add_cloned_vm(vm_cloned)
+				if @options["cloned_vms"] != nil
+					@options["cloned_vms"] << {"name" => vm_cloned.name}
+				else
+					@options.merge!({"cloned_vms" => [{"name" => vm_cloned.name}]})
+				end
+				record_conf("VM #{vm_cloned.name} has been saved")			
+			end
+			
+			def delete_cloned_vm(vm_cloned)
+				@options["cloned_vms"].reject!{|vm| vm == {"name" => vm_cloned.name.gsub(/\"/,'')} }
+				record_conf("VM #{vm_cloned.name} has been deleted")
+			end
+
+		end
+	end
+end

data/lib/virtualman/interactive/helper.rb

@@ -0,0 +1,209 @@
+module Virtualman
+  module Interactive
+    module Helper
+      require 'fileutils'
+      require 'erb'
+
+      extend self
+
+      def choose source
+        
+        list = Array.new
+        self.configuration.options[source].each do |option|
+          list << option["name"]
+        end
+        list << "exit"
+
+        choice = Menu.unic_run(list)
+
+        exit 0 if choice == "exit"
+
+        self.configuration.options[source].each_with_index do |option,index|
+          if option["name"] == choice
+            return self.configuration.options[source][index]
+          end
+        end
+
+      end
+
+      #Source can be either source_vms or clonned_vms
+      def choose_vm source
+        vm_choice = choose source
+        return Vm.new("#{vm_choice["name"]}")
+         
+      end
+
+      def clone_vm
+        puts "----Clone_VM----"
+        puts "Which VM do you want to clone?"
+
+        vm_choice = choose "source_vms"
+        vm_to_clone = Vm.new("\"#{vm_choice["name"]}\"")
+
+        puts "How do you want to name your freshly spawned VM?"
+        vm_name = Menu.ask
+
+        options = "--snapshot \"#{vm_choice["snapshot"]}\" --name \"#{vm_name}\" --register"
+        vm_to_clone.manage("clonevm", options)
+        vm_cloned = Vm.new(vm_name)
+        return vm_cloned
+      end
+
+      def start_vm(vm)
+        if !vm.running?
+          puts "Do you want to start the VM? headless?"
+          puts "(default is no)"
+          puts "yes/headless/[no]"
+
+          answer = Menu.ask
+
+          if answer == "headless"
+            option = "--type headless"
+            puts "The VM is booting headless"
+          elsif answer == "yes"
+            option = ""
+            puts "The VM is booting"
+          else
+            puts "The vm will not be started"
+            return false
+          end
+
+          vm.manage("startvm", option)
+
+          Kernel.print "Waiting for the VM to get an IP"
+          while !vm.ip
+            Kernel.print "."
+            Kernel.sleep (1)
+          end
+          Kernel.print "\n"
+        end
+
+        return vm.running?
+      end
+
+      
+
+      def check_chmod_script
+        script = "/Applications/VirtualBox.app/Contents/MacOS/VBoxAutostartDarwin.sh"
+        permission = Kernel.sprintf("%o", File.world_readable?(script) )
+        if permission != "744"
+          puts "Changing file permission of #{script}, to allow it to be executable"
+          puts "Thanks to provide your admin password."
+          File.chmod(0744, script)
+        end
+      end
+
+      def integrate_template filename, path, template_string, *variables
+        template = ERB.new(template_string, 0, "%<>")
+
+        templated = template.result(binding)
+
+        File.open("/tmp/#{filename}", 'w') { |file| file.write(templated) }
+
+        if File.exist?(path+filename)
+          diff = `diff #{path}#{filename} /tmp/#{filename}`
+          result = $?
+          if result != 0
+            puts "We are trying to install the previous file but there are differences"
+            puts "here are the differences"
+            puts "#{diff}"
+            puts "Do you want to override the original?"
+            puts "yes/[no]"
+
+            answer = Menu.ask
+
+            if answer != "yes"
+              return false
+            end
+          else
+            return true
+          end
+        end
+
+        puts "Installing the file #{path}#{filename}..."
+        puts "Please povide your password :"
+
+        output = `sudo cp /tmp/#{filename} #{path}#{filename}`
+        result = $?
+        if result == 0
+          return true
+        else
+          Kernel.abort(output)
+        end
+      end
+
+      def check_plist_file
+        puts "Checking plist file..."
+        plist_file = "org.virtualbox.vboxautostart.plist"
+        plist_path = "/Library/LaunchDaemons/"
+
+        plist_template = %q{
+    <?xml version="1.0" encoding="UTF-8"?>
+    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+    <plist version="1.0">
+    <dict>
+      <key>Disabled</key>
+      <false/>
+      <key>KeepAlive</key>
+      <false/>
+      <key>Label</key>
+      <string>org.virtualbox.vboxautostart</string>
+      <key>ProgramArguments</key>
+      <array>
+        <string>/Applications/VirtualBox.app/Contents/MacOS/VBoxAutostartDarwin.sh</string>
+        <string>--start</string>
+        <string>/etc/vbox/autostart.cfg</string>
+      </array>
+      <key>RunAtLoad</key>
+      <true/>
+      <key>debug</key>
+      <true/>
+    </dict>
+    </plist>
+    }    
+
+        if self.integrate_template(plist_file, plist_path, plist_template)
+          puts "loading the plist file"
+          puts "Thanks to provide your admin password."
+          `sudo launchctl load #{plist_path}#{plist_file}`
+        end
+      end
+
+
+      def check_conf_file
+        puts "Checking conf file..."
+        conf_file = "autostart.cfg"
+        conf_path = "/etc/vbox/"
+
+        conf_template = %q{
+    # Default policy is to deny starting a VM, the other option is "allow".
+    default_policy = deny
+
+    # <%= variables[0] %> is allowed to start virtual machines but starting them
+    # will be delayed for 10 seconds
+    <%= variables[0] %> = {
+        allow = true
+        startup_delay = 10
+    }
+    }.gsub(/^  /, '')
+
+        username = `whoami`.strip
+
+        integrate_template(conf_file, conf_path, conf_template, username)
+      end
+
+      def init_bootify
+
+        #check plist file
+    		check_plist_file
+
+    		#Check chmod of the bash script
+        check_chmod_script
+
+    		#Check the conf file
+        check_conf_file
+
+    	end
+    end
+  end
+end

data/lib/virtualman/{menu.rb → interactive/menu.rb}

@@ -23,34 +23,41 @@
 
 #Forked from https://github.com/cldwalker/menu
 
-module Menu
-  extend self
+module Virtualman
+  module Interactive
+    module Menu
+      extend self
+
+      def ask
+        $stdin.reopen '/dev/tty'
+        $stdin.gets.chomp
+      end
+
+      def unic_prompt(lines)
+        ljust_size = lines.size.to_s.size + 1
+        lines.each_with_index {|obj,i|
+          puts "#{i+1}.".ljust(ljust_size) + " " +obj
+        }
+        print "\nSpecify your choice\nChoose: "
+      end
+
+      def unic_answer(array, input)
+        if input[/(\d+)/]
+          index = input.to_i - 1
+          if array[index]
+            return array[index] 
+          end
+        end
+        
+        Kernel.abort "#{input} is an invalid choice."
+      end
+
+      def unic_run(array)
+        unic_prompt(array)
+        answer = ask
+        return unic_answer(array, answer)
+      end
 
-  def ask
-    $stdin.reopen '/dev/tty'
-    $stdin.gets.chomp
-  end
-
-  def unic_run(array)
-    unic_prompt(array)
-    answer = ask
-    return unic_answer(array, answer)
-  end
-
-  def unic_answer(array, input)
-    if input[/(\d+)/]
-      index = $1.to_i - 1
-      return array[index] if array[index]
-    else
-      abort("`#{input}' is an invalid choice.")
     end
   end
-
-  def unic_prompt(lines)
-    ljust_size = lines.size.to_s.size + 1
-    lines.each_with_index {|obj,i|
-      puts "#{i+1}.".ljust(ljust_size) + " " +obj
-    }
-    print "\nSpecify your choice\nChoose: "
-  end
 end

data/lib/virtualman/vm.rb

@@ -1,62 +1,65 @@
-# Implement a way to interact with the VirtualBox command line tool.
-# Each #Vm is a Class that contains the #name of the VM. With that 
-# name you can then interact with it through VBoxManage for example
+module Virtualman
+  # Implement a way to interact with the VirtualBox command line tool.
+  # Each #Vm is a Class that contains the #name of the VM. With that 
+  # name you can then interact with it through VBoxManage for example
 
-class Vm
+  class Vm
 
-  # This attribute contains the name of the VM in VirtualBox.
-  attr_reader :name
+    # This attribute contains the name of the VM in VirtualBox.
+    attr_reader :name
 
-  # A #Vm is just described by it's name.
-  # *type is for further needs
-  def initialize(vm_name, *type)
-  	@name = vm_name
-  end
-
-  # Returns a boolean whether the VM is running or not
-  def running?
-  	!`VBoxManage showvminfo #{name} | grep State | grep running`.empty?
-  end
-
-  # A general method to interact with the VM.
-  # action is the kind of action to request to VBoxManage
-  # *param is a list of options
-  def manage(action, *param)
-    puts "VBoxManage #{action} #{@name} #{param.join(" ")}"
-    puts `VBoxManage #{action} #{@name} #{param.join(" ")}`
-  end
+    # A #Vm is just described by it's name.
+    # *type is for further needs
+    def initialize(vm_name, *type)
+    	@name = vm_name
+    end
 
-  # A method to stop properly a vm
-  # It assumes that you have the name of the VM on your personnal hosts file or DNS
-  # It can be modified to use GuestAdditions instead
-  def stop!
-    $stdout.sync = true
-    if self.running?
-      `ssh root@#{self.ip} "shutdown -h now"`
-      puts "Waiting for complete shutdown of #{self.name}"
-      while self.running?
-        print "."
-        sleep (1)
+    # A general method to interact with the VM.
+    # action is the kind of action to request to VBoxManage
+    # *param is a list of options
+    def manage(action, *param)
+      #puts "VBoxManage #{action} #{@name} #{param.join(" ")}"
+      output = `VBoxManage #{action} \"#{@name}\" #{param.join(" ")} 2>&1`
+      if $?.exitstatus != 0
+        Kernel.abort(output)
+      else
+        return output
       end
-      sleep (5)
     end
 
-  end
+    # Returns a boolean whether the VM is running or not
+    def running?
+      return !self.manage("showvminfo").split("\n").grep(/running/).empty?
+    end
 
-  # return the ip of the VM if it is running. O if it is not.
-  def ip
-    if self.running?
-      options = "enumerate #{self.name} | grep IP | cut -d , -f 2 | cut -d : -f 2"
-      cmd_ip = "VBoxManage guestproperty #{options}"
-      ip = `#{cmd_ip}`.strip
-      if ip.match /[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/
-        return ip
+    # return the ip of the VM if it is running. O if it is not or if the ip is not correct.
+    def ip
+      if self.running?
+        ip = self.manage("guestproperty enumerate").split("\n").grep(/IP/)[0].split(",")[1].sub(/^ value: /, '')
+        if ip.match /[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}/
+          return ip
+        else
+          return false
+        end
       else
+        puts "The VM is not running, cannot determine IP"
         return false
       end
-    else
-      puts "The VM is not running, cannot determine IP"
-      return false
+    end
+
+    # A method to stop properly a vm
+    # It assumes that you can access to the VM with root and ssh_keys
+    def stop!
+      if self.running?
+        `ssh root@#{self.ip} "shutdown -h now"`
+        print "Waiting for complete shutdown of #{self.name}"
+        while self.running?
+          print "."
+          sleep (1)
+        end
+        sleep (5)
+        print("\n")
+      end
     end
   end
 end

data/lib/virtualman/vmlister.rb

@@ -1,58 +1,60 @@
-# Create an array that contains all the #Vm from VirtualBox
-# And implement methods to play with it as a whole.
-class VmLister < Array
-
-  # Return an array with the list returned by the command "VBoxManage list vms"
-  # The argument *type will be used later (to specify a remote host for instance)
-  def perform_list(*type)
-    vm_list = `VBoxManage list vms`.split(/\n/).collect {|e| e[/".*"/]}
-    return vm_list
-  end
+module Virtualman
+  # Create an array that contains all the #Vm from VirtualBox
+  # And implement methods to play with it as a whole.
+  class VmLister < Array
+
+    # Return an array with the list returned by the command "VBoxManage list vms"
+    # The argument *type will be used later (to specify a remote host for instance)
+    def perform_list(*type)
+      vm_list = `VBoxManage list vms`.split(/\n/).collect {|e| e[/".*"/]}
+      return vm_list
+    end
 
-  # Populate the array with the method perform_list
-  # The argument *type will be used later (to specify a remote host for instance)
-  def populate!(*type)
-    self.perform_list.each {|vm| self << Vm.new(vm)}
-  end
+    # Populate the array with the method perform_list
+    # The argument *type will be used later (to specify a remote host for instance)
+    def populate!(*type)
+      self.perform_list.each {|vm| self << Vm.new(vm)}
+    end
 
-  # A simple lister
-  def list
-    self.each {|vm| puts "#{vm.name}"}
-  end
+    # A simple lister
+    def list
+      self.each {|vm| puts "#{vm.name}"}
+    end
 
-  # Get the IP of each running vm.
-  def ip
-    self.each {|vm| puts vm.ip}
-  end
+    # Get the IP of each running vm.
+    def ip
+      self.each {|vm| puts vm.ip}
+    end
 
-  # This methods returns a #VmLister object but just with the running VMs of the list.
-  def running?
-    running_vms = VmLister.new
-    self.collect {|vm| running_vms << vm if vm.running?}
-    return running_vms
-  end
+    # This methods returns a #VmLister object but just with the running VMs of the list.
+    def running?
+      running_vms = VmLister.new
+      self.collect {|vm| running_vms << vm if vm.running?}
+      return running_vms
+    end
 
-  # A general method to interact with the VBoxManage tool
-  # the block param could be useful for advanced links between your script and this class
-  def manage(action, *param, &block)
-    self.each do |vm|
-      block_param = block.call(vm.name) if block_given?
+    # A general method to interact with the VBoxManage tool
+    # the block param could be useful for advanced links between your script and this class
+    def manage(action, *param, &block)
+      self.each do |vm|
+        block_param = block.call(vm.name) if block_given?
 
-      vm.manage(action, param, block_param)
+        vm.manage(action, param, block_param)
+      end
     end
-  end
 
-  # A method to automatically export the list of VMs
-  def backup!(folder)
-    self.each {|vm| vm.stop!}
-    sleep (5)
+    # A method to automatically export the list of VMs
+    def backup!(folder)
+      self.each {|vm| vm.stop!}
+      sleep (5)
 
-    self.each do |vm|
-      filename = Time.now().strftime("#{vm.name.delete "\""}_%Y%m%dT%H%M")
-      vm.manage("export","-o #{folder}/#{filename}.ova")
-      sleep(5)
-    end
+      self.each do |vm|
+        filename = Time.now().strftime("#{vm.name.delete "\""}_%Y%m%dT%H%M")
+        vm.manage("export","-o #{folder}/#{filename}.ova")
+        sleep(5)
+      end
 
-    self.each {|vm| vm.manage("startvm", "--type headless")}
+      self.each {|vm| vm.manage("startvm", "--type headless")}
+    end
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: virtualman
 version: !ruby/object:Gem::Version
-  version: 1.1.9
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,9 +9,9 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-06 00:00:00.000000000 Z
+date: 2012-11-15 00:00:00.000000000 Z
 dependencies: []
-description: An interactive tool to manage quickly your VMs
+description: An interactive tool, and library to manage quickly your VMs
 email: pierre.ozoux@gmail.com
 executables:
 - virtualman
@@ -19,11 +19,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/virtualman.rb
-- lib/virtualman/configuration.rb
-- lib/virtualman/interractive.rb
-- lib/virtualman/menu.rb
+- lib/virtualman/interactive/configuration.rb
+- lib/virtualman/interactive/REPL.rb
+- lib/virtualman/interactive/menu.rb
 - lib/virtualman/vm.rb
 - lib/virtualman/vmlister.rb
+- lib/virtualman/interactive/helper.rb
 - bin/virtualman
 homepage: http://rubygems.org/gems/virtualman
 licenses: []

data/lib/virtualman/configuration.rb

@@ -1,51 +0,0 @@
-require 'yaml'
-
-module Configuration
-
-	def config_file
-		File.join(ENV['HOME'],'.virtualman.rc.yaml')
-	end
-
-	def load_conf
-		if File.exists? config_file
-		  config_options = YAML.load_file(config_file)
-		else
-			STDERR.puts "No configuration file found here ~/.vm_to_clone.rc.yaml"
-			STDERR.puts "Config file example:"
-			STDERR.puts "---"
-			STDERR.puts "source_vm:"
-			STDERR.puts " - name: 			Debian"
-			STDERR.puts "   snapshot: 	ready to clone!"
-			STDERR.puts " - name: 			Gentoo"
-			STDERR.puts "   snapshot: 	almost ready"
-			STDERR.puts "role_path: http://path/to/your/role/fodler"
-			STDERR.puts "cookbook_path: http://path/to/your/cookbooks.tar.gz"
-			STDERR.puts "roles:"
-			STDERR.puts "- devtest"
-			STDERR.puts "- devtest_jenkins"
-			STDERR.puts "- build_pkg_devtest_jenkins"
-		end
-		return config_options
-	end
-
-	def record_conf(vm_cloned, *param)
-		conf = load_conf()
-
-		if param[0] == "delete"
-			verb = "deleted"
-			conf["cloned_vms"].reject!{|vm| vm == {"name" => vm_cloned.name.gsub(/\"/,'')} }
-		else
-			verb = "saved"
-
-			if conf["cloned_vms"]
-				conf["cloned_vms"] << {"name" => vm_cloned.name}
-			else
-				conf.merge!({"cloned_vms" => {"name" => vm_cloned.name}})
-			end
-		end
-
-		File.open(config_file, "w") {|f| f.write(conf.to_yaml) }
-		puts "VM #{vm_cloned.name} has been #{verb} in your configuration file."
-	end
-	
-end

data/lib/virtualman/interractive.rb

@@ -1,226 +0,0 @@
-require 'open3'
-require 'erb'
-
-module Interractive
-include Configuration
-
-	def choosed_option(array,choice,attribute_to_check)
-		array.each_with_index do |option,index|
-			if option[attribute_to_check] == choice
-				return array[index]
-			end
-		end
-	end
-
-	def choose options, *attribute_to_check
-		options_array = Configuration.load_conf[options]
-		if attribute_to_check.empty?
-			return Menu.unic_run(options_array)
-		else
-			list = Array.new
-			options_array.each do |option|
-				list << option[attribute_to_check[0]]
-			end
-			list << "exit"
-
-			choice = Menu.unic_run(list)
-
-			exit 0 if choice == "exit"
-
-			return choosed_option(options_array,choice,attribute_to_check[0])
-		end
-	end
-
-	def choose_vm source
-		vm_choice = choose source, "name"
-		vm_choosed = Vm.new("\"#{vm_choice["name"]}\"")
-		return vm_choosed
-	end
-
-	def clone_vm
-		puts "----Clone_VM----"
-		puts "Which VM do you want to clone?"
-
-		vm_choice = choose "source_vms", "name"
-		vm_to_clone = Vm.new("\"#{vm_choice["name"]}\"")
-
-		puts "How do you want to name your freshly spawned VM?"
-		vm_name = Menu.ask
-
-		options = "--snapshot \"#{vm_choice["snapshot"]}\" --name \"#{vm_name}\" --register"
-		vm_to_clone.manage("clonevm", options)
-
-		vm_cloned = Vm.new(vm_name)
-		return vm_cloned
-	end
-
-	def start_vm(vm)
-		if !vm.running?
-			puts "Do you want to start the VM? headless?"
-			puts "(default is no)"
-			puts "yes/headless/[no]"
-
-			answer = Menu.ask
-
-			if answer == "headless"
-				option = "--type headless"
-				puts "The VM is booting headless"
-			elsif answer == "yes"
-				option = ""
-				puts "The VM is booting"
-			else
-				puts "The vm will not be started"
-				return vm
-			end
-
-			vm.manage("startvm", option)
-
-			print "Waiting for the VM to get an IP"
-			while !vm.ip
-				print "."
-				sleep (1)
-			end
-			print "\n"
-		end
-
-		return vm.running?
-	end
-
-	def clone
-		cloned_vm = clone_vm
-		start_vm(cloned_vm)
-		record_conf(cloned_vm)
-	end
-
-	def cook
-		puts "----Cook a clone!----"
-		puts "Which VM do you want to cook?"
-		role_path = load_conf["role_path"]
-		cookbook_path = load_conf["cookbook_path"]
-
-		selected_vm = choose_vm "cloned_vms"
-
-		puts "Which role do you want to give?"
-
-		role = choose "roles"
-
-		user="root"
-
-		if start_vm(selected_vm)
-			cmd = "ssh #{user}@#{selected_vm.ip} '/usr/local/bin/chef-solo -j #{role_path}#{role}.json -r #{cookbook_path}'"
-			p cmd
-			system(cmd)
-		end
-
-		puts "Thanks!"
-	end
-
-	def ssh
-		puts "----SSH to cloned VM----"
-		puts "Which VM do you want to ssh?"
-
-		selected_vm = choose_vm "cloned_vms"
-
-		puts "With which user? [root]"
-		user = Menu.ask
-
-		if user.empty?
-			user = "root"
-		end
-
-		if start_vm(selected_vm)
-			cmd = "ssh #{user}@#{selected_vm.ip}"
-			exec (cmd)
-		end	
-	end
-
-	def delete
-		puts "----Delete a cloned VM----"
-		puts "Which VM delete?"
-
-		selected_vm = choose_vm "cloned_vms"
-
-		puts "!!YOU ARE ABOUT TO DELETE PEMANENTLY DELETE #{selected_vm.name}!!"
-		puts "Are you sure? (yes/[no])"
-
-		choice = Menu.ask
-
-		if choice == "yes"
-			selected_vm.stop!
-
-			selected_vm.manage("unregistervm","--delete")
-
-			record_conf(selected_vm, "delete")
-		end
-	end
-
-	def add
-		puts "----Add a VM----"
-		puts "Give the path of the OVA file you want to add"
-		puts "(An OVA file represents a Virtual Machine)"
-
-		path = Menu.ask
-
-		cmd = "VBoxManage import #{path}"
-		p cmd
-		system(cmd)
-
-		added_vm = Vm.new(File.basename("#{path}",".*"))
-		record_conf(added_vm)
-	end
-
-	def bootify
-		puts "----Start a VM at boot----"
-		puts "Whcih VM do you want to add to your boot sequence?"
-
-		selected_vm = choose_vm "cloned_vms"
-
-		# Create template.
-		template_plist = %q{
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-  <key>Label</key>
-  <string>org.virtualman.<%= vmname %></string>
-  <key>ProgramArguments</key>
-  <array>
-    <string>VBoxManage</string>
-    <string>startvm</string>
-    <string><%= vmname %></string>
-    <string>--type</string>
-    <string>headless</string>
-  </array>
-  <key>RunAtLoad</key>
-  <true/>
-  <key>UserName</key>
-  <string><%= username %></string>
-  <key>debug</key>
-  <true/>
-</dict>
-</plist>
-		}.gsub(/^  /, '')
-
-		plist = ERB.new(template_plist, 0, "%<>")
-
-		# Set up template data.
-
-		vmname = selected_vm.name.gsub(/\"/,'')
-		username = `whoami`.strip
-
-		# Produce result.
-
-		vm_plist = plist.result(binding)
-
-		plist_filename = "org.virtualman.#{vmname}.plist"
-		tmp_file = "/tmp/#{plist_filename}"
-		path = "/Library/LaunchDaemons/"
-
-		File.open(tmp_file, 'w') { |file| file.write(vm_plist) }
-
-		`sudo cp #{tmp_file} #{path};sudo launchctl load #{path}#{plist_filename}`
-
-		puts "#{vmname} added to your boot sequence."
-	end
-
-end