Netpulse_SasS/server/internal/store/ncm_retention.go

package store

import (
	"context"
	"errors"
	"fmt"
	"time"

	"github.com/jackc/pgx/v5"
)

// Очистка сховища версій конфігів: політика, прибиральник і ручне
// видалення.
//
// Що взагалі означає «видалити версію» за наявності Git.
//
// Тіло конфігу живе у двох місцях: зашифрованим у core.secrets (звідти
// його читає веб, звідти ж рахується diff) і об'єктом у голому
// Git-репозиторії тенанта. Git append-only за побудовою: прибрати з
// нього одну історичну версію означає переписати всі наступні коміти
// гілки, а це нові SHA — тобто миттєво зламані commit_sha/blob_sha у
// ВСІХ уцілілих рядках ncm.configs і неможливий fast-forward для
// налаштованого дзеркала. Ціна не відповідає задачі.
//
// Тому видалення тут — це видалення з бази: рядок ncm.configs і
// зашифроване тіло в core.secrets. Місце звільняється (саме там лежать
// мегабайти), версія зникає з інтерфейсу й з порівнянь, а Git лишається
// тим, чим його й заводили, — довгим архівом на випадок розбору аварії
// (див. коментар пакета gitstore). Людині це кажеться прямо у вікні
// підтвердження: «видалення не стирає версію з Git-репозиторію».
//
// Практичний наслідок, про який треба знати: видалити конфіг, у який
// потрапив секрет, цим способом НЕ можна. Це не обхід, а чесна межа —
// компрометований пароль лікується зміною пароля, а не спробою
// підчистити архів.

// RetentionPolicy — політика очистки старих версій, спільна на тенант.
//
// Дві одиниці, і саме об'єднанням: версія лишається, якщо входить у
// останні Versions АБО молодша за Days днів. Чому не одна — у міграції
// 0037.
type RetentionPolicy struct {
	Enabled  bool `json:"enabled"`
	Versions int  `json:"versions"`
	Days     int  `json:"days"`

	// Коли прибиральник востаннє проходив і скільки прибрав. Без цього
	// форма не відповідає на «а воно взагалі працює».
	LastRunAt   *time.Time `json:"last_run_at,omitempty"`
	LastDeleted int        `json:"last_deleted"`

	// Скільки версій і байтів прибрала б політика прямо зараз. Рахується
	// на читанні форми: обіцянка «звільниться стільки-то» цінна саме до
	// натискання, а не після.
	Candidates      int   `json:"candidates"`
	CandidateBytes  int64 `json:"candidate_bytes"`
	TotalVersions   int   `json:"total_versions"`
	TotalBytes      int64 `json:"total_bytes"`
	ProtectedLatest int   `json:"protected_latest"`
}

const (
	defaultRetentionVersions = 20
	defaultRetentionDays     = 180

	// Стеля на один прохід прибиральника. Не про продуктивність
	// видалення, а про розмір транзакції: перший прохід на інсталяції,
	// яка рік збирала конфіги, інакше взяв би десятки тисяч рядків і
	// тримав би блокування, поки триває збір. Залишок піде наступним
	// тактом за годину — поспішати нікуди.
	retentionBatch = 500
)

