Merge ~cloud-images-release-managers/cloud-images/+git/mfdiff:features/snap-diffs into ~cloud-images-release-managers/cloud-images/+git/mfdiff:master

[Tobias Koch]

diff snaps

The output of the command looks like this now (shortened for readability):

new: {}
removed: {'python3-pam': '0.4.2-13.2ubuntu6'}
changed: ['dash', 'python3-twisted', 'python3-twisted-bin:amd64']
new snaps: {'test-snap': ['stable', '1']}
removed snaps: {'lxd': ['stable/ubuntu-19.04', '9795']}
changed snaps: ['core']
==== dash: 0.5.10.2-2 => 0.5.10.2-3ubuntu1 ====
==== dash
  * preinst is removed, thus divertion is not setup upon
  ...
==== twisted: 18.7.0-2 => 18.9.0-3 ====
==== python3-twisted python3-twisted-bin:amd64
  * Don't fix package substvars in binary-arch:, they did not depend on hamcrest
  ...

[Dan Watkins (oddbloke)]

I haven't had time to do a full review, but I have a naming change suggestion: snaps are packages too, so using "pkgs" for debs is a little confusing. Could you do s/pkgs/debs/ (or deb_pkgs or something)?

[Dan Watkins (oddbloke)]

Other than the naming issue above, this looks really good. (FAOD, I'm not asking you to change every reference to debs as packages; just to modify the names that are introduced/modified in this MP.)

review: Needs Fixing

[Tobias Koch (tobijk)]

@daniel-thewatkins, ok like this?

[Dan Watkins (oddbloke)]

Thanks!

review: Approve

[Philip Roche (philroche)]

Nice

review: Approve

diff --git a/test/test_manifest.py b/test/test_manifest.py
index 29ab614..f3d38a7 100644
--- a/test/test_manifest.py
+++ b/test/test_manifest.py
@@ -9,34 +9,37 @@ class TestManifest(object):
         manifest_file.write('')
         manifest = Manifest(str(manifest_file), 'bionic', 'amd64')
         assert len(manifest) == 0
-        assert manifest.dict == {}
+        assert manifest.debs == {}
 
-    def test_single_package(self, tmpdir):
-        package_name, package_version = 'package_name', '1.0-0ubuntu1'
+    def test_single_deb(self, tmpdir):
+        deb_name, deb_version = 'deb_name', '1.0-0ubuntu1'
         manifest_file = tmpdir.join('manifest')
-        manifest_file.write(deb_package_line(package_name, package_version))
+        manifest_file.write(deb_package_line(deb_name, deb_version))
         manifest = Manifest(str(manifest_file), 'bionic', 'amd64')
         assert len(manifest) == 1
-        assert manifest.dict == { package_name: package_version }
+        assert manifest.debs == { deb_name: deb_version }
 
-    def test_snaps_are_skipped(self, tmpdir):
-        package_name, package_version = 'package_name', '1.0-0ubuntu1'
+    def test_single_snap(self, tmpdir):
+        snap_name, snap_channel, snap_version = ('snap_name', 'snap_channel',
+                'snap_version')
         manifest_file = tmpdir.join('manifest')
         manifest_file.write('\n'.join([
-            deb_package_line(package_name, package_version),
             snap_package_line('snap_name', 'snap_channel', 'snap_version')
         ]))
         manifest = Manifest(str(manifest_file), 'bionic', 'amd64')
         assert len(manifest) == 1
-        assert manifest.dict == { package_name: package_version }
+        assert manifest.snaps == { snap_name: [snap_channel, snap_version]}
 
-    def test_deb_packages_starting_with_snap_arent_skipped(self, tmpdir):
-        package_name, package_version = 'snapd', '1.0-0ubuntu1'
+    def test_deb_and_snap(self, tmpdir):
+        deb_name, deb_version = 'snapd', '1.0-0ubuntu1'
+        snap_name, snap_channel, snap_version = ('snap_name', 'snap_channel',
+                'snap_version')
         manifest_file = tmpdir.join('manifest')
         manifest_file.write('\n'.join([
-            deb_package_line(package_name, package_version),
-            snap_package_line('snap_name', 'snap_channel', 'snap_version')
+            deb_package_line(deb_name, deb_version),
+            snap_package_line(snap_name, snap_channel, snap_version)
         ]))
         manifest = Manifest(str(manifest_file), 'bionic', 'amd64')
-        assert len(manifest) == 1
-        assert manifest.dict == { package_name: package_version }
+        assert len(manifest) == 2
+        assert manifest.debs == { deb_name: deb_version }
+        assert manifest.snaps == { snap_name: [snap_channel, snap_version]}
diff --git a/test/test_manifestdiff.py b/test/test_manifestdiff.py
index 3d33731..c391f17 100644
--- a/test/test_manifestdiff.py
+++ b/test/test_manifestdiff.py
@@ -5,11 +5,11 @@ from .util import deb_package_line, snap_package_line, write_manifest_file
 class TestManifestDiff(object):
 
     def test_incompatible_manifest_raise_error(self, tmpdir):
-        package_name, package_version = 'package', '1.0-0ubuntu1'
+        deb_name, deb_version = 'package', '1.0-0ubuntu1'
         manifest_file1 = tmpdir.join('manifest1')
         manifest_file2 = tmpdir.join('manifest2')
-        manifest_file1.write(deb_package_line(package_name, package_version))
-        manifest_file2.write(deb_package_line(package_name, package_version))
+        manifest_file1.write(deb_package_line(deb_name, deb_version))
+        manifest_file2.write(deb_package_line(deb_name, deb_version))
         manifest1 = Manifest(str(manifest_file1), 'bionic', 'amd64')
         manifest2 = Manifest(str(manifest_file2), 'bionic', 'arm64')
 
@@ -21,57 +21,57 @@ class TestManifestDiff(object):
 
         assert incompatible == True
 
-    def test_find_added_packages(self, tmpdir):
-        package_list = [
+    def test_find_added_debs(self, tmpdir):
+        deb_list = [
             ('package1', '1.0-1'),
             ('package2', '0.9.1-0ubuntu1'),
         ]
-        additional_packages = [
+        additional_debs = [
             ('package3', '0.8a~tp1-1ubuntu1'),
         ]
 
         manifest_file1 = tmpdir.join('manifest1')
         manifest_file2 = tmpdir.join('manifest2')
-        write_manifest_file(manifest_file1, package_list)
-        write_manifest_file(manifest_file2, package_list
-                + additional_packages)
+        write_manifest_file(manifest_file1, debs=deb_list)
+        write_manifest_file(manifest_file2, debs=deb_list
+                + additional_debs)
 
         manifest1 = Manifest(str(manifest_file1), 'bionic', 'amd64')
         manifest2 = Manifest(str(manifest_file2), 'bionic', 'amd64')
 
         diff = ManifestDiff(manifest1, manifest2)
-        added_packages = diff.get_added()
-        assert added_packages == dict(additional_packages)
+        added_debs = diff.get_added_debs()
+        assert added_debs == dict(additional_debs)
 
-    def test_find_removed_packages(self, tmpdir):
-        package_list = [
+    def test_find_removed_debs(self, tmpdir):
+        deb_list = [
             ('package1', '1.0-1'),
             ('package2', '0.9.1-0ubuntu1')
         ]
-        additional_packages = [
+        additional_debs = [
             ('package3', '0.8a~tp1-1ubuntu1')
         ]
 
         manifest_file1 = tmpdir.join('manifest1')
         manifest_file2 = tmpdir.join('manifest2')
-        write_manifest_file(manifest_file1, package_list
-                + additional_packages)
-        write_manifest_file(manifest_file2, package_list)
+        write_manifest_file(manifest_file1, debs=deb_list
+                + additional_debs)
+        write_manifest_file(manifest_file2, debs=deb_list)
 
         manifest1 = Manifest(str(manifest_file1), 'bionic', 'amd64')
         manifest2 = Manifest(str(manifest_file2), 'bionic', 'amd64')
 
         diff = ManifestDiff(manifest1, manifest2)
-        removed_packages = diff.get_removed()
-        assert removed_packages == dict(additional_packages)
+        removed_debs = diff.get_removed_debs()
+        assert removed_debs == dict(additional_debs)
 
-    def test_find_changed_packages(self, tmpdir):
-        package_list1 = [
+    def test_find_changed_debs(self, tmpdir):
+        deb_list1 = [
             ('package1', '1.0-1'),
             ('package2', '0.9.1-0ubuntu1'),
             ('package3', '2.0'),
         ]
-        package_list2 = [
+        deb_list2 = [
             ('package1', '1.0-1'),
             ('package2', '0.10.1-0ubuntu1'),
             ('package3', '2.0'),
@@ -79,17 +79,61 @@ class TestManifestDiff(object):
 
         manifest_file1 = tmpdir.join('manifest1')
         manifest_file2 = tmpdir.join('manifest2')
-        write_manifest_file(manifest_file1, package_list1)
-        write_manifest_file(manifest_file2, package_list2)
+        write_manifest_file(manifest_file1, debs=deb_list1)
+        write_manifest_file(manifest_file2, debs=deb_list2)
 
         manifest1 = Manifest(str(manifest_file1), 'bionic', 'amd64')
         manifest2 = Manifest(str(manifest_file2), 'bionic', 'amd64')
         diff = ManifestDiff(manifest1, manifest2)
-        changed_packages = diff.get_changed()
-        assert changed_packages == ['package2']
+        changed_debs = diff.get_changed_debs()
+        assert changed_debs == ['package2']
+
+    def test_find_added_snaps(self, tmpdir):
+        snap_list = [
+            ('snap1', ['stable', '1.0-1']),
+            ('snap2', ['edge', '0.9.1-0ubuntu1']),
+        ]
+        additional_snaps = [
+            ('snap3', ['stable/ubuntu-18.04', '0.8a~tp1-1ubuntu1']),
+        ]
+
+        manifest_file1 = tmpdir.join('manifest1')
+        manifest_file2 = tmpdir.join('manifest2')
+        write_manifest_file(manifest_file1, snaps=snap_list)
+        write_manifest_file(manifest_file2, snaps=snap_list
+                + additional_snaps)
+
+        manifest1 = Manifest(str(manifest_file1), 'bionic', 'amd64')
+        manifest2 = Manifest(str(manifest_file2), 'bionic', 'amd64')
+
+        diff = ManifestDiff(manifest1, manifest2)
+        added_snaps = diff.get_added_snaps()
+        assert added_snaps == dict(additional_snaps)
+
+    def test_find_removed_snaps(self, tmpdir):
+        snap_list = [
+            ('snap1', ['stable', '1.0-1']),
+            ('snap2', ['edge', '0.9.1-0ubuntu1'])
+        ]
+        additional_snaps = [
+            ('package3', ['stable/ubuntu-18.04', '0.8a~tp1-1ubuntu1'])
+        ]
+
+        manifest_file1 = tmpdir.join('manifest1')
+        manifest_file2 = tmpdir.join('manifest2')
+        write_manifest_file(manifest_file1, snaps=snap_list
+                + additional_snaps)
+        write_manifest_file(manifest_file2, snaps=snap_list)
+
+        manifest1 = Manifest(str(manifest_file1), 'bionic', 'amd64')
+        manifest2 = Manifest(str(manifest_file2), 'bionic', 'amd64')
+
+        diff = ManifestDiff(manifest1, manifest2)
+        removed_snaps = diff.get_removed_snaps()
+        assert removed_snaps == dict(additional_snaps)
 
     def test_find_added_removed_changed(self, tmpdir):
-        package_list1 = [
+        deb_list1 = [
             ('package1', '1.0'),
             ('package4', '1.0'),
             ('package5', '1.0'),
@@ -99,7 +143,7 @@ class TestManifestDiff(object):
             ('package9', '1.0'),
             ('package10', '1.0')
         ]
-        package_list2 = [
+        deb_list2 = [
             ('package1', '1.0'),
             ('package2', '1.0'),
             ('package3', '1.0'),
@@ -110,40 +154,77 @@ class TestManifestDiff(object):
             ('package10', '1.0')
         ]
 
+        snap_list1 = [
+            ('snap1', ['stable', '1.0']),
+            ('snap4', ['stable', '1.0']),
+            ('snap5', ['stable', '1.0']),
+            ('snap6', ['stable', '1.0']),
+            ('snap7', ['stable', '1.0']),
+            ('snap8', ['stable', '1.0']),
+            ('snap9', ['stable', '1.0']),
+            ('snap10', ['stable', '1.0']),
+        ]
+        snap_list2 = [
+            ('snap1', ['stable', '1.0']),
+            ('snap2', ['stable', '1.0']),
+            ('snap3', ['stable', '1.0']),
+            ('snap4', ['stable', '2.0']),
+            ('snap5', ['edge', '1.0']),
+            ('snap6', ['stable', '1.0']),
+            ('snap9', ['stable', '1.0']),
+            ('snap10', ['stable', '1.0']),
+        ]
+
         manifest_file1 = tmpdir.join('manifest1')
         manifest_file2 = tmpdir.join('manifest2')
-        write_manifest_file(manifest_file1, package_list1)
-        write_manifest_file(manifest_file2, package_list2)
+        write_manifest_file(manifest_file1, debs=deb_list1,
+                snaps=snap_list1)
+        write_manifest_file(manifest_file2, debs=deb_list2,
+                snaps=snap_list2)
 
         manifest1 = Manifest(str(manifest_file1), 'bionic', 'amd64')
         manifest2 = Manifest(str(manifest_file2), 'bionic', 'amd64')
         diff = ManifestDiff(manifest1, manifest2)
 
-        added_packages   = diff.get_added()
-        removed_packages = diff.get_removed()
-        changed_packages = diff.get_changed()
+        added_debs   = diff.get_added_debs()
+        removed_debs = diff.get_removed_debs()
+        changed_debs = diff.get_changed_debs()
+
+        assert added_debs == {'package2': '1.0', 'package3': '1.0'}
+        assert removed_debs == {'package7': '1.0', 'package8': '1.0'}
+        assert changed_debs == ['package4', 'package5']
+
+        added_snaps = diff.get_added_snaps()
+        removed_snaps = diff.get_removed_snaps()
+        changed_snaps = diff.get_changed_snaps()
 
-        assert added_packages == {'package2': '1.0', 'package3': '1.0'}
-        assert removed_packages == {'package7': '1.0', 'package8': '1.0'}
-        assert changed_packages == ['package4', 'package5']
+        assert added_snaps == {
+            'snap2': ['stable', '1.0'],
+            'snap3': ['stable', '1.0']
+        }
+        assert removed_snaps == {
+            'snap7': ['stable', '1.0'],
+            'snap8': ['stable', '1.0']
+        }
+        assert changed_snaps == ['snap4', 'snap5']
 
     def test_kernel_fixups(self, tmpdir):
-        package_list1 = [('linux-image-4.13.0-16-generic', '4.13.0-16.19')]
-        package_list2 = [('linux-image-4.13.0-25-generic', '4.13.0-25.29')]
+        deb_list1 = [('linux-image-4.13.0-16-generic', '4.13.0-16.19')]
+        deb_list2 = [('linux-image-4.13.0-25-generic', '4.13.0-25.29')]
 
         manifest_file1 = tmpdir.join('manifest1')
         manifest_file2 = tmpdir.join('manifest2')
-        write_manifest_file(manifest_file1, package_list1)
-        write_manifest_file(manifest_file2, package_list2)
+        write_manifest_file(manifest_file1, debs=deb_list1)
+        write_manifest_file(manifest_file2, debs=deb_list2)
 
         manifest1 = Manifest(str(manifest_file1), 'bionic', 'amd64')
         manifest2 = Manifest(str(manifest_file2), 'bionic', 'amd64')
         diff = ManifestDiff(manifest1, manifest2)
 
-        added_packages   = diff.get_added()
-        removed_packages = diff.get_removed()
-        changed_packages = diff.get_changed()
+        added_debs   = diff.get_added_debs()
+        removed_debs = diff.get_removed_debs()
+        changed_debs = diff.get_changed_debs()
 
-        assert added_packages == {}
-        assert removed_packages == {}
-        assert changed_packages == ['linux-image-4.13.0-25-generic']
+        assert added_debs == {}
+        assert removed_debs == {}
+        assert changed_debs == ['linux-image-4.13.0-25-generic']
diff --git a/test/util.py b/test/util.py
index 9979a78..a39b7ec 100644
--- a/test/util.py
+++ b/test/util.py
@@ -1,6 +1,6 @@
-def deb_package_line(package_name, package_version):
+def deb_package_line(deb_name, deb_version):
     """Format a deb package manifest line"""
-    return '\t'.join([package_name, package_version])
+    return '\t'.join([deb_name, deb_version])
 
 
 def snap_package_line(snap_name, snap_channel, snap_version):
@@ -8,14 +8,20 @@ def snap_package_line(snap_name, snap_channel, snap_version):
     return '\t'.join(
         ['snap:{}'.format(snap_name), snap_channel, snap_version])
 
-def write_manifest_file(path_obj, packages):
+def write_manifest_file(path_obj, debs=None, snaps=None):
     """Write a list of packages to a manifest file."""
     manifest_lines = []
 
     # Then add more to the second.
-    for package_name, package_version in packages:
-        manifest_lines.append(deb_package_line(
-            package_name, package_version))
+    if debs is not None:
+        for deb_name, deb_version in debs:
+            manifest_lines.append(deb_package_line(
+                deb_name, deb_version))
+
+    if snaps is not None:
+        for snap_name, (snap_channel, snap_version) in snaps:
+            manifest_lines.append(snap_package_line(
+                snap_name, snap_channel, snap_version))
 
     path_obj.write("\n".join(manifest_lines))
 
diff --git a/ubuntu/cloudimage/mfdiff/cli.py b/ubuntu/cloudimage/mfdiff/cli.py
index ba8d102..5cc0629 100644
--- a/ubuntu/cloudimage/mfdiff/cli.py
+++ b/ubuntu/cloudimage/mfdiff/cli.py
@@ -128,14 +128,22 @@ def main():
     manifest_from = Manifest(manifest_from_filename, release, arch)
     manifest_diff = ManifestDiff(manifest_from, manifest_to)
 
-    added_pkgs = manifest_diff.get_added()
-    removed_pkgs = manifest_diff.get_removed()
-    changed_pkgs = manifest_diff.get_changed()
+    added_debs = manifest_diff.get_added_debs()
+    removed_debs = manifest_diff.get_removed_debs()
+    changed_debs = manifest_diff.get_changed_debs()
 
-    print("new: %s" % added_pkgs)
-    print("removed: %s" % removed_pkgs)
-    print("changed: %s" % changed_pkgs)
+    added_snaps = manifest_diff.get_added_snaps()
+    removed_snaps = manifest_diff.get_removed_snaps()
+    changed_snaps = manifest_diff.get_changed_snaps()
+
+    print("new: %s" % added_debs)
+    print("removed: %s" % removed_debs)
+    print("changed: %s" % changed_debs)
+
+    print("new snaps: %s" % added_snaps)
+    print("removed snaps: %s" % removed_snaps)
+    print("changed snaps: %s" % changed_snaps)
 
     # if modified packages, download all changelogs from changelogs.
-    if changed_pkgs:
+    if changed_debs:
         print(manifest_diff.render_changelog())
diff --git a/ubuntu/cloudimage/mfdiff/manifest.py b/ubuntu/cloudimage/mfdiff/manifest.py
index 6907ad8..bd1f416 100644
--- a/ubuntu/cloudimage/mfdiff/manifest.py
+++ b/ubuntu/cloudimage/mfdiff/manifest.py
@@ -27,23 +27,10 @@ class Manifest(object):
     def __init__(self, filename, release, arch):
         self.release = release
         self.arch = arch
-        self.dict = self._manifest_to_dict(filename)
-
-    def __iter__(self):
-        for item in self.dict:
-            yield item
-
-    def __getitem__(self, key):
-        return self.dict[key]
-
-    def __setitem__(self, key, value):
-        self.dict[key] = value
-
-    def __delitem__(self, key):
-        del self.dict[key]
+        self.debs, self.snaps = self._manifest_to_dict(filename)
 
     def __len__(self):
-        return len(self.dict)
+        return len(self.debs) + len(self.snaps)
 
     @classmethod
     def _manifest_to_dict(cls, filename):
@@ -54,12 +41,16 @@ class Manifest(object):
         :return: List of package versions by name
         :rtype: dict
         """
-        ret = {}
+        debs  = {}
+        snaps = {}
+
         logging.debug('Reading package manifest from %s', filename)
         with open(filename, "r") as manifest:
             for line in manifest:
                 if line.startswith("snap:"):
-                    continue
-                (pkg, ver) = line.split()
-                ret[pkg] = ver
-        return ret
+                    (name, channel, ver) = line[5:].split()
+                    snaps[name] = [channel, ver]
+                else:
+                    (name, ver) = line.split()
+                    debs[name] = ver
+        return debs, snaps
diff --git a/ubuntu/cloudimage/mfdiff/manifestdiff.py b/ubuntu/cloudimage/mfdiff/manifestdiff.py
index 20e7804..436e6fa 100644
--- a/ubuntu/cloudimage/mfdiff/manifestdiff.py
+++ b/ubuntu/cloudimage/mfdiff/manifestdiff.py
@@ -64,9 +64,12 @@ class ManifestDiff(object):
 
         self._manifest_from = manifest_from
         self._manifest_to   = manifest_to
-        self._added_pkgs    = {}
-        self._removed_pkgs  = {}
-        self._changed_pkgs  = []
+        self._added_debs    = {}
+        self._removed_debs  = {}
+        self._changed_debs  = []
+        self._added_snaps   = {}
+        self._removed_snaps = {}
+        self._changed_snaps = []
 
         self._cache = ManifestCache(manifest_from.release,
                 manifest_from.arch)
@@ -74,37 +77,59 @@ class ManifestDiff(object):
         if apply_fixups:
             self.apply_kernel_fixups()
 
-    def get_added(self):
+    def get_added_debs(self):
         "Find new packages in manifest_to"
-        if not self._added_pkgs:
-            for pkg in sorted(viewkeys(self._manifest_to.dict) -
-                    viewkeys(self._manifest_from.dict)):
-                logging.debug('New package: %s', pkg)
-                self._added_pkgs[pkg] = self._manifest_to.dict[pkg]
-        return self._added_pkgs
-
-    def get_removed(self):
+        if not self._added_debs:
+            self._added_debs = self._get_added_dict_items(
+                self._manifest_from.debs,
+                self._manifest_to.debs
+            )
+        return self._added_debs
+
+    def get_removed_debs(self):
         "Find packages removed from manifest_from"
-        if not self._removed_pkgs:
-            for pkg in sorted(viewkeys(self._manifest_from.dict) -
-                    viewkeys(self._manifest_to.dict)):
-                logging.debug('Removed package: %s', pkg)
-                self._removed_pkgs[pkg] = self._manifest_from[pkg]
-        return self._removed_pkgs
-
-    def get_changed(self):
+        if not self._removed_debs:
+            self._removed_debs = self._get_removed_dict_items(
+                self._manifest_from.debs,
+                self._manifest_to.debs
+            )
+        return self._removed_debs
+
+    def get_changed_debs(self):
         "Find modified packages"
-        if not self._changed_pkgs:
-            changed = []
-            for pkg in sorted(viewkeys(self._manifest_from.dict) &
-                    viewkeys(self._manifest_to.dict)):
-                if self._manifest_from[pkg] != self._manifest_to[pkg]:
-                    logging.debug('Changed package: %s', pkg)
-                    changed.append(pkg)
-
-            self._changed_pkgs = changed
-
-        return self._changed_pkgs
+        if not self._changed_debs:
+            self._changed_debs = self._get_changed_dict_items(
+                self._manifest_from.debs,
+                self._manifest_to.debs
+            )
+        return self._changed_debs
+
+    def get_added_snaps(self):
+        "Find new snaps in manifest_to"
+        if not self._added_snaps:
+            self._added_snaps = self._get_added_dict_items(
+                self._manifest_from.snaps,
+                self._manifest_to.snaps
+            )
+        return self._added_snaps
+
+    def get_removed_snaps(self):
+        "Find snaps removed from manifest_from"
+        if not self._removed_snaps:
+            self._removed_snaps = self._get_removed_dict_items(
+                self._manifest_from.snaps,
+                self._manifest_to.snaps
+            )
+        return self._removed_snaps
+
+    def get_changed_snaps(self):
+        "Find modified snaps"
+        if not self._changed_snaps:
+            self._changed_snaps = self._get_changed_dict_items(
+                self._manifest_from.snaps,
+                self._manifest_to.snaps
+            )
+        return self._changed_snaps
 
     def render_changelog(self):
         """
@@ -114,7 +139,7 @@ class ManifestDiff(object):
 
         srcs = {}
         errors = []
-        src2bins = self._cache.get_src2bin_mapping(self._changed_pkgs)
+        src2bins = self._cache.get_src2bin_mapping(self._changed_debs)
 
         # Generate changelog data per unique source package
         for source_name in src2bins:
@@ -127,19 +152,19 @@ class ManifestDiff(object):
             # Find the source version data for the binary in manifest #2
             try:
                 src['version_to'] = self._cache.source_version_for_binary(
-                        binary_name, self._manifest_to[binary_name])
+                        binary_name, self._manifest_to.debs[binary_name])
             except UnknownSourceVersionError as excp:
                 logging.error(str(excp))
                 errors.append(excp)
                 continue
 
             # Find the source version data for the binary in manifest #1
-            binver_from = self._manifest_from[binary_name]
+            binver_from = self._manifest_from.debs[binary_name]
             try:
                 src['version_from'] = self._cache.source_version_for_binary(
                         binary_name, binver_from)
             except UnknownSourceVersionError as excp:
-                if self._manifest_to[binary_name] == src['version_to']:
+                if self._manifest_to.debs[binary_name] == src['version_to']:
                     logging.info('Could not find source version data in apt '
                                  'cache. Assuming source %s version %s from '
                                  'binary %s', source_name, binver_from,
@@ -189,8 +214,8 @@ class ManifestDiff(object):
             binlist = sorted(src2bins[source_name])
             binary = binlist[0]
             result.append("==== %s: %s => %s ====" %
-                  (source_name, self._manifest_from[binary],
-                      self._manifest_to[binary]))
+                  (source_name, self._manifest_from.debs[binary],
+                      self._manifest_to.debs[binary]))
             result.append("====     %s" % ' '.join(binlist))
             for block in srcs[source_name]["changeblocks"]:
                 entry = '\n'.join([x for x in block.changes() if x])
@@ -213,17 +238,17 @@ class ManifestDiff(object):
         """
         kfixups = {}
         kmatch = re.compile("linux-image-[0-9]")
-        for pkg in self._manifest_to:
+        for pkg in self._manifest_to.debs:
             # if this is a linux-image-* binary package do some hacks to make it
             # look like manifest_from is the same (format like
             # linux-image-2.6.32-32-virtual)
             if kmatch.match(pkg):
                 logging.debug('Found kernel %s in manifest #2', pkg)
                 img_type = pkg.split("-")[-1]
-                if pkg in self._manifest_from:
+                if pkg in self._manifest_from.debs:
                     logging.debug('Found same kernel in manifest #1')
                     continue
-                for fpkg in self._manifest_from:
+                for fpkg in self._manifest_from.debs:
                     if kmatch.match(fpkg) and fpkg.endswith("-%s" % img_type):
                         logging.debug('Found similar kernel %s in manifest #1',
                                       fpkg)
@@ -232,8 +257,8 @@ class ManifestDiff(object):
         for pkg_to, pkg_from in iteritems(kfixups):
             logging.debug('Substituting kernel %s for %s in manifest #1 to '
                           'enable version comparison', pkg_to, pkg_from)
-            self._manifest_from[pkg_to] = self._manifest_from[pkg_from]
-            del self._manifest_from[pkg_from]
+            self._manifest_from.debs[pkg_to] = self._manifest_from.debs[pkg_from]
+            del self._manifest_from.debs[pkg_from]
 
     def _filter_changelog(self, changelog_path, version_low, version_high):
         """
@@ -282,3 +307,21 @@ class ManifestDiff(object):
             logging.error(error_msg)
         return change_blocks, error_msg
 
+    def _get_added_dict_items(self, from_dict, to_dict):
+        added = {}
+        for key in sorted(viewkeys(to_dict) - viewkeys(from_dict)):
+            added[key] = to_dict[key]
+        return added
+
+    def _get_removed_dict_items(self, from_dict, to_dict):
+        removed = {}
+        for key in sorted(viewkeys(from_dict) - viewkeys(to_dict)):
+            removed[key] = from_dict[key]
+        return removed
+
+    def _get_changed_dict_items(self, from_dict, to_dict):
+        changed = []
+        for key in sorted(viewkeys(from_dict) & viewkeys(to_dict)):
+            if from_dict[key] != to_dict[key]:
+                changed.append(key)
+        return changed