vagrant-node 1.0.0 → 1.1.1

data/lib/vagrant-node/apidesc.rb

@@ -4,9 +4,17 @@ module RestRoutes
 	
 	class RouteManager
 	
+		def self.node_info_route
+			NODE_INFO
+		end
+
 		def self.box_list_route
 			BOX_LIST_ROUTE
 		end
+
+		def self.box_download_route
+			BOX_DOWNLOAD_ROUTE
+		end
 		
 		def self.box_delete_route
 			BOX_DELETE_ROUTE
@@ -37,8 +45,8 @@ module RestRoutes
 		end
 		
 		def self.vm_add_route
-      VM_ADD_ROUTE
-    end
+      		VM_ADD_ROUTE
+    	end
 		
 		def self.vm_status_route
 			VM_STATUS_ROUTE
@@ -69,12 +77,12 @@ module RestRoutes
 		end
 		
 		def self.vm_snapshot_delete_route
-      VM_SNAPSHOT_DELETE_ROUTE
-    end
+      		VM_SNAPSHOT_DELETE_ROUTE
+    	end
 		
 		def self.vm_delete_route
-      VM_DELETE_ROUTE
-    end
+      		VM_DELETE_ROUTE
+    	end
 		
 		def self.vm_snapshot_restore_route
 			VM_SNAPSHOT_RESTORE_ROUTE
@@ -85,10 +93,12 @@ module RestRoutes
 		end
 		
 		def self.node_password_change_route
-      NODE_PASSWORD_CHANGE
-    end
-		
+	      	NODE_PASSWORD_CHANGE
+	    end
 		
+		def self.vm_info_route
+			VM_INFO_ROUTE
+		end
 		
 		def self.vm_backup_log_route
 			VM_BACKUP_LOG_ROUTE
@@ -96,12 +106,12 @@ module RestRoutes
 		
 		
 		def self.config_show_route
-      NODE_CONFIG_SHOW_ROUTE
-    end
+      		NODE_CONFIG_SHOW_ROUTE
+    	end
     
-    def self.config_upload_route
-      NODE_CONFIG_UPLOAD_ROUTE
-    end
+    	def self.config_upload_route
+      		NODE_CONFIG_UPLOAD_ROUTE
+    	end
 		
 		
 		def self.login_route
@@ -113,12 +123,18 @@ module RestRoutes
 		end
 		
 		def self.node_queue_last_route
-      NODE_QUEUE_LAST_ROUTE
-    end
-		
+      		NODE_QUEUE_LAST_ROUTE
+    	end
 		
 		
+
+		def self.node_info_url(host,port)
+			"http://#{host}:#{port}#{node_info_route}"
+		end
 		
+		def self.box_download_url(host,port)
+			"http://#{host}:#{port}#{box_download_route}"
+		end
 		
 		def self.box_list_url(host,port)
 			"http://#{host}:#{port}#{box_list_route}"
@@ -145,11 +161,12 @@ module RestRoutes
 		  url="http://#{host}:#{port}#{url}"
 		end
 
-    def self.node_queue_last_url(host,port)
-      "http://#{host}:#{port}#{node_queue_last_route}"
-    end
+	    def self.node_queue_last_url(host,port)
+	      "http://#{host}:#{port}#{node_queue_last_route}"
+	    end
 
 		def self.login_url(host,port)
+			
 		  "http://#{host}:#{port}#{login_route}"
 		end
 		
@@ -182,7 +199,12 @@ module RestRoutes
 		end
 		
 			
-		
+		def self.vm_info_url(host,port,vmname)
+			url="http://#{host}:#{port}#{vm_info_route}"
+			url=String.new(vm_info_route)
+			url[":vm"]=vmname
+			url="http://#{host}:#{port}#{url}"		
+		end		
 		
 		def self.vm_status_url(host,port,vmname=nil)	
 			url="http://#{host}:#{port}#{vm_status_all_route}"
@@ -285,8 +307,11 @@ module RestRoutes
 		
 		private
 			BOX_LIST_ROUTE =	"/api/box/list"
+			BOX_DOWNLOAD_ROUTE =	"/api/box/download"
 			BOX_DELETE_ROUTE =	"/api/box/:box/:provider/delete"
 			BOX_ADD_ROUTE = "/api/box/add" 
+
+			NODE_INFO = "/api/info"
 			
 			VM_UP_ROUTE = "/api/vm/up"
 			VM_HALT_ROUTE = "/api/vm/halt"
@@ -298,6 +323,7 @@ module RestRoutes
 			VM_PROVISION_ROUTE = "/api/vm/provision"
 			VM_STATUS_ALL_ROUTE = "/api/vm/status"
 			VM_STATUS_ROUTE = "/api/vm/:vm/status"			
+			VM_INFO_ROUTE = "/api/vm/:vm/info"			
 			SSH_CONFIG_ROUTE = "/api/vm/:vm/sshconfig"
 			
 			SNAPSHOTS_ALL_ROUTE = "/api/vm/snapshots"

data/lib/vagrant-node/clientcontroller.rb

