vagrant-node 0.0.2 → 1.0.0

data/lib/vagrant-node/configmanager.rb

@@ -0,0 +1,284 @@
+require 'vagrant'
+require 'ruby_parser'
+require 'ruby2ruby'
+require 'vagrant-node/exceptions.rb'
+
+module Vagrant
+  module Node
+    class ConfigManager
+      attr_accessor :config_global,:config_warnings,:config_errors,:config_sexp
+      def initialize(spath_config_file)
+        @config_file_path = spath_config_file
+        config_loader = Config::Loader.new(Config::VERSIONS, Config::VERSIONS_ORDER)
+        config_loader.set(:conffile, File.expand_path(@config_file_path))
+        @config_global,@config_warnings, @config_errors = config_loader.load([:confile])
+
+        config_content = File.read(@config_file_path)
+        
+        @config_sexp = RubyParser.new.parse(config_content)
+
+        #If config file is in the default style convert it to a block one 
+        convert_default_to_block
+        
+      end
+
+       
+      def extract_vms_sexp
+        raise RestException.new(406,"Config File has no virtual machine configured") if (@config_sexp.nil? ||
+                                                                                         @config_sexp.empty? ||
+                                                                                         @config_sexp[VM_INDEX_START].nil?)
+                                                                                         
+         
+        if @config_sexp[VM_INDEX_START].node_type==:block
+
+            if (@config_sexp[VM_INDEX_START].find_nodes(:iter).empty?)
+              #One machine with default style
+              return default_to_block
+              
+            else
+              #Several machines configured
+              return @config_sexp[VM_INDEX_START].find_nodes(:iter)
+            end
+
+        else            
+            #Only one machine configured
+            return [@config_sexp[VM_INDEX_START]]
+        end
+              
+      end
+
+      def delete_vm (vm_name)
+        
+
+        if !@config_sexp[VM_INDEX_START].nil?
+          #Este caso se presenta cuando existe más de una máquina virtual
+          #O bien cuando la máquina es de tipo default
+          if @config_sexp[VM_INDEX_START].node_type==:block
+
+            if (@config_sexp[VM_INDEX_START].find_nodes(:iter).empty? && vm_name.to_sym==:default)
+              #Una única máquina configurada y no como bloque
+              @config_sexp.delete_at(VM_INDEX_START)
+              save
+              return true
+            else
+            #Entorno multi vm
+              @config_sexp[VM_INDEX_START].each_sexp do |vm|
+                vm.find_nodes(:call).first.find_nodes(:lit).each do |node|
+                  if node.value === vm_name.to_sym
+                    @config_sexp[VM_INDEX_START].delete(vm)
+                    save
+                  return true
+                  end
+                end
+              end
+            end
+
+          else            
+            #Este caso se produce cuando hay unicamente
+            #una maquina virtual configurada. En este caso
+            #@config_sexp[VM_INDEX_START] contiene la definicion
+            #de la maquina directamente
+            node=@config_sexp[VM_INDEX_START].find_nodes(:call).first.find_node(:lit)
+            if node.value === vm_name.to_sym
+              @config_sexp.delete_at(VM_INDEX_START)
+              save
+              return true
+            end
+
+          end
+        end
+
+        raise RestException.new(404,"Virtual Machine #{vm_name} not found")
+
+      
+      end
+
+      
+      def get_vm_names
+
+        raise RestException.new(406,"No virtual machine configured") if @config_sexp[VM_INDEX_START].nil?
+
+        names = []
+        if @config_sexp[VM_INDEX_START].node_type==:block
+          #Entorno con una maquina configurada fuera de bloque
+          if (@config_sexp[VM_INDEX_START].find_nodes(:iter).empty?)
+            names.push(:default)
+          else
+          #Entorno multi vm
+            @config_sexp[VM_INDEX_START].each_sexp do |vm|
+              vm.find_nodes(:call).first.find_nodes(:lit).each do |node|
+                names.push(node.value)
+              end
+            end
+          end
+
+        else
+        #Este caso se produce cuando hay unicamente
+        #una maquina virtual configurada. En este caso
+        #@config_sexp[VM_INDEX_START] contiene la definicion
+        #de la maquina directamente
+          node=@config_sexp[VM_INDEX_START].find_nodes(:call).first.find_node(:lit)
+        names.push(node.value)
+
+        end
+
+        names
+      end
+      
+  
+      #FIXME REVISAR PORQUE CUANDO QUEDA UNA ÚNICA máquina en un entorno
+      #multi vm el fichero cambia
+      def rename_vm(old_name,new_name)
+        machines = extract_vms_sexp 
+          
+        machines.each do |machine|
+          machine.find_nodes(:call).first.find_nodes(:lit).each do |node|
+            node[1] = new_name.to_sym if (node.value == old_name)
+          end
+        end  
+        
+      end
+
+      def insert_vms_sexp(vms_sexp)        
+        raise RestException.new(406,"Invalid configuration file supplied") if vms_sexp.nil? || vms_sexp.empty?        
+        
+        if !@config_sexp[VM_INDEX_START].nil?
+          # If @config_sexp[VM_INDEX_START] isn't nil could mean three things:
+          #  -- There is machine configure in with a default style
+          #  -- There are some machines inserted inside a block 
+          #  -- There is only one machine and it is stored at @config_sexp[VM_INDEX_START]
+          if @config_sexp[VM_INDEX_START].node_type==:block
+            # If node is a block we could have the first two options
+            if (@config_sexp[VM_INDEX_START].find_nodes(:iter).empty?)
+              # This case match the first option, so the steps to perdorm are the following:
+              # -- Create a block node 
+                new_block = s(:block)
+              # -- Convert the current machine to a block style and insert into the block               
+                new_block.add(default_to_block)
+              # -- Insert the new vms              
+                new_block.add(vms_sexp)                
+                
+                
+              @config_sexp.delete_at(VM_INDEX_START)              
+              
+              @config_sexp[VM_INDEX_START] = new_block
+              
+               
+            else
+              # This case means that there are some machines inserted inside a block
+              # we only have to add thems 
+              #FIXME FALTA COMPREOBAR SI HACE FALTA RENOMBRAR              
+              @config_sexp[VM_INDEX_START].add(vms_sexp)
+            end
+
+          else            
+            #There is only one machine stored, we can store it at @config_sexp[VM_INDEX_START]            
+            new_block = s(:block)
+            new_block.add(extract_vms_sexp)
+            new_block.add(vms_sexp)
+            @config_sexp.delete_at(VM_INDEX_START)
+            @config_sexp[VM_INDEX_START] = new_block
+            
+            
+          end
+        else
+            #If @config_sexp[VM_INDEX_START] is nil means that there isn't any
+            #machine configured
+            #In order to proceed correctly we have to check if there are one or more
+            #vms to be inserted:
+            #  -- If there is only one machine to be inserted is must be stored in
+            #  @config_sexp[VM_INDEX_START] directly
+            #  -- If there are two ore more vms to be inserted they have to be inserted inside 
+            #  a block in @config_sexp[VM_INDEX_START]
+            
+            
+            if (vms_sexp.length>1)              
+              new_block = s(:block)
+              new_block.add(vms_sexp)            
+              @config_sexp[VM_INDEX_START] = new_block
+            else              
+              @config_sexp[VM_INDEX_START] = vms_sexp.first                                          
+            end
+            
+        end
+        
+        # Saving the result to disk
+        save
+
+        true
+
+      end
+
+      #Ruby2Ruby modify the parameter, so a deep cloned copy is passed
+      def config_content
+        begin        
+          Ruby2Ruby.new.process(@config_sexp.dclone)
+        rescue => e
+          raise RestException.new(406,"There was an error processing the config file, check if there is any error")   
+        end
+      end
+
+      def save
+        #Processing the content first. If there is any error
+        #the file wont'be modified
+        content= config_content
+        f = File.open(@config_file_path, "w")        
+        f.write(content)
+        f.write("\n")
+        f.close
+      end
+
+      private
+        VM_INDEX_START = 3
+        DEFAULT_BLOCK_NAME = :default_config
+        
+        
+        
+        def rename_block_to_default(exp)
+          exp.each_sexp do |node|
+            rename_block_to_default(node)
+            # pp node.node_type
+            if (node.node_type == :lvar)
+              node[1]=DEFAULT_BLOCK_NAME
+            end
+          end
+        end
+        
+        #Process a default virtual machine and produces
+        #a block with the vm configuration
+        def default_to_block
+          
+            
+            #Getting the main block name
+            mblock_name = @config_sexp[2].value.to_s
+                        
+            rename_block_to_default(@config_sexp[VM_INDEX_START])
+            
+            result= RubyParser.new.parse(
+                                         "Vagrant.configure('2') do |#{mblock_name}|"+
+                                         "#{mblock_name}.vm.define(:default) do |#{DEFAULT_BLOCK_NAME.to_s}|\n"+
+                                         Ruby2Ruby.new.process(@config_sexp[VM_INDEX_START].dclone)+
+                                         "end\nend"
+                                         )
+                                        
+               
+             
+             return [result[VM_INDEX_START]]
+        end
+
+        def convert_default_to_block
+          if (@config_sexp[VM_INDEX_START].node_type==:block && 
+              @config_sexp[VM_INDEX_START].find_nodes(:iter).empty?)
+             new_block = s(:block)                             
+             new_block.add(default_to_block)
+                
+             @config_sexp.delete_at(VM_INDEX_START)
+             @config_sexp[VM_INDEX_START] = new_block 
+          end
+        end
+
+    end
+
+  end
+end
+

