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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
|
# DistUpgradeControler.py
#
# Copyright (c) 2004,2005 Canonical
#
# Author: Michael Vogt <michael.vogt@ubuntu.com>
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; either version 2 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
# USA
import apt
import apt_pkg
import sys
import os
import subprocess
from UpdateManager.Common.SimpleGladeApp import SimpleGladeApp
from SoftwareProperties.aptsources import SourcesList, SourceEntry
from gettext import gettext as _
class MyCache(apt.Cache):
@property
def requiredDownload(self):
pm = apt_pkg.GetPackageManager(self._depcache)
fetcher = apt_pkg.GetAcquire()
pm.GetArchives(fetcher, self._list, self._records)
return fetcher.FetchNeeded
def downloadable(self, pkg, useCandidate=True):
" check if the given pkg can be downloaded "
if useCandidate:
ver = self._depcache.GetCandidateVer(pkg._pkg)
else:
ver = pkg._pkg.CurrentVer
if ver == None:
return False
return ver.Downloadable
class DistUpgradeControler(object):
def __init__(self, distUpgradeView):
self._view = distUpgradeView
self._view.updateStatus(_("Reading cache"))
self._cache = None
# some constants here
self.fromDist = "hoary"
self.toDist = "breezy"
self.origin = "Ubuntu"
def openCache(self):
self._cache = MyCache(self._view.getOpCacheProgress())
def sanityCheck(self):
if self._cache._depcache.BrokenCount > 0:
# FIXME: we more helpful here and offer to actually fix the
# system
self._view.error(_("Broken packages"),
_("Your system contains broken packages. "
"Please fix them first using synaptic or "
"apt-get before proceeding."))
return False
# FIXME: check for ubuntu-desktop, kubuntu-dekstop, edubuntu-desktop
return True
def updateSourcesList(self):
sources = SourcesList()
# this must map, i.e. second in "from" must be the second in "to"
# (but they can be different, so in theory we could exchange
# component names here)
fromDists = [self.fromDist,
self.fromDist+"-security",
self.fromDist+"-updates",
self.fromDist+"-backports"
]
toDists = [self.toDist,
self.toDist+"-security",
self.toDist+"-updates",
self.toDist+"-backports"
]
# list of valid mirrors that we can add
valid_mirrors = ["http://archive.ubuntu.com/ubuntu",
"http://security.ubuntu.com/ubuntu"]
# look over the stuff we have
foundToDist = False
for entry in sources:
# check if it's a mirror (or offical site)
for mirror in valid_mirrors:
if sources.is_mirror(mirror,entry.uri):
if entry.dist in toDists:
# so the sources.list is already set to the new
# distro
foundToDist = True
elif entry.dist in fromDists:
foundToDist = True
entry.dist = toDists[fromDists.index(entry.dist)]
else:
# disable all entries that are official but don't
# point to the "from" dist
entry.disabled = True
# it can only be one valid mirror, so we can break here
break
else:
# disable non-official entries that point to dist
if entry.dist == self.fromDist:
entry.disabled = True
if not foundToDist:
# FIXME: offer to write a new sources.list entry
return self._view.error(_("No valid entry found"),
_("While scaning your repository "
"information no valid entry for "
"the upgrade was found.\n"))
# write (well, backup first ;) !
backup_ext = ".distUpgrade"
sources.backup(backup_ext)
sources.save()
# re-check if the written sources are valid, if not revert and
# bail out
try:
sourceslist = apt_pkg.GetPkgSourceList()
sourceslist.ReadMainList()
except SystemError:
sources.restoreBackup(backup_ext)
self._view.error(_("Repository information invalid"),
_("Upgrading the repository information "
"resulted in a invalid file. Please "
"report this as a bug."))
return False
return True
def _getObsoletesPkgs(self):
" get all package names that are not downloadable "
obsolete_pkgs =set()
for pkg in self._cache:
if pkg.isInstalled:
if not self._cache.downloadable(pkg):
obsolete_pkgs.add(pkg.name)
return obsolete_pkgs
def _getForeignPkgs(self):
""" get all packages that are installed from a foreign repo
(and are actually downloadable)
"""
foreign_pkgs =set()
for pkg in self._cache:
if pkg.isInstalled and self._cache.downloadable(pkg):
# assume it is foreign and see if it is from the
# official archive
foreign=True
for origin in pkg.candidateOrigin:
if self.fromDist in origin.archive and \
origin.origin == self.origin:
foreign = False
if self.toDist in origin.archive and \
origin.origin == self.origin:
foreign = False
if foreign:
foreign_pkgs.add(pkg.name)
return foreign_pkgs
def doPreUpgrade(self):
# FIXME: check out what packages are downloadable etc to
# compare the list after the update again
self.obsolete_pkgs = self._getObsoletesPkgs()
self.foreign_pkgs = self._getForeignPkgs()
#print self.foreign_pkgs
#print self.obsolete_pkgs
def doUpdate(self):
self._cache._list.ReadMainList()
progress = self._view.getFetchProgress()
self._cache.update(progress)
def askDistUpgrade(self):
# FIXME: add "ubuntu-desktop" (or kubuntu-desktop, edubuntu-desktop)
# (if required)
self._cache.upgrade(True)
changes = self._cache.getChanges()
res = self._view.confirmChanges(changes,self._cache.requiredDownload)
return res
def doDistUpgrade(self):
fprogress = self._view.getFetchProgress()
iprogress = self._view.getInstallProgress()
self._cache.commit(fprogress,iprogress)
def doPostUpgrade(self):
# FIXME: check out what packages are cruft now
# use self.{foreign,obsolete}_pkgs here and see what changed
pass
def askForReboot(self):
return self._view.askYesNoQuestion(_("Reboot required"),
_("The upgrade is finished now. "
"A reboot is required to "
"now, do you want to do this "
"now?"))
# this is the core
def breezyUpgrade(self):
# sanity check (check for ubuntu-desktop, brokenCache etc)
self._view.updateStatus(_("Checking the system"))
self._view.setStep(1)
self.openCache()
if not self.sanityCheck():
sys.exit(1)
# do pre-upgrade stuff (calc list of obsolete pkgs etc)
self.doPreUpgrade()
# update sources.list
self._view.setStep(2)
self._view.updateStatus(_("Updating repository information"))
if not self.updateSourcesList():
sys.exit(1)
# then update the package index files
self.doUpdate()
# then open the cache (again)
self._view.updateStatus(_("Reading cache"))
self.openCache()
# calc the dist-upgrade and see if the removals are ok/expected
# do the dist-upgrade
self._view.setStep(3)
self._view.updateStatus(_("Performing the upgrade"))
if not self.askDistUpgrade():
sys.exit(1)
self.doDistUpgrade()
# do post-upgrade stuff
self._view.setStep(4)
self.doPostUpgrade()
# done, ask for reboot
if self.askForReboot():
subprocess.call(["reboot"])
def run(self):
self.breezyUpgrade()
|
