vagrant-node 1.0.0 → 1.1.1

data/lib/vagrant-node/configmanager.rb

@@ -24,70 +24,107 @@ module Vagrant
 
        
       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
+        
+
+        index=VM_INDEX_START
+
+        if (@config_sexp[0]==:iter)          
+          block=@config_sexp
+        else
+          
+          gindex=0
+          block=nil
+          @config_sexp.each_sexp do |conf|           
+             gindex=gindex+1
+             if (conf.node_type == :iter)
+               block = @config_sexp[gindex]
+             end             
+          end
 
-            if (@config_sexp[VM_INDEX_START].find_nodes(:iter).empty?)
+        end
+          
+        
+
+
+        raise RestException.new(406,
+                               "Config File has no virtual machine configured") if (block.nil? ||
+                                                                                    block.empty? ||
+                                                                                    block[index].nil?)
+             
+
+             
+         
+        if block[index].node_type==:block
+            
+            if (block[index].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)
+              return block[index].find_nodes(:iter)
             end
 
-        else            
-            #Only one machine configured
-            return [@config_sexp[VM_INDEX_START]]
+        else   
+            
+            return [block[index]]
         end
               
       end
 
-      def delete_vm (vm_name)
+      def delete_vm (vm_name)        
+        index=get_start_index
+        
         
 
-        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
+        if (@config_sexp[0]==:iter)
+          nodo=@config_sexp
+        else
+          nodo=@config_sexp.find_nodes(:iter).first
+        end
+        
+
+        if (!nodo[VM_INDEX_START].nil?)
 
-          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
+          if (nodo[VM_INDEX_START].node_type == :iter)
+            vm = nodo[VM_INDEX_START].find_nodes(:call)
+            
+            if (!vm.empty?)
+              leaf= vm.first.find_nodes(:lit)
+              
+              if (!leaf.empty? && leaf.first.value === vm_name.to_sym)
+                nodo.delete_at(VM_INDEX_START)
+                
+                save
+                return true
+              end
             end
+          elsif (nodo[VM_INDEX_START].node_type == :block)
+             nodo[VM_INDEX_START].each_sexp do |vm|            
 
+              
+                subnode=vm.find_nodes(:call)              
+                if (!subnode.empty?)                  
+                  leaf=subnode.first.find_nodes(:lit)                  
+                  if (!leaf.empty? && leaf.first.value === vm_name.to_sym)
+                    
+                    nodo[VM_INDEX_START].delete(vm)
+                    save
+                    
+                    return true                    
+                  end
+                end          
+              
+             end
           end
+          
+          
         end
 
+        
+
         raise RestException.new(404,"Virtual Machine #{vm_name} not found")
 
       
@@ -95,17 +132,18 @@ module Vagrant
 
       
       def get_vm_names
-
-        raise RestException.new(406,"No virtual machine configured") if @config_sexp[VM_INDEX_START].nil?
+        
+        index=get_start_index
+        raise RestException.new(406,"No virtual machine configured") if @config_sexp[index].nil?
 
         names = []
-        if @config_sexp[VM_INDEX_START].node_type==:block
+        if @config_sexp[index].node_type==:block
           #Entorno con una maquina configurada fuera de bloque
-          if (@config_sexp[VM_INDEX_START].find_nodes(:iter).empty?)
+          if (@config_sexp[index].find_nodes(:iter).empty?)
             names.push(:default)
           else
           #Entorno multi vm
-            @config_sexp[VM_INDEX_START].each_sexp do |vm|
+            @config_sexp[index].each_sexp do |vm|
               vm.find_nodes(:call).first.find_nodes(:lit).each do |node|
                 names.push(node.value)
               end
@@ -117,7 +155,7 @@ module Vagrant
         #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)
+          node=@config_sexp[index].find_nodes(:call).first.find_node(:lit)
         names.push(node.value)
 
         end
@@ -129,6 +167,7 @@ module Vagrant
       #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|
@@ -139,18 +178,40 @@ module Vagrant
         
       end
 
