~ubuntu-core-dev/update-manager/main

« back to all changes in this revision

Viewing changes to UpdateManager/Core/UpdateList.py

  • Committer: Robert Ancell
  • Date: 2022-09-29 20:01:45 UTC
  • mfrom: (2947.1.13 update-manager-ua)
  • Revision ID: robert.ancell@canonical.com-20220929200145-g0tia8s145rmu9mt
Show pending Ubuntu pro packages

Show diffs side-by-side

added added

removed removed

Lines of Context:
44
44
 
45
45
 
46
46
class UpdateItem():
47
 
    def __init__(self, pkg, name, icon, to_remove):
 
47
    def __init__(self, pkg, name, icon, to_remove, sensitive=True):
48
48
        self.icon = icon
49
49
        self.name = name
50
50
        self.pkg = pkg
51
51
        self.to_remove = to_remove
 
52
        self.sensitive = sensitive
52
53
 
53
54
    def is_selected(self):
54
55
        if not self.to_remove:
60
61
class UpdateGroup(UpdateItem):
61
62
    _depcache = {}
62
63
 
63
 
    def __init__(self, pkg, name, icon, to_remove):
64
 
        UpdateItem.__init__(self, pkg, name, icon, to_remove)
 
64
    def __init__(self, pkg, name, icon, to_remove, sensitive=True):
 
65
        UpdateItem.__init__(self, pkg, name, icon, to_remove, sensitive)
65
66
        self._items = set()
66
67
        self._deps = set()
67
68
        self.core_item = None
68
69
        if pkg is not None:
69
 
            self.core_item = UpdateItem(pkg, name, icon, to_remove)
 
70
            self.core_item = UpdateItem(pkg, name, icon, to_remove, sensitive)
70
71
            self._items.add(self.core_item)
71
72
 
72
73
    @property
75
76
        all_items.extend(self._items)
76
77
        return sorted(all_items, key=lambda a: a.name.lower())
77
78
 
78
 
    def add(self, pkg, cache=None, eventloop_callback=None, to_remove=False):
 
79
    def add(self, pkg, cache=None, eventloop_callback=None, to_remove=False, sensitive=True):
79
80
        name = utils.get_package_label(pkg)
80
81
        icon = Gio.ThemedIcon.new("package")
81
 
        self._items.add(UpdateItem(pkg, name, icon, to_remove))
 
82
        self._items.add(UpdateItem(pkg, name, icon, to_remove, sensitive))
82
83
        # If the pkg is in self._deps, stop here. We have already calculated
83
84
        # the recursive dependencies for this package, no need to do it again.
84
85
        if cache and pkg.name in cache and pkg.name not in self._deps:
154
155
 
155
156
 
156
157
class UpdateApplicationGroup(UpdateGroup):
157
 
    def __init__(self, pkg, application, to_remove):
 
158
    def __init__(self, pkg, application, to_remove, sensitive=True):
158
159
        name = application.get_display_name()
159
160
        icon = application.get_icon()
160
161
        super(UpdateApplicationGroup, self).__init__(pkg, name, icon,
161
 
                                                     to_remove)
 
162
                                                     to_remove, sensitive)
162
163
 
163
164
 
164
165
class UpdatePackageGroup(UpdateGroup):
165
 
    def __init__(self, pkg, to_remove):
 
166
    def __init__(self, pkg, to_remove, sensitive=True):
166
167
        name = utils.get_package_label(pkg)
167
168
        icon = Gio.ThemedIcon.new("package")
168
 
        super(UpdatePackageGroup, self).__init__(pkg, name, icon, to_remove)
 
169
        super(UpdatePackageGroup, self).__init__(pkg, name, icon, to_remove, sensitive)
169
170
 
170
171
 
171
172
class UpdateSystemGroup(UpdateGroup):
172
 
    def __init__(self, cache, to_remove):
 
173
    def __init__(self, cache, to_remove, sensitive=True):
173
174
        # Translators: the %s is a distro name, like 'Ubuntu' and 'base' as in
174
175
        # the core components and packages.
175
176
        name = _("%s base") % utils.get_ubuntu_flavor_name(cache=cache)
176
177
        icon = Gio.ThemedIcon.new("distributor-logo")
177
 
        super(UpdateSystemGroup, self).__init__(None, name, icon, to_remove)
 
178
        super(UpdateSystemGroup, self).__init__(None, name, icon, to_remove, sensitive)
178
179
 
179
180
 
180
181
class UpdateOrigin():
216
217
        self.security_groups = []
217
218
        self.kernel_autoremove_groups = []
218
219
        self.duplicate_groups = []
 
220
        self.ubuntu_pro_groups = []
219
221
        self.num_updates = 0
220
222
        self.random = random.Random()
221
223
        self.ignored_phased_updates = []
464
466
 
465
467
        return app_groups + pkg_groups
466
468
 
467
 
    def update(self, cache, eventloop_callback=None, duplicate_packages=[]):
 
469
    def update(self, cache, eventloop_callback=None, duplicate_packages=[], ua_security_packages=[]):
468
470
        self.held_back = []
469
471
 
470
472
        # do the upgrade
476
478
        kernel_autoremove_pkgs = []
477
479
        duplicate_pkgs = []
478
480
 
 
481
        class FakeUbuntuProPackageCandidate:
 
482
            def __init__ (self, source_name, version, size):
 
483
                self.source_name = source_name
 
484
                self.summary = source_name
 
485
                self.description = source_name
 
486
                self.version = version
 
487
                self.size = size
 
488
                self.downloadable = False
 
489
                self.record = {}
 
490
        class FakeUbuntuProPackage:
 
491
            def __init__ (self, package_name, version, size):
 
492
                self.name = package_name
 
493
                self.candidate = FakeUbuntuProPackageCandidate(package_name, version, size)
 
494
                self.marked_install = False
 
495
                self.marked_upgrade = False
 
496
 
 
497
            def mark_install(self):
 
498
                pass
 
499
 
 
500
            def mark_delete(self):
 
501
                pass
 
502
        fake_ua_packages = []
 
503
        for (package_name, version, size) in ua_security_packages:
 
504
            fake_ua_packages.append(FakeUbuntuProPackage(package_name, version, size))
 
505
 
479
506
        # Find all upgradable packages
480
507
        for pkg in cache:
481
508
            if pkg.is_upgradable or pkg.marked_install:
541
568
            cache, kernel_autoremove_pkgs, eventloop_callback, True)
542
569
        self.duplicate_groups = self._make_groups(
543
570
            cache, duplicate_pkgs, eventloop_callback, True)
 
571
        if len(fake_ua_packages) > 0:
 
572
            ubuntu_pro_group = UpdateGroup(None, "Ubuntu Pro (enable in Settings…)", None, False, False)
 
573
            for package in fake_ua_packages:
 
574
                ubuntu_pro_group.add(package)
 
575
            self.ubuntu_pro_groups = [ubuntu_pro_group]