Method process_alive_ips

orchestrator.py:294–399

Process all IPs with alive status set to 1

(self, current_data)

            logger.error(f"Module {module_name} is missing required attributes: {e}")

    def process_alive_ips(self, current_data):
        """Process all IPs with alive status set to 1"""
        any_action_executed = False
        action_executed_status = None
        
        # Debug: Log what we're processing
        alive_hosts = [row for row in current_data if row.get("Alive") == '1']
        logger.debug(f"Processing {len(alive_hosts)} alive hosts out of {len(current_data)} total hosts")
        logger.debug(f"Available actions: {len(self.actions)} (parent+child actions)")
        
        if not alive_hosts:
            logger.warning("No alive hosts to process - all hosts have Alive != '1'")
            return False
        
        if not self.actions:
            logger.warning("No actions loaded - check actions.json configuration")
            return False

        # Process all parent actions (those without dependencies) across ALL hosts
        for action in self.actions:
            if action.b_parent_action is None:
                action_key = action.action_name
                required_port = getattr(action, 'port', None)
                
                # Pre-filter hosts by port requirement (FAST - no semaphore needed)
                for row in current_data:
                    if row["Alive"] != '1':
                        continue
                    
                    ip = row["IPs"]
                    ports = self._extract_ports(row)
                    
                    # OPTIMIZATION: Check port requirement BEFORE acquiring semaphore
                    # This prevents serializing hundreds of "port not found" checks
                    if required_port not in (None, '', 0, '0'):
                        required_port_str = str(required_port).strip().split('/')[0]
                        ports_normalized = [str(p).strip().split('/')[0] for p in ports]
                        
                        if required_port_str not in ports_normalized:
                            # Skip silently - port not available (no semaphore needed)
                            continue
                    
                    # MEMORY CHECK: Prevent OOM kills
                    if not resource_monitor.can_start_operation(f"action_{action_key}", min_memory_mb=30):
                        logger.warning(f"Insufficient memory to execute {action_key}, skipping to prevent OOM")
                        continue
                    
                    # Only acquire semaphore when we actually need to execute
                    with self.semaphore:
                        if self.execute_action(action, ip, ports, row, action_key, current_data):
                            action_executed_status = action_key
                            any_action_executed = True
                            self.shared_data.ragnarorch_status = action_executed_status
                            
                            # After parent succeeds, immediately try child actions on same host
                            # Note: Already within semaphore context, no need to re-acquire
                            for child_action in self.actions:
                                if child_action.b_parent_action == action_key: