vagrant-nodemaster 0.0.2 → 1.0.0

data/lib/vagrant-nodemaster/remote/remotesnapshottake.rb

@@ -6,21 +6,31 @@ module Vagrant
 		class SnapshotTake < Vagrant.plugin(2, :command)
 			def execute
 				options = {}
-	
+	      options[:async] = true
 				opts = OptionParser.new do |opts|
-					opts.banner = "Usage: vagrant remote snapshot take <node-name> <vmname> <name> [description]"
+					opts.banner = "Usage: vagrant remote snapshot take <node-name> <vmname> <name> [description] [--synchronous]"
+					opts.separator ""
+          opts.on("-s", "--synchronous", "Wait until the operation finishes") do |f|
+              options[:async] = false
+          end
 				end
 				
 				
 				argv = parse_options(opts)          
 									
 				return if !argv
+				
 				raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length < 3 || argv.length > 4 
-					
-				snapshot = RequestController.vm_snapshot_take(argv[0],argv[1],argv[2],argv[3])			
+        					
+				snapshot = RequestController.vm_snapshot_take(argv[0],argv[1],argv[2],argv[3],options[:async])
+				
+				if options[:async] == false
+          @env.ui.info("Remote Client: #{argv[0]}", :prefix => false)
+          @env.ui.info("Snapshot \"#{snapshot[:name]}\" with UUID #{snapshot[:id]} succesfully created.")           
+        else
+          @env.ui.info("Remote Client \"#{argv[0]}\": The operation ID is \"#{snapshot.gsub!(/\D/, "")}\"")
+        end
 				
-				@env.ui.info("Remote Client: #{argv[0]}", :prefix => false)
-				@env.ui.info("Snapshot \"#{snapshot[:name]}\" with UUID #{snapshot[:id]} succesfully created.")
 						
 				0
 			end

data/lib/vagrant-nodemaster/remote/remotesuspend.rb

@@ -6,9 +6,14 @@ module Vagrant
 			def execute
 			
 				options = {}
+				options[:async] = true
 				
 				opts = OptionParser.new do |opts|
-					opts.banner = "Usage: vagrant remote suspend <node-name> [vm_name]"
+					opts.banner = "Usage: vagrant remote suspend <node-name> [vm_name] [--synchronous]"
+					opts.separator ""
+          opts.on("-s", "--synchronous", "Wait until the operation finishes") do |f|
+            options[:async] = false
+          end
 				end
 				
 				argv = parse_options(opts)
@@ -16,14 +21,17 @@ module Vagrant
 				raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if (argv.length < 1 || argv.length > 2)
 				
 					
-				machines=RequestController.vm_suspend(argv[0],argv[1])
+				machines=RequestController.vm_suspend(argv[0],argv[1],options[:async])
 								
-					
-				machines.each do |machine|
-					@env.ui.info("Remote Client \"#{argv[0]}\":Virtual Machine \"#{machine}\" suspended")
-				end          				
+				if options[:async] == false   	
+  				machines.each do |machine|
+  					@env.ui.success("Remote Client \"#{argv[0]}\":Virtual Machine \"#{machine["vmname"]}\" suspended")
+  				end          				
+  		  else
+  		    @env.ui.info("Remote Client \"#{argv[0]}\": The operation ID is \"#{machines.gsub!(/\D/, "")}\"")
+  		  end
 								
-				@env.ui.info(" ")
+				
 				0								
 			end
 		

data/lib/vagrant-nodemaster/remote/remoteup.rb

@@ -4,37 +4,33 @@ module Vagrant
   module NodeMaster
 	class UpVM < Vagrant.plugin(2, :command)
 		def execute
-	     options = {}
-
+	        options = {}          
+          options[:async] = true
+          
           opts = OptionParser.new do |opts|
-            opts.banner = "Usage: vagrant remote up <node-name> [vm_name]"
+            opts.banner = "Usage: vagrant remote up <node-name> [vm_name] [--synchronous]"
+            opts.separator ""
+            opts.on("-s", "--synchronous", "Wait until the operation finishes") do |f|
+              options[:async] = false
+            end
           end
           
           argv = parse_options(opts)
           return if !argv  
           raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if (argv.length < 1 || argv.length > 2)
           
-#          begin          		          		
-          		
           		
-					machines=RequestController.vm_up(argv[0],argv[1])
+					machines=RequestController.vm_up(argv[0],argv[1],options[:async])
           			  	
