Merge pull request #1279 from percona/release-2.13.0

Release 2.13.0

Author: sandraromanchenko

.github/pr-badge.yml

@@ -34,6 +34,10 @@ on:
       - "packaging/**"
       - "version/**"
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   test:
     runs-on: ubuntu-latest
@@ -49,11 +53,45 @@ jobs:
       PR_NUMBER: ${{ github.event.number|| github.event.inputs.pr_ver }}
       MAKE_TARGET: 'build-cover'
     steps:
+      - name: Cleanup unnecessary software
+        run: |
+          sudo rm -rf /usr/share/dotnet
+          sudo rm -rf /usr/local/lib/android
+          sudo rm -rf /opt/ghc
+          sudo rm -rf /opt/hostedtoolcache/CodeQL
+          df -h
+
+      - name: Determine test branch
+        id: test_branch
+        run: |
+          if [ -n "${{ github.event.inputs.tests_ver }}" ]; then
+            echo "branch=${{ github.event.inputs.tests_ver }}" >> $GITHUB_OUTPUT
+          elif [ -n "${{ github.event.pull_request.title }}" ]; then
+            PR_TITLE="${{ github.event.pull_request.title }}"
+            echo "PR title: $PR_TITLE"
+            BRANCH_TO_CHECK=$(echo "$PR_TITLE" | grep -oE 'PBM-[0-9]+' | head -1)
+            if [ -n "$BRANCH_TO_CHECK" ]; then
+              echo "Extracted branch pattern: $BRANCH_TO_CHECK"
+              if curl -sf "https://api.github.com/repos/Percona-QA/psmdb-testing/branches/$BRANCH_TO_CHECK" > /dev/null; then
+                echo "Branch $BRANCH_TO_CHECK found, using it"
+                echo "branch=$BRANCH_TO_CHECK" >> $GITHUB_OUTPUT
+              else
+                echo "Branch $BRANCH_TO_CHECK not found, falling back to main"
+                echo "branch=main" >> $GITHUB_OUTPUT
+              fi
+            else
+              echo "No PBM-XXXXX pattern found in PR title, using main"
+              echo "branch=main" >> $GITHUB_OUTPUT
+            fi
+          else
+            echo "branch=main" >> $GITHUB_OUTPUT
+          fi
+
       - name: Checkout testing repo
         uses: actions/checkout@v4
         with:
           repository: Percona-QA/psmdb-testing
-          ref: ${{ github.event.inputs.tests_ver || 'main'}}
+          ref: ${{ steps.test_branch.outputs.branch }}
           path: psmdb-testing
 
       - name: Setup environment with PSMDB ${{ matrix.psmdb }} for PBM PR/branch ${{ github.event.pull_request.title || env.PR_NUMBER || env.PBM_BRANCH }}

.github/workflows/ci.yml

@@ -24,7 +24,7 @@ jobs:
           tar -xzf ${{ github.workspace }}/trivy/trivy.tar.gz -C ${{ github.workspace }}/trivy
 
       - name: Generate SBOM
-        run: ${{ github.workspace }}/trivy/trivy fs --format cyclonedx --output ${{ github.workspace }}/sbom.json ${{ github.workspace }}
+        run: ${{ github.workspace }}/trivy/trivy fs --format cyclonedx --output ${{ github.workspace }}/sbom.json --skip-dirs ${{ github.workspace }}/vendor ${{ github.workspace }}
 
       - name: Run trivy scan on SBOM
         run: ${{ github.workspace }}/trivy/trivy sbom ${{ github.workspace }}/sbom.json --severity HIGH,CRITICAL --ignore-unfixed --exit-code=1

.github/workflows/trivy.yml

@@ -1 +1 @@
-* @boris-ilijic @inelpandzic
+* @boris-ilijic @jcechace

CODEOWNERS