@@ -1,13 +1,25 @@
 
 require 'vagrant'
 require 'vagrant-node/actions/snapshot'
+require 'vagrant-node/actions/boxadd'
 require 'vagrant-node/dbmanager'
 require 'vagrant-node/pwmanager'
 require 'vagrant-node/exceptions.rb'
 require 'vagrant-node/configmanager'
+require 'vagrant-node/obmanager'
+require 'usagewatch'
+require "sys/cpu"
+require 'facter'
+
+
+
+
 
 
 module Vagrant
+
+
+
 	module Node
 	  
 	    
@@ -15,8 +27,9 @@ module Vagrant
 		class ClientController
 			
 			
-			def self.execute_queued			
+			def self.execute_queued						
 			  ensure_environment
+			  
 			  #Generating a random identifier for process
 			  rpid=rand(1000000)
 			  
@@ -26,17 +39,18 @@ module Vagrant
 			     res = yield			     
 			     @db.set_queued_process_result(rpid,res.to_json)		     
 			     
-			    rescue Exception => e
+			    rescue Exception => e				      		    
 			      @db.set_queued_process_error(rpid,e)			      
 			    end
 			  end
+
 			  rpid
 			end
 			
 			def self.send_challenge			  
 			  challenge = SecureRandom.urlsafe_base64(nil, false)
 			  cookie = SecureRandom.urlsafe_base64(nil, false)			  
-			  
+
 			  
 			  {:cookie => cookie, :challenge => challenge}
 			end
@@ -46,7 +60,69 @@ module Vagrant
 			 
 			 @pw.authorized?(token,challenge)			 
 			end
+
+			################################################################
+			#######################  NODE INFO (CPU,MEMORY) ################
+			################################################################			
+			def self.nodeinfo
+				
+				
+  				usw = Usagewatch
+
+				
+  				Facter.loadfacts
+
+  				
+  				
+  				result=Hash[Facter.to_hash.map{|(k,v)| [k.to_sym,v]}]
+
+  				result[:cpuaverage] = Sys::CPU.load_avg;
+  				result[:diskusage] = usw.uw_diskused
+
+  				result	
+			
+				
+			end			
 			
+			################################################################
+			#######################  BOX DOWNLOADS METHOD ##################
+			################################################################			
+			def self.listdownloadboxes
+			  
+			
+  				ensure_environment
+  				
+  				downloads = @db.get_box_download  				
+  				
+  				
+  				fdownloads = Array.new				
+  				downloads.each do |row|	  		  					
+  				 	fdownloads << {"box_name" => row["box_name"],"box_url" => row["box_url"],"box_progress" => row["download_progress"],"box_remaining" => row["download_remaining"],"download_status" => row["download_status"]}
+  				end
+  				
+  				
+
+  				fdownloads		
+			
+				
+			end			
+
+			################################################################
+			#################  CLEAR BOX DOWNLOADS METHOD ##################
+			################################################################			
+			def self.cleardownloadboxes
+			  
+			
+  				ensure_environment
+  				
+  				@db.clear_box_downloads
+  				
+
+  				true
+				
+			end			
+
+
 			################################################################
 			#######################  BOX LIST METHOD #######################
 			################################################################			
@@ -74,15 +150,28 @@ module Vagrant
 			def self.box_delete(box,provider)
 			
 				ensure_environment
+
+				boxes = []				
+				
 				
-				boxes = []			
 
-			  box = @env.boxes.find(box,provider.to_sym)
-			  
-			  if (box)			  	
-			  	boxes << box.name			  
-			  	box.destroy!			  				  	
-			  end 
+				bbox = @env.boxes.find(box,provider.to_sym)
+				
+
+
+				if (bbox)	
+					get_vms("").each do |machine|
+						if (!machine.box.nil? && machine.box.name==box)
+							raise RestException.new(500,"The box can't be deleted because the virtual machine '#{machine.name.to_s}' is using it")	
+						end
+																			
+					end		
+
+					boxes << bbox.name			  
+					bbox.destroy!			  				  	
+				else
+					raise RestException.new(404,"The box '#{box}' does not exist")	
+				end 
 								
 				boxes
 				
@@ -92,6 +181,16 @@ module Vagrant
 			########################  BOX ADD METHOD #######################
 			################################################################			
 			def self.box_add(box,url,user="guest",pass="--no-pass")