-          		
-					machines.each do |machine|
-						@env.ui.info("Remote Client \"#{argv[0]}\": Virtual Machine \"#{machine}\" launched")
-					end          				
-										
-					@env.ui.info(" ")
-          		         		
-#          rescue RestClient::RequestFailed => e
-#          		@env.ui.error("Remote Client \"#{argv[0]}\": Request Failed")
-#          rescue RestClient::ResourceNotFound => e          
-#          		@env.ui.error("Remote Client \"#{argv[0]}\": Virtual Machine \"#{argv[1]}\" could not be found")
-#          rescue RestClient::ExceptionWithResponse=> e          
-#          		@env.ui.error(e.response)
-#          rescue Exception => e
-#          		@env.ui.error(e.message)
-#          end
+          if options[:async] == false		
+  					machines.each do |machine|
+  						@env.ui.success("Remote Client \"#{argv[0]}\": Virtual Machine \"#{machine["vmname"]}\" launched")
+  					end          				
+  										
+  					@env.ui.info(" ")
+					else
+			       @env.ui.info("Remote Client \"#{argv[0]}\": The operation ID is \"#{machines.gsub!(/\D/, "")}\"")
+					end          		         		
           
         end
         

data/lib/vagrant-nodemaster/remote/remotevmstatus.rb

@@ -18,7 +18,7 @@ module Vagrant
 					machine_status=RequestController.vm_status(argv[0],argv[1])
 	
 					@env.ui.info("Remote Client: #{argv[0]}", :prefix => false)
-					
+	
 					machine_status.each do |machine|
 						@env.ui.info(" * #{machine["name"].ljust(25)}   #{machine["status"]} (#{machine["provider"]})", :prefix => false) 
 					end          				

data/lib/vagrant-nodemaster/remotecommand.rb

@@ -1,6 +1,6 @@
 
 require 'vagrant/plugin'
- 
+require 'vagrant-nodemaster/node/nodedbmanager' 
 
 module Vagrant
   module NodeMaster
@@ -10,7 +10,10 @@ module Vagrant
 			super
 
 			@main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
-
+     
+      #Initializing db structure
+      DB::NodeDBManager.new(@env.data_dir)
+      
 #			puts "MAIN ARGS #{@main_args}"
 #			puts "SUB COMMAND #{@sub_command}"
 #			puts "SUB ARGS #{@sub_args}"
@@ -41,6 +44,11 @@ module Vagrant
 					HaltVM
 				end
 				
+				# @subcommands.register(:add) do
+          # require File.expand_path("../remote/remoteadd", __FILE__)
+          # AddVM
+        # end
+				
 				@subcommands.register(:suspend) do
 					require File.expand_path("../remote/remotesuspend", __FILE__)
 					SuspendVM
@@ -81,6 +89,11 @@ module Vagrant
 					BackupCommand
 				end
 				
+				@subcommands.register(:config) do
+          require File.expand_path("../remote/remoteconfigcommand", __FILE__)            
+          ConfigCommand
+        end
+				
 			end
 
 		def execute
@@ -99,12 +112,12 @@ module Vagrant
 			begin				
 				# Initialize and execute the command class
 				command_class.new(@sub_args, @env).execute
+			rescue RestClient::ExceptionWithResponse=> e          
+      @env.ui.error(e.response)
 			rescue RestClient::RequestFailed => e
 				@env.ui.error("Remote Client \"#{@sub_args[0]}\": Request Failed")
 			rescue RestClient::ResourceNotFound => e          
-				@env.ui.error("Remote Client \"#{@sub_args[0]}\": Virtual Machine \"#{@sub_args[1]}\" could not be found")
-			rescue RestClient::ExceptionWithResponse=> e          
-				@env.ui.error(e.response)
+				@env.ui.error("Remote Client \"#{@sub_args[0]}\": Virtual Machine \"#{@sub_args[1]}\" could not be found")			
 			rescue Exception => e
 				@env.ui.error(e.message)
 			end

data/lib/vagrant-nodemaster/requestcontroller.rb

@@ -4,28 +4,49 @@ require 'pp'
 require 'vagrant-nodemaster/apidesc'
 require 'vagrant-nodemaster/node/nodedbmanager'
 
+ 
+
+    
 module Vagrant
   module NodeMaster
+    
+    
+    
 		class RequestController
 			include RestRoutes 
