vagrant-node 0.0.2 → 1.0.0

data/lib/vagrant-node/api.rb

@@ -4,7 +4,9 @@ require 'json'
 require 'rack'
 require 'vagrant-node/clientcontroller'
 require 'vagrant-node/apidesc'
+require 'vagrant-node/exceptions'
 
+require 'cgi'
 
 require 'pp'
 module Vagrant
@@ -12,10 +14,18 @@ module Vagrant
 		module ServerAPI
 			
 			class API < Sinatra::Base
-				include RestRoutes 
-				before do 
-  					content_type :json
-				end
+				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
@@ -26,10 +36,47 @@ module Vagrant
 				#  redirect '/'
 				#end		
 				
-				
-#				before '/admin/*' do
-#  				authenticate!
-#				end
+				#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))			       				    		    
+			    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
 				
 			######### FIXME DELETE #####################			
 			get '/' do
@@ -37,122 +84,256 @@ module Vagrant
 			end		
 			
 			###############################################
-				
+		  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
+				#ClientController.listboxes.to_json
+				execute(:listboxes)
 			end
 
-			delete RouteManager.box_delete_route do					
-				handle_response_result(ClientController.box_delete(params[:box],params[:provider]))
+			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					
-				handle_response_result(ClientController.box_add(params[:box],params[:url]))
+			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))
+				#handle_response_result(ClientController.vm_status(nil))
+				execute(:vm_status)
 			end
 			
 				
 
 			get RouteManager.vm_status_route do
-				handle_response_result(ClientController.vm_status(params[:vm]))
+				#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
-				handle_response_result(ClientController.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]))
+				#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]))
+				#handle_response_result(ClientController.vm_confirmed_destroy(params[:vmname]))
+				execute(:vm_confirmed_destroy,true,params[:vmname])        
 			end
+			
+			put RouteManager.vm_add_route do			  
+        execute(:vm_add,false,params[:file],params[:rename])        
+      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]))
+			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]))
+				#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]))
+				#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]))
+				#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))
+				#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]))
+				#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=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"
+									:type => 'Application/octet-stream' if result[0]==200 && params[:download]=="true"
 				
 				status result[0]
 					
 			end
 			
 						
-			post RouteManager.vm_snapshot_take_route do
-					handle_response_result(ClientController.vm_snapshot_take(params[:vmname],params[:name],params[:desc]))
+			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]))
+					#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
+        execute(:vm_snapshot_delete,false,params[:vm],params[:snapid])
+      end
+			
 			
 			get RouteManager.vm_backup_log_route do
-				handle_response_result(ClientController.backup_log(params[:vm]))
+				#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))
+				#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  
+        
+        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
+			
+			get RouteManager.node_queue_last_route do			  
+        execute(:operation_queued_last,true)
+      end
+			
+			
 				
 			private
-			def handle_response_result(result)														
-					if (!result)											
-						status 500
-					elsif (result.empty?)												
-						status 404
-					end					
-					result.to_json
-			end
+			  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"
+            #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		  
+			  
+			  
+  			
+  			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

data/lib/vagrant-node/apidesc.rb

@@ -36,6 +36,10 @@ module RestRoutes
 			VM_DESTROY_ROUTE
 		end
 		
+		def self.vm_add_route
+      VM_ADD_ROUTE
+    end
+		
 		def self.vm_status_route
 			VM_STATUS_ROUTE
 		end
@@ -64,6 +68,14 @@ module RestRoutes
 			VM_SNAPSHOT_TAKE_ROUTE
 		end
 		
+		def self.vm_snapshot_delete_route
+      VM_SNAPSHOT_DELETE_ROUTE
+    end
+		
+		def self.vm_delete_route
+      VM_DELETE_ROUTE
+    end
+		
 		def self.vm_snapshot_restore_route
 			VM_SNAPSHOT_RESTORE_ROUTE
 		end
@@ -72,11 +84,42 @@ module RestRoutes
 			NODE_BACKUP_LOG_ROUTE
 		end
 		
+		def self.node_password_change_route
+      NODE_PASSWORD_CHANGE
+    end
+		
+		
+		
 		def self.vm_backup_log_route
 			VM_BACKUP_LOG_ROUTE
 		end
 		
 		