+
+				@env.boxes.all.each do |box_name,provider|
+
+					if box_name==box
+						raise RestException.new(500,"There is a box with the same name")	
+					end					
+				end
+
+				
+
 				command_block = Proc.new {
                   				#ensure_environment
                   				
@@ -196,21 +295,35 @@ module Vagrant
                   #          	          		 
                   #					else
                   
+                           
+                            copy_db = @db.clone
                             
-                            
+                           
+
                               boxes <<{:name=>box}
                   #						FIXME Ver qué poner en los parámetros de la llamada
                   						provider=nil
                   						force = true # Always overwrite box if exists
                   						insecure = true #Don't validate SSL certs
                   						#Calling original box add action
-                  						@env.action_runner.run(Vagrant::Action.action_box_add, {
-                              :box_name     => box,
-                              :box_provider => provider,
-                              :box_url      => url,
-                              :box_force    => force,
-                              :box_download_insecure => insecure,
-                            	})
+
+                  						
+                  						@env.action_runner.run(BoxAddAction, {
+								                              :box_name     => box,
+								                              :box_provider => provider,
+								                              :box_url      => url,
+								                              :box_force    => force,
+								                              :box_download_insecure => insecure,
+								                              :db => copy_db,
+								                            	})
+
+                  						# @env.action_runner.run(Vagrant::Action.action_box_add, {
+                        #       :box_name     => box,
+                        #       :box_provider => provider,
+                        #       :box_url      => url,
+                        #       :box_force    => force,
+                        #       :box_download_insecure => insecure,
+                        #     	})
                   
                   #					end
                   
@@ -219,14 +332,15 @@ module Vagrant
 					     
 
                                       
-              boxes					     
-					     
-				rescue =>e
-						puts e.message
-				end
+	              	boxes					     
+						     
+					rescue =>e
+							puts e.message
+					end
 
 				}
-        method("execute_queued").call(&command_block);
+
+        		method("execute_queued").call(&command_block);
 				
 			end
 			
@@ -235,42 +349,61 @@ module Vagrant
 			################################################################
 			##################  VIRTUAL MACHINE UP METHOD ##################
 			################################################################
-			def self.vm_up(vmname)
-			  command_block = Proc.new {
-				#ensure_environment
-					
-				machine_names = []
-	
-				#begin
-	        
-					options = {}
-					options[:parallel] = true
+			def self.vm_up(vmname)	
+			
 				
-					#Launching machines
-					@env.batch(options[:parallel]) do |batch|			
-						get_vms(vmname).each do |machine|
-							batch.action(machine, :up, options)							
-							machine_names << {"vmname" => machine.name.to_s,
-																"status" => "running"}												
-						end
-					end           
+
+			  	command_block = Proc.new {					
 					
+					machine_names = []
+
+
+
+					begin
 					
-					machine_names
-					}
+			        
+						options = {}
+						options[:parallel] = true
+						
+						#Launching machines
+						@env.batch(options[:parallel]) do |batch|			
+							
+							get_vms(vmname).each do |machine|
+									
+									batch.action(machine, :up, options)							
+									
+									machine_names << {"vmname" => machine.name.to_s,
+													  "provider" => machine.provider_name.to_s,
+													  "status" => "running"}												
+
+								
+
+							end
+						end           
+				
+						raise RestException.new(404,"The machine #{vmname} does not exist") if (machine_names.empty?)						
+
+						machine_names
+
+					rescue Exception => e  	
+												
+						aux=get_vms(vmname)
+						machine=aux[0]
+
+						raise RestException.new(404,"The machine #{vmname} does not exist") if (aux.empty?)						
+						raise VMActionException.new(machine.name.to_s,machine.provider_name.to_s,e.message) if (!machine.nil?)
+					end
+
 					
-					method("execute_queued").call(&command_block);
+				}
+				
+				method("execute_queued").call(&command_block)
 					
-				# rescue Vagrant::Errors::BoxNotFound => e
-				  # puts "BOX NOT FOUND"
-				# rescue => e
-				  # pp e
-				  # puts e.message
-				  # raise RestException.new(404,e.message)								 
-				# end
+				
 				
 			end
 		
+		
 		 
 			
 			
@@ -286,15 +419,19 @@ module Vagrant
           f.write(config)
           f.close          
                   
-                   
+          
           cm = ConfigManager.new(@env.root_path+"Vagrantfile")
+          
+          
           cmtmp = ConfigManager.new(path)
           
+          
                  
           current_vms = @env.machine_names
           
-          cmtmp.get_vm_names.each do |key|             
-           
+          
+
+          cmtmp.get_vm_names.each do |key|                         
             if current_vms.include?(key)  
               raise RestException.new(406,"There is a remote VM with the same name: \"#{key}\"") if rename=="false"             
               cmtmp.rename_vm(key,"#{key}_1")            
@@ -355,195 +492,276 @@ module Vagrant
         
       end
 			
-			################################################################
-			#################  VIRTUAL MACHINE HALT METHOD #################
-			################################################################
-			def self.vm_halt(vmname,force)
-			  command_block = Proc.new {
-  				#ensure_environment				
-  			
-  				machine_names = []
-  	
-  				#begin				
-  					
-  					get_vms(vmname).each do |machine|						
-  						machine.action(:halt, :force_halt => force)
-  						machine_names << {"vmname" => machine.name.to_s,
-  															"status" => machine.state.short_description}
-  					end
-  							
-  					machine_names
-					}
-					
-					method("execute_queued").call(&command_block);
-				
-				#rescue => e					
-#					return nil
-				#end
-				
-			end
+		################################################################
+		#################  VIRTUAL MACHINE HALT METHOD #################
+		################################################################
+		def self.vm_halt(vmname,force)
 			
