1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
#!/usr/bin/python3
from __future__ import print_function
import apt
import csv
import locale
import datetime
import operator
import os
import subprocess
import time
import gettext
import sys
from apt.utils import (
get_maintenance_end_date,
)
from optparse import OptionParser
from UpdateManager.Core.utils import twrap, get_dist
CODENAME = get_dist()
def get_release_date(dist):
distro_data = '/usr/share/distro-info/ubuntu.csv'
release_date = None
try:
with open(distro_data) as csvfile:
csv_reader = csv.DictReader(csvfile)
for row in csv_reader:
if row['series'] == CODENAME:
release_date = row['release']
break
except FileNotFoundError:
return None
if not release_date:
return None
time_t = time.mktime(time.strptime(release_date, '%Y-%m-%d'))
release_date = datetime.datetime.fromtimestamp(time_t)
return release_date
def get_component(origin_tag, filename_tag):
if origin_tag != "Ubuntu":
return None
if not filename_tag:
return None
for component in ["main", "restricted", "universe", "multiverse"]:
if filename_tag.startswith("pool/" + component):
return component
return None
def get_maintenance_status(supported_tag, component, release_date):
if supported_tag.endswith("y"):
supported_for_n_month = 12*int(supported_tag.rstrip("y"))
elif supported_tag.endswith("m"):
supported_for_n_month = int(supported_tag.rstrip("m"))
else:
raise Exception("Unsupported tag '%s'" % supported_tag)
if component in ['main', 'restricted']:
supported_by = "Canonical"
else:
supported_by = _("Community")
now = datetime.datetime.now()
# mvo: we do not define the end date very precisely
# currently this is why it will just display a end
# range
(support_end_year, support_end_month) = get_maintenance_end_date(release_date, supported_for_n_month)
support_end_month_str = locale.nl_langinfo(getattr(locale,"MON_%d" % support_end_month))
# check if the support has ended
support_ended = (now.year > support_end_year or
(now.year == support_end_year and now.month > support_end_month))
# build dict for the argument string
d = { 'support_duration' : supported_tag,
'support_end_month_str' : support_end_month_str,
'support_end_year' : support_end_year,
'supported_by' : supported_by }
return (not support_ended, d)
if __name__ == "__main__":
#FIXME: Workaround a bug in optparser which doesn't handle unicode/str
# correctly, see http://bugs.python.org/issue4391
# Should be resolved by Python3
gettext.bindtextdomain("update-manager", "/usr/share/locale")
gettext.textdomain("update-manager")
translation = gettext.translation("update-manager", fallback=True)
if sys.version >= '3':
_ = translation.gettext
else:
_ = translation.ugettext
try:
locale.setlocale(locale.LC_ALL, "")
except:
pass
parser = OptionParser()
parser.add_option("", "--show-unsupported",
action="store_true", default=False,
help=_("Show unsupported packages on this machine"))
parser.add_option("", "--show-supported",
action="store_true", default=False,
help=_("Show supported packages on this machine"))
parser.add_option("", "--show-all",
action="store_true", default=False,
help=_("Show all packages with their status"))
parser.add_option("", "--list",
action="store_true", default=False,
help=_("Show all packages in a list"))
(options, args) = parser.parse_args()
# packages that are not downloadable
no_candidate = set()
# packages that we have no support information
unsupported = set()
# dict with pkgname : support time
supported_time_for_pkgname = {}
# dict with supporttime : set of packagenames
supported_by_time = {}
# total count, for statistics
total = 0
release_date = None
if CODENAME != 'unknown distribution':
release_date = get_release_date(CODENAME)
if not release_date:
print ("No valid Ubuntu release found, support status unknown")
sys.exit(1)
# analyze
with apt.Cache() as cache:
for pkg in cache:
if pkg.is_installed:
total += 1
if not pkg.candidate or not pkg.candidate.downloadable:
no_candidate.add(pkg.name)
continue
if not "Supported" in pkg.candidate.record:
unsupported.add(pkg.name)
continue
# get support time
support_tag = pkg.candidate.record["Supported"]
component = get_component(
pkg.candidate.record.get("Origin"),
pkg.candidate.record.get("Filename"))
if not component:
unsupported.add(pkg.name)
continue
(still_supported, details) = get_maintenance_status(
support_tag, component, release_date)
if not still_supported:
unsupported.add(pkg.name)
continue
supported_time_for_pkgname[pkg.name] = (
"%(support_duration)s - %(supported_by)s" % details)
support_str = (
"%(support_end_month_str)s %(support_end_year)s "
"(%(supported_by)s - %(support_duration)s)" % details)
if not support_str in supported_by_time:
supported_by_time[support_str] = set()
supported_by_time[support_str].add(pkg.name)
# output
print(_("Support status summary of '%s':") % os.uname()[1])
print()
for (time, tset) in supported_by_time.items():
print(_("You have %(num)s packages (%(percent).1f%%) supported until %(time)s") % {
'num' : len(tset),
'percent' : len(tset) * 100.0 / total,
'time' : time})
print()
print(_("You have %(num)s packages (%(percent).1f%%) that can not/no-longer be downloaded") % {
'num' : len(no_candidate),
'percent' : len(no_candidate) * 100.0 / total})
print(_("You have %(num)s packages (%(percent).1f%%) that are unsupported") % {
'num' : len(unsupported),
'percent' : len(unsupported) * 100.0 / total})
# provide the HWE support status info as well
if os.path.exists("/usr/bin/hwe-support-status"):
print("")
subprocess.call(["/usr/bin/hwe-support-status"])
if not (options.show_unsupported or
options.show_supported or
options.show_all):
print()
print(_("Run with --show-unsupported, --show-supported or --show-all to see more details"))
if options.show_unsupported or options.show_all:
print()
print(_("No longer downloadable:"))
print(twrap(" ".join(sorted(no_candidate))))
print(_("Unsupported: "))
print(twrap(" ".join(sorted(unsupported))))
if options.show_supported or options.show_all:
for (time, tset) in supported_by_time.items():
print(_("Supported until %s:") % time)
print(twrap(" ".join(sorted(tset))))
if options.list:
pkg = max(cache, key=lambda pkg: pkg.is_installed and len(pkg.name))
field_width = len(pkg.name)
format_str = "%-"+str(field_width)+"s %s"
for pkg in sorted(cache, key=operator.attrgetter("name")):
if pkg.is_installed:
support = supported_time_for_pkgname.get(pkg.name, _("Unsupported"))
print(format_str % (pkg.name, support))
|