// GetRetention читає політику разом із тим, що вона зробила б зараз.
func (s *Store) GetRetention(ctx context.Context, tenantID string) (*RetentionPolicy, error) {
	p := &RetentionPolicy{Versions: defaultRetentionVersions, Days: defaultRetentionDays}

	err := s.InTenantTx(ctx, tenantID, func(tx pgx.Tx) error {
		err := tx.QueryRow(ctx, `
			SELECT retention_enabled, retention_versions, retention_days,
			       retention_last_run_at, retention_last_deleted
			FROM ncm.backup_defaults WHERE tenant_id = $1
		`, tenantID).Scan(&p.Enabled, &p.Versions, &p.Days, &p.LastRunAt, &p.LastDeleted)
		if err != nil && !isNoRows(err) {
			return err
		}

		if err := tx.QueryRow(ctx, `
			SELECT count(*), COALESCE(sum(size_bytes),0)
			FROM ncm.configs WHERE tenant_id = $1
		`, tenantID).Scan(&p.TotalVersions, &p.TotalBytes); err != nil {
			return err
		}

		if err := tx.QueryRow(ctx, `
			SELECT count(DISTINCT (device_id, config_type))
			FROM ncm.configs WHERE tenant_id = $1
		`, tenantID).Scan(&p.ProtectedLatest); err != nil {
			return err
		}

		// Скільки забрала б політика зараз — за тими самими правилами,
		// що й сам прохід. Другого місця з умовами немає навмисно:
		// розбіжність між обіцянкою у формі й тим, що станеться вночі,
		// коштувала б довіри до обох.
		return tx.QueryRow(ctx, `
			SELECT count(*), COALESCE(sum(size_bytes),0)
			FROM (`+retentionCandidatesSQL+`) q
		`, tenantID, p.Versions, p.Days, 0).Scan(&p.Candidates, &p.CandidateBytes)
	})
	return p, err
}

// SetRetention зберігає політику.
func (s *Store) SetRetention(ctx context.Context, tenantID string, p RetentionPolicy) error {
	if p.Versions < 1 || p.Versions > 10000 {
		return fmt.Errorf("%w: кількість версій має бути від 1 до 10000", ErrInvalid)
	}
	if p.Days < 1 || p.Days > 36500 {
		return fmt.Errorf("%w: глибина в днях має бути від 1 до 36500", ErrInvalid)
	}

	return s.InTenantTx(ctx, tenantID, func(tx pgx.Tx) error {
		// Рядок backup_defaults може ще не існувати: розклад і очистка
		// живуть в одній таблиці, але вмикають їх окремо й у будь-якому
		// порядку.
		_, err := tx.Exec(ctx, `
			INSERT INTO ncm.backup_defaults
				(tenant_id, retention_enabled, retention_versions, retention_days)
			VALUES ($1, $2, $3, $4)
			ON CONFLICT (tenant_id) DO UPDATE SET
				retention_enabled  = EXCLUDED.retention_enabled,
				retention_versions = EXCLUDED.retention_versions,
				retention_days     = EXCLUDED.retention_days,
				updated_at         = now()
		`, tenantID, p.Enabled, p.Versions, p.Days)
		return err
	})
}

// retentionCandidatesSQL — вибірка версій, які політика має прибрати.
//
// Один текст на два вживання (показ у формі й сам прохід): умови
// видалення не мають існувати у двох редакціях.
//
// $1 tenant, $2 версій, $3 днів, $4 стеля (0 — без стелі).
//
// Окремо про rn > $2: політика тримає останні N, а N не менше одиниці
// (CHECK у міграції), тож найновіша версія кожного (хост, тип) під
// вибірку не потрапляє ніколи — це та сама гарантія «остання не
// видаляється», лише виражена арифметикою, а не окремою умовою.
const retentionCandidatesSQL = `
	WITH ranked AS (
		SELECT c.id, c.size_bytes, c.collected_at,
		       row_number() OVER (PARTITION BY c.device_id, c.config_type
		                          ORDER BY c.collected_at DESC) AS rn
		FROM ncm.configs c
		WHERE c.tenant_id = $1
	)
	SELECT r.id, r.size_bytes
	FROM ranked r
	WHERE r.rn > $2::int
	  AND r.collected_at < now() - make_interval(days => $3::int)
	  -- Версія, на яку посилається відкат, — не «старий конфіг», а те,
	  -- що збираються залити на залізо. Так само результат перевірки
	  -- відповідності без свого конфігу перетворюється на звинувачення
	  -- без доказу.
	  AND NOT EXISTS (SELECT 1 FROM ncm.rollbacks b WHERE b.target_config_id = r.id)
	  AND NOT EXISTS (SELECT 1 FROM ncm.compliance_results cr WHERE cr.config_id = r.id)
	ORDER BY r.collected_at
	-- Явні касти в CASE не косметика: без них Postgres виводить тип
	-- параметрів як text і падає на порівнянні з числом (див. HISTORY).
	LIMIT CASE WHEN $4::int > 0 THEN $4::int ELSE NULL END
`

