lens, metabase: save last epoch when metabase was resynchronized

Add new key `last_resync_epoch` to `shardInfoBucket` in metabase `boltDB` and
new field in `Info` that contains last epoch when metabase was resynchronized.
Update this value in db when the metabase is `Reset` and read on `init`.
Also make `lens` command `meta last-resync-epoch` to read this value from
metabase path. Add test. Update VERSION.md.

Closes #2887.

Signed-off-by: Andrey Butusov <[email protected]>

CHANGELOG.md

@@ -11,6 +11,8 @@ Changelog for NeoFS Node
 - `node` config option `storage.ignore_uninited_shards` (#2953)
 - For `neofs-cli container create`, add `--global-name` flag, that sets name attribute as the value of `__NEOFS__NAME` 
 attribute, which is used for container domain name in NNS contracts (#2954)
+- Save last epoch when metabase was resynchronized (#2966)
+- `neofs-lens meta last-resync-epoch` command (#2966)
 
 ### Fixed
 - Do not search for tombstones when handling their expiration, use local indexes instead (#2929)

cmd/neofs-lens/internal/meta/last_resync_epoch.go

@@ -0,0 +1,33 @@
+package meta
+
+import (
+	common "github.com/nspcc-dev/neofs-node/cmd/neofs-lens/internal"
+	"github.com/spf13/cobra"
+)
+
+var lastResyncEpochCMD = &cobra.Command{
+	Use:   "last-resync-epoch",
+	Short: "Read last epoch when metabase was resynchronized",
+	Args:  cobra.NoArgs,
+	RunE:  lastResyncEpochFunc,
+}
+
+func init() {
+	common.AddComponentPathFlag(lastResyncEpochCMD, &vPath)
+}
+
+func lastResyncEpochFunc(cmd *cobra.Command, _ []string) error {
+	db, err := openMeta(true)
+	if err != nil {
+		return err
+	}
+	defer db.Close()
+
+	epoch, err := db.ReadLastResyncEpoch()
+	if err != nil {
+		return err
+	}
+	cmd.Println(epoch)
+
+	return nil
+}

cmd/neofs-lens/internal/meta/root.go

@@ -36,6 +36,7 @@ func init() {
 		writeObjectCMD,
 		getCMD,
 		statCMD,
+		lastResyncEpochCMD,
 	)
 }
 

pkg/local_object_storage/metabase/VERSION.md

@@ -40,6 +40,7 @@ The lowest not used bucket index: 20.
     - `version` -> metabase version as little-endian uint64
     - `phy_counter` -> shard's physical object counter as little-endian uint64
     - `logic_counter` -> shard's logical object counter as little-endian uint64
+    - `last_resync_epoch` -> last epoch when metabase was resynchronized as little-endian uint64
 
 ### Unique index buckets
 - Bucket containing objects of REGULAR type

pkg/local_object_storage/metabase/control.go

@@ -138,21 +138,31 @@ func (db *DB) init(reset bool) error {
 			if err != nil {
 				return fmt.Errorf("could not sync object counter: %w", err)
 			}
+		} else {
+			err = tx.ForEach(func(name []byte, b *bbolt.Bucket) error {
+				if _, ok := mStaticBuckets[string(name)]; !ok {
+					return tx.DeleteBucket(name)
+				}
 
-			return nil
-		}
-
-		err = tx.ForEach(func(name []byte, b *bbolt.Bucket) error {
-			if _, ok := mStaticBuckets[string(name)]; !ok {
-				return tx.DeleteBucket(name)
+				return nil
+			})
+			if err != nil {
+				return err
 			}
 
-			return nil
-		})
-		if err != nil {
-			return err
+			err = updateLastResyncEpoch(tx, db.epochState.CurrentEpoch())
+			if err != nil {
+				return err
+			}
+			err = updateVersion(tx, version)
+			if err != nil {
+				return err
+			}
 		}
-		return updateVersion(tx, version)
+
+		db.info.LastResyncEpoch = getLastResyncEpoch(tx)
+
+		return nil
 	})
 }
 

pkg/local_object_storage/metabase/info.go

@@ -11,6 +11,9 @@ type Info struct {
 
 	// Permission of database file.
 	Permission fs.FileMode
+
+	// LastResyncEpoch is a last epoch when metabase was resynchronized.
+	LastResyncEpoch uint64
 }
 
 // DumpInfo returns information about the DB.

pkg/local_object_storage/metabase/last_resync_epoch.go

@@ -0,0 +1,52 @@
+package meta
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"go.etcd.io/bbolt"
+)
+
+var lastResyncEpochKey = []byte("last_resync_epoch")
+
+// ReadLastResyncEpoch reads from db last epoch when metabase was resynchronized.
+// If id is missing, returns 0, nil.
+func (db *DB) ReadLastResyncEpoch() (epoch uint64, err error) {
+	db.modeMtx.RLock()
+	defer db.modeMtx.RUnlock()
+
+	if db.mode.NoMetabase() {
+		return 0, ErrDegradedMode
+	}
+
+	err = db.boltDB.View(func(tx *bbolt.Tx) error {
+		epoch = getLastResyncEpoch(tx)
+		return nil
+	})
+
+	return
+}
+
+// updateLastResyncEpoch updates db value of last epoch when metabase was resynchronized.
+func updateLastResyncEpoch(tx *bbolt.Tx, epoch uint64) error {
+	data := make([]byte, 8)
+	binary.LittleEndian.PutUint64(data, epoch)
+
+	b, err := tx.CreateBucketIfNotExists(shardInfoBucket)
+	if err != nil {
+		return fmt.Errorf("can't create auxiliary bucket: %w", err)
+	}
+	return b.Put(lastResyncEpochKey, data)
+}
+
+func getLastResyncEpoch(tx *bbolt.Tx) uint64 {
+	b := tx.Bucket(shardInfoBucket)
+	if b != nil {
+		data := b.Get(lastResyncEpochKey)
+		if len(data) == 8 {
+			return binary.LittleEndian.Uint64(data)
+		}
+	}
+
+	return 0
+}

pkg/local_object_storage/metabase/last_resync_epoch_test.go

@@ -0,0 +1,55 @@
+package meta_test
+
+import (
+	"path/filepath"
+	"testing"
+
+	meta "github.com/nspcc-dev/neofs-node/pkg/local_object_storage/metabase"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDB_ReadLastResyncEpoch(t *testing.T) {
+	es := &epochState{
+		e: currEpoch,
+	}
+
+	db := meta.New([]meta.Option{
+		meta.WithPath(filepath.Join(t.TempDir(), "meta")),
+		meta.WithPermissions(0o600),
+		meta.WithEpochState(es),
+	}...)
+
+	require.NoError(t, db.Open(false))
+	require.NoError(t, db.Init())
+
+	t.Cleanup(func() {
+		db.Close()
+	})
+
+	checkEpoch := func(t *testing.T, epoch uint64) {
+		gotEpoch, err := db.ReadLastResyncEpoch()
+		require.NoError(t, err)
+		require.Equal(t, epoch, gotEpoch)
+		require.Equal(t, epoch, db.DumpInfo().LastResyncEpoch)
+	}
+
+	// Clean db without resynchronizations, so it is 0.
+	checkEpoch(t, 0)
+
+	// After Reset, last resync epoch == current epoch.
+	require.NoError(t, db.Reset())
+
+	checkEpoch(t, currEpoch)
+
+	// Two epochs tick, last resync epoch the same.
+	es.e = currEpoch + 2
+
+	checkEpoch(t, currEpoch)
+
+	// After reload, last resync epoch the same.
+	require.NoError(t, db.Close())
+	require.NoError(t, db.Open(false))
+	require.NoError(t, db.Init())
+
+	checkEpoch(t, currEpoch)
+}