@@ -0,0 +1,5 @@
+# Percona Backup for MongoDB Code of Conduct
+
+All Percona Products follow the [Percona Community Code of Conduct](https://percona.community/contribute/coc/).
+
+If you notice any unacceptable behavior, let us know as soon as possible by writing to <community-team@percona.com>. We will respond within 48 hours.

CODE_OF_CONDUCT.md

@@ -14,6 +14,7 @@ import (
 	"github.com/percona/percona-backup-mongodb/pbm/prio"
 	"github.com/percona/percona-backup-mongodb/pbm/storage"
 	"github.com/percona/percona-backup-mongodb/pbm/topo"
+	"github.com/percona/percona-backup-mongodb/pbm/util"
 	"github.com/percona/percona-backup-mongodb/pbm/version"
 )
 
@@ -92,8 +93,10 @@ func (a *Agent) Backup(ctx context.Context, cmd *ctrl.BackupCmd, opid ctrl.OPID,
 		}
 	}
 
-	if cmd.Type == defs.LogicalBackup {
-		// wakeup the slicer to not wait for the tick
+	if cmd.Type == defs.LogicalBackup && cmd.Profile == "" {
+		// For backups to the main storage,
+		// wake up the slicer to not wait for the tick.
+		// This will slice and pause the main PITR
 		go a.sliceNow(opid)
 	}
 
@@ -155,20 +158,25 @@ func (a *Agent) Backup(ctx context.Context, cmd *ctrl.BackupCmd, opid ctrl.OPID,
 		// not replset. So an `incremental && not_base` backup should land on
 		// the agent that made a previous (src) backup.
 		const srcHostMultiplier = 3.0
-		var c map[string]float64
+		c := make(map[string]float64)
 		if cmd.Type == defs.IncrementalBackup && !cmd.IncrBase {
 			src, err := backup.LastIncrementalBackup(ctx, a.leadConn)
 			if err != nil {
 				// try backup anyway
 				l.Warning("define source backup: %v", err)
 			} else {
-				c = make(map[string]float64)
 				for _, rs := range src.Replsets {
 					c[rs.Node] = srcHostMultiplier
 				}
 			}
 		}
 
+		// When a logical backup targets an external profile (different storage),
+		// PITR keeps running. Deprioritize nodes currently running PITR slicer
+		if cmd.Type == defs.LogicalBackup && cmd.Profile != "" {
+			c = a.deprioritizePITRNodes(ctx, c, l)
+		}
+
 		agents, err := topo.ListSteadyAgents(ctx, a.leadConn)
 		if err != nil {
 			l.Error("get agents list: %v", err)
@@ -240,7 +248,7 @@ func (a *Agent) Backup(ctx context.Context, cmd *ctrl.BackupCmd, opid ctrl.OPID,
 	a.setBcp(&currentBackup{cancel: cancel})
 	defer a.setBcp(nil)
 
-	l.Info("backup started")
+	l.Info("backup started %s", util.LogProfileArg(cmd.Profile))
 	err = bcp.Run(bcpCtx, cmd, opid, l)
 	if err != nil {
 		if errors.Is(err, storage.ErrCancelled) || errors.Is(err, context.Canceled) {
@@ -266,6 +274,41 @@ func (a *Agent) getValidCandidates(agents []topo.AgentStat, backupType defs.Back
 	return validCandidates
 }
 
+// deprioritizePITRNodes adds low-priority coefficients for nodes currently running PITR slicing.
+// It only modifies the coefficient map for nodes not already present (e.g., incremental src host).
+// Returns the (possibly modified) coefficient map.
+func (a *Agent) deprioritizePITRNodes(
+	ctx context.Context,
+	coefficients map[string]float64,
+	l log.LogEvent,
+) map[string]float64 {
+	pitrLocks, err := lock.GetOpLocks(ctx, a.leadConn, &lock.LockHeader{Type: ctrl.CmdPITR})
+	if err != nil {
+		l.Warning("get pitr locks for deprioritization: %v", err)
+		return coefficients
+	}
+
+	ts, err := topo.GetClusterTime(ctx, a.leadConn)
+	if err != nil {
+		l.Warning("get cluster time for pitr deprioritization: %v", err)
+		return coefficients
+	}
+
+	for i := range pitrLocks {
+		pl := &pitrLocks[i]
+		if pl.Heartbeat.T+defs.StaleFrameSec < ts.T {
+			continue // stale lock, ignore
+		}
+
+		// Only set if not already present (preserve previous priorities)
+		if _, exists := coefficients[pl.Node]; !exists {
+			coefficients[pl.Node] = prio.DefaultScore - 0.1
+		}
+	}
+
+	return coefficients
+}
+
 const renominationFrame = 5 * time.Second
 
 func (a *Agent) nominateRS(ctx context.Context, bcp, rs string, nodes [][]string) error {

cmd/pbm-agent/backup.go

@@ -5,7 +5,6 @@ import (
 	"runtime"
 	"time"
 
-	"go.mongodb.org/mongo-driver/bson"
 	"go.mongodb.org/mongo-driver/bson/primitive"
 	"golang.org/x/sync/errgroup"
 
@@ -16,7 +15,6 @@ import (
 	"github.com/percona/percona-backup-mongodb/pbm/lock"
 	"github.com/percona/percona-backup-mongodb/pbm/log"
 	"github.com/percona/percona-backup-mongodb/pbm/oplog"
-	"github.com/percona/percona-backup-mongodb/pbm/resync"
 	"github.com/percona/percona-backup-mongodb/pbm/storage"
 	"github.com/percona/percona-backup-mongodb/pbm/topo"
 	"github.com/percona/percona-backup-mongodb/pbm/util"
@@ -95,17 +93,19 @@ func (a *Agent) Delete(ctx context.Context, d *ctrl.DeleteBackupCmd, opid ctrl.O
 			return
 		}
 
-		l.Info("deleting backups older than %v", t)
-		err = backup.DeleteBackupBefore(ctx, a.leadConn, t, bcpType, nodeInfo.Me)
+		stg, err := util.GetProfiledStorage(ctx, a.leadConn, d.Profile, nodeInfo.Me, l)
+		if err != nil {
+			l.Error("get storage: %v", err)
+			return
+		}
+		l.Info("deleting backups older than %v %s", t, util.LogProfileArg(d.Profile))
+		err = backup.DeleteBackupBefore(ctx, a.leadConn, stg, d.Profile, bcpType, t)
 		if err != nil {
 			l.Error("deleting: %v", err)
 			return
 		}
 	case d.Backup != "":
-		l = logger.NewEvent(string(ctrl.CmdDeleteBackup), d.Backup, opid.String(), ep.TS())
-		ctx := log.SetLogEventToContext(ctx, l)
-
-		l.Info("deleting backup")
+		l.Info("deleting backup %q", d.Backup)
 		err := backup.DeleteBackup(ctx, a.leadConn, d.Backup, nodeInfo.Me)
 		if err != nil {
 			l.Error("deleting: %v", err)
@@ -254,59 +254,40 @@ func (a *Agent) Cleanup(ctx context.Context, d *ctrl.CleanupCmd, opid ctrl.OPID,
 		return
 	}
 
-	cfg, err := config.GetConfig(ctx, a.leadConn)
+	cfg, err := config.GetProfiledConfig(ctx, a.leadConn, d.Profile)
 	if err != nil {
 		l.Error("get config: %v", err)
+		return
 	}
 
 	stg, err := util.StorageFromConfig(&cfg.Storage, a.brief.Me, l)
 	if err != nil {
 		l.Error("get storage: " + err.Error())
+		return
 	}
 
-	eg := errgroup.Group{}
-	eg.SetLimit(runtime.NumCPU())
-
-	cr, err := backup.MakeCleanupInfo(ctx, a.leadConn, d.OlderThan)
+	cr, err := backup.MakeCleanupInfo(ctx, a.leadConn, d.OlderThan, d.Profile)
 	if err != nil {
 		l.Error("make cleanup report: " + err.Error())
 		return
 	}
 
-	for i := range cr.Chunks {
-		name := cr.Chunks[i].FName
+	eg := &errgroup.Group{}
+	eg.SetLimit(runtime.NumCPU())
 
-		eg.Go(func() error {
-			err := stg.Delete(name)
-			return errors.Wrapf(err, "delete chunk file %q", name)
-		})
-	}
-	if err := eg.Wait(); err != nil {
+	if err := a.deleteChunks(ctx, eg, stg, cr.Chunks); err != nil {
 		l.Error(err.Error())
 	}
 
-	for i := range cr.Backups {
-		bcp := &cr.Backups[i]
-
-		eg.Go(func() error {
-			err := backup.DeleteBackupFiles(stg, bcp.Name)
-			return errors.Wrapf(err, "delete backup files %q", bcp.Name)
-		})
-	}
-	if err := eg.Wait(); err != nil {
+	if err := a.deleteBackups(ctx, eg, stg, cr.Backups); err != nil {
 		l.Error(err.Error())
 	}
-
-	err = resync.Resync(ctx, a.leadConn, &cfg.Storage, a.brief.Me, false)
-	if err != nil {
-		l.Error("storage resync: " + err.Error())
-	}
 }
 
 func (a *Agent) deletePITRImpl(ctx context.Context, ts primitive.Timestamp) error {
 	l := log.LogEventFromContext(ctx)
 
-	r, err := backup.MakeCleanupInfo(ctx, a.leadConn, ts)
+	r, err := backup.MakeCleanupInfo(ctx, a.leadConn, ts, "")
 	if err != nil {
 		return errors.Wrap(err, "get pitr chunks")
 	}
@@ -320,32 +301,40 @@ func (a *Agent) deletePITRImpl(ctx context.Context, ts primitive.Timestamp) erro
 		return errors.Wrap(err, "get storage")
 	}
 
-	return a.deleteChunks(ctx, stg, r.Chunks)
+	eg := &errgroup.Group{}
+	eg.SetLimit(runtime.NumCPU())
+	return a.deleteChunks(ctx, eg, stg, r.Chunks)
 }
 
-func (a *Agent) deleteChunks(ctx context.Context, stg storage.Storage, chunks []oplog.OplogChunk) error {
-	l := log.LogEventFromContext(ctx)
-
-	for _, chnk := range chunks {
-		err := stg.Delete(chnk.FName)
-		if err != nil && !errors.Is(err, storage.ErrNotExist) {
-			return errors.Wrapf(err, "delete pitr chunk '%s' (%v) from storage", chnk.FName, chnk)
-		}
+func (a *Agent) deleteChunks(
+	ctx context.Context,
+	eg *errgroup.Group,
+	stg storage.Storage,
+	chunks []oplog.OplogChunk,
+) error {
+	for _, c := range chunks {
+		eg.Go(func() error {
+			err := oplog.DeleteChunkData(ctx, a.leadConn, stg, c)
+			return errors.Wrapf(err, "delete chunk %q", c.FName)
+		})
+	}
+	return eg.Wait()
+}
 
-		_, err = a.leadConn.PITRChunksCollection().DeleteOne(
-			ctx,
-			bson.D{
-				{"rs", chnk.RS},
-				{"start_ts", chnk.StartTS},
-				{"end_ts", chnk.EndTS},
-			},
-		)
-		if err != nil {
-			return errors.Wrap(err, "delete pitr chunk metadata")
-		}
+func (a *Agent) deleteBackups(
+	ctx context.Context,
+	eg *errgroup.Group,
+	stg storage.Storage,
+	backups []backup.BackupMeta,
+) error {
+	l := log.LogEventFromContext(ctx)
 
-		l.Debug("deleted %s", chnk.FName)
+	for _, b := range backups {
+		eg.Go(func() error {
+			l.Info("deleting backup %q %s", b.Name, util.LogProfileArg(b.Store.Name))
+			err := backup.DeleteBackupData(ctx, a.leadConn, stg, b.Name)
+			return errors.Wrapf(err, "delete backup %q", b.Name)
+		})
 	}
-
-	return nil
+	return eg.Wait()
 }