-			################################################################
-			#################  VIRTUAL MACHINE STATUS METHOD ###############
-			################################################################
-			def self.vm_status(vmname=nil)
-				ensure_environment				
+			force=(force=="true")?true:false;
+
+		  	command_block = Proc.new {
+
+				begin
+					machine_names = []		
+					get_vms(vmname).each do |machine|						
+						machine.action(:halt, :force_halt => force)
+						machine_names << {"vmname" => machine.name.to_s,
+											"provider" => machine.provider_name.to_s,
+											"status" => machine.state.short_description}
+					end
+
+					raise RestException.new(404,"The machine #{vmname} does not exist") if (machine_names.empty?)						
+
+					machine_names
+
+				rescue Exception => e  						
+					aux=get_vms(vmname)
+					machine=aux[0]
+
+					raise RestException.new(404,"The machine #{vmname} does not exist") if (aux.empty?)						
+					raise VMActionException.new(machine.name.to_s,machine.provider_name.to_s,e.message) if (!machine.nil?)
+				end
+						
 				
+			}
 				
-					
-				status = Array.new
-									
-				get_vms(vmname).each do |machine|
-						
-					status << {"name" => machine.name.to_s,
-								"status" => machine.state.short_description,
-								"provider" => machine.provider_name}
-				end		
+			method("execute_queued").call(&command_block);
 			
+			#rescue => e					
+		#					return nil
+			#end
 			
-				status
-							
-				
+		end
+		
+		################################################################
+		#################  VIRTUAL MACHINE INFO METHOD ###############
+		################################################################
+		def self.vm_info(vmname)				
+			raise RestException.new(500,"The VM Name can't be emtpy") if vmname.empty?						
+
+			ensure_environment
+			
+			#execute("snapshot",self.uuid,"showvminfo",name)					   
+
+			machines=get_vms(vmname)
 				
+			raise RestException.new(404,"The machine #{vmname} does not exist") if (machines.empty?)						
+
+			info = Hash.new
+			
+			
+
+			if (machines[0].id!=nil)
+				machines[0].provider.driver.execute("showvminfo",machines[0].id,"--machinereadable").split("\n").each do |line|								
+					if (line =~ /^(.*?)=\"(.*?)\"$/) || (line =~ /^(.*?)=(.*?)$/)
+						info[$1]=$2
+					end
+				end
 			end
 			
-			################################################################
-			##################  VIRTUAL MACHINE SUSPEND METHOD ##################
-			################################################################
-			def self.vm_suspend(vmname)
-			  command_block = Proc.new {
-				  #ensure_environment
 			
-				  machine_names = []
+			info			
+
+		end
+
+
+		################################################################
+		#################  VIRTUAL MACHINE STATUS METHOD ###############
+		################################################################
+		def self.vm_status(vmname=nil,verbose=true)				
+			ensure_environment				
 			
-				
-				
+			
+			begin
+				status = Array.new
+				if (verbose==true || verbose=="true")				
 					
-					#Suspendiing machines								
 					get_vms(vmname).each do |machine|
-						machine.action(:suspend)
-						machine_names << {"vmname" => machine.name.to_s,
-																"status" => machine.state.short_description}
-					end           
 					
+						status << {"name" => machine.name.to_s,
+									"status" => machine.state.short_description,
+									"provider" => machine.provider_name}
+					end		
+				else				
+					@env.machine_names.each do |machine|
+						status << {"name" => machine.to_s}
+					end
+				end
+			
 				
-				  machine_names
-				  
-				}
-					
-				method("execute_queued").call(&command_block);
-				
+				status
+			rescue Exception => e 
+				raise e
 			end
+						
+			
+			
+		end
+			
+		################################################################
+		##################  VIRTUAL MACHINE SUSPEND METHOD ##################
+		################################################################
+		def self.vm_suspend(vmname)
+		  command_block = Proc.new {
+			  #ensure_environment
 		
-			################################################################
-			##################  VIRTUAL MACHINE RESUME METHOD ##################
-			################################################################
-			def self.vm_resume(vmname)
-			  command_block = Proc.new {
-				#ensure_environment
+			  begin
+			  
+			  	machine_names = []
+		
+			
+			
+				
+				#Suspendiing machines								
+				get_vms(vmname).each do |machine|
+					machine.action(:suspend)
+					machine_names << {"vmname" => machine.name.to_s,
+										"provider" => machine.provider_name.to_s,
+										"status" => machine.state.short_description}
+				end           
+				
+			
+				raise RestException.new(404,"The machine #{vmname} does not exist") if (machine_names.empty?)						
+
+			  	machine_names
+
+			  rescue Exception => e  						
+					aux=get_vms(vmname)
+					machine=aux[0]
+
+					raise RestException.new(404,"The machine #{vmname} does not exist") if (aux.empty?)						
+					raise VMActionException.new(machine.name.to_s,machine.provider_name.to_s,e.message) if (!machine.nil?)
+				end
+
+			  
+			}
+				
+			method("execute_queued").call(&command_block);
 			
-				machine_names = []			
+		end
+		
+		################################################################
+		##################  VIRTUAL MACHINE RESUME METHOD ##################
+		################################################################
+		def self.vm_resume(vmname)
+		  	command_block = Proc.new {
+			#ensure_environment
+				begin
+
+					machine_names = []			
 					#Launching machines
 								
 					get_vms(vmname).each do |machine|
 						machine.action(:resume)
 						machine_names << {"vmname" => machine.name.to_s,
-															"status" => machine.state.short_description}					
+											"provider" => machine.provider_name.to_s,
+											"status" => machine.state.short_description}					
 					end
 					           
-					
+					raise RestException.new(404,"The machine #{vmname} does not exist") if (machine_names.empty?)						
 				
 					machine_names
-				}
-				
-				method("execute_queued").call(&command_block);
-				
+					
+				rescue Exception => e  						
+					aux=get_vms(vmname)
+					machine=aux[0]
+
+					raise RestException.new(404,"The machine #{vmname} does not exist") if (aux.empty?)						
+					raise VMActionException.new(machine.name.to_s,machine.provider_name.to_s,e.message) if (!machine.nil?)
+				end
+			}
 				