+			GET_VERB = :get
+			POST_VERB = :post
+			DELETE_VERB = :delete
+			PUT_VERB = :put
+			SYNC_TIME = 10
 			
 			def self.get_remote_boxes(host)
 				client=get_host_parameters(host)				
-																			
-				response = RestClient.get RouteManager.box_list_url(client[:address],client[:port])
+
+        resource = RestClient::Resource.new(
+          RouteManager.box_list_url(client[:address],client[:port])
+        )
+        
+				response = execute(client,GET_VERB,resource);
+				
 				JSON.parse(response.to_str)
 			end
 			
 			def self.box_delete(host,box,provider)
-				client=get_host_parameters(host)				
-																			
-				response = RestClient.delete RouteManager.box_delete_url(client[:address],client[:port],box,provider)
+				client=get_host_parameters(host)
+				
+				
+				resource = RestClient::Resource.new(
+          RouteManager.box_delete_url(client[:address],client[:port],box,provider)
+        )                                     
+        
+        response = execute(client,DELETE_VERB,resource);
 
 				JSON.parse(response.to_str)
 				
 			end
 			
-			def self.box_add(host,box,url)
+			def self.box_add(host,box,url,async=true)
 				client=get_host_parameters(host)								
 				
 				resource = RestClient::Resource.new(
@@ -33,13 +54,17 @@ module Vagrant
 					:timeout => -1						
 				)
 				
-				response = resource.post :box => box,:url => url
-
-				JSON.parse(response.to_str)
+				
+        response = execute(client,POST_VERB,resource,{:box => box,:url => url},async);        
+        
+				return JSON.parse(response.to_str) if async ==false
+				
+        response
+				
 				
 			end
 			
-			def self.vm_up(host,vmname)
+			def self.vm_up(host,vmname,async=true)
 				client=get_host_parameters(host)
 				#Due to the fact that starting the machines can take long,
 				#setting the request not to expire
@@ -48,13 +73,15 @@ module Vagrant
 					:timeout => -1						
 				)
 				
-				response = resource.post :vmname => vmname					
-			
-				JSON.parse(response.to_str)
+									
+			  response = execute(client,POST_VERB,resource,{:vmname => vmname},async);
+			  
+				return JSON.parse(response.to_str) if async ==false
+				response
 				
 			end
 			
-			def self.vm_halt(host,vmname,force)
+			def self.vm_halt(host,vmname,force,async=true)
 				client=get_host_parameters(host)
 				#Due to the fact that halting the machines can take long,
 				#setting the request not to expire
@@ -63,40 +90,84 @@ module Vagrant
 					:timeout => -1
 				)
 				
-				response = resource.post :vmname => vmname,:force=>force
-			
-				JSON.parse(response.to_str)
+			  response = execute(client,POST_VERB,resource,{:vmname => vmname,:force=>force},async);
+				return JSON.parse(response.to_str) if async ==false
+        response
 				
 			end
 			
 			def self.vm_destroy (host,vmname)
 				client=get_host_parameters(host)
+				
 				resource = RestClient::Resource.new(
 					RouteManager.vm_destroy_url(client[:address],client[:port]),
 					:timeout => -1  				
 				)
 				
-				response = resource.post :vmname => vmname
-			
+				
+			  response = execute(client,POST_VERB,resource,{:vmname => vmname});
+			  
 				JSON.parse(response.to_str)
 				
 			end
 			
+      #Deletes from the remote node config the machine with name 'vmname'
+			def self.vm_delete(host,vmname,remove=false)
+			  client=get_host_parameters(host)
+			  
+			  
+			  
+			  resource = RestClient::Resource.new(
+          RouteManager.vm_delete_url(client[:address],client[:port],vmname),
+          :payload => { :remove => remove }
+        )                                     
+        
+        execute(client,DELETE_VERB,resource);
+        
+        
+
+        # JSON.parse(response.to_str)
+        
+			end
+			
 			
+			def self.vm_add(host,config,rename=false)
+        client=get_host_parameters(host)
+        
+        resource = RestClient::Resource.new(
+          RouteManager.vm_add_url(client[:address],client[:port]),
+          :timeout => -1 ,
+          # :payload => {
+            # :content_type => 'text/plain',
+            # :file => File.new(config, 'rb')
+          # }         
+        )       
+         
+        execute(client,PUT_VERB,resource,{:file => File.read(config), :content_type => 'text/plain',:rename => rename})
+        # JSON.parse(response.to_str)
+        
+      end
 			
 			def self.vm_status(host,vmname)
 				client=get_host_parameters(host)
 				