data/lib/vagrant-node/dbmanager.rb

@@ -1,5 +1,5 @@
 require 'sqlite3'
-
+require 'digest/md5'
 module Vagrant
 	module Node
 		module DB
@@ -27,28 +27,145 @@ module Vagrant
 					sql="UPDATE #{BACKUP_TABLE_NAME} SET #{BACKUP_STATUS_COLUMN} = ? WHERE #{BACKUP_DATE_COLUMN}= ? AND #{BACKUP_VM_NAME_COLUMN}= ?"
 					@db.execute(sql,status,date,vmname)					
 				end
-	 				
+	 			
+	 			def node_password_set?
+	 			  sql="SELECT Count(*) FROM #{PASSWORD_TABLE};"
+	 			  
+	 			  return @db.execute(sql).first[0]!=0
+	 			  #return true
+	 			  
+	 			end
+      
+        def node_check_password?(old_password)
+          sql="SELECT #{PASSWORD_COLUMN} FROM #{PASSWORD_TABLE} LIMIT 1;"
+          stored_pwd=@db.execute(sql)
+          
+          return (stored_pwd.length!=0 && (stored_pwd.first[0]==Digest::MD5.hexdigest(old_password)))  
+          #return true
+        end
+        
+        def node_password
+          sql="SELECT #{PASSWORD_COLUMN} FROM #{PASSWORD_TABLE} LIMIT 1;"
+          stored_pwd=@db.execute(sql)
+          stored_pwd.first[0]  
+        end
+        
+        def node_password_set(new_password,raw=false)          
+          if node_password_set?  || !node_default_password_set?        
+            sql="UPDATE #{PASSWORD_TABLE} SET #{PASSWORD_COLUMN} = ? "
+          else            
+            sql="INSERT INTO #{PASSWORD_TABLE} VALUES (?)"
+          end
+          
+          @db.execute(sql,
+                      ((raw)? new_password:
+                             Digest::MD5.hexdigest(new_password)))
+            
+        end
+
+        def node_default_password_set?
+          return node_password == DEFAULT_NODE_PASSWORD 
+        end
+
+
+        def create_queued_process(id)
+          sql="INSERT INTO #{OPERATION_QUEUE_TABLE_NAME} VALUES (?, ?, ?, ?, ?)"
+          @db.execute(sql,id,Time.now.strftime("%Y-%m-%d") ,Time.now.to_i,PROCESS_IN_PROGRESS,"")          
+        end
+        
+        def set_queued_process_result(id,result)
+          sql="UPDATE #{OPERATION_QUEUE_TABLE_NAME} SET #{OPERATION_STATUS_COLUMN} = ?,#{OPERATION_RESULT_COLUMN} = ?  WHERE #{OPERATION_ID_COLUMN}= ?"          
+          @db.execute(sql,PROCESS_SUCCESS,result,id)
+        end
+        
+        def set_queued_process_error(id,exception)          
+          sql="UPDATE #{OPERATION_QUEUE_TABLE_NAME} SET #{OPERATION_STATUS_COLUMN} = ?,#{OPERATION_RESULT_COLUMN} = ?  WHERE #{OPERATION_ID_COLUMN}= ?"
+          @db.execute(sql,PROCESS_ERROR,exception.message,id)
+        end
+        
+        def get_queued_process_result(id)
+          sql="SELECT #{OPERATION_STATUS_COLUMN},#{OPERATION_RESULT_COLUMN} FROM #{OPERATION_QUEUE_TABLE_NAME} WHERE #{OPERATION_ID_COLUMN}= ?;"
+          #sql="SELECT * FROM #{OPERATION_QUEUE_TABLE_NAME};"
+          @db.execute(sql,id)          
+        end
+        
+        def get_queued_last
+          sql="SELECT #{OPERATION_STATUS_COLUMN},#{OPERATION_RESULT_COLUMN} FROM #{OPERATION_QUEUE_TABLE_NAME};"
+          @db.execute(sql)
+        end
+        
+        
+        def remove_queued_processes
+          sql="DELETE FROM #{OPERATION_QUEUE_TABLE_NAME}"
+          @db.execute(sql)          
+        end
+        
 
 				private
 			
