-
Notifications
You must be signed in to change notification settings - Fork 0
/
apt-check-gigantt
195 lines (166 loc) · 6.56 KB
/
apt-check-gigantt
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
#!/usr/bin/python
#nice apt-get -s -o Debug::NoLocking=true upgrade | grep ^Inst
import apt_pkg
import os
import sys
from optparse import OptionParser
import gettext
import subprocess
SYNAPTIC_PINFILE = "/var/lib/synaptic/preferences"
DISTRO = subprocess.Popen(["lsb_release","-c","-s"],
stdout=subprocess.PIPE).communicate()[0].strip()
class OpNullProgress(object):
def update(self, percent):
pass
def done(self):
pass
def _(msg):
return gettext.dgettext("update-notifier", msg)
def _handleException(type, value, tb):
sys.stderr.write("E: "+ _("Unknown Error: '%s' (%s)") % (type,value))
sys.exit(-1)
def clean(cache,depcache):
" unmark (clean) all changes from the given depcache "
# mvo: looping is too inefficient with the new auto-mark code
#for pkg in cache.Packages:
# depcache.MarkKeep(pkg)
depcache.Init()
def saveDistUpgrade(cache,depcache):
""" this functions mimics a upgrade but will never remove anything """
depcache.Upgrade(True)
if depcache.DelCount > 0:
clean(cache,depcache)
depcache.Upgrade()
def isSecurityUpgrade(ver):
" check if the given version is a security update (or masks one) "
security_pocket = "%s-security" % DISTRO
for (file, index) in ver.FileList:
if (file.Archive == security_pocket and file.Origin == "Ubuntu"):
return True
return False
def write_package_names(outstream, cache, depcache):
" write out package names that change to outstream "
pkgs = filter(lambda pkg:
depcache.MarkedInstall(pkg) or depcache.MarkedUpgrade(pkg),
cache.Packages)
outstream.write("\n".join(map(lambda p: p.Name, pkgs)))
def write_human_readable_summary(outstream, upgrades, security_updates):
" write out human summary summary to outstream "
outstream.write(gettext.dngettext("update-notifier",
"%i package can be updated.",
"%i packages can be updated.",
upgrades) % upgrades)
outstream.write("\n")
outstream.write(gettext.dngettext("update-notifier",
"%i update is a security update.",
"%i updates are security updates.",
security_updates) % security_updates)
outstream.write("\n")
def init():
" init the system, be nice "
# FIXME: do a ionice here too?
os.nice(19)
apt_pkg.init()
# force apt to build its caches in memory for now to make sure
# that there is no race when the pkgcache file gets re-generated
apt_pkg.Config.Set("Dir::Cache::pkgcache","")
def run(options=None):
# we are run in "are security updates installed automatically?"
# question mode
if options.security_updates_unattended:
res = apt_pkg.Config.FindI("APT::Periodic::Unattended-Upgrade", 0)
#print res
sys.exit(res)
# get caches
try:
cache = apt_pkg.GetCache(OpNullProgress())
except SystemError, e:
sys.stderr.write("E: "+ _("Error: Opening the cache (%s)") % e)
sys.exit(-1)
depcache = apt_pkg.GetDepCache(cache)
# read the pin files
depcache.ReadPinFile()
# read the synaptic pins too
if os.path.exists(SYNAPTIC_PINFILE):
depcache.ReadPinFile(SYNAPTIC_PINFILE)
# init the depcache
depcache.Init()
if depcache.BrokenCount > 0:
sys.stderr.write("E: "+ _("Error: BrokenCount > 0"))
sys.exit(-1)
# do the upgrade (not dist-upgrade!)
try:
saveDistUpgrade(cache,depcache)
except SystemError, e:
sys.stderr.write("E: "+ _("Error: Marking the upgrade (%s)") % e)
sys.exit(-1)
# analyze the ugprade
upgrades = 0
security_updates = 0
for pkg in cache.Packages:
# skip packages that are not marked upgraded/installed
if not (depcache.MarkedInstall(pkg) or depcache.MarkedUpgrade(pkg)):
continue
# check if this is really a upgrade or a false positive
# (workaround for ubuntu #7907)
inst_ver = pkg.CurrentVer
cand_ver = depcache.GetCandidateVer(pkg)
if cand_ver == inst_ver:
continue
# check for security upgrades
upgrades = upgrades + 1
if isSecurityUpgrade(cand_ver):
security_updates += 1
sys.stderr.write("Security: %s\n" % pkg.Name)
continue
# now check for security updates that are masked by a
# canidate version from another repo (-proposed or -updates)
for ver in pkg.VersionList:
if (inst_ver and apt_pkg.VersionCompare(ver.VerStr, inst_ver.VerStr) <= 0):
#print "skipping '%s' " % ver.VerStr
continue
if isSecurityUpgrade(ver):
security_updates += 1
sys.stderr.write("Security: %s\n" % pkg.Name)
break
# print the number of upgrades
if options and options.show_package_names:
write_package_names(sys.stderr, cache, depcache)
elif options and options.readable_output:
write_human_readable_summary(sys.stdout, upgrades, security_updates)
else:
# print the number of regular upgrades and the number of
# security upgrades
sys.stderr.write("%s;%s\n" % (upgrades,security_updates))
# return the number of upgrades (if its used as a module)
return(upgrades,security_updates)
if __name__ == "__main__":
# setup a exception handler to make sure that uncaught stuff goes
# to the notifier
sys.excepthook = _handleException
# gettext
APP="update-notifier"
DIR="/usr/share/locale"
gettext.bindtextdomain(APP, DIR)
gettext.textdomain(APP)
# check arguments
parser = OptionParser()
parser.add_option("-p",
"--package-names",
action="store_true",
dest="show_package_names",
help=_("Show the packages that are going to be installed/upgraded"))
parser.add_option("",
"--human-readable",
action="store_true",
dest="readable_output",
help=_("Show human readable output on stdout"))
parser.add_option("",
"--security-updates-unattended",
action="store_true",
help=_("Return the time in days when security updates "
"are installed unattended (0 means disabled)"))
(options, args) = parser.parse_args()
# run it
init()
run(options)