| package binary |
| |
| import ( |
| "fmt" |
| "io/ioutil" |
| "os" |
| "path/filepath" |
| "sort" |
| "strings" |
| |
| "cos.googlesource.com/cos/tools.git/src/cmd/cos_image_analyzer/internal/input" |
| "cos.googlesource.com/cos/tools.git/src/cmd/cos_image_analyzer/internal/utilities" |
| ) |
| |
| // Global variables |
| var ( |
| // Command-line path strings |
| // /etc is the OS configurations directory |
| etc = "/etc/" |
| |
| // /etc/os-release is the file describing COS versioning |
| etcOSRelease = "/etc/os-release" |
| ) |
| |
| // Differences is a intermediate Struct used to store all binary differences |
| // Field names are pre-defined in parse_input.go and will be cross-checked with -binary flag. |
| type Differences struct { |
| Version []string |
| BuildID []string |
| Rootfs string |
| OSConfigs map[string]string |
| Stateful string |
| PartitionStructure string |
| KernelConfigs string |
| KernelCommandLine map[string]string |
| SysctlSettings string |
| } |
| |
| // versionDiff calculates the Version difference of two images |
| func (d *Differences) versionDiff(image1, image2 *input.ImageInfo) { |
| if image1.Version != image2.Version { |
| d.Version = []string{image1.Version, image2.Version} |
| } |
| } |
| |
| // buildDiff calculates the BuildID difference of two images |
| func (d *Differences) buildDiff(image1, image2 *input.ImageInfo) { |
| if image1.BuildID != image2.BuildID { |
| d.BuildID = []string{image1.BuildID, image2.BuildID} |
| } |
| } |
| |
| // rootfsDiff calculates the Root FS difference of two images |
| func (d *Differences) rootfsDiff(image1, image2 *input.ImageInfo, flagInfo *input.FlagInfo) error { |
| rootfsDiff, err := directoryDiff(image1.RootfsPartition3, image2.RootfsPartition3, "rootfs", flagInfo.Verbose, flagInfo.CompressRootfsSlice) |
| if err != nil { |
| return fmt.Errorf("fail to diff Rootfs partitions %v and %v: %v", image1.RootfsPartition3, image2.RootfsPartition3, err) |
| } |
| d.Rootfs = rootfsDiff |
| return nil |
| } |
| |
| // osConfigDiff calculates the OsConfig difference of two images |
| func (d *Differences) osConfigDiff(image1, image2 *input.ImageInfo, flagInfo *input.FlagInfo) error { |
| mapOfEtcEntries, err := findOSConfigs(image1, image2) // Get map of /etc entries for both images |
| if err != nil { |
| return fmt.Errorf("failed to find OS Configs: %v", err) |
| } |
| output := make(map[string]string) |
| for etcEntryName, img := range mapOfEtcEntries { |
| etcEntryPath := filepath.Join(etc, etcEntryName) + "/" |
| if flagInfo.Verbose || !utilities.InArray(etcEntryPath, flagInfo.CompressRootfsSlice) { // Only diff if Verbose or etcEntry is not in CompressRootfs.txt |
| currentImage := img |
| if img != "" { // Unique /etc entry in Image 1 or Image2 |
| output[etcEntryPath] += "Only in " + img + "/rootfs/etc: " + etcEntryName |
| } else { // Shared /etc entry in Image 1 and Image 2 |
| osConfigDiff, err := pureDiff(filepath.Join(image1.RootfsPartition3, etcEntryPath), filepath.Join(image2.RootfsPartition3, etcEntryPath)) |
| if err != nil { |
| return fmt.Errorf("fail to take \"diff -r --no-dereference\" on %v: %v", etcEntryPath, err) |
| } |
| currentImage = image1.TempDir |
| output[etcEntryPath] = osConfigDiff |
| } |
| |
| fullPath := filepath.Join(currentImage, "/rootfs/", etcEntryPath) |
| entryFile, err := os.Stat(fullPath) |
| if err != nil { |
| return fmt.Errorf("failed to get info on file %v: %v", fullPath, err) |
| } |
| if output[etcEntryPath] != "" { |
| if entryFile.IsDir() { |
| output[etcEntryPath] = "Configs for directory " + etcEntryPath + "\n" + output[etcEntryPath] |
| } else { |
| output[etcEntryPath] = "Configs for file " + etcEntryPath + "\n" + output[etcEntryPath] |
| } |
| } |
| } |
| } |
| d.OSConfigs = output |
| return nil |
| } |
| |
| // statefulDiff calculates the stateful partition difference of two images |
| func (d *Differences) statefulDiff(image1, image2 *input.ImageInfo, flagInfo *input.FlagInfo) error { |
| statefulDiff, err := directoryDiff(image1.StatePartition1, image2.StatePartition1, "stateful", flagInfo.Verbose, flagInfo.CompressStatefulSlice) |
| if err != nil { |
| return fmt.Errorf("failed to diff stateful partitions %v and %v: %v", image1.StatePartition1, image2.StatePartition1, err) |
| } |
| d.Stateful = statefulDiff |
| return nil |
| } |
| |
| // partitionStructureDiff calculates the Version difference of two images |
| func (d *Differences) partitionStructureDiff(image1, image2 *input.ImageInfo) error { |
| if image2.TempDir != "" { |
| partitionStructureDiff, err := pureDiff(image1.PartitionFile, image2.PartitionFile) |
| if err != nil { |
| return fmt.Errorf("fail to compare both image's \"partitions.txt\" file: %v", err) |
| } |
| d.PartitionStructure = partitionStructureDiff |
| } else { |
| image1Structure, err := ioutil.ReadFile(image1.PartitionFile) |
| if err != nil { |
| return fmt.Errorf("failed to read partition file of image %v: %v", image1.TempDir, err) |
| } |
| d.PartitionStructure = string(image1Structure) |
| } |
| return nil |
| } |
| |
| // kernelConfigsDiff calculates the kernel configs difference of two images |
| func (d *Differences) kernelConfigsDiff(image1, image2 *input.ImageInfo) error { |
| if image2.TempDir != "" { |
| kernelConfigsDiff, err := pureDiff(image1.KernelConfigsFile, image2.KernelConfigsFile) |
| if err != nil { |
| return fmt.Errorf("fail to compare the two image's kernel configs files: %v", err) |
| } |
| d.KernelConfigs = kernelConfigsDiff |
| } else { |
| image1KernelConfigs, err := ioutil.ReadFile(image1.KernelConfigsFile) |
| if err != nil { |
| return fmt.Errorf("failed to read kernel configs file of image %v: %v", image1.TempDir, err) |
| } |
| d.KernelConfigs = string(image1KernelConfigs) |
| } |
| return nil |
| } |
| |
| // kernelCommandLineDiff calculates the kernel commad line difference of two images |
| func (d *Differences) kernelCommandLineDiff(image1, image2 *input.ImageInfo) error { |
| output := make(map[string]string) |
| if image2.TempDir != "" { |
| mapImage1 := getKclMap(strings.Fields(image1.KernelCommandLine)) |
| mapImage2 := getKclMap(strings.Fields(image2.KernelCommandLine)) |
| |
| for key1, value1 := range mapImage1 { |
| if value2, ok := mapImage2[key1]; !ok { // Unique KCL parameter in image1 |
| if value1 != "" { |
| output[key1] = "d\n" + "< " + key1 + "=" + value1 |
| } else { |
| output[key1] = "d\n" + "< " + key1 |
| } |
| } else if value2 != value1 { // Image1 and Image2 KCL parameter values differ |
| output[key1] = "c\n" + "< " + key1 + "=" + value1 + "\n---\n> " + key1 + "=" + value2 |
| } |
| } |
| for key2, value2 := range mapImage2 { |
| if _, ok := mapImage1[key2]; !ok { // Unique KCL parameter in image2 |
| if value2 != "" { |
| output[key2] = "a\n" + "> " + key2 + "=" + value2 |
| } else { |
| output[key2] = "a\n" + "> " + key2 |
| } |
| } |
| } |
| } else { |
| output["Image1 KCL"] = image1.KernelCommandLine |
| } |
| d.KernelCommandLine = output |
| return nil |
| } |
| |
| // sysctlSettingsDiff calculates the sysctl Settings difference of two images |
| func (d *Differences) sysctlSettingsDiff(image1, image2 *input.ImageInfo) error { |
| if image2.TempDir != "" { |
| sysctlSettingsDiff, err := pureDiff(image1.SysctlSettingsFile, image2.SysctlSettingsFile) |
| if err != nil { |
| return fmt.Errorf("fail to compare the two image's sysctl settings files: %v", err) |
| } |
| d.SysctlSettings = sysctlSettingsDiff |
| } else { |
| image1SysctlSettings, err := ioutil.ReadFile(image1.SysctlSettingsFile) |
| if err != nil { |
| return fmt.Errorf("failed to convert image 1's %v file to string: %v", image1.SysctlSettingsFile, err) |
| } |
| d.SysctlSettings = string(image1SysctlSettings) |
| } |
| return nil |
| } |
| |
| // FormatVersionDiff returns a formated string of the version difference |
| func (d *Differences) FormatVersionDiff() string { |
| if len(d.Version) == 2 { |
| if d.Version[1] != "" { |
| return "----------Version----------\n< " + d.Version[0] + "\n> " + d.Version[1] + "\n\n" |
| } |
| return "----------Version----------\n" + d.Version[0] + "\n\n" |
| } |
| return "" |
| } |
| |
| // FormatBuildIDDiff returns a formated string of the build difference |
| func (d *Differences) FormatBuildIDDiff() string { |
| if len(d.BuildID) == 2 { |
| if d.BuildID[1] != "" { |
| return "----------BuildID----------\n< " + d.BuildID[0] + "\n> " + d.BuildID[1] + "\n\n" |
| } |
| return "----------BuildID----------\n" + d.BuildID[0] + "\n\n" |
| } |
| return "" |
| } |
| |
| // FormatRootfsDiff returns a formated string of the rootfs difference |
| func (d *Differences) FormatRootfsDiff() string { |
| if d.Rootfs != "" { |
| return "----------RootFS----------\n" + d.Rootfs + "\n\n" |
| } |
| return "" |
| } |
| |
| // FormatStatefulDiff returns a formated string of the stateful partition difference |
| func (d *Differences) FormatStatefulDiff() string { |
| if d.Stateful != "" { |
| return "----------Stateful Partition----------\n" + d.Stateful + "\n\n" |
| } |
| return "" |
| } |
| |
| // FormatOSConfigDiff returns a formated string of the OS Config difference |
| func (d *Differences) FormatOSConfigDiff() string { |
| if len(d.OSConfigs) > 0 { |
| osConfigDifference := "----------OS Configurations----------\n" |
| keys := make([]string, 0) |
| for k := range d.OSConfigs { |
| keys = append(keys, k) |
| } |
| sort.Strings(keys) |
| for _, k := range keys { |
| if d.OSConfigs[k] != "" { |
| osConfigDifference += d.OSConfigs[k] + "\n\n" |
| } |
| } |
| return osConfigDifference |
| } |
| return "" |
| } |
| |
| // FormatPartitionStructureDiff returns a formated string of the partition structure difference |
| func (d *Differences) FormatPartitionStructureDiff() string { |
| if d.PartitionStructure != "" { |
| return "----------Partition Structure----------\n" + d.PartitionStructure + "\n\n" |
| } |
| return "" |
| } |
| |
| // FormatKernelConfigsDiff returns a formated string of the kernel configs difference |
| func (d *Differences) FormatKernelConfigsDiff() string { |
| if d.KernelConfigs != "" { |
| return "----------Kernel Configs----------\n" + d.KernelConfigs + "\n\n" |
| } |
| return "" |
| } |
| |
| // FormatKernelCommandLineDiff returns a formated string of the KCL difference |
| func (d *Differences) FormatKernelCommandLineDiff() string { |
| if len(d.KernelCommandLine) > 0 { |
| kclDifference := "----------Kernel Command Line----------\n" |
| keys := make([]string, 0) |
| for k := range d.KernelCommandLine { |
| keys = append(keys, k) |
| } |
| sort.Strings(keys) |
| for _, k := range keys { |
| if d.KernelCommandLine[k] != "" { |
| kclDifference += d.KernelCommandLine[k] + "\n\n" |
| } |
| } |
| return kclDifference |
| } |
| return "" |
| } |
| |
| // FormatSysctlSettingsDiff returns a formated string of the Sysctrl settings difference |
| func (d *Differences) FormatSysctlSettingsDiff() string { |
| if d.SysctlSettings != "" { |
| return "----------Sysctl settings----------\n" + d.SysctlSettings + "\n\n" |
| } |
| return "" |
| } |
| |
| // Diff is a tool that finds all binary differences of two COS images |
| // (COS version, rootfs, kernel command line, stateful partition, ...) |
| // Input: |
| // (*ImageInfo) image1 - A struct that will store binary info for image1 |
| // (*ImageInfo) image2 - A struct that will store binary info for image2 |
| // (*FlagInfo) flagInfo - A struct that holds input preference from the user |
| // Output: |
| // (*Differences) BinaryDiff - A struct that will store the binary differences |
| func Diff(image1, image2 *input.ImageInfo, flagInfo *input.FlagInfo) (*Differences, error) { |
| BinaryDiff := &Differences{} |
| |
| if utilities.InArray("Version", flagInfo.BinaryTypesSelected) { |
| BinaryDiff.versionDiff(image1, image2) |
| } |
| if utilities.InArray("BuildID", flagInfo.BinaryTypesSelected) { |
| BinaryDiff.buildDiff(image1, image2) |
| } |
| |
| if utilities.InArray("Partition-structure", flagInfo.BinaryTypesSelected) { |
| if err := BinaryDiff.partitionStructureDiff(image1, image2); err != nil { |
| return BinaryDiff, fmt.Errorf("Failed to get Partition-structure difference: %v", err) |
| } |
| } |
| if utilities.InArray("Kernel-configs", flagInfo.BinaryTypesSelected) { |
| if err := BinaryDiff.kernelConfigsDiff(image1, image2); err != nil { |
| return BinaryDiff, fmt.Errorf("failed to get Kernel-configs difference: %v", err) |
| } |
| } |
| if utilities.InArray("Kernel-command-line", flagInfo.BinaryTypesSelected) { |
| if err := BinaryDiff.kernelCommandLineDiff(image1, image2); err != nil { |
| return BinaryDiff, fmt.Errorf("failed to get Kernel-command-line difference: %v", err) |
| } |
| } |
| if utilities.InArray("Sysctl-settings", flagInfo.BinaryTypesSelected) { |
| if err := BinaryDiff.sysctlSettingsDiff(image1, image2); err != nil { |
| return BinaryDiff, fmt.Errorf("failed to get Sysctl-settings difference: %v", err) |
| } |
| } |
| |
| if image2.TempDir != "" { |
| if utilities.InArray("Rootfs", flagInfo.BinaryTypesSelected) { |
| if err := BinaryDiff.rootfsDiff(image1, image2, flagInfo); err != nil { |
| return BinaryDiff, fmt.Errorf("Failed to get Roofs difference: %v", err) |
| } |
| } |
| if utilities.InArray("OS-config", flagInfo.BinaryTypesSelected) { |
| if err := BinaryDiff.osConfigDiff(image1, image2, flagInfo); err != nil { |
| return BinaryDiff, fmt.Errorf("Failed to get OS-config difference: %v", err) |
| } |
| } |
| if utilities.InArray("Stateful-partition", flagInfo.BinaryTypesSelected) { |
| if err := BinaryDiff.statefulDiff(image1, image2, flagInfo); err != nil { |
| return BinaryDiff, fmt.Errorf("Failed to get Stateful-partition difference: %v", err) |
| } |
| } |
| } |
| return BinaryDiff, nil |
| } |