package main

import (
	"context"
	"errors"
	"fmt"
	"io/fs"
	"net/http"
	"os"
	"path/filepath"
	"slices"
	"strings"
	"time"

	linstorClient "github.com/LINBIT/golinstor/client"

	internalInstance "github.com/lxc/incus/v7/internal/instance"
	"github.com/lxc/incus/v7/internal/server/auth"
	"github.com/lxc/incus/v7/internal/server/backup"
	"github.com/lxc/incus/v7/internal/server/certificate"
	"github.com/lxc/incus/v7/internal/server/cluster"
	"github.com/lxc/incus/v7/internal/server/db"
	dbCluster "github.com/lxc/incus/v7/internal/server/db/cluster"
	"github.com/lxc/incus/v7/internal/server/db/query"
	deviceConfig "github.com/lxc/incus/v7/internal/server/device/config"
	"github.com/lxc/incus/v7/internal/server/instance"
	"github.com/lxc/incus/v7/internal/server/instance/instancetype"
	"github.com/lxc/incus/v7/internal/server/network"
	"github.com/lxc/incus/v7/internal/server/network/acl"
	"github.com/lxc/incus/v7/internal/server/network/ovn"
	"github.com/lxc/incus/v7/internal/server/node"
	"github.com/lxc/incus/v7/internal/server/project"
	storagePools "github.com/lxc/incus/v7/internal/server/storage"
	storageDrivers "github.com/lxc/incus/v7/internal/server/storage/drivers"
	internalUtil "github.com/lxc/incus/v7/internal/util"
	"github.com/lxc/incus/v7/shared/api"
	"github.com/lxc/incus/v7/shared/logger"
	"github.com/lxc/incus/v7/shared/revert"
	"github.com/lxc/incus/v7/shared/subprocess"
	"github.com/lxc/incus/v7/shared/util"
)

type patchStage int

// Define the stages that patches can run at.
const (
	patchNoStageSet patchStage = iota
	patchPreDaemonStorage
	patchPostDaemonStorage
	patchPostNetworks
)

/*
Patches are one-time actions that are sometimes needed to update

	existing container configuration or move things around on the
	filesystem.

	Those patches are applied at startup time after the database schema
	has been fully updated. Patches can therefore assume a working database.

	At the time the patches are applied, the containers aren't started
	yet and the daemon isn't listening to requests.

	DO NOT use this mechanism for database update. Schema updates must be
	done through the separate schema update mechanism.


	Only append to the patches list, never remove entries and never re-order them.
*/
var patches = []patch{
	{name: "storage_lvm_skipactivation", stage: patchPostDaemonStorage, run: patchGenericStorage},
	{name: "clustering_drop_database_role", stage: patchPostDaemonStorage, run: patchClusteringDropDatabaseRole},
	{name: "network_clear_bridge_volatile_hwaddr", stage: patchPostDaemonStorage, run: patchGenericNetwork(patchNetworkClearBridgeVolatileHwaddr)},
	{name: "move_backups_instances", stage: patchPostDaemonStorage, run: patchMoveBackupsInstances},
	{name: "network_ovn_enable_nat", stage: patchPostDaemonStorage, run: patchGenericNetwork(patchNetworkOVNEnableNAT)},
	{name: "network_ovn_remove_routes", stage: patchPostDaemonStorage, run: patchGenericNetwork(patchNetworkOVNRemoveRoutes)},
	{name: "thinpool_typo_fix", stage: patchPostDaemonStorage, run: patchThinpoolTypoFix},
	{name: "vm_rename_uuid_key", stage: patchPostDaemonStorage, run: patchVMRenameUUIDKey},
	{name: "db_nodes_autoinc", stage: patchPreDaemonStorage, run: patchDBNodesAutoInc},
	{name: "network_acl_remove_defaults", stage: patchPostDaemonStorage, run: patchGenericNetwork(patchNetworkACLRemoveDefaults)},
	{name: "clustering_server_cert_trust", stage: patchPreDaemonStorage, run: patchClusteringServerCertTrust},
	{name: "warnings_remove_empty_node", stage: patchPostDaemonStorage, run: patchRemoveWarningsWithEmptyNode},
	{name: "dnsmasq_entries_include_device_name", stage: patchPostDaemonStorage, run: patchDnsmasqEntriesIncludeDeviceName},
	{name: "storage_missing_snapshot_records", stage: patchPostDaemonStorage, run: patchGenericStorage},
	{name: "storage_delete_old_snapshot_records", stage: patchPostDaemonStorage, run: patchGenericStorage},
	{name: "storage_zfs_drop_block_volume_filesystem_extension", stage: patchPostDaemonStorage, run: patchGenericStorage},
	{name: "storage_prefix_bucket_names_with_project", stage: patchPostDaemonStorage, run: patchGenericStorage},
	{name: "storage_move_custom_iso_block_volumes", stage: patchPostDaemonStorage, run: patchStorageRenameCustomISOBlockVolumes},
	{name: "zfs_set_content_type_user_property", stage: patchPostDaemonStorage, run: patchZfsSetContentTypeUserProperty},
	{name: "snapshots_rename", stage: patchPreDaemonStorage, run: patchSnapshotsRename},
	{name: "storage_zfs_unset_invalid_block_settings", stage: patchPostDaemonStorage, run: patchStorageZfsUnsetInvalidBlockSettings},
	{name: "storage_zfs_unset_invalid_block_settings_v2", stage: patchPostDaemonStorage, run: patchStorageZfsUnsetInvalidBlockSettingsV2},
	{name: "runtime_directory", stage: patchPostDaemonStorage, run: patchRuntimeDirectory},
	{name: "lvm_node_force_reuse", stage: patchPostDaemonStorage, run: patchLvmForceReuseKey},
	{name: "auth_openfga_viewer", stage: patchPostNetworks, run: patchGenericAuthorization},
	{name: "auth_openfga_network_address_set", stage: patchPostNetworks, run: patchGenericAuthorization},
	{name: "db_json_columns", stage: patchPreDaemonStorage, run: patchConvertJSONColumn},
	{name: "network_ovn_directional_port_groups", stage: patchPostDaemonStorage, run: patchGenericNetwork(patchNetworkOVNPortGroups)},
	{name: "pool_fix_default_permissions", stage: patchPostDaemonStorage, run: patchDefaultStoragePermissions},
	{name: "auth_openfga_volume_files", stage: patchPostNetworks, run: patchGenericAuthorization},
	{name: "btrfs_config_volume_subvolume_names", stage: patchPostNetworks, run: patchBtrfsSubvolumeNames},
	{name: "linstor_tune_rs_discard_granularity", stage: patchPostDaemonStorage, run: patchLinstorDiscardGranularity},
	{name: "storage_lvmcluster_qcow2_overhead", stage: patchPostDaemonStorage, run: patchGenericStorage},
	{name: "authorization_openfga_config_keys", stage: patchPreDaemonStorage, run: patchAuthorizationOpenFGAConfigKeys},
	{name: "authorization_client_routes_from_driver", stage: patchPreDaemonStorage, run: patchAuthorizationClientRoutesFromDriver},
}

type patchRun func(name string, d *Daemon) error

var errRetryNextTime = errors.New("skipped")

type patch struct {
	name  string
	stage patchStage
	run   patchRun
}

func (p *patch) apply(d *Daemon) error {
	logger.Info("Applying patch", logger.Ctx{"name": p.name})

	err := p.run(p.name, d)
	if err != nil {
		if errors.Is(err, errRetryNextTime) {
			return nil
		}

		return fmt.Errorf("Failed applying patch %q: %w", p.name, err)
	}

	err = d.db.Node.MarkPatchAsApplied(p.name)
	if err != nil {
		return fmt.Errorf("Failed marking patch applied %q: %w", p.name, err)
	}

	return nil
}

// Return the names of all available patches.
func patchesGetNames() []string {
	names := make([]string, len(patches))
	for i, patch := range patches {
		if patch.stage == patchNoStageSet {
			continue // Ignore any patch without explicitly set stage (it is defined incorrectly).
		}

		names[i] = patch.name
	}

	return names
}