// SweepStat — підсумок одного проходу прибиральника.
type SweepStat struct {
	Deleted    int
	FreedBytes int64
}

// SweepRetention прибирає старі версії одного тенанта.
//
// Повертає (0,0) без помилки, якщо політику не ввімкнено — це штатний
// стан, а не збій: типово чистка вимкнена.
func (s *Store) SweepRetention(ctx context.Context, tenantID string) (SweepStat, error) {
	var stat SweepStat

	var (
		enabled  bool
		versions = defaultRetentionVersions
		days     = defaultRetentionDays
	)
	err := s.InTenantTx(ctx, tenantID, func(tx pgx.Tx) error {
		err := tx.QueryRow(ctx, `
			SELECT retention_enabled, retention_versions, retention_days
			FROM ncm.backup_defaults WHERE tenant_id = $1
		`, tenantID).Scan(&enabled, &versions, &days)
		if err != nil && !isNoRows(err) {
			return err
		}
		return nil
	})
	if err != nil {
		return stat, err
	}
	if !enabled {
		return stat, nil
	}

	err = s.InTenantTx(ctx, tenantID, func(tx pgx.Tx) error {
		rows, err := tx.Query(ctx, retentionCandidatesSQL,
			tenantID, versions, days, retentionBatch)
		if err != nil {
			return err
		}
		var ids []string
		for rows.Next() {
			var id string
			var size int
			if err := rows.Scan(&id, &size); err != nil {
				rows.Close()
				return err
			}
			ids = append(ids, id)
		}
		rows.Close()
		if err := rows.Err(); err != nil {
			return err
		}
		if len(ids) > 0 {
			n, freed, err := deleteConfigRows(ctx, tx, tenantID, ids)
			if err != nil {
				return err
			}
			stat.Deleted, stat.FreedBytes = n, freed
		}

		// Позначка ставиться на КОЖНОМУ проході, навіть коли прибирати
		// нічого. Саме цим вона й корисна: порожня дата означає «не
		// ходив», а не «нічого не знайшов», і без цієї різниці форма не
		// відповідає на питання, заради якого позначку й заводили.
		//
		// У тій самій транзакції, що й видалення: інакше «прибрано 300»
		// могло б лишитись від проходу, який насправді відкотився.
		_, err = tx.Exec(ctx, `
			UPDATE ncm.backup_defaults
			SET retention_last_run_at = now(), retention_last_deleted = $2
			WHERE tenant_id = $1
		`, tenantID, stat.Deleted)
		return err
	})
	return stat, err
}

// TenantsWithRetention — тенанти, у яких політику ввімкнено.
//
// Окремий запит замість «пройтись по всіх тенантах і кожного спитати»:
// прибиральник тікає щогодини, а ввімкнена чистка — рідкість.
func (s *Store) TenantsWithRetention(ctx context.Context) ([]string, error) {
	rows, err := s.bg.Query(ctx, `
		SELECT b.tenant_id::text
		FROM ncm.backup_defaults b
		JOIN core.tenants t ON t.id = b.tenant_id
		WHERE b.retention_enabled
		  AND t.deleted_at IS NULL
		  AND t.status NOT IN ('suspended','cancelled')
		ORDER BY b.tenant_id
	`)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	var out []string
	for rows.Next() {
		var id string
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		out = append(out, id)
	}
	return out, rows.Err()
}

// ---------------------------------------------------------------------
// Ручне видалення
// ---------------------------------------------------------------------

// KeptConfig — версія, яку не видалили, і чому.
//
// Не помилка запиту: оператор міг обрати десять версій, з яких одна
// виявилась останньою. Відмовити всьому запиту означало б змусити його
// вгадувати, яка саме заважає.
type KeptConfig struct {
	ID         string `json:"id"`
	DeviceName string `json:"device_name"`
	// Вказівник, а не значення: для неіснуючого ідентифікатора дати
	// немає взагалі, а нульовий time.Time поїхав би у веб як
	// «01.01.0001» — тобто як дата, якої ніколи не було.
	CollectedAt *time.Time `json:"collected_at,omitempty"`
	Reason      string     `json:"reason"`
}