-				get_vm_status(client[:address],client[:port],vmname)				
+				#get_vm_status(client[:address],client[:port],vmname)				
+				get_vm_status(client,vmname)
 				
 			end
 			
 			def self.vm_ssh_config(host,vmname)
 				client=get_host_parameters(host)
 				
-				response = RestClient.get RouteManager.vm_sshconfig_url(client[:address],client[:port],vmname)					
+								
+				resource = RestClient::Resource.new(
+          RouteManager.vm_sshconfig_url(client[:address],client[:port],vmname)
+        )
+        
+				response = execute(client,GET_VERB,resource);
+        result=JSON.parse(response.to_str, {:symbolize_names => true})									
+				
 				
-				result=JSON.parse(response.to_str, {:symbolize_names => true})
 				#Change the target machine
 				result[:host]=client[:address]
 				
@@ -104,7 +175,7 @@ module Vagrant
 			end
 			
 			
-			def self.vm_suspend(host,vmname)
+			def self.vm_suspend(host,vmname,async=true)
 				client=get_host_parameters(host)
 				#Due to the fact that suspending the machines can take long,
 				#setting the request not to expire
@@ -113,77 +184,141 @@ module Vagrant
 					:timeout => -1						
 				)
 				
-				response = resource.post :vmname => vmname					
-			
-				JSON.parse(response.to_str)
+									
+			  response = execute(client,POST_VERB,resource,{:vmname => vmname},async);
+			  
+				return JSON.parse(response.to_str) if async ==false
+        response
 				
 			end
 			
-			def self.vm_resume(host,vmname)
+			def self.vm_resume(host,vmname,async=true)
 				client=get_host_parameters(host)
 				#Due to the fact that resuming the machines can take long,
 				#setting the request not to expire
 				resource = RestClient::Resource.new(
 					RouteManager.vm_resume_url(client[:address],client[:port]),					
 					:timeout => -1						
-				)
+				)				
 				
-				response = resource.post :vmname => vmname					
-			
-				JSON.parse(response.to_str)
+			  response = execute(client,POST_VERB,resource,{:vmname => vmname},async);
+			  
+				return JSON.parse(response.to_str) if async ==false
+        response
 				
 			end
 			
 			
-			def self.vm_provision(host,vmname)
+			def self.vm_provision(host,vmname,async=true)
 				client=get_host_parameters(host)
 				#Due to the fact that provisioning the machines can take long,
 				#setting the request not to expire
 				resource = RestClient::Resource.new(
 					RouteManager.vm_provision_url(client[:address],client[:port]),					
 					:timeout => -1						
-				)
+				)				
 				
-				response = resource.post :vmname => vmname					
-			
-				JSON.parse(response.to_str)
+									
+			  response = execute(client,POST_VERB,resource,{:vmname => vmname},async);
+			  
+				return JSON.parse(response.to_str) if async ==false
+        response
 				
 			end
 			
-			def self.get_remote_snapshots(host,vmname)				
-				client=get_host_parameters(host)			
-				
-				url=RouteManager.snapshot_list_url(client[:address],client[:port],vmname)
-
-				response = RestClient.get url
+			def self.get_remote_snapshots(host,vmname)
+			  			
+				client=get_host_parameters(host)
 				
+				resource = RestClient::Resource.new(
+            RouteManager.snapshot_list_url(client[:address],client[:port],vmname)
+        )     
+        
+        
+        response = execute(client,GET_VERB,resource);
 				
 				JSON.parse(response.to_str,{:symbolize_names => true})
+				# return JSON.parse(response.to_str,{:symbolize_names => true}) if async ==false
+        # response
 				
 			end
 			
-			def self.vm_snapshot_take(host,vmname,sname,sdesc)
-				client=get_host_parameters(host)	
+			def self.vm_snapshot_take(host,vmname,sname,sdesc,async=true)
+				client=get_host_parameters(host)
+					
 				#Due to the fact that taking the snapshot can take long,
-				#setting the request not to expire		
+				#setting the request not to expire
+					
 				resource = RestClient::Resource.new(
-					RouteManager.vm_snapshot_take_url(client[:address],client[:port],vmname),					
-					:timeout => -1						
-				)
-				response = resource.post :vmname => vmname,:name => sname,:desc => sdesc
+					RouteManager.vm_snapshot_take_url(client[:address],client[:port],vmname),					 					
+					:timeout => -1,											
+				)				
+
+        
+				response = execute(client,POST_VERB,resource,{:vmname => vmname,:name => sname,:desc => sdesc},async);
 				
