feat(service): timeout_sec без дефолта; 0=нет таймаута; operator v0.1.48

- api/v1alpha1/service_types.go: убрать +kubebuilder:default=30 - invoke.go: TimeoutSec=0 → &http.Client{} (без таймаута) - services.go: валидация timeout_sec < 0 || > 900 → HTTP 400 - service_resource.go: TF schema Optional (без Computed); 0 → Int64Null() - deployments/k8s/operator.yaml: v0.1.47 → v0.1.48 - doc/: progress.md + api/design.md (модель Service) + decisions/log.md - examples/POSTGRES/: bug_hunter.sh, chaos_marathon.sh, chaos_marathon.tf
2026-03-21 16:58:43 +03:00
parent 7f7aa44e59
commit b86ff3a62e
37 changed files with 2493 additions and 50 deletions
@@ -0,0 +1,40 @@
+# 2026-03-21 — chaos-badparams: проверяет что функция не падает на мусорных входных данных.
+# Принимает type=missing|wrong_type|huge|negative|zero и возвращает safe-ответ.
+# Тестирует: устойчивость к "тупому юзеру" — никакого 500 на плохих входных данных.
+import json
+
+_MAX_N = 10_000
+
+def validate(event):
+    errors = []
+    results = {}
+
+    # n: должно быть int от 1 до MAX_N
+    raw_n = event.get("n")
+    try:
+        n = int(raw_n)
+        if n <= 0:
+            errors.append(f"n must be > 0, got {n}")
+            n = 1
+        elif n > _MAX_N:
+            errors.append(f"n capped from {n} to {_MAX_N}")
+            n = _MAX_N
+    except (TypeError, ValueError):
+        errors.append(f"n is not a valid int: {repr(raw_n)}, using default 1")
+        n = 1
+    results["n"] = n
+
+    # name: обрезаем до 100 символов
+    raw_name = event.get("name", "")
+    if not isinstance(raw_name, str):
+        raw_name = str(raw_name)
+        errors.append("name was not a string, converted")
+    name = raw_name[:100]
+    results["name"] = name
+
+    # flag: любое "truthy" значение
+    raw_flag = event.get("flag", False)
+    flag = raw_flag in (True, "true", "1", 1, "yes")
+    results["flag"] = flag
+
+    return {"ok": len(errors) == 0, "errors": errors, "results": results}
@@ -0,0 +1,27 @@
+# 2026-03-21 — chaos-bigpayload: генерирует/принимает большой JSON.
+# Тестирует: большие ответы (64KB+), память рантайма.
+import json, time
+
+def bigpayload(event):
+    size_kb = min(int(event.get("size_kb", 16)), 256)   # cap 256KB
+    word = str(event.get("word", "x"))[:32]
+
+    # Генерируем список строк нужного размера
+    chunk = word * 32   # ~32+ байт на запись
+    items = []
+    total = 0
+    target = size_kb * 1024
+    i = 0
+    while total < target:
+        entry = f"{chunk}-{i}"
+        items.append(entry)
+        total += len(entry) + 3   # 3 байта JSON overhead
+        i += 1
+
+    return {
+        "items_count": len(items),
+        "size_kb_approx": round(total / 1024, 1),
+        "first": items[0] if items else "",
+        "last": items[-1] if items else "",
+        "ts": int(time.time()),
+    }
@@ -0,0 +1,19 @@
+# 2026-03-21 — chaos-echo: отражает входные данные обратно.
+# Тестирует: большие payload, unicode, null, вложенные структуры, спецсимволы.
+# "Тупой юзер" шлёт всё что угодно — функция должна вернуть это обратно без падения.
+import json
+
+def echo(event):
+    # Пытаемся сериализовать обратно — выловит непериализуемые типы
+    try:
+        size = len(json.dumps(event))
+    except Exception:
+        size = -1
+
+    keys = list(event.keys()) if isinstance(event, dict) else []
+    return {
+        "echo": event,
+        "keys": keys,
+        "size_bytes": size,
+        "type": type(event).__name__,
+    }
@@ -0,0 +1,19 @@
+# 2026-03-21 — chaos-slowquery: намеренно медленный запрос через pg_sleep.
+# Тестирует: timeout enforcement — платформа должна прервать запрос если > timeout_sec.
+# sleep_sec cap = 8 (меньше timeout_sec=10 сервиса → успех; >10 → таймаут платформы).
+import os, psycopg2
+
+def slowquery(event):
+    sleep_sec = min(float(event.get("sleep_sec", 2.0)), 8.0)
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor() as cur:
+            cur.execute("SELECT pg_sleep(%s), now()::text", (sleep_sec,))
+            result = cur.fetchone()
+        return {"slept_sec": sleep_sec, "pg_now": result[1]}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,55 @@
+// 2026-03-21 — go-counter-atomic: считает вызовы через atomic в памяти + пишет в PG.
+// Тестирует: in-memory state между вызовами (Go pod остаётся живым), + PG INSERT на каждый вызов.
+package handler
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync/atomic"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// invocations считается между вызовами (пока pod жив).
+var invocations int64
+
+// Handle записывает факт вызова в PG и возвращает накопленный счётчик.
+func Handle(event map[string]interface{}) interface{} {
+	n := atomic.AddInt64(&invocations, 1)
+
+	dsn := fmt.Sprintf(
+		"host=%s port=%s dbname=%s user=%s password=%s sslmode=%s",
+		os.Getenv("PGHOST"), envOrDefault("PGPORT", "5432"),
+		os.Getenv("PGDATABASE"), os.Getenv("PGUSER"),
+		os.Getenv("PGPASSWORD"), envOrDefault("PGSSLMODE", "require"),
+	)
+	pool, err := pgxpool.New(context.Background(), dsn)
+	if err != nil {
+		return map[string]interface{}{"invocation_n": n, "error": err.Error()}
+	}
+	defer pool.Close()
+
+	title := fmt.Sprintf("go-counter-invoke-%d-%d", n, time.Now().UnixMilli())
+	var id int64
+	err = pool.QueryRow(context.Background(),
+		"INSERT INTO terraform_demo_table (title) VALUES ($1) RETURNING id", title,
+	).Scan(&id)
+	if err != nil {
+		return map[string]interface{}{"invocation_n": n, "error": err.Error()}
+	}
+
+	return map[string]interface{}{
+		"invocation_n": n,
+		"inserted_id":  id,
+		"title":        title,
+	}
+}
+
+func envOrDefault(key, def string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return def
+}
@@ -0,0 +1,94 @@
+// 2026-03-21 — go-pg-race: параллельные INSERT из нескольких горутин внутри одной функции.
+// Тестирует: race condition устойчивость Go + PG при concurrent writes из одного пода.
+// Использует pgx/v5 (pre-cached в base image).
+package handler
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+// Handle запускает workers горутин, каждая делает n_per_worker INSERTs.
+func Handle(event map[string]interface{}) interface{} {
+	workers := intParam(event, "workers", 5)
+	if workers > 20 {
+		workers = 20
+	}
+	nPerWorker := intParam(event, "n_per_worker", 10)
+	if nPerWorker > 50 {
+		nPerWorker = 50
+	}
+
+	dsn := fmt.Sprintf(
+		"host=%s port=%s dbname=%s user=%s password=%s sslmode=%s",
+		os.Getenv("PGHOST"), getenv("PGPORT", "5432"),
+		os.Getenv("PGDATABASE"), os.Getenv("PGUSER"),
+		os.Getenv("PGPASSWORD"), getenv("PGSSLMODE", "require"),
+	)
+	pool, err := pgxpool.New(context.Background(), dsn)
+	if err != nil {
+		return map[string]interface{}{"error": err.Error()}
+	}
+	defer pool.Close()
+
+	var (
+		wg       sync.WaitGroup
+		ok       int64
+		errCount int64
+	)
+	t0 := time.Now()
+	for w := 0; w < workers; w++ {
+		wg.Add(1)
+		go func(wid int) {
+			defer wg.Done()
+			for i := 0; i < nPerWorker; i++ {
+				title := fmt.Sprintf("go-race-w%d-%d-%d", wid, time.Now().UnixMilli(), i)
+				_, err := pool.Exec(context.Background(),
+					"INSERT INTO terraform_demo_table (title) VALUES ($1)", title)
+				if err != nil {
+					atomic.AddInt64(&errCount, 1)
+				} else {
+					atomic.AddInt64(&ok, 1)
+				}
+			}
+		}(w)
+	}
+	wg.Wait()
+	elapsed := time.Since(t0).Seconds()
+
+	return map[string]interface{}{
+		"workers":      workers,
+		"n_per_worker": nPerWorker,
+		"inserted":     ok,
+		"errors":       errCount,
+		"elapsed_sec":  elapsed,
+		"ops_per_sec":  float64(ok) / elapsed,
+	}
+}
+
+func intParam(event map[string]interface{}, key string, def int) int {
+	v, ok := event[key]
+	if !ok {
+		return def
+	}
+	switch val := v.(type) {
+	case float64:
+		return int(val)
+	case int:
+		return val
+	}
+	return def
+}
+
+func getenv(key, def string) string {
+	if v := os.Getenv(key); v != "" {
+		return v
+	}
+	return def
+}
@@ -0,0 +1,58 @@
+// 2026-03-21 — js-idempotent: INSERT с проверкой по idempotency_key.
+// Повторный вызов с тем же key НЕ создаёт дубль — возвращает существующую запись.
+// Тестирует: идемпотентность через SELECT ... FOR UPDATE + условный INSERT.
+const { Client } = require('pg');
+
+async function run(event) {
+    const key = String(event.idempotency_key ?? `auto-${Date.now()}`).slice(0, 200);
+    const title = String(event.title ?? key).slice(0, 255);
+
+    const client = new Client({
+        host: process.env.PGHOST,
+        port: parseInt(process.env.PGPORT ?? '5432'),
+        database: process.env.PGDATABASE,
+        user: process.env.PGUSER,
+        password: process.env.PGPASSWORD,
+        ssl: { rejectUnauthorized: false },
+    });
+    await client.connect();
+
+    try {
+        await client.query('BEGIN');
+
+        // Ищем существующую запись по title (используем как idempotency key)
+        const existing = await client.query(
+            'SELECT id, title, created_at FROM terraform_demo_table WHERE title = $1 LIMIT 1 FOR UPDATE',
+            [key]
+        );
+
+        let action, row;
+        if (existing.rows.length > 0) {
+            action = 'existing';
+            row = existing.rows[0];
+        } else {
+            const ins = await client.query(
+                'INSERT INTO terraform_demo_table (title) VALUES ($1) RETURNING id, title, created_at',
+                [key]
+            );
+            action = 'created';
+            row = ins.rows[0];
+        }
+
+        await client.query('COMMIT');
+        return {
+            action,
+            id: row.id,
+            title: row.title,
+            created_at: row.created_at,
+            idempotency_key: key,
+        };
+    } catch (e) {
+        await client.query('ROLLBACK');
+        throw e;
+    } finally {
+        await client.end();
+    }
+}
+
+module.exports = { run };
@@ -0,0 +1,7 @@
+{
+  "name": "js-idempotent",
+  "version": "1.0.0",
+  "dependencies": {
+    "pg": "^8.11.3"
+  }
+}
@@ -0,0 +1,43 @@
+// 2026-03-21 — js-pg-batch: вставляет N строк через parameterized bulk query.
+// Тестирует: async/await PG с пакетной вставкой, Node.js под нагрузкой.
+const { Client } = require('pg');
+
+async function run(event) {
+    const n = Math.min(parseInt(event.n ?? 20, 10) || 20, 200);
+    const prefix = String(event.prefix ?? 'js-batch').slice(0, 40);
+
+    const client = new Client({
+        host: process.env.PGHOST,
+        port: parseInt(process.env.PGPORT ?? '5432'),
+        database: process.env.PGDATABASE,
+        user: process.env.PGUSER,
+        password: process.env.PGPASSWORD,
+        ssl: { rejectUnauthorized: false },
+    });
+    await client.connect();
+
+    try {
+        const ts = Date.now();
+        // Строим multi-value INSERT: INSERT INTO ... VALUES ($1), ($2), ...
+        const placeholders = [];
+        const values = [];
+        for (let i = 0; i < n; i++) {
+            placeholders.push(`($${i + 1})`);
+            values.push(`${prefix}-${ts}-${i}`);
+        }
+        const sql = `INSERT INTO terraform_demo_table (title) VALUES ${placeholders.join(',')} RETURNING id`;
+        const t0 = Date.now();
+        const res = await client.query(sql, values);
+        const elapsed = (Date.now() - t0) / 1000;
+
+        return {
+            inserted: res.rowCount,
+            first_id: res.rows[0]?.id ?? null,
+            elapsed_sec: elapsed,
+        };
+    } finally {
+        await client.end();
+    }
+}
+
+module.exports = { run };
@@ -0,0 +1,7 @@
+{
+  "name": "js-pg-batch",
+  "version": "1.0.0",
+  "dependencies": {
+    "pg": "^8.11.3"
+  }
+}
@@ -0,0 +1,38 @@
+# 2026-03-21 — pg-bulk-insert: bulk INSERT через execute_values.
+# Тестирует: большие батчи (до 500 строк), производительность, память.
+import os, time, psycopg2, psycopg2.extras
+
+def bulk_insert(event):
+    try:
+        n = max(0, min(int(event.get("n", 50)), 500))  # cap 500, min 0
+    except (TypeError, ValueError):
+        n = 50
+    prefix = str(event.get("prefix", "bulk"))[:50]
+    ts = int(time.time() * 1000)
+
+    # n=0 — граничный случай: вернуть сразу без обращения к PG.
+    if n == 0:
+        return {"inserted": 0, "first_id": None, "elapsed_sec": 0.0}
+
+    rows = [(f"{prefix}-{ts}-{i}",) for i in range(n)]
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        t0 = time.time()
+        with conn.cursor() as cur:
+            psycopg2.extras.execute_values(
+                cur,
+                "INSERT INTO terraform_demo_table (title) VALUES %s RETURNING id",
+                rows,
+                page_size=100,
+            )
+            ids = [r[0] for r in cur.fetchall()]
+        conn.commit()
+        elapsed = round(time.time() - t0, 3)
+        return {"inserted": len(ids), "first_id": ids[0] if ids else None, "elapsed_sec": elapsed}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,23 @@
+# 2026-03-21 — pg-counter: считает строки по prefix, возвращает статистику.
+# Тестирует: SELECT COUNT с WHERE LIKE, агрегация, concurrent reads.
+import os, psycopg2
+
+def count(event):
+    prefix = event.get("prefix", "")
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor() as cur:
+            if prefix:
+                cur.execute("SELECT COUNT(*) FROM terraform_demo_table WHERE title LIKE %s", (f"{prefix}%",))
+            else:
+                cur.execute("SELECT COUNT(*) FROM terraform_demo_table")
+            total = cur.fetchone()[0]
+            cur.execute("SELECT COUNT(*) FROM terraform_demo_table WHERE created_at > now() - interval '1 hour'")
+            last_hour = cur.fetchone()[0]
+        return {"total": total, "last_hour": last_hour, "prefix": prefix or "*"}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,38 @@
+# 2026-03-21 — pg-dedup: удаляет дубликаты по title, оставляет первый (min id).
+# Тестирует: DELETE с subquery, CTE, idempotency (повторный вызов безопасен).
+import os, psycopg2
+
+def dedup(event):
+    dry_run = str(event.get("dry_run", "false")).lower() in ("true", "1", "yes")
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor() as cur:
+            # Считаем сколько дублей есть
+            cur.execute("""
+                SELECT COUNT(*) FROM terraform_demo_table t1
+                WHERE EXISTS (
+                    SELECT 1 FROM terraform_demo_table t2
+                    WHERE t2.title = t1.title AND t2.id < t1.id
+                )
+            """)
+            dupes_count = cur.fetchone()[0]
+
+            if not dry_run and dupes_count > 0:
+                cur.execute("""
+                    DELETE FROM terraform_demo_table
+                    WHERE id NOT IN (
+                        SELECT MIN(id) FROM terraform_demo_table GROUP BY title
+                    )
+                """)
+                deleted = cur.rowcount
+                conn.commit()
+            else:
+                deleted = 0
+
+        return {"duplicates_found": dupes_count, "deleted": deleted, "dry_run": dry_run}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,33 @@
+# 2026-03-21 — pg-delete-old: удаляет строки старше N минут (default 60).
+# Тестирует: DELETE с RETURNING, идемпотентность (повторный вызов = 0 удалений если нет старых).
+import os, psycopg2, psycopg2.extras
+
+def delete_old(event):
+    older_than_min = max(int(event.get("older_than_min", 60)), 1)
+    prefix_filter = event.get("prefix", "")
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+            if prefix_filter:
+                cur.execute(
+                    "DELETE FROM terraform_demo_table "
+                    "WHERE created_at < now() - interval '1 minute' * %s "
+                    "AND title LIKE %s RETURNING id, title",
+                    (older_than_min, f"{prefix_filter}%"),
+                )
+            else:
+                cur.execute(
+                    "DELETE FROM terraform_demo_table "
+                    "WHERE created_at < now() - interval '1 minute' * %s RETURNING id, title",
+                    (older_than_min,),
+                )
+            deleted = [dict(r) for r in cur.fetchall()]
+        conn.commit()
+        return {"deleted": len(deleted), "older_than_min": older_than_min, "sample": deleted[:5]}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,36 @@
+# 2026-03-21 — pg-search: полнотекстовый поиск по title через ILIKE + LIMIT/OFFSET.
+# Тестирует: пагинацию, спецсимволы в input (XSS, SQL injection attempt → безопасно через параметры).
+import os, psycopg2, psycopg2.extras
+
+def search(event):
+    # «query» — основной параметр (user-friendly), «q» — алиас для совместимости.
+    query = str(event.get("query") or event.get("q") or "")[:200]
+    # int() может упасть если юзер прислал строку — защищаем try/except.
+    try:
+        limit = max(1, min(int(event.get("limit", 20)), 100))
+    except (TypeError, ValueError):
+        limit = 20
+    try:
+        offset = max(0, int(event.get("offset", 0)))
+    except (TypeError, ValueError):
+        offset = 0
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor) as cur:
+            pattern = f"%{query}%" if query else "%"
+            cur.execute(
+                "SELECT id, title, created_at::text FROM terraform_demo_table "
+                "WHERE title ILIKE %s ORDER BY id DESC LIMIT %s OFFSET %s",
+                (pattern, limit, offset),
+            )
+            rows = [dict(r) for r in cur.fetchall()]
+            cur.execute("SELECT COUNT(*) FROM terraform_demo_table WHERE title ILIKE %s", (pattern,))
+            total = cur.fetchone()["count"]
+        return {"rows": rows, "count": len(rows), "total": total, "q": query, "limit": limit, "offset": offset}
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,36 @@
+# 2026-03-21 — pg-upsert: INSERT ... ON CONFLICT (title) DO UPDATE.
+# Тестирует: идемпотентность вставки — один и тот же title можно вызывать 100 раз подряд.
+# Требует уникального индекса на title — создаётся при первом вызове (CREATE UNIQUE INDEX IF NOT EXISTS).
+import os, psycopg2
+
+def upsert(event):
+    title = str(event.get("title", "upsert-default"))[:255]
+    payload = str(event.get("payload", ""))[:500]
+
+    conn = psycopg2.connect(
+        host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+        dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+        password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+    )
+    try:
+        with conn.cursor() as cur:
+            # Создаём уникальный индекс если нет — для поддержки ON CONFLICT
+            cur.execute(
+                "CREATE UNIQUE INDEX IF NOT EXISTS terraform_demo_table_title_uniq "
+                "ON terraform_demo_table (title)"
+            )
+            cur.execute(
+                "INSERT INTO terraform_demo_table (title) VALUES (%s) "
+                "ON CONFLICT (title) DO UPDATE SET created_at = now() "
+                "RETURNING id, title, created_at::text, xmax",
+                (title,),
+            )
+            row = cur.fetchone()
+            was_insert = row[3] == 0   # xmax=0 означает INSERT, иначе UPDATE
+        conn.commit()
+        return {
+            "id": row[0], "title": row[1], "created_at": row[2],
+            "action": "inserted" if was_insert else "updated",
+        }
+    finally:
+        conn.close()
@@ -0,0 +1 @@
+psycopg2-binary
@@ -0,0 +1,54 @@
+# 2026-03-21 — py-retry-writer: пишет N строк с retry при PG ошибке.
+# Тестирует: устойчивость к transient PG errors (simulate_error=true), retry logic,
+# корректный rollback при частичном сбое.
+import os, time, psycopg2, random
+
+_MAX_RETRIES = 3
+
+def retry_write(event):
+    n = min(int(event.get("n", 5)), 100)
+    prefix = str(event.get("prefix", "retry"))[:40]
+    # simulate_error: с вероятностью 30% кидает OperationalError на 2-й попытке
+    simulate = str(event.get("simulate_error", "false")).lower() in ("true", "1")
+
+    attempt = 0
+    last_err = None
+
+    while attempt < _MAX_RETRIES:
+        attempt += 1
+        try:
+            conn = psycopg2.connect(
+                host=os.environ["PGHOST"], port=int(os.environ.get("PGPORT", 5432)),
+                dbname=os.environ["PGDATABASE"], user=os.environ["PGUSER"],
+                password=os.environ["PGPASSWORD"], sslmode=os.environ.get("PGSSLMODE", "require"),
+            )
+            inserted = []
+            try:
+                with conn.cursor() as cur:
+                    for i in range(n):
+                        # Симуляция: на первой попытке падаем с вероятностью 50%
+                        if simulate and attempt == 1 and i == n // 2:
+                            raise psycopg2.OperationalError("simulated transient error")
+                        title = f"{prefix}-{int(time.time()*1000)}-{i}-a{attempt}"
+                        cur.execute(
+                            "INSERT INTO terraform_demo_table (title) VALUES (%s) RETURNING id",
+                            (title,),
+                        )
+                        inserted.append(cur.fetchone()[0])
+                conn.commit()
+                return {
+                    "ok": True, "inserted": len(inserted),
+                    "attempts": attempt, "first_id": inserted[0] if inserted else None,
+                }
+            except Exception as e:
+                conn.rollback()
+                raise
+            finally:
+                conn.close()
+        except psycopg2.OperationalError as e:
+            last_err = str(e)
+            if attempt < _MAX_RETRIES:
+                time.sleep(0.3 * attempt)   # exponential backoff
+            continue
+
+    return {"ok": False, "attempts": attempt, "last_error": last_err}
@@ -0,0 +1 @@
+psycopg2-binary