// DeletedConfig — те, що пішло в аудит: без нього рядок журналу не
// сказав би, ЩО саме зникло.
type DeletedConfig struct {
	ID          string    `json:"id"`
	DeviceID    string    `json:"device_id"`
	DeviceName  string    `json:"device_name"`
	CollectedAt time.Time `json:"collected_at"`
	SizeBytes   int       `json:"size_bytes"`
}

// DeleteConfigsResult — підсумок ручного видалення.
type DeleteConfigsResult struct {
	Deleted    []DeletedConfig `json:"deleted"`
	Kept       []KeptConfig    `json:"kept"`
	FreedBytes int64           `json:"freed_bytes"`
}

// ErrNothingToDelete — жодна з обраних версій не підлягає видаленню.
var ErrNothingToDelete = errors.New("жодну з обраних версій видалити не можна")

// DeleteConfigs видаляє обрані версії, лишаючи захищені.
//
// canWrite питається про КОЖЕН хост окремо, а не про перелік цілком:
// у запиті можуть бути версії різних хостів, і межі видимості людини
// проходять саме по хостах.
func (s *Store) DeleteConfigs(
	ctx context.Context, tenantID string, ids []string, canWrite func(deviceID string) bool,
) (DeleteConfigsResult, error) {
	var res DeleteConfigsResult
	if len(ids) == 0 {
		return res, fmt.Errorf("%w: не обрано жодної версії", ErrInvalid)
	}

	err := s.InTenantTx(ctx, tenantID, func(tx pgx.Tx) error {
		// Один запит на всі перевірки замість чотирьох по колу: причина
		// відмови має бути ОДНА й визначена, а не залежати від того, у
		// якому порядку обробник встиг спитати.
		rows, err := tx.Query(ctx, `
			SELECT c.id::text, c.device_id::text, d.name, c.collected_at, c.size_bytes,
			       c.collected_at = max(c.collected_at) OVER (
			           PARTITION BY c.device_id, c.config_type) AS is_latest,
			       EXISTS (SELECT 1 FROM ncm.rollbacks b WHERE b.target_config_id = c.id),
			       EXISTS (SELECT 1 FROM ncm.compliance_results cr WHERE cr.config_id = c.id)
			FROM ncm.configs c
			JOIN inv.devices d ON d.id = c.device_id
			WHERE c.tenant_id = $1 AND c.id IN (SELECT unnest($2::text[])::uuid)
		`, tenantID, ids)
		if err != nil {
			return err
		}

		type cand struct {
			id, deviceID, name string
			at                 time.Time
			size               int
		}
		var doomed []cand
		seen := map[string]bool{}

		for rows.Next() {
			var (
				c                                  cand
				isLatest, inRollback, inCompliance bool
			)
			if err := rows.Scan(&c.id, &c.deviceID, &c.name, &c.at, &c.size,
				&isLatest, &inRollback, &inCompliance); err != nil {
				rows.Close()
				return err
			}
			seen[c.id] = true

			keep := func(reason string) {
				at := c.at
				res.Kept = append(res.Kept, KeptConfig{
					ID: c.id, DeviceName: c.name, CollectedAt: &at, Reason: reason,
				})
			}
			switch {
			case !canWrite(c.deviceID):
				keep("немає доступу на запис до цього хоста")
			case isLatest:
				// Головна гарантія всієї функції. Конфіг, якого більше
				// ніде немає, — це не «старий конфіг»: після такого
				// видалення сторінка хоста показувала б порожнечу, а
				// наступний збір не мав би з чим порівнюватись.
				keep("остання версія хоста — не видаляється")
			case inRollback:
				keep("на цю версію посилається відкат")
			case inCompliance:
				keep("на цю версію посилається результат перевірки відповідності")
			default:
				doomed = append(doomed, c)
			}
		}
		rows.Close()
		if err := rows.Err(); err != nil {
			return err
		}

		// Ідентифікатор, якого немає в базі, теж має отримати рядок:
		// мовчазне «видалено 2 з 3» лишає людину без пояснення.
		for _, id := range ids {
			if !seen[id] {
				res.Kept = append(res.Kept, KeptConfig{ID: id, Reason: "версію не знайдено"})
			}
		}

		if len(doomed) == 0 {
			return ErrNothingToDelete
		}

		list := make([]string, 0, len(doomed))
		for _, c := range doomed {
			list = append(list, c.id)
			res.Deleted = append(res.Deleted, DeletedConfig{
				ID: c.id, DeviceID: c.deviceID, DeviceName: c.name,
				CollectedAt: c.at, SizeBytes: c.size,
			})
		}

		_, freed, err := deleteConfigRows(ctx, tx, tenantID, list)
		if err != nil {
			return err
		}
		res.FreedBytes = freed
		return nil
	})
	return res, err
}