+			  PROCESS_IN_PROGRESS = 100;
+			  PROCESS_SUCCESS = 200;
+			  PROCESS_ERROR = 500;
+			
 				BACKUP_TABLE_NAME='node_table'
 				BACKUP_DATE_COLUMN = 'date'
 				BACKUP_VM_NAME_COLUMN = 'vm_name'
 				BACKUP_STATUS_COLUMN = 'backup_status'
+				PASSWORD_TABLE = 'node_password_table'
+				PASSWORD_COLUMN = 'node_password'
+				DEFAULT_NODE_PASSWORD = 'catedrasaesumu'
+				
+				OPERATION_QUEUE_TABLE_NAME='operation_queue_table'
+				OPERATION_CMD_COLUMN = 'operation_cmd'
+				OPERATION_STATUS_COLUMN = 'operation_status'
+				OPERATION_RESULT_COLUMN = 'operation_result'
+				OPERATION_ID_COLUMN = 'operation_id'
+				OPERATION_DATE_COLUMN = 'operation_date'				
+				OPERATION_TIME_COLUMN = 'operation_time'
 				
 				def check_database(data_dir)					
 					#Creates and/or open the database
 					
 					db = SQLite3::Database.new( data_dir.to_s + "/node.db" )
+					#Trying to avoid the sqlite3::busyexception
+					db.busy_timeout=100;
 									
 					if db.execute("SELECT name FROM sqlite_master 
 											 WHERE type='table' AND name='#{BACKUP_TABLE_NAME}';").length==0						
 						db.execute( "create table '#{BACKUP_TABLE_NAME}' (#{BACKUP_DATE_COLUMN} TEXT NOT NULL, 
 												 																#{BACKUP_VM_NAME_COLUMN} TEXT PRIMARY_KEY,
 												 																#{BACKUP_STATUS_COLUMN} TEXT NOT NULL);" )
+												 																
+            
+												 																
+												 																
 					end
 					
-					#return db
+					
+					if db.execute("SELECT name FROM sqlite_master 
+                       WHERE type='table' AND name='#{PASSWORD_TABLE}';").length==0            
+            db.execute("create table '#{PASSWORD_TABLE}' (#{PASSWORD_COLUMN} TEXT NOT NULL);" )
+            db.execute("INSERT INTO #{PASSWORD_TABLE} VALUES (\"#{DEFAULT_NODE_PASSWORD}\");");            
+          end
+					
+					if db.execute("SELECT name FROM sqlite_master 
+                       WHERE type='table' AND name='#{OPERATION_QUEUE_TABLE_NAME}';").length==0
+					
+		         # db.execute( "create table '#{OPERATION_QUEUE_TABLE_NAME}' (#{OPERATION_ID_COLUMN} INTEGER PRIMARY_KEY,
+		                                                    # #{OPERATION_CMD_COLUMN} TEXT NOT NULL,
+		                                                    # #{OPERATION_DATE_COLUMN} TEXT NOT NULL,
+		                                                    # #{OPERATION_TIME_COLUMN} INTEGER NOT NULL,
+                                                        # #{OPERATION_STATUS_COLUMN} TEXT NOT NULL,
+                                                        # #{OPERATION_RESULT_COLUMN} TEXT NOT NULL);" )
+               db.execute( "create table '#{OPERATION_QUEUE_TABLE_NAME}' (#{OPERATION_ID_COLUMN} INTEGER PRIMARY_KEY,                                                        
+                                                        #{OPERATION_DATE_COLUMN} TEXT NOT NULL,
+                                                        #{OPERATION_TIME_COLUMN} INTEGER NOT NULL,
+                                                        #{OPERATION_STATUS_COLUMN} INTEGER NOT NULL,
+                                                        #{OPERATION_RESULT_COLUMN} TEXT NOT NULL);" )
+                                                        
+          end
+					
+					
 					db
 					
 				end

data/lib/vagrant-node/exceptions.rb

@@ -0,0 +1,87 @@
+
+require 'vagrant'
+
+module Vagrant
+	module Node
+	  
+	  class RestException < StandardError	    
+      def initialize(code,msg)
+        super(msg)
+        @code = code        
+      end
+      def code
+        @code
+      end
+    end	
+
+    class ExceptionMutator < RestException
+      include Vagrant::Errors
+      def initialize(exception)
+        if (exception.is_a?(Vagrant::Errors::VagrantError))         
+          puts exception.class
+          case exception               
+          when BaseVMNotFound,
+               BoxNotFound,
+               BoxSpecifiedDoesntExist,
+               MachineNotFound,
+               NetworkNotFound,
+               ProviderNotFound,
+               VMNotFoundError,
+               VagrantfileExistsError
+            super(404,exception.message)
+          when BoxNotSpecified,
+               CLIInvalidOptions,
+               CLIInvalidUsage,
+               DestroyRequiresForce           
+            super(400,exception.message)
+          when ConfigInvalid,
+               NameError,
+               # ConfigValidationFailed,
+               # DeprecationError,
+               DownloaderFileDoesntExist,
+               BoxProviderDoesntMatch,
+               #BoxDownloadUnknownType,
+               BoxAlreadyExists,
+               ActiveMachineWithDifferentProvider,
+               BoxUnpackageFailure,
+               BoxUpgradeRequired, 
+               BoxVerificationFailed,
+               VMImportFailure               
+            super(406,exception.message)           
+          else
+            super(500,exception.message)
+          end
+          
+        else
+          super(500,exception.message)
+        end
+        
+      end
+    end
+    
+	end
+end
+
+
+ # Otras que por ahora no veo la necesidad de incluirlas
+ # , , , , 
+ # , , DotfileIsDirectory, DotfileUpgradeJSONError, , 
+ # DownloaderHTTPConnectReset, DownloaderHTTPConnectTimeout, DownloaderHTTPSocketError, DownloaderHTTPStatusError, 
+ # EnvironmentLockedError, EnvironmentNonExistentCWD, ForwardPortAutolistEmpty, ForwardPortCollision, 
+ # ForwardPortCollisionResume, GemCommandInBundler, HomeDirectoryMigrationFailed, HomeDirectoryNotAccessible, 
+ # LocalDataDirectoryNotAccessible, MachineGuestNotReady, , MultiVMEnvironmentRequired, MultiVMTargetRequired, 
+ # NFSHostRequired, NFSNoHostNetwork, NFSNotSupported, NetworkAdapterCollision, NetworkCollision, 
+ # NetworkDHCPAlreadyAttached, NetworkNoAdapters, , NoEnvironmentError, 
+ # PackageIncludeMissing, PackageOutputDirectory, PackageOutputExists, PackageRequiresDirectory,
+  # PersistDotfileExists, PluginLoadError, , SCPPermissionDenied, SCPUnavailable, SSHAuthenticationFailed
+  # , SSHConnectionRefused, SSHConnectionTimeout, SSHDisconnected, SSHHostDown, SSHKeyBadPermissions
+  # , SSHKeyTypeNotSupported, SSHNotReady, SSHPortNotDetected, SSHUnavailable
+  # , SSHUnavailableWindows, SharedFolderCreateFailed, UIExpectsTTY, UnimplementedProviderAction,
+   
+
+
+
+
+
+
+