-				JSON.parse(response.to_str,{:symbolize_names => true})
+				#JSON.parse(response.to_str,{:symbolize_names => true})
+				return JSON.parse(response.to_str,{:symbolize_names => true}) if async ==false
+        response
 				
 			end
 			
-			def self.vm_snapshot_restore(host,vmname,snapid)
-				client=get_host_parameters(host)			
+			def self.vm_snapshot_delete(host,vmname,snapid)
+        client=get_host_parameters(host)  
+        
+        #Due to the fact that deleting the snapshot can take long,
+        #setting the request not to expire                  
+        resource = RestClient::Resource.new(
+          RouteManager.vm_snapshot_delete_url(client[:address],client[:port],vmname,snapid),                   
+          :timeout => -1,                     
+        )       
+
+                
+        response = execute(client,DELETE_VERB,resource);
+        
+        # JSON.parse(response.to_str,{:symbolize_names => true})
+        
+      end
+			
+			
+			def self.vm_snapshot_restore(host,vmname,snapid,async=true)
+			  
+				client=get_host_parameters(host)
+							
 				resource = RestClient::Resource.new(
 					RouteManager.vm_snapshot_restore_url(client[:address],client[:port],vmname),					
 					:timeout => -1						
 				)
-				response = resource.post :vmname => vmname,:snapid => snapid
-				JSON.parse(response.to_str,{:symbolize_names => true})
+				
+				response = execute(client,POST_VERB,resource,{:vmname => vmname,:snapid => snapid},async);
+				
+				
+				#JSON.parse(response.to_str,{:symbolize_names => true})
+				return JSON.parse(response.to_str,{:symbolize_names => true}) if async ==false
+        response
+			end
+			
+			
+			def self.node_operation_queued(host,id)			  
+			  client=get_host_parameters(host)
+			  resource = RestClient::Resource.new(
+            RouteManager.node_queue_url(client[:address],client[:port],id)
+        )
+        
+        response = execute(client,GET_VERB,resource);
+        
+        JSON.parse(response.to_str,{:symbolize_names => true})
+			end
+			
+			def self.node_operation_queued_last(host)
+			  client=get_host_parameters(host)
+        resource = RestClient::Resource.new(
+            RouteManager.node_queue_last_url(client[:address],client[:port])
+        )
+        
+        response = execute(client,GET_VERB,resource);
+        
+        JSON.parse(response.to_str,{:symbolize_names => true})
 			end
 			
 			def self.node_backup_take(ui,target_dir,host=nil,vmname=nil)				
@@ -191,6 +326,7 @@ module Vagrant
 				current_client=nil
 				current_file = nil
 				download_backup = false
+				
 				begin
 					
 					raise "Directory \"#{target_dir}\" does not exists" if target_dir && !File.directory?(target_dir)
@@ -201,14 +337,16 @@ module Vagrant
 					if (host)
 						clients << get_host_parameters(host)
 					else
-						dbmanager=DB::NodeDBManager.new
-						clients = dbmanager.get_nodes
+					  #FIXME QUITAR ESTO DE AQUI
+						#@dbmanager=DB::NodeDBManager.new if !@dbmanager
+						clients = DB::NodeDBManager.get_nodes
 					end
 				
 					clients.each do |client|				
 						current_client=client
 						#Fist get remote virtual machines
-						vms=get_vm_status(client[:address],client[:port],vmname)
+						vms=get_vm_status(client,vmname)
+						
 						
 						vms.each do |vm|
 							
@@ -227,7 +365,9 @@ module Vagrant
 									:timeout => -1						
 							)
     					
-							response = resource.get({:params => {'download' => download_backup}})					
+    					#OLD. FIXME REMOVE
+							#response = resource.get({:params => {'download' => download_backup}})
+							response = execute(client,GET_VERB,resource,:params => {'download' => download_backup});					
 							
 							th.kill if th
 							
@@ -272,8 +412,6 @@ module Vagrant
 			end
 			
 			def self.node_backup_log(ui,node,vmname=nil)
-				clients = []
-				
 				
 				raise "Error finding the node" if node==nil
 				
@@ -281,30 +419,144 @@ module Vagrant
 				
 				resource = RestClient::Resource.new(
 						RouteManager.backup_log_url(client[:address],client[:port],vmname),					
-						:timeout => -1						
+						:timeout => -1
 				)
 		
