graph-crawler 5.3.5__tar.gz → 5.3.7__tar.gz

{graph_crawler-5.3.5 → graph_crawler-5.3.7}/CHANGELOG.md

@@ -2,6 +2,43 @@
 
 ## Unreleased
 
+## 5.3.7 — 2026-10
+
+### Fixed
+
+- **A crawl worker no longer dies on a canonical redirect while another SQLite statement is running.**
+  `SQLiteBackend._sync_execute` treated `sqlite3.OperationalError: cannot commit transaction - SQL statements in
+  progress` as a failed write, although the DELETE/UPDATE had already run in the open transaction of the shared
+  connection. The fallback `_run_async` then ran the coroutine on a new loop in a thread (`asyncio.Lock ... is bound to
+  a different event loop`) and, catching that `RuntimeError`, called `asyncio.run()` inside the running loop — the
+  worker failed (`Graph.remove_node` → `delete_node_sync`). Now:
+  - a commit refused because of in-progress statements is deferred: the change stays in the open transaction and is
+    committed by the next async commit or by `close()`;
+  - `_run_async` inside a running loop schedules the write as a task on that loop (errors are logged) instead of
+    blocking on a foreign loop; outside a loop it still runs synchronously;
+  - `close()` awaits scheduled writes and commits before closing.
+- Tests: `tests/test_sqlite_sync_write_in_loop.py`.
+
+## 5.3.6 — 2026-06
+
+### Fixed
+
+- **A timeout on robots.txt / sitemap stops the sitemap phase of the host (1.6, daxx.com).** A down origin behind
+  Cloudflare does not always answer 52x: robots.txt came back after ~20 s and every sitemap request hung until the
+  client timeout, then the default candidates (`sitemap.xml`, `sitemap_index.xml`) and the driver's retries/tier
+  escalation repeated it (80–180 s per domain). Now:
+  - `SitemapParser._fetch` bounds the whole request by `SitemapParser.timeout` (covers driver retries and tier
+    escalation); a timeout is an answer "origin does not respond", not a reason to try again;
+  - the first timeout (no status + timeout error, incl. the driver's `tier timeout after …`) or CF 520–527 marks the
+    host `ORIGIN_DOWN` (`SitemapParser.mark_origin_down` / `origin_down_reason`); no further request to that host in
+    this sitemap phase — no default candidates, no nested sitemaps, no retries;
+  - `result["origin_down_reason"]` = `"timeout"` | `"cf_52x"`; `SitemapSpider.origin_down`,
+    `get_stats()["origin_down"]`, `SITEMAP_CRAWL_COMPLETED.data["origin_down"]`, and the robots.txt node gets
+    `error_message = "origin_down: <reason>"`. A spider-level `SITEMAP_PARSE_TIMEOUT` also marks the host down.
+  - Non-timeout network errors (DNS, connection refused) keep the old behaviour (default candidates are tried).
+  Live: daxx.com sitemap phase 80 s → 50 s (robots ~20 s + one 30 s timeout), healthy sites unchanged.
+- Tests: `tests/test_sitemap_origin_down_timeout.py` (8).
+
 ## 5.3.5 — 2026-06
 
 ### Fixed

{graph_crawler-5.3.5/graph_crawler.egg-info → graph_crawler-5.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-crawler
-Version: 5.3.5
+Version: 5.3.7
 Summary: Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines.
 Author: 0-EternalJunior-0
 Maintainer: 0-EternalJunior-0

{graph_crawler-5.3.5 → graph_crawler-5.3.7}/graph_crawler/application/use_cases/crawling/sitemap_parser.py

@@ -64,6 +64,12 @@ _MSG_UNKNOWN_SITEMAP_TYPE = "Unknown sitemap type: %s"
 # тому такі файли читаються напряму через aiohttp навіть за наявності драйвера.
 _BINARY_CONTENT_TYPES = ("gzip", "octet-stream")
 
+# Причини ORIGIN_DOWN: origin не відповідає — sitemap-фаза хоста зупиняється без ретраїв.
+ORIGIN_DOWN_CF_5XX = "cf_52x"
+ORIGIN_DOWN_TIMEOUT = "timeout"
+# Як різні транспорти формулюють таймаут у ``FetchResponse.error`` (aiohttp, curl_cffi, тир-ланцюг).
+_TIMEOUT_ERROR_MARKERS = ("timeout", "timed out")
+
 
 @dataclass
 class _Fetched:
@@ -154,6 +160,10 @@ class SitemapParser:
         # щоб уникнути шуму, коли той самий сайт запитується декілька разів.
         self._logged_domain_redirects: set[tuple[str, str]] = set()
 
+        # Хости з лежачим origin (CF 52x або таймаут запиту): host → причина. Перший такий
+        # сигнал зупиняє sitemap-фазу хоста — далі жодного запиту, ні ретраю, ні кандидата.
+        self._down_hosts: dict[str, str] = {}
+
         self._xml_executor = ThreadPoolExecutor(
             max_workers=4, thread_name_prefix=f"xml_parser_{id(self)}_"
         )
@@ -191,6 +201,18 @@ class SitemapParser:
         return url.lower().endswith(".gz") or any(t in content_type for t in _BINARY_CONTENT_TYPES)
 
     async def _fetch(self, url: str) -> _Fetched:
+        """robots.txt/sitemap з верхньою межею ``self.timeout`` на весь запит.
+
+        Межа покриває і ретраї, і ескалацію тирів драйвера: таймаут — це вже відповідь
+        «origin не відповідає», а не привід пробувати ще раз (див. ``ORIGIN_DOWN``).
+        """
+        try:
+            async with asyncio.timeout(self.timeout):
+                return await self._fetch_unbounded(url)
+        except TimeoutError:
+            return _Fetched(status=None, final_url=url, error=f"timeout after {self.timeout}s")
+
+    async def _fetch_unbounded(self, url: str) -> _Fetched:
         """robots.txt/sitemap через ``IDriver`` (тир-ланцюг) або власний aiohttp.
 
         ``FetchResponse.html`` — текст: бінарні ``.gz`` (за URL або Content-Type)
@@ -263,20 +285,15 @@ class SitemapParser:
                 - ``sitemap_indexes``: sitemap-index URL (якщо є).
         """
         result = {"sitemap_urls": [], "urls": [], "sitemap_indexes": []}
+        robots_url = urljoin(base_url, "/robots.txt")
+        if self._mark_if_origin_down_cached(robots_url, result):
+            return result
 
         try:
-            robots_url = urljoin(base_url, "/robots.txt")
             fetched = await self._fetch(robots_url)
 
-            if self._is_origin_down(fetched.status):
-                logger.warning(
-                    "ORIGIN_DOWN: %s returned %s (Cloudflare origin error) — "
-                    "stopping sitemap phase without retries",
-                    robots_url,
-                    fetched.status,
-                )
-                result["origin_down"] = True
-                return result
+            if self._check_origin(robots_url, fetched):
+                return self._with_origin_down(robots_url, result)
 
             if fetched.status != 200 or fetched.body is None:
                 logger.warning("robots.txt not found at %s", robots_url)
@@ -306,6 +323,7 @@ class SitemapParser:
                     if isinstance(sitemap_data, dict):
                         if sitemap_data.get("origin_down"):
                             result["origin_down"] = True
+                            result["origin_down_reason"] = sitemap_data.get("origin_down_reason")
                         result["urls"].extend(sitemap_data.get("urls", []))
                         result["sitemap_indexes"].extend(sitemap_data.get("sitemap_indexes", []))
                         result.setdefault("lastmod", {}).update(sitemap_data.get("lastmod", {}))
@@ -315,7 +333,8 @@ class SitemapParser:
 
         except Exception as e:
             logger.error(_MSG_ROBOTS_READ_ERROR, base_url, e)
-            result = await self._try_default_sitemaps_async(base_url, result)
+            if not self._mark_if_origin_down_cached(robots_url, result):
+                result = await self._try_default_sitemaps_async(base_url, result)
 
         result["urls"] = list(set(result["urls"]))
         result["sitemap_indexes"] = list(set(result["sitemap_indexes"]))
@@ -335,6 +354,7 @@ class SitemapParser:
                 sitemap_data = await self.parse_sitemap_async(sitemap_url)
                 if sitemap_data.get("origin_down"):
                     result["origin_down"] = True
+                    result["origin_down_reason"] = sitemap_data.get("origin_down_reason")
                     break
                 if sitemap_data["urls"] or sitemap_data["sitemap_indexes"]:
                     result["sitemap_urls"].append(sitemap_url)
@@ -367,19 +387,14 @@ class SitemapParser:
         if cached is not None:
             logger.debug("Sitemap cache hit: %s", sitemap_url)
             return cached
+        if self._mark_if_origin_down_cached(sitemap_url, result):
+            return result
 
         try:
             fetched = await self._fetch(sitemap_url)
 
-            if self._is_origin_down(fetched.status):
-                logger.warning(
-                    "ORIGIN_DOWN: sitemap %s returned %s (Cloudflare origin error) — "
-                    "no retries",
-                    sitemap_url,
-                    fetched.status,
-                )
-                result["origin_down"] = True
-                return result
+            if self._check_origin(sitemap_url, fetched):
+                return self._with_origin_down(sitemap_url, result)
 
             if fetched.status not in (200, 301, 302) or fetched.body is None:
                 logger.warning(
@@ -562,6 +577,55 @@ class SitemapParser:
             return raw.split()[0]
         return None
 
+    def origin_down_reason(self, url: str) -> str | None:
+        """Причина ORIGIN_DOWN для хоста ``url`` (``cf_52x``/``timeout``) або ``None``."""
+        return self._down_hosts.get(urlparse(url).hostname or "")
+
+    def mark_origin_down(self, url: str, reason: str, detail: str | int | None = None) -> None:
+        """Позначає origin хоста ``url`` лежачим: решта sitemap-фази хоста — без запитів."""
+        host = urlparse(url).hostname or ""
+        if not host or host in self._down_hosts:
+            return
+        self._down_hosts[host] = reason
+        logger.warning(
+            "ORIGIN_DOWN: %s (%s, %s on %s) — stopping sitemap phase for host without retries",
+            host,
+            reason,
+            detail,
+            url,
+        )
+
+    def _check_origin(self, url: str, fetched: _Fetched) -> bool:
+        """``True`` і позначка хоста, якщо відповідь каже «origin лежить» (CF 52x або таймаут)."""
+        if self._is_origin_down(fetched.status):
+            self.mark_origin_down(url, ORIGIN_DOWN_CF_5XX, fetched.status)
+            return True
+        if self._is_timeout(fetched):
+            self.mark_origin_down(url, ORIGIN_DOWN_TIMEOUT, fetched.error)
+            return True
+        return False
+
+    def _with_origin_down(self, url: str, result: dict) -> dict:
+        result["origin_down"] = True
+        result["origin_down_reason"] = self.origin_down_reason(url)
+        return result
+
+    def _mark_if_origin_down_cached(self, url: str, result: dict) -> bool:
+        """Хост уже позначено лежачим — віддаємо ``origin_down`` без запиту."""
+        if self.origin_down_reason(url) is None:
+            return False
+        logger.debug("ORIGIN_DOWN: skipping %s (host already down)", url)
+        self._with_origin_down(url, result)
+        return True
+
+    @staticmethod
+    def _is_timeout(fetched: _Fetched) -> bool:
+        """Таймаут без відповіді сервера: статусу немає, у помилці — ознака таймауту."""
+        if fetched.status is not None or not fetched.error:
+            return False
+        error = fetched.error.lower()
+        return any(marker in error for marker in _TIMEOUT_ERROR_MARKERS)
+
     @staticmethod
     def _is_origin_down(status: int | None) -> bool:
         """``True`` для Cloudflare-origin помилок 520–527 (origin недоступний).

{graph_crawler-5.3.5 → graph_crawler-5.3.7}/graph_crawler/application/use_cases/crawling/sitemap_spider.py

@@ -23,7 +23,10 @@ from graph_crawler.application.use_cases.crawling.base_spider import (
     BaseSpider,
     CrawlerState,
 )
-from graph_crawler.application.use_cases.crawling.sitemap_parser import SitemapParser
+from graph_crawler.application.use_cases.crawling.sitemap_parser import (
+    ORIGIN_DOWN_TIMEOUT,
+    SitemapParser,
+)
 from graph_crawler.application.use_cases.crawling.sitemap_processor import (
     SitemapProcessor,
 )
@@ -127,6 +130,8 @@ class SitemapSpider(BaseSpider):
 
         # Зберігаємо вже оброблені sitemap URLs для детекції циклів
         self._processed_sitemaps: set[str] = set()
+        # Причина ORIGIN_DOWN (cf_52x/timeout), якщо sitemap-фазу зупинено через лежачий origin.
+        self.origin_down: str | None = None
 
         logger.info(
             f"SitemapSpider (async) initialized: "
@@ -171,7 +176,7 @@ class SitemapSpider(BaseSpider):
             sitemap_data = await self._parse_robots_txt(robots_url)
 
             # Створюємо Node для robots.txt
-            self.processor.create_robots_node(
+            robots_node = self.processor.create_robots_node(
                 url=robots_url,
                 sitemap_urls=sitemap_data.get("sitemap_urls", []),
                 error=sitemap_data.get("error"),
@@ -179,7 +184,13 @@ class SitemapSpider(BaseSpider):
 
             # Обробляємо кожен знайдений sitemap
             sitemap_urls = sitemap_data.get("sitemap_urls", [])
-            if sitemap_urls:
+            if sitemap_data.get("origin_down"):
+                logger.warning(
+                    "Sitemap phase stopped for %s: ORIGIN_DOWN (%s)",
+                    self.config.url,
+                    sitemap_data.get("origin_down_reason"),
+                )
+            elif sitemap_urls:
                 # Сортуємо за пріоритетом якщо є url_rules
                 if self.url_rules:
                     sitemap_urls = self._sort_sitemaps_by_priority(sitemap_urls)
@@ -198,6 +209,10 @@ class SitemapSpider(BaseSpider):
                     robots_url,
                 )
 
+            self.origin_down = self._origin_down_reason(robots_url, sitemap_urls)
+            if self.origin_down and robots_node is not None:
+                robots_node.error_message = f"origin_down: {self.origin_down}"
+
             # Завершення
             duration = time.time() - start_time
             stats = self.graph.get_stats()
@@ -238,6 +253,7 @@ class SitemapSpider(BaseSpider):
                         "sitemaps_processed": self.sitemaps_processed,
                         "urls_extracted": self.urls_extracted,
                         "duration": duration,
+                        "origin_down": self.origin_down,
                     },
                 )
             )
@@ -282,6 +298,8 @@ class SitemapSpider(BaseSpider):
             return {
                 "sitemap_urls": result.get("sitemap_urls", []),
                 "error": None,
+                "origin_down": bool(result.get("origin_down")),
+                "origin_down_reason": result.get("origin_down_reason"),
             }
 
         except Exception as e:
@@ -477,6 +495,11 @@ class SitemapSpider(BaseSpider):
             self.sitemaps_skipped += 1
             return
 
+        if self._parser_down(sitemap_url):
+            logger.info("Skipping sitemap (ORIGIN_DOWN): %s", sitemap_url)
+            self.sitemaps_skipped += 1
+            return
+
         logger.info("Processing sitemap: %s (depth=%s, priority=%s)", sitemap_url, depth, priority)
 
         try:
@@ -493,6 +516,9 @@ class SitemapSpider(BaseSpider):
                 logger.warning(
                     "Timeout parsing sitemap (%ss): %s", SITEMAP_PARSE_TIMEOUT, sitemap_url
                 )
+                mark = getattr(self.parser, "mark_origin_down", None)
+                if mark is not None:
+                    mark(sitemap_url, ORIGIN_DOWN_TIMEOUT, f"parse timeout {SITEMAP_PARSE_TIMEOUT}s")
                 self.processor.create_error_node(
                     url=sitemap_url,
                     parent_url=parent_url,
@@ -500,6 +526,9 @@ class SitemapSpider(BaseSpider):
                     depth=depth,
                 )
                 return
+            if sitemap_data.get("origin_down"):
+                self.sitemaps_skipped += 1
+                return
             has_nested_sitemaps = len(sitemap_data.get("sitemap_indexes", [])) > 0
             has_urls = len(sitemap_data.get("urls", [])) > 0
 
@@ -594,8 +623,23 @@ class SitemapSpider(BaseSpider):
         stats["sitemaps_skipped"] = self.sitemaps_skipped
         stats["urls_extracted"] = self.urls_extracted
         stats["url_rules_count"] = len(self.url_rules)
+        stats["origin_down"] = self.origin_down
         return stats
 
+    def _origin_down_reason(self, robots_url: str, sitemap_urls: list[str]) -> str | None:
+        """Перша причина ORIGIN_DOWN серед хоста сайту та хостів його sitemap-ів."""
+        for url in (robots_url, *sitemap_urls):
+            reason = self._parser_down(url)
+            if reason:
+                return reason
+        return None
+
+    def _parser_down(self, url: str) -> str | None:
+        """ORIGIN_DOWN хоста від парсера; інжектований парсер без цього API — ``None``."""
+        fn = getattr(self.parser, "origin_down_reason", None)
+        reason = fn(url) if fn is not None else None
+        return reason if isinstance(reason, str) else None
+
     async def close(self) -> None:
         """Async закриває ресурси Spider."""
         await self.driver.close()

{graph_crawler-5.3.5 → graph_crawler-5.3.7}/graph_crawler/data/backends/sqlite.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+import sqlite3
 from collections import OrderedDict, defaultdict
 from collections.abc import Mapping
 from contextlib import asynccontextmanager
@@ -275,6 +276,8 @@ class SQLiteBackend:
         # Task, що тримає transaction(); методи з цього task
         # не беруть lock повторно (asyncio.Lock не reentrant → deadlock)
         self._transaction_task: asyncio.Task | None = None
+        # Записи, заплановані *_sync-методами задачами на робочому event loop.
+        self._pending_writes: set[asyncio.Task] = set()
 
         # Stats
         self._use_cache = True  # Use in-memory cache for fast reads
@@ -425,7 +428,13 @@ class SQLiteBackend:
     def _sync_execute(self, statements: list[tuple[str, tuple]]) -> int | None:
         """Синхронний запис через спільне з'єднання (без ``_run_async``
         і cross-loop ``asyncio.Lock``). None → з'єднання немає; інакше rowcount
-        першого statement-у."""
+        першого statement-у.
+
+        Якщо на з'єднанні саме відкритий курсор aiosqlite-воркера, SQLite відмовляє
+        у commit («SQL statements in progress»). Зміни вже лежать у відкритій
+        транзакції цього ж з'єднання й фіксуються найближчим async-commit-ом
+        (або в ``close()``), тож запис вважається успішним.
+        """
         conn = self._conn
         raw = getattr(conn, "_connection", None) if conn is not None else None
         if raw is None:
@@ -436,7 +445,12 @@ class SQLiteBackend:
                 cur = raw.execute(sql, params)
                 if rowcount is None:
                     rowcount = cur.rowcount
-            raw.commit()
+            try:
+                raw.commit()
+            except sqlite3.OperationalError:
+                if not raw.in_transaction:
+                    raise
+                logger.debug("SQLiteBackend sync write: commit deferred (statements in progress)")
             return rowcount if rowcount is not None else 0
         except Exception:
             logger.warning("SQLiteBackend sync write failed", exc_info=True)
@@ -580,7 +594,10 @@ class SQLiteBackend:
 
     async def close(self) -> None:
         """Закриває з'єднання."""
+        if self._pending_writes:
+            await asyncio.gather(*self._pending_writes, return_exceptions=True)
         if self._conn:
+            await self._conn.commit()
             await self._conn.close()
             self._conn = None
         self._is_open = False
@@ -1597,20 +1614,28 @@ class SQLiteBackend:
     # SYNC WRAPPERS
     # ═══════════════════════════════════════════════════════════════════════════
 
-    def _run_async(self, coro):
-        """Запускає coroutine синхронно."""
+    def _run_async(self, coro, result_in_loop: Any):
+        """Виконує async-запис із sync-коду.
+
+        Поза event loop — синхронно через ``asyncio.run``. Усередині робочого loop
+        дочекатися coroutine неможливо: ``self._lock`` і з'єднання aiosqlite
+        прив'язані до цього loop, а окремий loop у потоці падає з «bound to a
+        different event loop». Тому запис планується задачею на поточному loop,
+        а викликачу повертається ``result_in_loop``.
+        """
         try:
             loop = asyncio.get_running_loop()
-            if loop.is_running():
-                # Already in async context - use cache directly
-                import concurrent.futures
-
-                with concurrent.futures.ThreadPoolExecutor() as executor:
-                    future = executor.submit(asyncio.run, coro)
-                    return future.result()
-            return loop.run_until_complete(coro)
         except RuntimeError:
             return asyncio.run(coro)
+        task = loop.create_task(coro)
+        self._pending_writes.add(task)
+        task.add_done_callback(self._on_pending_write_done)
+        return result_in_loop
+
+    def _on_pending_write_done(self, task: asyncio.Task) -> None:
+        self._pending_writes.discard(task)
+        if not task.cancelled() and task.exception() is not None:
+            logger.warning("SQLiteBackend scheduled write failed", exc_info=task.exception())
 
     def insert_node_sync(self, node: Any) -> Any:
         # Use cache directly for sync calls
@@ -1656,7 +1681,7 @@ class SQLiteBackend:
         if url is None:
             rows = self._sync_fetchall("SELECT url FROM nodes WHERE node_id = ?", (node_id,))
             if rows is None:
-                return self._run_async(self.delete_node(node_id))
+                return self._run_async(self.delete_node(node_id), result_in_loop=True)
             if not rows:
                 return False
             url = rows[0][0]
@@ -1670,7 +1695,7 @@ class SQLiteBackend:
             ]
         )
         if deleted is None:
