feat: litt unlock command

litt/cli/litt_cli.go

@@ -18,6 +18,11 @@ var (
 		Usage:    "Source paths where the DB data is found, at least one is required.",
 		Required: true,
 	}
+	forceFlag = &cli.BoolFlag{
+		Name:    "force",
+		Aliases: []string{"f"},
+		Usage:   "Force the operation without prompting for confirmation.",
+	}
 )
 
 // buildCliParser creates a command line parser for the LittDB CLI tool.
@@ -280,9 +285,10 @@ func buildCLIParser(logger logging.Logger) *cli.App {
 			{
 				Name:      "unlock",
 				Usage:     "Manually delete LittDB lock files. Dangerous if used improperly, use with caution.",
-				ArgsUsage: "--src <path1> ... --src <pathN>",
+				ArgsUsage: "--src <path1> ... --src <pathN> [--force]",
 				Flags: []cli.Flag{
 					srcFlag,
+					forceFlag,
 				},
 				Action: unlockCommand,
 			},

litt/cli/unlock.go

@@ -1,7 +1,10 @@
 package main
 
 import (
+	"bufio"
 	"fmt"
+	"os"
+	"strings"
 
 	"github.com/Layr-Labs/eigenda/common"
 	"github.com/Layr-Labs/eigenda/litt/disktable"
@@ -20,5 +23,22 @@ func unlockCommand(ctx *cli.Context) error {
 		return fmt.Errorf("at least one source path is required")
 	}
 
+	force := ctx.Bool(forceFlag.Name)
+	if !force {
+		magicString := "I know what I am doing"
+		logger.Warnf("About to delete LittDB lock files. This is potentially dangerous. "+
+			"Type \"%s\" to continue, or use "+
+			"the --force flag.", magicString)
+		reader := bufio.NewReader(os.Stdin)
+		input, err := reader.ReadString('\n')
+		if err != nil {
+			return fmt.Errorf("failed to read input: %w", err)
+		}
+		input = strings.TrimSuffix(input, "\n")
+		if input != magicString {
+			return fmt.Errorf("unlock operation aborted")
+		}
+	}
+
 	return disktable.Unlock(logger, sources)
 }

litt/test/unlock_test.go

@@ -1,6 +1,7 @@
 package test
 
 import (
+	"fmt"
 	"os"
 	"path"
 	"path/filepath"
@@ -20,11 +21,12 @@ import (
 func TestUnlock(t *testing.T) {
 	testDir := t.TempDir()
 	rand := testrandom.NewTestRandom()
-	volumes := []string{path.Join(testDir, "volume1", path.Join(testDir, "volume2"), path.Join(testDir, "volume3"))}
+	volumes := []string{path.Join(testDir, "volume1"), path.Join(testDir, "volume2"), path.Join(testDir, "volume3")}
 
 	config, err := litt.DefaultConfig(volumes...)
 	config.Fsync = false // Disable fsync for faster tests
 	config.TargetSegmentFileSize = 100
+	config.ShardingFactor = uint32(len(volumes))
 	require.NoError(t, err)
 
 	db, err := littbuilder.NewDB(config)
@@ -55,11 +57,13 @@ func TestUnlock(t *testing.T) {
 			return nil
 		}
 		if strings.HasSuffix(path, util.LockfileName) {
+			fmt.Printf("Found lockfile %s\n", path) // TODO
 			lockFileCount++
 		}
 		return nil
 	})
 	require.NoError(t, err)
+	require.Equal(t, 3, lockFileCount)
 
 	// Unlock the DB. This should remove all lock files, but leave other files intact.
 	err = disktable.Unlock(config.Logger, volumes)

node/config.go

@@ -138,6 +138,21 @@ type Config struct {
 
 	// If true, then purge LittDB locks on startup. Potentially useful to get rid of zombie lock files,
 	// but also dangerous (multiple LittDB processes operating on the same files can lead to data corruption).
+	//
+	// When LittDB starts up, it attempts to create lock files. When a validator is forcefully shut down, lock files
+	// may be left behind. At startup time, if LittDB observes existing lock files, it first checks to see
+	// if the process that created the lock files is still running. The lock files contain the creator's PID, and so
+	// LittDB checks to see if there is any process with that PID still running.
+	//
+	// Although it should be rare, it's possible that another process may be started with the same PID as the
+	// PID used to create the lock files. When this happens, LittDB will be prevented from starting up out of
+	// fear of another process trying to access the same files, even though the original process that created the
+	// lock files is no longer running. If that happens, this flag is a safe way to force LittDB to start up
+	// without being blocked by those lock files. BE VERY CERTAIN THAT THE OTHER PROCESS IS ACTUALLY DEAD!
+	// If two instances of LittDB are running on the same files, it WILL lead to data corruption.
+	//
+	// An alternate way to clear the LittDB lock files is via the LittDB CLI with the "litt unlock" command.
+	// Run "litt unlock --help" for more information.
 	LittUnsafePurgeLocks bool
 
 	// The rate limit for the number of bytes served by the GetChunks API if the data is in the cache.

node/flags/flags.go

@@ -636,7 +636,7 @@ var optionalFlags = []cli.Flag{
 	EigenDADirectoryFlag,
 	BlsOperatorStateRetrieverFlag,
 	EigenDAServiceManagerFlag,
-	LevelDBDisableSeeksCompactionV1Flag,
+	LittUnsafePurgeLocksFlag,
 }
 
 func init() {