github.com/Cloud-Foundations/Dominator@v0.3.4/lib/image/verify.go (about)

     1  package image
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"path"
     7  
     8  	"github.com/Cloud-Foundations/Dominator/lib/filesystem"
     9  	"github.com/Cloud-Foundations/Dominator/lib/objectserver"
    10  )
    11  
    12  func (image *Image) verify() error {
    13  	computedInodes := make(map[uint64]struct{})
    14  	return verifyDirectory(&image.FileSystem.DirectoryInode, computedInodes, "")
    15  }
    16  
    17  func verifyDirectory(directoryInode *filesystem.DirectoryInode,
    18  	computedInodes map[uint64]struct{}, name string) error {
    19  	for _, dirent := range directoryInode.EntryList {
    20  		if _, ok := dirent.Inode().(*filesystem.ComputedRegularInode); ok {
    21  			if _, ok := computedInodes[dirent.InodeNumber]; ok {
    22  				return errors.New("duplicate computed inode: " +
    23  					path.Join(name, dirent.Name))
    24  			}
    25  			computedInodes[dirent.InodeNumber] = struct{}{}
    26  		} else if inode, ok := dirent.Inode().(*filesystem.DirectoryInode); ok {
    27  			verifyDirectory(inode, computedInodes, path.Join(name, dirent.Name))
    28  		}
    29  	}
    30  	return nil
    31  }
    32  
    33  func (image *Image) verifyObjects(checker objectserver.ObjectsChecker) error {
    34  	missingObjects, err := image.ListMissingObjects(checker)
    35  	if err != nil {
    36  		return err
    37  	}
    38  	switch len(missingObjects) {
    39  	case 0:
    40  		return nil
    41  	case 1:
    42  		return fmt.Errorf("object: %x is not available", missingObjects[0])
    43  	default:
    44  		return fmt.Errorf("%d objects are not available", len(missingObjects))
    45  	}
    46  }
    47  
    48  func (image *Image) verifyRequiredPaths(requiredPaths map[string]rune) error {
    49  	if image.Filter == nil {
    50  		return nil
    51  	}
    52  	fs := image.FileSystem
    53  	filenameToInodeTable := fs.FilenameToInodeTable()
    54  	for pathName, pathType := range requiredPaths {
    55  		inum, ok := filenameToInodeTable[pathName]
    56  		if !ok {
    57  			return errors.New(
    58  				"VerifyRequiredPaths(): missing path: " + pathName)
    59  		}
    60  		inode := fs.InodeTable[inum]
    61  		switch pathType {
    62  		case 'b', 'c', 'p':
    63  			if _, ok := inode.(*filesystem.SpecialInode); !ok {
    64  				return errors.New(
    65  					"VerifyRequiredPaths(): path is not a special inode: " +
    66  						pathName)
    67  			}
    68  		case 'd':
    69  			if _, ok := inode.(*filesystem.DirectoryInode); !ok {
    70  				return errors.New(
    71  					"VerifyRequiredPaths(): path is not a directory: " +
    72  						pathName)
    73  			}
    74  		case 'f':
    75  			if _, ok := inode.(*filesystem.RegularInode); !ok {
    76  				return errors.New(
    77  					"VerifyRequiredPaths(): path is not a regular file: " +
    78  						pathName)
    79  			}
    80  		case 'l':
    81  			if _, ok := inode.(*filesystem.SymlinkInode); !ok {
    82  				return errors.New(
    83  					"VerifyRequiredPaths(): path is not a symlink: " +
    84  						pathName)
    85  			}
    86  		}
    87  	}
    88  	return nil
    89  }