-      def insert_vms_sexp(vms_sexp)        
+      def insert_vms_sexp(vms_sexp)    
+        
         raise RestException.new(406,"Invalid configuration file supplied") if vms_sexp.nil? || vms_sexp.empty?        
+        index=VM_INDEX_START        
         
-        if !@config_sexp[VM_INDEX_START].nil?
+
+
+        if @config_sexp[0]==:iter          
+          block=@config_sexp
+        else          
+          gindex=0
+          block=nil
+          @config_sexp.each_sexp do |conf|           
+             gindex=gindex+1
+             if (!conf.nil? && conf.node_type == :iter)
+               block = @config_sexp[gindex]
+             end             
+             
+          end
+        end
+
+        
+        
+        
+
+        if !block[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 is a machine configured 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:
+          #  -- There is only one machine and it is stored at block[VM_INDEX_START]
+          if block[VM_INDEX_START].node_type==:block
+            # If node is a block it could be the first two options
+            if (block[VM_INDEX_START].find_nodes(:iter).empty?)
+              # This case match the first option, so the steps to perform are the following:
               # -- Create a block node 
                 new_block = s(:block)
               # -- Convert the current machine to a block style and insert into the block               
@@ -159,26 +220,50 @@ module Vagrant
                 new_block.add(vms_sexp)                
                 
                 
-              @config_sexp.delete_at(VM_INDEX_START)              
+              @config_sexp.delete_at(index)              
               
-              @config_sexp[VM_INDEX_START] = new_block
+              @config_sexp[index] = new_block
               
                
-            else
+            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)
+              if @config_sexp[0]==:iter
+                @config_sexp[VM_INDEX_START].add(vms_sexp) 
+              elsif @config_sexp[0]==:block
+                 @config_sexp[gindex][VM_INDEX_START].add(vms_sexp)
+              end
+              
             end
 
-          else            
-            #There is only one machine stored, we can store it at @config_sexp[VM_INDEX_START]            
+          else           
+            
+
+            #There is only one machine stored, we can store it at @config_sexp[index]            
             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
+
+            result = extract_vms_sexp
             
+
+            if (@config_sexp[0]==:block)
+              #SI el elemento 0 es un bloque
+
+              new_block.add(result)              
+              new_block.add(vms_sexp)  
+              
+
+              block.delete_at(VM_INDEX_START)
+              @config_sexp[gindex][VM_INDEX_START]=new_block
+
+            else
+              new_block.add(extract_vms_sexp)
+              new_block.add(vms_sexp)
+              @config_sexp.delete_at(index)
+              
+
+              @config_sexp[index] = new_block
+            end            
             
           end
         else
@@ -195,9 +280,9 @@ module Vagrant
             if (vms_sexp.length>1)              
               new_block = s(:block)
               new_block.add(vms_sexp)            
-              @config_sexp[VM_INDEX_START] = new_block
+              @config_sexp[index] = new_block
             else              
-              @config_sexp[VM_INDEX_START] = vms_sexp.first                                          
+              @config_sexp[index] = vms_sexp.first                                          
             end
             
         end
@@ -210,7 +295,7 @@ module Vagrant
       end
 
       #Ruby2Ruby modify the parameter, so a deep cloned copy is passed
-      def config_content
+      def config_content        
         begin        
           Ruby2Ruby.new.process(@config_sexp.dclone)
         rescue => e
@@ -218,7 +303,7 @@ module Vagrant
         end
       end
 
-      def save
+      def save        
         #Processing the content first. If there is any error
         #the file wont'be modified
         content= config_content
@@ -231,24 +316,31 @@ module Vagrant
       private
         VM_INDEX_START = 3
         DEFAULT_BLOCK_NAME = :default_config
+        DEFAULT_MACHINE = "default"
         
         
         
-        def rename_block_to_default(exp)
+        def rename_block_to_default(exp)          
           exp.each_sexp do |node|
-            rename_block_to_default(node)
-            # pp node.node_type
+            rename_block_to_default(node)            
             if (node.node_type == :lvar)
               node[1]=DEFAULT_BLOCK_NAME
             end
           end
         end
         
