vagrant-node 1.0.0 → 1.1.1

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
 .bundle
+.svn
 Gemfile.lock
 pkg/*

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

@@ -0,0 +1,110 @@
+  require 'pp'
+require 'rubygems'
+require 'vagrant-node/util/downloader'
+require "vagrant/util/platform"
+require 'vagrant-node/obmanager'
+
+module Vagrant
+  module Node
+  	class BoxAddAction
+  		def initialize(app, env)
+          @app    = app          
+        end
+
+        def call(env)
+          @temp_path = env[:tmp_path].join("box" + Time.now.to_i.to_s)
+          
+
+          url = env[: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)
+            url = "file:#{file_path}"
+          end
+
+          downloader_options = {}
+          downloader_options[:callback] = env[:callback]
+          downloader_options[:insecure] = env[:box_download_insecure]
+          downloader_options[:ui] = env[:ui]
+          downloader_options[:db] = env[:db]
+          downloader_options[:box_name] = env[:box_name]
+
+
+
+
+          # Download the box to a temporary path. We store the temporary
+          # path as an instance variable so that the `#recover` method can
+          # access it.
+          #env[:ui].info(I18n.t("vagrant.actions.box.download.downloading"))
+          
+
+          begin
+            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])
+          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)        
+            
+            added_box = env[:box_collection].add(
+              @temp_path, env[:box_name], env[:box_provider], env[:box_force])
+            
+            error=false
+          rescue Vagrant::Errors::BoxUpgradeRequired
+            
+            error=true
+            # Upgrade the box
+            #@db.set_box_uncompression_error(last_id)            
+
+            env[:box_collection].upgrade(env[: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)
+
+          #env[:db].close_db_connection
+          # Call the 'recover' method in all cases to clean up the
+          # downloaded temporary file.
+          recover(env)
+
+          # Success, we added a box!
+          #env[:ui].success(
+           # I18n.t("vagrant.actions.box.add.added", name: added_box.name, provider: added_box.provider))
+
+          # Carry on!
+          @app.call(env)
+        end
+
+        def recover(env)
+          if @temp_path && File.exist?(@temp_path)
+            File.unlink(@temp_path)
+          end
+        end
+  	end
+  end
+end	
+

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

@@ -67,7 +67,7 @@ module Vagrant
 				#se produce un error y deja a la máquina en estado 'gurumeditating'
 				def driver.take_snapshot(name,description=" ")						
           
-          raise RestException.new(400,"Snapshot name can't be emtpy") if name.empty?						
+          			raise RestException.new(400,"Snapshot name can't be emtpy") if name.empty?						
 					
 					#Snapshots with the same name are not allowed
 					begin

data/lib/vagrant-node/api.rb

@@ -2,43 +2,35 @@ require 'rubygems'
 require 'sinatra'
 require 'json'
 require 'rack'
-require 'vagrant-node/clientcontroller'
+require_relative 'clientcontroller'
 require 'vagrant-node/apidesc'
 require 'vagrant-node/exceptions'
-
 require 'cgi'
-
 require 'pp'
+require 'vagrant-node/obmanager'
+
+
+
 module Vagrant
-	module Node
-		module ServerAPI
+module Node
+module ServerAPI
 			
-			class API < Sinatra::Base
-				include RestRoutes
-				COOKIE_TOKEN_ID = "TOKEN"
-				COOKIE_EXPIRATION_TIME = 5
-				def initialize
-				  super
-				  @session_table=Hash.new
-				end 
-				#use Rack::Session::Pool, :expire_after => 2592000
-				#enable :sessions
-				# before do 
-  					# content_type :json
-				# end
-				
-				
-				#UPLOAD A FILE
-#				post '/' do
-				#  tempfile = params['file'][:tempfile]
-				#  filename = params['file'][:filename]
-				#  File.copy(tempfile.path, "./files/#{filename}")
-				#  redirect '/'
-				#end		
-				
-				#before '^.*(^login).*' do
-			before %r{^(?!#{RouteManager.login_route}$)} do			
-			  content_type :json
+	class API < Sinatra::Base
+		include RestRoutes
+		COOKIE_TOKEN_ID = "TOKEN"
+		COOKIE_EXPIRATION_TIME = 5
+		
+		def initialize
+		  super
+		  @session_table=Hash.new
+		  #ObManager.instance.env=env		  
+
+		end 
+		
+		
+		#before '^.*(^login).*' do
+	before %r{^(?!#{RouteManager.login_route}$)} do			
+	  content_type :json
 			  #FIXME REMOVE	
         #puts "ENTRO BEFORE" 
         #pp request.env
@@ -46,7 +38,7 @@ module Vagrant
         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 
@@ -58,284 +50,325 @@ module Vagrant
         # pp "TIENE COOKIE " if (@session_table.has_key?(cookie))
         # pp "CONTIENE TOKEN " if (challenged?(token))
         
-			  if (!@session_table.has_key?(cookie)|| 
-			       !challenged?(token))			       				    		    
-			    redirect to(RouteManager.login_route)
-			    
-			  else
-			    #raise RestException.new(401,"Not authorized") if !authorized?(cookie,token)	    
-			    halt 401, "Not authorized\n" if !authorized?(cookie,token)
-			  end				   
-			  clear_session_table
-			end
-			
-			after %r{^(?!#{RouteManager.login_route}$)} do
-			 
-			 cookie=request.cookies[COOKIE_TOKEN_ID]
-			 
-			 @session_table.delete(cookie) if cookie!=nil
-			 #FIXME REMOVE
-			 #pp "-------------------------------------------"
-			end
+		  if (!@session_table.has_key?(cookie)|| 
+		       !challenged?(token))			       				    		    
+		  	
+		    redirect to(RouteManager.login_route)
+	        
+		  else
+		    #raise RestException.new(401,"Not authorized") if !authorized?(cookie,token)	    
+		    
+		    halt 401, "Not authorized\n" if !authorized?(cookie,token)
+	        
+		  end	
+		  
+		  clear_session_table
+			  
+	end
+	
+	after %r{^(?!#{RouteManager.login_route}$)} do
+	 
+	 cookie=request.cookies[COOKIE_TOKEN_ID]
+	 
+	 @session_table.delete(cookie) if cookie!=nil
+	 
+	end
 				
-			######### FIXME DELETE #####################			
-			get '/' do
-					"Hello World"
-			end		
 			
-			###############################################
-		  get RouteManager.login_route do		    
+  	get RouteManager.login_route do		    
+
         res = ClientController.send_challenge
-        #FIXME REMOVE
-        #puts "LOGIN"
-        
-        
-        #@session_table[res[:cookie]]={:expiration => Time::now.to_i,:challenge=>res[:challenge]}
-        #pp res[:cookie]
         @session_table[res[:cookie]]={:expiration => Time::now.to_i+COOKIE_EXPIRATION_TIME,:challenge=>res[:challenge]}
-        #pp @session_table.inspect
-        
         response.set_cookie(COOKIE_TOKEN_ID, res[:cookie])        
         headers "Content_MD5"   => res[:challenge]        
+
         status 200  	    
         
-		    #handle_response_result(ClientController.send_challenge)
-		  end
-		  
-			get RouteManager.box_list_route	do				
-				#ClientController.listboxes.to_json
-				execute(:listboxes)
-			end
-
-			delete RouteManager.box_delete_route do			  					
-				#handle_response_result(ClientController.box_delete("params[:box]",params[:provider]))				
-				execute(:box_delete,true,params[:box],params[:provider])
-			end				
-			
-			post RouteManager.box_add_route do			  
-				execute_async(:box_add,params[:box],params[:url])
-			end
-			
-				
-								
-			get RouteManager.vm_status_all_route do
-				#handle_response_result(ClientController.vm_status(nil))
-				execute(:vm_status)
-			end
-			
-				
+	    #handle_response_result(ClientController.send_challenge)
+ 	end
+	
+ 	get RouteManager.node_info_route	do						
+		execute(:nodeinfo)
+	end
 
-			get RouteManager.vm_status_route do
-				#handle_response_result(ClientController.vm_status(params[:vm]))
-				execute(:vm_status,true,params[:vm])
-			end
-			
-			#accept :vmname as paramter. This parameter
-			#could be empty
-			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])        
-			end
+	get RouteManager.box_list_route	do						
+		execute(:listboxes)
+	end
+
+	get RouteManager.box_download_route	do												
+		execute(:listdownloadboxes)
+	end
+
+	delete RouteManager.box_download_route	do								
+		execute(:cleardownloadboxes)
+	end
+
+	delete RouteManager.box_delete_route do			  							
+		execute(:box_delete,true,params[:box],params[:provider])
+	end				
+	
+	post RouteManager.box_add_route do			  
+		execute_async(:box_add,params[:box],params[:url])
+	end
+	
+		
+						
+	get RouteManager.vm_status_all_route do				
+		#handle_response_result(ClientController.vm_status(nil))				
+		execute(:vm_status,true,nil,((params[:verbose]==nil || params[:verbose]=="1" || params[:verbose]=="true")?true:false))
+		
+	end
+	
+	get RouteManager.vm_info_route do		
+		execute(:vm_info,true,params[:vm])
+	end	
 				
-			#accept :vmname as paramter. This parameter
-			#could be empty
-			post RouteManager.vm_destroy_route do
-				#handle_response_result(ClientController.vm_confirmed_destroy(params[:vmname]))
-				execute(:vm_confirmed_destroy,true,params[:vmname])        
-			end
+
+	get RouteManager.vm_status_route do				
+		#handle_response_result(ClientController.vm_status(params[:vm]))										
+		execute(:vm_status,true,params[:vm],((params[:verbose]==nil || params[:verbose]=="1" || params[:verbose]=="true")?true:false))
+	end
+	
+	#accept :vmname as paramter. This parameter
+	#could be empty
+	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])        
+	end
+		
+	#accept :vmname as paramter. This parameter
+	#could be empty
+	post RouteManager.vm_destroy_route do
+		#handle_response_result(ClientController.vm_confirmed_destroy(params[:vmname]))
+		execute(:vm_confirmed_destroy,true,params[:vmname])        
+	end
 			
-			put RouteManager.vm_add_route do			  
+	put RouteManager.vm_add_route do			  
         execute(:vm_add,false,params[:file],params[:rename])        
-      end
+	end
       
-      delete RouteManager.vm_delete_route do
-        execute(:vm_delete,false,params[:vm],params[:remove])
-      end
-				
-			#accept :vmname as paramter. This parameter
-			#could be empty
-			post RouteManager.vm_suspend_route do				
-				#handle_response_result(ClientController.vm_suspend(params[:vmname]))
-				execute_async(:vm_suspend,params[:vmname])        
-			end
-				
-			#accept :vmname as paramter. This parameter
-			#could be empty
-			post RouteManager.vm_resume_route do					
-				#handle_response_result(ClientController.vm_resume(params[:vmname]))
-				execute_async(:vm_resume,params[:vmname])        
-			end
-			
-			post RouteManager.vm_provision_route do
-				#handle_response_result(ClientController.vm_provision(params[:vmname]))
-				execute_async(:vm_provision,params[:vmname])        
-			end
-				
-				
-				
-			get RouteManager.vm_sshconfig_route do				
-				#handle_response_result(ClientController.vm_ssh_config(params[:vm]))
-				execute(:vm_ssh_config,true,params[:vm])        
-			end
+	delete RouteManager.vm_delete_route do
+		execute(:vm_delete,false,params[:vm],params[:remove])
+	end
 				
-			get RouteManager.snapshots_all_route do
-				#handle_response_result(ClientController.vm_snapshots(nil))
-				execute(:vm_snapshots,true)        
-			end
+	#accept :vmname as paramter. This parameter
+	#could be empty
+	post RouteManager.vm_suspend_route do				
+		#handle_response_result(ClientController.vm_suspend(params[:vmname]))
+		execute_async(:vm_suspend,params[:vmname])        
+	end
+		
+	#accept :vmname as paramter. This parameter
+	#could be empty
+	post RouteManager.vm_resume_route do					
+		#handle_response_result(ClientController.vm_resume(params[:vmname]))
+		execute_async(:vm_resume,params[:vmname])        
+	end
+	
+	post RouteManager.vm_provision_route do
+		#handle_response_result(ClientController.vm_provision(params[:vmname]))
+		execute_async(:vm_provision,params[:vmname])        
+	end
+		
+		
+		
+	get RouteManager.vm_sshconfig_route do				
+		#handle_response_result(ClientController.vm_ssh_config(params[:vm]))
+		execute(:vm_ssh_config,true,params[:vm])        
+	end
+		
+	get RouteManager.snapshots_all_route do
+		#handle_response_result(ClientController.vm_snapshots(nil))
+		execute(:vm_snapshots,true)        
+	end
 			
 					
+	
+	get RouteManager.vm_snapshots_route do
+		#handle_response_result(ClientController.vm_snapshots(params[:vm]))
+		execute(:vm_snapshots,true,params[:vm])        
+	end
+	
+	get RouteManager.vm_snapshot_take_route do														
+		#result=ClientController.vm_snapshot_take_file(params[:vmname])
+		result=execute(:vm_snapshot_take_file,false,params[:vmname])
+		
 			
-			get RouteManager.vm_snapshots_route do
-				#handle_response_result(ClientController.vm_snapshots(params[:vm]))
-				execute(:vm_snapshots,true,params[:vm])        
-			end
+		send_file "#{result[1]}", :filename => result[1], 
+							:type => 'Application/octet-stream' if result[0]==200 && params[:download]=="true"
+		
+		status result[0]
 			
-			get RouteManager.vm_snapshot_take_route do														
-				#result=ClientController.vm_snapshot_take_file(params[:vmname])
-				result=execute(:vm_snapshot_take_file,false,params[:vmname])
-				
-					
-				send_file "#{result[1]}", :filename => result[1], 
-									:type => 'Application/octet-stream' if result[0]==200 && params[:download]=="true"
-				
-				status result[0]
-					
-			end
+	end
 			
 						
-			post RouteManager.vm_snapshot_take_route do			  
-					#handle_response_result(ClientController.vm_snapshot_take(params[:vmname],params[:name],params[:desc]))					
-					execute_async(:vm_snapshot_take,params[:vmname],params[:name],params[:desc])					      
-			end
-			
-			
-			post RouteManager.vm_snapshot_restore_route do
-					#handle_response_result(ClientController.vm_snapshot_restore(params[:vmname],params[:snapid]))					
-					execute_async(:vm_snapshot_restore,params[:vmname],params[:snapid])
-			end
+	post RouteManager.vm_snapshot_take_route do			  
+			#handle_response_result(ClientController.vm_snapshot_take(params[:vmname],params[:name],params[:desc]))					
+			execute_async(:vm_snapshot_take,params[:vmname],params[:name],params[:desc])					      
+	end
+	
+	
+	post RouteManager.vm_snapshot_restore_route do
+			#handle_response_result(ClientController.vm_snapshot_restore(params[:vmname],params[:snapid]))					
+			execute_async(:vm_snapshot_restore,params[:vmname],params[:snapid])
+	end
 			
-			delete RouteManager.vm_snapshot_delete_route do
+	delete RouteManager.vm_snapshot_delete_route do
         execute(:vm_snapshot_delete,false,params[:vm],params[:snapid])
-      end
-			
+	end
 			
-			get RouteManager.vm_backup_log_route do
-				#handle_response_result(ClientController.backup_log(params[:vm]))
-				execute(:backup_log,true,params[:vm])
-			end
 			
+	get RouteManager.vm_backup_log_route do
+		#handle_response_result(ClientController.backup_log(params[:vm]))
+		execute(:backup_log,true,params[:vm])
+	end
+	
 				
 
-			get RouteManager.node_backup_log_route do
-				#handle_response_result(ClientController.backup_log(nil))
-				execute(:backup_log,true)
-			end
+	get RouteManager.node_backup_log_route do
+		#handle_response_result(ClientController.backup_log(nil))
+		execute(:backup_log,true)
+	end
 			
 			
-			get RouteManager.config_show_route do
-			  result= execute(:config_show,false)
-			  #result=ClientController.config_show  
-        
+	get RouteManager.config_show_route do
+		result= execute(:config_show,false)
+	    #result=ClientController.config_show          
         send_file(result, :disposition => 'attachment', :filename => result)          
                         
-      end
-			
-			post RouteManager.node_password_change_route do
-			  execute(:password_change,false,params[:password])
-			end
-			
-			post RouteManager.config_upload_route do			  
-			  execute(:config_upload,false,params[:file])
-			end
-			
-			get RouteManager.node_queue_route do			  
-			  execute(:operation_queued,true,params[:id])
-			end
+  	end
 			
-			get RouteManager.node_queue_last_route do			  
-        execute(:operation_queued_last,true)
-      end
+	post RouteManager.node_password_change_route do
+	  execute(:password_change,false,params[:password])
+	end
+
+	post RouteManager.config_upload_route do			  
+	  execute(:config_upload,false,params[:file])
+	end
+
+	get RouteManager.node_queue_route do			  				
+	  execute(:operation_queued,true,params[:id])
+	end
+
+	get RouteManager.node_queue_last_route do			  
+		execute(:operation_queued_last,true)
+	end
 			
 			
 				
-			private
-			  def clear_session_table			   
-			   @session_table.delete_if {|key,value| Time::now.to_i >= value[:expiration]}
-			  end
-			  
-			  #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
-            body "Location: #{result}"
-            # body "Location: #{result}".to_json                        
-            
-          rescue => e          
-            #FIXME DELETE PUTS
-            #puts "EN EXCEPCION"
-             puts e.class
-             puts e.message
-             
-            
-             exception = ((e.class==RestException)? e:ExceptionMutator.new(e))           
-            
-             halt exception.code,exception.message           
-          end
-          
-        end     
+private
+	def clear_session_table			   
+		
+		@session_table.delete_if {|key,value| Time::now.to_i >= value[:expiration]}
+
+	end
+
+	#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
+		body "Location: #{result}"
+		# body "Location: #{result}".to_json                        
+
+		rescue => e          
+		#FIXME DELETE PUTS
+		 #puts "EN EXCEPCION"
+		 puts e.class
+		 puts e.message
+		 
+
+		 exception = ((e.class==RestException)? e:ExceptionMutator.new(e))           
+
+		 halt exception.code,exception.message           
+		end
+
+	end     
 			  
-			  #def execute(method,params = {} ,to_json = true)
-			  def execute(method,to_json = true,*params)
-			    begin	
-			      if params.empty?
-			        result=ClientController.send method.to_sym
-			      else			        
-			        result=ClientController.send method.to_sym,*params
-			      end
-            #puts "TERMINADA LA OPERACION"
+	  #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
+	      else			        
+	        result=ClientController.send method.to_sym,*params
+	      end			      	
             #puts "A JSON " if to_json
             #puts "resultado #{result}"
             return result.to_json if to_json
             result
-            
-			    rescue => e			     
-			      #puts "EN EXCEPCION"
-			       puts e.class
-			      puts e.message
-			       
-			      
-			      exception = ((e.class==RestException)? e:ExceptionMutator.new(e))			      
-			      
-			      halt exception.code,exception.message			      
-			    end
-			    
-			  end		  
+    
+	    rescue => e			     	      
+	      #puts "EN EXCEPCION1"
+	      
+	      
+	      if (e.class==Vagrant::Errors::VirtualBoxNotDetected)
+	      	#puts "******* SE HA GENERADO LA EXCEPCION VIRTUALBOXNOTDETECTED ******"
+	      	
+
+	      	restart_server
+	      	halt 503,"Node had a problem. Restarting. Try again in a few seconds"
+	      	return
+	      	#env[:machine].provider.driver
+			#system("vagrant nodeserver stop;sleep 10;vagrant nodeserver start")
+	      end
+
+	      puts e.class
+	      puts e.message
+	      
+	      exception = ((e.class==RestException)? e:ExceptionMutator.new(e))			      
+	      
+	      halt exception.code,exception.message			      
+	    end
+	    
+	end		  
 			  
+
+	def restart_server
+
+		#puts Process.pid
+
+		# pid = fork do						
+		# 	#system( "vagrant nodeserver stop;sleep 10;vagrant nodeserver start" );
+		# 	#system("vagrant nodeserver stop;sleep 10;vagrant nodeserver start")
+		# 	system("sleep 15");			
+		# end
+		# puts "EL PID ES #{pid}"
+		
+		# Process.kill('KILL', 0)
+		Process.kill('USR1', 0)
+	end
 			  
   			
-  			def authorized?(id,token)  			  
-  			  @session_table[id][:challenge]
-  			  ClientController.authorized?(token,@session_table[id][:challenge]) if @session_table.has_key?(id)
-  			end
-  			
-  			def challenged?(token)
-  			  (token!=nil && token.size==32) 
-  			end
-				
-			end
-		end
+	def authorized?(id,token)  			
+		
+	  @session_table[id][:challenge]
+	  ClientController.authorized?(token,@session_table[id][:challenge]) if @session_table.has_key?(id)
 	end
-end
+	
+	def challenged?(token)
+		
+	  (token!=nil && token.size==32) 
+	end
+				
+	end # API CLASS
+
+end #module Vagrant
+end #module Node
+end #module ServerAPI