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
|
#!/usr/bin/python2.4
import pygtk
pygtk.require('2.0')
import gtk
import gtk.gdk
import gtk.glade
import apt
import apt_pkg
import sys
from UpdateManager.Common.SimpleGladeApp import SimpleGladeApp
from UpdateManager.GtkProgress import GtkOpProgress
from SoftwareProperties.aptsources import SourcesList, SourceEntry
from gettext import gettext as _
class DistUpgradeProgress(object):
pass
class DistUpgradeView(object):
" abstraction for the upgrade view "
def __init__(self):
pass
def getOpCacheProgress(self):
" return a OpProgress() subclass for the given graphic"
return apt.progress.OpProgress()
def getFetchProgress(self):
" return a fetch progress object "
return apt.progress.FetchProgress()
def getInstallProgress(self):
" return a install progress object "
return apt.progress.InstallProgress()
def updateStatus(self, msg):
""" update the current status of the distUpgrade based
on the current view
"""
pass
def askYesNoQuestion(self, summary, msg):
pass
def error(self, summary, msg):
pass
class GtkDistUpgradeView(DistUpgradeView,SimpleGladeApp):
" gtk frontend of the distUpgrade tool "
class GtkFetchProgressAdapter(apt.progress.FetchProgress):
# FIXME: we really should have some sort of "we are at step"
# xy in the gui
# FIXME2: we need to thing about mediaCheck here too
def __init__(self, parent):
# if this is set to false the download will cancel
self.status = parent.label_status
self.progress = parent.progressbar_cache
def start(self):
self.progress.show()
self.progress.set_fraction(0)
def stop(self):
self.progress.hide()
def pulse(self):
# FIXME: move the status_str and progress_str into python-apt
# (python-apt need i18n first for this)
apt.progress.FetchProgress.pulse(self)
if self.currentCPS > 0:
self.status.set_text(_("Download rate: %s/s - %s remaining" % (apt_pkg.SizeToStr(self.currentCPS), apt_pkg.TimeToStr(self.eta))))
else:
self.status.set_text(_("Download rate: unkown"))
self.progress.set_fraction(self.percent/100.0)
currentItem = self.currentItems + 1
if currentItem > self.totalItems:
currentItem = self.totalItems
self.progress.set_text(_("Downloading file %li of %li" % (currentItem, self.totalItems)))
while gtk.events_pending():
gtk.main_iteration()
return True
def __init__(self):
# FIXME: i18n must be somewhere relative do this dir
SimpleGladeApp.__init__(self, "DistUpgrade.glade",
None, domain="update-manager")
self._opCacheProgress = GtkOpProgress(self.progressbar_cache)
self._fetchProgress = self.GtkFetchProgressAdapter(self)
def getFetchProgress(self):
return self._fetchProgress
def getOpCacheProgress(self):
return self._opCacheProgress
def updateStatus(self, msg):
self.label_status.set_markup("%s" % msg)
def error(self, summary, msg):
dialog = gtk.MessageDialog(self.window_main, 0, gtk.MESSAGE_ERROR,
gtk.BUTTONS_OK,"")
msg="<big><b>%s</b></big>\n\n%s" % (summary,msg)
dialog.set_markup(msg)
dialog.vbox.set_spacing(6)
dialog.run()
dialog.destroy()
return False
def askYesNoQuestion(self, summary, msg):
msg = "<big><b>%s</b></big>\n\n%s" % (summary,msg)
dialog = gtk.MessageDialog(parent=self.window_main,
flags=gtk.DIALOG_MODAL,
type=gtk.MESSAGE_QUESTION,
buttons=gtk.BUTTONS_YES_NO)
dialog.set_markup(msg)
res = dialog.run()
dialog.destroy()
if res == gtk.RESPONSE_YES:
return True
return False
class DistUpgradeControler(object):
def __init__(self, distUpgradeView):
self._view = distUpgradeView
self._view.updateStatus(_("Reading cache"))
self._cache = apt.Cache(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, fromDist, to):
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 = [fromDist,
fromDist+"-security",
fromDist+"-updates",
fromDist+"-backports"
]
toDists = [to,
to+"-security",
to+"-updates",
to+"-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 == 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 doPreUpgrade(self):
pass
def doUpdate(self):
progress = self._view.getFetchProgress()
self._cache.update(progress)
def doDistUpgrade(self):
self._view.askYesNoQuestion(_("Do the upgrade"),
_("lala lala"))
def breezyUpgrade(self):
# sanity check (check for ubuntu-desktop, brokenCache etc)
self._view.updateStatus(_("Checking the system"))
if not self.sanityCheck():
sys.exit(1)
# update sources.list
self._view.updateStatus(_("Updating repository information"))
if not self.updateSourcesList(fromDist="hoary",to="breezy"):
sys.exit(1)
# then update the package index files
self.doUpdate()
# then open the cache (again)
self._view.updateStatus(_("Reading cache"))
self._cache = apt.Cache(self._view.getOpCacheProgress())
# do pre-upgrade stuff
self.doPreUpgrade()
# calc the dist-upgrade and see if the removals are ok/expected
# do the dist-upgrade
self.doDistUpgrade()
# do post-upgrade stuff
# done, ask for reboot
def run(self):
self.breezyUpgrade()
if __name__ == "__main__":
view = GtkDistUpgradeView()
app = DistUpgradeControler(view)
app.run()
|