+        def get_start_index
+          
+          if (@config_sexp[0]==:iter)
+            return VM_INDEX_START
+          else
+            return VM_INDEX_START-1
+          end
+        end
+
         #Process a default virtual machine and produces
         #a block with the vm configuration
-        def default_to_block
-          
-            
+        def default_to_block            
             #Getting the main block name
             mblock_name = @config_sexp[2].value.to_s
                         
@@ -256,7 +348,7 @@ module Vagrant
             
             result= RubyParser.new.parse(
                                          "Vagrant.configure('2') do |#{mblock_name}|"+
-                                         "#{mblock_name}.vm.define(:default) do |#{DEFAULT_BLOCK_NAME.to_s}|\n"+
+                                         "#{mblock_name}.vm.define(:#{DEFAULT_MACHINE}) do |#{DEFAULT_BLOCK_NAME.to_s}|\n"+
                                          Ruby2Ruby.new.process(@config_sexp[VM_INDEX_START].dclone)+
                                          "end\nend"
                                          )
@@ -266,15 +358,104 @@ module Vagrant
              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)
+        
+        def convert_default_to_block                              
+
+          if (@config_sexp[0]==:iter)            
+
+            
+            #Caso en el que el fichero no tiene ningún contenido, tan solo el config
+            if (!@config_sexp[VM_INDEX_START].nil?)
+              if (@config_sexp[VM_INDEX_START].node_type==:attrasgn)
+                #Caso en el que el fichero es por defecto y los atributos están fuera
+                #de un bloque                
+                new_block = s(:block)          
+                new_block.add(default_to_block)
+
+                
+
+                @config_sexp.delete_at(VM_INDEX_START)
+                @config_sexp[VM_INDEX_START] = new_block 
+
+              elsif (@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
+
+          else
+            #Busco donde comienza la declaración del bloque principal            
+            
+            gindex=0
+            block=nil
+            @config_sexp.each_sexp do |conf|               
+               gindex=gindex+1               
+               if (conf.node_type == :iter)
+                 block = @config_sexp[gindex]
+               end
+               
+            end
+           
+            
+
+            if (!block.nil?)
+
+              if (block[VM_INDEX_START].nil?)
+                mblock_name = block[2][1].to_s              
+                block= RubyParser.new.parse(
+                                           "Vagrant.configure('2') do |#{mblock_name}|"+
+                                           "#{mblock_name}.vm.define(:#{DEFAULT_MACHINE}) do |#{DEFAULT_BLOCK_NAME.to_s}|\n"+                                           
+                                           "end\nend"
+                                           )  
+
+                @config_sexp[gindex] = block
+
+              elsif (!block[VM_INDEX_START].nil? && block[VM_INDEX_START].node_type==:attrasgn)
+                
+                
+                mblock_name = block[2][1].to_s              
                 
-             @config_sexp.delete_at(VM_INDEX_START)
-             @config_sexp[VM_INDEX_START] = new_block 
+                
+                rename_block_to_default(block[VM_INDEX_START])
+
+                block= RubyParser.new.parse(
+                                           "Vagrant.configure('2') do |#{mblock_name}|"+
+                                           "#{mblock_name}.vm.define(:#{DEFAULT_MACHINE}) do |#{DEFAULT_BLOCK_NAME.to_s}|\n"+
+                                           Ruby2Ruby.new.process(block[VM_INDEX_START].dclone)+
+                                           "end\nend"
+                                           )  
+
+                
+
+
+                
+                @config_sexp[gindex]=block
+                
+                
+              elsif (block[VM_INDEX_START].node_type==:block && 
+                    block[VM_INDEX_START].find_nodes(:iter).empty?)
+                   
+                   
+                   new_block = s(:block)                             
+                   new_block.add(default_to_block)
+                      
+                   block.delete_at(VM_INDEX_START)
+                   block[VM_INDEX_START] = new_block 
+                  
+                
+              end              
+
+            end
+
           end
+
         end
 
     end