Merge pull request #1 from HORNET-Storage/labelling

Added differences for root leaves

Author: f7f376a1fcd0d0e11a10ed1b6577c9

dag/dag.go

@@ -80,39 +80,43 @@ func CreateDag(path string, encoding ...multibase.Encoding) (*Dag, error) {
 		return nil, err
 	}
 
-	leaf, err := CheckMetaFile(path, dag, encoder)
+	metaLeaf, err := CheckMetaFile(path, dag, encoder)
 	if err != nil {
 		log.Println("Failed to check meta file")
 	} else {
-		builder.AddLink("0", leaf.Hash)
-		leaf.SetLabel("0")
-		dag.AddLeaf(leaf, encoder, nil)
+		builder.AddLink("0", metaLeaf.Hash)
+		metaLeaf.SetLabel("0")
+		dag.AddLeaf(metaLeaf, encoder, nil)
 	}
 
+	dag.AddLeaf(metaLeaf, encoder, nil)
+
 	for _, entry := range entries {
 		if entry.Name() != ".meta" {
 			leaf, err := processEntry(entry, &path, dag, encoder)
 			if err != nil {
 				return nil, err
 			}
 
-			label := builder.GetNextAvailableLabel()
+			label := dag.GetNextAvailableLabel()
 			builder.AddLink(label, leaf.Hash)
 			leaf.SetLabel(label)
 			dag.AddLeaf(leaf, encoder, nil)
 		}
 	}
 
-	leaf, err = builder.BuildLeaf(encoder)
-
+	leaf, err := builder.BuildRootLeaf(encoder, len(dag.Leafs))
 	if err != nil {
 		return nil, err
 	}
 
 	dag.AddLeaf(leaf, encoder, nil)
 
