vagrant-node 1.1.1 → 1.1.3

data/README.md

@@ -4,11 +4,11 @@ vagrant-node
 This plugin allows you to set a computer with a virtual environment, configured with Vagrant, to be controlled and managed remotely. The remote machine must have installed the controller plugin, [Vagrant-NodeMaster](https://github.com/fjsanpedro/vagrant-nodemaster/tree/master/lib/vagrant-nodemaster).
 
 With this plugin installed, the Vagrant environment can perform requests, that you usually can execute locally, but commanded by a remote computer. This service is provided through a REST API that this plugin exposes.
-
+	
 This plugin has been developed in the context of the [Catedra SAES](http://www.catedrasaes.org) of the University of Murcia(Spain).
 
 ##Installation
-Requires Vagrant 1.2 and libsqlite3-dev
+Requires Vagrant (minimum version 1.2.2) and MySql Server
 
 ```bash
 $ vagrant plugin install vagrant-node

data/lib/vagrant-node/actions/boxadd.rb

@@ -1,4 +1,4 @@
-  require 'pp'
+require 'pp'
 require 'rubygems'
 require 'vagrant-node/util/downloader'
 require "vagrant/util/platform"
@@ -11,11 +11,17 @@ module Vagrant
           @app    = app          
         end
 
-        def call(env)
+        def download_boxes(env)
           @temp_path = env[:tmp_path].join("box" + Time.now.to_i.to_s)
           
+          result=ObManager.instance.dbmanager.get_box_to_download          
+          
+          next_id=result["id"]          
+          
+          next_box_name = result["box_name"]
 
-          url = env[:box_url]
+          url = result["box_url"]
+          
           if File.file?(url) || url !~ /^[a-z0-9]+:.*$/i          
             file_path = File.expand_path(url)
             file_path = Util::Platform.cygwin_windows_path(file_path)
@@ -27,7 +33,7 @@ module Vagrant
           downloader_options[:insecure] = env[:box_download_insecure]
           downloader_options[:ui] = env[:ui]
           downloader_options[:db] = env[:db]
-          downloader_options[:box_name] = env[:box_name]
+          downloader_options[:box_name] = next_box_name
 
 
 
@@ -39,34 +45,29 @@ module Vagrant
           
 
           begin
-            downloader = Util::Downloader.new(url, @temp_path, downloader_options)
+            downloader = Util::Downloader.new(url, @temp_path, downloader_options)             
             downloader.download!            
+            
           rescue Errors::DownloaderInterrupted
             # The downloader was interrupted, so just return, because that
             # means we were interrupted as well.
             #env[:ui].info(I18n.t("vagrant.actions.box.download.interrupted"))
             return          
           rescue Errors::DownloaderError => msg
-            #puts msg.message.split(/\r\n/).inspect.length
-
-            #puts "CONTROLAR ESTE MENSAJE DE ERROR"
-            
-
             return
           end
 
-          # Add the box
-          #env[:ui].info I18n.t("vagrant.actions.box.add.adding", :name => env[:box_name])
+          # Add the box          
           added_box = nil
           error=false
 
           begin
-
-            #last_id=env[:db].add_box_uncompression(env[:box_name],url)        
-            last_id=ObManager.instance.dbmanager.add_box_uncompression(env[:box_name],url)        
             
+            #last_id=env[:db].add_box_uncompression(env[:box_name],url)        
+            ObManager.instance.dbmanager.add_box_uncompression(next_id)
+              
             added_box = env[:box_collection].add(
-              @temp_path, env[:box_name], env[:box_provider], env[:box_force])
+              @temp_path, next_box_name, env[:box_provider], env[:box_force])
             
             error=false
           rescue Vagrant::Errors::BoxUpgradeRequired
@@ -75,22 +76,30 @@ module Vagrant
             # Upgrade the box
             #@db.set_box_uncompression_error(last_id)            
 
-            env[:box_collection].upgrade(env[:box_name])
+            env[:box_collection].upgrade(next_box_name)
 
             # Try adding it again
             retry
           end
 
 
-          #env[:db].clear_box_uncompression(last_id) if (error==false)
-          #env[:db].clear_box_uncompression(last_id)
-          ObManager.instance.dbmanager.clear_box_uncompression(last_id)
+          
+          ObManager.instance.dbmanager.clear_box_uncompression(next_id)
 
           #env[:db].close_db_connection
           # Call the 'recover' method in all cases to clean up the
           # downloaded temporary file.
           recover(env)
+        end
+
+        def call(env)
 
+
+          while ObManager.instance.dbmanager.are_boxes_queued
+            download_boxes(env)
+          end
+
+          
           # Success, we added a box!
           #env[:ui].success(
            # I18n.t("vagrant.actions.box.add.added", name: added_box.name, provider: added_box.provider))

data/lib/vagrant-node/actions/snapshot.rb

@@ -281,30 +281,5 @@ module Vagrant
   end
 end
 
-#				def driver.list
-#						puts "LISTING SNAPSHOT"
-#						begin
-#						snapshots = []
-#						puts "UUID #{self.uuid}"
-#						execute("snapshot",self.uuid,"list").split("\n").each do |line|
-#							snapshot = {}							
-#
-#							if line =~ /Name:\s(.*?)\s\(UUID:\s(.*?)\)$/								
-#								snapshot[:name] = $1
-#								snapshot[:id] = $2
-#								snapshot[:current_state] = false						 	
-#						 	elsif line =~ /Name:\s(.*?)\s\(UUID:\s(.*?)\)\s\*$/						
-#								snapshot[:name] = $1
-#								snapshot[:id] = $2
-#								snapshot[:current_state] = true
-#						 	end					
-#						 	snapshots.push(snapshot)		
-#						end
-#						rescue Exception => e
-#							puts e.message
-#						end
-#						
-#						puts snapshots
-#						return snapshots
-#				end
+
 				

data/lib/vagrant-node/api.rb

@@ -31,24 +31,17 @@ module ServerAPI
 		#before '^.*(^login).*' do
 	before %r{^(?!#{RouteManager.login_route}$)} do			
 	  content_type :json
-			  #FIXME REMOVE	
-        #puts "ENTRO BEFORE" 
-        #pp request.env
+			  
         token  = ""
         cookie = ""
         
-        #pp "TOKEN DESCAPADO = #{CGI::unescape(request.env['HTTP_CONTENT_MD5'])}"
+        
 
         
         cookie = request.cookies[COOKIE_TOKEN_ID]        
         token = CGI::unescape(request.env['HTTP_CONTENT_MD5']) if request.env['HTTP_CONTENT_MD5']!=nil 
         
-        #FIXME REMOVE
-        # pp "COOKIES = #{cookie}"
-        # pp "TOKEN = #{token}"
-#                                   
-        # pp "TIENE COOKIE " if (@session_table.has_key?(cookie))
-        # pp "CONTIENE TOKEN " if (challenged?(token))
+        
         
 		  if (!@session_table.has_key?(cookie)|| 
 		       !challenged?(token))			       				    		    
@@ -131,14 +124,14 @@ module ServerAPI
 	
 	#accept :vmname as paramter. This parameter
 	#could be empty
-	post RouteManager.vm_up_route do		  
-	  execute_async(:vm_up,params[:vmname])
+	post RouteManager.vm_up_route do	  		  
+		execute_async(:vm_up,params[:vmname])	  	
 	end
 		
 	#accept :vmname and :force as paramters
 	post RouteManager.vm_halt_route do
 		#handle_response_result(ClientController.vm_halt(params[:vmname],params[:force])
-		execute_async(:vm_halt,params[:vmname],params[:force])        
+		execute_async(:vm_halt,params[:vmname],params[:force])        		
 	end
 		
 	#accept :vmname as paramter. This parameter
@@ -271,13 +264,13 @@ private
 	#FIXME Factorizar estos dos métodos
 	def execute_async(method,*params)
 		begin 
-			
+		
 		if params.empty?
 		  result=ClientController.send method.to_sym
 		else              
 		  result=ClientController.send method.to_sym,*params
 		end
-
+		
 
 		#pp result
 		status 202
@@ -287,8 +280,8 @@ private
 		rescue => e          
 		#FIXME DELETE PUTS
 		 #puts "EN EXCEPCION"
-		 puts e.class
-		 puts e.message
+		 # puts e.class
+		 # puts e.message
 		 
 
 		 exception = ((e.class==RestException)? e:ExceptionMutator.new(e))           
@@ -301,17 +294,15 @@ private
 	  #def execute(method,params = {} ,to_json = true)
 	def execute(method,to_json = true,*params)
 	    begin	
-
+	    
 	      #raise Vagrant::Errors::VirtualBoxNotDetected
 
 	      if params.empty?
-	        result=ClientController.send method.to_sym
+	        result=ClientController.send method.to_sym	        
 	      else			        
-	        result=ClientController.send method.to_sym,*params
+	        result=ClientController.send method.to_sym,*params	        
 	      end			      	
-            #puts "A JSON " if to_json
-            #puts "resultado #{result}"
-            return result.to_json if to_json
+            return result.to_json.gsub("\n"," ") if to_json
             result
     
 	    rescue => e			     	      
@@ -321,6 +312,7 @@ private
 	      if (e.class==Vagrant::Errors::VirtualBoxNotDetected)
 	      	#puts "******* SE HA GENERADO LA EXCEPCION VIRTUALBOXNOTDETECTED ******"
 	      	
+	      	@env = ObManager.instance.reload_env
 
 	      	restart_server
 	      	halt 503,"Node had a problem. Restarting. Try again in a few seconds"
@@ -329,8 +321,8 @@ private
 			#system("vagrant nodeserver stop;sleep 10;vagrant nodeserver start")
 	      end
 
-	      puts e.class
-	      puts e.message
+	      # puts e.class
+	      # puts e.message
 	      
 	      exception = ((e.class==RestException)? e:ExceptionMutator.new(e))			      
 	      

data/lib/vagrant-node/clientcontroller.rb

@@ -7,7 +7,8 @@ require 'vagrant-node/pwmanager'
 require 'vagrant-node/exceptions.rb'
 require 'vagrant-node/configmanager'
 require 'vagrant-node/obmanager'
-require 'usagewatch'
+require 'vagrant-node/util/hwfunctions'
+#require 'usagewatch'
 require "sys/cpu"
 require 'facter'
 
@@ -36,7 +37,7 @@ module Vagrant
 			  pid = fork do
 			    begin
 			     @db.create_queued_process(rpid)			     
-			     res = yield			     
+			     res = yield					     
 			     @db.set_queued_process_result(rpid,res.to_json)		     
 			     
 			    rescue Exception => e				      		    
@@ -64,22 +65,44 @@ module Vagrant
 			################################################################
 			#######################  NODE INFO (CPU,MEMORY) ################
 			################################################################			
+
 			def self.nodeinfo
 				
 				
-  				usw = Usagewatch
+  				#usw = Usagewatch
 
-				
-  				Facter.loadfacts
+				begin
+					Facter.loadfacts
 
-  				
-  				
-  				result=Hash[Facter.to_hash.map{|(k,v)| [k.to_sym,v]}]
+	  				mem_values = Util::HwFunctions.get_mem_values
+
+	  				disk_values = Util::HwFunctions.get_disk_values 				
+	  				
 
-  				result[:cpuaverage] = Sys::CPU.load_avg;
-  				result[:diskusage] = usw.uw_diskused
+	  				
+	  				result=Hash[Facter.to_hash.map{|(k,v)| [k.to_sym,v]}]
 
-  				result	
+	  				
+	  				#Overriding memory values of Facter  				
+	  				result[:memorysize] = (mem_values[0] / 1024.0).round(2) #Converting to GB and rounding
+	  				result[:memoryfree] = (mem_values[1] / 1024.0).round(2) #Converting to GB
+	  				result[:memorysize_mb] = mem_values[0]
+	  				result[:memoryfree_mb] = mem_values[1]
+	  				 
+	  				
+
+	  				result[:cpuaverage] = Sys::CPU.load_avg;
+	  				#result[:diskusage] = usw.uw_diskused
+	  				result[:diskusage] = disk_values
+
+	  				result[:vagrant_version] = Vagrant::VERSION
+
+	  				result	
+
+				rescue Exception => e
+					raise RestException.new(500,"Error gathering node hardware information")
+				end
+  				
 			
 				
 			end			
@@ -134,11 +157,16 @@ module Vagrant
   				boxes = @env.boxes.all.sort				
   				
   				fboxes = Array.new				
-  				boxes.each do |name, provider|					
-  					fboxes << {"name" => name,"provider" => provider}
+
+  				#From version 1.6.5 (I'think) the box array is different from previous ones
+  				boxes.each do |entry|					  					
+  					if entry.size==3
+  						fboxes << {"name" => entry[0],"provider" => entry[2]}
+  					else
+  						fboxes << {"name" => entry[0],"provider" => entry[1]}
+  					end
   				end
   				
-  				
   				fboxes		
 			
 				
@@ -180,163 +208,144 @@ module Vagrant
 			################################################################
 			########################  BOX ADD METHOD #######################
 			################################################################			
-			def self.box_add(box,url,user="guest",pass="--no-pass")
+			# def self.box_add(box,url,user="guest",pass="--no-pass")
 
-				@env.boxes.all.each do |box_name,provider|
+				
+			# 	@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
+				
+			# 	#Adding the box to the list
+			# 	@db.add_box_download_info(box,url)
 
-					if box_name==box
-						raise RestException.new(500,"There is a box with the same name")	
-					end					
-				end
 
+			# 	#If the box is downloading or there isn't any box return
+			# 	return [] if (@db.is_box_downloading)				
+					
 				
 
-				command_block = Proc.new {
-                  				#ensure_environment
+			# 	command_block = Proc.new {  
+   #                				#ensure_environment
                   				
-                  				boxes = []			
+   #                				boxes = []			
                   
-                  				#TODO
                   				
-                  				# Get the provider if one was set
-                  				provider = nil
-                  #				provider = options[:provider].to_sym if options[:provider]
+                  				
+   #                				# Get the provider if one was set
+   #                				provider = nil
+   #                #				provider = options[:provider].to_sym if options[:provider]
                   
-                  				begin
+   #                				begin
                   					
-                  					#uri = "\\\\155.54.190.227\\boxtmp\\boxes\\debian_squeeze_32.box"
-                  #					
-                  #					if uri=~ /^\\\\(.*?)\\(.*?)\\(.*?)$/						
-                  #						puts "EL HOST ES #{$1}"
-                  #						puts "EL Share ES #{$2}"
-                  #						puts "EL PATH ES #{$3}"
-                  #						host = $1
-                  #						share = $2
-                  #						path = $3
-                  #						
-                  #						Getting and checking box file						
-                  #						boxname=File.basename(path.gsub('\\',File::SEPARATOR))
-                  #						
-                  #            raise 'Box file format not supported' if File.extname(boxname)!=".box"
-                  #
-                  #						samba = nil
-                  #						begin						
-                  #						samba = Sambal::Client.new(  :host     =>  host,
-                  #																				:share    =>  share,
-                  #																				:user     =>  user,
-                  #																				:password =>  pass)
-                  #					
-                  #						
-                  #						
-                  #						Get the tmp file name					
-                  #						temp_path = @env.tmp_path.join("box" + Time.now.to_i.to_s)
-                  #				
-                  #					
-                  #						response = nil
-                  #						
-                  #						smbclient //155.54.190.227/boxtmp --no-pass -W WORKGROUP -U guest -p 445
-                  #						smbclient //155.54.190.227/boxtmp -D boxes -c "get debian_squeeze_321.box" -N
-                  #						
-                  #						command="smbclient //#{host}/#{share} -D #{dirlocation} -c \"get #{boxname}\" -U #{user} --no-pass"
-                  #						
-                  #
-                  #						FIXME encontrar si existe algún tipo de notificación por
-                  #						interrupciónde la descarga
-                  #						FIXME a little hack beacuse in version 0.1.2 of sambal there is 
-                  #						a timeout that close the download after 10 seconds 
-                  #						def samba.ask(cmd)							
-                  #							@i.printf("#{cmd}\n")
-                  #							response = @o.expect(/^smb:.*\\>/)[0]				
-                  #						end
-                  #						
-                  #						response = samba.get(path, temp_path.to_s)
-                  #						FIXME DELETE
-                  #						pp response.inspect						
-                  #						
-                  #						raise response.message if !response.success?
-                  #						
-                  #						if response.success?								
-                  #								File download succesfully
-                  #								added_box = nil
-                  #								begin									
-                  #									provider=nil
-                  #									force = true
-                  #									added_box = @env.boxes.add(temp_path,box,nil,force)									
-                  #									boxes << {:name=>box,:provider=>added_box.provider.to_s}
-                  #								rescue Vagrant::Errors::BoxUpgradeRequired									
-                  #									Upgrade the box
-                  #									env.boxes.upgrade(box)
-                  #			
-                  #									Try adding it again
-                  #									retry
-                  #								rescue Exception => e									
-                  #									boxes = nil
-                  #								end
-                  #													
-                  #						end
-                  #						
-                  #						rescue Exception => e
-                  #							puts "EXCEPCION de descarga" if response
-                  #							puts "EXCEPCION de conexion" if !response
-                  #							puts e.message
-                  #							boxes=nil
-                  #						end
-                  #						
-                  #						
-                  #						Closing connection
-                  #						samba.close if samba
-                  #						
-                  #						
-                  #						Cleaning
-                  #						if temp_path && File.exist?(temp_path)
-                  #            	File.unlink(temp_path)
-                  #          	end
-                  # 
-                  #          	          		 
-                  #					else
+                 
                   
                            
-                            copy_db = @db.clone
+   #                          	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
+   #                            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(BoxAddAction, {
-								                              :box_name     => box,
-								                              :box_provider => provider,
-								                              :box_url      => url,
-								                              :box_force    => force,
-								                              :box_download_insecure => insecure,
-								                              :db => copy_db,
-								                            	})
+   #                						@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
-                  
+                  						
                   
 					     
 					     
+   #                				puts "HA TERMINADO LA ACCION"
+		                                      	
+			# 	              	boxes					     
+						     
+			# 		rescue =>e
+			# 				puts e.message
+			# 		end
+
+			# 	}
+
+   #      		method("execute_queued").call(&command_block);
+				
+			# end
+
+			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
+                  				
+                  				boxes = []			
+                  				boxes <<{:name=>box}
+                  				#Adding the box to the list
+								@db.add_box_download_info(box,url)
+
+
+								#If the box is downloading or there isn't any box return
+								if (!@db.is_box_downloading)			
+                  				
+	                  				# Get the provider if one was set
+	                  				provider = nil                  
+	                  
+	                  				begin
+	                  					
+	                 
+	                  
+	                           
+		                            	copy_db = @db.clone
+		                            
+		                           
+
+		                              	#boxes <<{:name=>box}
+
+		          
+		          						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(BoxAddAction, {	
+		          											  :box_provider => provider,						                              
+								                              :box_force    => force,
+								                              :box_download_insecure => insecure,
+								                              :db => copy_db,
+								                            	})
 
-                                      
-	              	boxes					     
 						     
-					rescue =>e
-							puts e.message
-					end
+	                  				
+			                                      	
+					              						     
+						     
+									rescue =>e
+											puts e.message
+									end
+
+									boxes
+
+								end
 
 				}
 
@@ -351,7 +360,7 @@ module Vagrant
 			################################################################
 			def self.vm_up(vmname)	
 			
-				
+					
 
 			  	command_block = Proc.new {					
 					
@@ -382,7 +391,7 @@ module Vagrant
 						end           
 				
 						raise RestException.new(404,"The machine #{vmname} does not exist") if (machine_names.empty?)						
-
+						
 						machine_names
 
 					rescue Exception => e  	
@@ -511,7 +520,7 @@ module Vagrant
 					end
 
 					raise RestException.new(404,"The machine #{vmname} does not exist") if (machine_names.empty?)						
-
+					
 					machine_names
 
 				rescue Exception => e  						
@@ -1015,19 +1024,37 @@ module Vagrant
           
           opres = Array.new
 
+          
+          
+
           aux=result.first          
+          
+
+
 
           opres[0]=aux["operation_status"]
           opres[1]=aux["operation_result"]
           
+          
+
           opres
       end
       
       def self.operation_queued_last          
           ensure_environment
           
-          @db.get_queued_last         
-           
+          opres = Array.new
+
+          result=@db.get_queued_last         
+          
+          result.each do |row|
+          	aux=Array.new
+          	aux[0]=row["operation_status"]
+          	aux[1]=row["operation_result"]
+          	opres << aux
+          end
+          
+          opres
       end