-            return self._run_async(self.delete_node(node_id))
+            return self._run_async(self.delete_node(node_id), result_in_loop=True)
         if self._use_cache:
             self._cache_remove(node_id, url)
             self._edges = [
@@ -1764,8 +1789,8 @@ class SQLiteBackend:
 
         Проблема залишається на рівні **диску**: SQLite-рядок не оновлюється,
         поки ніхто явно не викличе ``update_node``. Цей метод вирішує проблему:
-        викликає ``update_node(node)`` синхронно через ``_run_async`` так само,
-        як це робиться у ``iter_nodes_sync`` / ``insert_node_sync``.
+        пише рядок напряму через ``_sync_execute``; якщо це неможливо — передає
+        ``update_node(node)`` у ``_run_async``.
 
         Args:
             node: Ноду з оновленими полями (``node_id`` має існувати у БД).
@@ -1813,7 +1838,7 @@ class SQLiteBackend:
             ]
         )
         if rowcount is None:
-            return self._run_async(self.update_node(node))
+            return self._run_async(self.update_node(node), result_in_loop=True)
         if rowcount > 0:
             self._dirty_node_ids.discard(node.node_id)
             return True

{graph_crawler-5.3.5 → graph_crawler-5.3.7/graph_crawler.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graph-crawler
-Version: 5.3.5
+Version: 5.3.7
 Summary: Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines.
 Author: 0-EternalJunior-0
 Maintainer: 0-EternalJunior-0

{graph_crawler-5.3.5 → graph_crawler-5.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graph-crawler"
-version = "5.3.5"
+version = "5.3.7"
 description = "Web crawler that builds a graph of a site. HTTP → TLS → browser escalation with pluggable browser engines."
 readme = "README.md"
 requires-python = ">=3.11"