Multithread fsverify

1 files changed, 104 insertions, 51 deletions

diff --git a/cmd/verify.go b/cmd/verify.go
index 1d18e41..0cafe5b 100644
--- a/cmd/verify.go
+++ b/cmd/verify.go
@@ -1,13 +1,19 @@
 package cmd
 
 import (
-	"bufio"
+	"bytes"
 	"fmt"
+	"math"
+	"os"
+	"sync"
+
+	"github.com/axtloss/fsverify/config"
 	"github.com/axtloss/fsverify/core"
 	"github.com/spf13/cobra"
-	"os"
 )
 
+var validateFailed bool
+
 func NewVerifyCommand() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:          "verify",
@@ -19,37 +25,71 @@ func NewVerifyCommand() *cobra.Command {
 	return cmd
 }
 
-func ValidateCommand(_ *cobra.Command, args []string) error {
+func validateThread(blockStart int, blockEnd int, bundleSize int, diskBytes []byte, n int, dbfile string, waitGroup *sync.WaitGroup, errChan chan error) {
+	defer waitGroup.Done()
+	defer close(errChan)
+	var reader *bytes.Reader
+	blockCount := math.Floor(float64(bundleSize / 2000))
+	totalReadBlocks := 0
 
-	/*entrynode := core.Node{
-		BlockStart:  0,
-		BlockEnd:    4000,
-		BlockSum:    "32fd1c42b66cbf1b2f0f1a65a3cb08f3d7845eac7f43e13b2b5b5f9f837e3346",
-		PrevNodeSum: "Entrypoint",
+	fmt.Println("DBFILE: ", dbfile)
+	db, err := core.OpenDB(dbfile, true)
+	if err != nil {
+		errChan <- err
 	}
 
-	err := core.AddNode(entrynode, nil)
+	reader = bytes.NewReader(diskBytes)
+
+	node, err := core.GetNode(fmt.Sprintf("Entrypoint%d", n), db)
 	if err != nil {
-		return err
+		errChan <- err
 	}
+	block, i, err := core.ReadBlock(node, reader, totalReadBlocks)
+	totalReadBlocks = i
 
-	entryHash, err := entrynode.GetHash()
+	err = core.VerifyBlock(block, node)
 	if err != nil {
-		return err
+		fmt.Println("fail")
+		errChan <- err
 	}
-	nextNode := core.Node{
-		BlockStart:  4000,
-		BlockEnd:    8000,
-		BlockSum:    "3d73ff8cb154dcfe8cdae426021f679e541b47dbe14e8426e6b1cd3f2c57017c",
-		PrevNodeSum: entryHash,
+
+	for int64(totalReadBlocks) < int64(blockCount) {
+		if validateFailed {
+			return
+		}
+		nodeSum, err := node.GetHash()
+		if err != nil {
+			fmt.Println("Using node ", nodeSum)
+			errChan <- err
+		}
+		node, err := core.GetNode(nodeSum, db)
+		if err != nil {
+			errChan <- err
+		}
+		fmt.Println("----")
+		fmt.Println(node)
+		part, i, err := core.ReadBlock(node, reader, totalReadBlocks)
+		totalReadBlocks = i
+		if err != nil {
+			errChan <- err
+			validateFailed = true
+			return
+		}
+		err = core.VerifyBlock(part, node)
+		if err != nil {
+			fmt.Println("fail")
+			errChan <- err
+			validateFailed = true
+			return
+			//fmt.Printf("Block '%s' ranging from %d to %d matches!\n", node.PrevNodeSum, node.BlockStart, node.BlockEnd)
+		}
+
 	}
 
-	err = core.AddNode(nextNode, nil)
-	if err != nil {
-		return err
-	}*/
+}
 
-	header, err := core.ReadHeader("/dev/sda")
+func ValidateCommand(_ *cobra.Command, args []string) error {
+	header, err := core.ReadHeader("./part.fsverify")
 	fmt.Printf("Magic Number: %d\n", header.MagicNumber)
 	fmt.Printf("Signature: %s", header.Signature)
 	fmt.Printf("FsSize: %d\n", header.FilesystemSize)
@@ -59,23 +99,17 @@ func ValidateCommand(_ *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	}
-	dbfile, err := core.ReadDB("/dev/sda")
+	fmt.Println("Reading DB")
+	//dbfile, err := core.ReadDB("/dev/sda")
+	dbfile, err := core.ReadDB("./part.fsverify")
 	if err != nil {
 		return err
 	}
 	fmt.Println("DBFILE: ", dbfile)
-	db, err := core.OpenDB(dbfile, true)
-	if err != nil {
-		return err
-	}
-
-	getnode, err := core.GetNode("Entrypoint", db)
-	if err != nil {
-		return err
-	}
-	fmt.Println(getnode)
-
-	fmt.Println("----")
+	/*	db, err := core.OpenDB(dbfile, true)
+		if err != nil {
+			return err
+		}*/
 
 	key, err := core.ReadKey()
 	if err != nil {
@@ -86,39 +120,58 @@ func ValidateCommand(_ *cobra.Command, args []string) error {
 	if err != nil {
 		return err
 	} else if !verified {
-		return fmt.Errorf("Signature verification failed\n")
+		//return fmt.Errorf("Signature verification failed\n")
+		fmt.Println("Signature verification failedw")
 	} else {
 		fmt.Println("Signature verification success!")
 	}
 
 	fmt.Println("----")
-
-	disk, err := os.Open("./partition.raw")
-	reader := bufio.NewReader(disk)
-	part, err := core.ReadBlock(getnode, reader)
+	disk, err := os.Open(args[0])
 	if err != nil {
 		return err
 	}
+	defer disk.Close()
 	diskInfo, err := disk.Stat()
-	node, err := core.GetNode("Entrypoint", db)
 	if err != nil {
 		return err
 	}
-	hash, err := core.CalculateBlockHash(part)
-	fmt.Println(hash)
+	diskSize := diskInfo.Size()
+
+	bundleSize := math.Floor(float64(diskSize / int64(config.ProcCount)))
+	//	blockCount := math.Ceil(float64(bundleSize / 2000))
+	//	lastBlockSize := int(diskSize) - int(diskSize)*config.ProcCount
+	diskBytes := make([]byte, diskSize)
+	_, err = disk.Read(diskBytes)
 	if err != nil {
 		return err
 	}
+	reader := bytes.NewReader(diskBytes)
+	var waitGroup sync.WaitGroup
+	errChan := make(chan error)
+	validateFailed = false
+	for i := 0; i < config.ProcCount; i++ {
+		diskBytes, err := core.CopyByteArea(i*(int(bundleSize)), (i+1)*(int(bundleSize)), reader)
+		if err != nil {
+			fmt.Println("Failed to copy byte area ", i*int(bundleSize), " ", (i+1)+int(bundleSize))
+			return err
+		}
+		waitGroup.Add(1)
+		go validateThread(i*int(bundleSize), (i+1)*int(bundleSize), int(bundleSize), diskBytes, i, dbfile, &waitGroup, errChan)
+	}
 
-	err = core.VerifyBlock(part, getnode)
-	if err != nil {
-		fmt.Println("fail")
-		return err
+	go func() {
+		waitGroup.Wait()
+		close(errChan)
+	}()
+
+	for err := range errChan {
+		if err != nil {
+			return err
+		}
 	}
-	fmt.Printf("Block '%s' ranging from %d to %d matches!\n", getnode.PrevNodeSum, getnode.BlockStart, getnode.BlockEnd)
 
-	fmt.Println(node)
-	for int64(core.TotalReadBlocks) < diskInfo.Size() {
+	/*for int64(core.TotalReadBlocks) < diskInfo.Size() {
 		nodeSum, err := node.GetHash()
 		if err != nil {
 			return err
@@ -145,7 +198,7 @@ func ValidateCommand(_ *cobra.Command, args []string) error {
 		}
 		fmt.Printf("Block '%s' ranging from %d to %d matches!\n", node.PrevNodeSum, node.BlockStart, node.BlockEnd)
 
-	}
+	}*/
 
 	return nil
 }