// patchesApplyPostDaemonStorage applies the patches that need to run after the daemon storage is initialized.
func patchesApply(d *Daemon, stage patchStage) error {
	appliedPatches, err := d.db.Node.GetAppliedPatches()
	if err != nil {
		return err
	}

	for _, patch := range patches {
		if patch.stage == patchNoStageSet {
			return fmt.Errorf("Patch %q has no stage set: %d", patch.name, patch.stage)
		}

		if patch.stage != stage {
			continue
		}

		if slices.Contains(appliedPatches, patch.name) {
			continue
		}

		err := patch.apply(d)
		if err != nil {
			return err
		}
	}

	return nil
}

// Patches begin here

func patchDnsmasqEntriesIncludeDeviceName(_ string, d *Daemon) error {
	err := network.UpdateDNSMasqStatic(d.State(), "")
	if err != nil {
		return err
	}

	return nil
}

func patchRemoveWarningsWithEmptyNode(_ string, d *Daemon) error {
	err := d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		warnings, err := dbCluster.GetWarnings(ctx, tx.Tx())
		if err != nil {
			return err
		}

		for _, w := range warnings {
			if w.Node == "" {
				err = dbCluster.DeleteWarning(ctx, tx.Tx(), w.UUID)
				if err != nil {
					return err
				}
			}
		}

		return nil
	})
	if err != nil {
		return err
	}

	return nil
}

func patchClusteringServerCertTrust(name string, d *Daemon) error {
	if !d.serverClustered {
		return nil
	}

	var serverName string
	err := d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		var err error
		serverName, err = tx.GetLocalNodeName(ctx)
		return err
	})
	if err != nil {
		return err
	}

	// Add our server cert to DB trust store.
	serverCert, err := internalUtil.LoadServerCert(d.os.VarDir)
	if err != nil {
		return err
	}
	// Update our own entry in the nodes table.
	logger.Infof("Adding local server certificate to global trust store for %q patch", name)
	err = d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		return cluster.EnsureServerCertificateTrusted(serverName, serverCert, tx)
	})
	if err != nil {
		return err
	}

	logger.Infof("Added local server certificate to global trust store for %q patch", name)

	// Check all other members have done the same.
	for {
		var err error
		var dbCerts []dbCluster.Certificate
		err = d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
			dbCerts, err = dbCluster.GetCertificates(ctx, tx.Tx())
			return err
		})
		if err != nil {
			return err
		}

		trustedServerCerts := make(map[string]*dbCluster.Certificate)

		for _, c := range dbCerts {
			if c.Type == certificate.TypeServer {
				trustedServerCerts[c.Name] = &c
			}
		}

		var members []db.NodeInfo
		err = d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
			members, err = tx.GetNodes(ctx)
			if err != nil {
				return fmt.Errorf("Failed getting cluster members: %w", err)
			}

			return nil
		})
		if err != nil {
			return err
		}

		missingCerts := false
		for _, member := range members {
			_, found := trustedServerCerts[member.Name]
			if !found {
				logger.Warnf("Missing trusted server certificate for cluster member %q", member.Name)
				missingCerts = true
				break
			}
		}

		if missingCerts {
			logger.Warnf("Waiting for %q patch to be applied on all cluster members", name)
			time.Sleep(time.Second)
			continue
		}

		logger.Infof("Trusted server certificates found in trust store for all cluster members")
		break
	}

	// Now switch to using our server certificate for intra-cluster communication and load the trusted server
	// certificates for the other members into the in-memory trusted cache.
	logger.Infof("Set client certificate to server certificate %v", serverCert.Fingerprint())
	d.serverCertInt = serverCert
	updateCertificateCache(d)

	return nil
}

// patchNetworkACLRemoveDefaults removes the "default.action" and "default.logged" settings from network ACLs.
// It was decided that the user experience of having the default actions at the ACL level was confusing when using
// multiple ACLs, and that the interplay between conflicting default actions on multiple ACLs was difficult to
// understand. Instead it will be replace with a network and NIC level defaults settings.
func patchNetworkACLRemoveDefaults(_ string, d *Daemon) error {
	var err error
	var projectNames []string

	// Get projects.
	err = d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		projectNames, err = dbCluster.GetProjectNames(ctx, tx.Tx())
		return err
	})
	if err != nil {
		return err
	}

	err = d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		// Get ACLs in projects.
		for _, projectName := range projectNames {
			acls, err := dbCluster.GetNetworkACLs(ctx, tx.Tx(), dbCluster.NetworkACLFilter{Project: &projectName})
			if err != nil {
				return err
			}

			for _, acl := range acls {
				aclAPI, err := acl.ToAPI(ctx, tx.Tx())
				if err != nil {
					return err
				}

				modified := false

				// Remove the offending keys if found.
				_, found := aclAPI.Config["default.action"]
				if found {
					delete(aclAPI.Config, "default.action")
					modified = true
				}

				_, found = aclAPI.Config["default.logged"]
				if found {
					delete(aclAPI.Config, "default.logged")
					modified = true
				}

				// Write back modified config if needed.
				if modified {
					err = dbCluster.UpdateNetworkACLAPI(ctx, tx.Tx(), int64(acl.ID), &aclAPI.NetworkACLPut)
					if err != nil {
						return fmt.Errorf("Failed updating network ACL %d: %w", acl.ID, err)
					}
				}
			}
		}

		return nil
	})
	if err != nil {
		return err
	}

	return nil
}

// patchDBNodesAutoInc re-creates the nodes table id column as AUTOINCREMENT.
// Its done as a patch rather than a schema update so we can use PRAGMA foreign_keys = OFF without a transaction.
func patchDBNodesAutoInc(name string, d *Daemon) error {
	s := d.State()

	for {
		// Only apply patch if schema needs it.
		var schemaSQL string
		row := s.DB.Cluster.DB().QueryRow("SELECT sql FROM sqlite_master WHERE name = 'nodes'")
		err := row.Scan(&schemaSQL)
		if err != nil {
			return err
		}

		if strings.Contains(schemaSQL, "id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL") {
			logger.Debugf(`Skipping %q patch as "nodes" table id column already AUTOINCREMENT`, name)
			return nil // Nothing to do.
		}

		// Only apply patch on leader, otherwise wait for it to be applied.
		var localConfig *node.Config
		err = d.db.Node.Transaction(context.TODO(), func(ctx context.Context, tx *db.NodeTx) error {
			localConfig, err = node.ConfigLoad(ctx, tx)
			return err
		})
		if err != nil {
			return err
		}

		leaderAddress, err := s.Cluster.LeaderAddress()
		if err != nil {
			if errors.Is(err, cluster.ErrNodeIsNotClustered) {
				break // Apply change on standalone node.
			}

			return err
		}

		if localConfig.ClusterAddress() == leaderAddress {
			break // Apply change on leader node.
		}

		logger.Warnf("Waiting for %q patch to be applied on leader cluster member", name)
		time.Sleep(time.Second)
	}

	// Apply patch.
	_, err := s.DB.Cluster.DB().Exec(`
PRAGMA foreign_keys=OFF; -- So that integrity doesn't get in the way for now.
PRAGMA legacy_alter_table = ON; -- So that views referencing this table don't block change.

CREATE TABLE nodes_new (
	id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
	name TEXT NOT NULL,
	description TEXT DEFAULT '',
	address TEXT NOT NULL,
	schema INTEGER NOT NULL,
	api_extensions INTEGER NOT NULL,
	heartbeat DATETIME DEFAULT CURRENT_TIMESTAMP,
	state INTEGER NOT NULL DEFAULT 0,
	arch INTEGER NOT NULL DEFAULT 0 CHECK (arch > 0),
	failure_domain_id INTEGER DEFAULT NULL REFERENCES nodes_failure_domains (id) ON DELETE SET NULL,
	UNIQUE (name),
	UNIQUE (address)
);

INSERT INTO nodes_new (id, name, description, address, schema, api_extensions, heartbeat, state, arch, failure_domain_id)
	SELECT id, name, description, address, schema, api_extensions, heartbeat, state, arch, failure_domain_id FROM nodes;

DROP TABLE nodes;
ALTER TABLE nodes_new RENAME TO nodes;

PRAGMA foreign_keys=ON; -- Make sure we turn integrity checks back on.
PRAGMA legacy_alter_table = OFF; -- So views check integrity again.
`)

	return err
}