-			end
+			method("execute_queued").call(&command_block);
 			
-			################################################################
-			############  VIRTUAL MACHINE SNAPSHOT LIST METHOD #############
-			################################################################
-			def self.vm_snapshots(vmname=nil)
-				ensure_environment				
-				
-				#begin
-				
-					snapshots = {}
-										
-					get_vms(vmname).each do |machine|
-						
-						env = 
-						{							
-        			:machine        => machine,
-        			:machine_action => SnapshotAction::LIST
-						}
-						
-						
-						res = @env.action_runner.run(SnapshotAction,env)
-						
-						snapshots[machine.name.to_sym]=res[:snapshots_list]
-						
-					end		
-				
-				  
-					snapshots
-							
-				# rescue => e
-					# puts e.message
-# #					return nil				
-				# end
-				
-			end
 			
-			################################################################
-			############  VIRTUAL MACHINE SNAPSHOT TAKE METHOD #############
-			################################################################
-			def self.vm_snapshot_take(vmname,name,desc=" ")
-			  command_block = Proc.new {
-				#ensure_environment				
-				
+		end
+		
+		################################################################
+		############  VIRTUAL MACHINE SNAPSHOT LIST METHOD #############
+		################################################################
+		def self.vm_snapshots(vmname=nil)
+			ensure_environment				
+			
+			#begin
+			
+				snapshots = {}
+									
+				get_vms(vmname).each do |machine|
 					
-					raise RestException.new(404,"Virtual Machine not specified") if (vmname==nil ||vmname.empty?)
+					env = 
+					{							
+		    			:machine        => machine,
+		    			:machine_action => SnapshotAction::LIST
+					}
 					
 					
-					machine = get_vms(vmname)
-					raise RestException.new(404,"Virtual Machine not found") if (machine.empty?)
+					res = @env.action_runner.run(SnapshotAction,env)
 					
-           env = 
-           {              
-              :machine        => machine.first,
-              :machine_action => SnapshotAction::TAKE,
-              :snapshot_name  => name,
-              :snapshot_desc  => desc             
-            }
-              
-            res = @env.action_runner.run(SnapshotAction,env)
-              
-            res[:last_snapshot]            
-            
-           		
-					# get_vms(vmname).each do |machine|
-					 # env = 
-					 # {							
-        			# :machine        => machine,
-        			# :machine_action => SnapshotAction::TAKE,
-        			# :snapshot_name 	=> name,
-        			# :snapshot_desc  => desc        			
-						# }
+					snapshots[machine.name.to_sym]=res[:snapshots_list]
+					
+				end		
+			
+			  
+				snapshots
+						
+			# rescue => e
+				# puts e.message
+# #					return nil				
+			# end
+			
+		end
+		
+		################################################################
+		############  VIRTUAL MACHINE SNAPSHOT TAKE METHOD #############
+		################################################################
+		def self.vm_snapshot_take(vmname,name,desc=" ")
+		  command_block = Proc.new {
+			#ensure_environment				
+			
+				
+				raise RestException.new(404,"Virtual Machine not specified") if (vmname==nil ||vmname.empty?)
+				
+				
+				machine = get_vms(vmname)
+				raise RestException.new(404,"Virtual Machine not found") if (machine.empty?)
+						
+		       env = 
+		       {              
+		          :machine        => machine.first,
+		          :machine_action => SnapshotAction::TAKE,
+		          :snapshot_name  => name,
+		          :snapshot_desc  => desc             
+		        }
+		          
+		        res = @env.action_runner.run(SnapshotAction,env)
+		          
+
+		        
+
+		        res[:last_snapshot]            
+        
+       		
+				# get_vms(vmname).each do |machine|
+				 # env = 
+				 # {							
+    			# :machine        => machine,
+    			# :machine_action => SnapshotAction::TAKE,
+    			# :snapshot_name 	=> name,
+    			# :snapshot_desc  => desc        			
+					# }
 #  						
-						# res = @env.action_runner.run(SnapshotAction,env)
+					# res = @env.action_runner.run(SnapshotAction,env)
 # 						
-						# return res[:last_snapshot]						
+					# return res[:last_snapshot]						
 # 						
-					# end
-					
-					
-				}		
-					
-				method("execute_queued").call(&command_block);
+				# end
 				
-			end
+				
+			}		
+				
+			method("execute_queued").call(&command_block);
+			
+		end
 			
 			################################################################
       ############  VIRTUAL MACHINE SNAPSHOT DELETE METHOD #############