-	rootHash := leaf.Hash
-	return dag.BuildDag(rootHash), nil
+	builtDag := dag.BuildDag(leaf.Hash)
+
+	builtDag.GenerateLabelMap()
+
+	return builtDag, nil
 }
 
 func processMetaFile(path *string, basePath *string, dag *DagBuilder, encoder multibase.Encoder) (*DagLeaf, error) {
@@ -147,7 +151,7 @@ func processMetaFile(path *string, basePath *string, dag *DagBuilder, encoder mu
 				return nil, err
 			}
 
-			label := builder.GetNextAvailableLabel()
+			label := dag.GetNextAvailableLabel()
 			builder.AddLink(label, chunkLeaf.Hash)
 			chunkLeaf.SetLabel(label)
 			dag.AddLeaf(chunkLeaf, encoder, nil)
@@ -180,23 +184,14 @@ func processEntry(entry fs.FileInfo, path *string, dag *DagBuilder, encoder mult
 			return nil, err
 		}
 
-		leaf, err := CheckMetaFile(entryPath, dag, encoder)
-		if err != nil {
-			log.Println("Failed to check meta file")
-		} else {
-			builder.AddLink("0", leaf.Hash)
-			leaf.SetLabel("0")
-			dag.AddLeaf(leaf, encoder, nil)
-		}
-
 		for _, entry := range entries {
 			if entry.Name() != ".meta" {
 				leaf, err := processEntry(entry, &entryPath, dag, encoder)
 				if err != nil {
 					return nil, err
 				}
 
-				label := builder.GetNextAvailableLabel()
+				label := dag.GetNextAvailableLabel()
 				builder.AddLink(label, leaf.Hash)
 				leaf.SetLabel(label)
 				dag.AddLeaf(leaf, encoder, nil)
@@ -227,7 +222,7 @@ func processEntry(entry fs.FileInfo, path *string, dag *DagBuilder, encoder mult
 					return nil, err
 				}
 
-				label := builder.GetNextAvailableLabel()
+				label := dag.GetNextAvailableLabel()
 				builder.AddLink(label, chunkLeaf.Hash)
 				chunkLeaf.SetLabel(label)
 				dag.AddLeaf(chunkLeaf, encoder, nil)
@@ -260,7 +255,8 @@ func chunkFile(fileData []byte, chunkSize int) [][]byte {
 
 func CreateDagBuilder() *DagBuilder {
 	return &DagBuilder{
-		Leafs: map[string]*DagLeaf{},
+		Labels: map[string]string{},
+		Leafs:  map[string]*DagLeaf{},
 	}
 }
 
@@ -271,6 +267,8 @@ func (b *DagBuilder) AddLeaf(leaf *DagLeaf, encoder multibase.Encoder, parentLea
 		if !exists {
 			parentLeaf.AddLink(leaf.Hash)
 		}
+
+		b.Labels[label] = leaf.Hash
 	}
 
 	b.Leafs[leaf.Hash] = leaf
@@ -280,22 +278,34 @@ func (b *DagBuilder) AddLeaf(leaf *DagLeaf, encoder multibase.Encoder, parentLea
 
 func (b *DagBuilder) BuildDag(root string) *Dag {
 	return &Dag{
-		Leafs: b.Leafs,
-		Root:  root,
+		Leafs:  b.Leafs,
+		Labels: b.Labels,
+		Root:   root,
 	}
 }
 
 func (dag *Dag) Verify(encoder multibase.Encoder) (bool, error) {
 	result := true
 
-	for _, leaf := range dag.Leafs {
-		leafResult, err := leaf.VerifyLeaf(encoder)
-		if err != nil {
-			return false, err
-		}
+	for hash, leaf := range dag.Leafs {
+		if hash == dag.Root {
+			leafResult, err := leaf.VerifyRootLeaf(encoder)
+			if err != nil {
+				return false, err
+			}
+
+			if !leafResult {
+				return false, nil
+			}
+		} else {
+			leafResult, err := leaf.VerifyLeaf(encoder)
+			if err != nil {
+				return false, err
+			}
 
-		if !leafResult {
-			result = false
+			if !leafResult {
+				return false, nil
+			}
 		}
 	}
 
@@ -332,7 +342,8 @@ func (dag *Dag) CreateDirectory(path string, encoder multibase.Encoder) error {
 
 	/*
 		if runtime.GOOS == "windows" {
-			p, err := syscall.UTF16PtrFromString(fileName)
+			p, err := syscal
+			l.UTF16PtrFromString(fileName)
 			if err != nil {
 				log.Fatal(err)
 			}
@@ -363,9 +374,40 @@ func ReadDag(path string) (*Dag, error) {
 		return nil, fmt.Errorf("could not decode Dag: %w", err)
 	}
 
+	result.GenerateLabelMap()
+
 	return &result, nil
 }
 
+func (dag *Dag) GenerateLabelMap() {
+	dag.Labels = map[string]string{}
+
+	for hash, _ := range dag.Leafs {
+		label := GetLabel(hash)
+
+		dag.Labels[label] = hash
+	}
+}
+
+func (dag *Dag) FindLeafByLabel(label string) *DagLeaf {
+	hash, exists := dag.Labels[label]
+
+	fmt.Println("Find leaf: " + label)
+
+	if exists {
+		fmt.Println("Found leaf: " + hash)
+
+		leaf, result := dag.Leafs[hash]
+		if result {
+			return leaf
+		} else {
+			return nil
+		}
+	} else {
+		return nil
+	}
+}
+
 func (dag *Dag) FindLeafByHash(hash string) *DagLeaf {
 	leaf, result := dag.Leafs[hash]
 	if result {
@@ -398,7 +440,13 @@ func (dag *Dag) DeleteLeaf(leaf *DagLeaf, encoder multibase.Encoder) error {
 		return fmt.Errorf("Parent leaf does not exist")
 	}
 
-	err := parentLeaf.RemoveLink(GetLabel(leaf.Hash))
+	label := GetLabel(leaf.Hash)
+
+	if label == "0" {
+		return fmt.Errorf("Unable to delete leaf 0")
+	}
+
+	err := parentLeaf.RemoveLink(label)
 	if err != nil {
 		return err
 	}
@@ -407,11 +455,18 @@ func (dag *Dag) DeleteLeaf(leaf *DagLeaf, encoder multibase.Encoder) error {
 
 	delete(dag.Leafs, leaf.Hash)
 
+	err = dag.WriteToMetaLeaf(label, encoder)
+	if err != nil {
+		return err
+	}
+
 	root, err := dag.RegenerateDag(parentLeaf, encoder)
 	if err != nil {
 		return err
 	}
 
+	dag.GenerateLabelMap()
+
 	dag.Root = *root
 
 	return nil
@@ -503,7 +558,92 @@ func (dag *Dag) RemoveChildren(leaf *DagLeaf, encoder multibase.Encoder) {
 	}
 }
 
-// There must be a better way, but this is all I could think of doing at the time
+func (dag *Dag) AddLeaf(leaf *DagLeaf) {
+	dag.Leafs[leaf.Hash] = leaf
+}
+
+func (dag *Dag) GetDataFromLeaf(leaf *DagLeaf) ([]byte, error) {
+	if len(leaf.Data) <= 0 {
+		return []byte{}, nil
+	}
+
+	var content []byte
+
+	if len(leaf.Links) > 0 {
+		for _, link := range leaf.Links {
+			childLeaf := dag.Leafs[link]
+			if childLeaf == nil {
+				return nil, fmt.Errorf("invalid link: %s", link)
+			}
+
+			content = append(content, childLeaf.Data...)
+		}
+	} else {
+		content = leaf.Data
+	}
+
+	return content, nil
+}
+
+func (dag *Dag) WriteToMetaLeaf(label string, encoder multibase.Encoder) error {
+	leaf := dag.FindLeafByLabel("0")
+
+	if leaf == nil {
+		return fmt.Errorf("Meta leaf does not exist")
+	}
+
+	content, err := dag.GetDataFromLeaf(leaf)
+	if err != nil {
+		return err
+	}
+
+	builder := CreateDagLeafBuilder(".meta")
+
+	builder.SetType(FileLeafType)
+
+	fileChunks := chunkFile(content, ChunkSize)
+
+	if len(fileChunks) == 1 {
+		builder.SetData(fileChunks[0])
+	} else {
+		for i, chunk := range fileChunks {
+			chunkEntryPath := filepath.Join(".meta", strconv.Itoa(i))
+			chunkBuilder := CreateDagLeafBuilder(chunkEntryPath)
+
+			chunkBuilder.SetType(ChunkLeafType)
+			chunkBuilder.SetData(chunk)
+
+			chunkLeaf, err := chunkBuilder.BuildLeaf(encoder)
+			if err != nil {
+				return err
+			}
+
+			label := dag.GetNextAvailableLabel()
+			builder.AddLink(label, chunkLeaf.Hash)
+			chunkLeaf.SetLabel(label)
+			dag.AddLeaf(chunkLeaf)
+		}
+	}
+
+	metaLeaf, err := builder.BuildLeaf(encoder)
+	if err != nil {
+		return err
+	}
+
+	rootLeaf := dag.Leafs[dag.Root]
+
+	if err != nil {
+		log.Println("Failed to update meta leaf")
+	} else {
+		metaLeaf.SetLabel("0")
+		rootLeaf.AddLink(metaLeaf.Hash)
+
+		dag.AddLeaf(metaLeaf)
+	}
+
+	return nil
+}
+
 func (dag *Dag) DoesExistMoreThanOnce(hash string) bool {
 	count := 0