// patchVMRenameUUIDKey renames the volatile.vm.uuid key to volatile.uuid in instance and snapshot configs.
func patchVMRenameUUIDKey(_ string, d *Daemon) error {
	oldUUIDKey := "volatile.vm.uuid"
	newUUIDKey := "volatile.uuid"

	s := d.State()

	return s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		return tx.InstanceList(ctx, func(inst db.InstanceArgs, p api.Project) error {
			if inst.Type != instancetype.VM {
				return nil
			}

			uuid := inst.Config[oldUUIDKey]
			if uuid != "" {
				changes := map[string]string{
					oldUUIDKey: "",
					newUUIDKey: uuid,
				}

				logger.Debugf("Renaming config key %q to %q for VM %q (Project %q)", oldUUIDKey, newUUIDKey, inst.Name, inst.Project)
				err := tx.UpdateInstanceConfig(inst.ID, changes)
				if err != nil {
					return fmt.Errorf("Failed renaming config key %q to %q for VM %q (Project %q): %w", oldUUIDKey, newUUIDKey, inst.Name, inst.Project, err)
				}
			}

			snaps, err := tx.GetInstanceSnapshotsWithName(ctx, inst.Project, inst.Name)
			if err != nil {
				return err
			}

			for _, snap := range snaps {
				config, err := dbCluster.GetInstanceConfig(ctx, tx.Tx(), snap.ID)
				if err != nil {
					return err
				}

				uuid := config[oldUUIDKey]
				if uuid != "" {
					changes := map[string]string{
						oldUUIDKey: "",
						newUUIDKey: uuid,
					}

					logger.Debugf("Renaming config key %q to %q for VM %q (Project %q)", oldUUIDKey, newUUIDKey, snap.Name, snap.Project)
					err = tx.UpdateInstanceSnapshotConfig(snap.ID, changes)
					if err != nil {
						return fmt.Errorf("Failed renaming config key %q to %q for VM %q (Project %q): %w", oldUUIDKey, newUUIDKey, snap.Name, snap.Project, err)
					}
				}
			}

			return nil
		})
	})
}

// patchThinpoolTypoFix renames any config incorrectly set config file entries due to the lvm.thinpool_name typo.
func patchThinpoolTypoFix(_ string, d *Daemon) error {
	reverter := revert.New()
	defer reverter.Fail()

	// Setup a transaction.
	tx, err := d.db.Cluster.Begin()
	if err != nil {
		return fmt.Errorf("Failed to begin transaction: %w", err)
	}

	reverter.Add(func() { _ = tx.Rollback() })

	// Fetch the IDs of all existing nodes.
	nodeIDs, err := query.SelectIntegers(context.TODO(), tx, "SELECT id FROM nodes")
	if err != nil {
		return fmt.Errorf("Failed to get IDs of current nodes: %w", err)
	}

	// Fetch the IDs of all existing lvm pools.
	poolIDs, err := query.SelectIntegers(context.TODO(), tx, "SELECT id FROM storage_pools WHERE driver='lvm'")
	if err != nil {
		return fmt.Errorf("Failed to get IDs of current lvm pools: %w", err)
	}

	for _, poolID := range poolIDs {
		// Fetch the config for this lvm pool and check if it has the lvm.thinpool_name.
		config, err := query.SelectConfig(context.TODO(), tx, "storage_pools_config", "storage_pool_id=? AND node_id IS NULL", poolID)
		if err != nil {
			return fmt.Errorf("Failed to fetch of lvm pool config: %w", err)
		}

		value, ok := config["lvm.thinpool_name"]
		if !ok {
			continue
		}

		// Delete the current key
		_, err = tx.Exec(`
DELETE FROM storage_pools_config WHERE key='lvm.thinpool_name' AND storage_pool_id=? AND node_id IS NULL
`, poolID)
		if err != nil {
			return fmt.Errorf("Failed to delete lvm.thinpool_name config: %w", err)
		}

		// Add the config entry for each node
		for _, nodeID := range nodeIDs {
			_, err := tx.Exec(`
INSERT INTO storage_pools_config(storage_pool_id, node_id, key, value)
  VALUES(?, ?, 'lvm.thinpool_name', ?)
`, poolID, nodeID, value)
			if err != nil {
				return fmt.Errorf("Failed to create lvm.thinpool_name node config: %w", err)
			}
		}
	}

	err = tx.Commit()
	if err != nil {
		return fmt.Errorf("Failed to commit transaction: %w", err)
	}

	reverter.Success()
	return nil
}

// patchNetworkOVNRemoveRoutes removes the "ipv4.routes.external" and "ipv6.routes.external" settings from OVN
// networks. It was decided that the OVN NIC level equivalent settings were sufficient.
func patchNetworkOVNRemoveRoutes(_ string, d *Daemon) error {
	err := d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		projectNetworks, err := tx.GetCreatedNetworks(ctx)
		if err != nil {
			return err
		}

		for projectName, networks := range projectNetworks {
			for networkID, network := range networks {
				if network.Type != "ovn" {
					continue
				}

				modified := false

				// Ensure existing behaviour of having NAT enabled if IP address was set.
				_, found := network.Config["ipv4.routes.external"]
				if found {
					modified = true
					delete(network.Config, "ipv4.routes.external")
				}

				_, found = network.Config["ipv6.routes.external"]
				if found {
					modified = true
					delete(network.Config, "ipv6.routes.external")
				}

				if modified {
					err = tx.UpdateNetwork(ctx, projectName, network.Name, network.Description, network.Config)
					if err != nil {
						return fmt.Errorf("Failed removing OVN external route settings for %q (%d): %w", network.Name, networkID, err)
					}

					logger.Debugf("Removing external route settings for OVN network %q (%d)", network.Name, networkID)
				}
			}
		}

		return nil
	})
	if err != nil {
		return err
	}

	return nil
}

// patchNetworkOVNEnableNAT adds "ipv4.nat" and "ipv6.nat" keys set to "true" to OVN networks if not present.
// This is to ensure existing networks retain the old behaviour of always having NAT enabled as we introduce
// the new NAT settings which default to disabled if not specified.
// patchNetworkCearBridgeVolatileHwaddr removes the unsupported `volatile.bridge.hwaddr` config key from networks.
func patchNetworkOVNEnableNAT(_ string, d *Daemon) error {
	err := d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		projectNetworks, err := tx.GetCreatedNetworks(ctx)
		if err != nil {
			return err
		}

		for projectName, networks := range projectNetworks {
			for networkID, network := range networks {
				if network.Type != "ovn" {
					continue
				}

				modified := false

				// Ensure existing behaviour of having NAT enabled if IP address was set.
				if network.Config["ipv4.address"] != "" && network.Config["ipv4.nat"] == "" {
					modified = true
					network.Config["ipv4.nat"] = "true"
				}

				if network.Config["ipv6.address"] != "" && network.Config["ipv6.nat"] == "" {
					modified = true
					network.Config["ipv6.nat"] = "true"
				}

				if modified {
					err = tx.UpdateNetwork(ctx, projectName, network.Name, network.Description, network.Config)
					if err != nil {
						return fmt.Errorf("Failed saving OVN NAT settings for %q (%d): %w", network.Name, networkID, err)
					}

					logger.Debugf("Enabling NAT for OVN network %q (%d)", network.Name, networkID)
				}
			}
		}

		return nil
	})
	if err != nil {
		return err
	}

	return nil
}

