Merge pull request #8 from mrf345/testing

Allow multiple input paths, and tweak settings for performance (2x faster)

Author: mrf345

README.md

@@ -58,12 +58,12 @@ echo "password123456" | safelock-cli encrypt path_to_encrypt encrypted_file_path
 
   func main() {
     lock := safelock.New()
-    inputPath := "/home/testing/important"
+    inputPaths := []string{"/home/testing/important"}
     outputPath := "/home/testing/encrypted.sla"
     password := "testing123456"
 
-    // Encrypts `inputPath` with the default settings
-    if err := lock.Encrypt(nil, inputPath, outputPath, password); err != nil {
+    // Encrypts `inputPaths` with the default settings
+    if err := lock.Encrypt(nil, inputPaths, outputPath, password); err != nil {
       panic(err)
     }
 
@@ -77,31 +77,32 @@ echo "password123456" | safelock-cli encrypt path_to_encrypt encrypted_file_path
 
 ### Performance
 
-With the default settings it should be about **twice** as fast as `gpgtar`
+With the default settings it should be about **three times** faster than `gpgtar`
 
 ```shell
 > du -hs testing/
 1.2G testing/
 
-> time gpgtar --encrypt --output testing.gpg -r user testing/
-real	0m42.710s
-user	0m41.148s
-sys	0m7.943s
+> time gpgtar -e -o testing.gpg -c --yes --batch --gpg-args "--passphrase testing123456" testing/
+real	0m40.141s
+user	0m33.933s
+sys	0m6.930s
+
 
 > time echo "testing123456" | safelock-cli encrypt testing/ testing.sla --quiet
-real	0m20.697s
-user	0m25.355s
-sys	0m9.647s
+real	0m8.403s
+user	0m10.790s
+sys	0m4.832s
 ```
 
 > [!TIP]
-> You can get even faster performance using the `--sha256` flag (less secure)
+> You can get slightly better performance using the `--sha256` flag (less secure)
 
 ```shell
 > time echo "testing123456" | safelock-cli encrypt testing/ testing.sla --quiet --sha256
-real	0m16.043s
-user	0m17.550s
-sys	0m8.707s
+real	0m8.188s
+user	0m10.441s
+sys	0m4.709s
 ```
 
 And no major file size difference

cmd/decrypt.go

@@ -40,6 +40,7 @@ var decryptCmd = &cobra.Command{
 		}
 
 		sl.Quiet = beQuiet
+		sl.Registry.TempDir = tempDir
 		inputPath, outputPath := args[0], args[1]
 
 		if err = sl.Decrypt(context.TODO(), inputPath, outputPath, pwd); err != nil {

cmd/encrypt.go

@@ -41,7 +41,8 @@ var encryptCmd = &cobra.Command{
 		}
 
 		sl.Quiet = beQuiet
-		inputPath, outputPath := args[0], args[1]
+		sl.Registry.TempDir = tempDir
+		inputPath, outputPath := []string{args[0]}, args[1]
 
 		if err = sl.Encrypt(context.TODO(), inputPath, outputPath, pwd); err != nil {
 			utils.PrintErrsAndExit(err.Error())

cmd/root.go

@@ -10,6 +10,7 @@ import (
 
 var useSha256 bool
 var beQuiet bool
+var tempDir string
 
 var rootCmd = &cobra.Command{
 	Use:   "safelock-cli",
@@ -30,4 +31,5 @@ func Execute() {
 func init() {
 	rootCmd.PersistentFlags().BoolVar(&useSha256, "sha256", false, "use SHA256 (faster) instead of SHA512")
 	rootCmd.PersistentFlags().BoolVar(&beQuiet, "quiet", false, "disable output logs")
+	rootCmd.PersistentFlags().StringVar(&tempDir, "temp-dir", os.TempDir(), "directory for temporary files")
 }

safelock/decrypt.go

@@ -67,7 +67,6 @@ func (sl *Safelock) Decrypt(ctx context.Context, inputPath, outputPath, password
 		}
 
 		sl.updateStatus(fmt.Sprintf("Decrypted into %s", outputPath), 100.0)
-		sl.StatusObs.Trigger(EventStatusEnd)
 		close(signals)
 		close(errs)
 	}()
@@ -108,7 +107,7 @@ func (sl *Safelock) decryptArchiveFileInChunks(inputPath, password string) (outp
 		return
 	}
 
-	if outputFile, err = sl.Registry.NewFile("", "d_output_temp"); err != nil {
+	if outputFile, err = sl.Registry.NewFile("d_output_temp"); err != nil {
 		err = fmt.Errorf("failed to create temporary file > %w", err)
 		return
 	}
@@ -187,7 +186,12 @@ func (sl *Safelock) extractArchiveFile(ctx context.Context, outputPath string, a
 		return fmt.Errorf("cannot read archive file > %w", err)
 	}
 
-	go sl.updateArchiveFileStatus(statusCtx, archive.Name(), outputPath, "Extracting", 70.0)
+	go sl.updateArchiveFileStatus(
+		statusCtx,
+		[]string{archive.Name()},
+		outputPath,
+		"Extracting", 70.0,
+	)
 
 	if err = sl.Archival.Extract(ctx, reader, nil, fileHandler); err != nil {
 		return fmt.Errorf("cannot extract archive file > %w", err)

safelock/decrypt_test.go

@@ -54,12 +54,13 @@ func TestDecryptFileWithTimeout(t *testing.T) {
 	inputFile, _ := os.CreateTemp("", "input_file")
 	outputDirPath, _ := os.MkdirTemp("", "output_dir")
 	outputPath := filepath.Join(outputDirPath, "output_file.sla")
+	inputPaths := []string{inputFile.Name()}
 
 	cancel()
 	_, _ = inputFile.WriteString(content)
 	_, _ = inputFile.Seek(0, io.SeekStart)
 
-	encErr := sl.Encrypt(context.TODO(), inputFile.Name(), outputPath, password)
+	encErr := sl.Encrypt(context.TODO(), inputPaths, outputPath, password)
 	decErr := sl.Decrypt(ctx, inputFile.Name(), outputPath, password)
 	_, isExpectedErr := decErr.(*myErrs.ErrContextExpired)
 
@@ -80,11 +81,12 @@ func TestDecryptFileWithWrongPassword(t *testing.T) {
 	inputFile, _ := os.CreateTemp("", "input_file")
 	outputDirPath, _ := os.MkdirTemp("", "output_dir")
 	outputPath := filepath.Join(outputDirPath, "output_file.sla")
+	inputPaths := []string{inputFile.Name()}
 
 	_, _ = inputFile.WriteString(content)
 	_, _ = inputFile.Seek(0, io.SeekStart)
 
-	encErr := sl.Encrypt(context.TODO(), inputFile.Name(), outputPath, password)
+	encErr := sl.Encrypt(context.TODO(), inputPaths, outputPath, password)
 	decErr := sl.Decrypt(context.TODO(), outputPath, outputDirPath, "wrong")
 	_, isExpectedErr := errors.Unwrap(decErr).(*myErrs.ErrFailedToAuthenticate)
 

safelock/encrypt.go

@@ -20,11 +20,11 @@ import (
 	"golang.org/x/crypto/pbkdf2"
 )
 
-// encrypts `inputPath` which can be either a file or directory and output into the `outputPath`
-// which must be a nonexisting file filepath.
+// encrypts `inputPaths` which can be either a slice of file or directory paths and outputs into the `outputPath`
+// which must be a nonexisting file path.
 //
 // NOTE: `ctx` context is optional you can pass `nil` and the method will handle it
-func (sl *Safelock) Encrypt(ctx context.Context, inputPath, outputPath, password string) (err error) {
+func (sl *Safelock) Encrypt(ctx context.Context, inputPaths []string, outputPath, password string) (err error) {
 	errs := make(chan error)
 	signals := sl.getExitSignalsChannel()
 
@@ -45,7 +45,7 @@ func (sl *Safelock) Encrypt(ctx context.Context, inputPath, outputPath, password
 		var outputFile *os.File
 
 		sl.updateStatus("Validating input and output", 0.0)
-		if err = validateEncryptionPaths(inputPath, outputPath); err != nil {
+		if err = validateEncryptionPaths(inputPaths, outputPath); err != nil {
 			errs <- fmt.Errorf("invalid encryption input/output paths > %w", err)
 			return
 		}
@@ -56,7 +56,7 @@ func (sl *Safelock) Encrypt(ctx context.Context, inputPath, outputPath, password
 		}
 
 		sl.updateStatus("Creating compressed archive file", 1.0)
-		if archiveFile, err = sl.createArchiveFile(ctx, inputPath); err != nil {
+		if archiveFile, err = sl.createArchiveFile(ctx, inputPaths); err != nil {
 			errs <- fmt.Errorf("failed to create archive file > %w", err)
 			return
 		}
@@ -76,7 +76,6 @@ func (sl *Safelock) Encrypt(ctx context.Context, inputPath, outputPath, password
 
 		unRegister()
 		sl.updateStatus(fmt.Sprintf("Encrypted %s", outputPath), 100.0)
-		sl.StatusObs.Trigger(EventStatusEnd)
 		close(signals)
 		close(errs)
 	}()
@@ -103,15 +102,17 @@ func (sl *Safelock) getExitSignalsChannel() chan os.Signal {
 	return signals
 }
 
-func validateEncryptionPaths(inputPath, outputPath string) (err error) {
-	inputIsFile, inputErrFile := utils.IsValidFile(inputPath)
-	inputIsDir, inputErrDir := utils.IsValidDir(inputPath)
+func validateEncryptionPaths(inputPath []string, outputPath string) (err error) {
+	for _, inputPath := range inputPath {
+		inputIsFile, inputErrFile := utils.IsValidFile(inputPath)
+		inputIsDir, inputErrDir := utils.IsValidDir(inputPath)
 
-	if !inputIsFile && !inputIsDir {
-		if inputErrFile != nil {
-			return inputErrFile
-		} else {
-			return inputErrDir
+		if !inputIsFile && !inputIsDir {
+			if inputErrFile != nil {
+				return inputErrFile
+			} else {
+				return inputErrDir
+			}
 		}
 	}
 
@@ -122,18 +123,23 @@ func validateEncryptionPaths(inputPath, outputPath string) (err error) {
 	return
 }
 
-func (sl *Safelock) createArchiveFile(ctx context.Context, inputPath string) (file *utils.RegFile, err error) {
+func (sl *Safelock) createArchiveFile(ctx context.Context, inputPaths []string) (file *utils.RegFile, err error) {
 	var files []archiver.File
+	var filesMap = make(map[string]string)
+
+	for _, input := range inputPaths {
+		filesMap[input] = ""
+	}
 
 	statusCtx, cancelStatus := context.WithCancel(ctx)
 	defer cancelStatus()
 
-	if files, err = archiver.FilesFromDisk(nil, map[string]string{inputPath: ""}); err != nil {
+	if files, err = archiver.FilesFromDisk(nil, filesMap); err != nil {
 		err = fmt.Errorf("failed to list archive files > %w", err)
 		return
 	}
 
-	if file, err = sl.Registry.NewFile("", "e_output_temp"); err != nil {
+	if file, err = sl.Registry.NewFile("e_output_temp"); err != nil {
 		err = fmt.Errorf("failed to create temporary file > %w", err)
 		return
 	}
@@ -143,7 +149,7 @@ func (sl *Safelock) createArchiveFile(ctx context.Context, inputPath string) (fi
 		Archival:    sl.Archival,
 	}
 
-	go sl.updateArchiveFileStatus(statusCtx, inputPath, file.Name(), "Creating", 1.0)
+	go sl.updateArchiveFileStatus(statusCtx, inputPaths, file.Name(), "Creating", 1.0)
 
 	if err = format.Archive(ctx, file, files); err != nil {
 		err = fmt.Errorf("failed to create archive file > %w", err)
@@ -155,13 +161,19 @@ func (sl *Safelock) createArchiveFile(ctx context.Context, inputPath string) (fi
 	return
 }
 
-func (sl *Safelock) updateArchiveFileStatus(ctx context.Context, inputPath, archivePath, act string, start float64) {
+func (sl *Safelock) updateArchiveFileStatus(
+	ctx context.Context,
+	inputPaths []string,
+	archivePath,
+	act string,
+	start float64,
+) {
 	for {
 		select {
 		case <-ctx.Done():
 			return
 		default:
-			if p, err := utils.GetPathsPercent(inputPath, archivePath, start, 30.0); err != nil {
+			if p, err := utils.GetPathsPercent(inputPaths, archivePath, start, 30.0); err != nil {
 				return
 			} else {
 				sl.updateStatus(fmt.Sprintf("%s compressed archive file", act), p)

safelock/encrypt_test.go

@@ -14,7 +14,7 @@ import (
 
 func TestEncryptWithInvalidInputPath(t *testing.T) {
 	assert := assert.New(t)
-	inputPath := "wrong_input.txt"
+	inputPath := []string{"wrong_input.txt"}
 	password := "testing123456"
 	sl := GetQuietSafelock()
 	outputFile, _ := os.CreateTemp("", "output_file")
@@ -37,13 +37,14 @@ func TestEncryptFile(t *testing.T) {
 	outputPath := filepath.Join(outputDir, "output_file.sla")
 	content := "Hello World!"
 	decryptedPath := filepath.Join(outputDir, filepath.Base(inputFile.Name()))
+	inputPaths := []string{inputFile.Name()}
 
 	defer os.Remove(inputFile.Name())
 	defer os.RemoveAll(outputDir)
 	_, _ = inputFile.WriteString(content)
 	inputFile.Close()
 
-	inErr := encSl.Encrypt(context.TODO(), inputFile.Name(), outputPath, password)
+	inErr := encSl.Encrypt(context.TODO(), inputPaths, outputPath, password)
 	outErr := decSl.Decrypt(context.TODO(), outputPath, outputDir, password)
 	reader, _ := os.Open(decryptedPath)
 	decrypted, _ := io.ReadAll(reader)
@@ -64,13 +65,14 @@ func TestEncryptFileWithSha256AndGzip(t *testing.T) {
 	outputDir, _ := os.MkdirTemp("", "output_dir")
 	outputPath := filepath.Join(outputDir, "output_file.sla")
 	decryptedPath := filepath.Join(outputDir, filepath.Base(inputFile.Name()))
+	inputPaths := []string{inputFile.Name()}
 
 	defer os.Remove(inputFile.Name())
 	defer os.RemoveAll(outputDir)
 	_, _ = inputFile.WriteString(content)
 	_, _ = inputFile.Seek(0, io.SeekStart)
 
-	inErr := encSl.Encrypt(context.TODO(), inputFile.Name(), outputPath, password)
+	inErr := encSl.Encrypt(context.TODO(), inputPaths, outputPath, password)
 	outErr := decSl.Decrypt(context.TODO(), outputPath, outputDir, password)
 	reader, _ := os.Open(decryptedPath)
 	decrypted, _ := io.ReadAll(reader)
@@ -89,12 +91,13 @@ func TestEncryptFileWithTimeout(t *testing.T) {
 	inputFile, _ := os.CreateTemp("", "input_file")
 	outputDir, _ := os.MkdirTemp("", "output_dir")
 	outputPath := filepath.Join(outputDir, "output_file.sla")
+	inputPaths := []string{inputFile.Name()}
 
 	cancel()
 	_, _ = inputFile.WriteString(content)
 	_, _ = inputFile.Seek(0, io.SeekStart)
 
-	err := sl.Encrypt(ctx, inputFile.Name(), outputPath, password)
+	err := sl.Encrypt(ctx, inputPaths, outputPath, password)
 	_, isExpectedErr := err.(*myErrs.ErrContextExpired)
 
 	assert.NotNil(err)

safelock/examples_test.go

@@ -22,10 +22,11 @@ func ExampleSafelock_Encrypt() {
 
 	// Prepare files to encrypt (should ignore this)
 	inputFilePath, encryptedFilePath, clean := getUnencryptedFilePaths()
+	inputPaths := []string{inputFilePath}
 	defer clean()
 
-	// Encrypt `inputFilePath` with the assigned settings
-	if err := lock.Encrypt(ctx, inputFilePath, encryptedFilePath, password); err != nil {
+	// Encrypt `inputPaths` with the assigned settings
+	if err := lock.Encrypt(ctx, inputPaths, encryptedFilePath, password); err != nil {
 		fmt.Println("failed!")
 	}
 
@@ -76,9 +77,9 @@ func getEncryptedFilePath() (encryptedFilePath string, clean func()) {
 	ctx := context.Background()
 	file, _ := os.CreateTemp("", "test_input")
 	dirPath, _ := os.MkdirTemp("", "test_output")
-	filePath := file.Name()
+	filePaths := []string{file.Name()}
 	encryptedFilePath = filepath.Join(dirPath, "encrypted.sla")
-	_ = lock.Encrypt(ctx, filePath, encryptedFilePath, password)
+	_ = lock.Encrypt(ctx, filePaths, encryptedFilePath, password)
 	clean = func() {
 		os.Remove(file.Name())
 		os.RemoveAll(dirPath)

safelock/logger.go

@@ -18,5 +18,5 @@ func (sl *Safelock) log(msg string, params ...any) {
 }
 
 func (sl *Safelock) logStatus(status string, percent float64) {
-	sl.log("%s (%.2f)\n", status, percent)
+	sl.log("%s (%.2f%%)\n", status, percent)
 }

safelock/main.go

@@ -8,12 +8,12 @@
 //
 //	func main() {
 //	  lock := safelock.New()
-//	  inputPath := "/home/testing/important"
+//	  inputPaths := []string{"/home/testing/important"}
 //	  outputPath := "/home/testing/encrypted.sla"
 //	  extractTo := "/home/testing"
 //	  password := "testing123456"
 //
-//	  // Encrypts `inputPath` with the default settings
+//	  // Encrypts `inputPaths` with the default settings
 //	  if err := lock.Encrypt(nil, inputPath, outputPath, password); err != nil {
 //	    panic(err)
 //	  }