diff snaps

6 files changed, 268 insertions, 136 deletions

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