vagrant-node 1.0.0 → 1.1.1

data/lib/vagrant-node/exceptions.rb

@@ -14,6 +14,21 @@ module Vagrant
       end
     end	
 
+    class VMActionException < StandardError     
+      def initialize(vmname,provider,msg)
+        super(msg)
+        @vmname = vmname        
+        @provider = provider
+      end
+      def vmname
+        @vmname
+      end
+
+      def provider
+        @provider
+      end
+    end 
+
     class ExceptionMutator < RestException
       include Vagrant::Errors
       def initialize(exception)

data/lib/vagrant-node/nodeserverpasswd.rb

@@ -6,6 +6,25 @@ require 'vagrant-node/dbmanager'
 module Vagrant
   module Node
 	class NodeServerPasswd < Vagrant.plugin(2, :command)
+
+    def ask_for_config
+      puts "Configuring Vagrant Node"
+      puts "Insert database user:"
+      user=STDIN.noecho(&:gets).chomp
+      print "\n"
+      print "Insert database password:"
+      password=STDIN.noecho(&:gets).chomp
+      print "\n"
+      print "Insert database name:"
+      database=STDIN.noecho(&:gets).chomp
+      print "\n"
+
+      DB::DBManager.create_config_file(@env.data_dir,'localhost',database,user,password)
+
+      DB::DBManager.check_bbdd_structure
+
+    end
+
 		def execute
 	     options = {}
 
@@ -20,42 +39,98 @@ module Vagrant
           
           # if (argv.length==0)
   
-  
-            
-            db = DB::DBManager.new(@env.data_dir)            
-            
-            #Checking if user knows the old password
-            if (db.node_password_set? && !db.node_default_password_set?)              
-              print "Insert current password: "
-              old_password=STDIN.noecho(&:gets).chomp
-              print "\n"
-              if !db.node_check_password?(old_password)
-                @env.ui.error("Password failed!")
-                return 0
-              end            
-            end
-            
-            pass_m = "Insert your new password for this Node: "
-            confirm_m = "Please Insert again the new password: "
-            
-   
-            if STDIN.respond_to?(:noecho)
-              print pass_m
-              password=STDIN.noecho(&:gets).chomp
-              print "\n#{confirm_m}"
-              confirm=STDIN.noecho(&:gets).chomp
-              print "\n"
-            else
-              #FIXME Don't show password 
-              password = @env.ui.ask(pass_m)
-              confirm = @env.ui.ask(confirm_m)
+            i=0
+
+
+            begin    
+
+              if (!DB::DBManager.check_config_file(@env.data_dir))
+
+                
+
+                puts "Configuring Vagrant Node"
+                print "Insert privileged database user:  "
+                user=STDIN.cooked(&:gets).chomp
+                
+                print "Insert privileged database user password:  "
+                password=STDIN.noecho(&:gets).chomp
+                print "\n"
+                print "Insert database name:  "
+                database=STDIN.cooked(&:gets).chomp
+                print "\n"
+
+                DB::DBManager.create_config_file(@env.data_dir,'localhost',database,user,password)
+
+
+              end
+
+              
+              db = DB::DBManager.new(@env.data_dir)  
+
+            rescue Exception => e            
+              
+              if (!DB::DBManager.check_config_file(@env.data_dir))
+                retry
+              end
+              
+              if (e.class==Mysql2::Error)              
+                print "Can't connect to mysql with current configuration, please review provided credentials. Please execute again this command to reconfigure"
+                DB::DBManager.delete_config_file(@env.data_dir)                
+              end
+
+              # #if (exception.class==Mysql2::Error)
+              # if (i<1)                                
+              #   puts "Configuring database connection "
+              #   puts "Do you let us create "
+              #   puts "Insert privilege database user:"
+              #   user=STDIN.noecho(&:gets).chomp
+              #   print "\n"
+              #   print "Insert privilege database password:"
+              #   password=STDIN.noecho(&:gets).chomp
+              #   print "\n"
+              #   print "Insert database name:"
+              #   database=STDIN.noecho(&:gets).chomp
+              #   print "\n"
+              #   DB::DBManager.create_config_file(@env.data_dir,'localhost',database,user,password)
+              #   i=i+1
+              #   retry
+              # end
             end
             
