virtualman 1.0.0 → 1.1.0

data/bin/clone_cooking

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+####Required
+require 'virtualman'
+
+cloned_vms = load_conf["cloned_vms"]
+
+cloned_vms.each do |vm|
+	list << vm["name"]
+end
+
+puts "----Clone_Cooking----"
+puts "Which VM do you want to cook?"
+
+chocie = Menu.unic_run(list)
+
+selected_vm = Vm.new(choice)
+
+if !selected_vm.running?
+	puts "#{selected_vm.name} is not running..."
+	start_vm(selected_vm)
+	if !selected_vm.running?
+		puts "As you want.."
+		return 1
+	end
+end
+
+cmd = "ssh #{user}@#{selected_vm.ip}"
+exec (cmd)
+
+puts "Thanks!"

data/bin/clone_vm

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+####Required
+require 'virtualman'
+
+source_vms = load_conf["source_vms"]
+
+cloned_vm = clone_vm(source_vms)
+
+start_vm(cloned_vm)
+
+record_conf(cloned_vm)

data/bin/ssh_cloned

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+####Required
+require 'virtualman'
+
+cloned_vms = load_conf["cloned_vms"]
+
+cloned_vms.each do |vm|
+	list << vm["name"]
+end
+
+puts "----SSH_cloned_VM----"
+puts "Which VM do you want to ssh?"
+
+chocie = Menu.unic_run(list)
+
+selected_vm = Vm.new(choice)
+
+puts "With which user? [root]"
+user = Menu.ask
+
+if user.empty?
+	user = "root"
+end
+
+if !selected_vm.running?
+	puts "#{selected_vm.name} is not running..."
+	puts "Do you want to start it?"
+	puts "yes/[no]"
+	chocie = Menu.ask
+	if choice == "yes"
+		start_vm(selected_vm)
+	else
+		puts "As you want!"
+		return 1
+	end
+end
+
+cmd = "ssh #{user}@#{selected_vm.ip}"
+exec (cmd)
+
+puts "Thanks!"

data/bin/virtualman

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+####Required
+require 'virtualman'
+
+menu = ["clone","cook","ssh_cloned","exit"]
+
+puts "----VirtualMan----"
+puts "Please select an action to do with your VM."
+
+choice = Menu.unic_run(menu)
+
+while choice != "exit"
+	send(choice)
+	puts "----VirtualMan----"
+	puts "Please select an action to do with your VM."
+	choice = Menu.unic_run(menu)
+end
+
+puts "Thank you come again!"

data/lib/virtualman.rb

@@ -1,98 +1,5 @@
-# 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
-
-  # 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 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.name.delete "\""} "shutdown -h now"`
-      puts "Waiting for complete shutdown of #{self.name}"
-      while self.running?
-        print "."
-        sleep (1)
-      end
-    end
-
-  end
-end
-
-# Create an array tht 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
-
-  # A simple lister
-  def list
-    self.each {|vm| puts "#{vm.name}"}
-  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?
-
-      vm.manage(action, param, block_param)
-    end
-  end
-
-  # 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 {|vm| vm.manage("startvm", "--type headless")}
-  end
-end
+require 'virtualman/menu'
+require 'virtualman/vm'
+require 'virtualman/vmlister'
+require 'virtualman/conf'
+require 'virtualman/interractive'

data/lib/virtualman/conf.rb

@@ -0,0 +1,37 @@
+require 'yaml'
+
+CONFIG_FILE = File.join(ENV['HOME'],'.clone_vm.rc.yaml') 
+
+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)
+	conf = load_conf()
+	if conf["cloned_vms"]
+		conf["cloned_vms"] << {"name" => vm_cloned.name}
+	else
+		conf.merge!({"cloned_vms" => {"name" => vm_cloned.name}})
+	end
+
+	File.open(CONFIG_FILE, "w") {|f| f.write(conf.to_yaml) }
+	puts "VM #{vm_cloned.name} saved in your configuration file"
+end

data/lib/virtualman/interractive.rb

@@ -0,0 +1,124 @@
+#require 'lib/virtualman'
+
+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 = 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
+		choice = Menu.unic_run(list)
+		return choosed_option(options_array,choice,attribute_to_check[0])
+	end
+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"]
+
+	vm_choice = choose "cloned_vms", "name"
+
+	selected_vm = Vm.new(vm_choice["name"])
+
+	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
+		`#{cmd}`
+	end
+
+	puts "Thanks!"
+end
+
+def ssh_cloned
+	puts "----SSH to cloned VM----"
+	puts "Which VM do you want to ssh?"
+
+	vm_choice = choose "cloned_vms", "name"
+
+	selected_vm = Vm.new(vm_choice["name"])
+
+	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

data/lib/virtualman/menu.rb

@@ -0,0 +1,58 @@
+#The MIT LICENSE
+
+#Copyright (c) 2010 Gabriel Horner
+
+#Permission is hereby granted, free of charge, to any person obtaining
+#a copy of this software and associated documentation files (the
+#"Software"), to deal in the Software without restriction, including
+#without limitation the rights to use, copy, modify, merge, publish,
+#distribute, sublicense, and/or sell copies of the Software, and to
+#permit persons to whom the Software is furnished to do so, subject to
+#the following conditions:
+
+#The above copyright notice and this permission notice shall be
+#included in all copies or substantial portions of the Software.
+
+#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#Forked from https://github.com/cldwalker/menu
+
+module Menu
+  extend self
+
+  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

@@ -0,0 +1,61 @@
+# 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
+
+  # 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 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.name.delete "\""} "shutdown -h now"`
+      puts "Waiting for complete shutdown of #{self.name}"
+      while self.running?
+        print "."
+        sleep (1)
+      end
+    end
+
+  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
+      else
+        return false
+      end
+    else
+      puts "The VM is not running, cannot determine IP"
+      return false
+    end
+  end
+end

data/lib/virtualman/vmlister.rb

@@ -0,0 +1,58 @@
+# 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
+
+  # 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
+
+  # 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?
+
+      vm.manage(action, param, block_param)
+    end
+  end
+
+  # 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 {|vm| vm.manage("startvm", "--type headless")}
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: virtualman
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,29 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-16 00:00:00.000000000 Z
+date: 2012-09-06 00:00:00.000000000 Z
 dependencies: []
 description: It is for writing scripts for UNIX-like systems to handle your VirtualBox
   appliance.
 email: pierre.ozoux@gmail.com
-executables: []
+executables:
+- clone_vm
+- virtualman
+- ssh_cloned
+- clone_cooking
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/virtualman.rb
+- lib/virtualman/conf.rb
+- lib/virtualman/interractive.rb
+- lib/virtualman/menu.rb
+- lib/virtualman/vm.rb
+- lib/virtualman/vmlister.rb
+- bin/clone_vm
+- bin/virtualman
+- bin/ssh_cloned
+- bin/clone_cooking
 homepage: http://rubygems.org/gems/virtualman
 licenses: []
 post_install_message: 
@@ -42,5 +55,5 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: A sinmple way to manage your Virtual Machines under VirtualBox.
+summary: A simple way to manage your Virtual Machines under VirtualBox.
 test_files: []