-		
-				response = resource.get :vmname => vmname	
-		
+		    
+					
+		    response = execute(client,GET_VERB,resource,:vmname => vmname);
+		    
 				JSON.parse(response.to_str)
 				
 			end
 			
+			def self.node_config_show(node)
+			  raise "Please enter a valid node" if node==nil
+			  client=get_host_parameters(node)
+			  
+			  
+			  resource = RestClient::Resource.new(
+            RouteManager.config_show_url(client[:address],client[:port]),         
+            :timeout => -1                        
+        )   
+    
+        			  
+			  execute(client,GET_VERB,resource);
+			  
+			end
+			
+			
+			
+			def self.node_config_upload(node,config_path)        
+        client=get_host_parameters(node)
+        
+        
+        resource = RestClient::Resource.new(
+            RouteManager.config_upload_url(client[:address],client[:port]),         
+            :timeout => -1                        
+        )    
+        
+        execute(client,POST_VERB,resource,{:file => File.read(config_path), :content_type => 'text/plain'})
+        
+      end
+			
+			
+			def self.node_password_change(node,password)
+			  client=get_host_parameters(node)
+        
+        
+        resource = RestClient::Resource.new(
+            RouteManager.node_password_change_url(client[:address],client[:port]),         
+            :timeout => -1                        
+        )
+        
+        execute(client,POST_VERB,resource,{:password => Digest::MD5.hexdigest(password)});
+        
+			end
+			
 			
 			private
 			
+			def self.execute(host,http_method,resource,params=nil,async=true)
+			  client = login(host)
+			  
+			  #FIXME AÑADIR AQUI GESTION DE ERRORES
+			  #SI NO HAY COOKIE
+			  #SI NO HAY TOKEN
+			  #Y EnVIAR DESDE SERVeR ALGUNA EXECPCION 
+			  #PARA MONITORIZAR LA FALTA DE ALGUN PARAMETRO Y REPETIR LA TRANSACCION
+			  resource.options[:headers] = { :content_md5 => CGI.escape(client[:token]),
+			                                 :cookies => client[:cookies]
+			                               }
+			  
+			  data= {}			    			  
+			  
+			  data.merge!(params) if params!=nil			  
+			  
+			  
+			  
+			  #response = resource.send http_method.to_sym, :content_md5 => client[:token], :cookies => client[:cookies]
+			  
+			  response = resource.send http_method.to_sym, data			  
+			  
+			  if response.code == 202 && async==false
+			      #Getting the location operation id
+			      opid = response.gsub!(/\D/, "")
+			      
+			      begin
+  			      sleep SYNC_TIME
+  			      client1 = login(host)			    
+  			      resourceop = RestClient::Resource.new(
+                RouteManager.node_queue_url(client1[:address],client1[:port],opid)
+              )
+              resourceop.options[:headers] = { :content_md5 => CGI.escape(client1[:token]),
+                                               :cookies => client1[:cookies]
+                                              }
+              responseop = resourceop.send GET_VERB
+              
+              res = JSON.parse(responseop.to_str)
+              pp res[0]
+              
+                                                            
+          end while (res[0].eql? "IN PROGRESS") #While operation code is IN PROGRESS iterate
+                                     
+          res[1]       
+			     
+			  else
+			    response  
+			  end
+			  			  
+			end
+			
+			
+			
+			def self.login(host)			  
+			  
+			  response = RestClient.get RouteManager.login_url(host[:address],host[:port])
+			  
+			  host[:token] = Digest::MD5.hexdigest(response.headers[:content_md5]+host[:password])
+			  host[:cookies] = response.cookies			  
+			  
+			  host
+			end
+			
 			def self.get_host_parameters(host)
 			
-				dbmanager=DB::NodeDBManager.new
-				
-				return dbmanager.get_node(host)
+				#@dbmanager=DB::NodeDBManager.get_reference if !@dbmanager				
+				DB::NodeDBManager.get_node(host)
 					
 			end
 			
-			def self.get_vm_status(address,port,vmname)
-				response = RestClient.get RouteManager.vm_status_url(address,port,vmname)
+			def self.get_vm_status(client,vmname)
+        
+  			resource = RestClient::Resource.new(
+            RouteManager.vm_status_url(client[:address],client[:port],vmname)      
+        )  
+	
+				response = execute(client,GET_VERB,resource);
+								
 				JSON.parse(response.to_str)
+				
 			end
 			
 			def self.draw_progress(ui,download,node,vmname)