// deleteConfigRows — спільне тіло видалення для політики й для рук.
//
// Три кроки, і порядок у них не довільний.
//
//  1. Перезшити ланцюжок prev_config_id. Зовнішній ключ оголошено як
//     ON DELETE SET NULL, тобто без цього кроку версія, що йшла ПІСЛЯ
//     видаленої, залишилась би без попередниці — і показувалась би як
//     «перша», а порівняння «з попередньою» для неї зникло б. Ланцюжок
//     завжди веде в минуле, тож рекурсивний обхід гарантовано доходить
//     до живої версії або до NULL.
//  2. Видалити рядки ncm.configs. Кешовані diff-и (ncm.diffs) підуть
//     каскадом самі — вони не мають сенсу без обох сторін.
//  3. Видалити зашифровані тіла з core.secrets. Саме тут лежать
//     мегабайти, і саме цей крок не робиться сам: посилання оголошено
//     ON DELETE SET NULL, тож без нього шифротекст лишився б у базі
//     назавжди, без жодного способу до нього дійти.
func deleteConfigRows(
	ctx context.Context, tx pgx.Tx, tenantID string, ids []string,
) (int, int64, error) {
	if _, err := tx.Exec(ctx, `
		WITH RECURSIVE dead AS (
			SELECT unnest($2::text[])::uuid AS id
		),
		walk(start_id, cur) AS (
			SELECT s.id, s.prev_config_id
			FROM ncm.configs s
			WHERE s.tenant_id = $1
			  AND s.prev_config_id IN (SELECT id FROM dead)
			  AND s.id NOT IN (SELECT id FROM dead)
			UNION ALL
			SELECT w.start_id, d.prev_config_id
			FROM walk w
			JOIN ncm.configs d ON d.id = w.cur AND d.tenant_id = $1
			WHERE w.cur IN (SELECT id FROM dead)
		)
		UPDATE ncm.configs s
		SET prev_config_id = w.cur
		FROM walk w
		WHERE s.tenant_id = $1 AND s.id = w.start_id
		  AND (w.cur IS NULL OR w.cur NOT IN (SELECT id FROM dead))
	`, tenantID, ids); err != nil {
		return 0, 0, fmt.Errorf("перезшивання ланцюжка версій: %w", err)
	}

	rows, err := tx.Query(ctx, `
		DELETE FROM ncm.configs
		WHERE tenant_id = $1 AND id IN (SELECT unnest($2::text[])::uuid)
		RETURNING COALESCE(body_secret_id::text,''), size_bytes
	`, tenantID, ids)
	if err != nil {
		return 0, 0, err
	}
	var (
		secrets []string
		freed   int64
		n       int
	)
	for rows.Next() {
		var sec string
		var size int
		if err := rows.Scan(&sec, &size); err != nil {
			rows.Close()
			return 0, 0, err
		}
		n++
		freed += int64(size)
		if sec != "" {
			secrets = append(secrets, sec)
		}
	}
	rows.Close()
	if err := rows.Err(); err != nil {
		return 0, 0, err
	}

	if len(secrets) > 0 {
		if _, err := tx.Exec(ctx, `
			DELETE FROM core.secrets
			WHERE tenant_id = $1 AND id IN (SELECT unnest($2::text[])::uuid)
		`, tenantID, secrets); err != nil {
			return 0, 0, fmt.Errorf("видалення зашифрованих тіл: %w", err)
		}
	}
	return n, freed, nil
}