-            if (password==confirm)              
-              db.node_password_set(password)
-              @env.ui.success("Password changed!")
-            else
-              @env.ui.error("Passwords does not match!")
+            if (!db.nil?)
+              #Checking if user knows the old password
+              if (db.node_password_set? && !db.node_default_password_set?)              
+                print "Insert current password: "
+                old_password=STDIN.noecho(&:gets).chomp
+                print "\n"
+                if !db.node_check_password?(old_password)
+                  @env.ui.error("Password failed!")
+                  return 0
+                end            
+              end
+              
+              pass_m = "Insert your new password for this Node: "
+              confirm_m = "Please Insert again the new password: "
+              
+     
+              if STDIN.respond_to?(:noecho)
+                print pass_m
+                password=STDIN.noecho(&:gets).chomp
+                print "\n#{confirm_m}"
+                confirm=STDIN.noecho(&:gets).chomp
+                print "\n"
+              else
+                #FIXME Don't show password 
+                password = @env.ui.ask(pass_m)
+                confirm = @env.ui.ask(confirm_m)
+              end
+              
+              if (password==confirm)              
+                db.node_password_set(password)
+                @env.ui.success("Password changed!")
+              else
+                @env.ui.error("Passwords does not match!")
+              end
             end
   
   

data/lib/vagrant-node/nodeserverstart.rb

@@ -20,12 +20,13 @@ module Vagrant
       return if !argv  
       raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length > 1
       		
-  		begin
-			 ServerAPI::ServerManager.run(File.dirname(@env.lock_path),@env.data_dir,argv[0].to_i)
+  		begin                        
+			 #ServerAPI::ServerManager.run(File.dirname(@env.lock_path),@env.data_dir,@env,argv[0].to_i)       
+       ServerAPI::ServerManager.run(@env.tmp_path,@env.data_dir,@env,argv[0].to_i)       
 			rescue Exception => e  
         @env.ui.error(e.message)
       end 
-          		         		
+	   
       0
     end
         

data/lib/vagrant-node/nodeserverstop.rb

@@ -20,7 +20,8 @@ module Vagrant
       raise Vagrant::Errors::CLIInvalidUsage, :help => opts.help.chomp if argv.length > 1 
       
       begin
-        ServerAPI::ServerManager.stop(File.dirname(@env.lock_path),@env.data_dir)
+        #ServerAPI::ServerManager.stop(File.dirname(@env.lock_path),@env.data_dir)
+        ServerAPI::ServerManager.stop(@env.tmp_path,@env.data_dir)
       rescue Exception => e  
         @env.ui.error(e.message)
       end

data/lib/vagrant-node/obmanager.rb

@@ -0,0 +1,123 @@
+require 'vagrant'
+require 'vagrant-node/dbmanager'
+require 'vagrant-node/pwmanager'
+require 'vagrant-node/exceptions.rb'
+require 'singleton'
+
+
+module Vagrant
+
+end
+
+module Vagrant
+	module Config
+		class Loader
+			def procs_for_path(path)
+				
+				return Config.capture_configures do
+					begin
+						
+						#Module hack to remove previous constans definitions
+						modaux=Module.new
+						res=modaux.module_eval(File.read(path))
+						obconstants = Object.constants
+						modaux.constants.each do |var|
+							Object.send(:remove_const,var) if Object.constants.include?(var)
+						end
+						############################33
+						
+						
+						Kernel.load path
+					rescue SyntaxError => e
+						# Report syntax errors in a nice way.
+						raise Errors::VagrantfileSyntaxError, :file => e.message
+					rescue SystemExit
+						# Continue raising that exception...
+						raise
+					rescue Vagrant::Errors::VagrantError
+						# Continue raising known Vagrant errors since they already
+						# contain well worded error messages and context.
+						raise
+					rescue Exception => e
+						@logger.error("Vagrantfile load error: #{e.message}")
+						@logger.error(e.backtrace.join("\n"))
+
+					# Report the generic exception
+					raise Errors::VagrantfileLoadError,
+					  :path => path,
+					  :message => e.message
+					end
+	        	end
+			end
+		end
+	end
+
+
+	# class Environment		
+
+ #    	def reload
+    		
+ #    		@config_global = nil
+ #    		@config_loader = nil
+ #    		@config_global = config_global
+    		
+			
+	# 		@config_global
+ #    	end
+ #    end
+
+module Node
+
+	
+
+	class ObManager
+
+		include Singleton
+
+		def initialize			
+			@env = Environment.new
+			@db = DB::DBManager.new(@env.data_dir) if (!@db)
+			@pw = PwManager.new(@db) if (!@pw)
+		end
+		
+		def env	
+			if (!@env)		
+				self.env=Environment.new
+			end
+			@env
+		end
+
+		def reload_env
+
+			if (@env)				
+				@env.unload if (@env)
+				# @env.reload				
+				@env = nil
+			end
+
+			@env = Environment.new
+			self.env=@env
+
+			@env
+		end
+
+		def env=(environment)			
+			@env=environment
+			@db=nil
+			@pw=nil
+			@db = DB::DBManager.new(@env.data_dir) if (!@db)
+			@pw = PwManager.new(@db) if (!@pw)
+		end
+
+		def dbmanager			
+			@db
+		end
+
+		def pwmanager			
+			@pw
+		end
+
+		
+	end
+end
+end