@@ -581,196 +799,198 @@ module Vagrant
       end
 			
 			
+		
+		################################################################
+		############  VIRTUAL MACHINE SNAPSHOT RESTORE METHOD #############
+		################################################################
+		def self.vm_snapshot_restore(vmname,snapshot_id)
+		  command_block = Proc.new {
+			  #ensure_environment				
 			
-			################################################################
-			############  VIRTUAL MACHINE SNAPSHOT RESTORE METHOD #############
-			################################################################
-			def self.vm_snapshot_restore(vmname,snapshot_id)
-			  command_block = Proc.new {
-				  #ensure_environment				
+			  raise RestException.new(404,"Virtual Machine not specified") if (vmname==nil ||vmname.empty?)
+			  
+			  restore_results = {}
+				
+								
+				get_vms(vmname).each do |machine|				  
 				
-				  raise RestException.new(404,"Virtual Machine not specified") if (vmname==nil ||vmname.empty?)
 				  
-				  restore_results = {}
+					prev_state=machine.state.id
+					#First, ensure that the machine is in a proper state
+					#to restore the snapshot (save, poweroff)
+					machine.action(:suspend) if prev_state==:running
 					
-									
-					get_vms(vmname).each do |machine|				  
+					#Now the machine is ready for restoration
+					env = 
+					{							
+		    			:machine        => machine,
+		    			:machine_action => SnapshotAction::RESTORE,
+		    			:snapshot_id 	=> snapshot_id        			   			
+					}
 					
-					  
-						prev_state=machine.state.id
-						#First, ensure that the machine is in a proper state
-						#to restore the snapshot (save, poweroff)
-						machine.action(:suspend) if prev_state==:running
-						
-						#Now the machine is ready for restoration
-						env = 
-						{							
-        			:machine        => machine,
-        			:machine_action => SnapshotAction::RESTORE,
-        			:snapshot_id 	=> snapshot_id        			   			
-						}
-						
-						
-						res = @env.action_runner.run(SnapshotAction,env)
-						
-						#Now restore the vm to the previous state if running
-						machine.action(:up) if prev_state==:running
-						
-						restore_results[machine.name.to_sym]=res[:restore_result]						
-					end		
 					
-					restore_results
+					res = @env.action_runner.run(SnapshotAction,env)
 					
+					#Now restore the vm to the previous state if running
+					machine.action(:up) if prev_state==:running
 					
-		   }
-			 method("execute_queued").call(&command_block);
+					restore_results[machine.name.to_sym]=res[:restore_result]						
+				end		
 				
-			end
+				
+
+				restore_results
+				
+				
+	   }
+		 method("execute_queued").call(&command_block);
+			
+		end
 			
 			
 					
-			################################################################
-			##################  VIRTUAL MACHINE PROVISION METHOD ##################
-			################################################################
-			def self.vm_provision(vmname)
-				#ensure_environment
-			  command_block = Proc.new {
-  				machine_names = []
-  	
-  	      # Por ahora no dejo que el vmname esté vacío para realizar la operación sobre todas las vm
-  				raise RestException.new(404,"Virtual Machine not specified") if (vmname==nil ||vmname.empty?)
-  				#begin
-  				
-  					#Provisioning								
-  					get_vms(vmname).each do |machine|										
-  						machine_names << machine.name	
-  						machine.action(:provision)					
-  					end
-  					           
-  					
-  				
-  					machine_names
-				}
+		################################################################
+		##################  VIRTUAL MACHINE PROVISION METHOD ##################
+		################################################################
+		def self.vm_provision(vmname)
+			#ensure_environment
+		  command_block = Proc.new {
+				machine_names = []
+	
+	      # Por ahora no dejo que el vmname esté vacío para realizar la operación sobre todas las vm
+				raise RestException.new(404,"Virtual Machine not specified") if (vmname==nil ||vmname.empty?)
+				#begin
 				
-        method("execute_queued").call(&command_block);	
-		
+					#Provisioning								
+					get_vms(vmname).each do |machine|										
+						machine_names << machine.name	
+						machine.action(:provision)					
+					end
+					           
+					raise RestException.new(404,"The machine #{vmname} does not exist") if (machine_names.empty?)						
 				
-			end				
+					machine_names
+			}
+			
+    		method("execute_queued").call(&command_block);	
+	
+			
+		end				
 					
 					
 					
 					
 					