// Moves backups from internalUtil.VarPath("backups") to internalUtil.VarPath("backups", "instances").
func patchMoveBackupsInstances(_ string, _ *Daemon) error {
	if !util.PathExists(internalUtil.VarPath("backups")) {
		return nil // Nothing to do, no backups directory.
	}

	backupsPath := internalUtil.VarPath("backups", "instances")

	err := os.MkdirAll(backupsPath, 0o700)
	if err != nil {
		return fmt.Errorf("Failed creating instances backup directory %q: %w", backupsPath, err)
	}

	backups, err := os.ReadDir(internalUtil.VarPath("backups"))
	if err != nil {
		return fmt.Errorf("Failed listing existing backup directory %q: %w", internalUtil.VarPath("backups"), err)
	}

	for _, backupDir := range backups {
		if backupDir.Name() == "instances" || strings.HasPrefix(backupDir.Name(), backup.WorkingDirPrefix) {
			continue // Don't try and move our new instances directory or temporary directories.
		}

		oldPath := internalUtil.VarPath("backups", backupDir.Name())
		newPath := filepath.Join(backupsPath, backupDir.Name())
		logger.Debugf("Moving backup from %q to %q", oldPath, newPath)
		err = os.Rename(oldPath, newPath)
		if err != nil {
			return fmt.Errorf("Failed moving backup from %q to %q: %w", oldPath, newPath, err)
		}
	}

	return nil
}

func patchGenericAuthorization(name string, d *Daemon) error {
	return d.authorizer.ApplyPatch(d.shutdownCtx, name)
}

func patchGenericStorage(name string, d *Daemon) error {
	return storagePools.Patch(d.State(), name)
}

func patchGenericNetwork(f func(name string, d *Daemon) error) func(name string, d *Daemon) error {
	return func(name string, d *Daemon) error {
		err := network.PatchPreCheck()
		if err != nil {
			return err
		}

		return f(name, d)
	}
}

func patchClusteringDropDatabaseRole(_ string, d *Daemon) error {
	return d.State().DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		members, err := tx.GetNodes(ctx)
		if err != nil {
			return fmt.Errorf("Failed getting cluster members: %w", err)
		}

		for _, member := range members {
			err := tx.UpdateNodeRoles(member.ID, nil)
			if err != nil {
				return err
			}
		}
		return nil
	})
}

// patchNetworkClearBridgeVolatileHwaddr removes the unsupported `volatile.bridge.hwaddr` config key from networks.
func patchNetworkClearBridgeVolatileHwaddr(_ string, d *Daemon) error {
	// Use api.ProjectDefaultName, as bridge networks don't support projects.
	projectName := api.ProjectDefaultName

	err := d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		// Get the list of networks.
		networks, err := tx.GetNetworks(ctx, projectName)
		if err != nil {
			return fmt.Errorf("Failed loading networks for network_clear_bridge_volatile_hwaddr patch: %w", err)
		}

		for _, networkName := range networks {
			_, net, _, err := tx.GetNetworkInAnyState(ctx, projectName, networkName)
			if err != nil {
				return fmt.Errorf("Failed loading network %q for network_clear_bridge_volatile_hwaddr patch: %w", networkName, err)
			}

			if net.Config["volatile.bridge.hwaddr"] != "" {
				delete(net.Config, "volatile.bridge.hwaddr")
				err = tx.UpdateNetwork(ctx, projectName, net.Name, net.Description, net.Config)
				if err != nil {
					return fmt.Errorf("Failed updating network %q for network_clear_bridge_volatile_hwaddr patch: %w", networkName, err)
				}
			}
		}

		return nil
	})
	if err != nil {
		return err
	}

	return nil
}

// patchStorageRenameCustomISOBlockVolumes renames existing custom ISO volumes by adding the ".iso" suffix so they can be distinguished from regular custom block volumes.
// This patch doesn't use the patchGenericStorage function because the storage drivers themselves aren't aware of custom ISO volumes.
func patchStorageRenameCustomISOBlockVolumes(_ string, d *Daemon) error {
	s := d.State()

	var pools []string

	err := s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		var err error

		// Get all storage pool names.
		pools, err = tx.GetStoragePoolNames(ctx)

		return err
	})
	if err != nil {
		// Skip the rest of the patch if no storage pools were found.
		if api.StatusErrorCheck(err, http.StatusNotFound) {
			return nil
		}

		return fmt.Errorf("Failed getting storage pool names: %w", err)
	}

	// Only apply patch on leader.
	var localConfig *node.Config
	isLeader := false

	err = d.db.Node.Transaction(s.ShutdownCtx, func(ctx context.Context, tx *db.NodeTx) error {
		localConfig, err = node.ConfigLoad(ctx, tx)
		return err
	})
	if err != nil {
		return err
	}

	leaderAddress, err := s.Cluster.LeaderAddress()
	if err != nil {
		// If we're not clustered, we're the leader.
		if !errors.Is(err, cluster.ErrNodeIsNotClustered) {
			return err
		}

		isLeader = true
	} else if localConfig.ClusterAddress() == leaderAddress {
		isLeader = true
	}

	volTypeCustom := db.StoragePoolVolumeTypeCustom
	customPoolVolumes := make(map[string][]*db.StorageVolume)

	err = s.DB.Cluster.Transaction(s.ShutdownCtx, func(ctx context.Context, tx *db.ClusterTx) error {
		for _, pool := range pools {
			// Get storage pool ID.
			poolID, err := tx.GetStoragePoolID(ctx, pool)
			if err != nil {
				return fmt.Errorf("Failed getting storage pool ID of pool %q: %w", pool, err)
			}

			// Get the pool's custom storage volumes.
			customVolumes, err := tx.GetStoragePoolVolumes(ctx, poolID, false, db.StorageVolumeFilter{Type: &volTypeCustom})
			if err != nil {
				return fmt.Errorf("Failed getting custom storage volumes of pool %q: %w", pool, err)
			}

			if customPoolVolumes[pool] == nil {
				customPoolVolumes[pool] = []*db.StorageVolume{}
			}

			customPoolVolumes[pool] = append(customPoolVolumes[pool], customVolumes...)
		}

		return nil
	})
	if err != nil {
		return err
	}

	for poolName, volumes := range customPoolVolumes {
		// Load storage pool.
		p, err := storagePools.LoadByName(s, poolName)
		if err != nil {
			return fmt.Errorf("Failed loading pool %q: %w", poolName, err)
		}

		// Ensure the renaming is done only on the cluster leader for remote storage pools.
		if p.Driver().Info().Remote && !isLeader {
			continue
		}

		for _, vol := range volumes {
			// In a non-clusted environment ServerName will be empty.
			if s.ServerName != "" && vol.Location != s.ServerName {
				continue
			}

			// Exclude non-ISO custom volumes.
			if vol.ContentType != db.StoragePoolVolumeContentTypeNameISO {
				continue
			}

			// We need to use ContentTypeBlock here in order for the driver to figure out the correct (old) location.
			oldVol := storageDrivers.NewVolume(p.Driver(), p.Name(), storageDrivers.VolumeTypeCustom, storageDrivers.ContentTypeBlock, project.StorageVolume(vol.Project, vol.Name), nil, nil)

			err = p.Driver().RenameVolume(oldVol, fmt.Sprintf("%s.iso", oldVol.Name()), nil)
			if err != nil {
				return fmt.Errorf("Failed renaming volume: %w", err)
			}
		}
	}

	return nil
}

