Method _run_scan

recon_engine.py:230–279

(
        self,
        scan_id: str,
        target: str,
        recon_types: List[ReconType],
        timeout: int,
    )

        }

    def _run_scan(
        self,
        scan_id: str,
        target: str,
        recon_types: List[ReconType],
        timeout: int,
    ) -> None:
        state = self.get_scan_state(scan_id)
        if not state:
            return

        state.status = "running"
        state.started_at = datetime.now()

        runner_map = {
            ReconType.TLS_AUDIT: self._run_tls_audit,
            ReconType.DNS_PASSIVE: self._run_dns_passive,
            ReconType.CONTENT_DISCOVERY: self._run_content_discovery,
        }

        try:
            with ThreadPoolExecutor(max_workers=len(recon_types)) as pool:
                futures = {
                    pool.submit(runner_map[rt], target): rt for rt in recon_types if rt in runner_map
                }
                for future in as_completed(futures, timeout=timeout):
                    rt = futures[future]
                    try:
                        result = future.result()
                    except Exception as exc:
                        import traceback
                        logger.error(f"Recon runner {rt.value} raised in {scan_id}: {exc}\n{traceback.format_exc()}")
                        result = ReconResult(
                            recon_type=rt,
                            target=target,
                            status="error",
                            error_message=str(exc),
                        )
                    state.results[rt] = result
        except TimeoutError:
            state.error_message = f"engine timeout after {timeout}s"
            logger.warning(f"Recon scan {scan_id} hit engine timeout")
        except Exception as exc:
            import traceback
            state.error_message = str(exc)
            logger.error(f"Recon scan {scan_id} engine failed: {exc}\n{traceback.format_exc()}")

        state.status = "completed"
        state.completed_at = datetime.now()
        self._scan_history.append(scan_id)

    def _run_tls_audit(self, target: str) -> ReconResult:
        result = ReconResult(recon_type=ReconType.TLS_AUDIT, target=target)