-			################################################################
-			###################  VIRTUAL MACHINE SSHCONFIG## ###############
-			################################################################
-			def self.vm_ssh_config(vmname)
-				ensure_environment
+		################################################################
+		###################  VIRTUAL MACHINE SSHCONFIG## ###############
+		################################################################
+		def self.vm_ssh_config(vmname)
+			ensure_environment
+			
+			
+			#Ensure vmname exists and it is not empty
+			return nil if vmname.empty?
 				
+			
+			#begin
+				info = Array.new
+				get_vms(vmname).each do |machine|												
+					info << machine.ssh_info						
+				end
 				
-				#Ensure vmname exists and it is not empty
-				return nil if vmname.empty?
-					
+				info[0]
 				
-				#begin
-					info = Array.new
-					get_vms(vmname).each do |machine|												
-						info << machine.ssh_info						
-					end
-					
-					info[0]
-					
-				# rescue => e
-					# puts e.message
+			# rescue => e
+				# puts e.message
 #					return nil
-				#end	
-			
-			end
+			#end	
 		
-			################################################################
-			############  VIRTUAL MACHINE BACKUP TAKE METHOD #############
-			################################################################
-			def self.vm_snapshot_take_file(vmname)
-				ensure_environment
+		end
+	
+		################################################################
+		############  VIRTUAL MACHINE BACKUP TAKE METHOD #############
+		################################################################
+		def self.vm_snapshot_take_file(vmname)
+			ensure_environment
+			
+			current_machine = nil
+			t = Time.now.strftime "%Y-%m-%d %H:%M:%S"
+			begin
+			  
+				machines=get_vms(vmname)
 				
-				current_machine = nil
-				t = Time.now.strftime "%Y-%m-%d %H:%M:%S"
-				begin
-				  
-					machines=get_vms(vmname)
+				return [404,"Virtual Machine not found"] if machines.empty?
+									
+				machines.each do |machine|						
 					
-					return [404,"Virtual Machine not found"] if machines.empty?
-										
-					machines.each do |machine|						
-						
-						current_machine = machine.name.to_s						
-						
-						env = 
-						{							
-							:machine        => machine,
-							:machine_action => SnapshotAction::BACKUP,
-							:path						=> @env.data_dir
-						}
-						
-						@db.add_backup_log_entry(t,current_machine,BACKUP_IN_PROGRESS)
-		
-						res = @env.action_runner.run(SnapshotAction,env)
-						
-						if res[:bak_filename] == SnapshotAction::ERROR
-							@db.update_backup_log_entry(t,current_machine,BACKUP_ERROR)
-							return [500,"Internal Error"] if res[:bak_filename] == SnapshotAction::ERROR
-						else					
-							@db.update_backup_log_entry(t,current_machine,BACKUP_SUCCESS)
-							return [200,res[:bak_filename]]
-						end
+					current_machine = machine.name.to_s						
+					
+					env = 
+					{							
+						:machine        => machine,
+						:machine_action => SnapshotAction::BACKUP,
+						:path						=> @env.data_dir
+					}
+					
+					@db.add_backup_log_entry(t,current_machine,BACKUP_IN_PROGRESS)
+	
+					res = @env.action_runner.run(SnapshotAction,env)
+					
+					if res[:bak_filename] == SnapshotAction::ERROR
+						@db.update_backup_log_entry(t,current_machine,BACKUP_ERROR)
+						return [500,"Internal Error"] if res[:bak_filename] == SnapshotAction::ERROR
+					else					
+						@db.update_backup_log_entry(t,current_machine,BACKUP_SUCCESS)
+						return [200,res[:bak_filename]]
+					end
+					
+				end	
 						
-					end	
-							
-				rescue => e					
-					@db.update_backup_log_entry(t,current_machine,BACKUP_ERROR)
-					return [500,"Internal Error"]				
-				end
-				
+			rescue => e					
+				@db.update_backup_log_entry(t,current_machine,BACKUP_ERROR)
+				return [500,"Internal Error"]				
 			end
 			
-			################################################################
+		end
+		
+	  ################################################################
       ###################  NODE PASSWORD CHANGE    ###################
       ################################################################
-			def self.password_change(new_password)
-			  ensure_environment
-			  
-			  @db.node_password_set(new_password,true)
-			  true
-			end
+		def self.password_change(new_password)
+		  ensure_environment
+		  
+		  @db.node_password_set(new_password,true)
+		  true
+		end
+		
+		################################################################
+		#################  BACKUP LOG METHOD ###############
+		################################################################
+		#FIXME No está controlado el que el parámetro sea nil
+		def self.backup_log(vmname=nil)
+			ensure_environment				
 			
-			################################################################
-			#################  BACKUP LOG METHOD ###############
-			################################################################
-			#FIXME No está controlado el que el parámetro sea nil
-			def self.backup_log(vmname=nil)
-				ensure_environment				
-				
-				#begin
-				
-					@db.get_backup_log_entries(vmname)
-					
-				# rescue => e
-					# puts e.message									
-				# end
+			#begin
+			
+				@db.get_backup_log_entries(vmname)
 				
-			end
+			# rescue => e
+				# puts e.message									
+			# end
 			