// patchZfsSetContentTypeUserProperty adds the `incus:content_type` user property to custom storage volumes. In case of recovery, this allows for proper detection of block-mode enabled volumes.
func patchZfsSetContentTypeUserProperty(_ string, d *Daemon) error {
	s := d.State()

	var pools []string

	err := s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		var err error

		// Get all storage pool names.
		pools, err = tx.GetStoragePoolNames(ctx)

		return err
	})
	if err != nil {
		// Skip the rest of the patch if no storage pools were found.
		if api.StatusErrorCheck(err, http.StatusNotFound) {
			return nil
		}

		return fmt.Errorf("Failed getting storage pool names: %w", err)
	}

	volTypeCustom := db.StoragePoolVolumeTypeCustom
	customPoolVolumes := make(map[string][]*db.StorageVolume)

	err = s.DB.Cluster.Transaction(s.ShutdownCtx, func(ctx context.Context, tx *db.ClusterTx) error {
		for _, pool := range pools {
			// Get storage pool ID.
			poolID, err := tx.GetStoragePoolID(ctx, pool)
			if err != nil {
				return fmt.Errorf("Failed getting storage pool ID of pool %q: %w", pool, err)
			}

			// Get the pool's custom storage volumes.
			customVolumes, err := tx.GetStoragePoolVolumes(ctx, poolID, false, db.StorageVolumeFilter{Type: &volTypeCustom})
			if err != nil {
				return fmt.Errorf("Failed getting custom storage volumes of pool %q: %w", pool, err)
			}

			if customPoolVolumes[pool] == nil {
				customPoolVolumes[pool] = []*db.StorageVolume{}
			}

			customPoolVolumes[pool] = append(customPoolVolumes[pool], customVolumes...)
		}

		return nil
	})
	if err != nil {
		return err
	}

	for poolName, volumes := range customPoolVolumes {
		// Load storage pool.
		p, err := storagePools.LoadByName(s, poolName)
		if err != nil {
			return fmt.Errorf("Failed loading pool %q: %w", poolName, err)
		}

		if p.Driver().Info().Name != "zfs" {
			continue
		}

		for _, vol := range volumes {
			// In a non-clusted environment ServerName will be empty.
			if s.ServerName != "" && vol.Location != s.ServerName {
				continue
			}

			zfsPoolName := p.Driver().Config()["zfs.pool_name"]
			if zfsPoolName != "" {
				poolName = zfsPoolName
			}

			zfsVolName := fmt.Sprintf("%s/%s/%s", poolName, storageDrivers.VolumeTypeCustom, project.StorageVolume(vol.Project, vol.Name))

			_, err = subprocess.RunCommand("zfs", "set", fmt.Sprintf("incus:content_type=%s", vol.ContentType), zfsVolName)
			if err != nil {
				logger.Debug("Failed setting incus:content_type property", logger.Ctx{"name": zfsVolName, "err": err})
			}
		}
	}

	return nil
}

// patchSnapshotsRename renames the "snapshots" directory to "container-snapshots".
func patchSnapshotsRename(_ string, _ *Daemon) error {
	// Remove what should be an empty directory.
	os.Remove(internalUtil.VarPath("containers-snapshots"))

	return os.Rename(internalUtil.VarPath("snapshots"), internalUtil.VarPath("containers-snapshots"))
}

// patchStorageZfsUnsetInvalidBlockSettings removes invalid block settings from volumes.
func patchStorageZfsUnsetInvalidBlockSettings(_ string, d *Daemon) error {
	s := d.State()

	var pools []string

	err := s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		var err error

		// Get all storage pool names.
		pools, err = tx.GetStoragePoolNames(ctx)

		return err
	})
	if err != nil {
		// Skip the rest of the patch if no storage pools were found.
		if api.StatusErrorCheck(err, http.StatusNotFound) {
			return nil
		}

		return fmt.Errorf("Failed getting storage pool names: %w", err)
	}

	volTypeCustom := db.StoragePoolVolumeTypeCustom
	volTypeVM := db.StoragePoolVolumeTypeVM

	poolIDNameMap := make(map[int64]string)
	poolVolumes := make(map[int64][]*db.StorageVolume)

	err = s.DB.Cluster.Transaction(s.ShutdownCtx, func(ctx context.Context, tx *db.ClusterTx) error {
		for _, pool := range pools {
			// Get storage pool ID.
			poolID, err := tx.GetStoragePoolID(ctx, pool)
			if err != nil {
				return fmt.Errorf("Failed getting storage pool ID of pool %q: %w", pool, err)
			}

			driverName, err := tx.GetStoragePoolDriver(ctx, poolID)
			if err != nil {
				return fmt.Errorf("Failed getting storage pool driver of pool %q: %w", pool, err)
			}

			if driverName != "zfs" {
				continue
			}

			// Get the pool's custom storage volumes.
			volumes, err := tx.GetStoragePoolVolumes(ctx, poolID, false, db.StorageVolumeFilter{Type: &volTypeCustom}, db.StorageVolumeFilter{Type: &volTypeVM})
			if err != nil {
				return fmt.Errorf("Failed getting custom storage volumes of pool %q: %w", pool, err)
			}

			if poolVolumes[poolID] == nil {
				poolVolumes[poolID] = []*db.StorageVolume{}
			}

			poolIDNameMap[poolID] = pool
			poolVolumes[poolID] = append(poolVolumes[poolID], volumes...)
		}

		return nil
	})
	if err != nil {
		return err
	}

	var volType int

	for pool, volumes := range poolVolumes {
		for _, vol := range volumes {
			// In a non-clusted environment ServerName will be empty.
			if s.ServerName != "" && vol.Location != s.ServerName {
				continue
			}

			config := vol.Config

			if util.IsTrue(config["zfs.block_mode"]) {
				continue
			}

			update := false
			for _, k := range []string{"block.filesystem", "block.mount_options"} {
				_, found := config[k]
				if found {
					delete(config, k)
					update = true
				}
			}

			if !update {
				continue
			}

			switch vol.Type {
			case db.StoragePoolVolumeTypeNameVM:
				volType = volTypeVM
			case db.StoragePoolVolumeTypeNameCustom:
				volType = volTypeCustom
			default:
				// Should not happen.
				continue
			}

			err = s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
				return tx.UpdateStoragePoolVolume(ctx, vol.Project, vol.Name, volType, pool, vol.Description, config)
			})
			if err != nil {
				return fmt.Errorf("Failed updating volume %q in project %q on pool %q: %w", vol.Name, vol.Project, poolIDNameMap[pool], err)
			}
		}
	}

	return nil
}

// patchStorageZfsUnsetInvalidBlockSettingsV2 removes invalid block settings from volumes.
// This patch fixes the previous one.
// - Handle non-clusted environments correctly.
// - Always remove block.* settings from VMs.
func patchStorageZfsUnsetInvalidBlockSettingsV2(_ string, d *Daemon) error {
	s := d.State()

	var pools []string

	err := s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		var err error

		// Get all storage pool names.
		pools, err = tx.GetStoragePoolNames(ctx)

		return err
	})
	if err != nil {
		// Skip the rest of the patch if no storage pools were found.
		if api.StatusErrorCheck(err, http.StatusNotFound) {
			return nil
		}

		return fmt.Errorf("Failed getting storage pool names: %w", err)
	}

	volTypeCustom := db.StoragePoolVolumeTypeCustom
	volTypeVM := db.StoragePoolVolumeTypeVM

	poolIDNameMap := make(map[int64]string)
	poolVolumes := make(map[int64][]*db.StorageVolume)

	err = s.DB.Cluster.Transaction(s.ShutdownCtx, func(ctx context.Context, tx *db.ClusterTx) error {
		for _, pool := range pools {
			// Get storage pool ID.
			poolID, err := tx.GetStoragePoolID(ctx, pool)
			if err != nil {
				return fmt.Errorf("Failed getting storage pool ID of pool %q: %w", pool, err)
			}

			driverName, err := tx.GetStoragePoolDriver(ctx, poolID)
			if err != nil {
				return fmt.Errorf("Failed getting storage pool driver of pool %q: %w", pool, err)
			}

			if driverName != "zfs" {
				continue
			}

			// Get the pool's custom storage volumes.
			volumes, err := tx.GetStoragePoolVolumes(ctx, poolID, false, db.StorageVolumeFilter{Type: &volTypeCustom}, db.StorageVolumeFilter{Type: &volTypeVM})
			if err != nil {
				return fmt.Errorf("Failed getting custom storage volumes of pool %q: %w", pool, err)
			}

			if poolVolumes[poolID] == nil {
				poolVolumes[poolID] = []*db.StorageVolume{}
			}

			poolIDNameMap[poolID] = pool
			poolVolumes[poolID] = append(poolVolumes[poolID], volumes...)
		}

		return nil
	})
	if err != nil {
		return err
	}

	var volType int

	for pool, volumes := range poolVolumes {
		for _, vol := range volumes {
			// In a non-clusted environment ServerName will be empty.
			if s.ServerName != "" && vol.Location != s.ServerName {
				continue
			}

			config := vol.Config

			// Only check zfs.block_mode for custom volumes. VMs should never have any block.* settings
			// regardless of the zfs.block_mode setting.
			if util.IsTrue(config["zfs.block_mode"]) && vol.Type == db.StoragePoolVolumeTypeNameCustom {
				continue
			}

			update := false
			for _, k := range []string{"block.filesystem", "block.mount_options"} {
				_, found := config[k]
				if found {
					delete(config, k)
					update = true
				}
			}

			if !update {
				continue
			}

			switch vol.Type {
			case db.StoragePoolVolumeTypeNameVM:
				volType = volTypeVM
			case db.StoragePoolVolumeTypeNameCustom:
				volType = volTypeCustom
			default:
				// Should not happen.
				continue
			}

			err = s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
				return tx.UpdateStoragePoolVolume(ctx, vol.Project, vol.Name, volType, pool, vol.Description, config)
			})
			if err != nil {
				return fmt.Errorf("Failed updating volume %q in project %q on pool %q: %w", vol.Name, vol.Project, poolIDNameMap[pool], err)
			}
		}
	}

	return nil
}