+		def self.config_show_route
+      NODE_CONFIG_SHOW_ROUTE
+    end
+    
+    def self.config_upload_route
+      NODE_CONFIG_UPLOAD_ROUTE
+    end
+		
+		
+		def self.login_route
+		  LOGIN_ROUTE
+		end
+		
+		def self.node_queue_route
+		  NODE_QUEUE_ROUTE
+		end
+		
+		def self.node_queue_last_route
+      NODE_QUEUE_LAST_ROUTE
+    end
+		
+		
+		
+		
+		
 		def self.box_list_url(host,port)
 			"http://#{host}:#{port}#{box_list_route}"
 		end
@@ -95,8 +138,20 @@ module RestRoutes
 			url
 			
 		end
-
 		
+		def self.node_queue_url(host,port,id)
+		  url=String.new(node_queue_route)		  
+		  url[":id"] = id		  
+		  url="http://#{host}:#{port}#{url}"
+		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
 		
 		def self.vm_up_url(host,port)
 			"http://#{host}:#{port}#{vm_up_route}"
@@ -110,6 +165,10 @@ module RestRoutes
 			"http://#{host}:#{port}#{vm_destroy_route}"
 		end			
 		
+		def self.vm_add_url(host,port)
+      "http://#{host}:#{port}#{vm_add_route}"
+    end
+		
 		def self.vm_suspend_url(host,port)
 			"http://#{host}:#{port}#{vm_suspend_route}"
 		end
@@ -168,6 +227,16 @@ module RestRoutes
 			
 		end
 		
+		def self.vm_snapshot_delete_url(host,port,vmname,snapid)       
+      url=String.new(vm_snapshot_delete_route)        
+      url[":vm"]=vmname
+      url[":snapid"]=snapid
+      url="http://#{host}:#{port}#{url}"            
+      
+      url
+      
+    end
+		
 		def self.vm_snapshot_restore_url(host,port,vmname)
 			url=String.new(vm_snapshot_restore_route)
 			url[":vm"]=vmname
@@ -177,6 +246,17 @@ module RestRoutes
 			
 		end
 		
+		def self.vm_delete_url(host,port,vmname)
+		  url=String.new(vm_delete_route)
+      url[":vm"]=vmname
+      url="http://#{host}:#{port}#{url}"    
+      
+      url
+		end
+		
+		
+				
+		
 		def self.backup_log_url(host,port,vmname=nil)
 			url="http://#{host}:#{port}#{node_backup_log_route}"
 		
@@ -190,6 +270,17 @@ module RestRoutes
 			
 		end
 		
+		def self.config_show_url(host,port)
+      "http://#{host}:#{port}#{config_show_route}"
+    end
+    
+    def self.node_password_change_url(host,port)
+      "http://#{host}:#{port}#{node_password_change_route}"
+    end
+    
+    def self.config_upload_url(host,port)
+      "http://#{host}:#{port}#{config_upload_route}"
+    end
 		
 		
 		private
@@ -200,6 +291,8 @@ module RestRoutes
 			VM_UP_ROUTE = "/api/vm/up"
 			VM_HALT_ROUTE = "/api/vm/halt"
 			VM_DESTROY_ROUTE =	"/api/vm/destroy"
+			VM_DELETE_ROUTE = "/api/vm/:vm/delete"
+			VM_ADD_ROUTE = "/api/vm/add"
 			VM_SUSPEND_ROUTE = "/api/vm/suspend"
 			VM_RESUME_ROUTE = "/api/vm/resume"
 			VM_PROVISION_ROUTE = "/api/vm/provision"
@@ -210,11 +303,22 @@ module RestRoutes
 			SNAPSHOTS_ALL_ROUTE = "/api/vm/snapshots"
 			VM_SNAPSHOTS_ROUTE = "/api/vm/:vm/snapshots"
 			VM_SNAPSHOT_TAKE_ROUTE = "/api/vm/:vm/take"
+			VM_SNAPSHOT_DELETE_ROUTE = "/api/vm/:vm/:snapid/delete"
 			VM_SNAPSHOT_RESTORE_ROUTE = "/api/vm/:vm/restore"
 			
 			VM_BACKUP_LOG_ROUTE = "/api/vm/:vm/backuplog"
 			NODE_BACKUP_LOG_ROUTE = "/api/backuplog"
 			
+			NODE_CONFIG_SHOW_ROUTE = "/api/config/show"
+			NODE_CONFIG_UPLOAD_ROUTE = "/api/config/upload"
+			
+			NODE_PASSWORD_CHANGE = "/api/password/change"
+			
+			NODE_QUEUE_ROUTE = "/api/queue/:id"
+			NODE_QUEUE_LAST_ROUTE = "/api/queuelast"
+			
+			LOGIN_ROUTE = "/api/login"
+			
 	end
 	
 end