+		end
 			
-			################################################################
+			
+	  ################################################################
       ######################  CONFIG SHOW METHOD #####################
       ################################################################
-			def self.config_show
-			    ensure_environment			    
-			    
-			    file = @env.root_path+"Vagrantfile"
-			end
+		def self.config_show
+		    ensure_environment			    
+		    
+		    file = @env.root_path+"Vagrantfile"
+		end
 			
-			 ################################################################
+	  ################################################################
       ######################  CONFIG UPLOAD METHOD #####################
       ################################################################
       def self.config_upload(cfile)
@@ -783,14 +1003,24 @@ module Vagrant
           true
       end
       
-      
+      ################################################################
+	  #######################  OPERATION METHODS #######################
+	  ################################################################
       def self.operation_queued(id)          
           ensure_environment
+          
           result = @db.get_queued_process_result(id)          
           
-          raise RestException.new(404,"The operation ID: #{id} not found") if result.empty?
+          raise RestException.new(404,"The operation ID: #{id} not found") if (result.size==0)
+          
+          opres = Array.new
+
+          aux=result.first          
+
+          opres[0]=aux["operation_status"]
+          opres[1]=aux["operation_result"]
           
-          result.first 
+          opres
       end
       
       def self.operation_queued_last          
@@ -803,69 +1033,82 @@ module Vagrant
       
 			
 			
-			################################################################
-			#######################  PRIVATE METHODS #######################
-			################################################################
-			private
-			
-			BACKUP_ERROR = "ERROR"
-			BACKUP_SUCCESS = "OK"
-			BACKUP_IN_PROGRESS = "IN PROGRESS"
-			
-			def self.ensure_environment
-				#Due to the fact that the enviroment data can change
-				#if we always use a stored value of env we won't be
-				#able to notice those changes 				
+		################################################################
+		#######################  PRIVATE METHODS #######################
+		################################################################
+		private
+		
+		BACKUP_ERROR = "ERROR"
+		BACKUP_SUCCESS = "OK"
+		BACKUP_IN_PROGRESS = "IN PROGRESS"
+		
+		def self.ensure_environment
+			#Due to the fact that the enviroment data can change
+			#if we always use a stored value of env we won't be
+			#able to notice those changes 				
 #				if (!@env)
 #					opts = {}					
 #					@env = Vagrant::Environment.new(opts)					
 #				end				
-				
-				opts = {}					
-				@env = Vagrant::Environment.new(opts)
-				@db = DB::DBManager.new(@env.data_dir) if (!@db)
-				@pw = PwManager.new(@db) if (!@pw)
-			end
 			
-			#FIXME REVISAR Y MEJORAR, LO HE HECHO DEPRISA PERO SE 
-			#PUEDE OPTIMIZAR
-			def self.get_vms(vmname)				
-				machines = []
-				provider=@env.default_provider
-							
-				if (vmname && !vmname.empty?)
-						#If a machine was specified launch only that machine									
-						name=vmname.to_sym
-					if (@env.machine_names.index(name)!=nil)
-						
-						@env.active_machines.each do |active_name, active_provider|
-												
-							if name==active_name							
-								provider=active_provider
-								break							
-							end
-																				
+			
+			
+			@env = ObManager.instance.reload_env
+			@db = ObManager.instance.dbmanager
+			@pw = ObManager.instance.pwmanager
+
+			#opts = {}					
+			#@env = Vagrant::Environment.new(opts)
+			#@db = DB::DBManager.new(@env.data_dir) if (!@db)
+			#@pw = PwManager.new(@db) if (!@pw)
+		end
+		
+		#FIXME REVISAR Y MEJORAR, LO HE HECHO DEPRISA PERO SE 
+		#PUEDE OPTIMIZAR
+		def self.get_vms(vmname)				
+			machines = []
+			provider=@env.default_provider
+		
+			
+			
+			if (vmname && !vmname.empty?)
+				#If a machine was specified launch only that machine									
+				name=vmname.to_sym
+
+				
+				if (@env.machine_names.index(name)!=nil)
+					
+					@env.active_machines.each do |active_name, active_provider|
+											
+						if name==active_name							
+							provider=active_provider
+							break							
 						end
-						machines << @env.machine(name,provider)
+																			
 					end
-	
-				else
-					#If no machine was specified launch all
-					@env.machine_names.each do |machine_name|
-							@env.active_machines.each do |active_name, active_provider|								
-								if active_name==machine_name
-									provider=active_provider
-									break
-								end
+					machines << @env.machine(name,provider)
+				end
+
+			else					
+
+				#If no machine was specified launch all
+				@env.machine_names.each do |machine_name|
+						@env.active_machines.each do |active_name, active_provider|								
+							if active_name==machine_name
+								provider=active_provider
 								
+								break
 							end
-							machines << @env.machine(machine_name,provider)
-					end			
-				end		
-				
-				machines
+							
+						end
+						machines << @env.machine(machine_name,provider)
+				end	
 				
-			end
+			end		
+			
+			machines
+			
+		end
 			
 		end
 	end