func patchRuntimeDirectory(_ string, d *Daemon) error {
	s := d.State()

	// Get the list of local instances.
	instances, err := instance.LoadNodeAll(s, instancetype.Any)
	if err != nil {
		return fmt.Errorf("Failed loading local instances: %w", err)
	}

	for _, inst := range instances {
		if !util.PathExists(inst.LogPath()) {
			continue
		}

		err = os.MkdirAll(inst.RunPath(), 0o700)
		if err != nil && !os.IsExist(err) {
			return fmt.Errorf("Failed to create runtime directory for %q in project %q: %w", inst.Name(), inst.Project(), err)
		}

		files, err := os.ReadDir(inst.LogPath())
		if err != nil {
			return fmt.Errorf("Failed to list log files for %q in project %q: %w", inst.Name(), inst.Project(), err)
		}

		for _, fi := range files {
			name := fi.Name()

			// Keep actual log files where they are.
			if strings.HasSuffix(name, ".log") || strings.HasSuffix(name, ".log.old") || strings.HasSuffix(name, ".gz") {
				continue
			}

			info, err := fi.Info()
			if err != nil {
				return fmt.Errorf("Failed getting file info on %q for instance %q in project %q: %w", name, inst.Name(), inst.Project(), err)
			}

			if info.Mode().IsRegular() {
				// Relocate the file.
				_, err := subprocess.RunCommand("mv", filepath.Join(inst.LogPath(), name), inst.RunPath())
				if err != nil {
					return fmt.Errorf("Failed to relocate runtime file %q for instance %q in project %q: %w", name, inst.Name(), inst.Project(), err)
				}
			} else {
				// For pipes and sockets, we need to use a symlink to avoid breaking the listener.
				err := os.Symlink(filepath.Join(inst.LogPath(), name), filepath.Join(inst.RunPath(), name))
				if err != nil {
					return fmt.Errorf("Failed to symlink runtime file %q for instance %q in project %q: %w", name, inst.Name(), inst.Project(), err)
				}
			}
		}
	}

	return nil
}

// The lvm.vg.force_reuse config key is node-specific and need to be linked to nodes.
func patchLvmForceReuseKey(_ string, d *Daemon) error {
	reverter := revert.New()
	defer reverter.Fail()

	// Setup a transaction.
	tx, err := d.db.Cluster.Begin()
	if err != nil {
		return fmt.Errorf("Failed to begin transaction: %w", err)
	}

	reverter.Add(func() { _ = tx.Rollback() })

	// Fetch the IDs of all existing nodes.
	nodeIDs, err := query.SelectIntegers(context.TODO(), tx, "SELECT id FROM nodes")
	if err != nil {
		return fmt.Errorf("Failed to get IDs of current nodes: %w", err)
	}

	// Fetch the IDs of all existing lvm pools.
	poolIDs, err := query.SelectIntegers(context.TODO(), tx, "SELECT id FROM storage_pools WHERE driver='lvm'")
	if err != nil {
		return fmt.Errorf("Failed to get IDs of current LVM pools: %w", err)
	}

	for _, poolID := range poolIDs {
		// Fetch the config for this LVM pool and check if it has the lvm.vg.force_reuse key.
		config, err := query.SelectConfig(context.TODO(), tx, "storage_pools_config", "storage_pool_id=? AND node_id IS NULL", poolID)
		if err != nil {
			return fmt.Errorf("Failed to fetch of lvm pool config: %w", err)
		}

		value, ok := config["lvm.vg.force_reuse"]
		if !ok {
			continue
		}

		// Delete the current key.
		_, err = tx.Exec("DELETE FROM storage_pools_config WHERE key='lvm.vg.force_reuse' AND storage_pool_id=? AND node_id IS NULL", poolID)
		if err != nil {
			return fmt.Errorf("Failed to delete old config: %w", err)
		}

		// Add the config entry for each node.
		for _, nodeID := range nodeIDs {
			_, err := tx.Exec(`
INSERT INTO storage_pools_config(storage_pool_id, node_id, key, value)
  VALUES(?, ?, 'lvm.vg.force_reuse', ?)
`, poolID, nodeID, value)
			if err != nil {
				return fmt.Errorf("Failed to create new config: %w", err)
			}
		}
	}

	err = tx.Commit()
	if err != nil {
		return fmt.Errorf("Failed to commit transaction: %w", err)
	}

	reverter.Success()
	return nil
}

// The database generator expects valid JSON. An empty string isn't valid JSON.
func patchConvertJSONColumn(_ string, d *Daemon) error {
	s := d.State()

	_, err := s.DB.Cluster.DB().Exec(`
UPDATE networks_acls SET egress="null" WHERE egress="";
UPDATE networks_acls SET ingress="null" WHERE ingress="";
UPDATE networks_forwards SET ports="null" WHERE ports="";
UPDATE networks_load_balancers SET backends="null" WHERE backends="";
UPDATE networks_load_balancers SET ports="null" WHERE ports="";
`)
	if err != nil {
		return fmt.Errorf("Failed to fix JSON columns: %w", err)
	}

	return nil
}