data/lib/vagrant-node/server.rb

@@ -16,12 +16,12 @@ module Vagrant
 				DEFAULT_BIND_PORT = 3333	
 				BIND_ADDRESS = "0.0.0.0"
 				LOG_FILE = "webrick.log"						
-				def self.run(pid_path,data_path,port=DEFAULT_BIND_PORT)
+				def self.run(pid_path,data_path,env,port=DEFAULT_BIND_PORT)
 					
-					check_password(data_path);
+					check_password(data_path)
 					
 					pid_file = File.join(pid_path,PIDFILENAME)
-								
+				        	
 					pid = fork do
 					
 						
@@ -42,12 +42,25 @@ module Vagrant
 							:AccessLog => access_log
 						}
 						
+						
 						#begin
 							server = WEBrick::HTTPServer.new(options)	
 							
 							server.mount "/", Rack::Handler::WEBrick,ServerAPI::API.new
-							trap("INT") { server.stop }
-						
+							
+							trap("INT") { server.shutdown }
+
+							trap("USR1") { 
+								
+								#Stopping server
+								server.shutdown
+								
+								#Restarting server
+								server = WEBrick::HTTPServer.new(options)
+								server.mount "/", Rack::Handler::WEBrick,ServerAPI::API.new	
+								server.start
+							}
+
 							PidFile.create(pid_file,Process.pid)						
 							
 							server.start
@@ -93,24 +106,17 @@ module Vagrant
 				end
 				
 				private
+
 				
 				def self.check_password(data_path)				  
-				  @db = DB::DBManager.new(data_path)
-				  if (!@db.node_password_set? || @db.node_default_password_set?)
-				    raise "Please, set first a password with the command \"vagrant nodeserver passwd\""
-				  # else
-				    # if (password==nil || password.size==0)				      
-				      # if STDIN.respond_to?(:noecho)
-                # print "Password: "
-                # password=STDIN.noecho(&:gets).chomp                
-                # print "\n"              
-              # end
-				    # end
-				    
-				    # if(!@db.node_check_password?(password))
-                # raise "Password failed!"
-            # end 
-				  end
+
+					begin
+					  	@db = DB::DBManager.new(data_path)					  
+					rescue
+						if (!@db || !@db.node_password_set? || @db.node_default_password_set?)
+							raise "Please, set first a password with the command \"vagrant nodeserver passwd\""				  
+						end
+					end
 				  true
 				end
 				

data/lib/vagrant-node/util/downloader.rb

