27038e67fed45d773ba0d344803023f1b49290f5
[enigma2.git] / lib / python / Plugins / SystemPlugins / NFIFlash / downloader.py
1 # -*- coding: utf-8 -*-
2 from Plugins.SystemPlugins.Hotplug.plugin import hotplugNotifier
3 from Screens.Screen import Screen
4 from Screens.MessageBox import MessageBox
5 from Screens.ChoiceBox import ChoiceBox
6 from Screens.HelpMenu import HelpableScreen
7 from Screens.TaskView import JobView
8 from Components.About import about
9 from Components.ActionMap import ActionMap
10 from Components.Sources.StaticText import StaticText
11 from Components.Sources.List import List
12 from Components.Label import Label
13 from Components.FileList import FileList
14 from Components.MenuList import MenuList
15 from Components.MultiContent import MultiContentEntryText
16 from Components.ScrollLabel import ScrollLabel
17 from Components.Harddisk import harddiskmanager
18 from Components.Task import Task, Job, job_manager, Condition
19 from Tools.Directories import fileExists, isMount
20 from Tools.HardwareInfo import HardwareInfo
21 from Tools.Downloader import downloadWithProgress
22 from enigma import eConsoleAppContainer, gFont, RT_HALIGN_LEFT, RT_HALIGN_CENTER, RT_VALIGN_CENTER, RT_WRAP, eTimer
23 from os import system, path, access, stat, remove, W_OK, R_OK
24 from twisted.web import client
25 from twisted.internet import reactor, defer
26 from twisted.python import failure
27 import re
28
29 class ImageDownloadJob(Job):
30         def __init__(self, url, filename, device=None, mountpoint="/"):
31                 Job.__init__(self, _("Download .NFI-Files for USB-Flasher"))
32                 if device:
33                         if isMount(mountpoint):
34                                 UmountTask(self, mountpoint)
35                         MountTask(self, device, mountpoint)
36                 ImageDownloadTask(self, url, mountpoint+filename)
37                 ImageDownloadTask(self, url[:-4]+".nfo", mountpoint+filename[:-4]+".nfo")
38                 #if device:
39                         #UmountTask(self, mountpoint)
40
41         def retry(self):
42                 self.tasks[0].args += self.tasks[0].retryargs
43                 Job.retry(self)
44
45 class MountTask(Task):
46         def __init__(self, job, device, mountpoint):
47                 Task.__init__(self, job, ("mount"))
48                 self.setTool("mount")
49                 options = "rw,sync"
50                 self.mountpoint = mountpoint
51                 self.args += [ device, mountpoint, "-o"+options ]
52                 self.weighting = 1
53
54         def processOutput(self, data):
55                 print "[MountTask] output:", data
56
57 class UmountTask(Task):
58         def __init__(self, job, mountpoint):
59                 Task.__init__(self, job, ("mount"))
60                 self.setTool("umount")
61                 self.args += [mountpoint]
62                 self.weighting = 1
63
64 class DownloaderPostcondition(Condition):
65         def check(self, task):
66                 return task.returncode == 0
67
68         def getErrorMessage(self, task):
69                 return self.error_message
70                 
71 class ImageDownloadTask(Task):
72         def __init__(self, job, url, path):
73                 Task.__init__(self, job, _("Downloading"))
74                 self.postconditions.append(DownloaderPostcondition())
75                 self.job = job
76                 self.url = url
77                 self.path = path
78                 self.error_message = ""
79                 self.last_recvbytes = 0
80                 self.error_message = None
81                 self.download = None
82                 self.aborted = False
83
84         def run(self, callback):
85                 self.callback = callback
86                 self.download = downloadWithProgress(self.url,self.path)
87                 self.download.addProgress(self.download_progress)
88                 self.download.start().addCallback(self.download_finished).addErrback(self.download_failed)
89                 print "[ImageDownloadTask] downloading", self.url, "to", self.path
90
91         def abort(self):
92                 print "[ImageDownloadTask] aborting", self.url
93                 if self.download:
94                         self.download.stop()
95                 self.aborted = True
96
97         def download_progress(self, recvbytes, totalbytes):
98                 #print "[update_progress] recvbytes=%d, totalbytes=%d" % (recvbytes, totalbytes)
99                 if ( recvbytes - self.last_recvbytes  ) > 10000: # anti-flicker
100                         self.progress = int(100*(float(recvbytes)/float(totalbytes)))
101                         self.name = _("Downloading") + ' ' + "%d of %d kBytes" % (recvbytes/1024, totalbytes/1024)
102                         self.last_recvbytes = recvbytes
103
104         def download_failed(self, failure_instance=None, error_message=""):
105                 self.error_message = error_message
106                 if error_message == "" and failure_instance is not None:
107                         self.error_message = failure_instance.getErrorMessage()
108                 Task.processFinished(self, 1)
109
110         def download_finished(self, string=""):
111                 if self.aborted:
112                         self.finish(aborted = True)
113                 else:
114                         Task.processFinished(self, 0)
115
116 class StickWizardJob(Job):
117         def __init__(self, path):
118                 Job.__init__(self, _("USB stick wizard"))
119                 self.path = path
120                 self.device = path
121                 while self.device[-1:] == "/" or self.device[-1:].isdigit():
122                         self.device = self.device[:-1]
123                                 
124                 box = HardwareInfo().get_device_name()
125                 url = "http://www.dreamboxupdate.com/download/opendreambox/dreambox-nfiflasher-%s.tar.bz2" % box
126                 self.downloadfilename = "/tmp/dreambox-nfiflasher-%s.tar.bz2" % box
127                 self.imagefilename = "/tmp/nfiflash_%s.img" % box
128                 #UmountTask(self, device)
129                 PartitionTask(self)
130                 ImageDownloadTask(self, url, self.downloadfilename)
131                 UnpackTask(self)
132                 CopyTask(self)
133
134 class PartitionTaskPostcondition(Condition):
135         def check(self, task):
136                 return task.returncode == 0
137
138         def getErrorMessage(self, task):
139                 return {
140                         task.ERROR_BLKRRPART: ("Device or resource busy"),
141                         task.ERROR_UNKNOWN: (task.errormsg)
142                 }[task.error]
143                 
144 class PartitionTask(Task):
145         ERROR_UNKNOWN, ERROR_BLKRRPART = range(2)
146         def __init__(self, job):
147                 Task.__init__(self, job, ("partitioning"))
148                 self.postconditions.append(PartitionTaskPostcondition())
149                 self.job = job          
150                 self.setTool("sfdisk")
151                 self.args += [self.job.device]
152                 self.weighting = 10
153                 self.initial_input = "0 - 0x6 *\n;\n;\n;\ny"
154                 self.errormsg = ""
155         
156         def run(self, callback):
157                 Task.run(self, callback)
158         
159         def processOutput(self, data):
160                 print "[PartitionTask] output:", data
161                 if data.startswith("BLKRRPART:"):
162                         self.error = self.ERROR_BLKRRPART
163                 else:
164                         self.error = self.ERROR_UNKNOWN
165                         self.errormsg = data
166
167 class UnpackTask(Task):
168         def __init__(self, job):
169                 Task.__init__(self, job, ("Unpacking USB flasher image..."))
170                 self.job = job
171                 self.setTool("tar")
172                 self.args += ["-xjvf", self.job.downloadfilename]
173                 self.weighting = 80
174                 self.end = 80
175                 self.delayTimer = eTimer()
176                 self.delayTimer.callback.append(self.progress_increment)
177         
178         def run(self, callback):
179                 Task.run(self, callback)
180                 self.delayTimer.start(950, False)
181                 
182         def progress_increment(self):
183                 self.progress += 1
184
185         def processOutput(self, data):
186                 print "[UnpackTask] output: \'%s\'" % data
187                 self.job.imagefilename = data
188         
189         def afterRun(self):
190                 self.delayTimer.callback.remove(self.progress_increment)
191
192 class CopyTask(Task):
193         def __init__(self, job):
194                 Task.__init__(self, job, ("Copying USB flasher boot image to stick..."))
195                 self.job = job
196                 self.setTool("dd")
197                 self.args += ["if=%s" % self.job.imagefilename, "of=%s1" % self.job.device]
198                 self.weighting = 20
199                 self.end = 20
200                 self.delayTimer = eTimer()
201                 self.delayTimer.callback.append(self.progress_increment)
202
203         def run(self, callback):
204                 Task.run(self, callback)
205                 self.delayTimer.start(100, False)
206                 
207         def progress_increment(self):
208                 self.progress += 1
209
210         def processOutput(self, data):
211                 print "[CopyTask] output:", data
212
213         def afterRun(self):
214                 self.delayTimer.callback.remove(self.progress_increment)
215
216 class NFOViewer(Screen):
217         skin = """
218                 <screen name="NFOViewer" position="center,center" size="610,410" title="Changelog viewer" >
219                         <widget name="changelog" position="10,10" size="590,380" font="Regular;16" />
220                 </screen>"""
221
222         def __init__(self, session, nfo):
223                 Screen.__init__(self, session)
224                 self["changelog"] = ScrollLabel(nfo)
225
226                 self["ViewerActions"] = ActionMap(["SetupActions", "ColorActions", "DirectionActions"],
227                         {
228                                 "green": self.exit,
229                                 "red": self.exit,
230                                 "ok": self.exit,
231                                 "cancel": self.exit,
232                                 "down": self.pageDown,
233                                 "up": self.pageUp
234                         })
235         def pageUp(self):
236                 self["changelog"].pageUp()
237
238         def pageDown(self):
239                 self["changelog"].pageDown()
240
241         def exit(self):
242                 self.close(False)
243
244 class feedDownloader:
245         def __init__(self, feed_base, box, OE_vers):
246                 print "[feedDownloader::init] feed_base=%s, box=%s" % (feed_base, box)
247                 self.feed_base = feed_base
248                 self.OE_vers = OE_vers
249                 self.box = box
250         
251         def getList(self, callback, errback):
252                 self.urlbase = "%s/%s/%s/images/" % (self.feed_base, self.OE_vers, self.box)
253                 print "[getList]", self.urlbase
254                 self.callback = callback
255                 self.errback = errback
256                 client.getPage(self.urlbase).addCallback(self.feed_finished).addErrback(self.feed_failed)
257
258         def feed_failed(self, failure_instance):
259                 print "[feed_failed]", str(failure_instance)
260                 self.errback(failure_instance.getErrorMessage())
261
262         def feed_finished(self, feedhtml):
263                 print "[feed_finished]"
264                 fileresultmask = re.compile("<a class=[\'\"]nfi[\'\"] href=[\'\"](?P<url>.*?)[\'\"]>(?P<name>.*?.nfi)</a>", re.DOTALL)
265                 searchresults = fileresultmask.finditer(feedhtml)
266                 fileresultlist = []
267                 if searchresults:
268                         for x in searchresults:
269                                 url = x.group("url")
270                                 if url[0:7] != "http://":
271                                         url = self.urlbase + x.group("url")
272                                 name = x.group("name")
273                                 entry = (name, url)
274                                 fileresultlist.append(entry)
275                 self.callback(fileresultlist, self.OE_vers)
276
277 class DeviceBrowser(Screen, HelpableScreen):
278         skin = """
279                 <screen name="DeviceBrowser" position="center,center" size="520,430" title="Please select target medium" >
280                         <ePixmap pixmap="skin_default/buttons/red.png" position="0,0" size="140,40" alphatest="on" />
281                         <ePixmap pixmap="skin_default/buttons/green.png" position="140,0" size="140,40" alphatest="on" />
282                         <widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#9f1313" transparent="1" />
283                         <widget source="key_green" render="Label" position="140,0" zPosition="1" size="140,40" font="Regular;20" halign="center" valign="center" backgroundColor="#1f771f" transparent="1" />
284                         <widget source="message" render="Label" position="5,50" size="510,150" font="Regular;16" />
285                         <widget name="filelist" position="5,210" size="510,220" scrollbarMode="showOnDemand" />
286                 </screen>"""
287
288         def __init__(self, session, startdir, message="", showDirectories = True, showFiles = True, showMountpoints = True, matchingPattern = "", useServiceRef = False, inhibitDirs = False, inhibitMounts = False, isTop = False, enableWrapAround = False, additionalExtensions = None):
289                 Screen.__init__(self, session)
290
291                 HelpableScreen.__init__(self)
292
293                 self["key_red"] = StaticText(_("Cancel"))
294                 self["key_green"] = StaticText()
295                 self["message"] = StaticText(message)
296
297                 self.filelist = FileList(startdir, showDirectories = showDirectories, showFiles = showFiles, showMountpoints = showMountpoints, matchingPattern = matchingPattern, useServiceRef = useServiceRef, inhibitDirs = inhibitDirs, inhibitMounts = inhibitMounts, isTop = isTop, enableWrapAround = enableWrapAround, additionalExtensions = additionalExtensions)
298                 self["filelist"] = self.filelist
299
300                 self["FilelistActions"] = ActionMap(["SetupActions", "ColorActions"],
301                         {
302                                 "green": self.use,
303                                 "red": self.exit,
304                                 "ok": self.ok,
305                                 "cancel": self.exit
306                         })
307                 
308                 hotplugNotifier.append(self.hotplugCB)
309                 self.onShown.append(self.updateButton)
310                 self.onClose.append(self.removeHotplug)
311
312         def hotplugCB(self, dev, action):
313                 print "[hotplugCB]", dev, action
314                 self.updateButton()
315         
316         def updateButton(self):
317                 
318                 if self["filelist"].getFilename() or self["filelist"].getCurrentDirectory():
319                         self["key_green"].text = _("Use")
320                 else:
321                         self["key_green"].text = ""
322         
323         def removeHotplug(self):
324                 print "[removeHotplug]"
325                 hotplugNotifier.remove(self.hotplugCB)
326
327         def ok(self):
328                 if self.filelist.canDescent():
329                         if self["filelist"].showMountpoints == True and self["filelist"].showDirectories == False:
330                                 self.use()
331                         else:
332                                 self.filelist.descent()
333
334         def use(self):
335                 print "[use]", self["filelist"].getCurrentDirectory(), self["filelist"].getFilename()
336                 if self["filelist"].getCurrentDirectory() is not None:
337                         if self.filelist.canDescent() and self["filelist"].getFilename() and len(self["filelist"].getFilename()) > len(self["filelist"].getCurrentDirectory()):
338                                 self.filelist.descent()
339                         self.close(self["filelist"].getCurrentDirectory())
340                 elif self["filelist"].getFilename():
341                         self.close(self["filelist"].getFilename())
342
343         def exit(self):
344                 self.close(False)
345
346 (ALLIMAGES, RELEASE, EXPERIMENTAL, STICK_WIZARD, START) = range(5)
347
348 class NFIDownload(Screen):
349         skin = """
350         <screen name="NFIDownload" position="center,center" size="610,410" title="NFIDownload" >
351                 <ePixmap pixmap="skin_default/buttons/red.png" position="0,0" size="140,40" alphatest="on" />
352                 <ePixmap pixmap="skin_default/buttons/green.png" position="140,0" size="140,40" alphatest="on" />
353                 <ePixmap pixmap="skin_default/buttons/yellow.png" position="280,0" size="140,40" alphatest="on" />
354                 <ePixmap pixmap="skin_default/buttons/blue.png" position="420,0" size="140,40" alphatest="on" />
355                 <widget source="key_red" render="Label" position="0,0" zPosition="1" size="140,40" font="Regular;20" valign="center" halign="center" backgroundColor="#9f1313" transparent="1" />
356                 <widget source="key_green" render="Label" position="140,0" zPosition="1" size="140,40" font="Regular;20" valign="center" halign="center" backgroundColor="#1f771f" transparent="1" />
357                 <widget source="key_yellow" render="Label" position="280,0" zPosition="1" size="140,40" font="Regular;20" valign="center" halign="center" backgroundColor="#a08500" transparent="1" />
358                 <widget source="key_blue" render="Label" position="420,0" zPosition="1" size="140,40" font="Regular;20" valign="center" halign="center" backgroundColor="#18188b" transparent="1" />
359                 <ePixmap pixmap="skin_default/border_menu_350.png" position="5,50" zPosition="1" size="350,300" transparent="1" alphatest="on" />
360                 <widget source="menu" render="Listbox" position="15,60" size="330,290" scrollbarMode="showOnDemand">
361                         <convert type="TemplatedMultiContent">
362                                 {"templates": 
363                                         {"default": (25, [
364                                                 MultiContentEntryText(pos = (2, 2), size = (330, 24), flags = RT_HALIGN_LEFT, text = 1), # index 0 is the MenuText,
365                                         ], True, "showOnDemand")
366                                         },
367                                 "fonts": [gFont("Regular", 22)],
368                                 "itemHeight": 25
369                                 }
370                         </convert>
371                 </widget>
372                 <widget source="menu" render="Listbox" position="360,50" size="240,300" scrollbarMode="showNever" selectionDisabled="1">
373                         <convert type="TemplatedMultiContent">
374                                 {"templates":
375                                         {"default": (300, [
376                                                 MultiContentEntryText(pos = (2, 2), size = (240, 300), flags = RT_HALIGN_CENTER|RT_VALIGN_CENTER|RT_WRAP, text = 2), # index 2 is the Description,
377                                         ], False, "showNever")
378                                         },      
379                                 "fonts": [gFont("Regular", 22)],
380                                 "itemHeight": 300
381                                 }
382                         </convert>
383                 </widget>
384                 <widget source="status" render="Label" position="5,360" zPosition="10" size="600,50" halign="center" valign="center" font="Regular;22" transparent="1" shadowColor="black" shadowOffset="-1,-1" />
385         </screen>"""
386                 
387         def __init__(self, session, destdir=None):
388                 Screen.__init__(self, session)
389                 #self.skin_path = plugin_path
390                 #self.menu = args
391                 
392                 self.box = HardwareInfo().get_device_name()
393                 self.feed_base = "http://www.dreamboxupdate.com/opendreambox" #/1.5/%s/images/" % self.box      
394                 self.usbmountpoint = "/mnt/usb/"
395
396                 self.menulist = []
397
398                 self["menu"] = List(self.menulist)
399                 self["key_red"] = StaticText(_("Close"))
400                 self["key_green"] = StaticText()
401                 self["key_yellow"] = StaticText()
402                 self["key_blue"] = StaticText()
403
404                 self["status"] = StaticText(_("Please wait... Loading list..."))
405
406                 self["shortcuts"] = ActionMap(["OkCancelActions", "ColorActions", "ShortcutActions", "DirectionActions"],
407                 {
408                         "ok": self.keyOk,
409                         "green": self.keyOk,
410                         "red": self.keyRed,
411                         "blue": self.keyBlue,
412                         "up": self.keyUp,
413                         "upRepeated": self.keyUp,
414                         "downRepeated": self.keyDown,
415                         "down": self.keyDown,
416                         "cancel": self.close,
417                 }, -1)
418                 self.onShown.append(self.go)
419                 self.feedlists = [[],[],[]]
420                 self.branch = START
421                 self.container = eConsoleAppContainer()
422                 self.container.dataAvail.append(self.tool_avail)
423                 self.taskstring = ""
424                 self.image_idx = 0
425                 self.nfofilename = ""
426                 self.nfo = ""
427                 self.target_dir = None
428
429         def tool_avail(self, string):
430                 print "[tool_avail]" + string
431                 self.taskstring += string
432
433         def go(self):
434                 self.onShown.remove(self.go)
435                 self.umountCallback = self.getMD5
436                 self.umount()
437         
438         def getMD5(self):
439                 url = "http://www.dreamboxupdate.com/download/opendreambox/dreambox-nfiflasher-%s-md5sums" % self.box
440                 client.getPage(url).addCallback(self.md5sums_finished).addErrback(self.feed_failed)
441
442         def md5sums_finished(self, data):
443                 print "[md5sums_finished]", data
444                 self.stickimage_md5 = data
445                 self.checkUSBStick()
446
447         def keyRed(self):
448                 if self.branch == START:
449                         self.close()
450                 else:
451                         self.branch = START
452                         self["menu"].setList(self.menulist)
453                 #elif self.branch == ALLIMAGES or self.branch == STICK_WIZARD:
454
455         def keyBlue(self):
456                 if self.nfo != "":
457                         self.session.open(NFOViewer, self.nfo)
458
459         def keyOk(self):
460                 print "[keyOk]", self["menu"].getCurrent()
461                 current = self["menu"].getCurrent()
462                 if current:
463                         if self.branch == START:
464                                 currentEntry = current[0]
465                                 if currentEntry == RELEASE:
466                                         self.image_idx = 0
467                                         self.branch = RELEASE
468                                         self.askDestination()
469                                 elif currentEntry == EXPERIMENTAL:
470                                         self.image_idx = 0
471                                         self.branch = EXPERIMENTAL
472                                         self.askDestination()
473                                 elif currentEntry == ALLIMAGES:
474                                         self.branch = ALLIMAGES
475                                         self.listImages()
476                                 elif currentEntry == STICK_WIZARD:
477                                         self.askStartWizard()
478                         elif self.branch == ALLIMAGES:
479                                 self.image_idx = self["menu"].getIndex()
480                                 self.askDestination()
481                 self.updateButtons()
482
483         def keyUp(self):
484                 self["menu"].selectPrevious()
485                 self.updateButtons()
486
487         def keyDown(self):
488                 self["menu"].selectNext()
489                 self.updateButtons()
490                 
491         def updateButtons(self):
492                 current = self["menu"].getCurrent()
493                 if current:
494                         if self.branch == START:
495                                 self["key_red"].text = _("Close")
496                                 currentEntry = current[0]
497                                 if currentEntry in (RELEASE, EXPERIMENTAL):
498                                         self.nfo_download(currentEntry, 0)
499                                         self["key_green"].text = _("Download")
500                                 else:
501                                         self.nfofilename = ""
502                                         self.nfo = ""
503                                         self["key_blue"].text = ""
504                                         self["key_green"].text = _("continue")
505
506                         elif self.branch == ALLIMAGES:
507                                 self["key_red"].text = _("Back")
508                                 self["key_green"].text = _("Download")
509                                 self.nfo_download(ALLIMAGES, self["menu"].getIndex())
510
511         def listImages(self):
512                 print "[listImages]"
513                 imagelist = []
514                 mask = re.compile("%s/(?P<OE_vers>1\.\d)/%s/images/(?P<branch>.*?)-%s_(?P<version>.*?).nfi" % (self.feed_base, self.box, self.box), re.DOTALL)
515                 for name, url in self.feedlists[ALLIMAGES]:
516                         result = mask.match(url)
517                         if result:
518                                 if result.group("version").startswith("20"):
519                                         version = ( result.group("version")[:4]+'-'+result.group("version")[4:6]+'-'+result.group("version")[6:8] )
520                                 else:
521                                         version = result.group("version")
522                                 description = "\nOpendreambox %s\n%s image\n%s\n" % (result.group("OE_vers"), result.group("branch"), version)
523                                 imagelist.append((url, name, _("Download %s from Server" ) % description, None))
524                 self["menu"].setList(imagelist)
525         
526         def getUSBPartitions(self):
527                 allpartitions = [ (r.description, r.mountpoint) for r in harddiskmanager.getMountedPartitions(onlyhotplug = True)]
528                 print "[getUSBPartitions]", allpartitions
529                 usbpartition = []
530                 for x in allpartitions:
531                         print x, x[1] == '/', x[0].find("USB"), access(x[1], R_OK)
532                         if x[1] != '/' and x[0].find("USB") > -1:  # and access(x[1], R_OK) is True:
533                                 usbpartition.append(x)
534                 return usbpartition
535                                 
536         def askDestination(self):
537                 usbpartition = self.getUSBPartitions()
538                 if len(usbpartition) == 1:
539                         self.target_dir = usbpartition[0][1]
540                         self.ackDestinationDevice(device_description=usbpartition[0][0])
541                 else:
542                         self.openDeviceBrowser()
543         
544         def openDeviceBrowser(self):
545                 self.session.openWithCallback(self.DeviceBrowserClosed, DeviceBrowser, None, showDirectories=True, showMountpoints=True, inhibitMounts=["/autofs/sr0/"])
546
547         def DeviceBrowserClosed(self, path):
548                 print "[DeviceBrowserClosed]", str(path)
549                 self.target_dir = path
550                 if path:
551                         self.ackDestinationDevice()
552                 else:
553                         self.keyRed()
554         
555         def ackDestinationDevice(self, device_description=None):
556                 if device_description == None:
557                         dev = self.target_dir
558                 else:
559                         dev = device_description
560                 message = _("Do you want to download the image to %s ?") % (dev)
561                 choices = [(_("Yes"), self.ackedDestination), (_("List of Storage Devices"),self.openDeviceBrowser), (_("Cancel"),self.keyRed)]
562                 self.session.openWithCallback(self.ackDestination_query, ChoiceBox, title=message, list=choices)
563
564         def ackDestination_query(self, choice):
565                 print "[ackDestination_query]", choice
566                 if isinstance(choice, tuple):
567                         choice[1]()
568                 else:
569                         self.keyRed()
570
571         def ackedDestination(self):
572                 print "[ackedDestination]", self.branch, self.target_dir
573                 self.container.setCWD("/mnt")
574                 if self.target_dir[:8] == "/autofs/":
575                         self.target_dir = "/dev/" + self.target_dir[8:-1]
576
577                 if self.branch == STICK_WIZARD:
578                         job = StickWizardJob(self.target_dir)
579                         job.afterEvent = "close"
580                         job_manager.AddJob(job)
581                         job_manager.failed_jobs = []
582                         self.session.openWithCallback(self.StickWizardCB, JobView, job, afterEventChangeable = False)
583
584                 elif self.branch != STICK_WIZARD:
585                         url = self.feedlists[self.branch][self.image_idx][1]
586                         filename = self.feedlists[self.branch][self.image_idx][0]
587                         print "[getImage] start downloading %s to %s" % (url, filename)
588                         if self.target_dir.startswith("/dev/"):
589                                 job = ImageDownloadJob(url, filename, self.target_dir, self.usbmountpoint)
590                         else:
591                                 job = ImageDownloadJob(url, filename, None, self.target_dir)
592                         job.afterEvent = "close"
593                         job_manager.AddJob(job)
594                         job_manager.failed_jobs = []
595                         self.session.openWithCallback(self.ImageDownloadCB, JobView, job, afterEventChangeable = False)
596
597         def StickWizardCB(self, ret=None):
598                 print "[StickWizardCB]", ret
599 #               print job_manager.active_jobs, job_manager.failed_jobs, job_manager.job_classes, job_manager.in_background, job_manager.active_job
600                 if len(job_manager.failed_jobs) == 0:
601                         self.session.open(MessageBox, _("The USB stick was prepared to be bootable.\nNow you can download an NFI image file!"), type = MessageBox.TYPE_INFO)
602                         if len(self.feedlists[ALLIMAGES]) == 0:
603                                 self.getFeed()
604                         else:
605                                 self.setMenu()
606                 else:
607                         self.umountCallback = self.checkUSBStick
608                         self.umount()
609
610         def ImageDownloadCB(self, ret):
611                 print "[ImageDownloadCB]", ret
612 #               print job_manager.active_jobs, job_manager.failed_jobs, job_manager.job_classes, job_manager.in_background, job_manager.active_job
613                 if len(job_manager.failed_jobs) == 0:
614                         self.session.openWithCallback(self.askBackupCB, MessageBox, _("The wizard can backup your current settings. Do you want to do a backup now?"), MessageBox.TYPE_YESNO)
615                 else:
616                         self.umountCallback = self.keyRed
617                         self.umount()
618
619         def askBackupCB(self, ret):
620                 if ret:
621                         from Plugins.SystemPlugins.SoftwareManager.BackupRestore import BackupScreen
622
623                         class USBBackupScreen(BackupScreen):
624                                 def __init__(self, session, usbmountpoint):
625                                         BackupScreen.__init__(self, session, runBackup = True)
626                                         self.backuppath = usbmountpoint
627                                         self.fullbackupfilename = self.backuppath + "/" + self.backupfile
628
629                         self.session.openWithCallback(self.showHint, USBBackupScreen, self.usbmountpoint)
630                 else:
631                         self.showHint()
632
633         def showHint(self, ret=None):
634                 self.session.open(MessageBox, _("To update your Dreambox firmware, please follow these steps:\n1) Turn off your box with the rear power switch and plug in the bootable USB stick.\n2) Turn mains back on and hold the DOWN button on the front panel pressed for 10 seconds.\n3) Wait for bootup and follow instructions of the wizard."), type = MessageBox.TYPE_INFO)
635                 self.umountCallback = self.keyRed
636                 self.umount()
637
638         def getFeed(self):
639                 self.feedDownloader15 = feedDownloader(self.feed_base, self.box, OE_vers="1.5")
640                 self.feedDownloader16 = feedDownloader(self.feed_base, self.box, OE_vers="1.6")
641                 self.feedlists = [[],[],[]]
642                 self.feedDownloader15.getList(self.gotFeed, self.feed_failed)
643                 self.feedDownloader16.getList(self.gotFeed, self.feed_failed)
644                 
645         def feed_failed(self, message=""):
646                 self["status"].text = _("Could not connect to Dreambox .NFI Image Feed Server:") + "\n" + str(message) + "\n" + _("Please check your network settings!")
647
648         def gotFeed(self, feedlist, OE_vers):
649                 print "[gotFeed]", OE_vers
650                 releaselist = []
651                 experimentallist = []
652                 
653                 for name, url in feedlist:
654                         if name.find("release") > -1:
655                                 releaselist.append((name, url))
656                         if name.find("experimental") > -1:
657                                 experimentallist.append((name, url))
658                         self.feedlists[ALLIMAGES].append((name, url))
659                 
660                 if OE_vers == "1.6":
661                         self.feedlists[RELEASE] = releaselist + self.feedlists[RELEASE]
662                         self.feedlists[EXPERIMENTAL] = experimentallist + self.feedlists[RELEASE]
663                 elif OE_vers == "1.5":
664                         self.feedlists[RELEASE] = self.feedlists[RELEASE] + releaselist
665                         self.feedlists[EXPERIMENTAL] = self.feedlists[EXPERIMENTAL] + experimentallist
666
667                 self.setMenu()
668
669         def checkUSBStick(self):
670                 self.target_dir = None
671                 allpartitions = [ (r.description, r.mountpoint) for r in harddiskmanager.getMountedPartitions(onlyhotplug = True)]
672                 print "[checkUSBStick] found partitions:", allpartitions
673                 usbpartition = []
674                 for x in allpartitions:
675                         print x, x[1] == '/', x[0].find("USB"), access(x[1], R_OK)
676                         if x[1] != '/' and x[0].find("USB") > -1:  # and access(x[1], R_OK) is True:
677                                 usbpartition.append(x)
678
679                 print usbpartition
680                 if len(usbpartition) == 1:
681                         self.target_dir = usbpartition[0][1]
682                         self.md5_passback = self.getFeed
683                         self.md5_failback = self.askStartWizard
684                         self.md5verify(self.stickimage_md5, self.target_dir)
685                 elif usbpartition == []:
686                         print "[NFIFlash] needs to create usb flasher stick first!"
687                         self.askStartWizard()
688                 else:
689                         self.askStartWizard()
690
691         def askStartWizard(self):
692                 self.branch = STICK_WIZARD
693                 message = _("""This plugin creates a USB stick which can be used to update the firmware of your Dreambox in case it has no network connection or only WLAN access.
694 First, you need to prepare a USB stick so that it is bootable.
695 In the next step, an NFI image file can be downloaded from the update server and saved on the USB stick.
696 If you already have a prepared bootable USB stick, please insert it now. Otherwise plug in a USB stick with a minimum size of 64 MB!""")
697                 self.session.openWithCallback(self.wizardDeviceBrowserClosed, DeviceBrowser, None, message, showDirectories=True, showMountpoints=True, inhibitMounts=["/","/autofs/sr0/","/autofs/sda1/","/media/hdd/","/media/net/",self.usbmountpoint,"/media/dvd/"])
698
699         def wizardDeviceBrowserClosed(self, path):
700                 print "[wizardDeviceBrowserClosed]", path
701                 self.target_dir = path
702                 if path:
703                         self.md5_passback = self.getFeed
704                         self.md5_failback = self.wizardQuery
705                         self.md5verify(self.stickimage_md5, self.target_dir)
706                 else:
707                         self.close()
708         
709         def wizardQuery(self):
710                 print "[wizardQuery]"
711                 description = self.target_dir
712                 for name, dev in self.getUSBPartitions():
713                         if dev == self.target_dir:
714                                 description = name
715                 message = _("You have chosen to create a new .NFI flasher bootable USB stick. This will repartition the USB stick and therefore all data on it will be erased.") + "\n"
716                 message += _("The following device was found:\n\n%s\n\nDo you want to write the USB flasher to this stick?") % description
717                 choices = [(_("Yes"), self.ackedDestination), (_("List of Storage Devices"),self.askStartWizard), (_("Cancel"),self.close)]
718                 self.session.openWithCallback(self.ackDestination_query, ChoiceBox, title=message, list=choices)
719                         
720         def setMenu(self):
721                 self.menulist = []
722                 try:
723                         latest_release = "Release %s (Opendreambox 1.5)" % self.feedlists[RELEASE][0][0][-9:-4]
724                         self.menulist.append((RELEASE, _("Get latest release image"), _("Download %s from Server" ) % latest_release, None))
725                 except IndexError:
726                         pass
727
728                 try:
729                         dat = self.feedlists[EXPERIMENTAL][0][0][-12:-4]
730                         latest_experimental = "Experimental %s-%s-%s (Opendreambox 1.6)" % (dat[:4], dat[4:6], dat[6:])
731                         self.menulist.append((EXPERIMENTAL, _("Get latest experimental image"), _("Download %s from Server") % latest_experimental, None))
732                 except IndexError:
733                         pass
734
735                 self.menulist.append((ALLIMAGES, _("Choose image to download"), _("Select desired image from feed list" ), None))
736                 self.menulist.append((STICK_WIZARD, _("USB stick wizard"), _("Prepare another USB stick for image flashing" ), None))
737                 self["menu"].setList(self.menulist)
738                 self["status"].text = _("Currently installed image") + ": %s" % (about.getImageVersionString())
739                 self.branch = START
740                 self.updateButtons()
741
742         def nfo_download(self, branch, idx):
743                 nfourl = (self.feedlists[branch][idx][1])[:-4]+".nfo"
744                 self.nfofilename = (self.feedlists[branch][idx][0])[:-4]+".nfo"
745                 print "[check_for_NFO]", nfourl
746                 client.getPage(nfourl).addCallback(self.nfo_finished).addErrback(self.nfo_failed)
747
748         def nfo_failed(self, failure_instance):
749                 print "[nfo_failed] " + str(failure_instance)
750                 self["key_blue"].text = ""
751                 self.nfofilename = ""
752                 self.nfo = ""
753
754         def nfo_finished(self,nfodata=""):
755                 print "[nfo_finished] " + str(nfodata)
756                 self["key_blue"].text = _("Changelog viewer")
757                 self.nfo = nfodata
758
759         def md5verify(self, md5, path):
760                 cmd = "md5sum -c -s"
761                 print "[verify_md5]", md5, path, cmd
762                 self.container.setCWD(path)
763                 self.container.appClosed.append(self.md5finished)
764                 self.container.execute(cmd)
765                 self.container.write(md5)
766                 self.container.dataSent.append(self.md5ready)
767
768         def md5ready(self, retval):
769                 self.container.sendEOF()
770
771         def md5finished(self, retval):
772                 print "[md5finished]", str(retval)
773                 self.container.appClosed.remove(self.md5finished)
774                 self.container.dataSent.remove(self.md5ready)
775                 if retval==0:
776                         print "check passed! calling", repr(self.md5_passback)
777                         self.md5_passback()
778                 else:
779                         print "check failed! calling", repr(self.md5_failback)
780                         self.md5_failback()
781
782         def umount(self):
783                 cmd = "umount " + self.usbmountpoint
784                 print "[umount]", cmd
785                 self.container.setCWD('/')
786                 self.container.appClosed.append(self.umountFinished)
787                 self.container.execute(cmd)
788
789         def umountFinished(self, retval):
790                 print "[umountFinished]", str(retval)
791                 self.container.appClosed.remove(self.umountFinished)
792                 self.umountCallback()
793
794 def main(session, **kwargs):
795         session.open(NFIDownload,"/home/root")
796
797 def filescan_open(list, session, **kwargs):
798         dev = "/dev/" + (list[0].path).rsplit('/',1)[0][7:]
799         print "mounting device " + dev + " to /mnt/usb..."
800         system("mount "+dev+" /mnt/usb/ -o rw,sync")
801         session.open(NFIDownload,"/mnt/usb/")
802
803 def filescan(**kwargs):
804         from Components.Scanner import Scanner, ScanPath
805         return \
806                 Scanner(mimetypes = ["application/x-dream-image"], 
807                         paths_to_scan = 
808                                 [
809                                         ScanPath(path = "", with_subdirs = False),
810                                 ], 
811                         name = "NFI", 
812                         description = (_("Download .NFI-Files for USB-Flasher")+"..."),
813                         openfnc = filescan_open, )