func patchNetworkOVNPortGroups(_ string, d *Daemon) error {
	reverter := revert.New()
	defer reverter.Fail()

	s := d.State()

	// Only apply patch on leader.
	var err error
	var localConfig *node.Config
	isLeader := false

	err = d.db.Node.Transaction(s.ShutdownCtx, func(ctx context.Context, tx *db.NodeTx) error {
		localConfig, err = node.ConfigLoad(ctx, tx)
		return err
	})
	if err != nil {
		return err
	}

	leaderAddress, err := s.Cluster.LeaderAddress()
	if err != nil {
		// If we're not clustered, we're the leader.
		if !errors.Is(err, cluster.ErrNodeIsNotClustered) {
			return err
		}

		isLeader = true
	} else if localConfig.ClusterAddress() == leaderAddress {
		isLeader = true
	}

	if !isLeader {
		return nil
	}

	projectACLs := make(map[string][]dbCluster.NetworkACL)
	err = d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		// Get all project names.
		projects, err := dbCluster.GetProjects(ctx, tx.Tx())
		if err != nil {
			return fmt.Errorf("Failed loading projects: %w", err)
		}

		for _, project := range projects {
			networkACLs, err := dbCluster.GetNetworkACLs(ctx, tx.Tx(), dbCluster.NetworkACLFilter{Project: &project.Name})
			if err != nil {
				return err
			}

			projectACLs[project.Name] = networkACLs
		}

		return nil
	})
	if err != nil {
		return err
	}

	instanceDeviceACLDefaults := func(networkConfig map[string]string, deviceCfg deviceConfig.Device, direction string) string {
		defaults := map[string]string{
			fmt.Sprintf("security.acls.default.%s.action", direction): "reject",
		}

		for k := range defaults {
			if deviceCfg[k] != "" {
				defaults[k] = deviceCfg[k]
			} else if networkConfig[k] != "" {
				defaults[k] = networkConfig[k]
			}
		}

		return defaults[fmt.Sprintf("security.acls.default.%s.action", direction)]
	}

	for projectName, networkACLs := range projectACLs {
		var projectID int64
		err := s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
			var err error

			// Get project ID.
			projectID, err = dbCluster.GetProjectID(ctx, tx.Tx(), projectName)
			if err != nil {
				return fmt.Errorf("Failed getting project ID for project %q: %w", projectName, err)
			}

			return nil
		})
		if err != nil {
			return err
		}

		aclNameIDs := make(map[string]int64, len(networkACLs))
		for _, networkACL := range networkACLs {
			aclNameIDs[networkACL.Name] = int64(networkACL.ID)
		}

		allNetworks := []string{}
		for _, networkACL := range networkACLs {
			// Get a list of networks that are using this ACL (either directly or indirectly via a NIC).
			aclNets := map[string]acl.NetworkACLUsage{}
			err = acl.NetworkUsage(s, projectName, []string{networkACL.Name}, aclNets)
			if err != nil {
				return fmt.Errorf("Failed getting ACL network usage: %w", err)
			}

			aclOVNNets := map[string]acl.NetworkACLUsage{}
			for k, v := range aclNets {
				if v.Type != "ovn" {
					continue
				}

				aclOVNNets[k] = v

				if slices.Contains(allNetworks, k) {
					continue
				}

				allNetworks = append(allNetworks, k)
			}

			if len(aclOVNNets) < 1 {
				continue
			}

			// Check that OVN is available.
			ovnnb, _, err := s.OVN()
			if err != nil {
				return err
			}

			// Get list of OVN port groups associated to this project.
			portGroups, err := ovnnb.GetPortGroupsByProject(context.TODO(), projectID)
			if err != nil {
				return fmt.Errorf("Failed getting port groups for project %q: %w", projectName, err)
			}

			// Prepare a slice `removePortGroup` containing port groups to be removed with the prefix "incus_acl".
			removePortGroups := []ovn.OVNPortGroup{}
			for _, portGroup := range portGroups {
				if !strings.HasPrefix(string(portGroup), acl.OVNACLPortGroupNamePrefix(int64(networkACL.ID))) {
					continue
				}

				removePortGroups = append(removePortGroups, portGroup)
			}

			// Delete 'old' port groups
			err = ovnnb.DeletePortGroup(context.TODO(), removePortGroups...)
			if err != nil {
				return fmt.Errorf("Failed to delete unused OVN port groups: %w", err)
			}

			cleanup, err := acl.OVNEnsureACLs(s, logger.AddContext(logger.Ctx{}), ovnnb, projectName, aclNameIDs, aclOVNNets, []string{networkACL.Name}, true)
			if err != nil {
				return fmt.Errorf("Failed ensuring ACL is configured in OVN: %w", err)
			}

			reverter.Add(cleanup)
		}

		if len(allNetworks) < 1 {
			continue
		}

		// Check that OVN is available.
		ovnnb, _, err := s.OVN()
		if err != nil {
			return err
		}

		for _, networkName := range allNetworks {
			n, err := network.LoadByName(s, projectName, networkName)
			if err != nil {
				return err
			}

			// Get list of active switch ports.
			switchName := acl.OVNIntSwitchName(n.ID())
			activePorts, err := ovnnb.GetLogicalSwitchPorts(context.TODO(), switchName)
			if err != nil {
				return fmt.Errorf("Failed getting active ports: %w", err)
			}

			addedACLs := util.SplitNTrimSpace(n.Config()["security.acls"], ",", -1, true)
			addChangeSet := map[ovn.OVNPortGroup][]ovn.OVNSwitchPortUUID{}

			err = network.UsedByInstanceDevices(s, n.Project(), n.Name(), n.Type(), func(inst db.InstanceArgs, nicName string, nicConfig map[string]string) error {
				// Combine NIC ACLs (including ACLs from the profile) with network ACLs.
				nicACLs := util.SplitNTrimSpace(nicConfig["security.acls"], ",", -1, true)
				for _, addedACL := range addedACLs {
					if slices.Contains(nicACLs, addedACL) {
						continue
					}

					nicACLs = append(nicACLs, addedACL)
				}

				// Get logical port UUID and name.
				networkPrefix := acl.OVNNetworkPrefix(n.ID())
				intSwitchInstancePortPrefix := fmt.Sprintf("%s-instance", networkPrefix)
				instancePortName := ovn.OVNSwitchPort(fmt.Sprintf("%s-%s-%s", intSwitchInstancePortPrefix, inst.Config["volatile.uuid"], nicName))

				portUUID, found := activePorts[instancePortName]
				if !found {
					return nil // No need to update a port that isn't started yet.
				}

				ingressAction := instanceDeviceACLDefaults(n.Config(), nicConfig, "ingress")
				egressAction := instanceDeviceACLDefaults(n.Config(), nicConfig, "egress")

				// Add NIC port to ACL port group.
				for _, nicACL := range nicACLs {
					aclID, found := aclNameIDs[nicACL]
					if !found {
						return fmt.Errorf("Cannot find security ACL ID for %q", nicACL)
					}

					directionalPortGroups := acl.OVNACLDirectionalPortGroups(aclID)
					var ingressPortGroupName ovn.OVNPortGroup
					if ingressAction == "allow" {
						ingressPortGroupName = directionalPortGroups.IngressReversed
					} else {
						ingressPortGroupName = directionalPortGroups.Ingress
					}

					acl.OVNPortGroupInstanceNICSchedule(portUUID, addChangeSet, ingressPortGroupName)
					logger.Debug("Scheduled logical port for ACL port group addition", logger.Ctx{"networkACL": nicACL, "portGroup": ingressPortGroupName, "port": instancePortName})

					var egressPortGroupName ovn.OVNPortGroup
					if egressAction == "allow" {
						egressPortGroupName = directionalPortGroups.EgressReversed
					} else {
						egressPortGroupName = directionalPortGroups.Egress
					}

					acl.OVNPortGroupInstanceNICSchedule(portUUID, addChangeSet, egressPortGroupName)
					logger.Debug("Scheduled logical port for ACL port group addition", logger.Ctx{"networkACL": nicACL, "portGroup": egressPortGroupName, "port": instancePortName})
				}

				return nil
			})
			if err != nil {
				return err
			}

			// Apply add changesets.
			if len(addChangeSet) > 0 {
				logger.Debug("Applying ACL port group member change sets")
				removeChangeSet := map[ovn.OVNPortGroup][]ovn.OVNSwitchPortUUID{}
				err = ovnnb.UpdatePortGroupMembers(context.TODO(), addChangeSet, removeChangeSet)
				if err != nil {
					return fmt.Errorf("Failed applying OVN port group member change sets for instance NIC: %w", err)
				}
			}
		}
	}

	reverter.Success()
	return nil
}

// patchDefaultStoragePermissions re-applies the default modes to all storage pools.
func patchDefaultStoragePermissions(_ string, d *Daemon) error {
	s := d.State()

	var pools []string

	err := s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		var err error

		// Get all storage pool names.
		pools, err = tx.GetStoragePoolNames(ctx)

		return err
	})
	if err != nil {
		// Skip the rest of the patch if no storage pools were found.
		if api.StatusErrorCheck(err, http.StatusNotFound) {
			return nil
		}

		return fmt.Errorf("Failed getting storage pool names: %w", err)
	}

	for _, pool := range pools {
		for _, volEntry := range storageDrivers.BaseDirectories {
			for _, volDir := range volEntry.Paths {
				path := filepath.Join(storagePools.GetStoragePoolMountPoint(pool), volDir)

				err := os.Chmod(path, volEntry.Mode)
				if err != nil && !errors.Is(err, fs.ErrNotExist) {
					return fmt.Errorf("Failed to set directory mode %q: %w", path, err)
				}
			}
		}
	}

	return nil
}