@@ -0,0 +1,182 @@
+require 'pp'
+require "vagrant/util/busy"
+
+require "vagrant/util/subprocess"
+
+module Vagrant
+  module Node
+    module Util
+      # This class downloads files using various protocols by subprocessing
+      # to cURL. cURL is a much more capable and complete download tool than
+      # a hand-rolled Ruby library, so we defer to it's expertise.
+      class Downloader
+        UPDATETIME = 10
+
+        def initialize(source, destination, options=nil)          
+          @source      = source.to_s
+          @destination = destination.to_s
+
+          # Get the various optional values
+          options     ||= {}
+          #@callback    = options[:callback]
+          @insecure    = options[:insecure]
+          @ui          = options[:ui]
+          @db          = options[:db]
+          @box_name          = options[:box_name]
+        end
+
+        # This executes the actual download, downloading the source file
+        # to the destination with the given opens used to initialize this
+        # class.
+        #
+        # If this method returns without an exception, the download
+        # succeeded. An exception will be raised if the download failed.
+        def download!          
+          # Build the list of parameters to execute with cURL
+          options = [
+            "--fail",
+            "--location",
+            "--max-redirs", "10",
+            "--output", @destination
+          ]
+
+          options << "--insecure" if @insecure
+          options << @source
+
+          # Specify some options for the subprocess
+          subprocess_options = {}
+
+          # If we're in Vagrant, then we use the packaged CA bundle
+          if Vagrant.in_installer?
+            subprocess_options[:env] ||= {}
+            subprocess_options[:env]["CURL_CA_BUNDLE"] =
+              File.expand_path("cacert.pem", ENV["VAGRANT_INSTALLER_EMBEDDED_DIR"])
+          end
+
+          # This variable can contain the proc that'll be sent to
+          # the subprocess execute.
+          data_proc = nil
+
+          subprocess_options[:notify] = :stderr
+
+          progress_data = ""
+          progress_regexp = /(\r(.+?))\r/
+
+          # Setup the proc that'll receive the real-time data from
+          # the downloader.
+          last_id=@db.add_box_download_info(@box_name,@source)
+          
+          comienzo = Time.now();
+          
+          data_proc = Proc.new do |type, data|
+            # Type will always be "stderr" because that is the only
+            # type of data we're subscribed for notifications.
+
+            # Accumulate progress_data
+            progress_data << data
+          
+
+            
+            while true
+              # If we have a full amount of column data (two "\r") then
+              # we report new progress reports. Otherwise, just keep
+              # accumulating.
+              match = progress_regexp.match(progress_data)
+              break if !match
+              data = match[2]
+              progress_data.gsub!(match[1], "")
+
+              # Ignore the first \r and split by whitespace to grab the columns
+              columns = data.strip.split(/\s+/)
+
+              # COLUMN DATA:
+              #
+              # 0 - % total
+              # 1 - Total size
+              # 2 - % received
+              # 3 - Received size
+              # 4 - % transferred
+              # 5 - Transferred size
+              # 6 - Average download speed
+              # 7 - Average upload speed
+              # 9 - Total time
+              # 9 - Time spent
+              # 10 - Time left
+              # 11 - Current speed
+              
+              if (Time.now()-comienzo > UPDATETIME)                
+                @db.update_box_download_info(last_id,"#{columns[0]}%","#{columns[10]}")
+                comienzo = Time.now()
+              end
+
+              #db.execute("INSERT INTO #{PASSWORD_TABLE} VALUES (\"#{DEFAULT_NODE_PASSWORD}\");");       
+              #pp "Progress: #{columns[0]}% (Rate: #{columns[11]}/s, Estimated time remaining: #{columns[10]})"
+
+              #output = "Progress: #{columns[0]}% (Rate: #{columns[11]}/s, Estimated time remaining: #{columns[10]})"
+              ##@ui.clear_line
+              #@ui.info(output, :new_line => false)
+            end
+
+            #@db.update_box_download_info(last_id,"100%","--:--:--")
+          end
+          
+
+          # Add the subprocess options onto the options we'll execute with
+          options << subprocess_options
+
+          # Create the callback that is called if we are interrupted
+          interrupted  = false
+          int_callback = Proc.new do            
+            interrupted = true
+          end
+
+          
+          # Execute!
+          result = Vagrant::Util::Busy.busy(int_callback) do
+            Vagrant::Util::Subprocess.execute("curl", *options, &data_proc)
+          
+            
+          end
+          
+
+          if ((!interrupted) && (result.exit_code==0))
+              # @db.update_box_download_info(last_id,"100%","--:--:--")                            
+              @db.delete_box_download(last_id)
+          else                                              
+              @db.set_box_download_error(last_id)
+          end
+          
+          
+          # If the download was interrupted, then raise a specific error
+          raise Errors::DownloaderInterrupted if interrupted
+
+          
+          # If we're outputting to the UI, clear the output to
+          # avoid lingering progress meters.
+          @ui.clear_line if @ui
+
+          
+          # If it didn't exit successfully, we need to parse the data and
+          # show an error message.
+          if result.exit_code != 0
+            
+            @logger.warn("Downloader exit code: #{result.exit_code}") if @logger
+            
+            parts    = result.stderr.split(/\n*curl:\s+\(\d+\)\s*/, 2)
+            
+            parts[1] ||= ""
+            
+            
+
+            raise Errors::DownloaderError, :message => parts[1].chomp
+          end
+
+          
+
+          # Everything succeeded
+          true
+        end
+      end
+    end
+  end
+end