lib/rundock/builder/operation_builder.rb in rundock-0.5.0 vs lib/rundock/builder/operation_builder.rb in rundock-0.5.2

@@ -4,57 +4,59 @@
       def build_first(scenario, targets, tasks, hooks)
         if @options[:targetgroup] && !@options[:command]
           raise CommandArgNotFoundError, %("--command or -c" option is required if targetgroup specified.)
         end
 
-        node = nil
-        node_attribute = nil
+        parsing_node_attribute = nil
         scen = Scenario.new
         scen.tasks = tasks
 
-        # use scenario file
-        scenario.each do |n|
-          scen.nodes.push(node) if node
+        scenario.each do |sn|
+          nodes = []
+          operations = []
+          hook_contents = []
 
-          n.deep_symbolize_keys.each do |sk, sv|
+          sn.deep_symbolize_keys.each do |sk, sv|
             if sk == :target
               target_builder = TargetBuilder.new(@options)
               target = target_builder.build(sv, targets)
 
               if target.is_a?(Node)
-                if node_attribute.nil?
-                  node_attribute = Rundock::Attribute::NodeAttribute.new(task_info: {})
-                else
-                  node_attribute.next
+                nodes = Array(target)
+                parsing_node_attribute = build_node_attribute(scen, sv, parsing_node_attribute, tasks, target_builder.parsed_node_options[sv.to_sym])
+                operations = Array(build_cli_command_operation(@options[:command], parsing_node_attribute, @options)) if @options[:command]
+              end
+            elsif sk == :target_group
+              target_builder = TargetBuilder.new(@options)
+              nodes = target_builder.build_group(sv, targets)
+              nodes.each do |n|
+                if n.is_a?(Node)
+                  parsing_node_attribute = build_node_attribute(scen, n.name, parsing_node_attribute, tasks, target_builder.parsed_node_options[n.name.to_sym])
+                  operations = Array(build_cli_command_operation(@options[:command], parsing_node_attribute, @options)) if @options[:command]
                 end
-
-                node_attribute.nodename = sv
-                node = target
-                tasks.each { |k, v| node_attribute.task_info[k] = v } if tasks
-                scen.node_info[sv.to_sym] = node_attribute.nodeinfo = target_builder.parsed_options
               end
-
-              if @options[:command]
-                node.add_operation(build_cli_command_operation(@options[:command], node_attribute, @options))
-              end
             elsif sk == :hook
               hooks_builder = HookBuilder.new(@options)
-              if node
-                node.hooks = hooks_builder.build(Array(sv), hooks)
-                node_attribute.hooks = hooks_builder.enable_hooks
-              end
+              hook_contents = hooks_builder.build(Array(sv), hooks)
+              parsing_node_attribute.hooks = hooks_builder.enable_hooks
             else
+              ope = build_operations(sk, Array(sv), parsing_node_attribute, @options, false)
+              operations << ope if ope
+            end
+          end
 
-              next unless node
-
-              ope = build_operations(sk, Array(sv), node_attribute, @options, false)
-              node.add_operation(ope) if ope
+          nodes.each do |n|
+            operations.each do |o|
+              n.add_operation(o)
             end
+
+            n.hooks = hook_contents
           end
+
+          scen.nodes.concat(nodes)
         end
 
-        scen.nodes.push(node) if node
         scen
       end
 
       def build_task(tasks, backend, node_attribute)
         node = Node.new(node_attribute.nodename, backend)
@@ -84,11 +86,25 @@
         scen
       end
 
       private
 
+      def build_node_attribute(scenario, nodename, node_attribute, tasks, parsed_options)
+        if node_attribute.nil?
+          node_attribute = Rundock::Attribute::NodeAttribute.new(task_info: {})
+        else
+          node_attribute.init_except_take_over_state
+        end
+
+        node_attribute.nodename = nodename
+        tasks.each { |k, v| node_attribute.task_info[k] = v } if tasks
+        scenario.node_info[nodename.to_sym] = node_attribute.nodeinfo = parsed_options
+
+        node_attribute
+      end
+
       def build_cli_command_operation(command, node_attributes, cli_options)
-        node_attributes.nodename = @options[:host]
+        node_attributes.nodename = @options[:host] unless node_attributes.nodename
         node_attributes.errexit = !cli_options[:run_anyway]
         node_attributes.dry_run = cli_options[:dry_run] ? true : false
         Rundock::OperationFactory.instance(:command).create(Array(command), node_attributes.list)
       end