// patchBtrfsSubvolumeNames updates Btrfs subvolume names for instance config volumes,
// replacing the pattern '<instance-name>-' with 'instance-'.
func patchBtrfsSubvolumeNames(_ string, d *Daemon) error {
	s := d.State()

	// Get the list of local instances.
	instances, err := instance.LoadNodeAll(s, instancetype.Any)
	if err != nil {
		return fmt.Errorf("Failed loading local instances: %w", err)
	}

	for _, inst := range instances {
		volType, err := storagePools.InstanceTypeToVolumeType(inst.Type())
		if err != nil {
			return err
		}

		// Get the volume name on storage.
		volStorageName := project.Instance(inst.Project().Name, inst.Name())
		contentType := storagePools.InstanceContentType(inst)

		_, currentPool, _ := internalInstance.GetRootDiskDevice(inst.ExpandedDevices().CloneNative())

		// Load storage pool.
		p, err := storagePools.LoadByName(s, currentPool["pool"])
		if err != nil {
			logger.Error("Failed loading pool", logger.Ctx{"pool": currentPool["pool"], "err": err})
			continue
		}

		// Check if driver is 'lvmcluster'.
		if p.Driver().Info().Name != "lvmcluster" {
			continue
		}

		// Load storage volume from database.
		dbVol, err := storagePools.VolumeDBGet(p, inst.Project().Name, inst.Name(), volType)
		if err != nil {
			logger.Error("Failed loading volume", logger.Ctx{"vol": inst.Name(), "err": err})
			continue
		}

		// Process only qcow2 instances.
		if dbVol.Config["block.type"] != "qcow2" {
			continue
		}

		vol := p.GetVolume(volType, contentType, volStorageName, dbVol.Config)

		newName := storageDrivers.Qcow2ConfigVolumeBase
		fsVol := vol.NewVMBlockFilesystemVolume()

		// Increment the ref count for running instances,
		// since it is equal zero at this stage and may cause an unintended volume deactivation.
		if inst.IsRunning() {
			fsVol.MountRefCountIncrement()
		}

		err = storageDrivers.Qcow2MountConfigTask(fsVol, nil, func(mountPath string) error {
			_, volName := project.StorageVolumeParts(fsVol.Name())
			entries, err := os.ReadDir(mountPath)
			if err != nil {
				return err
			}

			// Iterate through all entries (directories) and rename them.
			for _, entry := range entries {
				if !entry.IsDir() {
					continue
				}

				oldName := entry.Name()

				if oldName == volName || strings.HasPrefix(oldName, volName) {
					newName := newName + strings.TrimPrefix(oldName, volName)

					oldPath := filepath.Join(mountPath, oldName)
					newPath := filepath.Join(mountPath, newName)

					err := os.Rename(oldPath, newPath)
					if err != nil {
						return fmt.Errorf("Failed to rename %q to %q: %w", oldPath, newPath, err)
					}
				}
			}

			return nil
		})
		if err != nil {
			logger.Error("Failed to rename btrfs subvolumes", logger.Ctx{"err": err})
			continue
		}

		if inst.IsRunning() {
			fsVol.MountRefCountDecrement()
		}
	}

	return nil
}

// patchLinstorDiscardGranularity sets `DrbdOptions/Disk/rs-discard-granularity` on pools that don’t
// already set it.
func patchLinstorDiscardGranularity(_ string, d *Daemon) error {
	s := d.State()
	var pools map[int64]api.StoragePool

	err := s.DB.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		var err error

		// Get all storage pools.
		pools, _, err = tx.GetStoragePools(ctx, nil)

		return err
	})
	if err != nil {
		// Skip the rest of the patch if no storage pools were found.
		if api.StatusErrorCheck(err, http.StatusNotFound) {
			return nil
		}

		return fmt.Errorf("Failed getting storage pools: %w", err)
	}

	var resourceGroups []string
	for _, pool := range pools {
		if pool.Driver == "linstor" {
			resourceGroups = append(resourceGroups, pool.Config[storageDrivers.LinstorResourceGroupNameConfigKey])
		}
	}

	if len(resourceGroups) == 0 {
		return nil
	}

	// Retrieve the Linstor client.
	linstor, err := s.Linstor()
	if err != nil {
		// Let’s not fail the daemon here.
		logger.Errorf("Failed to load LINSTOR client: %v", err)
		return errRetryNextTime
	}

	retryNextTime := false
	for _, resourceGroup := range resourceGroups {
		rg, err := linstor.Client.ResourceGroups.Get(context.TODO(), resourceGroup)
		if err != nil {
			logger.Errorf("Could not get LINSTOR resource group %s: %v", resourceGroup, err)
			retryNextTime = true
			continue
		}

		if rg.Props["DrbdOptions/Disk/rs-discard-granularity"] == "" {
			err = linstor.Client.ResourceGroups.Modify(context.TODO(), resourceGroup, linstorClient.ResourceGroupModify{
				OverrideProps: map[string]string{"DrbdOptions/Disk/rs-discard-granularity": "1048576"},
			})
			if err != nil {
				logger.Errorf("Could not set LINSTOR resource group %s property: %v", resourceGroup, err)
				retryNextTime = true
			}
		}
	}

	if retryNextTime {
		return errRetryNextTime
	}

	return nil
}

// patchAuthorizationOpenFGAConfigKeys migrates the OpenFGA server configuration
// keys from the legacy `openfga.*` names to the general `authorization.openfga.*`
// namespace. Existing values are copied over and the old keys are removed so
// that OpenFGA authorization keeps working seamlessly across the upgrade.
func patchAuthorizationOpenFGAConfigKeys(_ string, d *Daemon) error {
	// Mapping of the legacy key to its replacement under authorization.*.
	renamedKeys := map[string]string{
		"openfga.api.url":   "authorization.openfga.api.url",
		"openfga.api.token": "authorization.openfga.api.token",
		"openfga.store.id":  "authorization.openfga.store.id",
	}

	return d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		// Read the raw cluster config, bypassing schema validation so that the
		// now-removed legacy keys are still visible.
		config, err := tx.Config(ctx)
		if err != nil {
			return fmt.Errorf("Failed getting cluster config: %w", err)
		}

		changes := map[string]string{}
		for oldKey, newKey := range renamedKeys {
			value, ok := config[oldKey]
			if !ok {
				continue
			}

			// Only carry over the value if the new key hasn't already been set.
			if value != "" && config[newKey] == "" {
				changes[newKey] = value
			}

			// Clear the legacy key (an empty value deletes it).
			changes[oldKey] = ""
		}

		if len(changes) == 0 {
			return nil
		}

		err = tx.UpdateClusterConfig(changes)
		if err != nil {
			return fmt.Errorf("Failed updating cluster config: %w", err)
		}

		return nil
	})
}

// patchAuthorizationClientRoutesFromDriver seeds authorization.client.* config
// from the current authorizer class, so an upgrade keeps enforcing the same driver.
func patchAuthorizationClientRoutesFromDriver(_ string, d *Daemon) error {
	return d.db.Cluster.Transaction(context.TODO(), func(ctx context.Context, tx *db.ClusterTx) error {
		config, err := tx.Config(ctx)
		if err != nil {
			return fmt.Errorf("Failed getting cluster config: %w", err)
		}

		// If any explicit route is already set, the routing table has been
		// configured directly; leave it untouched.
		for _, class := range []string{"default", "unix", "tls", "tls-restricted", "oidc"} {
			if config["authorization.client."+class] != "" {
				return nil
			}
		}

		// Determine the implicitly selected driver, matching the legacy startup
		// precedence: scriptlet over OpenFGA over the default (TLS) driver.
		var changes map[string]string
		switch {
		case config["authorization.scriptlet"] != "":
			changes = map[string]string{
				"authorization.client.tls":            auth.DriverScriptlet,
				"authorization.client.tls-restricted": auth.DriverScriptlet,
				"authorization.client.oidc":           auth.DriverScriptlet,
			}

		case config["authorization.openfga.api.url"] != "" && config["authorization.openfga.api.token"] != "" && config["authorization.openfga.store.id"] != "":
			changes = map[string]string{
				"authorization.client.oidc": auth.DriverOpenFGA,
			}
		}

		err = tx.UpdateClusterConfig(changes)
		if err != nil {
			return fmt.Errorf("Failed updating cluster config: %w", err)
		}

		return nil
	})
}

// Patches end here
