class OnlineUpdateCheckPoller:
def __init__(self):
self.timer = eTimer()
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def start(self):
if self.onlineupdate_check not in self.timer.callback:
self.timer.callback.append(self.onlineupdate_check)
if time() > 1262304000:
self.timer.startLongTimer(0)
else:
self.timer.startLongTimer(120)
def stop(self):
if self.version_check in self.timer.callback:
self.timer.callback.remove(self.onlineupdate_check)
self.timer.stop()
def onlineupdate_check(self):
if config.softwareupdate.check.value:
Components.Task.job_manager.AddJob(self.createCheckJob())
self.timer.startLongTimer(config.softwareupdate.checktimer.value * 3600)
def createCheckJob(self):
job = Components.Task.Job(_('OnlineVersionCheck'))
task = Components.Task.PythonTask(job, _('Checking for Updates...'))
task.work = self.JobStart
task.weighting = 1
return job
def JobStart(self):
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
print '[OnlineVersionCheck] %s Updates available' % self.total_packages
if self.total_packages:
from urllib import urlopen
import socket
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
config.softwareupdate.updatefound.setValue(True)
status = urlopen('http://feeds.italysat.eu/status').read()
if '404 Not Found' in status:
status = '1'
config.softwareupdate.updateisunstable.setValue(status)
socket.setdefaulttimeout(currentTimeoutDefault)
else:
config.softwareupdate.updatefound.setValue(False)
else:
config.softwareupdate.updatefound.setValue(False)
class OnlineUpdateCheckPoller:
def __init__(self):
# Init Timer
self.timer = eTimer()
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def start(self):
if self.onlineupdate_check not in self.timer.callback:
self.timer.callback.append(self.onlineupdate_check)
if time() > 1262304000: # Fri, 01 Jan 2010 00:00:00 GMT
self.timer.startLongTimer(30)
else:
self.timer.startLongTimer(10 * 60)
def stop(self):
if self.version_check in self.timer.callback:
self.timer.callback.remove(self.onlineupdate_check)
self.timer.stop()
def onlineupdate_check(self):
if config.softwareupdate.check.value:
Components.Task.job_manager.AddJob(self.createCheckJob())
self.timer.startLongTimer(int(config.softwareupdate.checktimer.value) * 3600)
def createCheckJob(self):
job = Components.Task.Job(_("OnlineVersionCheck"))
task = Components.Task.PythonTask(job, _("Checking for updates..."))
task.work = self.JobStart
task.weighting = 1
return job
def JobStart(self):
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
print ('[OnlineVersionCheck] %s updates available' % self.total_packages)
if self.total_packages:
config.softwareupdate.updatefound.setValue(True)
if not versioncheck.user_notified:
versioncheck.user_notified = True
Notifications.AddNotificationWithCallback(self.updateNotificationAnswer, SuspendableMessageBox, _("Online update available.\nInstall now?"))
else:
config.softwareupdate.updatefound.setValue(False)
else:
config.softwareupdate.updatefound.setValue(False)
def updateNotificationAnswer(self, answer):
if answer:
Notifications.AddNotification(UpdatePlugin)
class InstallWizardIpkgUpdater(Screen): def __init__(self, session, info, cmd, pkg = None): Screen.__init__(self, session) self["statusbar"] = StaticText(info) self.pkg = pkg self.state = 0 self.ipkg = IpkgComponent() self.ipkg.addCallback(self.ipkgCallback) self.ipkg.startCmd(cmd, pkg) def ipkgCallback(self, event, param): if event == IpkgComponent.EVENT_DONE: plugins.readPluginList(resolveFilename(SCOPE_PLUGINS)) self.close()
class InstallWizardIpkgUpdater(Screen): def __init__(self, session, index, info, cmd, pkg = None): Screen.__init__(self, session) self["statusbar"] = StaticText(info) self.pkg = pkg self.index = index self.state = 0 self.ipkg = IpkgComponent() self.ipkg.addCallback(self.ipkgCallback) self.ipkg.startCmd(cmd, pkg) def ipkgCallback(self, event, param): if event == IpkgComponent.EVENT_DONE: if self.index == InstallWizard.STATE_UPDATE: config.misc.installwizard.ipkgloaded.value = True self.close()
class InstallWizardIpkgUpdater(Screen):
def __init__(self, session, index, info, cmd, pkg = None):
Screen.__init__(self, session)
self["statusbar"] = StaticText(info)
self.pkg = pkg
self.index = index
self.state = 0
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
if self.index == InstallWizard.STATE_CHOISE_CHANNELLIST:
self.ipkg.startCmd(cmd, {'package': 'enigma2-plugin-settings-*'})
else:
self.ipkg.startCmd(cmd, pkg)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
if self.index == InstallWizard.STATE_UPDATE:
config.misc.installwizard.ipkgloaded.value = True
elif self.index == InstallWizard.STATE_CHOISE_CHANNELLIST:
if self.state == 0:
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, self.pkg)
self.state = 1
return
else:
config.misc.installwizard.channellistdownloaded.value = True
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
self.close()
class InstallWizardIpkgUpdater(Screen):
skin = """
<screen position="c-300,c-25" size="600,50" title=" ">
<widget source="statusbar" render="Label" position="10,5" zPosition="10" size="e-10,30" halign="center" valign="center" font="Regular;22" transparent="1" shadowColor="black" shadowOffset="-1,-1" />
</screen>"""
def __init__(self, session, index, info, cmd, pkg = None):
self.skin = InstallWizardIpkgUpdater.skin
Screen.__init__(self, session)
self['statusbar'] = StaticText(info)
self.pkg = pkg
self.index = index
self.state = 0
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
if self.index == InstallWizard.STATE_CHOISE_CHANNELLIST:
self.ipkg.startCmd(cmd, {'package': 'enigma2-plugin-settings-*'})
else:
self.ipkg.startCmd(cmd, pkg)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
if self.index == InstallWizard.STATE_UPDATE:
config.misc.installwizard.ipkgloaded.value = True
elif self.index == InstallWizard.STATE_CHOISE_CHANNELLIST:
if self.state == 0:
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, self.pkg)
self.state = 1
return
config.misc.installwizard.channellistdownloaded.value = True
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
self.close()
class Ipkg(Screen):
def __init__(self, session, cmdList = []):
Screen.__init__(self, session)
self.cmdList = cmdList
self.sliderPackages = {}
self.slider = Slider(0, len(cmdList))
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = Label(_("Preparing... Please wait"))
self["status"] = self.status
self.package = Label()
self["package"] = self.package
self.packages = 0
self.error = 0
self.processed_packages = []
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer_conn = self.activityTimer.timeout.connect(self.doActivityTimer)
#self.activityTimer.start(100, False)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.runningCmd = None
self.runNextCmd()
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
def runNextCmd(self):
if self.runningCmd is None:
self.runningCmd = 0
else:
self.runningCmd += 1
print len(self.cmdList), self.runningCmd
if len(self.cmdList) - 1 < self.runningCmd:
self.activityslider.setValue(0)
self.slider.setValue(len(self.cmdList))
self.package.setText("")
self.status.setText(_("Done - Installed, upgraded or removed %d packages with %d errors") % (self.packages, self.error))
return False
else:
cmd = self.cmdList[self.runningCmd]
self.slider.setValue(self.runningCmd)
self.ipkg.startCmd(cmd[0], args = cmd[1])
self.startActivityTimer()
def doActivityTimer(self):
if not self.ipkg.isRunning():
self.stopActivityTimer()
else:
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def startActivityTimer(self):
self.activityTimer.start(100, False)
def stopActivityTimer(self):
self.activityTimer.stop()
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
self.runNextCmd()
def exit(self):
if not self.ipkg.isRunning():
self.close()
class SoftwareTools(DreamInfoHandler):
lastDownloadDate = None
NetworkConnectionAvailable = None
list_updating = False
available_updates = 0
available_updatelist = []
available_packetlist = []
installed_packetlist = {}
upgradable_packages = {}
upgradeAvailable = False
def __init__(self):
aboutInfo = about.getImageVersionString()
if aboutInfo.startswith("dev-"):
self.ImageVersion = 'Experimental'
else:
self.ImageVersion = 'Stable'
self.language = language.getLanguage()[:2] # getLanguage returns e.g. "fi_FI" for "language_country"
DreamInfoHandler.__init__(self, self.statusCallback, blocking = False, neededTag = 'ALL_TAGS', neededFlag = self.ImageVersion)
self.directory = resolveFilename(SCOPE_METADIR)
self.hardware_info = HardwareInfo()
self.list = List([])
self.NotifierCallback = None
self.Console = Console()
self.UpdateConsole = Console()
self.UpgradeConsole = Console()
self.cmdList = []
self.unwanted_extensions = ('-dbg', '-dev', '-doc', '-staticdev')
self.reboot_required_packages = ('dreambox-dvb-modules', 'kernel-')
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def statusCallback(self, status, progress):
pass
def startSoftwareTools(self, callback = None):
if callback is not None:
self.NotifierCallback = callback
if eNetworkManager.getInstance().online():
self.NetworkConnectionAvailable = True
self.getUpdates()
else:
self.NetworkConnectionAvailable = False
self.getUpdates()
def getUpdates(self, callback = None):
if self.lastDownloadDate is None:
etpm = eTPM()
l2cert = etpm.getData(eTPM.DT_LEVEL2_CERT)
if l2cert is None:
return
l2key = validate_cert(l2cert, rootkey)
if l2key is None:
return
l3cert = etpm.getData(eTPM.DT_LEVEL3_CERT)
if l3cert is None:
return
l3key = validate_cert(l3cert, l2key)
if l3key is None:
return
rnd = read_random()
if rnd is None:
return
val = etpm.computeSignature(rnd)
result = decrypt_block(val, l3key)
if result[80:88] == rnd:
if self.NetworkConnectionAvailable == True:
self.lastDownloadDate = time()
if self.list_updating is False and callback is None:
self.list_updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is False and callback is not None:
self.list_updating = True
self.NotifierCallback = callback
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is True and callback is not None:
self.NotifierCallback = callback
else:
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
else:
self.NetworkConnectionAvailable = False
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
else:
if self.NetworkConnectionAvailable == True:
self.lastDownloadDate = time()
if self.list_updating is False and callback is None:
self.list_updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is False and callback is not None:
self.list_updating = True
self.NotifierCallback = callback
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is True and callback is not None:
self.NotifierCallback = callback
else:
if self.list_updating and callback is not None:
etpm = eTPM()
l2cert = etpm.getData(eTPM.DT_LEVEL2_CERT)
if l2cert is None:
return
l2key = validate_cert(l2cert, rootkey)
if l2key is None:
return
l3cert = etpm.getData(eTPM.DT_LEVEL3_CERT)
if l3cert is None:
return
l3key = validate_cert(l3cert, l2key)
if l3key is None:
return
rnd = read_random()
if rnd is None:
return
val = etpm.computeSignature(rnd)
result = decrypt_block(val, l3key)
if result[80:88] == rnd:
self.NotifierCallback = callback
self.startIpkgListAvailable()
else:
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.list_updating = False
if self.NotifierCallback is not None:
self.NotifierCallback(False)
elif event == IpkgComponent.EVENT_DONE:
if self.list_updating:
self.startIpkgListAvailable()
#print event, "-", param
pass
def startIpkgListAvailable(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = "opkg list | grep -e '^[a-z][a-z0-9+.-]'"
self.UpdateConsole.ePopen(cmd, self.IpkgListAvailableCB, callback)
def IpkgListAvailableCB(self, result, retval, extra_args = None):
(callback) = extra_args
if result:
if self.list_updating:
self.available_packetlist = []
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 1 and tokens[1].strip() or ""
descr = l > 2 and tokens[2].strip() or ""
self.available_packetlist.append([name, version, descr])
if callback is None:
self.startInstallMetaPackage()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def startInstallMetaPackage(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if self.NetworkConnectionAvailable == True:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = "opkg install enigma2-meta enigma2-plugins-meta enigma2-skins-meta"
self.UpdateConsole.ePopen(cmd, self.InstallMetaPackageCB, callback)
else:
self.InstallMetaPackageCB(True)
def InstallMetaPackageCB(self, result, retval = None, extra_args = None):
(callback) = extra_args
if result:
self.fillPackagesIndexList()
if callback is None:
self.startIpkgListInstalled()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def startIpkgListInstalled(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = "opkg list-installed"
self.UpdateConsole.ePopen(cmd, self.IpkgListInstalledCB, callback)
def IpkgListInstalledCB(self, result, retval, extra_args = None):
(callback) = extra_args
if result:
self.installed_packetlist = {}
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 1 and tokens[1].strip() or ""
self.installed_packetlist[name] = version
for package in self.packagesIndexlist[:]:
if not self.verifyPrerequisites(package[0]["prerequisites"]):
self.packagesIndexlist.remove(package)
for package in self.packagesIndexlist[:]:
attributes = package[0]["attributes"]
if attributes.has_key("packagetype"):
if attributes["packagetype"] == "internal":
self.packagesIndexlist.remove(package)
if callback is None:
self.listUpgradable()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def listUpgradable(self, callback = None):
self.list_updating = True
if not self.UpgradeConsole:
self.UpgradeConsole = Console()
cmd = "opkg list-upgradable"
self.UpgradeConsole.ePopen(cmd, self.listUpgradableCB, callback)
def listUpgradableCB(self, result, retval, extra_args = None):
(callback) = extra_args
self.upgradable_packages = {}
self.available_updates = 0
self.available_updatelist = []
if result:
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 2 and tokens[2].strip() or ""
self.upgradable_packages[name] = version
for package in self.packagesIndexlist[:]:
attributes = package[0]["attributes"]
packagename = attributes["packagename"]
for x in self.available_packetlist:
if x[0] == packagename:
if self.installed_packetlist.has_key(packagename):
if self.installed_packetlist[packagename] != x[1]:
self.available_updates +=1
self.available_updatelist.append([packagename])
self.list_updating = False
if self.upgradable_packages:
self.upgradeAvailable = True
if self.UpgradeConsole:
if len(self.UpgradeConsole.appContainers) == 0:
if callback is not None:
callback(True)
callback = None
elif self.NotifierCallback is not None:
self.NotifierCallback(True)
self.NotifierCallback = None
def cleanupSoftwareTools(self):
self.list_updating = False
if self.NotifierCallback is not None:
self.NotifierCallback = None
self.ipkg.stop()
if self.Console is not None:
if len(self.Console.appContainers):
for name in self.Console.appContainers.keys():
self.Console.kill(name)
if self.UpdateConsole is not None:
if len(self.UpdateConsole.appContainers):
for name in self.UpdateConsole.appContainers.keys():
self.UpdateConsole.kill(name)
if self.UpgradeConsole is not None:
if len(self.UpgradeConsole.appContainers):
for name in self.UpgradeConsole.appContainers.keys():
self.UpgradeConsole.kill(name)
def verifyPrerequisites(self, prerequisites):
if prerequisites.has_key("hardware"):
hardware_found = False
for hardware in prerequisites["hardware"]:
if hardware == self.hardware_info.device_name:
hardware_found = True
if not hardware_found:
return False
return True
class UpdatePlugin(Screen):
skin = '\n\t\t<screen name="UpdatePlugin" position="center,center" size="550,300">\n\t\t\t<widget name="activityslider" position="0,0" size="550,5" />\n\t\t\t<widget name="slider" position="0,150" size="550,30" />\n\t\t\t<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />\n\t\t\t<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />\n\t\t</screen>'
def __init__(self, session, *args):
Screen.__init__(self, session)
self.sliderPackages = {'dreambox-dvb-modules': 1,
'enigma2': 2,
'tuxbox-image-info': 3}
self.setTitle(_('Software update'))
self.slider = Slider(0, 4)
self['slider'] = self.slider
self.activityslider = Slider(0, 100)
self['activityslider'] = self.activityslider
self.status = StaticText(_('Please wait...'))
self['status'] = self.status
self.package = StaticText(_('Package list update'))
self['package'] = self.package
self.oktext = _('Press OK on your remote control to continue.')
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self['actions'] = ActionMap(['WizardActions'], {'ok': self.exit,
'back': self.exit}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, True)
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
message = ''
picon = None
default = True
try:
if getBoxType() in urlopen('http://openpli.org/status').read().split(','):
message = _('The current beta image might not be stable.\nFor more information see %s.') % 'www.openpli.org'
picon = MessageBox.TYPE_ERROR
default = False
except:
message = _('The status of the current beta image could not be checked because %s can not be reached.') % 'www.openpli.org'
picon = MessageBox.TYPE_ERROR
default = False
socket.setdefaulttimeout(currentTimeoutDefault)
if default:
self.startActualUpdate(True)
else:
message += '\n' + _('Do you want to update your receiver?')
self.session.openWithCallback(self.startActualUpdate, MessageBox, message, default=default, picon=picon)
def getLatestImageTimestamp(self):
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
latestImageTimestamp = ''
try:
latestImageTimestamp = re.findall('<dd>(.*?)</dd>', urlopen('http://openpli.org/download/' + getBoxType() + '/').read())[0][:16]
latestImageTimestamp = time.strftime(_('%d-%b-%Y %-H:%M'), time.strptime(latestImageTimestamp, '%Y/%m/%d %H:%M'))
except:
pass
socket.setdefaulttimeout(currentTimeoutDefault)
return latestImageTimestamp
def startActualUpdate(self, answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext('Update completed, %d package was installed.', 'Update completed, %d packages were installed.', self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_('Downloading'))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_('Upgrading') + ': %s/%s' % (self.packages, self.total_packages))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_('Installing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_('Removing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_('Configuring'))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ('N', 'Y'):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(self.modificationCallback, MessageBox, _('A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?') % param)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
latestImageTimestamp = self.getLatestImageTimestamp()
if latestImageTimestamp:
message = _('Do you want to update your receiver to %s?') % self.getLatestImageTimestamp() + '\n'
else:
message = _('Do you want to update your receiver?') + '\n'
message = message + '(' + ngettext('%s updated package available', '%s updated packages available', self.total_packages) % self.total_packages + ')'
choices = [(_('Update and reboot (recommended)'), 'cold'),
(_('Update and ask to reboot'), 'hot'),
(_('Update channel list only'), 'channels'),
(_('Show latest commits on sourceforge'), 'commits'),
(_('Cancel'), '')]
self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices)
else:
self.session.openWithCallback(self.close, MessageBox, _('No updates available'), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_('Could not find installed channel list.'))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _('Your receiver might be unusable now. Please consult the manual for further assistance before rebooting your receiver.')
if self.packages == 0:
error = _('No updates available. Please try again later.')
if self.updating:
error = _('Update failed. Your receiver does not have a working internet connection.')
self.status.setText(_('Error') + ' - ' + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == 'cold':
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
elif answer[1] == 'channels':
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args={'installed_only': True})
elif answer[1] == 'commits':
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), CommitInfo)
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and 'N' or 'Y')
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _('Update completed. Do you want to reboot your receiver?'))
else:
self.close()
elif not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class DreamInfoHandler:
STATUS_WORKING = 0
STATUS_DONE = 1
STATUS_ERROR = 2
STATUS_INIT = 4
def __init__(self, statusCallback, blocking = False, neededTag = None, neededFlag = None):
self.hardware_info = HardwareInfo()
self.directory = "/"
self.neededTag = neededTag
self.neededFlag = neededFlag
# caution: blocking should only be used, if further execution in enigma2 depends on the outcome of
# the installer!
self.blocking = blocking
self.currentlyInstallingMetaIndex = None
self.console = eConsoleAppContainer()
self.console.appClosed.append(self.installNext)
self.reloadFavourites = False
self.statusCallback = statusCallback
self.setStatus(self.STATUS_INIT)
self.packageslist = []
self.packagesIndexlist = []
self.packageDetails = []
def readInfo(self, directory, file):
print "Reading .info file", file
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageslist.append((entry,file))
except InfoHandlerParseError:
print "file", file, "ignored due to errors in the file"
#print handler.list
def readIndex(self, directory, file):
print "Reading .xml meta index file", directory, file
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packagesIndexlist.append((entry,file))
except InfoHandlerParseError:
print "file", file, "ignored due to errors in the file"
#print handler.list
def readDetails(self, directory, file):
self.packageDetails = []
print "Reading .xml meta details file", file
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageDetails.append((entry,file))
except InfoHandlerParseError:
print "file", file, "ignored due to errors in the file"
#print handler.list
# prerequisites = True: give only packages matching the prerequisites
def fillPackagesList(self, prerequisites = True):
self.packageslist = []
packages = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for directory in self.directory:
packages += crawlDirectory(directory, ".*\.info$")
for package in packages:
self.readInfo(package[0] + "/", package[0] + "/" + package[1])
if prerequisites:
for package in self.packageslist[:]:
if not self.prerequisiteMet(package[0]["prerequisites"]):
self.packageslist.remove(package)
return self.packageslist
# prerequisites = True: give only packages matching the prerequisites
def fillPackagesIndexList(self, prerequisites = True):
self.packagesIndexlist = []
indexfileList = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for indexfile in os.listdir(self.directory[0]):
if indexfile.startswith("index-"):
if indexfile.endswith(".xml"):
if indexfile[-7:-6] == "_":
continue
indexfileList.append(indexfile)
if len(indexfileList):
for file in indexfileList:
neededFile = self.directory[0] + "/" + file
if os.path.isfile(neededFile):
self.readIndex(self.directory[0] + "/" , neededFile)
if prerequisites:
for package in self.packagesIndexlist[:]:
if not self.prerequisiteMet(package[0]["prerequisites"]):
self.packagesIndexlist.remove(package)
return self.packagesIndexlist
# prerequisites = True: give only packages matching the prerequisites
def fillPackageDetails(self, details = None):
self.packageDetails = []
detailsfile = details
if not isinstance(self.directory, list):
self.directory = [self.directory]
self.readDetails(self.directory[0] + "/", self.directory[0] + "/" + detailsfile)
return self.packageDetails
def prerequisiteMet(self, prerequisites):
# TODO: we need to implement a hardware detection here...
print "prerequisites:", prerequisites
met = True
if self.neededTag is None:
if prerequisites.has_key("tag"):
return False
elif self.neededTag == 'ALL_TAGS':
return True
else:
if prerequisites.has_key("tag"):
if not self.neededTag in prerequisites["tag"]:
return False
else:
return False
if self.neededFlag is None:
if prerequisites.has_key("flag"):
return False
else:
if prerequisites.has_key("flag"):
if not self.neededFlag in prerequisites["flag"]:
return False
else:
return True # No flag found, assuming all flags valid
if prerequisites.has_key("satellite"):
for sat in prerequisites["satellite"]:
if int(sat) not in nimmanager.getConfiguredSats():
return False
if prerequisites.has_key("bcastsystem"):
has_system = False
for bcastsystem in prerequisites["bcastsystem"]:
if nimmanager.hasNimType(bcastsystem):
has_system = True
if not has_system:
return False
if prerequisites.has_key("hardware"):
hardware_found = False
for hardware in prerequisites["hardware"]:
if hardware == self.hardware_info.device_name:
hardware_found = True
if not hardware_found:
return False
return True
def installPackages(self, indexes):
print "installing packages", indexes
if len(indexes) == 0:
self.setStatus(self.STATUS_DONE)
return
self.installIndexes = indexes
print "+++++++++++++++++++++++bla"
self.currentlyInstallingMetaIndex = 0
self.installPackage(self.installIndexes[self.currentlyInstallingMetaIndex])
def installPackage(self, index):
print "self.packageslist:", self.packageslist
if len(self.packageslist) <= index:
print "no package with index", index, "found... installing nothing"
return
print "installing package with index", index, "and name", self.packageslist[index][0]["attributes"]["name"]
attributes = self.packageslist[index][0]["attributes"]
self.installingAttributes = attributes
self.attributeNames = ["skin", "config", "favourites", "package", "services"]
self.currentAttributeIndex = 0
self.currentIndex = -1
self.installNext()
def setStatus(self, status):
self.status = status
self.statusCallback(self.status, None)
def installNext(self, *args, **kwargs):
if self.reloadFavourites:
self.reloadFavourites = False
db = eDVBDB.getInstance().reloadBouquets()
self.currentIndex += 1
attributes = self.installingAttributes
#print "attributes:", attributes
if self.currentAttributeIndex >= len(self.attributeNames): # end of package reached
print "end of package reached"
if self.currentlyInstallingMetaIndex is None or self.currentlyInstallingMetaIndex >= len(self.installIndexes) - 1:
print "set status to DONE"
self.setStatus(self.STATUS_DONE)
return
else:
print "increment meta index to install next package"
self.currentlyInstallingMetaIndex += 1
self.currentAttributeIndex = 0
self.installPackage(self.installIndexes[self.currentlyInstallingMetaIndex])
return
self.setStatus(self.STATUS_WORKING)
print "currentAttributeIndex:", self.currentAttributeIndex
currentAttribute = self.attributeNames[self.currentAttributeIndex]
print "installing", currentAttribute, "with index", self.currentIndex
if attributes.has_key(currentAttribute):
if self.currentIndex >= len(attributes[currentAttribute]): # all jobs done for current attribute
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
else: # nothing to install here
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
if currentAttribute == "skin":
skin = attributes["skin"][self.currentIndex]
self.installSkin(skin["directory"], skin["name"])
elif currentAttribute == "config":
if self.currentIndex == 0:
from Components.config import configfile
configfile.save()
config = attributes["config"][self.currentIndex]
self.mergeConfig(config["directory"], config["name"])
elif currentAttribute == "favourites":
favourite = attributes["favourites"][self.currentIndex]
self.installFavourites(favourite["directory"], favourite["name"])
elif currentAttribute == "package":
package = attributes["package"][self.currentIndex]
self.installIPK(package["directory"], package["name"])
elif currentAttribute == "services":
service = attributes["services"][self.currentIndex]
self.mergeServices(service["directory"], service["name"])
def readfile(self, filename):
if not os.path.isfile(filename):
return []
fd = open(filename)
lines = fd.readlines()
fd.close()
return lines
def mergeConfig(self, directory, name, merge = True):
print "merging config:", directory, " - ", name
if os.path.isfile(directory + name):
config.loadFromFile(directory + name)
configfile.save()
self.installNext()
def installIPK(self, directory, name):
if self.blocking:
os.system("opkg install " + directory + name)
self.installNext()
else:
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': directory + name})
def ipkgCallback(self, event, param):
print "ipkgCallback"
if event == IpkgComponent.EVENT_DONE:
self.installNext()
elif event == IpkgComponent.EVENT_ERROR:
self.installNext()
def installSkin(self, directory, name):
print "installing skin:", directory, " - ", name
print "cp -a %s %s" % (directory, resolveFilename(SCOPE_SKIN))
if self.blocking:
copytree(directory, resolveFilename(SCOPE_SKIN))
self.installNext()
else:
if self.console.execute("cp -a %s %s" % (directory, resolveFilename(SCOPE_SKIN))):
print "execute failed"
self.installNext()
def mergeServices(self, directory, name, merge = False):
print "merging services:", directory, " - ", name
if os.path.isfile(directory + name):
db = eDVBDB.getInstance()
db.reloadServicelist()
db.loadServicelist(directory + name)
db.saveServicelist()
self.installNext()
def installFavourites(self, directory, name):
print "installing favourites:", directory, " - ", name
self.reloadFavourites = True
if self.blocking:
copyfile(directory + name, resolveFilename(SCOPE_CONFIG))
self.installNext()
else:
if self.console.execute("cp %s %s" % ((directory + name), resolveFilename(SCOPE_CONFIG))):
print "execute failed"
self.installNext()
class UpdatePlugin(Screen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, True)
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
from urllib import urlopen
import socket
import os
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
message = ""
picon = None
default = True
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
if getBoxType() in urlopen("http://openpli.org/status").read().split(','):
message = _("The current beta image might not be stable.\nFor more information see www.openpli.org.")
picon = MessageBox.TYPE_ERROR
default = False
except:
message = _("The status of the current beta image could not be checked because www.openpli.org can not be reached.")
picon = MessageBox.TYPE_ERROR
default = False
socket.setdefaulttimeout(currentTimeoutDefault)
if default:
self.startActualUpdate(True)
else:
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate, MessageBox, message, default = default, picon = picon)
def startActualUpdate(self,answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % (param)
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
message = _("Do you want to update your receiver?") + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
(_("Update channel list only"), "channels"),
(_("Cancel"), "")]
self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices)
else:
self.session.openWithCallback(self.close, MessageBox, _("No updates available"), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your receiver might be unusable now. Please consult the manual for further assistance before rebooting your receiver.")
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _("Update failed. Your receiver does not have a working internet connection.")
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args = {'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Update completed. Do you want to reboot your receiver?"))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop,retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class SoftwareTools(PackageInfoHandler):
lastDownloadDate = None
NetworkConnectionAvailable = None
list_updating = False
available_updates = 0
available_updatelist = []
available_packetlist = []
installed_packetlist = {}
def __init__(self):
aboutInfo = about.getImageVersionString()
if aboutInfo.startswith("dev-"):
self.ImageVersion = 'Experimental'
else:
self.ImageVersion = 'Stable'
self.language = language.getLanguage()[:2] # getLanguage returns e.g. "fi_FI" for "language_country"
PackageInfoHandler.__init__(self, self.statusCallback, blocking = False, neededTag = 'ALL_TAGS', neededFlag = self.ImageVersion)
self.directory = resolveFilename(SCOPE_METADIR)
self.list = List([])
self.NotifierCallback = None
self.Console = Console()
self.UpdateConsole = Console()
self.cmdList = []
self.unwanted_extensions = ('-dbg', '-dev', '-doc', '-staticdev', '-src')
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def statusCallback(self, status, progress):
pass
def startSoftwareTools(self, callback = None):
if callback is not None:
self.NotifierCallback = callback
iNetwork.checkNetworkState(self.checkNetworkCB)
def checkNetworkCB(self,data):
if data is not None:
if data <= 2:
self.NetworkConnectionAvailable = True
self.getUpdates()
else:
self.NetworkConnectionAvailable = False
self.getUpdates()
def getUpdates(self, callback = None):
if self.lastDownloadDate is None:
if self.NetworkConnectionAvailable == True:
self.lastDownloadDate = time()
if self.list_updating is False and callback is None:
self.list_updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is False and callback is not None:
self.list_updating = True
self.NotifierCallback = callback
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is True and callback is not None:
self.NotifierCallback = callback
else:
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
else:
if self.NetworkConnectionAvailable == True:
self.lastDownloadDate = time()
if self.list_updating is False and callback is None:
self.list_updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is False and callback is not None:
self.list_updating = True
self.NotifierCallback = callback
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is True and callback is not None:
self.NotifierCallback = callback
else:
if self.list_updating and callback is not None:
self.NotifierCallback = callback
self.startIpkgListAvailable()
else:
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.list_updating = False
if self.NotifierCallback is not None:
self.NotifierCallback(False)
elif event == IpkgComponent.EVENT_DONE:
if self.list_updating:
self.startIpkgListAvailable()
pass
def startIpkgListAvailable(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = self.ipkg.ipkg + " list"
self.UpdateConsole.ePopen(cmd, self.IpkgListAvailableCB, callback)
def IpkgListAvailableCB(self, result, retval, extra_args = None):
(callback) = extra_args
if result:
if self.list_updating:
self.available_packetlist = []
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 1 and tokens[1].strip() or ""
descr = l > 2 and tokens[2].strip() or ""
self.available_packetlist.append([name, version, descr])
if callback is None:
self.startInstallMetaPackage()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def startInstallMetaPackage(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if self.NetworkConnectionAvailable == True:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = self.ipkg.ipkg + " install enigma2-meta enigma2-plugins-meta enigma2-skins-meta"
self.UpdateConsole.ePopen(cmd, self.InstallMetaPackageCB, callback)
else:
self.InstallMetaPackageCB(True)
def InstallMetaPackageCB(self, result, retval = None, extra_args = None):
(callback) = extra_args
if result:
self.fillPackagesIndexList()
if callback is None:
self.startIpkgListInstalled()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def startIpkgListInstalled(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = self.ipkg.ipkg + " list_installed"
self.UpdateConsole.ePopen(cmd, self.IpkgListInstalledCB, callback)
def IpkgListInstalledCB(self, result, retval, extra_args = None):
(callback) = extra_args
if result:
self.installed_packetlist = {}
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 1 and tokens[1].strip() or ""
self.installed_packetlist[name] = version
for package in self.packagesIndexlist[:]:
if not self.verifyPrerequisites(package[0]["prerequisites"]):
self.packagesIndexlist.remove(package)
for package in self.packagesIndexlist[:]:
attributes = package[0]["attributes"]
if attributes.has_key("packagetype"):
if attributes["packagetype"] == "internal":
self.packagesIndexlist.remove(package)
if callback is None:
self.countUpdates()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def countUpdates(self, callback = None):
self.available_updates = 0
self.available_updatelist = []
for package in self.packagesIndexlist[:]:
attributes = package[0]["attributes"]
packagename = attributes["packagename"]
for x in self.available_packetlist:
if x[0] == packagename:
if self.installed_packetlist.has_key(packagename):
if self.installed_packetlist[packagename] != x[1]:
self.available_updates +=1
self.available_updatelist.append([packagename])
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(True)
callback = None
elif self.NotifierCallback is not None:
self.NotifierCallback(True)
self.NotifierCallback = None
def startIpkgUpdate(self, callback = None):
if not self.Console:
self.Console = Console()
cmd = self.ipkg.ipkg + " update"
self.Console.ePopen(cmd, self.IpkgUpdateCB, callback)
def IpkgUpdateCB(self, result, retval, extra_args = None):
(callback) = extra_args
if result:
if self.Console:
if len(self.Console.appContainers) == 0:
if callback is not None:
callback(True)
callback = None
def cleanupSoftwareTools(self):
self.list_updating = False
if self.NotifierCallback is not None:
self.NotifierCallback = None
self.ipkg.stop()
if self.Console is not None:
if len(self.Console.appContainers):
for name in self.Console.appContainers.keys():
self.Console.kill(name)
if self.UpdateConsole is not None:
if len(self.UpdateConsole.appContainers):
for name in self.UpdateConsole.appContainers.keys():
self.UpdateConsole.kill(name)
def verifyPrerequisites(self, prerequisites):
if prerequisites.has_key("hardware"):
hardware_found = False
for hardware in prerequisites["hardware"]:
if hardware == HardwareInfo().device_name:
hardware_found = True
if not hardware_found:
return False
return True
class UpdatePlugin(Screen):
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _('Software Update'))
self.sliderPackages = {'dreambox-dvb-modules': 1,
'enigma2': 2,
'tuxbox-image-info': 3}
self.setTitle(_('Software update'))
self.slider = Slider(0, 4)
self['slider'] = self.slider
self.activityslider = Slider(0, 100)
self['activityslider'] = self.activityslider
self.status = StaticText(_('Please wait...'))
self['status'] = self.status
self.package = StaticText(_('Package list update'))
self['package'] = self.package
self.oktext = _('Press OK on your remote control to continue.')
status_msgs = {'stable': _('Feeds status: Stable'),
'unstable': _('Feeds status: Unstable'),
'updating': _('Feeds status: Updating'),
'unknown': _('No connection')}
self['tl_off'] = Pixmap()
self['tl_red'] = Pixmap()
self['tl_yellow'] = Pixmap()
self['tl_green'] = Pixmap()
self.feedsStatus()
self['feedStatusMSG'] = Label(status_msgs[self.trafficLight])
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.checkNetworkState()
return
def feedsStatus(self):
from urllib import urlopen
import socket
self['tl_red'].hide()
self['tl_yellow'].hide()
self['tl_green'].hide()
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
try:
d = urlopen('http://openvix.co.uk/TrafficLightState.php')
self.trafficLight = d.read()
if self.trafficLight == 'unstable':
self['tl_off'].hide()
self['tl_red'].show()
elif self.trafficLight == 'updating':
self['tl_off'].hide()
self['tl_yellow'].show()
elif self.trafficLight == 'stable':
self['tl_off'].hide()
self['tl_green'].show()
else:
self.trafficLight = 'unknown'
self['tl_off'].show()
except:
self.trafficLight = 'unknown'
self['tl_off'].show()
socket.setdefaulttimeout(currentTimeoutDefault)
def checkNetworkState(self):
cmd1 = 'opkg update'
self.CheckConsole = Console()
self.CheckConsole.ePopen(cmd1, self.checkNetworkStateFinished)
def checkNetworkStateFinished(self, result, retval, extra_args = None):
if 'No space left on device' in result:
self.session.openWithCallback(self.close, MessageBox, _('Your %s %s have a FULL flash memory, please free memory or expand in USB') % (getMachineBrand(), getMachineName()), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif 'bad address' in result:
self.session.openWithCallback(self.close, MessageBox, _('Your %s %s is not connected to the internet, please check your network settings and try again.') % (getMachineBrand(), getMachineName()), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif ('wget returned 1' or 'wget returned 255' or '404 Not Found') in result:
self.session.openWithCallback(self.close, MessageBox, _('Sorry feeds are down for maintenance, please try again later. If this issue persists please check www.italysat.eu'), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif 'Collected errors' in result:
self.session.openWithCallback(self.close, MessageBox, _('A background update check is in progress, please wait a few minutes and try again.'), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
else:
self.startCheck()
def startCheck(self):
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.updating = False
self['actions'] = ActionMap(['WizardActions'], {'ok': self.exit,
'back': self.exit}, -1)
self.updating = True
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext('Update completed, %d package was installed.', 'Update completed, %d packages were installed.', self.packages) % self.packages)
def ipkgCallback(self, event, param):
global ocram
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_('Downloading'))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_('Upgrading') + ': %s/%s' % (self.packages, self.total_packages))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_('Installing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_('Removing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_('Configuring'))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ('N', 'Y'):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(self.modificationCallback, MessageBox, _('A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?') % param)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
from urllib import urlopen
import socket
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
status = urlopen('http://feeds.italysat.eu/status').read()
if '404 Not Found' in status:
status = '1'
config.softwareupdate.updateisunstable.setValue(status)
socket.setdefaulttimeout(currentTimeoutDefault)
self.total_packages = None
if config.softwareupdate.updateisunstable.value == '1' and config.softwareupdate.updatebeta.value:
self.total_packages = len(self.ipkg.getFetchedList())
message = _('The current update may be unstable') + '\n' + _('Are you sure you want to update your %s %s ?') % (getMachineBrand(), getMachineName()) + '\n(' + ngettext('%s updated package available', '%s updated packages available', self.total_packages) % self.total_packages + ')'
elif config.softwareupdate.updateisunstable.value == '0':
self.total_packages = len(self.ipkg.getFetchedList())
message = _('Do you want to update your %s %s ?') % (getMachineBrand(), getMachineName()) + '\n(' + ngettext('%s updated package available', '%s updated packages available', self.total_packages) % self.total_packages + ')'
if self.total_packages:
for package_tmp in self.ipkg.getFetchedList():
if package_tmp[0].startswith('enigma2-plugin-picons-tv-ocram'):
ocram = ocram + '[ocram-picons] ' + package_tmp[0].split('enigma2-plugin-picons-tv-ocram.')[1] + 'updated ' + package_tmp[2] + '\n'
elif package_tmp[0].startswith('enigma2-plugin-settings-ocram'):
ocram = ocram + '[ocram-settings] ' + package_tmp[0].split('enigma2-plugin-picons-tv-ocram.')[1] + 'updated ' + package_tmp[2] + '\n'
config.softwareupdate.updatefound.setValue(True)
choices = [(_('Upgrade and reboot system'), 'cold')]
if path.exists('/usr/lib/enigma2/python/ItalySat/ItalysatBackupManager.pyo'):
if not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_('Perform a settings backup,') + '\n\t' + _('making a backup before updating') + '\n\t' + _('is strongly advised.'), 'backup'))
if not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_('Perform a full image backup'), 'imagebackup'))
choices.append((_('Cancel'), ''))
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name='SoftwareUpdateChoices', var=self.trafficLight)
upgrademessage.setTitle(_('Software update'))
else:
upgrademessage = self.session.openWithCallback(self.close, MessageBox, _('Nothing to upgrade'), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
upgrademessage.setTitle(_('Software update'))
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_('Could not find installed channel list.'))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _('Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s.') % (getMachineBrand(),
getMachineName(),
getMachineBrand(),
getMachineName())
if self.packages == 0:
error = _('No updates available. Please try again later.')
if self.updating:
error = _('Update failed. Your %s %s does not have a working internet connection.') % (getMachineBrand(), getMachineName())
self.status.setText(_('Error') + ' - ' + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
return
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == 'menu':
if config.softwareupdate.updateisunstable.value == '1':
message = _('The current update may be unstable') + '\n' + _('Are you sure you want to update your %s %s ?') % (getMachineBrand(), getMachineName()) + '\n(%s ' % self.total_packages + _('Packages') + ')'
elif config.softwareupdate.updateisunstable.value == '0':
message = _('Do you want to update your %s %s ?') % (getMachineBrand(), getMachineName()) + '\n(%s ' % self.total_packages + _('Packages') + ')'
choices = [(_('Upgrade and reboot system'), 'cold')]
if not self.SettingsBackupDone and not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_('Perform a settings backup, making a backup before updating is strongly advised.'), 'backup'))
if not self.ImageBackupDone and not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_('Perform a full image backup'), 'imagebackup'))
choices.append((_('Cancel'), ''))
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name='SoftwareUpdateChoices', var=self.trafficLight)
upgrademessage.setTitle(_('Software update'))
elif answer[1] == 'changes':
self.session.openWithCallback(self.startActualUpgrade, SoftwareUpdateChanges)
elif answer[1] == 'backup':
self.doSettingsBackup()
elif answer[1] == 'imagebackup':
self.doImageBackup()
elif answer[1] == 'channels':
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args={'installed_only': True})
elif answer[1] == 'cold':
if config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value or config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
self.doAutoBackup()
else:
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
def modificationCallback(self, res):
self.ipkg.write(res and 'N' or 'Y')
def doSettingsBackup(self):
backup = None
from ItalySat.ItalysatBackupManager import BackupFiles
self.BackupFiles = BackupFiles(self.session, True)
Components.Task.job_manager.AddJob(self.BackupFiles.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('italysat', 'Backup Manager'):
break
self.showJobView(job)
return
def doImageBackup(self):
backup = None
from ItalySat.ItalysatImageManager import ImageBackup
self.ImageBackup = ImageBackup(self.session, True)
Components.Task.job_manager.AddJob(self.ImageBackup.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('italysat', 'Image Manager'):
break
self.showJobView(job)
return
def doAutoBackup(self, val = False):
self.autobackuprunning = True
if config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value and not self.SettingsBackupDone:
self.doSettingsBackup()
elif config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value and not self.ImageBackupDone:
self.doImageBackup()
else:
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
def showJobView(self, job):
if job.name == dgettext('italysat', 'Image Manager'):
self.ImageBackupDone = True
elif job.name == dgettext('italysat', 'Backup Manager'):
self.SettingsBackupDone = True
from Screens.TaskView import JobView
Components.Task.job_manager.in_background = False
if not self.autobackuprunning:
self.session.openWithCallback(self.startActualUpgrade(('menu', 'menu')), JobView, job, cancelable=False, backgroundable=False, afterEventChangeable=False, afterEvent='close')
else:
self.session.openWithCallback(self.doAutoBackup, JobView, job, cancelable=False, backgroundable=False, afterEventChangeable=False, afterEvent='close')
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _('Upgrade finished.') + ' ' + _('Do you want to reboot your %s %s') % (getMachineBrand(), getMachineName()))
else:
self.close()
elif not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
return
class UpdatePlugin(Screen, ProtectedScreen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
self.sliderPackages = {
"dreambox-dvb-modules": 1,
"enigma2": 2,
"tuxbox-image-info": 3
}
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, True)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and\
(not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and\
config.ParentalControl.config_sections.software_update.value
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
message = ""
picon = None
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
url = "https://openpli.org/status/"
try:
status = urlopen(url, timeout=5).read().split('!', 1)
except:
# OpenPli 5.0 uses python 2.7.11 and here we need to bypass the certificate check
from ssl import _create_unverified_context
status = urlopen(
url, timeout=5,
context=_create_unverified_context()).read().split('!', 1)
print status
if getBoxType() in status[0].split(','):
message = len(status) > 1 and status[1] or _(
"The current image might not be stable.\nFor more information see %s."
) % ("www.openpli.org")
# strip any HTML that may be in the message, but retain line breaks
import re
message = message.replace("<br />",
"\n\n").replace("<br>", "\n\n")
message = re.sub('<[^<]+?>', '',
re.sub('‑', '-', message))
picon = MessageBox.TYPE_ERROR
except:
message = _(
"The status of the current image could not be checked because %s can not be reached."
) % ("www.openpli.org")
picon = MessageBox.TYPE_ERROR
if message != "":
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate,
MessageBox,
message,
picon=picon)
else:
self.startActualUpdate(True)
def getLatestImageTimestamp(self):
def gettime(url):
try:
return str(
datetime.datetime.strptime(
urlopen("%s/Packages.gz" %
url).info()["Last-Modified"],
'%a, %d %b %Y %H:%M:%S %Z'))
except:
return ""
return sorted([
gettime(
open("/etc/opkg/%s" % file, "r").readlines()[0].split()[2])
for file in os.listdir("/etc/opkg")
if not file.startswith("3rd-party") and file not in ("arch.conf",
"opkg.conf")
],
reverse=True)[0]
def startActualUpdate(self, answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(
ngettext("Update completed, %d package was installed.",
"Update completed, %d packages were installed.",
self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if param in self.sliderPackages:
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(
_("Upgrading") + ": %s/%s" %
(self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in (
"N", "Y"):
self.ipkg.write(
True and
config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback, MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?"
) % (param))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
latestImageTimestamp = self.getLatestImageTimestamp()
if latestImageTimestamp:
message = _(
"Do you want to update your receiver to %s?"
) % latestImageTimestamp + "\n"
else:
message = _(
"Do you want to update your receiver?") + "\n"
message += "(" + (ngettext(
"%s updated package available",
"%s updated packages available", self.total_packages) %
self.total_packages) + ")"
if self.total_packages > 150:
choices = [(_("Update and reboot"), "cold")]
message += " " + _("Reflash recommended!")
else:
choices = [(_("Update and reboot (recommended)"),
"cold"),
(_("Update and ask to reboot"), "hot")]
choices.append((_("Update channel list only"), "channels"))
choices.append(
(_("Show packages to be upgraded"), "showlist"))
else:
message = _("No updates available")
choices = []
if fileExists("/home/root/ipkgupgrade.log"):
choices.append((_("Show latest upgrade log"), "log"))
choices.append((_("Show latest commits"), "commits"))
choices.append((_("Cancel"), ""))
self.session.openWithCallback(self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices,
windowTitle=self.title)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(
_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
"Your receiver might be unusable now. Please consult the manual for further assistance before rebooting your receiver."
)
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _(
"Update failed. Your receiver does not have a working internet connection."
)
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[
0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST,
args={'installed_only': True})
elif answer[1] == "commits":
self.session.openWithCallback(
boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE,
None), CommitInfo)
elif answer[1] == "showlist":
text = "\n".join([
x[0]
for x in sorted(self.ipkg.getFetchedList(), key=lambda d: d[0])
])
self.session.openWithCallback(
boundFunction(self.ipkgCallback,
IpkgComponent.EVENT_DONE, None), TextBox, text,
_("Packages to update"), True)
elif answer[1] == "log":
text = open("/home/root/ipkgupgrade.log", "r").read()
self.session.openWithCallback(
boundFunction(self.ipkgCallback,
IpkgComponent.EVENT_DONE, None), TextBox, text,
_("Latest upgrade log"), True)
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE,
args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(
self.exitAnswer, MessageBox,
_("Update completed. Do you want to reboot your receiver?")
)
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class UpdatePlugin(Screen, ProtectedScreen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, True)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and\
(not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and\
config.ParentalControl.config_sections.software_update.value
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
from urllib import urlopen
import socket
import os
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
message = ""
picon = None
default = True
# try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
# status = urlopen("http://openpli.org/status").read().split('!', 1)
# if getBoxType() in status[0].split(','):
# message = len(status) > 1 and status[1] or _("The current beta image might not be stable.\nFor more information see %s.") % ("www.openpli.org")
# picon = MessageBox.TYPE_ERROR
# default = False
# except:
# message = _("The status of the current beta image could not be checked because %s can not be reached.") % ("www.openpli.org")
# picon = MessageBox.TYPE_ERROR
# default = False
socket.setdefaulttimeout(currentTimeoutDefault)
if default:
self.showDisclaimer()
else:
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate, MessageBox, message, default = default, picon = picon)
def showDisclaimer(self, justShow=False):
if config.usage.show_update_disclaimer.value or justShow:
message = _("With this disclaimer the openMips team is informing you that we are working with nightly builds and it might be that after the upgrades your set top box \
is not anymore working as expected. Therefore it is recommended to create backups. If something went wrong you can easily and quickly restore. \
When you discover 'bugs' please keep them reported on www.gigablue-support.com.\n\nDo you understand this?")
list = not justShow and [(_("no"), False), (_("yes"), True), (_("yes") + " " + _("and never show this message again"), "never")] or []
self.session.openWithCallback(boundFunction(self.disclaimerCallback, justShow), MessageBox, message, list=list)
else:
self.startActualUpdate(True)
def disclaimerCallback(self, justShow, answer):
if answer == "never":
config.usage.show_update_disclaimer.value = False
config.usage.show_update_disclaimer.save()
if justShow and answer:
self.ipkgCallback(IpkgComponent.EVENT_DONE, None)
else:
self.startActualUpdate(answer)
#def getLatestImageTimestamp(self):
# currentTimeoutDefault = socket.getdefaulttimeout()
# socket.setdefaulttimeout(3)
# latestImageTimestamp = ""
# try:
# # TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# # run in parallel to the package update.
# latestImageTimestamp = re.findall('class="dllink">(.*?)</a>', urlopen("http://image.openmips.com/4.2/index.php?open=" + getBoxType() ").read())[0][:16]
# latestImageTimestamp = time.strftime(_("%d-%b-%Y %-H:%M"), time.strptime(latestImageTimestamp, "%Y/%m/%d %H:%M"))
# except:
# pass
# socket.setdefaulttimeout(currentTimeoutDefault)
# return latestImageTimestamp
def startActualUpdate(self,answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % (param)
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
message = _("Do you want to update your receiver?") + "\n"
message += "(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
if self.total_packages > 150:
message += " " + _("Reflash recommended!")
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
#(_("Update channel list only"), "channels"),
(_("Show packages to be upgraded"), "showlist")]
else:
message = _("No updates available")
choices = []
if fileExists("/home/root/ipkgupgrade.log"):
choices.append((_("Show latest upgrade log"), "log"))
if not config.usage.show_update_disclaimer.value:
choices.append((_("Show disclaimer"), "disclaimer"))
choices.append((_("Cancel"), ""))
self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your receiver might be unusable now. Please consult the manual for further assistance before rebooting your receiver.")
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _("Update failed. Your receiver does not have a working internet connection.")
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
#elif answer[1] == "commits":
# self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), CommitInfo)
elif answer[1] == "disclaimer":
self.showDisclaimer(justShow=True)
elif answer[1] == "showlist":
text = ""
for i in [x[0] for x in sorted(self.ipkg.getFetchedList(), key=lambda d: d[0])]:
text = text and text + "\n" + i or i
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), TextBox, text, _("Packages to update"))
elif answer[1] == "log":
text = ""
for i in open("/home/root/ipkgupgrade.log", "r").readlines():
text += i
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), TextBox, text, _("Packages upgraded"))
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args = {'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Update completed. Do you want to reboot your receiver?"))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop,retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class Ipkg(Screen):
def __init__(self, session, cmdList=None):
if not cmdList:
cmdList = []
Screen.__init__(self, session)
self.cmdList = cmdList
self.sliderPackages = {}
self.slider = Slider(0, len(cmdList))
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = Label(_("Preparing... Please wait"))
self["status"] = self.status
self.package = Label()
self["package"] = self.package
self.packages = 0
self.error = 0
self.processed_packages = []
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
#self.activityTimer.start(100, False)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.runningCmd = None
self.runNextCmd()
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
def runNextCmd(self):
if self.runningCmd is None:
self.runningCmd = 0
else:
self.runningCmd += 1
print len(self.cmdList), self.runningCmd
if len(self.cmdList) - 1 < self.runningCmd:
self.activityslider.setValue(0)
self.slider.setValue(len(self.cmdList))
self.package.setText("")
self.status.setText(
ngettext(
"Done - Installed, upgraded or removed %d package (%s)",
"Done - Installed, upgraded or removed %d packages (%s)",
self.packages) %
(self.packages,
ngettext("with %d error", "with %d errors", self.error) %
self.error))
return False
else:
cmd = self.cmdList[self.runningCmd]
self.slider.setValue(self.runningCmd)
self.ipkg.startCmd(cmd[0], args=cmd[1])
self.startActivityTimer()
def doActivityTimer(self):
if not self.ipkg.isRunning():
self.stopActivityTimer()
else:
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def startActivityTimer(self):
self.activityTimer.start(100, False)
def stopActivityTimer(self):
self.activityTimer.stop()
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if param in self.sliderPackages:
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
self.runNextCmd()
elif event == IpkgComponent.EVENT_MODIFIED:
self.session.openWithCallback(
self.modificationCallback, MessageBox,
_("A configuration file (%s) was modified since Installation.\nDo you want to keep your version?"
) % param)
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
self.close()
class FeedsStatusCheck:
def __init__(self):
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def IsInt(self, val):
try:
int(val)
return True
except ValueError:
return False
def adapterAvailable(self): # Box has an adapter configured and active
for adapter in ("eth0", "eth1", "wlan0", "wlan1", "wlan2", "wlan3",
"ra0"):
if "addr" in about.getIfConfig(adapter):
print("[OnlineUpdateCheck][adapterAvailable] PASSED")
return True
print("[OnlineUpdateCheck][adapterAvailable] FAILED")
return False
def NetworkUp(self,
host="8.8.8.8",
port=53,
timeout=2): # Box can access outside the local network
# Avoids DNS resolution
# Avoids application layer (HTTP/FTP/IMAP)
# Avoids calls to external utilities
# Used "sudo nmap 8.8.8.8" to discover the following
# Host: 8.8.8.8 (google-public-dns-a.google.com)
# OpenPort: 53/tcp
# Service: domain (DNS/TCP)
previousTimeout = socket.getdefaulttimeout()
socket.setdefaulttimeout(timeout)
try:
sd = None
sd = socket.socket(socket.AF_INET, socket.SOCK_STREAM, 0)
sd.connect((host, port))
print("[OnlineUpdateCheck][NetworkUp] PASSED")
result = True
except:
print("[OnlineUpdateCheck][NetworkUp] FAILED", sys.exc_info()[0])
result = False
finally:
if sd is not None:
try:
sd.shutdown(socket.SHUT_RDWR)
except:
pass
sd.close()
socket.setdefaulttimeout(previousTimeout) # Reset to previous value.
return result
def getFeedStatus(self):
officialReleaseFeedsUri = "openvix.co.uk"
status = 1
trafficLight = "unknown"
if self.adapterAvailable():
if self.NetworkUp():
if getImageType(
) == "release" and officialReleaseFeedsUri in getFeedsUrl(
): # we know the network is good now so only do this check on release images where the release domain applies
try:
print(
"[OnlineUpdateCheck][getFeedStatus] checking feeds state"
)
req = Request(
"http://openvix.co.uk/TrafficLightState.php")
d = urlopen(req)
trafficLight = d.read().decode()
if trafficLight == "stable":
status = 0
print("trafficLight", trafficLight)
except HTTPError as err:
print("[OnlineUpdateCheck][getFeedStatus] ERROR:", err)
trafficLight = err.code
except URLError as err:
print("[OnlineUpdateCheck][getFeedStatus] ERROR:",
err.reason[0])
trafficLight = err.reason[0]
except:
print("[OnlineUpdateCheck][getFeedStatus] ERROR:",
sys.exc_info()[0])
trafficLight = -2
if getImageType(
) == "developer" and "openvixdev" in getFeedsUrl():
print(
"[OnlineUpdateCheck][getFeedStatus] Official developer feeds"
)
trafficLight = "developer"
elif officialReleaseFeedsUri not in getFeedsUrl(
): # if not using official feeds mark as alien. There is no status test for alien feeds (including official developer feeds).
print(
"[OnlineUpdateCheck][getFeedStatus] Alien feeds url: %s"
% getFeedsUrl())
status = 0
trafficLight = "alien"
config.softwareupdate.updateisunstable.value = status
return trafficLight
else: # network not up
print("[OnlineUpdateCheck][getFeedStatus] ERROR: -2")
return -2
else: # adapter not available
print("[OnlineUpdateCheck][getFeedStatus] ERROR: -3")
return -3
# We need a textual mapping for all possible return states for use by
# SoftwareUpdate::checkNetworkState() and ChoiceBox::onshow()
# Declared here for consistency and co-location with choices.
feed_status_msgs = {
"stable":
_("Feeds status: Stable"),
"unstable":
_("Feeds status: Unstable"),
"updating":
_("Feeds status: Updating"),
"-2":
_("ERROR: No internet found"),
"-3":
_("ERROR: No network found"),
"403":
_("ERROR: Response 403 Forbidden"),
"404":
_("ERROR: Response 404 Not Found"),
"inprogress":
_("ERROR: Check is already running in background, please wait a few minutes and try again"
),
"unknown":
_("Feeds status: Unknown"),
"alien":
_("Feeds status: Unknown, user feeds url"),
"developer":
_("Feeds status: Official developer feeds"),
}
def getFeedsBool(self):
global error
self.feedstatus = self.getFeedStatus()
if self.feedstatus in (-2, -3, 403, 404):
print("[OnlineUpdateCheck][getFeedsBool] Error %s" %
str(self.feedstatus))
return str(
self.feedstatus
) # must be str as used in string keys of feed_status_msgs
elif error:
print(
"[OnlineUpdateCheck][getFeedsBool] Check already in progress")
return "inprogress"
elif self.feedstatus == "updating":
print("[OnlineUpdateCheck][getFeedsBool] Feeds Updating")
return "updating"
elif self.feedstatus in ("stable", "unstable", "unknown", "alien",
"developer"):
print("[OnlineUpdateCheck][getFeedsBool]", self.feedstatus)
return self.feedstatus
def getFeedsErrorMessage(self):
global error
#feedstatus = feedsstatuscheck.getFeedsBool() # This is forcing an additional HTTP request so don't do it. Also the output was incorrect so the messages didn"t show, just an empty MessageBox.
if self.feedstatus == -2:
return _(
"Your %s %s has no internet access, please check your network settings and make sure you have network cable connected and try again."
) % (getMachineBrand(), getMachineName())
elif self.feedstatus == -3:
return _(
"Your %s %s has no network access, please check your network settings and make sure you have network cable connected and try again."
) % (getMachineBrand(), getMachineName())
elif self.feedstatus == 404:
return _(
"Your %s %s is not able to connect to the feeds, please try again later. If this persists please report on the OpenViX forum at world-of-satellite.com."
) % (getMachineBrand(), getMachineName())
elif self.feedstatus in ("updating", 403):
return _(
"Sorry feeds are down for maintenance, please try again later. If this issue persists please check openvix.co.uk or world-of-satellite.com."
)
elif error:
return _(
"There has been an error, please try again later. If this issue persists, please check openvix.co.uk or world-of-satellite.com"
)
def startCheck(self):
global error
error = 0
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
config.softwareupdate.updatefound.setValue(False)
if event == IpkgComponent.EVENT_ERROR:
global error
error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages and (
getImageType() != "release" or
(config.softwareupdate.updateisunstable.value == 1
and config.softwareupdate.updatebeta.value)
or config.softwareupdate.updateisunstable.value == 0):
print((
"[OnlineUpdateCheck][ipkgCallback] %s Updates available"
% self.total_packages))
config.softwareupdate.updatefound.setValue(True)
pass
class UpdateEGAMI(Screen):
skin = '<screen name="UpdateEGAMI" position="center,center" size="550,300" title="Software update" >\n\t\t<widget name="activityslider" position="0,0" size="550,5" />\n\t\t<widget name="slider" position="0,150" size="550,30" />\n\t\t<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />\n\t\t<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />\n\t\t</screen>'
def __init__(self, session, args=None):
Screen.__init__(self, session)
self.sliderPackages = {
'ceryon-dvb-modules': 1,
'broadmedia-dvb-modules': 2,
'ini-dvb-modules': 3,
'enigma2': 4,
'egami-version-info': 5
}
self.slider = Slider(0, 4)
self['slider'] = self.slider
self.activityslider = Slider(0, 100)
self['activityslider'] = self.activityslider
self.status = StaticText(_('Please wait...'))
self['status'] = self.status
self.package = StaticText(_('Verifying your internet connection...'))
self['package'] = self.package
self.oktext = _('Press OK on your remote control to continue.')
self.packages = 0
self.error = 0
self.processed_packages = []
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.updating = False
self['actions'] = ActionMap(['WizardActions'], {
'ok': self.exit,
'back': self.exit
}, -1)
self['actions'].csel = self
self['actions'].setEnabled(False)
iNetwork.checkNetworkState(self.checkNetworkCB)
self.onClose.append(self.cleanup)
def startUpgrade(self):
update_options = ' '
if config.usage.use_force_overwrite.value:
update_options += '--force-overwrite '
if config.usage.use_package_conffile.value:
update_options += '--force-maintainer '
f = open(update_trigger, 'w+')
f.write(update_options)
f.close()
config.usage.update_available.value = False
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def cleanup(self):
iNetwork.stopPingConsole()
def getFreeSpace(self, mountpoint):
if mountpoint:
stat_info = statvfs(mountpoint)
free_flash_space = stat_info.f_bfree * stat_info.f_bsize
return free_flash_space
def checkFreeSpace(self):
free_flash_space = self.getFreeSpace('/')
if free_flash_space > 19000000:
self.startUpgrade()
else:
human_free_space = free_flash_space / 1048576
msg = _(
'There are only %d MB free FLASH space available\nInstalling or updating software can cause serious software problems !\nContinue installing/updating software (at your own risk) ?'
) % human_free_space
self.session.openWithCallback(self.cbSpaceCheck,
MessageBox,
msg,
MessageBox.TYPE_YESNO,
default=False)
def cbSpaceCheck(self, result):
if not result:
self.close()
else:
self.startUpgrade()
def checkNetworkCB(self, data):
if data is not None:
if data <= 2:
self.updating = True
self.activityTimer.start(100, False)
self.package.setText(_('Package list update'))
self.status.setText(
_('Upgrading Your ') + ' %s %s ' %
(getMachineBrand(), getMachineName()) + _('Please wait'))
self.checkFreeSpace()
else:
self.package.setText(
_('Your network is not working. Please try again.'))
self.status.setText(self.oktext)
return
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_('Downloading'))
else:
if event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_('Upgrading'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
else:
if event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_('Installing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
else:
if event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_('Removing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
else:
if event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_('Configuring'))
else:
if event == IpkgComponent.EVENT_MODIFIED:
self.ipkg.write('Y')
else:
if event == IpkgComponent.EVENT_ERROR:
self['actions'].setEnabled(True)
else:
if event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
if config.usage.use_package_conffile.value == True:
upgrade_args = {
'use_maintainer': True,
'test_only': False
}
else:
upgrade_args = {
'use_maintainer': False,
'test_only': False
}
if config.usage.use_force_overwrite.value:
upgrade_args[
'force_overwrite'] = True
else:
upgrade_args[
'force_overwrite'] = False
self.ipkg.startCmd(
IpkgComponent.CMD_UPGRADE,
args=upgrade_args)
elif self.error == 0:
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(
_('Done - Installed or upgraded %d packages'
) % self.packages)
self.status.setText(self.oktext)
self['actions'].setEnabled(True)
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
'your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your STB.'
) % (getMachineBrand(),
getMachineName())
if self.packages == 0:
error = _(
'No packages were upgraded yet. So you can check your network and try again.'
)
if self.updating:
error = _(
"Your %s %s isn't connected to the internet properly. Please check it and try again."
) % (getMachineBrand(),
getMachineName())
self.status.setText(
_('Error') + ' - ' + error)
self['actions'].setEnabled(True)
def modificationCallback(self, res):
self.ipkg.write(res and 'N' or 'Y')
def exit(self):
if not self.ipkg.isRunning():
if self.packages == 0 and os_path.exists(update_trigger):
remove(update_trigger)
if self.packages != 0 and self.error == 0:
f = open('/etc/do_update', 'w+').close()
self.session.openWithCallback(
self.exitAnswer, MessageBox,
_('Upgrade finished.') + ' ' +
_('Do you want to reboot your %s %s ?') %
(getMachineBrand(), getMachineName()))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, 2)
self.close()
return
class OnlineUpdateCheckPoller:
def __init__(self):
# Init Timer
self.timer = eTimer()
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def start(self):
if self.onlineupdate_check not in self.timer.callback:
self.timer.callback.append(self.onlineupdate_check)
if time() > 1262304000: # Fri, 01 Jan 2010 00:00:00 GMT
self.timer.startLongTimer(30)
else:
self.timer.startLongTimer(10 * 60)
def stop(self):
if self.version_check in self.timer.callback:
self.timer.callback.remove(self.onlineupdate_check)
self.timer.stop()
def onlineupdate_check(self):
if config.softwareupdate.check.value:
Components.Task.job_manager.AddJob(self.createCheckJob())
self.timer.startLongTimer(
int(config.softwareupdate.checktimer.value) * 3600)
def createCheckJob(self):
job = Components.Task.Job(_("OnlineVersionCheck"))
task = Components.Task.PythonTask(job, _("Checking for updates..."))
task.work = self.JobStart
task.weighting = 1
return job
def JobStart(self):
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
print('[OnlineVersionCheck] %s updates available' %
self.total_packages)
if self.total_packages:
config.softwareupdate.updatefound.setValue(True)
if not versioncheck.user_notified:
versioncheck.user_notified = True
msg = _("Online update available.\n")
if self.total_packages > 100:
msg += _(
"\nThis is a large update. Consider a full USB update instead.\n"
)
msg += _("\nInstall now?\n")
default = self.total_packages <= 100
Notifications.AddNotificationWithUniqueIDCallback(
self.updateNotificationAnswer,
"OnlineUpdateAvailable",
SuspendableMessageBox,
msg,
default=default)
else:
config.softwareupdate.updatefound.setValue(False)
else:
config.softwareupdate.updatefound.setValue(False)
def updateNotificationAnswer(self, answer):
if answer:
Notifications.AddNotification(UpdatePlugin)
class UpdatePlugin(Screen, ProtectedScreen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
self.sliderPackages = {
"dreambox-dvb-modules": 1,
"enigma2": 2,
"tuxbox-image-info": 3
}
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, True)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and\
(not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and\
config.ParentalControl.config_sections.software_update.value
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
from urllib import urlopen
import socket
import os
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
message = ""
picon = None
default = True
socket.setdefaulttimeout(currentTimeoutDefault)
if default:
self.showDisclaimer()
else:
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate,
MessageBox,
message,
default=default,
picon=picon)
def showDisclaimer(self, justShow=False):
if config.usage.show_update_disclaimer.value or justShow:
message = _(
"The OpenSPA team would like to point out that upgrading to the latest nightly build comes not only with the latest features, but also with some risks. After the update, it is possible that your device no longer works as expected. We recommend you create backups. This allows you to quickly and easily restore your device to its previous state, should you experience any problems. If you encounter a 'bug', please report the issue on https://vuplus-images.co.uk.\n\nDo you understand this?"
)
list = not justShow and [
(_("no"), False), (_("yes"), True),
(_("yes") + " " + _("and never show this message again"),
"never")
] or []
self.session.openWithCallback(boundFunction(
self.disclaimerCallback, justShow),
MessageBox,
message,
list=list)
else:
self.startActualUpdate(True)
def disclaimerCallback(self, justShow, answer):
if answer == "never":
config.usage.show_update_disclaimer.value = False
config.usage.show_update_disclaimer.save()
if justShow and answer:
self.ipkgCallback(IpkgComponent.EVENT_DONE, None)
else:
self.startActualUpdate(answer)
def startActualUpdate(self, answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(
ngettext("Update completed, %d package was installed.",
"Update completed, %d packages were installed.",
self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(
_("Upgrading") + ": %s/%s" %
(self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in (
"N", "Y"):
self.ipkg.write(
True and
config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback, MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?"
) % (param))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
message = _(
"Do you want to update your receiver?") + "\n(" + (
ngettext("%s updated package available",
"%s updated packages available",
self.total_packages) %
self.total_packages) + ")"
if self.total_packages > 150:
message += " " + _("Reflash recommended!")
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
(_("Update channel list only"), "channels"),
(_("Show packages to be upgraded"), "showlist")]
else:
message = _("No updates available")
choices = []
if not config.usage.show_update_disclaimer.value:
choices.append((_("Show disclaimer"), "disclaimer"))
choices.append((_("Cancel"), ""))
self.session.openWithCallback(self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(
_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
"Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s."
) % (getMachineBrand(), getMachineName(), getMachineBrand(),
getMachineName())
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _(
"Update failed. Your %s %s does not have a working internet connection."
) % (getMachineBrand(), getMachineName())
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[
0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST,
args={'installed_only': True})
elif answer[1] == "disclaimer":
self.showDisclaimer(justShow=True)
elif answer[1] == "showlist":
text = ""
for i in [
x[0] for x in sorted(self.ipkg.getFetchedList(),
key=lambda d: d[0])
]:
text = text and text + "\n" + i or i
self.session.openWithCallback(
boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE,
None), TextBox, text, _("Packages to update"))
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE,
args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
if fileExists("/etc/enigma2/.removelang"):
from Components.Language import language
language.delLanguage()
self.session.openWithCallback(
self.exitAnswer, MessageBox,
_("Update completed. Do you want to reboot your receiver?")
)
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class UpdatePlugin(Screen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software Update"))
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.checkNetworkState()
def checkNetworkState(self):
cmd1 = "opkg update"
self.CheckConsole = Console()
self.CheckConsole.ePopen(cmd1, self.checkNetworkStateFinished)
def checkNetworkStateFinished(self, result, retval,extra_args=None):
if result.find('wget returned 1') != -1 or result.find('wget returned 255') != -1 or result.find('404 Not Found') != -1:
self.session.openWithCallback(self.close, MessageBox, _("Sorry feeds are down for maintenance, please try again later."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif result.find('bad address') != -1:
self.session.openWithCallback(self.close, MessageBox, _("Your STB_BOX is not connected to the internet, please check your network settings and try again."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif result.find('Collected errors') != -1:
self.session.openWithCallback(self.close, MessageBox, _("A background update check is is progress, please wait a few minutes and try again."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
else:
self.startCheck()
def startCheck(self):
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.updating = False
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self.updating = True
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.getValue() in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.getValue())
else:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % (param)
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
from urllib import urlopen
import socket
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
try:
config.softwareupdate.updateisunstable.setValue(urlopen("http://enigma2.world-of-satellite.com/feeds/" + about.getImageVersionString() + "/status").read())
except:
config.softwareupdate.updateisunstable.setValue(1)
socket.setdefaulttimeout(currentTimeoutDefault)
self.total_packages = None
if config.softwareupdate.updateisunstable.getValue() == '1' and config.softwareupdate.updatebeta.getValue():
self.total_packages = len(self.ipkg.getFetchedList())
message = _("The current update maybe unstable") + "\n" + _("Are you sure you want to update your STB_BOX?") + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
elif config.softwareupdate.updateisunstable.getValue() == '0':
self.total_packages = len(self.ipkg.getFetchedList())
message = _("Do you want to update your STB_BOX?") + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
if self.total_packages:
config.softwareupdate.updatefound.setValue(True)
choices = [(_("View the changes"), "changes"),
(_("Upgrade and reboot system"), "cold")]
if path.exists("/usr/lib/enigma2/python/Plugins/SystemPlugins/ViX/BackupManager.pyo"):
if not config.softwareupdate.autosettingsbackup.getValue():
choices.append((_("Perform a setting backup,") + '\n\t' + _("making a backup before updating") + '\n\t' +_("is strongly advised."), "backup"))
if not config.softwareupdate.autoimagebackup.getValue():
choices.append((_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name = "SoftwareUpdateChoices")
upgrademessage.setTitle(_('Software update'))
else:
upgrademessage = self.session.openWithCallback(self.close, MessageBox, _("Nothing to upgrade"), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
upgrademessage.setTitle(_('Software update'))
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your STB_BOX might be unusable now. Please consult the manual for further assistance before rebooting your STB_BOX.")
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _("Update failed. Your STB_BOX does not have a working internet connection.")
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "menu":
if config.softwareupdate.updateisunstable.getValue() == '1':
message = _("The current update maybe unstable") + "\n" + _("Are you sure you want to update your STB_BOX?") + "\n(%s " % self.total_packages + _("Packages") + ")"
elif config.softwareupdate.updateisunstable.getValue() == '0':
message = _("Do you want to update your STB_BOX?") + "\n(%s " % self.total_packages + _("Packages") + ")"
choices = [(_("View the changes"), "changes"),
(_("Upgrade and reboot system"), "cold")]
if not self.SettingsBackupDone and not config.softwareupdate.autosettingsbackup.getValue():
choices.append((_("Perform a setting backup, making a backup before updating is strongly advised."), "backup"))
if not self.ImageBackupDone and not config.softwareupdate.autoimagebackup.getValue():
choices.append((_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name = "SoftwareUpdateChoices")
upgrademessage.setTitle(_('Software update'))
elif answer[1] == "changes":
self.session.openWithCallback(self.startActualUpgrade,SoftwareUpdateChanges)
elif answer[1] == "backup":
self.doSettingsBackup()
elif answer[1] == "imagebackup":
self.doImageBackup()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
elif answer[1] == "cold":
if config.softwareupdate.autosettingsbackup.getValue() or config.softwareupdate.autoimagebackup.getValue():
self.doAutoBackup()
else:
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def doSettingsBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.BackupManager import BackupFiles
self.BackupFiles = BackupFiles(self.session)
Components.Task.job_manager.AddJob(self.BackupFiles.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('ViX', 'Backup Manager'):
break
self.showJobView(job)
def doImageBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.ImageManager import ImageBackup
self.ImageBackup = ImageBackup(self.session)
Components.Task.job_manager.AddJob(self.ImageBackup.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('ViX', 'Image Manager'):
break
self.showJobView(job)
def doAutoBackup(self, val = False):
self.autobackuprunning = True
if config.softwareupdate.autosettingsbackup.getValue() and not self.SettingsBackupDone:
self.doSettingsBackup()
elif config.softwareupdate.autoimagebackup.getValue() and not self.ImageBackupDone:
self.doImageBackup()
else:
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
def showJobView(self, job):
if job.name == dgettext('ViX', 'Image Manager'):
self.ImageBackupDone = True
elif job.name == dgettext('ViX', 'Backup Manager'):
self.SettingsBackupDone = True
from Screens.TaskView import JobView
Components.Task.job_manager.in_background = False
if not self.autobackuprunning:
self.session.openWithCallback(self.startActualUpgrade(("menu", "menu")), JobView, job, cancelable = False, backgroundable = False, afterEventChangeable = False, afterEvent="close")
else:
self.session.openWithCallback(self.doAutoBackup, JobView, job, cancelable = False, backgroundable = False, afterEventChangeable = False, afterEvent="close")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Upgrade finished.") +" "+_("Do you want to reboot your STB_BOX?"))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
class manageDttDevice(Screen):
__module__ = __name__
skin = '\n\t\t<screen position="80,95" size="560,430">\n\t\t\t<widget source="conn" render=Label position="10,10" size="540,340" font="Regular;20" halign="center" transparent="1" />\n\t\t\t<widget source="list" render="Listbox" position="10,10" size="540,340" scrollbarMode="showOnDemand">\n\t\t\t\t<convert type="TemplatedMultiContent">\n\t\t\t\t\t{"template": [\n\t\t\t\t\t\t\tMultiContentEntryText(pos = (0, 0), size = (400, 30), font=0, flags = RT_HALIGN_LEFT | RT_HALIGN_LEFT, text = 1),\n\t\t\t\t\t\t\tMultiContentEntryPixmapAlphaTest(pos=(405, 6), size=(80, 23), png=png),\n\t\t\t\t\t\t],\n\t\t\t\t\t"fonts": [gFont("Regular", 20)],\n\t\t\t\t\t"itemHeight": 30\n\t\t\t\t\t}\n\t\t\t\t</convert>\n\t\t\t</widget>\n\t\t\t<widget name="key_red" position="0,400" size="280,20" zPosition="1" font="Regular;22" valign="center" foregroundColor="#0064c7" backgroundColor="#9f1313" transparent="1" />\n\t\t\t<widget name="key_yellow" position="400,510" size="280,20" zPosition="1" font="Regular;22" valign="center" foregroundColor="#bab329" backgroundColor="#9f1313" transparent="1" />\n\t\t</screen>'
def __init__(self, session):
Screen.__init__(self, session)
self.list = []
self.devList = checkDev()
self.devstatus = { }
self.needInstall = False
self.updating = True
self['list'] = List(self.list)
self['key_red'] = Label(_('Exit'))
self['key_yellow'] = Label('')
self['conn'] = StaticText('')
self['actions'] = ActionMap([
'WizardActions',
'ColorActions'], {
'ok': self.KeyOk,
'yellow': self.modulesInstall,
'red': self.exit,
'back': self.exit })
self.cmdList = []
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.timeoutTimer = eTimer()
self.timeoutTimer.callback.append(self.doTimeoutTimer)
self.onLayoutFinish.append(self.updateList)
self.onShown.append(self.setWindowTitle)
def exit(self):
if not self.ipkg.isRunning():
self.close()
def setWindowTitle(self):
self.setTitle(_('Manage DVB-T/C Adapter'))
def KeyOk(self):
if self.devList:
sel = self['list'].getCurrent()[0]
if sel:
self.devstatus[sel] = not self.devstatus[sel]
self.saveStatus()
self.updateList()
if self.devstatus[sel]:
msg = _('Enigma2 will be now hard restarted to enable DVB/T.please wait\nDo You want restart now?')
box = self.session.openWithCallback(self.restartEnigma2, MessageBox, msg, MessageBox.TYPE_YESNO)
box.setTitle(_('Restart Enigma2'))
else:
msg = _('Dreambox will be now rebooted to disable DVB/T.\nDo You want reboot the box now?')
box = self.session.openWithCallback(self.rebootDream, MessageBox, msg, MessageBox.TYPE_YESNO)
box.setTitle(_('Reboot Dreambox'))
else:
self.close()
def restartEnigma2(self, answer):
if answer is True:
self.session.open(TryQuitMainloop, 3)
def rebootDream(self, answer):
if answer is True:
self.session.open(TryQuitMainloop, 2)
def readStatus(self):
try:
if self.devList:
for x in self.devList:
self.devstatus[x[1]] = False
if fileExists('/etc/dtt.devices'):
loadedDevices = open('/etc/dtt.devices', 'r')
for d in loadedDevices.readlines():
for dev in self.devList:
if dev[1] == d[:-1]:
self.devstatus[dev[1]] = True
continue
loadedDevices.close()
elif fileExists('/etc/dtt.devices'):
unlink('/etc/dtt.devices')
return None
except IOError:
return None
def saveStatus(self):
out = open('/etc/dtt.devices', 'w')
for dev in self.devList:
if self.devstatus.get(dev[1]):
out.write(dev[1] + '\n')
continue
out.close()
def updateList(self):
del self.list[:]
if fileExists('/usr/script/loaddttmodules.sh'):
self['conn'].text = ''
self['key_yellow'].setText(_('Remove Driver'))
self.readStatus()
self.needInstall = False
skin_path = GetSkinPath()
if self.devList:
for dev in self.devList:
res = [
dev[1]]
png = LoadPixmap({
True: skin_path + 'menu/menu_on.png',
False: skin_path + 'menu/menu_off.png' }[self.devstatus.get(dev[1])])
self.list.append((dev[1], dev[2], png))
self['list'].setList(self.list)
else:
self.needInstall = True
self['key_yellow'].setText(_('Install Driver'))
self.showInstMess()
def showInstMess(self):
diskSpace = t.getVarSpaceKb()
percFree = int((diskSpace[0] / diskSpace[1]) * 100)
strMess = _('Modules for support\nUSB DVB-T/C adapter\nare not installed!\n\nPress yellow button\nto install it.')
self['conn'].text = '%s\n\nFree: %d kB (%d%%)' % (strMess, int(diskSpace[0]), percFree)
def modulesInstall(self):
if self.needInstall:
if int(t.getVarSpaceKb()[0]) < 2500:
msg = _('Not enough space!\nPlease delete addons before install new.')
self.session.open(MessageBox, msg, MessageBox.TYPE_INFO)
return None
self['conn'].setText(_('Connetting to addons server.\nPlease wait...'))
self.updating = True
self.timeoutTimer.start(config.nemesis.ipkg.updateTimeout.value * 1000)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
msg = _('Do you want remove the support\npackages, for DVB-T/C adapters?') + _('\nAfter pressing OK, please wait!')
self.session.openWithCallback(self.runRemove, MessageBox, msg, MessageBox.TYPE_YESNO)
def doTimeoutTimer(self):
self['conn'].text = _('Server connection timeout!\nPlease try again later.')
self.ipkg.stop()
def runUpgrade(self, result):
if result:
self.session.openWithCallback(self.updateList, Ipkg, cmdList = self.cmdList)
else:
self.showInstMess()
def runRemove(self, result):
if result:
self.cmdList = []
self.cmdList.append((IpkgComponent.CMD_REMOVE, {
'package': 'dreambox-tuner-usb' }))
if len(self.cmdList):
self.session.openWithCallback(self.pakageRemoved, Ipkg, cmdList = self.cmdList)
def pakageRemoved(self):
self.updateList()
if fileExists('/etc/dtt.devices'):
unlink('/etc/dtt.devices')
msg = _('Dreambox will be now rebooted to disable DVB/T.\nDo You want reboot the box now?')
box = self.session.openWithCallback(self.rebootDream, MessageBox, msg, MessageBox.TYPE_YESNO)
box.setTitle(_('Reboot Dreambox'))
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.updating = False
self['conn'].text = _('Server not found!\nPlease check internet connection.')
elif event == IpkgComponent.EVENT_DONE:
if self.timeoutTimer.isActive():
self.timeoutTimer.stop()
if self.updating:
self.cmdList = []
self.cmdList.append((IpkgComponent.CMD_INSTALL, {
'package': 'dreambox-tuner-usb' }))
if len(self.cmdList):
self.session.openWithCallback(self.runUpgrade, MessageBox, _('Do you want install the support\npackages, for DVB-T/C adapters?') + _('\nAfter pressing OK, please wait!'), MessageBox.TYPE_YESNO)
class Ipkg(Screen):
def __init__(self, session, cmdList=[]):
Screen.__init__(self, session)
self.cmdList = cmdList
self.sliderPackages = {}
self.slider = Slider(0, len(cmdList))
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = Label(_("Preparing... Please wait"))
self["status"] = self.status
self.package = Label()
self["package"] = self.package
self.packages = 0
self.error = 0
self.processed_packages = []
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer_conn = self.activityTimer.timeout.connect(
self.doActivityTimer)
#self.activityTimer.start(100, False)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.runningCmd = None
self.runNextCmd()
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
def runNextCmd(self):
if self.runningCmd is None:
self.runningCmd = 0
else:
self.runningCmd += 1
print(len(self.cmdList), self.runningCmd)
if len(self.cmdList) - 1 < self.runningCmd:
self.activityslider.setValue(0)
self.slider.setValue(len(self.cmdList))
self.package.setText("")
self.status.setText(
_("Done - Installed, upgraded or removed %d packages with %d errors"
) % (self.packages, self.error))
return False
else:
cmd = self.cmdList[self.runningCmd]
self.slider.setValue(self.runningCmd)
self.ipkg.startCmd(cmd[0], args=cmd[1])
self.startActivityTimer()
def doActivityTimer(self):
if not self.ipkg.isRunning():
self.stopActivityTimer()
else:
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def startActivityTimer(self):
self.activityTimer.start(100, False)
def stopActivityTimer(self):
self.activityTimer.stop()
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if param in self.sliderPackages:
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
self.runNextCmd()
def exit(self):
if not self.ipkg.isRunning():
self.close()
class SoftwareTools(DreamInfoHandler):
lastDownloadDate = None
NetworkConnectionAvailable = None
list_updating = False
available_updates = 0
available_updatelist = []
available_packetlist = []
installed_packetlist = {}
upgradable_packages = {}
upgradeAvailable = False
def __init__(self):
aboutInfo = about.getImageVersionString()
if aboutInfo.startswith("dev-"):
self.ImageVersion = 'Experimental'
else:
self.ImageVersion = 'Stable'
self.language = language.getLanguage()[:2] # getLanguage returns e.g. "fi_FI" for "language_country"
DreamInfoHandler.__init__(self, self.statusCallback, blocking = False, neededTag = 'ALL_TAGS', neededFlag = self.ImageVersion)
self.directory = resolveFilename(SCOPE_METADIR)
self.hardware_info = HardwareInfo()
self.list = List([])
self.NotifierCallback = None
self.Console = Console()
self.UpdateConsole = Console()
self.UpgradeConsole = Console()
self.cmdList = []
self.unwanted_extensions = ('-dbg', '-dev', '-doc')
self.reboot_required_packages = ('dreambox-dvb-modules', 'kernel-')
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def statusCallback(self, status, progress):
pass
def startSoftwareTools(self, callback = None):
if callback is not None:
self.NotifierCallback = callback
if eNetworkManager.getInstance().online():
self.NetworkConnectionAvailable = True
self.getUpdates()
else:
self.NetworkConnectionAvailable = False
self.getUpdates()
def getUpdates(self, callback = None):
if self.lastDownloadDate is None:
etpm = eTPM()
l2cert = etpm.getData(eTPM.DT_LEVEL2_CERT)
if l2cert is None:
return
l2key = validate_cert(l2cert, rootkey)
if l2key is None:
return
l3cert = etpm.getData(eTPM.DT_LEVEL3_CERT)
if l3cert is None:
return
l3key = validate_cert(l3cert, l2key)
if l3key is None:
return
rnd = read_random()
if rnd is None:
return
val = etpm.computeSignature(rnd)
result = decrypt_block(val, l3key)
if result[80:88] == rnd:
if self.NetworkConnectionAvailable == True:
self.lastDownloadDate = time()
if self.list_updating is False and callback is None:
self.list_updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is False and callback is not None:
self.list_updating = True
self.NotifierCallback = callback
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is True and callback is not None:
self.NotifierCallback = callback
else:
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
else:
self.NetworkConnectionAvailable = False
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
else:
if self.NetworkConnectionAvailable == True:
self.lastDownloadDate = time()
if self.list_updating is False and callback is None:
self.list_updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is False and callback is not None:
self.list_updating = True
self.NotifierCallback = callback
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is True and callback is not None:
self.NotifierCallback = callback
else:
if self.list_updating and callback is not None:
etpm = eTPM()
l2cert = etpm.getData(eTPM.DT_LEVEL2_CERT)
if l2cert is None:
return
l2key = validate_cert(l2cert, rootkey)
if l2key is None:
return
l3cert = etpm.getData(eTPM.DT_LEVEL3_CERT)
if l3cert is None:
return
l3key = validate_cert(l3cert, l2key)
if l3key is None:
return
rnd = read_random()
if rnd is None:
return
val = etpm.computeSignature(rnd)
result = decrypt_block(val, l3key)
if result[80:88] == rnd:
self.NotifierCallback = callback
self.startIpkgListAvailable()
else:
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.list_updating = False
if self.NotifierCallback is not None:
self.NotifierCallback(False)
elif event == IpkgComponent.EVENT_DONE:
if self.list_updating:
self.startIpkgListAvailable()
#print event, "-", param
pass
def startIpkgListAvailable(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = "opkg list | grep -e '^[a-z][a-z0-9+.-]'"
self.UpdateConsole.ePopen(cmd, self.IpkgListAvailableCB, callback)
def IpkgListAvailableCB(self, result, retval, extra_args = None):
(callback) = extra_args
if result:
if self.list_updating:
self.available_packetlist = []
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 1 and tokens[1].strip() or ""
descr = l > 2 and tokens[2].strip() or ""
self.available_packetlist.append([name, version, descr])
if callback is None:
self.startInstallMetaPackage()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def startInstallMetaPackage(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if self.NetworkConnectionAvailable == True:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = "opkg install enigma2-meta enigma2-plugins-meta enigma2-skins-meta"
self.UpdateConsole.ePopen(cmd, self.InstallMetaPackageCB, callback)
else:
self.InstallMetaPackageCB(True)
def InstallMetaPackageCB(self, result, retval = None, extra_args = None):
(callback) = extra_args
if result:
self.fillPackagesIndexList()
if callback is None:
self.startIpkgListInstalled()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def startIpkgListInstalled(self, callback = None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = "opkg list-installed"
self.UpdateConsole.ePopen(cmd, self.IpkgListInstalledCB, callback)
def IpkgListInstalledCB(self, result, retval, extra_args = None):
(callback) = extra_args
if result:
self.installed_packetlist = {}
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 1 and tokens[1].strip() or ""
self.installed_packetlist[name] = version
for package in self.packagesIndexlist[:]:
if not self.verifyPrerequisites(package[0]["prerequisites"]):
self.packagesIndexlist.remove(package)
for package in self.packagesIndexlist[:]:
attributes = package[0]["attributes"]
if attributes.has_key("packagetype"):
if attributes["packagetype"] == "internal":
self.packagesIndexlist.remove(package)
if callback is None:
self.listUpgradable()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def listUpgradable(self, callback = None):
self.list_updating = True
if not self.UpgradeConsole:
self.UpgradeConsole = Console()
cmd = "opkg list-upgradable"
self.UpgradeConsole.ePopen(cmd, self.listUpgradableCB, callback)
def listUpgradableCB(self, result, retval, extra_args = None):
(callback) = extra_args
self.upgradable_packages = {}
self.available_updates = 0
self.available_updatelist = []
if result:
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 2 and tokens[2].strip() or ""
self.upgradable_packages[name] = version
for package in self.packagesIndexlist[:]:
attributes = package[0]["attributes"]
packagename = attributes["packagename"]
for x in self.available_packetlist:
if x[0] == packagename:
if self.installed_packetlist.has_key(packagename):
if self.installed_packetlist[packagename] != x[1]:
self.available_updates +=1
self.available_updatelist.append([packagename])
self.list_updating = False
if self.upgradable_packages:
self.upgradeAvailable = True
if self.UpgradeConsole:
if len(self.UpgradeConsole.appContainers) == 0:
if callback is not None:
callback(True)
callback = None
elif self.NotifierCallback is not None:
self.NotifierCallback(True)
self.NotifierCallback = None
def cleanupSoftwareTools(self):
self.list_updating = False
if self.NotifierCallback is not None:
self.NotifierCallback = None
self.ipkg.stop()
if self.Console is not None:
if len(self.Console.appContainers):
for name in self.Console.appContainers.keys():
self.Console.kill(name)
if self.UpdateConsole is not None:
if len(self.UpdateConsole.appContainers):
for name in self.UpdateConsole.appContainers.keys():
self.UpdateConsole.kill(name)
if self.UpgradeConsole is not None:
if len(self.UpgradeConsole.appContainers):
for name in self.UpgradeConsole.appContainers.keys():
self.UpgradeConsole.kill(name)
def verifyPrerequisites(self, prerequisites):
if prerequisites.has_key("hardware"):
hardware_found = False
for hardware in prerequisites["hardware"]:
if hardware == self.hardware_info.device_name:
hardware_found = True
if not hardware_found:
return False
return True
class UpdatePlugin(Screen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
self.sliderPackages = {
"dreambox-dvb-modules": 1,
"enigma2": 2,
"tuxbox-image-info": 3
}
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, True)
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
message = ""
picon = None
default = True
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
if getBoxType() in urlopen(
"http://openpli.org/status").read().split(','):
message = _(
"The current beta image might not be stable.\nFor more information see %s."
) % ("www.openpli.org")
picon = MessageBox.TYPE_ERROR
default = False
except:
message = _(
"The status of the current beta image could not be checked because %s can not be reached."
) % ("www.openpli.org")
picon = MessageBox.TYPE_ERROR
default = False
socket.setdefaulttimeout(currentTimeoutDefault)
if default:
self.startActualUpdate(True)
else:
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate,
MessageBox,
message,
default=default,
picon=picon)
def getLatestImageTimestamp(self):
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
latestImageTimestamp = ""
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
latestImageTimestamp = re.findall(
'<dd>(.*?)</dd>',
urlopen("http://openpli.org/download/" + getBoxType() +
"/").read())[0][:16]
latestImageTimestamp = time.strftime(
_("%d-%b-%Y %-H:%M"),
time.strptime(latestImageTimestamp, "%Y/%m/%d %H:%M"))
except:
pass
socket.setdefaulttimeout(currentTimeoutDefault)
return latestImageTimestamp
def startActualUpdate(self, answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(
ngettext("Update completed, %d package was installed.",
"Update completed, %d packages were installed.",
self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(
_("Upgrading") + ": %s/%s" %
(self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in (
"N", "Y"):
self.ipkg.write(
True and
config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback, MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?"
) % (param))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
latestImageTimestamp = self.getLatestImageTimestamp()
if latestImageTimestamp:
message = _(
"Do you want to update your receiver to %s?"
) % self.getLatestImageTimestamp() + "\n"
else:
message = _(
"Do you want to update your receiver?") + "\n"
message = message + "(" + (ngettext(
"%s updated package available",
"%s updated packages available", self.total_packages) %
self.total_packages) + ")"
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
(_("Update channel list only"), "channels"),
(_("Cancel"), "")]
self.session.openWithCallback(self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices)
else:
self.session.openWithCallback(self.close,
MessageBox,
_("No updates available"),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(
_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
"Your receiver might be unusable now. Please consult the manual for further assistance before rebooting your receiver."
)
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _(
"Update failed. Your receiver does not have a working internet connection."
)
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[
0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST,
args={'installed_only': True})
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE,
args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(
self.exitAnswer, MessageBox,
_("Update completed. Do you want to reboot your receiver?")
)
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class UpdatePlugin(Screen, ProtectedScreen):
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
Screen.setTitle(self, _('Software Update'))
self.sliderPackages = {'ini-dvb-modules': 1,
'enigma2': 2,
'tuxbox-image-info': 3}
self.slider = Slider(0, 4)
self['slider'] = self.slider
self.activityslider = Slider(0, 100)
self['activityslider'] = self.activityslider
self.status = StaticText(_('Please wait...'))
self['status'] = self.status
self.package = StaticText(_('Package list update'))
self['package'] = self.package
self.oktext = _('Press OK on your remote control to continue.')
self['tl_off'] = Pixmap()
self['tl_red'] = Pixmap()
self['tl_yellow'] = Pixmap()
self['tl_green'] = Pixmap()
self['feedStatusMSG'] = Label()
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.onFirstExecBegin.append(self.checkNetworkState)
def checkNetworkState(self):
self.trafficLight = feedsstatuscheck.getFeedsBool()
status_msgs = {'stable': _('Feeds status: Stable'),
'unstable': _('Feeds status: Unstable'),
'updating': _('Feeds status: Updating'),
'-2': _('ERROR: No network found'),
'404': _('ERROR: No internet found'),
'inprogress': _('ERROR: Check is already running in background'),
'unknown': _('No connection')}
self['tl_red'].hide()
self['tl_yellow'].hide()
self['tl_green'].hide()
self['tl_off'].hide()
if self.trafficLight:
self['feedStatusMSG'].setText(status_msgs[str(self.trafficLight)])
if self.trafficLight == 'stable':
self['tl_green'].show()
elif self.trafficLight == 'unstable':
self['tl_red'].show()
elif self.trafficLight == 'updating':
self['tl_yellow'].show()
else:
self['tl_off'].show()
if self.trafficLight not in ('stable', 'unstable'):
self.session.openWithCallback(self.close, MessageBox, feedsstatuscheck.getFeedsErrorMessage(), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif config.softwareupdate.updateisunstable.value == '1' and config.softwareupdate.updatebeta.value or config.softwareupdate.updateisunstable.value == '0':
self.startCheck()
else:
self.session.openWithCallback(self.close, MessageBox, _('Sorry feeds seem to be in an unstable state, if you wish to use them please enable \'Allow unstable (experimental) updates\' in "Software update settings".'), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
def startCheck(self):
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.updating = False
self['actions'] = ActionMap(['WizardActions'], {'ok': self.exit,
'back': self.exit}, -1)
self.updating = True
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and (not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and config.ParentalControl.config_sections.software_update.value
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext('Update completed, %d package was installed.', 'Update completed, %d packages were installed.', self.packages) % self.packages)
def ipkgCallback(self, event, param):
global ocram
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_('Downloading'))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_('Upgrading') + ': %s/%s' % (self.packages, self.total_packages))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_('Installing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_('Removing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_('Configuring'))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ('N', 'Y'):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(self.modificationCallback, MessageBox, _('A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?') % param)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = None
self.total_packages = len(self.ipkg.getFetchedList())
message = _('Do you want to update your %s %s ?') % (getMachineBrand(), getMachineName()) + '\n(' + ngettext('%s updated package available', '%s updated packages available', self.total_packages) % self.total_packages + ')'
if self.total_packages > 150:
message += ' ' + _('Reflash recommended!')
if self.total_packages:
for package_tmp in self.ipkg.getFetchedList():
if package_tmp[0].startswith('enigma2-plugin-picons-tv-ocram'):
ocram = ocram + '[ocram-picons] ' + package_tmp[0].split('enigma2-plugin-picons-tv-ocram.')[1] + 'updated ' + package_tmp[2] + '\n'
elif package_tmp[0].startswith('enigma2-plugin-settings-ocram'):
ocram = ocram + '[ocram-settings] ' + package_tmp[0].split('enigma2-plugin-picons-tv-ocram.')[1] + 'updated ' + package_tmp[2] + '\n'
config.softwareupdate.updatefound.setValue(True)
choices = [(_('View the changes'), 'changes'), (_('Update and ask to reboot'), 'hot'), (_('Upgrade and reboot system'), 'cold')]
if path.exists('/usr/lib/enigma2/python/Plugins/SystemPlugins/ViX/BackupManager.pyo'):
if not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_('Perform a settings backup,') + '\n\t' + _('making a backup before updating') + '\n\t' + _('is strongly advised.'), 'backup'))
if not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_('Perform a full image backup'), 'imagebackup'))
choices.append((_('Update channel list only'), 'channels'))
choices.append((_('Cancel'), ''))
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name='SoftwareUpdateChoices', var=self.trafficLight)
upgrademessage.setTitle(_('Software update'))
else:
upgrademessage = self.session.openWithCallback(self.close, MessageBox, _('Nothing to upgrade'), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
upgrademessage.setTitle(_('Software update'))
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_('Could not find installed channel list.'))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _('Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s.') % (getMachineBrand(),
getMachineName(),
getMachineBrand(),
getMachineName())
if self.packages == 0:
error = _('A background update check is in progress,\nplease wait a few minutes and try again.')
if self.updating:
error = _('Update failed. Your %s %s does not have a working internet connection.') % (getMachineBrand(), getMachineName())
self.status.setText(_('Error') + ' - ' + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == 'menu':
message = _('Do you want to update your %s %s ?') % (getMachineBrand(), getMachineName()) + '\n(%s ' % self.total_packages + _('Packages') + ')'
choices = [(_('View the changes'), 'changes'), (_('Update and ask to reboot'), 'hot'), (_('Upgrade and reboot system'), 'cold')]
choices.append((_('Update channel list only'), 'channels'))
choices.append((_('Cancel'), ''))
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name='SoftwareUpdateChoices', var=self.trafficLight)
upgrademessage.setTitle(_('Software update'))
elif answer[1] == 'changes':
from Plugins.Extensions.EGAMINews.plugin import EGAMIMainNews
self.session.openWithCallback(self.startActualUpgrade, EGAMIMainNews)
elif answer[1] == 'backup':
self.doSettingsBackup()
elif answer[1] == 'imagebackup':
self.doImageBackup()
elif answer[1] == 'channels':
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args={'installed_only': True})
elif answer[1] == 'cold':
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and 'N' or 'Y')
def doSettingsBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.BackupManager import BackupFiles
self.BackupFiles = BackupFiles(self.session, True)
Components.Task.job_manager.AddJob(self.BackupFiles.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('vix', 'Backup Manager'):
break
self.showJobView(job)
def doImageBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.ImageManager import ImageBackup
self.ImageBackup = ImageBackup(self.session, True)
Components.Task.job_manager.AddJob(self.ImageBackup.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('vix', 'Image Manager'):
break
self.showJobView(job)
def doAutoBackup(self, val = False):
self.autobackuprunning = True
if config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value and not self.SettingsBackupDone:
self.doSettingsBackup()
elif config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value and not self.ImageBackupDone:
self.doImageBackup()
else:
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
def showJobView(self, job):
if job.name == dgettext('vix', 'Image Manager'):
self.ImageBackupDone = True
elif job.name == dgettext('vix', 'Backup Manager'):
self.SettingsBackupDone = True
from Screens.TaskView import JobView
Components.Task.job_manager.in_background = False
if not self.autobackuprunning:
self.session.openWithCallback(self.startActualUpgrade(('menu', 'menu')), JobView, job, cancelable=False, backgroundable=False, afterEventChangeable=False, afterEvent='close')
else:
self.session.openWithCallback(self.doAutoBackup, JobView, job, cancelable=False, backgroundable=False, afterEventChangeable=False, afterEvent='close')
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _('Upgrade finished.') + ' ' + _('Do you want to reboot your %s %s') % (getMachineBrand(), getMachineName()))
else:
self.close()
elif not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
class DreamInfoHandler:
STATUS_WORKING = 0
STATUS_DONE = 1
STATUS_ERROR = 2
STATUS_INIT = 4
PACKAGES = []
def __init__(self,
statusCallback,
blocking=False,
neededTag=None,
neededFlag=None):
self.hardware_info = HardwareInfo()
self.directory = "/"
self.neededTag = neededTag
self.neededFlag = neededFlag
# caution: blocking should only be used, if further execution in enigma2 depends on the outcome of
# the installer!
self.blocking = blocking
self.currentlyInstallingMetaIndex = None
self.console = eConsoleAppContainer()
self.appClosed_conn = self.console.appClosed.connect(self.installNext)
self.reloadFavourites = False
self.statusCallback = statusCallback
self.setStatus(self.STATUS_INIT)
self.packageslist = []
def _getPackageDetails(self):
return DreamInfoHandler.PACKAGES
packageDetails = property(_getPackageDetails)
packagesIndexlist = property(_getPackageDetails)
def buildPackageIndex(self):
DreamInfoHandler.PACKAGES = []
files = crawlDirectory("/usr/share/meta", "(plugin|skin)\_.*\.xml")
for d, f in files:
d = "%s/" % (d, )
f = "%s%s" % (d, f)
self.readDetails(d, f)
def readInfo(self, directory, file):
print("Reading .info file", file)
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageslist.append((entry, file))
except InfoHandlerParseError:
print("file", file, "ignored due to errors in the file")
#print handler.list
def readDetails(self, directory, file):
Log.i("Reading .xml meta details file '%s'" % (file, ))
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
entry["attributes"]["details"] = file
DreamInfoHandler.PACKAGES.append((entry, file))
except InfoHandlerParseError:
print("file", file, "ignored due to errors in the file")
#print handler.list
# prerequisites = True: give only packages matching the prerequisites
def fillPackagesList(self, prerequisites=True):
self.packageslist = []
packages = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for directory in self.directory:
packages += crawlDirectory(directory, ".*\.info$")
for package in packages:
self.readInfo(package[0] + "/", package[0] + "/" + package[1])
if prerequisites:
for package in self.packageslist[:]:
if not self.prerequisiteMet(package[0]["prerequisites"]):
self.packageslist.remove(package)
return self.packageslist
# prerequisites = True: give only packages matching the prerequisites
def fillPackagesIndexList(self, prerequisites=True):
self.buildPackageIndex()
return self.packagesIndexlist
# prerequisites = True: give only packages matching the prerequisites
def getPackageDetails(self, details=None):
if not DreamInfoHandler.PACKAGES:
Log.w("Building index first!")
self.buildPackageIndex()
if details:
for p in DreamInfoHandler.PACKAGES:
if p[1] == details:
Log.i("details=%s, file=%s" % (details, p))
return p[0]
else:
return DreamInfoHandler.PACKAGES
def prerequisiteMet(self, prerequisites):
# TODO: we need to implement a hardware detection here...
print("prerequisites:", prerequisites)
if self.neededTag is None:
if "tag" in prerequisites:
return False
elif self.neededTag == 'ALL_TAGS':
return True
else:
if "tag" in prerequisites:
if not self.neededTag in prerequisites["tag"]:
return False
else:
return False
if self.neededFlag is None:
if "flag" in prerequisites:
return False
else:
if "flag" in prerequisites:
if not self.neededFlag in prerequisites["flag"]:
return False
else:
return True # No flag found, assuming all flags valid
if "satellite" in prerequisites:
for sat in prerequisites["satellite"]:
if int(sat) not in nimmanager.getConfiguredSats():
return False
if "bcastsystem" in prerequisites:
has_system = False
for bcastsystem in prerequisites["bcastsystem"]:
if nimmanager.hasNimType(bcastsystem):
has_system = True
if not has_system:
return False
if "hardware" in prerequisites:
hardware_found = False
for hardware in prerequisites["hardware"]:
if hardware == self.hardware_info.device_name:
hardware_found = True
if not hardware_found:
return False
if "eth0mac" in prerequisites:
nm = eNetworkManager.getInstance()
for service in nm.getServices():
ethernet = NetworkInterface(service).ethernet
if ethernet.interface == "eth0":
if ethernet.mac != prerequisites["eth0mac"]:
return False
return True
def installPackages(self, indexes):
print("installing packages", indexes)
if len(indexes) == 0:
self.setStatus(self.STATUS_DONE)
return
self.installIndexes = indexes
print("+++++++++++++++++++++++bla")
self.currentlyInstallingMetaIndex = 0
self.installPackage(
self.installIndexes[self.currentlyInstallingMetaIndex])
def installPackage(self, index):
print("self.packageslist:", self.packageslist)
if len(self.packageslist) <= index:
print("no package with index", index,
"found... installing nothing")
return
print("installing package with index", index, "and name",
self.packageslist[index][0]["attributes"]["name"])
attributes = self.packageslist[index][0]["attributes"]
self.installingAttributes = attributes
self.attributeNames = [
"skin", "config", "favourites", "package", "services"
]
self.currentAttributeIndex = 0
self.currentIndex = -1
self.installNext()
def setStatus(self, status):
self.status = status
self.statusCallback(self.status, None)
def installNext(self, *args, **kwargs):
if self.reloadFavourites:
self.reloadFavourites = False
eDVBDB.getInstance().reloadBouquets()
self.currentIndex += 1
attributes = self.installingAttributes
#print "attributes:", attributes
if self.currentAttributeIndex >= len(
self.attributeNames): # end of package reached
print("end of package reached")
if self.currentlyInstallingMetaIndex is None or self.currentlyInstallingMetaIndex >= len(
self.installIndexes) - 1:
print("set status to DONE")
self.setStatus(self.STATUS_DONE)
return
else:
print("increment meta index to install next package")
self.currentlyInstallingMetaIndex += 1
self.currentAttributeIndex = 0
self.installPackage(
self.installIndexes[self.currentlyInstallingMetaIndex])
return
self.setStatus(self.STATUS_WORKING)
print("currentAttributeIndex:", self.currentAttributeIndex)
currentAttribute = self.attributeNames[self.currentAttributeIndex]
print("installing", currentAttribute, "with index", self.currentIndex)
if currentAttribute in attributes:
if self.currentIndex >= len(
attributes[currentAttribute]
): # all jobs done for current attribute
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
else: # nothing to install here
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
if currentAttribute == "skin":
skin = attributes["skin"][self.currentIndex]
self.installSkin(skin["directory"], skin["name"])
elif currentAttribute == "config":
if self.currentIndex == 0:
from Components.config import configfile
configfile.save()
configAttributes = attributes["config"][self.currentIndex]
self.mergeConfig(configAttributes["directory"],
configAttributes["name"])
elif currentAttribute == "favourites":
favourite = attributes["favourites"][self.currentIndex]
self.installFavourites(favourite["directory"], favourite["name"])
elif currentAttribute == "package":
package = attributes["package"][self.currentIndex]
self.installIPK(package["directory"], package["name"])
elif currentAttribute == "services":
service = attributes["services"][self.currentIndex]
self.mergeServices(service["directory"], service["name"])
def readfile(self, filename):
if not os.path.isfile(filename):
return []
fd = open(filename)
lines = fd.readlines()
fd.close()
return lines
def mergeConfig(self, directory, name, merge=True):
print("merging config:", directory, " - ", name)
if os.path.isfile(directory + name):
config.loadFromFile(directory + name, append=merge)
configfile.save()
self.installNext()
def installIPK(self, directory, name):
if self.blocking:
os.system("opkg install " + directory + name)
self.installNext()
else:
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': directory + name})
def ipkgCallback(self, event, param):
print("ipkgCallback")
if event == IpkgComponent.EVENT_DONE:
self.installNext()
elif event == IpkgComponent.EVENT_ERROR:
self.installNext()
def installSkin(self, directory, name):
print("installing skin:", directory, " - ", name)
print("cp -a %s %s" % (directory, resolveFilename(SCOPE_SKIN)))
if self.blocking:
copytree(directory, resolveFilename(SCOPE_SKIN))
self.installNext()
else:
if self.console.execute("cp -a %s %s" %
(directory, resolveFilename(SCOPE_SKIN))):
print("execute failed")
self.installNext()
def mergeServices(self, directory, name, merge=False):
print("merging services:", directory, " - ", name)
if os.path.isfile(directory + name):
db = eDVBDB.getInstance()
db.reloadServicelist()
db.loadServicelist(directory + name)
db.saveServicelist()
self.installNext()
def installFavourites(self, directory, name):
print("installing favourites:", directory, " - ", name)
self.reloadFavourites = True
if self.blocking:
copyfile(directory + name, resolveFilename(SCOPE_CONFIG))
self.installNext()
else:
if self.console.execute(
"cp %s %s" %
((directory + name), resolveFilename(SCOPE_CONFIG))):
print("execute failed")
self.installNext()
class UpdatePlugin(Screen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,200" title="Software update" >
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,60" size="540,45" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, args = None):
Screen.__init__(self, session)
self.sliderPackages = { "Settop Box-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Upgrading Settop Box... Please wait"))
self["status"] = self.status
self.package = StaticText()
self["package"] = self.package
self.packages = 0
self.error = 0
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self.firsttime = True
self.onShown.append(self.confirmUpdate)
def confirmUpdate(self):
if self.firsttime:
self.firsttime = False
self.session.openWithCallback(self.confirmationResult, MessageBox, _("Do you want to upgrade?"))
def confirmationResult(self, result):
if not result:
self.close()
else:
self.activityTimer.start(100, False)
self.updating = True
self.package.setText(_("Package list update"))
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading"))
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) was modified since Installation.\nDo you want to keep your version?") % (param)
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args = {'test_only': False})
elif self.error == 0:
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText("")
self.status.setText(_("Done - Installed or upgraded %d packages") % self.packages)
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("your Settop Box might be unusable now. Please consult the manual for further assistance before rebooting your Settop Box.")
if self.packages == 0:
error = _("No packages were upgraded yet. So you can check your network and try again.")
if self.updating:
error = _("Your Settop Box isn't connected to the internet properly. Please check it and try again.")
self.status.setText(_("Error") + " - " + error)
#print event, "-", param
pass
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Upgrade finished. Do you want to reboot your Settop Box?"))
else:
self.close()
def exitAnswer(self, result):
if result is not None and result:
quitMainloop(2)
self.close()
class FeedsStatusCheck:
def __init__(self):
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def IsInt(self, val):
try:
int(val)
return True
except ValueError:
return False
def getFeedSatus(self):
status = '1'
trafficLight = 'unknown'
if about.getIfConfig('eth0').has_key('addr') or about.getIfConfig(
'eth1').has_key('addr') or about.getIfConfig('wlan0').has_key(
'addr') or about.getIfConfig('ra0').has_key('addr'):
try:
print '[OnlineVersionCheck] Checking feeds state'
req = urllib2.Request(
'http://openvix.co.uk/TrafficLightState.php')
d = urllib2.urlopen(req)
trafficLight = d.read()
except urllib2.HTTPError as err:
print '[OnlineVersionCheck] ERROR:', err
trafficLight = err.code
except urllib2.URLError as err:
print '[OnlineVersionCheck] ERROR:', err.reason[0]
trafficLight = err.reason[0]
except urllib2 as err:
print '[OnlineVersionCheck] ERROR:', err
trafficLight = err
except:
print '[OnlineVersionCheck] ERROR:', sys.exc_info()[0]
trafficLight = -2
if not self.IsInt(trafficLight) and getImageType() != 'release':
trafficLight = 'unknown'
elif trafficLight == 'stable':
status = '0'
config.softwareupdate.updateisunstable.setValue(status)
print '[OnlineVersionCheck] PASSED:', trafficLight
return trafficLight
else:
print '[OnlineVersionCheck] ERROR: -2'
return -2
def getFeedsBool(self):
global error
feedstatus = feedsstatuscheck.getFeedSatus()
if feedstatus in (-2, 403, 404):
print '[OnlineVersionCheck] Error %s' % feedstatus
return feedstatus
if error:
print '[OnlineVersionCheck] Check already in progress'
return 'inprogress'
if feedstatus == 'updating':
print '[OnlineVersionCheck] Feeds Updating'
return 'updating'
if feedstatus in ('stable', 'unstable', 'unknown'):
print '[OnlineVersionCheck]', feedstatus.title()
return str(feedstatus)
def getFeedsErrorMessage(self):
feedstatus = feedsstatuscheck.getFeedsBool()
if feedstatus == -2:
return _(
'Your %s %s has no network access, please check your network settings and make sure you have network cable connected and try again.'
) % (getMachineBrand(), getMachineName())
if feedstatus == 404:
return _(
'Your %s %s is not connected to the internet, please check your network settings and try again.'
) % (getMachineBrand(), getMachineName())
if feedstatus in ('updating', 403):
return _(
'Sorry feeds are down for maintenance, please try again later. If this issue persists please check www.egami-image.com'
)
if error:
return _(
'There has been an error, please try again later. If this issue persists, please check www.egami-image.com'
)
def startCheck(self):
global error
error = 0
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
global error
config.softwareupdate.updatefound.setValue(False)
if event == IpkgComponent.EVENT_ERROR:
error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages and (
getImageType() != 'release'
or config.softwareupdate.updateisunstable.value == '1'
and config.softwareupdate.updatebeta.value or
config.softwareupdate.updateisunstable.value == '0'):
print '[OnlineVersionCheck] %s Updates available' % self.total_packages
config.softwareupdate.updatefound.setValue(True)
class OnlineUpdateCheckPoller:
def __init__(self):
# Init Timer
self.timer = eTimer()
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def start(self):
if self.onlineupdate_check not in self.timer.callback:
self.timer.callback.append(self.onlineupdate_check)
if time() > 1262304000:
self.timer.startLongTimer(0)
else:
self.timer.startLongTimer(120)
def stop(self):
if self.version_check in self.timer.callback:
self.timer.callback.remove(self.onlineupdate_check)
self.timer.stop()
def onlineupdate_check(self):
if config.softwareupdate.check.getValue():
Components.Task.job_manager.AddJob(self.createCheckJob())
self.timer.startLongTimer(config.softwareupdate.checktimer.getValue() *
3600)
def createCheckJob(self):
job = Components.Task.Job(_("OnlineVersionCheck"))
task = Components.Task.PythonTask(job, _("Checking for Updates..."))
task.work = self.JobStart
task.weighting = 1
return job
def JobStart(self):
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
print('[OnlineVersionCheck] %s Updates available' %
self.total_packages)
if self.total_packages:
from urllib import urlopen
import socket
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
config.softwareupdate.updatefound.setValue(True)
try:
config.softwareupdate.updateisunstable.setValue(
urlopen("http://www.droidsat.org/status").read())
except:
config.softwareupdate.updateisunstable.setValue(1)
socket.setdefaulttimeout(currentTimeoutDefault)
else:
config.softwareupdate.updatefound.setValue(False)
else:
config.softwareupdate.updatefound.setValue(False)
pass
class UpdatePlugin(Screen, ProtectedScreen):
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
Screen.setTitle(self, _('Software Update'))
self['actions'] = ActionMap(['WizardActions'], {'ok': self.exit,
'back': self.exit
}, -1)
self['actions'].csel = self
self['actions'].setEnabled(False)
self.sliderPackages = {'ini-dvb-modules': 1,'enigma2': 2,'tuxbox-image-info': 3}
self.slider = Slider(0, 4)
self['slider'] = self.slider
self.activityslider = Slider(0, 100)
self['activityslider'] = self.activityslider
self.status = StaticText(_('Please wait...'))
self['status'] = self.status
self.package = StaticText(_('Package list update'))
self['package'] = self.package
self.oktext = _('Press OK on your remote control to continue.')
self['tl_off'] = Pixmap()
self['tl_red'] = Pixmap()
self['tl_yellow'] = Pixmap()
self['tl_green'] = Pixmap()
self['feedStatusMSG'] = Label()
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.updating = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.onFirstExecBegin.append(self.checkNetworkState)
return
def checkNetworkState(self):
self.trafficLight = feedsstatuscheck.getFeedsBool()
status_msgs = {'stable': _('Feeds status: Stable'),'unstable': _('Feeds status: Unstable'),'updating': _('Feeds status: Updating'),'-2': _('ERROR: No network found'),'404': _('ERROR: No internet found'),'inprogress': _('ERROR: Check is already running in background'),'unknown': _('Feeds status: Unkown')}
self['tl_red'].hide()
self['tl_yellow'].hide()
self['tl_green'].hide()
self['tl_off'].hide()
if self.trafficLight:
self['feedStatusMSG'].setText(status_msgs[str(self.trafficLight)])
if self.trafficLight == 'stable':
self['tl_green'].show()
elif self.trafficLight == 'unstable':
self['tl_red'].show()
elif self.trafficLight == 'updating':
self['tl_yellow'].show()
else:
self['tl_off'].show()
if getImageType() != 'release' and self.trafficLight != 'unknown' or getImageType() == 'release' and self.trafficLight not in ('stable',
'unstable'):
self.session.openWithCallback(self.close, MessageBox, feedsstatuscheck.getFeedsErrorMessage(), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif getImageType() != 'release' or config.softwareupdate.updateisunstable.value == '1' and config.softwareupdate.updatebeta.value or config.softwareupdate.updateisunstable.value == '0':
self.startCheck()
else:
self.session.openWithCallback(self.close, MessageBox, _('Sorry the feeds seem to be in an unstable state, if you wish to use them please enable \'Allow unstable (experimental) updates\' in "Software update settings".'), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
def startCheck(self):
self.updating = True
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and (not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and config.ParentalControl.config_sections.software_update.value
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext('Update completed, %d package was installed.', 'Update completed, %d packages were installed.', self.packages) % self.packages)
def ipkgCallback(self, event, param):
global ocram
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_('Downloading'))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_('Upgrading') + ': %s/%s' % (self.packages, self.total_packages))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_('Installing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_('Removing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_('Configuring'))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ('N', 'Y'):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self['actions'].setEnabled(True)
self.session.openWithCallback(self.modificationCallback, MessageBox, _('A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?') % param)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = None
self.total_packages = len(self.ipkg.getFetchedList())
message = _('Do you want to update your %s %s ?') % (getMachineBrand(), getMachineName()) + '\n(' + ngettext('%s updated package available', '%s updated packages available', self.total_packages) % self.total_packages + ')'
if self.total_packages > 150:
message += ' ' + _('Reflash recommended!')
if self.total_packages:
for package_tmp in self.ipkg.getFetchedList():
if package_tmp[0].startswith('enigma2-plugin-picons-tv-ocram'):
ocram = ocram + '[ocram-picons] ' + package_tmp[0].split('enigma2-plugin-picons-tv-ocram.')[1] + 'updated ' + package_tmp[2] + '\n'
elif package_tmp[0].startswith('enigma2-plugin-settings-ocram'):
ocram = ocram + '[ocram-settings] ' + package_tmp[0].split('enigma2-plugin-picons-tv-ocram.')[1] + 'updated ' + package_tmp[2] + '\n'
config.softwareupdate.updatefound.setValue(True)
choices = [(_('View the changes'), 'changes'),
(
_('Update and ask to reboot'), 'hot'),
(
_('Upgrade and reboot system'), 'cold')]
if path.exists('/usr/lib/enigma2/python/Plugins/SystemPlugins/ViX/BackupManager.pyo'):
if not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_('Perform a settings backup,') + '\n\t' + _('making a backup before updating') + '\n\t' + _('is strongly advised.'), 'backup'))
if not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_('Perform a full image backup'), 'imagebackup'))
choices.append((_('Update channel list only'), 'channels'))
choices.append((_('Cancel'), ''))
self['actions'].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name='SoftwareUpdateChoices', var=self.trafficLight)
upgrademessage.setTitle(_('Software update'))
else:
self['actions'].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.close, MessageBox, _('Nothing to upgrade'), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
upgrademessage.setTitle(_('Software update'))
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_('Could not find installed channel list.'))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _('Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s.') % (getMachineBrand(), getMachineName(), getMachineBrand(), getMachineName())
if self.packages == 0:
error = _('A background update check is in progress,\nplease wait a few minutes and try again.')
if self.updating:
error = _('Update failed. Your %s %s does not have a working internet connection.') % (getMachineBrand(), getMachineName())
self.status.setText(_('Error') + ' - ' + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
return
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == 'menu':
message = _('Do you want to update your %s %s ?') % (getMachineBrand(), getMachineName()) + '\n(%s ' % self.total_packages + _('Packages') + ')'
choices = [(_('View the changes'), 'changes'),
(
_('Update and ask to reboot'), 'hot'),
(
_('Upgrade and reboot system'), 'cold')]
choices.append((_('Update channel list only'), 'channels'))
choices.append((_('Cancel'), ''))
self['actions'].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name='SoftwareUpdateChoices', var=self.trafficLight)
upgrademessage.setTitle(_('Software update'))
elif answer[1] == 'changes':
from Plugins.Extensions.EGAMINews.plugin import EGAMIMainNews
self.session.openWithCallback(self.startActualUpgrade, EGAMIMainNews)
elif answer[1] == 'backup':
self.doSettingsBackup()
elif answer[1] == 'imagebackup':
self.doImageBackup()
elif answer[1] == 'channels':
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args={'installed_only': True})
elif answer[1] == 'cold':
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and 'N' or 'Y')
def doSettingsBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.BackupManager import BackupFiles
self.BackupFiles = BackupFiles(self.session, True)
Components.Task.job_manager.AddJob(self.BackupFiles.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('vix', 'Backup Manager'):
break
self.showJobView(job)
return
def doImageBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.ImageManager import ImageBackup
self.ImageBackup = ImageBackup(self.session, True)
Components.Task.job_manager.AddJob(self.ImageBackup.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('vix', 'Image Manager'):
break
self.showJobView(job)
return
def doAutoBackup(self, val=False):
self.autobackuprunning = True
if config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value and not self.SettingsBackupDone:
self.doSettingsBackup()
elif config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value and not self.ImageBackupDone:
self.doImageBackup()
else:
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
def showJobView(self, job):
if job.name == dgettext('vix', 'Image Manager'):
self.ImageBackupDone = True
elif job.name == dgettext('vix', 'Backup Manager'):
self.SettingsBackupDone = True
from Screens.TaskView import JobView
Components.Task.job_manager.in_background = False
if not self.autobackuprunning:
self.session.openWithCallback(self.startActualUpgrade(('menu', 'menu')), JobView, job, cancelable=False, backgroundable=False, afterEventChangeable=False, afterEvent='close')
else:
self.session.openWithCallback(self.doAutoBackup, JobView, job, cancelable=False, backgroundable=False, afterEventChangeable=False, afterEvent='close')
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _('Upgrade finished.') + ' ' + _('Do you want to reboot your %s %s') % (getMachineBrand(), getMachineName()))
else:
self.close()
elif not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
return
class UpdatePlugin(Screen, ProtectedScreen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
self.sliderPackages = {
"dreambox-dvb-modules": 1,
"enigma2": 2,
"tuxbox-image-info": 3
}
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, True)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and\
(not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and\
config.ParentalControl.config_sections.software_update.value
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
message = ""
picon = None
default = True
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
url = "https://openpli.org/status/"
try:
status = urlopen(url, timeout=5).read().split('!', 1)
except:
# OpenPli 5.0 uses python 2.7.11 and here we need to bypass the certificate check
from ssl import _create_unverified_context
status = urlopen(
url, timeout=5,
context=_create_unverified_context()).read().split('!', 1)
print status
if getBoxType() in status[0].split(','):
message = len(status) > 1 and status[1] or _(
"The current beta image might not be stable.\nFor more information see %s."
) % ("www.openpli.org")
picon = MessageBox.TYPE_ERROR
default = False
except:
message = _(
"The status of the current beta image could not be checked because %s can not be reached."
) % ("www.openpli.org")
picon = MessageBox.TYPE_ERROR
default = False
socket.setdefaulttimeout(currentTimeoutDefault)
if default:
self.showDisclaimer()
else:
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate,
MessageBox,
message,
default=default,
picon=picon)
def showDisclaimer(self, justShow=False):
if config.usage.show_update_disclaimer.value or justShow:
message = _(
"The OpenPLi team would like to point out that upgrading to the latest nightly build comes not only with the latest features, but also with some risks. After the update, it is possible that your device no longer works as expected. We recommend you create backups with Autobackup or Backupsuite. This allows you to quickly and easily restore your device to its previous state, should you experience any problems. If you encounter a 'bug', please report the issue on www.openpli.org.\n\nDo you understand this?"
)
list = not justShow and [
(_("no"), False), (_("yes"), True),
(_("yes") + " " + _("and never show this message again"),
"never")
] or []
self.session.openWithCallback(boundFunction(
self.disclaimerCallback, justShow),
MessageBox,
message,
list=list,
title=_("Disclaimer"))
else:
self.startActualUpdate(True)
def disclaimerCallback(self, justShow, answer):
if answer == "never":
config.usage.show_update_disclaimer.value = False
config.usage.show_update_disclaimer.save()
if justShow and answer:
self.ipkgCallback(IpkgComponent.EVENT_DONE, None)
else:
self.startActualUpdate(answer)
def getLatestImageTimestamp(self):
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
from time import strftime
from datetime import datetime
imageVersion = about.getImageTypeString().split(" ")[1]
imageVersion = (int(imageVersion) < 5 and "%.1f"
or "%s") % int(imageVersion)
url = "https://openpli.org/download/timestamp/%s~%s" % (
HardwareInfo().get_device_model(), imageVersion)
try:
latestImageTimestamp = datetime.fromtimestamp(
int(urlopen(url, timeout=5).read())).strftime(
_("%Y-%m-%d %H:%M"))
except:
# OpenPli 5.0 uses python 2.7.11 and here we need to bypass the certificate check
from ssl import _create_unverified_context
latestImageTimestamp = datetime.fromtimestamp(
int(
urlopen(url,
timeout=5,
context=_create_unverified_context()).read())
).strftime(_("%Y-%m-%d %H:%M"))
except:
latestImageTimestamp = ""
socket.setdefaulttimeout(currentTimeoutDefault)
return latestImageTimestamp
def startActualUpdate(self, answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(
ngettext("Update completed, %d package was installed.",
"Update completed, %d packages were installed.",
self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if param in self.sliderPackages:
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(
_("Upgrading") + ": %s/%s" %
(self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in (
"N", "Y"):
self.ipkg.write(
True and
config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback, MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?"
) % (param))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
latestImageTimestamp = self.getLatestImageTimestamp()
if latestImageTimestamp:
message = _(
"Do you want to update your receiver to %s?"
) % self.getLatestImageTimestamp() + "\n"
else:
message = _(
"Do you want to update your receiver?") + "\n"
message += "(" + (ngettext(
"%s updated package available",
"%s updated packages available", self.total_packages) %
self.total_packages) + ")"
if self.total_packages > 150:
message += " " + _("Reflash recommended!")
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
(_("Update channel list only"), "channels"),
(_("Show packages to be upgraded"), "showlist")]
else:
message = _("No updates available")
choices = []
if fileExists("/home/root/ipkgupgrade.log"):
choices.append((_("Show latest upgrade log"), "log"))
choices.append((_("Show latest commits"), "commits"))
if not config.usage.show_update_disclaimer.value:
choices.append((_("Show disclaimer"), "disclaimer"))
choices.append((_("Cancel"), ""))
self.session.openWithCallback(self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices,
windowTitle=self.title)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(
_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
"Your receiver might be unusable now. Please consult the manual for further assistance before rebooting your receiver."
)
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _(
"Update failed. Your receiver does not have a working internet connection."
)
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[
0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST,
args={'installed_only': True})
elif answer[1] == "commits":
self.session.openWithCallback(
boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE,
None), CommitInfo)
elif answer[1] == "disclaimer":
self.showDisclaimer(justShow=True)
elif answer[1] == "showlist":
text = "\n".join([
x[0]
for x in sorted(self.ipkg.getFetchedList(), key=lambda d: d[0])
])
self.session.openWithCallback(
boundFunction(self.ipkgCallback,
IpkgComponent.EVENT_DONE, None), TextBox, text,
_("Packages to update"), True)
elif answer[1] == "log":
text = open("/home/root/ipkgupgrade.log", "r").read()
self.session.openWithCallback(
boundFunction(self.ipkgCallback,
IpkgComponent.EVENT_DONE, None), TextBox, text,
_("Latest upgrade log"), True)
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE,
args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(
self.exitAnswer, MessageBox,
_("Update completed. Do you want to reboot your receiver?")
)
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class DaemonsList(Screen):
def __init__(self, session, args = 0):
Screen.__init__(self, session)
self.running = list()
self.installed = list()
self.daemons = list()
self['menu'] = ExtrasList(list())
self['menu'].onSelectionChanged.append(self.selectionChanged)
self['key_green'] = Button('')
self['key_red'] = Button('')
self['key_blue'] = Button(_('Exit'))
self['key_yellow'] = Button('')
self['actions'] = ActionMap(['OkCancelActions', 'ColorActions'], {'blue': self.quit,
'yellow': self.yellow,
'red': self.red,
'green': self.green,
'cancel': self.quit}, -2)
self.onFirstExecBegin.append(self.drawList)
self.onShown.append(self.setWindowTitle)
def setWindowTitle(self):
self.setTitle(_('Daemons'))
def selectionChanged(self):
if len(self.daemons) > 0:
index = self['menu'].getSelectionIndex()
if self.installed[index]:
if self.running[index]:
self['key_red'].setText(_('Stop'))
else:
self['key_red'].setText(_('Start'))
if self.daemons[index][6]:
self['key_yellow'].setText(_('Configure'))
else:
self['key_yellow'].setText('')
self['key_green'].setText('')
else:
self['key_red'].setText('')
self['key_yellow'].setText('')
if self.daemons[index][9]:
self['key_green'].setText(_('Install'))
else:
self['key_green'].setText('')
def drawList(self, ret = None):
self.session.open(ExtraActionBox, _('Checking daemons status...'), _('Daemons'), self.actionDrawList)
def actionDrawList(self):
self.ishowed = True
if len(self.daemons) == 0:
self.loadList()
self.checkInstalled()
self.checkRunning()
list = []
i = 0
for daemon in self.daemons:
list.append(DaemonEntry(daemon[0], 'Daemons/%s' % daemon[2], daemon[1], self.running[i], self.installed[i]))
i += 1
self['menu'].setList(list)
def checkRunning(self):
self.running = list()
for daemon in self.daemons:
self.running.append(daemon[3]())
def checkInstalled(self):
self.installed = list()
for daemon in self.daemons:
self.installed.append(daemon[7]())
def loadList(self):
self.daemons = list()
tdaemons = crawlDirectory('%s/Daemons/' % os.path.dirname(sys.modules[__name__].__file__), '.*\\.ext$')
tdaemons.sort()
for daemon in tdaemons:
if daemon[1][:1] != '.':
try:
src = open(os.path.join(daemon[0], daemon[1]))
exec src.read()
src.close()
self.daemons.append((daemon_name,
daemon_description,
daemon_icon,
daemon_fnc_status,
daemon_fnc_start,
daemon_fnc_stop,
daemon_class_config,
daemon_fnc_installed,
daemon_fnc_boot,
daemon_package))
except TypeError:
print '[CTPanel] Could not parse daemonlist while Directory crawl. Please check .ext Files for errors.'
def yellow(self):
index = self['menu'].getSelectionIndex()
try:
if self.installed[index]:
if self.daemons[index][6]:
if self.daemons[index][6] == 'XTOpenvpn':
from plugin import XTOpenvpn
self.session.open(XTOpenvpn)
elif self.daemons[index][6] == 'NFSServerSetup':
from Plugins.PLi.NFSServer.plugin import NFSServerSetup
self.session.open(NFSServerSetup)
elif self.daemons[index][6] == 'XTCronMang':
from plugin import XTCronMang
self.session.open(XTCronMang)
elif self.daemons[index][6] == 'XTNTPdConf':
self.session.open(MessageBox, _('Please visit the following Website:\nhttp://linux-fuer-alle.de/doc_show.php?docid=7\nto gain further instructions how to configure your STB as NTP-Client/Server.'), MessageBox.TYPE_INFO)
except IndexError:
print '[XTPANEL] no Daemon .ext files found.'
def green(self):
index = self['menu'].getSelectionIndex()
if not self.installed[index]:
if self.daemons[index][9]:
filename = self.daemons[index][9]
self.oktext = _('\nAfter pressing OK, please wait!')
self.cmdList = []
if not fileExists('/var/lib/opkg/openpli-all') and not fileExists('/var/lib/opkg/openpli-mipsel') and not fileExists('/var/lib/opkg/openpli-3rd-party'):
self.ipkg = IpkgComponent()
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
sleep(5)
self.cmdList.append((IpkgComponent.CMD_INSTALL, {'package': filename}))
if len(self.cmdList):
self.session.openWithCallback(self.runUpgrade, MessageBox, _('Do you want to install the package:\n') + filename + '\n' + self.oktext)
def red(self):
if len(self.daemons) > 0:
index = self['menu'].getSelectionIndex()
if self.running[index]:
self.session.openWithCallback(self.drawList, ExtraActionBox, _('Stopping %s...') % self.daemons[index][0], _('Daemons'), self.startstop)
else:
self.session.openWithCallback(self.drawList, ExtraActionBox, _('Starting %s...') % self.daemons[index][0], _('Daemons'), self.startstop)
def startstop(self):
if len(self.daemons) > 0:
index = self['menu'].getSelectionIndex()
if self.installed[index]:
if self.running[index]:
self.daemons[index][5]()
else:
self.daemons[index][4]()
self.daemons[index][8](self.daemons[index][3]())
def quit(self):
self.close()
def runUpgrade(self, result):
if result:
self.session.openWithCallback(self.runUpgradeFinished, Ipkg, cmdList=self.cmdList)
def runUpgradeFinished(self):
self.session.openWithCallback(self.UpgradeReboot, MessageBox, _('Installation/Upgrade finished.') + ' ' + _('Do you want to restart Enigma2?'), MessageBox.TYPE_YESNO)
def UpgradeReboot(self, result):
if result is None or result is False:
self.session.open(ExtraActionBox, _('Checking daemons status...'), _('Daemons'), self.actionDrawList)
if result:
quitMainloop(3)
class UpdatePlugin(Screen, ProtectedScreen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
self.sliderPackages = { "gigablue-": 1, "enigma2": 2, "teamblue-": 3 }
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, True)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and\
(not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and\
config.ParentalControl.config_sections.software_update.value
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
message = ""
picon = None
default = True
url = "http://images.teamblue.tech/status/%s-%s/" % (getImageVersion(), getImageType())
# print "[SoftwareUpdate] url status: ", url
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
try:
status = urlopen(url, timeout=5).read().split('!', 1)
print status
except:
# bypass the certificate check
from ssl import _create_unverified_context
status = urlopen(url, timeout=5, context=_create_unverified_context()).read().split('!', 1)
print status
# prefer getMachineBuild
if getMachineBuild() in status[0].split(','):
message = len(status) > 1 and status[1] or _("The current software might not be stable.\nFor more information see %s.") % ("http://images.teamblue.tech")
picon = MessageBox.TYPE_ERROR
default = False
# only use getBoxType if no getMachineBuild
elif getBoxType() in status[0].split(','):
message = len(status) > 1 and status[1] or _("The current software might not be stable.\nFor more information see %s.") % ("http://images.teamblue.tech")
picon = MessageBox.TYPE_ERROR
default = False
except:
message = _("The status of the current software could not be checked because %s can not be reached.") % ("http://images.teamblue.tech")
picon = MessageBox.TYPE_ERROR
default = False
if default:
self.showDisclaimer()
else:
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate, MessageBox, message, default = default, picon = picon)
def showDisclaimer(self, justShow=False):
if config.usage.show_update_disclaimer.value or justShow:
message = _("With this disclaimer the teamBlue team is informing you that we are working with nightly builds and it might be that after the upgrades your set top box \
is not anymore working as expected. Therefore it is recommended to create backups. If something went wrong you can easily and quickly restore. \
If you discover 'bugs' please keep them reported on www.teamblue.tech.\n\nDo you understand this?")
list = not justShow and [(_("no"), False), (_("yes"), True), (_("yes") + " " + _("and never show this message again"), "never")] or []
self.session.openWithCallback(boundFunction(self.disclaimerCallback, justShow), MessageBox, message, list=list, title=_("Disclaimer"))
else:
self.startActualUpdate(True)
def disclaimerCallback(self, justShow, answer):
if answer == "never":
config.usage.show_update_disclaimer.value = False
config.usage.show_update_disclaimer.save()
if justShow and answer:
self.ipkgCallback(IpkgComponent.EVENT_DONE, None)
else:
self.startActualUpdate(answer)
def getLatestImageTimestamp(self):
url = "http://images.teamblue.tech/status/%s-%s/buildtimestamp-%s" % (getImageVersion(), getImageType(), getBoxType())
# print "[SoftwareUpdate] url buildtimestamp: ", url
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
from time import strftime
from datetime import datetime
try:
latestImageTimestamp = datetime.fromtimestamp(int(urlopen(url, timeout=5).read())).strftime(_("%Y-%m-%d %H:%M"))
except:
# bypass the certificate check
from ssl import _create_unverified_context
latestImageTimestamp = datetime.fromtimestamp(int(urlopen(url, timeout=5, context=_create_unverified_context()).read())).strftime(_("%Y-%m-%d %H:%M"))
except:
latestImageTimestamp = ""
print "[SoftwareUpdate] latestImageTimestamp:", latestImageTimestamp
return latestImageTimestamp
def startActualUpdate(self,answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if param in self.sliderPackages:
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % (param)
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
latestImageTimestamp = self.getLatestImageTimestamp()
if latestImageTimestamp:
message = _("Latest available teamBlue %s build is from: %s") % (getImageVersion(), self.getLatestImageTimestamp()) + "\n"
message += _("Do you want to update your receiver?") + "\n"
else:
message = _("Do you want to update your receiver?") + "\n"
message += "(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
if self.total_packages > 150:
message += " " + _("Reflash recommended!")
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
#(_("Update channel list only"), "channels"),
(_("Show packages to be upgraded"), "showlist")]
else:
message = _("No updates available")
choices = []
if fileExists("/home/root/ipkgupgrade.log"):
choices.append((_("Show latest upgrade log"), "log"))
choices.append((_("Show latest commits"), "commits"))
if not config.usage.show_update_disclaimer.value:
choices.append((_("Show disclaimer"), "disclaimer"))
choices.append((_("Cancel"), ""))
self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, windowTitle=self.title)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your receiver might be unusable now. Please consult the manual for further assistance before rebooting your receiver.")
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _("Update failed. Your receiver does not have a working internet connection.")
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
elif answer[1] == "commits":
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), CommitInfo)
elif answer[1] == "disclaimer":
self.showDisclaimer(justShow=True)
elif answer[1] == "showlist":
text = "\n".join([x[0] for x in sorted(self.ipkg.getFetchedList(), key=lambda d: d[0])])
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), TextBox, text, _("Packages to update"), True)
elif answer[1] == "log":
text = open("/home/root/ipkgupgrade.log", "r").read()
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), TextBox, text, _("Packages upgraded"), True)
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args = {'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Update completed. Do you want to reboot your receiver?"))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class PurePrestigeFlashBackupUpdateCheck(Screen):
try:
sz_w = getDesktop(0).size().width()
except:
sz_w = 720
if sz_w == 1280:
skin = '\n <screen name="PPFlashBackupUpdateCheck" position="center,center" size="1280,720" title="Software update">\n <widget source="Title" render="Label" position="80,80" size="450,30" zPosition="3" font="Regular;22" transparent="1"/>\n <widget source="session.VideoPicture" render="Pig" position="80,120" size="380,215" zPosition="3" backgroundColor="#ff000000"/>\n <widget source="package" render="Label" position="550,130" size="660,28" font="Regular;24" backgroundColor="#25062748" transparent="1"/>\n <widget source="status" render="Label" position="550,170" size="660,56" font="Regular;24" backgroundColor="#25062748" transparent="1"/>\n <widget name="slider" position="550,290" size="660,20" borderWidth="1" transparent="1"/>\n <widget name="activityslider" position="43,670" size="1194,6" transparent="1"/>\n </screen>'
elif sz_w == 1024:
skin = '\n <screen name="PPFlashBackupUpdateCheck" position="center,center" size="1024,576" title="Software update">\n <widget name="activityslider" position="0,0" size="550,5"/>\n <widget name="slider" position="0,150" size="550,30"/>\n <widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1"/>\n <widget source="status" render="Label" position="10,60" size="540,45" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1"/>\n </screen>'
else:
skin = '\n <screen name="PPFlashBackupUpdateCheck" position="center,center" size="550,300" title="Software update" >\n <widget name="activityslider" position="0,0" size="550,5"/>\n <widget name="slider" position="0,150" size="550,30"/>\n <widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1"/>\n <widget source="status" render="Label" position="10,60" size="540,45" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1"/>\n </screen>'
def __init__(self, session, args=None):
Screen.__init__(self, session)
self.sliderPackages = {
'dreambox-dvb-modules': 1,
'enigma2': 2,
'tuxbox-image-info': 3
}
self.slider = Slider(0, 4)
self['slider'] = self.slider
self.activityslider = Slider(0, 100)
self['activityslider'] = self.activityslider
self.status = StaticText(_('Upgrading Dreambox... Please wait'))
self['status'] = self.status
self.package = StaticText()
self['package'] = self.package
self.oktext = _('Press OK on your remote control to continue.')
self.packages = 0
self.error = 0
self.processed_packages = []
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(100, False)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.updating = True
self.package.setText(_('Package list update'))
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
self['actions'] = ActionMap(['WizardActions'], {
'ok': self.exit,
'back': self.exit
}, -1)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_('Downloading'))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_('Upgrading'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_('Installing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_('Removing'))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_('Configuring'))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.SoftwareManager.overwriteConfigFiles.value in (
'N', 'Y'):
self.ipkg.write(
True and
config.plugins.SoftwareManager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback, MessageBox,
_('A configuration file (%s) was modified since Installation.\nDo you want to keep your version?'
) % param)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE,
args={'test_only': False})
elif self.error == 0:
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText('')
self.status.setText(
_('Done - Installed or upgraded %d packages') %
self.packages + '\n\n' + self.oktext)
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
'your dreambox might be unusable now. Please consult the manual for further assistance before rebooting your dreambox.'
)
if self.packages == 0:
error = _(
'No packages were upgraded yet. So you can check your network and try again.'
)
if self.updating:
error = _(
"Your dreambox isn't connected to the internet properly. Please check it and try again."
)
self.status.setText(_('Error') + ' - ' + error)
def modificationCallback(self, res):
self.ipkg.write(res and 'N' or 'Y')
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0:
self.session.openWithCallback(
self.exitAnswer, MessageBox,
_('Upgrade finished.') + ' ' +
_('Do you want to reboot your Dreambox?'))
else:
self.close()
def exitAnswer(self, result):
if result is not None and result:
quitMainloop(2)
self.close()
return
def cancel(self):
self.close(None)
return
class Ipkg(Screen):
def __init__(self, session, cmdList=None):
if not cmdList: cmdList = []
Screen.__init__(self, session)
self.cmdList = cmdList
self.sliderPackages = {}
self.slider = Slider(0, len(cmdList))
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = Label(_("Preparing... Please wait"))
self["status"] = self.status
self.package = Label()
self["package"] = self.package
self.packages = 0
self.error = 0
self.processed_packages = []
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
#self.activityTimer.start(100, False)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.runningCmd = None
self.runNextCmd()
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
def runNextCmd(self):
if self.runningCmd is None:
self.runningCmd = 0
else:
self.runningCmd += 1
print len(self.cmdList), self.runningCmd
if len(self.cmdList) - 1 < self.runningCmd:
self.activityslider.setValue(0)
self.slider.setValue(len(self.cmdList))
self.package.setText("")
self.status.setText(ngettext("Done - Installed, upgraded or removed %d package (%s)", "Done - Installed, upgraded or removed %d packages (%s)", self.packages) % (self.packages, ngettext("with %d error", "with %d errors", self.error) % self.error))
return False
else:
cmd = self.cmdList[self.runningCmd]
self.slider.setValue(self.runningCmd)
self.ipkg.startCmd(cmd[0], args = cmd[1])
self.startActivityTimer()
def doActivityTimer(self):
if not self.ipkg.isRunning():
self.stopActivityTimer()
else:
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def startActivityTimer(self):
self.activityTimer.start(100, False)
def stopActivityTimer(self):
self.activityTimer.stop()
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
self.runNextCmd()
elif event == IpkgComponent.EVENT_MODIFIED:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) was modified since Installation.\nDo you want to keep your version?") % param
)
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
self.close()
class SoftwarePanel(Screen):
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("OpenXTA Software Panel"))
skin = """
<screen name="SoftwarePanel" position="center,center" size="650,605" title="Software Panel">
<widget name="a_off" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/ExtrasPanel/pics/aoff.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_red" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/ExtrasPanel/pics/ared.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_yellow" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/ExtrasPanel/pics/ayellow.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_green" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/ExtrasPanel/pics/agreen.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="feedstatusRED" position="60,14" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="feedstatusYELLOW" position="60,46" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="feedstatusGREEN" position="60,78" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="packagetext" position="276,50" size="247,30" zPosition="1" font="Regular;25" halign="right" transparent="1" />
<widget name="packagenr" position="529,50" size="69,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget source="list" render="Listbox" position="10,120" size="630,365" scrollbarMode="showOnDemand">
<convert type="TemplatedMultiContent">
{"template": [
MultiContentEntryText(pos = (5, 1), size = (540, 28), font=0, flags = RT_HALIGN_LEFT, text = 0), # index 0 is the name
MultiContentEntryText(pos = (5, 26), size = (540, 20), font=1, flags = RT_HALIGN_LEFT, text = 2), # index 2 is the description
MultiContentEntryPixmapAlphaTest(pos = (545, 2), size = (48, 48), png = 4), # index 4 is the status pixmap
MultiContentEntryPixmapAlphaTest(pos = (5, 50), size = (610, 2), png = 5), # index 4 is the div pixmap
],
"fonts": [gFont("Regular", 22),gFont("Regular", 14)],
"itemHeight": 52
}
</convert>
</widget>
<ePixmap pixmap="skin_default/buttons/red.png" position="30,560" size="138,40" alphatest="blend" />
<widget name="key_green_pic" pixmap="skin_default/buttons/green.png" position="180,560" size="138,40" alphatest="blend" />
<ePixmap pixmap="skin_default/buttons/yellow.png" position="333,560" size="138,40" alphatest="blend" />
<ePixmap pixmap="skin_default/buttons/blue.png" position="481,560" size="138,40" alphatest="blend" />
<widget name="key_red" position="38,570" size="124,26" zPosition="1" font="Regular;17" halign="center" transparent="1" />
<widget name="key_green" position="188,570" size="124,26" zPosition="1" font="Regular;17" halign="center" transparent="1" />
<widget name="key_yellow" position="340,570" size="124,26" zPosition="1" font="Regular;17" halign="center" transparent="1" />
<widget name="key_blue" position="491,570" size="124,26" zPosition="1" font="Regular;17" halign="center" transparent="1" />
</screen> """
self.skin = skin
self.list = []
self.statuslist = []
self["list"] = List(self.list)
self['a_off'] = Pixmap()
self['a_red'] = Pixmap()
self['a_yellow'] = Pixmap()
self['a_green'] = Pixmap()
self['key_green_pic'] = Pixmap()
self['key_red_pic'] = Pixmap()
self['key_red'] = Label(_("Cancel"))
self['key_green'] = Label(_("Update"))
self['key_yellow'] = Label(_(""))
self['key_blue'] = Label(_("Setup Commits"))
self['packagetext'] = Label(_("Updates Available:"))
self['packagenr'] = Label("0")
self['feedstatusRED'] = Label("< " + _("feed status"))
self['feedstatusYELLOW'] = Label("< " + _("feed status"))
self['feedstatusGREEN'] = Label("< " + _("feed status"))
self['key_green'].hide()
self['key_green_pic'].hide()
self.update = False
self.packages = 0
self.trafficLight = 0
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ColorActions", "SetupActions"],
{
"cancel": self.Exit,
"green": self.Green,
"blue": self.showCommitLogSetup,
"yellow": self.showCommitLog
}, -2)
if config.CommitInfoSetup.commiturl.value == 'Enigma2':
self["key_yellow"].setText("E2 Commits")
elif config.CommitInfoSetup.commiturl.value == 'XTA':
self["key_yellow"].setText("XTA Commits")
elif config.CommitInfoSetup.commiturl.value == 'TechniHD':
self["key_yellow"].setText("THD Commits")
elif config.CommitInfoSetup.commiturl.value == 'Metrix':
self["key_yellow"].setText("Metrix Commits")
self.onLayoutFinish.append(self.layoutFinished)
def Exit(self):
self.ipkg.stop()
self.close()
def Green(self):
if self.packages > 0 and self.trafficLight > 0:
if self.trafficLight == 1: # yellow
message = _("The current image might not be stable.\nFor more information see %s.") % ("www.xtrend-alliance.com")
picon = MessageBox.TYPE_WARNING
elif self.trafficLight == 2: # red
message = _("The current image is not stable.\nFor more information see %s.") % ("www.xtrend-alliance.com")
picon = MessageBox.TYPE_ERROR
self.session.open(MessageBox, message, type=MessageBox.TYPE_ERROR, picon=picon, timeout = 15, close_on_any_key=True)
return
elif self.trafficLight == 3: # unknown
message = _("The status of the current image could not be checked because %s can not be reached.") % ("www.xtrend-alliance.com")
picon = MessageBox.TYPE_ERROR
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate, MessageBox, message, default = False, picon = picon)
elif self.packages > 0:
self.startActualUpdate(True)
def showCommitLog(self):
self.session.open(CommitInfo)
def showCommitLogSetup(self):
self.session.openWithCallback(self.commitinfoupdate, CommitInfoSetup)
def commitinfoupdate(self):
if config.CommitInfoSetup.commiturl.value == 'Enigma2':
self["key_yellow"].setText("E2 Commits")
elif config.CommitInfoSetup.commiturl.value == 'XTA':
self["key_yellow"].setText("XTA Commits")
elif config.CommitInfoSetup.commiturl.value == 'TechniHD':
self["key_yellow"].setText("THD Commits")
elif config.CommitInfoSetup.commiturl.value == 'Metrix':
self["key_yellow"].setText("Metrix Commits")
def startActualUpdate(self, answer):
if answer:
from Plugins.SystemPlugins.SoftwareManager.plugin import UpdatePlugin
self.session.open(UpdatePlugin)
self.close()
def layoutFinished(self):
self.checkTrafficLight()
self.rebuildList()
def UpdatePackageNr(self):
self.packages = len(self.list)
print self.packages
print"packagenr" + str(self.packages)
self["packagenr"].setText(str(self.packages))
if self.packages == 0:
self['key_green'].hide()
self['key_green_pic'].hide()
else:
self['key_green'].show()
self['key_green_pic'].show()
def checkTrafficLight(self):
print"checkTrafficLight"
from urllib import urlopen
import socket
self['a_red'].hide()
self['a_yellow'].hide()
self['a_green'].hide()
self['feedstatusRED'].hide()
self['feedstatusYELLOW'].hide()
self['feedstatusGREEN'].hide()
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
try:
urlOpenXta = "http://feed.openxta.com/status"
d = urlopen(urlOpenXta)
self.trafficLight = int(d.read())
if self.trafficLight == 2:
self['a_off'].hide()
self['a_red'].show()
self['feedstatusRED'].show()
elif self.trafficLight == 1:
self['a_off'].hide()
self['a_yellow'].show()
self['feedstatusYELLOW'].show()
elif self.trafficLight == 0:
self['a_off'].hide()
self['a_green'].show()
self['feedstatusGREEN'].show()
except:
self.trafficLight = 3
self['a_off'].show()
socket.setdefaulttimeout(currentTimeoutDefault)
def setStatus(self,status = None):
if status:
self.statuslist = []
divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/div-h.png"))
if status == 'update':
statuspng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/upgrade.png"))
self.statuslist.append(( _("Package list update"), '', _("Trying to download a new updatelist. Please wait..." ),'',statuspng, divpng ))
elif status == 'error':
statuspng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/remove.png"))
self.statuslist.append(( _("Error"), '', _("There was an error downloading the updatelist. Please try again." ),'',statuspng, divpng ))
elif status == 'noupdate':
statuspng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/installed.png"))
self.statuslist.append(( _("Nothing to upgrade"), '', _("There are no updates available." ),'',statuspng, divpng ))
self['list'].setList(self.statuslist)
def rebuildList(self):
self.setStatus('update')
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.setStatus('error')
elif event == IpkgComponent.EVENT_DONE:
if self.update == False:
self.update = True
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
else:
self.buildPacketList()
pass
def buildEntryComponent(self, name, version, description, state):
divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/div-h.png"))
if not description:
description = "No description available."
if state == 'installed':
installedpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/installed.png"))
return((name, version, _(description), state, installedpng, divpng))
elif state == 'upgradeable':
upgradeablepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/upgradeable.png"))
return((name, version, _(description), state, upgradeablepng, divpng))
else:
installablepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/installable.png"))
return((name, version, _(description), state, installablepng, divpng))
def buildPacketList(self):
self.list = []
fetchedList = self.ipkg.getFetchedList()
if len(fetchedList) > 0:
for x in fetchedList:
try:
self.list.append(self.buildEntryComponent(x[0], x[1], x[2], "upgradeable"))
except:
print "[SOFTWAREPANEL] " + x[0] + " no valid architecture, ignoring !!"
self['list'].setList(self.list)
elif len(fetchedList) == 0:
self.setStatus('noupdate')
else:
self.setStatus('error')
self.UpdatePackageNr()
class MyPluginManager(Screen):
def __init__(self, session, plugin_path, args = 0):
Screen.__init__(self, session)
self.session = session
self.skin_path = plugin_path
self.wanted_extensions_base = ('enigma2', 'kernel-module')
self.wanted_extensions = self.wanted_extensions_base
self['shortcuts'] = ActionMap(['ShortcutActions', 'WizardActions'], {'ok': self.go,
'back': self.exit,
'red': self.exit,
'green': self.reloadinfo,
'yellow': self.doInstall}, -1)
self.list = []
self.statuslist = []
self['list'] = List(self.list)
self['key_red'] = StaticText(_('Close'))
self['key_green'] = Label()
self['key_green'].setText(_('reload package data'))
self['key_yellow'] = Label()
self['key_yellow'].setText('')
self.title = _('Download or delete Software')
try:
self['title'] = StaticText(self.title)
except:
print 'self["title"] was not found in skin'
self.start_vc = 0
self.list_updating = True
self.plugin_list_state = False
self.first_run = True
self.replacename = None
self.greenpressed = False
self.packetlist = []
self.installed_packetlist = {}
self.Console = ComConsole()
self.cmdList = []
self.changeList = []
self.changed = False
self.doSoftwareAction = False
self.opkgupdated = False
self.upgradablelist = []
self.cachelist = []
self.cache_ttl = 21600
self.cache_file = '/tmp/packetsoftwaremanager.cache'
self.oktext = _('\nAfter pressing OK, please wait!')
self.unwanted_extensions = ('-dbg', '-dev', '-doc', 'busybox')
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onShown.append(self.setWindowTitle)
self.onLayoutFinish.append(self.rebuildList)
if self.selectionChanged not in self['list'].onSelectionChanged:
self['list'].onSelectionChanged.append(self.selectionChanged)
def getFreeSpace(self, mountpoint):
if mountpoint:
stat_info = statvfs(mountpoint)
free_flash_space = stat_info.f_bfree * stat_info.f_bsize
return free_flash_space
def checkFreeSpace(self):
free_flash_space = self.getFreeSpace('/')
if free_flash_space < 8000000:
human_free_space = free_flash_space / 1048576
msg = _('There are only %d MB free FLASH space available\nInstalling or updating software can cause serious software problems !\nContinue installing/updating software (at your own risk) ?') % human_free_space
self.session.openWithCallback(self.cbSpaceCheck, MessageBox, msg)
def cbSpaceCheck(self, result):
if not result:
if os_path.exists(self.cache_file) == True:
remove(self.cache_file)
self.close()
def exit(self):
self.ipkg.stop()
if self.Console is not None:
if len(self.Console.appContainers):
for name in self.Console.appContainers.keys():
self.Console.kill(name)
if self.plugin_list_state == True and self.doSoftwareAction == False:
self.setStatus('startmenu')
elif self.plugin_list_state == True and self.doSoftwareAction == True:
self['list'].setList(self.list)
elif self.plugin_list_state == False and self.doSoftwareAction == True:
self.setStatus('startmenu')
else:
if os_path.exists(self.cache_file) == True:
remove(self.cache_file)
self.reloadPluginlist()
self.close()
self.doSoftwareAction = False
if len(self.cmdList):
self['key_yellow'].setText(_('Excecute'))
def reloadinfo(self):
if self.plugin_list_state == True:
self.greenpressed = True
self.go()
else:
self.replacename = None
if os_path.exists(self.cache_file) == True:
remove(self.cache_file)
self.list_updating = True
self.rebuildList()
def setWindowTitle(self, title = None):
if not title:
title = self.title
try:
self['title'] = StaticText(title)
except:
print 'self["title"] was not found in skin'
def selectionChanged(self):
if self.plugin_list_state == True:
current = self['list'].getCurrent()
if current:
if current[3] == 'installed':
self['key_green'].setText(_('Remove'))
elif current[3] == 'installable':
self['key_green'].setText(_('Install'))
elif current[3] == 'upgradeable':
self['key_green'].setText(_('Upgrade'))
else:
self['key_green'].setText('')
elif self.doSoftwareAction == False:
self['key_green'].setText(_('reload package data'))
def setStatus(self, status = None):
if status:
self.statuslist = []
self.plugin_list_state = False
divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_SKIN_IMAGE, '750S/div-h.png'))
if status == 'update':
statuspng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/installable.png'))
self.statuslist.append((_('Package list update'),
'',
_('Trying to download a new packetlist. Please wait...'),
'',
statuspng,
divpng))
self['list'].setList(self.statuslist)
elif status == 'error':
statuspng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/remove.png'))
self.statuslist.append((_('Error'),
'',
_('There was an error downloading the packetlist. Please try again.'),
'',
statuspng,
divpng))
self['list'].setList(self.statuslist)
elif status == 'startmenu':
self.statuslist.append((_('Extensions'),
'',
_('install/remove common plugins'),
'extensions',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_plugin.png')),
divpng))
self.statuslist.append((_('Systemplugins'),
'',
_('install/remove systemplugins'),
'systemplugins',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_systemplugin.png')),
divpng))
self.statuslist.append((_('Skins'),
'',
_('install/remove skins to change look of OSD'),
'skins',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_skin.png')),
divpng))
self.statuslist.append((_('SoftCams'),
'',
_('install/remove softcams'),
'softcams',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_softcam.png')),
divpng))
self.statuslist.append((_('Configurations'),
'',
_('install/remove configuration files for softcams'),
'configs',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_softcam_config.png')),
divpng))
self.statuslist.append((_('Picons'),
'',
_('install/remove picons for OSD and graphical VFD'),
'picons',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_picon.png')),
divpng))
self.statuslist.append((_('Settings'),
'',
_('install/remove channel lists'),
'settings',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_channel.png')),
divpng))
self.statuslist.append((_('Kernel modules'),
'',
_('install/remove kernel modules'),
'kernel',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_kernel.png')),
divpng))
self.statuslist.append((_('Language packages'),
'',
_('install/remove language packages for dvbapp2'),
'locale',
LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/sm_world.png')),
divpng))
self['list'].setList(self.statuslist)
def rebuildList(self):
self.changed = False
self.cmdList = []
self.changeList = []
self.upgradablelist = []
self['key_yellow'].setText('')
self.setStatus('update')
self.inv_cache = 0
if self.start_vc != 0:
self.vc = valid_cache(self.cache_file, self.cache_ttl)
else:
self.vc = 0
if self.cache_ttl > 0 and self.vc != 0:
try:
self.buildPacketList()
except:
self.inv_cache = 1
if self.cache_ttl == 0 or self.inv_cache == 1 or self.vc == 0:
self.run = 0
self.wanted_extensions = self.wanted_extensions_base
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def go(self, returnValue = None):
cur = self['list'].getCurrent()
self.submenulist = ('systemplugins', 'extensions', 'skins', 'picons', 'settings', 'softcams', 'configs', 'drivers', 'kernel', 'locale')
if cur:
if self.doSoftwareAction == True:
if self.greenpressed == True:
self.greenpressed = False
self.runInstall()
elif cur[3] in self.submenulist:
self.plugin_list_state = True
if cur[3] == 'systemplugins':
self.wanted_extensions = 'enigma2-plugin-systemplugins-'
elif cur[3] == 'extensions':
self.wanted_extensions = 'enigma2-plugin-extensions-'
elif cur[3] == 'kernel':
self.wanted_extensions = 'kernel-module-'
elif cur[3] == 'skins':
self.wanted_extensions = 'enigma2-plugin-skin-'
elif cur[3] == 'picons':
self.wanted_extensions = 'enigma2-plugin-picons-'
elif cur[3] == 'settings':
self.wanted_extensions = 'enigma2-plugin-settings-'
elif cur[3] == 'softcams':
self.wanted_extensions = 'enigma2-plugin-cams-'
elif cur[3] == 'configs':
self.wanted_extensions = 'enigma2-plugin-config-'
elif cur[3] == 'drivers':
self.wanted_extensions = 'enigma2-plugin-drivers-'
elif cur[3] == 'locale':
self.wanted_extensions = 'enigma2-locale-'
self.replacename = self.wanted_extensions
self.vc = valid_cache(self.cache_file, self.cache_ttl)
self.buildPacketList()
self.setStatus(None)
else:
status = cur[3]
if self.replacename is not None:
package = self.wanted_extensions + cur[0]
else:
package = cur[0]
if status == 'upgradeable':
self.upgradablelist.append(package)
self.changecmdList = True
item = self['list'].getIndex()
curcache = [package,
cur[1],
cur[2],
cur[3]]
for cmdListitem in self.cmdList:
if str(cmdListitem).find(package) != -1:
self.cmdList.remove(cmdListitem)
self.changecmdList = False
if package in self.upgradablelist:
self.changecmdList = True
if package in self.changeList:
self.changeList.remove(package)
self.changed = False
else:
self.changeList.append(package)
self.changed = True
if status == 'installed':
if self.changed == True or package in self.upgradablelist:
self.list[item] = self.buildEntryComponent(cur[0], cur[1], cur[2], 'goremove')
else:
self.list[item] = self.buildEntryComponent(cur[0], cur[1], cur[2], 'installable')
try:
cacheindex = self.cachelist.index(curcache)
self.cachelist[cacheindex] = [package,
cur[1],
cur[2],
'installable']
except:
print '[VTI SoftwareManager] failed to modify packetcachefile'
self['key_green'].setText(_('Install'))
if self.changecmdList == True:
expert_args = ''
if config.usage.use_rm_force_depends.value:
expert_args = '--force-depends '
if config.usage.use_rm_autoremove.value:
expert_args += '--autoremove '
self.cmdList.append((IpkgComponent.CMD_REMOVE, {'package': expert_args + package}))
elif status == 'upgradeable':
if self.changed == True:
self.list[item] = self.buildEntryComponent(cur[0], cur[1], cur[2], 'goinstalled')
else:
self.list[item] = self.buildEntryComponent(cur[0], cur[1], cur[2], 'installed')
try:
cacheindex = self.cachelist.index(curcache)
self.cachelist[cacheindex] = [package,
cur[1],
cur[2],
'installed']
except:
print '[VTI SoftwareManager] failed to modify packetcachefile'
self['key_green'].setText(_('Remove'))
if self.changecmdList == True:
self.cmdList.append((IpkgComponent.CMD_INSTALL, {'package': package}))
elif status == 'installable':
if self.changed == True:
self.list[item] = self.buildEntryComponent(cur[0], cur[1], cur[2], 'goinstalled')
else:
self.list[item] = self.buildEntryComponent(cur[0], cur[1], cur[2], 'installed')
try:
cacheindex = self.cachelist.index(curcache)
self.cachelist[cacheindex] = [package,
cur[1],
cur[2],
'installed']
except:
print '[VTI SoftwareManager] failed to modify packetcachefile'
self['key_green'].setText(_('Remove'))
if self.changecmdList == True:
self.cmdList.append((IpkgComponent.CMD_INSTALL, {'package': package}))
write_cache(self.cache_file, self.cachelist)
self['list'].updateList(self.list)
self.selectionChanged
if len(self.cmdList):
self['key_yellow'].setText(_('Excecute'))
else:
self['key_yellow'].setText('')
def doInstall(self):
if len(self.cmdList) and self.doSoftwareAction != True:
self.removetextlist = ['enigma2-plugin-systemplugins-',
'enigma2-plugin-extensions-',
'kernel-module-',
'enigma2-plugin-skin-',
'enigma2-plugin-picons-',
'enigma2-plugin-settings-',
'enigma2-plugin-cams-',
'enigma2-plugin-config-',
'enigma2-plugin-drivers-',
'--force-depends ',
'--autoremove ']
self.execlist = []
self.plugin_list_state == False
self.text = ''
divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_SKIN_IMAGE, '750S/div-h.png'))
for self.textitem in self.cmdList:
self.textitemaction = self.textitem[0]
if self.textitemaction == 0:
self.textitemaction = _('Install')
actionpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/installed.png'))
elif self.textitemaction == 2:
self.textitemaction = _('Remove')
actionpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/remove.png'))
else:
self.textitemaction = _('upgrade')
self.textitempackage = self.textitem[1]
self.textitem = self.textitempackage['package']
for removetext in self.removetextlist:
self.textitem = self.textitem.replace(removetext, '')
self.execlist.append((self.textitem,
self.textitemaction,
'',
'',
actionpng,
divpng))
self['list'].setList(self.execlist)
self['key_yellow'].setText('')
self['key_green'].setText(_('Start'))
self.doSoftwareAction = True
def runInstall(self):
self.doSoftwareAction = False
self.session.openWithCallback(self.runInstallFinished, Ipkg, cmdList=self.cmdList)
def runInstallFinished(self):
needs_restart_list = ('enigma2-plugin-systemplugins-crossepg', 'enigma2-plugin-extensions-atmolightd', 'enigma2-plugin-extensions-enhancedmoviecenter', 'enigma2-plugin-extensions-epgimport', 'enigma2-plugin-extensions-grannybutton', 'enigma2-plugin-extensions-infobartunerstate', 'enigma2-plugin-extensions-lcd4linux', 'enigma2-plugin-extensions-multiquickbutton', 'enigma2-plugin-extensions-openvpn', 'enigma2-plugin-extensions-openwebif', 'enigma2-plugin-extensions-secondinfobar', 'enigma2-plugin-extensions-webbouqueteditor')
skin_installed = False
restart_required = False
for x in self.cmdList:
if len(x) > 1 and x[0] == 0:
if x[1].has_key('package'):
if x[1]['package'].startswith('enigma2-plugin-skin-'):
skin_installed = True
if len([ p_name for p_name in needs_restart_list if x[1]['package'].startswith(p_name) ]):
restart_required = True
if restart_required and skin_installed:
break
self.plugin_list_state = False
self.changed = False
self.cmdList = []
self.changeList = []
self.upgradablelist = []
self.reloadPluginlist()
self['key_yellow'].setText('')
if restart_required:
plugins.restart_required = True
if skin_installed:
self.session.openWithCallback(self.exitAnswerSkinChoice, MessageBox, _('A new skin was installed\n') + _('Do you want to open the skin choice list?'))
elif not plugins.restart_required:
if os_path.exists(self.cache_file) == True:
remove(self.cache_file)
self.close()
else:
self.session.openWithCallback(self.exitAnswer, MessageBox, _('Execution finished.\n') + _('Do you want to restart GUI ?'))
def exitAnswerSkinChoice(self, result):
if result:
from Plugins.SystemPlugins.SkinSelector.plugin import SkinSelector
self.prev_skin = config.skin.primary_skin.value
self.session.openWithCallback(self.skinChanged, SkinSelector, silent_close=True)
elif plugins.restart_required:
self.session.openWithCallback(self.exitAnswer, MessageBox, _('Execution finished.\n') + _('Do you want to restart GUI ?'))
else:
if os_path.exists(self.cache_file) == True:
remove(self.cache_file)
self.close()
def exitAnswer(self, result):
if result:
self.session.open(Screens.Standby.TryQuitMainloop, 3)
else:
self.reloadinfo()
def skinChanged(self, res = None):
need_restart = False
if plugins.restart_required:
need_restart = True
if self.prev_skin != config.skin.primary_skin.value:
need_restart = True
if need_restart:
self.session.openWithCallback(self.exitAnswer, MessageBox, _('Execution finished.\n') + _('Do you want to restart GUI ?'))
else:
if os_path.exists(self.cache_file) == True:
remove(self.cache_file)
self.close()
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.list_updating = False
self.setStatus('error')
elif event == IpkgComponent.EVENT_DONE:
if self.list_updating:
self.list_updating = False
if not self.Console:
self.Console = Console()
cmd = 'opkg list-installed'
self.Console.ePopen(cmd, self.IpkgListInstalled_Finished)
def IpkgList_Finished(self, result, retval, extra_args = None):
if len(result):
self.packetlist = []
for x in result.splitlines():
split = x.split(' - ')
if split[0].strip().startswith(self.wanted_extensions):
try:
self.packetlist.append([split[0].strip(), split[1].strip(), split[2].strip()])
except:
self.packetlist.append([split[0].strip(), split[1].strip(), ' '])
if not self.Console:
self.Console = Console()
cmd = 'opkg list-upgradable'
self.Console.ePopen(cmd, self.OpkgUpgradableList_Finished)
def IpkgListInstalled_Finished(self, result, retval, extra_args = None):
if len(result):
self.installed_packetlist = {}
for x in result.splitlines():
split = x.split(' - ')
if split[0].strip().startswith(self.wanted_extensions):
self.installed_packetlist[split[0].strip()] = split[1].strip()
if not self.Console:
self.Console = Console()
cmd = "opkg list | grep -v '^[[:space:]]'"
self.Console.ePopen(cmd, self.IpkgList_Finished)
def OpkgUpgradableList_Finished(self, result, retval, extra_args = None):
self.upgradable_packetlist = {}
if len(result):
for x in result.splitlines():
split = x.split(' - ')
if split[0].strip().startswith(self.wanted_extensions):
self.upgradable_packetlist[split[0].strip()] = split[1].strip()
self.opkgupdated = True
self.buildPacketList()
def buildEntryComponent(self, name, version, description, state):
divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_SKIN_IMAGE, '750S/div-h.png'))
self.fullname = name
if self.replacename is not None:
name = name.replace(self.wanted_extensions, '')
if state == 'installed':
if self.fullname in self.changeList:
installedpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/installplugin.png'))
else:
installedpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/installed.png'))
return (name,
version,
description,
state,
installedpng,
divpng)
elif state == 'upgradeable':
upgradeablepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/upgradeable.png'))
return (name,
version,
description,
state,
upgradeablepng,
divpng)
elif state == 'goinstalled':
state = 'installed'
goinstalledpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/installplugin.png'))
return (name,
version,
description,
state,
goinstalledpng,
divpng)
elif state == 'goremove':
state = 'installable'
goremovepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/removeplugin.png'))
return (name,
version,
description,
state,
goremovepng,
divpng)
else:
if self.fullname in self.changeList or self.fullname in self.upgradablelist:
installablepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/removeplugin.png'))
else:
installablepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_PLUGINS, 'SystemPlugins/VTIPanel/pictures/installable.png'))
return (name,
version,
description,
state,
installablepng,
divpng)
def buildPacketList(self):
self.list = []
self.cachelist = []
if self.cache_ttl > 0 and self.vc != 0:
try:
self.cachelist = load_cache(self.cache_file)
if len(self.cachelist) > 0:
for x in self.cachelist:
if x[0].strip().startswith(self.wanted_extensions):
self.list.append(self.buildEntryComponent(x[0], x[1], x[2], x[3]))
if self.first_run == True:
self.first_run = False
self.setStatus('startmenu')
else:
self['list'].setList(self.list)
except:
self.inv_cache = 1
if self.cache_ttl == 0 or self.inv_cache == 1 or self.vc == 0:
for x in self.packetlist:
status = ''
if self.upgradable_packetlist.has_key(x[0].strip()):
status = 'upgradeable'
self.list.append(self.buildEntryComponent(x[0].strip(), x[1].strip(), x[2].strip(), status))
elif self.installed_packetlist.has_key(x[0].strip()):
status = 'installed'
if x[1].strip() == self.installed_packetlist[x[0].strip()]:
self.list.append(self.buildEntryComponent(x[0].strip(), x[1].strip(), x[2].strip(), status))
else:
status = 'installable'
self.list.append(self.buildEntryComponent(x[0].strip(), x[1].strip(), x[2].strip(), status))
if self.installed_packetlist.has_key(x[0].strip()):
if x[1].strip() == self.installed_packetlist[x[0].strip()]:
self.cachelist.append([x[0].strip(),
x[1].strip(),
x[2].strip(),
status])
else:
self.cachelist.append([x[0].strip(),
x[1].strip(),
x[2].strip(),
status])
write_cache(self.cache_file, self.cachelist)
self.first_run = False
self.setStatus('startmenu')
self.selectionChanged()
if self.opkgupdated == True:
self.opkgupdated = False
self.checkFreeSpace()
def reloadPluginlist(self):
plugins.clearPluginList()
plugins.readPluginList(resolveFilename(SCOPE_PLUGINS))
class UpdatePlugin(Screen):
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software update"))
self.setTitle(_("Software update"))
self.slider = Slider(0, 100)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.checkNetworkState()
def checkNetworkState(self):
cmd1 = "opkg update"
self.CheckConsole = Console()
self.CheckConsole.ePopen(cmd1, self.checkNetworkStateFinished)
def checkNetworkStateFinished(self, result, retval, extra_args=None):
if 'bad address' in result:
self.session.openWithCallback(self.close, MessageBox, _("Your %s %s is not connected to the Internet, please check your network settings and try again.") % (getMachineBrand(), getMachineName()), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif ('wget returned 1' or 'wget returned 255' or '404 Not Found') in result:
self.session.openWithCallback(self.close, MessageBox, _("Can not retrieve data from feed server. Check your Internet connection and try again later."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif 'Collected errors' in result:
self.session.openWithCallback(self.close, MessageBox, _("A background update check is in progress, please wait a few minutes and try again."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
else:
self.startCheck()
def startCheck(self):
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self.updating = False
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
self.updating = True
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
self.package.setText(param.rpartition("/")[2].rstrip("."))
elif event == IpkgComponent.EVENT_UPGRADE:
self.slider.setValue(100 * self.packages / self.total_packages)
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if param not in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % param
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = None
self.total_packages = len(self.ipkg.getFetchedList())
message = _("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
if self.total_packages:
config.softwareupdate.updatefound.setValue(True)
choices = [
(_("View the changes"), "showlist"),
(_("Update and ask to reboot"), "hot"),
# (_("Upgrade and reboot system"), "cold")
]
choices.append((_("Cancel"), ""))
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name="SoftwareUpdateChoices")
upgrademessage.setTitle(_('Software update'))
else:
upgrademessage = self.session.openWithCallback(self.close, MessageBox, _("Nothing to upgrade"), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
upgrademessage.setTitle(_('Software update'))
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(33)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(66)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s.") % (getMachineBrand(), getMachineName(), getMachineBrand(), getMachineName())
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _("Update failed. Your %s %s does not have a working Internet connection.") % (getMachineBrand(), getMachineName())
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(100)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "menu":
message = _("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(%s " % self.total_packages + _("Packages") + ")"
choices = [
(_("View the changes"), "showlist"),
(_("Update and ask to reboot"), "hot"),
# (_("Upgrade and reboot system"), "cold")
]
choices.append((_("Cancel"), ""))
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name="SoftwareUpdateChoices")
upgrademessage.setTitle(_('Software update'))
elif answer[1] == "showlist":
format = "%-38.38s %-32.32s %-32.32s\n"
text = format % ("Package name", "Current version", "New version")
spaces = "-" * 50
text += format % (spaces, spaces, spaces)
for i in sorted(self.ipkg.getFetchedList(), key=lambda d: d[0]):
text += format % (i[0], i[1], i[2])
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), SoftwareUpdateChangeView, text)
elif answer[1] == "cold":
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if self.updating:
return
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Upgrade finished.") + " " + _("Do you want to reboot your %s %s") % (getMachineBrand(), getMachineName()))
else:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class OnlineUpdateCheckPoller:
def __init__(self):
# Init Timer
self.timer = eTimer()
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def start(self):
if self.onlineupdate_check not in self.timer.callback:
self.timer.callback.append(self.onlineupdate_check)
if time() > 1262304000:
self.timer.startLongTimer(0)
else:
self.timer.startLongTimer(120)
def stop(self):
if self.version_check in self.timer.callback:
self.timer.callback.remove(self.onlineupdate_check)
self.timer.stop()
def onlineupdate_check(self):
if config.softwareupdate.check.getValue():
Components.Task.job_manager.AddJob(self.createCheckJob())
self.timer.startLongTimer(config.softwareupdate.checktimer.getValue() * 3600)
def createCheckJob(self):
job = Components.Task.Job(_("OnlineVersionCheck"))
task = Components.Task.PythonTask(job, _("Checking for Updates..."))
task.work = self.JobStart
task.weighting = 1
return job
def JobStart(self):
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
print ('[OnlineVersionCheck] %s Updates available' % self.total_packages)
if self.total_packages:
from urllib import urlopen
import socket
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
config.softwareupdate.updatefound.setValue(True)
try:
config.softwareupdate.updateisunstable.setValue(urlopen("http://enigma2.world-of-satellite.com/feeds/" + about.getImageVersionString() + "/status").read())
except:
config.softwareupdate.updateisunstable.setValue(1)
socket.setdefaulttimeout(currentTimeoutDefault)
else:
config.softwareupdate.updatefound.setValue(False)
else:
config.softwareupdate.updatefound.setValue(False)
pass
class SoftwarePanel(Screen):
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software Panel"))
skin = """
<screen name="SoftwarePanel" position="center,center" size="650,605" title="Software Panel">
<widget name="a_off" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/aoff.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_red" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/ared.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_yellow" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/ayellow.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_green" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/agreen.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="feedstatusRED" position="60,14" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="feedstatusYELLOW" position="60,46" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="feedstatusGREEN" position="60,78" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="packagetext" position="180,50" size="350,30" zPosition="1" font="Regular;25" halign="right" transparent="1" />
<widget name="packagenr" position="511,50" size="50,30" zPosition="1" font="Regular;25" halign="right" transparent="1" />
<widget source="list" render="Listbox" position="10,120" size="630,365" scrollbarMode="showOnDemand">
<convert type="TemplatedMultiContent">
{"template": [
MultiContentEntryText(pos = (5, 1), size = (540, 28), font=0, flags = RT_HALIGN_LEFT, text = 0), # index 0 is the name
MultiContentEntryText(pos = (5, 26), size = (540, 20), font=1, flags = RT_HALIGN_LEFT, text = 2), # index 2 is the description
MultiContentEntryPixmapAlphaBlend(pos = (545, 2), size = (48, 48), png = 4), # index 4 is the status pixmap
MultiContentEntryPixmapAlphaBlend(pos = (5, 50), size = (610, 2), png = 5), # index 4 is the div pixmap
],
"fonts": [gFont("Regular", 22),gFont("Regular", 14)],
"itemHeight": 52
}
</convert>
</widget>
<ePixmap pixmap="skin_default/buttons/red.png" position=" 30,570" size="35,27" alphatest="blend" />
<widget name="key_green_pic" pixmap="skin_default/buttons/green.png" position="290,570" size="35,27" alphatest="blend" />
<widget name="key_red" position=" 80,573" size="200,26" zPosition="1" font="Regular;22" halign="left" transparent="1" />
<widget name="key_green" position="340,573" size="200,26" zPosition="1" font="Regular;22" halign="left" transparent="1" />
</screen> """
self.skin = skin
self.list = []
self.statuslist = []
self["list"] = List(self.list)
self['a_off'] = Pixmap()
self['a_red'] = Pixmap()
self['a_yellow'] = Pixmap()
self['a_green'] = Pixmap()
self['key_green_pic'] = Pixmap()
self['key_red_pic'] = Pixmap()
self['key_red'] = Label(_("Cancel"))
self['key_green'] = Label(_("Update"))
self['packagetext'] = Label(_("Updates Available:"))
self['packagenr'] = Label("0")
self['feedstatusRED'] = Label("< " + _("feed status"))
self['feedstatusYELLOW'] = Label("< " + _("feed status"))
self['feedstatusGREEN'] = Label("< " + _("feed status"))
self['key_green'].hide()
self['key_green_pic'].hide()
self.update = False
self.packages = 0
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self["actions"] = ActionMap([
"OkCancelActions", "DirectionActions", "ColorActions",
"SetupActions"
], {
"cancel": self.Exit,
"green": self.Green,
"red": self.Exit,
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def Exit(self):
self.ipkg.stop()
self.close()
def Green(self):
if self.packages > 0:
if self.packages <= 200:
from Plugins.SystemPlugins.SoftwareManager.plugin import UpdatePlugin
self.session.open(UpdatePlugin)
self.close()
else:
print("DO NOT UPDATE !!!")
message = _(
"There are to many update packages !!\n\n"
"There is a risk that your %s %s will not\n"
"boot after online-update, or will show disfunction in running Image.\n\n"
"You need to flash new !!\n\n"
"Do you want to flash-online ?") % (getMachineBrand(),
getMachineName())
self.session.openWithCallback(self.checkPackagesCallback,
MessageBox,
message,
default=True)
def checkPackagesCallback(self, ret):
print(ret)
if ret:
from Plugins.SystemPlugins.SoftwareManager.Flash_online import FlashOnline
self.session.open(FlashOnline)
self.close()
def layoutFinished(self):
self.checkTrafficLight()
self.rebuildList()
def UpdatePackageNr(self):
self.packages = len(self.list)
print(self.packages)
print("packagenr" + str(self.packages))
self["packagenr"].setText(str(self.packages))
if self.packages == 0:
self['key_green'].hide()
self['key_green_pic'].hide()
else:
self['key_green'].show()
self['key_green_pic'].show()
def checkTrafficLight(self):
print("checkTrafficLight")
from six.moves.urllib.request import urlopen
import socket
self['a_red'].hide()
self['a_yellow'].hide()
self['a_green'].hide()
self['feedstatusRED'].hide()
self['feedstatusYELLOW'].hide()
self['feedstatusGREEN'].hide()
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
try:
urlopenATV = "http://ampel.mynonpublic.com/Ampel/index.php"
d = urlopen(urlopenATV)
tmpStatus = d.read()
if b'rot.png' in tmpStatus:
self['a_off'].hide()
self['a_red'].show()
self['feedstatusRED'].show()
elif b'gelb.png' in tmpStatus:
self['a_off'].hide()
self['a_yellow'].show()
self['feedstatusYELLOW'].show()
elif b'gruen.png' in tmpStatus:
self['a_off'].hide()
self['a_green'].show()
self['feedstatusGREEN'].show()
except:
self['a_off'].show()
socket.setdefaulttimeout(currentTimeoutDefault)
def setStatus(self, status=None):
if status:
self.statuslist = []
divpng = LoadPixmap(cached=True,
path=resolveFilename(SCOPE_GUISKIN,
"skin_default/div-h.png"))
if status == 'update':
if os_path.exists(
resolveFilename(SCOPE_GUISKIN, "icons/upgrade.png")):
statuspng = LoadPixmap(cached=True,
path=resolveFilename(
SCOPE_GUISKIN,
"icons/upgrade.png"))
else:
statuspng = LoadPixmap(
cached=True,
path=resolveFilename(
SCOPE_CURRENT_PLUGIN,
"SystemPlugins/SoftwareManager/upgrade.png"))
self.statuslist.append(
(_("Package list update"), '',
_("Trying to download a new updatelist. Please wait..."),
'', statuspng, divpng))
elif status == 'error':
if os_path.exists(
resolveFilename(SCOPE_GUISKIN, "icons/remove.png")):
statuspng = LoadPixmap(cached=True,
path=resolveFilename(
SCOPE_GUISKIN,
"icons/remove.png"))
else:
statuspng = LoadPixmap(
cached=True,
path=resolveFilename(
SCOPE_CURRENT_PLUGIN,
"SystemPlugins/SoftwareManager/remove.png"))
self.statuslist.append((
_("Error"), '',
_("There was an error downloading the updatelist. Please try again."
), '', statuspng, divpng))
elif status == 'noupdate':
if os_path.exists(
resolveFilename(SCOPE_GUISKIN, "icons/installed.png")):
statuspng = LoadPixmap(cached=True,
path=resolveFilename(
SCOPE_GUISKIN,
"icons/installed.png"))
else:
statuspng = LoadPixmap(
cached=True,
path=resolveFilename(
SCOPE_CURRENT_PLUGIN,
"SystemPlugins/SoftwareManager/installed.png"))
self.statuslist.append((_("Nothing to upgrade"), '',
_("There are no updates available."),
'', statuspng, divpng))
self['list'].setList(self.statuslist)
def rebuildList(self):
self.setStatus('update')
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.setStatus('error')
elif event == IpkgComponent.EVENT_DONE:
if self.update == False:
self.update = True
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
else:
self.buildPacketList()
pass
def buildEntryComponent(self, name, version, description, state):
divpng = LoadPixmap(cached=True,
path=resolveFilename(SCOPE_GUISKIN,
"skin_default/div-h.png"))
if not description:
description = "No description available."
if state == 'installed':
if os_path.exists(
resolveFilename(SCOPE_GUISKIN, "icons/installed.png")):
installedpng = LoadPixmap(cached=True,
path=resolveFilename(
SCOPE_GUISKIN,
"icons/installed.png"))
else:
installedpng = LoadPixmap(
cached=True,
path=resolveFilename(
SCOPE_CURRENT_PLUGIN,
"SystemPlugins/SoftwareManager/installed.png"))
return ((name, version, _(description), state, installedpng,
divpng))
elif state == 'upgradeable':
if os_path.exists(
resolveFilename(SCOPE_GUISKIN, "icons/upgradeable.png")):
upgradeablepng = LoadPixmap(cached=True,
path=resolveFilename(
SCOPE_GUISKIN,
"icons/upgradeable.png"))
else:
upgradeablepng = LoadPixmap(
cached=True,
path=resolveFilename(
SCOPE_CURRENT_PLUGIN,
"SystemPlugins/SoftwareManager/upgradeable.png"))
return ((name, version, _(description), state, upgradeablepng,
divpng))
else:
if os_path.exists(
resolveFilename(SCOPE_GUISKIN, "icons/installable.png")):
installablepng = LoadPixmap(cached=True,
path=resolveFilename(
SCOPE_GUISKIN,
"icons/installable.png"))
else:
installablepng = LoadPixmap(
cached=True,
path=resolveFilename(
SCOPE_CURRENT_PLUGIN,
"SystemPlugins/SoftwareManager/installable.png"))
return ((name, version, _(description), state, installablepng,
divpng))
def buildPacketList(self):
self.list = []
fetchedList = self.ipkg.getFetchedList()
excludeList = self.ipkg.getExcludeList()
if len(fetchedList) > 0:
for x in fetchedList:
try:
self.list.append(
self.buildEntryComponent(x[0], x[1], x[2],
"upgradeable"))
except:
print("[SOFTWAREPANEL] " + x[0] +
" no valid architecture, ignoring !!")
# self.list.append(self.buildEntryComponent(x[0], '', 'no valid architecture, ignoring !!', "installable"))
# if len(excludeList) > 0:
# for x in excludeList:
# try:
# self.list.append(self.buildEntryComponent(x[0], x[1], x[2], "installable"))
# except:
# self.list.append(self.buildEntryComponent(x[0], '', 'no valid architecture, ignoring !!', "installable"))
if self.list:
self['list'].setList(self.list)
else:
self.setStatus('noupdate')
elif len(fetchedList) == 0:
self.setStatus('noupdate')
else:
self.setStatus('error')
self.UpdatePackageNr()
class SoftwarePanel(Screen):
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software Panel"))
skin = """
<screen name="SoftwarePanel" position="center,center" size="650,605" title="Software Panel">
<widget name="a_off" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/aoff.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_red" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/ared.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_yellow" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/ayellow.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="a_green" pixmap="/usr/lib/enigma2/python/Plugins/Extensions/Infopanel/icons/agreen.png" position="10,10" zPosition="1" size="36,97" alphatest="on" />
<widget name="feedstatusRED" position="60,14" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="feedstatusYELLOW" position="60,46" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="feedstatusGREEN" position="60,78" size="200,30" zPosition="1" font="Regular;25" halign="left" transparent="1" />
<widget name="packagetext" position="180,50" size="350,30" zPosition="1" font="Regular;25" halign="right" transparent="1" />
<widget name="packagenr" position="511,50" size="50,30" zPosition="1" font="Regular;25" halign="right" transparent="1" />
<widget source="list" render="Listbox" position="10,120" size="630,365" scrollbarMode="showOnDemand">
<convert type="TemplatedMultiContent">
{"template": [
MultiContentEntryText(pos = (5, 1), size = (540, 28), font=0, flags = RT_HALIGN_LEFT, text = 0), # index 0 is the name
MultiContentEntryText(pos = (5, 26), size = (540, 20), font=1, flags = RT_HALIGN_LEFT, text = 2), # index 2 is the description
MultiContentEntryPixmapAlphaBlend(pos = (545, 2), size = (48, 48), png = 4), # index 4 is the status pixmap
MultiContentEntryPixmapAlphaBlend(pos = (5, 50), size = (610, 2), png = 5), # index 4 is the div pixmap
],
"fonts": [gFont("Regular", 22),gFont("Regular", 14)],
"itemHeight": 52
}
</convert>
</widget>
<ePixmap pixmap="skin_default/buttons/red.png" position=" 30,570" size="35,27" alphatest="blend" />
<widget name="key_green_pic" pixmap="skin_default/buttons/green.png" position="290,570" size="35,27" alphatest="blend" />
<widget name="key_red" position=" 80,573" size="200,26" zPosition="1" font="Regular;22" halign="left" transparent="1" />
<widget name="key_green" position="340,573" size="200,26" zPosition="1" font="Regular;22" halign="left" transparent="1" />
</screen> """
self.skin = skin
self.list = []
self.statuslist = []
self["list"] = List(self.list)
self['a_off'] = Pixmap()
self['a_red'] = Pixmap()
self['a_yellow'] = Pixmap()
self['a_green'] = Pixmap()
self['key_green_pic'] = Pixmap()
self['key_red_pic'] = Pixmap()
self['key_red'] = Label(_("Cancel"))
self['key_green'] = Label(_("Update"))
self['packagetext'] = Label(_("Updates Available:"))
self['packagenr'] = Label("0")
self['feedstatusRED'] = Label("< " + _("feed status"))
self['feedstatusYELLOW'] = Label("< " + _("feed status"))
self['feedstatusGREEN'] = Label("< " + _("feed status"))
self['key_green'].hide()
self['key_green_pic'].hide()
self.update = False
self.packages = 0
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self["actions"] = ActionMap(["OkCancelActions", "DirectionActions", "ColorActions", "SetupActions"],
{
"cancel": self.Exit,
"green": self.Green,
"red": self.Exit,
}, -2)
self.onLayoutFinish.append(self.layoutFinished)
def Exit(self):
self.ipkg.stop()
self.close()
def Green(self):
if self.packages > 0:
if self.packages <= 200:
from Plugins.SystemPlugins.SoftwareManager.plugin import UpdatePlugin
self.session.open(UpdatePlugin)
self.close()
else:
print "DO NOT UPDATE !!!"
message = _("There are to many update packages !!\n\n"
"There is a risk that your %s %s will not\n"
"boot after online-update, or will show disfunction in running Image.\n\n"
"You need to flash new !!\n\n"
"Do you want to flash-online ?") % (getMachineBrand(), getMachineName())
self.session.openWithCallback(self.checkPackagesCallback, MessageBox, message, default = True)
def checkPackagesCallback(self, ret):
print ret
if ret:
from Plugins.SystemPlugins.SoftwareManager.Flash_online import FlashOnline
self.session.open(FlashOnline)
self.close()
def layoutFinished(self):
self.checkTraficLight()
self.rebuildList()
def UpdatePackageNr(self):
self.packages = len(self.list)
print self.packages
print"packagenr" + str(self.packages)
self["packagenr"].setText(str(self.packages))
if self.packages == 0:
self['key_green'].hide()
self['key_green_pic'].hide()
else:
self['key_green'].show()
self['key_green_pic'].show()
def checkTraficLight(self):
print"checkTraficLight"
from urllib import urlopen
import socket
self['a_red'].hide()
self['a_yellow'].hide()
self['a_green'].hide()
self['feedstatusRED'].hide()
self['feedstatusYELLOW'].hide()
self['feedstatusGREEN'].hide()
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
try:
urlopenATV = "http://ampel.mynonpublic.com/Ampel/index.php"
d = urlopen(urlopenATV)
tmpStatus = d.read()
if 'rot.png' in tmpStatus:
self['a_off'].hide()
self['a_red'].show()
self['feedstatusRED'].show()
elif 'gelb.png' in tmpStatus:
self['a_off'].hide()
self['a_yellow'].show()
self['feedstatusYELLOW'].show()
elif 'gruen.png' in tmpStatus:
self['a_off'].hide()
self['a_green'].show()
self['feedstatusGREEN'].show()
except:
self['a_off'].show()
socket.setdefaulttimeout(currentTimeoutDefault)
def setStatus(self,status = None):
if status:
self.statuslist = []
divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/div-h.png"))
if status == 'update':
statuspng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/upgrade.png"))
self.statuslist.append(( _("Package list update"), '', _("Trying to download a new updatelist. Please wait..." ),'',statuspng, divpng ))
elif status == 'error':
statuspng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/remove.png"))
self.statuslist.append(( _("Error"), '', _("There was an error downloading the updatelist. Please try again." ),'',statuspng, divpng ))
elif status == 'noupdate':
statuspng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/installed.png"))
self.statuslist.append(( _("Nothing to upgrade"), '', _("There are no updates available." ),'',statuspng, divpng ))
self['list'].setList(self.statuslist)
def rebuildList(self):
self.setStatus('update')
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.setStatus('error')
elif event == IpkgComponent.EVENT_DONE:
if self.update == False:
self.update = True
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
else:
self.buildPacketList()
pass
def buildEntryComponent(self, name, version, description, state):
divpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_SKIN, "skin_default/div-h.png"))
if not description:
description = "No description available."
if state == 'installed':
installedpng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/installed.png"))
return((name, version, _(description), state, installedpng, divpng))
elif state == 'upgradeable':
upgradeablepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/upgradeable.png"))
return((name, version, _(description), state, upgradeablepng, divpng))
else:
installablepng = LoadPixmap(cached=True, path=resolveFilename(SCOPE_CURRENT_PLUGIN, "SystemPlugins/SoftwareManager/installable.png"))
return((name, version, _(description), state, installablepng, divpng))
def buildPacketList(self):
self.list = []
fetchedList = self.ipkg.getFetchedList()
excludeList = self.ipkg.getExcludeList()
if len(fetchedList) > 0:
for x in fetchedList:
try:
self.list.append(self.buildEntryComponent(x[0], x[1], x[2], "upgradeable"))
except:
print "[SOFTWAREPANEL] " + x[0] + " no valid architecture, ignoring !!"
# self.list.append(self.buildEntryComponent(x[0], '', 'no valid architecture, ignoring !!', "installable"))
# if len(excludeList) > 0:
# for x in excludeList:
# try:
# self.list.append(self.buildEntryComponent(x[0], x[1], x[2], "installable"))
# except:
# self.list.append(self.buildEntryComponent(x[0], '', 'no valid architecture, ignoring !!', "installable"))
if self.list:
self['list'].setList(self.list)
else:
self.setStatus('noupdate')
elif len(fetchedList) == 0:
self.setStatus('noupdate')
else:
self.setStatus('error')
self.UpdatePackageNr()
class UpdatePlugin(Screen):
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software Update"))
self.sliderPackages = {
"dreambox-dvb-modules": 1,
"enigma2": 2,
"tuxbox-image-info": 3
}
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
status_msgs = {
'stable': _('Feeds status: Stable'),
'unstable': _('Feeds status: Unstable'),
'updating': _('Feeds status: Updating'),
'unknown': _('No connection')
}
self['tl_off'] = Pixmap()
self['tl_red'] = Pixmap()
self['tl_yellow'] = Pixmap()
self['tl_green'] = Pixmap()
self.feedsStatus()
self['feedStatusMSG'] = Label(status_msgs[self.trafficLight])
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.checkNetworkState()
def feedsStatus(self):
from six.moves.urllib.request import urlopen
import socket
self['tl_red'].hide()
self['tl_yellow'].hide()
self['tl_green'].hide()
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
try:
d = urlopen("https://openvix.co.uk/TrafficLightState.php")
self.trafficLight = d.read()
if self.trafficLight == 'unstable':
self['tl_off'].hide()
self['tl_red'].show()
elif self.trafficLight == 'updating':
self['tl_off'].hide()
self['tl_yellow'].show()
elif self.trafficLight == 'stable':
self['tl_off'].hide()
self['tl_green'].show()
else:
self.trafficLight = 'unknown'
self['tl_off'].show()
except:
self.trafficLight = 'unknown'
self['tl_off'].show()
socket.setdefaulttimeout(currentTimeoutDefault)
def checkNetworkState(self):
cmd1 = "opkg update"
self.CheckConsole = Console()
self.CheckConsole.ePopen(cmd1, self.checkNetworkStateFinished)
def checkNetworkStateFinished(self, result, retval, extra_args=None):
result = six.ensure_str(result)
if 'bad address' in result:
self.session.openWithCallback(
self.close,
MessageBox,
_("Your %s %s is not connected to the internet, please check your network settings and try again."
) % (getMachineBrand(), getMachineName()),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
elif ('wget returned 1' or 'wget returned 255'
or '404 Not Found') in result:
self.session.openWithCallback(
self.close,
MessageBox,
_("Sorry feeds are down for maintenance, please try again later. If this issue persists please check www.opena.tv"
),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
elif 'Collected errors' in result:
self.session.openWithCallback(
self.close,
MessageBox,
_("A background update check is in progress, please wait a few minutes and try again."
),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
else:
self.startCheck()
def startCheck(self):
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.updating = False
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
self.updating = True
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(
ngettext("Update completed, %d package was installed.",
"Update completed, %d packages were installed.",
self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if param in self.sliderPackages:
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(
_("Upgrading") + ": %s/%s" %
(self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in (
"N", "Y"):
self.ipkg.write(
True and
config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback, MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?"
) % param)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
from six.moves.urllib.request import urlopen
import socket
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
status = urlopen(
'https://www.openvix.co.uk/feeds/status').read()
if '404 Not Found' in status:
status = '1'
config.softwareupdate.updateisunstable.setValue(status)
socket.setdefaulttimeout(currentTimeoutDefault)
self.total_packages = None
if config.softwareupdate.updateisunstable.value == '1' and config.softwareupdate.updatebeta.value:
self.total_packages = len(self.ipkg.getFetchedList())
message = _(
"The current update may be unstable") + "\n" + _(
"Are you sure you want to update your %s %s ?"
) % (getMachineBrand(), getMachineName()) + "\n(" + (
ngettext("%s updated package available",
"%s updated packages available",
self.total_packages) %
self.total_packages) + ")"
elif config.softwareupdate.updateisunstable.value == '0':
self.total_packages = len(self.ipkg.getFetchedList())
message = _("Do you want to update your %s %s ?") % (
getMachineBrand(), getMachineName()) + "\n(" + (
ngettext("%s updated package available",
"%s updated packages available",
self.total_packages) %
self.total_packages) + ")"
if self.total_packages:
global ocram
for package_tmp in self.ipkg.getFetchedList():
if package_tmp[0].startswith(
'enigma2-plugin-picons-tv-ocram'):
ocram = ocram + '[ocram-picons] ' + package_tmp[
0].split('enigma2-plugin-picons-tv-ocram.')[
1] + 'updated ' + package_tmp[2] + '\n'
elif package_tmp[0].startswith(
'enigma2-plugin-settings-ocram'):
ocram = ocram + '[ocram-settings] ' + package_tmp[
0].split('enigma2-plugin-picons-tv-ocram.')[
1] + 'updated ' + package_tmp[2] + '\n'
config.softwareupdate.updatefound.setValue(True)
choices = [(_("View the changes"), "changes"),
(_("Upgrade and reboot system"), "cold")]
if path.exists(
"/usr/lib/enigma2/python/Plugins/SystemPlugins/ViX/BackupManager.py"
):
if not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append(
(_("Perform a settings backup,") + '\n\t' +
_("making a backup before updating") +
'\n\t' + _("is strongly advised."), "backup"))
if not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_("Perform a full image backup"),
"imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
upgrademessage = self.session.openWithCallback(
self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices,
skin_name="SoftwareUpdateChoices",
var=self.trafficLight)
upgrademessage.setTitle(_('Software update'))
else:
upgrademessage = self.session.openWithCallback(
self.close,
MessageBox,
_("Nothing to upgrade"),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
upgrademessage.setTitle(_('Software update'))
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(
_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
"Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s."
) % (getMachineBrand(), getMachineName(), getMachineBrand(),
getMachineName())
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _(
"Update failed. Your %s %s does not have a working internet connection."
) % (getMachineBrand(), getMachineName())
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[
0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "menu":
if config.softwareupdate.updateisunstable.value == '1':
message = _("The current update may be unstable") + "\n" + _(
"Are you sure you want to update your %s %s ?") % (
getMachineBrand(), getMachineName()
) + "\n(%s " % self.total_packages + _("Packages") + ")"
elif config.softwareupdate.updateisunstable.value == '0':
message = _("Do you want to update your %s %s ?") % (
getMachineBrand(), getMachineName()
) + "\n(%s " % self.total_packages + _("Packages") + ")"
choices = [(_("View the changes"), "changes"),
(_("Upgrade and reboot system"), "cold")]
if not self.SettingsBackupDone and not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_(
"Perform a settings backup, making a backup before updating is strongly advised."
), "backup"))
if not self.ImageBackupDone and not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append(
(_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
upgrademessage = self.session.openWithCallback(
self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices,
skin_name="SoftwareUpdateChoices",
var=self.trafficLight)
upgrademessage.setTitle(_('Software update'))
elif answer[1] == "changes":
self.session.openWithCallback(self.startActualUpgrade,
SoftwareUpdateChanges)
elif answer[1] == "backup":
self.doSettingsBackup()
elif answer[1] == "imagebackup":
self.doImageBackup()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST,
args={'installed_only': True})
elif answer[1] == "cold":
if (config.softwareupdate.autosettingsbackup.value
and config.backupmanager.backuplocation.value) or (
config.softwareupdate.autoimagebackup.value
and config.imagemanager.backuplocation.value):
self.doAutoBackup()
else:
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def doSettingsBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.BackupManager import BackupFiles
self.BackupFiles = BackupFiles(self.session, True)
Components.Task.job_manager.AddJob(self.BackupFiles.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('vix', 'Backup Manager'):
break
self.showJobView(job)
def doImageBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.ImageManager import ImageBackup
self.ImageBackup = ImageBackup(self.session, True)
Components.Task.job_manager.AddJob(self.ImageBackup.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('vix', 'Image Manager'):
break
self.showJobView(job)
def doAutoBackup(self, val=False):
self.autobackuprunning = True
if config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value and not self.SettingsBackupDone:
self.doSettingsBackup()
elif config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value and not self.ImageBackupDone:
self.doImageBackup()
else:
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
def showJobView(self, job):
if job.name == dgettext('vix', 'Image Manager'):
self.ImageBackupDone = True
elif job.name == dgettext('vix', 'Backup Manager'):
self.SettingsBackupDone = True
from Screens.TaskView import JobView
Components.Task.job_manager.in_background = False
if not self.autobackuprunning:
self.session.openWithCallback(self.startActualUpgrade(
("menu", "menu")),
JobView,
job,
cancelable=False,
backgroundable=False,
afterEventChangeable=False,
afterEvent="close")
else:
self.session.openWithCallback(self.doAutoBackup,
JobView,
job,
cancelable=False,
backgroundable=False,
afterEventChangeable=False,
afterEvent="close")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(
self.exitAnswer, MessageBox,
_("Upgrade finished.") + " " +
_("Do you want to reboot your %s %s") %
(getMachineBrand(), getMachineName()))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
class PackageInfoHandler:
STATUS_WORKING = 0
STATUS_DONE = 1
STATUS_ERROR = 2
STATUS_INIT = 4
def __init__(self, statusCallback, blocking = False, neededTag = None, neededFlag = None):
self.directory = '/'
self.neededTag = neededTag
self.neededFlag = neededFlag
self.blocking = blocking
self.currentlyInstallingMetaIndex = None
self.console = eConsoleAppContainer()
self.console.appClosed.append(self.installNext)
self.reloadFavourites = False
self.statusCallback = statusCallback
self.setStatus(self.STATUS_INIT)
self.packageslist = []
self.packagesIndexlist = []
self.packageDetails = []
return
def readInfo(self, directory, file):
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageslist.append((entry, file))
except InfoHandlerParseError:
pass
def readIndex(self, directory, file):
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packagesIndexlist.append((entry, file))
except InfoHandlerParseError:
pass
def readDetails(self, directory, file):
self.packageDetails = []
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageDetails.append((entry, file))
except InfoHandlerParseError:
pass
def fillPackagesList(self, prerequisites = True):
self.packageslist = []
packages = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for directory in self.directory:
packages += crawlDirectory(directory, '.*\\.info$')
for package in packages:
self.readInfo(package[0] + '/', package[0] + '/' + package[1])
if prerequisites:
for package in self.packageslist[:]:
if not self.prerequisiteMet(package[0]['prerequisites']):
self.packageslist.remove(package)
return self.packageslist
def fillPackagesIndexList(self, prerequisites = True):
self.packagesIndexlist = []
indexfileList = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for indexfile in os.listdir(self.directory[0]):
if indexfile.startswith('index-'):
if indexfile.endswith('.xml'):
if indexfile[-7:-6] == '_':
continue
indexfileList.append(indexfile)
if len(indexfileList):
for file in indexfileList:
neededFile = self.directory[0] + '/' + file
if os.path.isfile(neededFile):
self.readIndex(self.directory[0] + '/', neededFile)
if prerequisites:
for package in self.packagesIndexlist[:]:
if not self.prerequisiteMet(package[0]['prerequisites']):
self.packagesIndexlist.remove(package)
return self.packagesIndexlist
def fillPackageDetails(self, details = None):
self.packageDetails = []
detailsfile = details
if not isinstance(self.directory, list):
self.directory = [self.directory]
self.readDetails(self.directory[0] + '/', self.directory[0] + '/' + detailsfile)
return self.packageDetails
def prerequisiteMet(self, prerequisites):
met = True
if self.neededTag is None:
if prerequisites.has_key('tag'):
return False
else:
if self.neededTag == 'ALL_TAGS':
return True
if prerequisites.has_key('tag'):
if self.neededTag not in prerequisites['tag']:
return False
else:
return False
if self.neededFlag is None:
if prerequisites.has_key('flag'):
return False
elif prerequisites.has_key('flag'):
if self.neededFlag not in prerequisites['flag']:
return False
else:
return True
if prerequisites.has_key('satellite'):
for sat in prerequisites['satellite']:
if int(sat) not in nimmanager.getConfiguredSats():
return False
if prerequisites.has_key('bcastsystem'):
has_system = False
for bcastsystem in prerequisites['bcastsystem']:
if nimmanager.hasNimType(bcastsystem):
has_system = True
if not has_system:
return False
if prerequisites.has_key('hardware'):
hardware_found = False
for hardware in prerequisites['hardware']:
if hardware == getBoxType():
hardware_found = True
if not hardware_found:
return False
return True
def installPackages(self, indexes):
if len(indexes) == 0:
self.setStatus(self.STATUS_DONE)
return
self.installIndexes = indexes
self.currentlyInstallingMetaIndex = 0
self.installPackage(self.installIndexes[self.currentlyInstallingMetaIndex])
def installPackage(self, index):
if len(self.packageslist) <= index:
return
attributes = self.packageslist[index][0]['attributes']
self.installingAttributes = attributes
self.attributeNames = ['skin',
'config',
'favourites',
'package',
'services']
self.currentAttributeIndex = 0
self.currentIndex = -1
self.installNext()
def setStatus(self, status):
self.status = status
self.statusCallback(self.status, None)
return
def installNext(self, *args, **kwargs):
if self.reloadFavourites:
self.reloadFavourites = False
db = eDVBDB.getInstance().reloadBouquets()
self.currentIndex += 1
attributes = self.installingAttributes
if self.currentAttributeIndex >= len(self.attributeNames):
if self.currentlyInstallingMetaIndex is None or self.currentlyInstallingMetaIndex >= len(self.installIndexes) - 1:
self.setStatus(self.STATUS_DONE)
return
else:
self.currentlyInstallingMetaIndex += 1
self.currentAttributeIndex = 0
self.installPackage(self.installIndexes[self.currentlyInstallingMetaIndex])
return
self.setStatus(self.STATUS_WORKING)
currentAttribute = self.attributeNames[self.currentAttributeIndex]
if attributes.has_key(currentAttribute):
if self.currentIndex >= len(attributes[currentAttribute]):
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
else:
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
if currentAttribute == 'skin':
skin = attributes['skin'][self.currentIndex]
self.installSkin(skin['directory'], skin['name'])
elif currentAttribute == 'config':
if self.currentIndex == 0:
from Components.config import configfile
configfile.save()
config = attributes['config'][self.currentIndex]
self.mergeConfig(config['directory'], config['name'])
elif currentAttribute == 'favourites':
favourite = attributes['favourites'][self.currentIndex]
self.installFavourites(favourite['directory'], favourite['name'])
elif currentAttribute == 'package':
package = attributes['package'][self.currentIndex]
self.installIPK(package['directory'], package['name'])
elif currentAttribute == 'services':
service = attributes['services'][self.currentIndex]
self.mergeServices(service['directory'], service['name'])
return
def readfile(self, filename):
if not os.path.isfile(filename):
return []
fd = open(filename)
lines = fd.readlines()
fd.close()
return lines
def mergeConfig(self, directory, name, merge = True):
if os.path.isfile(directory + name):
config.loadFromFile(directory + name, base_file=False)
configfile.save()
self.installNext()
def installIPK(self, directory, name):
if self.blocking:
os.system('opkg install ' + directory + name)
self.installNext()
else:
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': directory + name})
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
self.installNext()
elif event == IpkgComponent.EVENT_ERROR:
self.installNext()
def installSkin(self, directory, name):
if self.blocking:
copytree(directory, resolveFilename(SCOPE_SKIN))
self.installNext()
elif self.console.execute('cp -a %s %s' % (directory, resolveFilename(SCOPE_SKIN))):
self.installNext()
def mergeServices(self, directory, name, merge = False):
if os.path.isfile(directory + name):
db = eDVBDB.getInstance()
db.reloadServicelist()
db.loadServicelist(directory + name)
db.saveServicelist()
self.installNext()
def installFavourites(self, directory, name):
self.reloadFavourites = True
if self.blocking:
copyfile(directory + name, resolveFilename(SCOPE_CONFIG))
self.installNext()
elif self.console.execute('cp %s %s' % (directory + name, resolveFilename(SCOPE_CONFIG))):
self.installNext()
class UpdatePlugin(Screen, ProtectedScreen):
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
screentitle = _("Software update")
self.menu_path = args[0]
if config.usage.show_menupath.value == 'large':
self.menu_path += screentitle
self.title = self.menu_path
self.menu_path_compressed = ""
self.menu_path += ' / '
elif config.usage.show_menupath.value == 'small':
self.title = screentitle
condtext = ""
if self.menu_path and not self.menu_path.endswith(' / '):
condtext = self.menu_path + " >"
elif self.menu_path:
condtext = self.menu_path[:-3] + " >"
self.menu_path_compressed = condtext
self.menu_path += screentitle + ' / '
else:
self.title = screentitle
self.menu_path_compressed = ""
self["menu_path_compressed"] = StaticText(self.menu_path_compressed)
Screen.setTitle(self, self.title)
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self['actions'].csel = self
self["actions"].setEnabled(False)
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self['tl_off'] = Pixmap()
self['tl_red'] = Pixmap()
self['tl_yellow'] = Pixmap()
self['tl_green'] = Pixmap()
self['feedStatusMSG'] = Label()
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.updating = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.onFirstExecBegin.append(self.checkNetworkState)
def checkNetworkState(self):
self['tl_red'].hide()
self['tl_yellow'].hide()
self['tl_green'].hide()
self['tl_off'].hide()
self.trafficLight = feedsstatuscheck.getFeedsBool()
if self.trafficLight in feedsstatuscheck.feed_status_msgs:
status_text = feedsstatuscheck.feed_status_msgs[self.trafficLight]
else:
status_text = _('Feeds status: Unexpected')
if self.trafficLight:
self['feedStatusMSG'].setText(status_text)
if self.trafficLight == 'stable':
self['tl_green'].show()
elif self.trafficLight == 'unstable':
self['tl_red'].show()
elif self.trafficLight == 'updating':
self['tl_yellow'].show()
else:
self['tl_off'].show()
if (getImageType() != 'release' and self.trafficLight != 'unknown') or (getImageType() == 'release' and self.trafficLight not in ('stable', 'unstable')):
self.session.openWithCallback(self.close, MessageBox, feedsstatuscheck.getFeedsErrorMessage(), type=MessageBox.TYPE_INFO, timeout=30, close_on_any_key=True)
return
else:
if getImageType() != 'release' or (config.softwareupdate.updateisunstable.value == '1' and config.softwareupdate.updatebeta.value) or config.softwareupdate.updateisunstable.value == '0':
if kernelMismatch():
self.session.openWithCallback(self.close, MessageBox, _("The Linux kernel has changed, an update is not permitted. \nInstall latest image using USB stick or Image Manager."), type=MessageBox.TYPE_INFO, timeout=30, close_on_any_key=True)
return
message = statusMessage()
if message:
message += "\nDo you want to continue?"
self.session.openWithCallback(self.statusMessageCallback, MessageBox, message, type=MessageBox.TYPE_YESNO, default=False)
else:
self.startCheck()
else:
self.session.openWithCallback(self.close, MessageBox, _("Sorry the feeds seem to be in an unstable state, if you wish to use them please enable 'Allow unstable (experimental) updates' in \"Software update settings\"."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
def statusMessageCallback(self, answer):
if answer:
self.startCheck()
else:
self.close()
def startCheck(self):
self.updating = True
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
# We've just manually checked for an update, so note this time as the last
# check time, then update the next autocheck time too.
#
from time import time
config.softwareupdate.updatelastcheck.setValue(int(time()))
config.softwareupdate.updatelastcheck.save()
from Components.OnlineUpdateCheck import onlineupdatecheckpoller
onlineupdatecheckpoller.start()
def isProtected(self):
return config.ParentalControl.setuppinactive.value and\
(not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and\
config.ParentalControl.config_sections.software_update.value
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if param in self.sliderPackages:
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self["actions"].setEnabled(True)
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % param
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
self.updating = False
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = None
if getImageType() != 'release' or (config.softwareupdate.updateisunstable.value == '1' and config.softwareupdate.updatebeta.value):
self.total_packages = len(self.ipkg.getFetchedList())
message = _("The current update may be unstable") + "\n" + _("Are you sure you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
elif config.softwareupdate.updateisunstable.value == '0':
self.total_packages = len(self.ipkg.getFetchedList())
message = _("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
if self.total_packages > 150:
message += " " + _("Reflash recommended!")
if self.total_packages:
global ocram
ocram = ''
for package_tmp in self.ipkg.getFetchedList():
if package_tmp[0].startswith('enigma2-plugin-picons-snp'):
ocram = ocram + '[ocram-picons] ' + package_tmp[0].split('enigma2-plugin-picons-snp-')[1].replace('.',' ') + ' updated ' + package_tmp[2].replace('--',' ') + '\n'
elif package_tmp[0].startswith('enigma2-plugin-picons-srp'):
ocram = ocram + '[ocram-picons] ' + package_tmp[0].split('enigma2-plugin-picons-srp-')[1].replace('.',' ') + ' updated ' + package_tmp[2].replace('--',' ') + '\n'
config.softwareupdate.updatefound.setValue(True)
choices = [(_("View the changes"), "changes"),
(_("Upgrade and reboot system"), "cold")]
if path.exists("/usr/lib/enigma2/python/Plugins/SystemPlugins/OBH/BackupManager.pyo"):
if not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_("Perform a settings backup,") + '\n\t' + _("making a backup before updating") + '\n\t' +_("is strongly advised."), "backup"))
if not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
self["actions"].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, UpdateChoices, text=message, list=choices, skin_name = "SoftwareUpdateChoices", var=self.trafficLight, menu_path=self.menu_path_compressed)
upgrademessage.setTitle(self.title)
else:
message = _("No updates found, Press OK to exit this screen.")
choices = [(_("Nothing to upgrade"), "")]
self["actions"].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, UpdateChoices, text=message, list=choices, skin_name = "SoftwareUpdateChoices", var=self.trafficLight, menu_path=self.menu_path_compressed)
upgrademessage.setTitle(self.title)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s.") % (getMachineBrand(), getMachineName(), getMachineBrand(), getMachineName())
if self.packages == 0:
if self.error != 0:
error = _("Problem retrieving update list.\nIf this issue persists please check/report on forum")
else:
error = _("A background update check is in progress,\nplease wait a few minutes and try again.")
if self.updating:
error = _("Update failed. Your %s %s does not have a working internet connection.") % (getMachineBrand(), getMachineName())
self.status.setText(_("Error") + " - " + error)
self["actions"].setEnabled(True)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "menu":
if config.softwareupdate.updateisunstable.value == '1':
message = _("The current update may be unstable") + "\n" + _("Are you sure you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(%s " % self.total_packages + _("Packages") + ")"
elif config.softwareupdate.updateisunstable.value == '0':
message = _("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(%s " % self.total_packages + _("Packages") + ")"
choices = [(_("View the changes"), "changes"),
(_("Upgrade and reboot system"), "cold")]
if not self.SettingsBackupDone and not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_("Perform a settings backup, making a backup before updating is strongly advised."), "backup"))
if not self.ImageBackupDone and not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
self["actions"].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, UpdateChoices, text=message, list=choices, skin_name="SoftwareUpdateChoices", var=self.trafficLight, menu_path=self.menu_path_compressed)
upgrademessage.setTitle(self.title)
elif answer[1] == "changes":
self.session.openWithCallback(self.startActualUpgrade,SoftwareUpdateChanges, self.menu_path)
elif answer[1] == "backup":
self.doSettingsBackup()
elif answer[1] == "imagebackup":
self.doImageBackup()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
elif answer[1] == "cold":
if (config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value) or (config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value):
self.doAutoBackup()
else:
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def doSettingsBackup(self):
backup = None
from Plugins.SystemPlugins.OBH.BackupManager import BackupFiles
self.BackupFiles = BackupFiles(self.session, True)
Components.Task.job_manager.AddJob(self.BackupFiles.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('obh', 'Backup manager'):
break
self.showJobView(job)
def doImageBackup(self):
backup = None
from Plugins.SystemPlugins.OBH.ImageManager import ImageBackup
self.ImageBackup = ImageBackup(self.session, True)
Components.Task.job_manager.AddJob(self.ImageBackup.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('obh', 'Image manager'):
break
self.showJobView(job)
def doAutoBackup(self, val = False):
self.autobackuprunning = True
if config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value and not self.SettingsBackupDone:
self.doSettingsBackup()
elif config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value and not self.ImageBackupDone:
self.doImageBackup()
else:
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
def showJobView(self, job):
if job.name == dgettext('OBH', 'Image manager'):
self.ImageBackupDone = True
elif job.name == dgettext('obh', 'Backup manager'):
self.SettingsBackupDone = True
from Screens.TaskView import JobView
Components.Task.job_manager.in_background = False
if not self.autobackuprunning:
self.session.openWithCallback(self.startActualUpgrade(("menu", "menu")), JobView, job, cancelable = False, backgroundable = False, afterEventChangeable = False, afterEvent="close")
else:
self.session.openWithCallback(self.doAutoBackup, JobView, job, cancelable = False, backgroundable = False, afterEventChangeable = False, afterEvent="close")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Upgrade finished.") +" "+_("Do you want to reboot your %s %s") % (getMachineBrand(), getMachineName()))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
class UpdatePlugin(Screen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="620,160" title="Software update">
<widget name="activityslider" position="10,10" size="600,10" borderWidth="2" borderColor="#cccccc"/>
<widget source="package" render="Label" position="10,40" size="600,25" font="Regular;22" />
<widget source="status" render="Label" position="10,70" size="600,45" font="Regular;22" />
<widget name="slider" position="10,140" size="600,12" borderWidth="2" borderColor="#cccccc" />
</screen>"""
def __init__(self, session, args = None):
Screen.__init__(self, session)
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Verifying your internet connection..."))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.modified_packages = []
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer_conn = self.activityTimer.timeout.connect(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.updating = False
self.rebootRequired = False
self.device_name = iSoftwareTools.hardware_info.device_name
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self.checkNetwork()
self.onClose.append(self.cleanup)
def cleanup(self):
iSoftwareTools.cleanupSoftwareTools()
def checkNetwork(self):
if eNetworkManager.getInstance().online():
self.updating = True
self.activityTimer.start(100, False)
self.package.setText(_("Package list update"))
self.status.setText(_("Upgrading Dreambox... Please wait"))
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.package.setText(_("Your network is not working. Please try again."))
self.status.setText(self.oktext)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
iSoftwareTools.listUpgradable(self.listUpgradableCB)
elif self.error == 0:
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(_("Done - Installed or upgraded %d packages") % self.packages)
self.status.setText(self.oktext)
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("your dreambox might be unusable now. Please consult the manual for further assistance before rebooting your dreambox.")
if self.packages == 0:
error = _("No packages were upgraded yet. So you can check your network and try again.")
if self.updating:
error = _("Your dreambox isn't connected to the internet properly. Please check it and try again.")
self.status.setText(_("Error") + " - " + error)
#print event, "-", param
pass
def listUpgradableCB(self, res):
if iSoftwareTools.upgradeAvailable is False:
self.updating = False
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(_("Done - No updates available."))
self.status.setText(self.oktext)
else:
self.updating = False
upgrade_args = {'use_maintainer' : True, 'test_only': False}
if config.plugins.softwaremanager.overwriteConfigFiles.value == 'N':
upgrade_args = {'use_maintainer' : False, 'test_only': False}
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args = upgrade_args)
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0:
self.session.openWithCallback(self.exitReboot, MessageBox, _("Upgrade finished.") +" "+_("Do you want to reboot your Dreambox?"))
else:
self.close()
else:
if not self.updating:
self.close()
def exitReboot(self, result):
if result:
quitMainloop(2)
self.close()
def exitRestart(self, result):
if result:
quitMainloop(3)
self.close()
class SoftwareTools(PackageInfoHandler):
lastDownloadDate = None
NetworkConnectionAvailable = None
list_updating = False
available_updates = 0
available_updatelist = []
available_packetlist = []
installed_packetlist = {}
def __init__(self):
aboutInfo = getImageVersion()
if aboutInfo.startswith("dev-"):
self.ImageVersion = 'Experimental'
else:
self.ImageVersion = 'Stable'
self.language = language.getLanguage()[:2] # getLanguage returns e.g. "fi_FI" for "language_country"
PackageInfoHandler.__init__(self, self.statusCallback, blocking=False, neededTag='ALL_TAGS', neededFlag=self.ImageVersion)
self.directory = resolveFilename(SCOPE_METADIR)
self.hardware_info = HardwareInfo()
self.list = List([])
self.NotifierCallback = None
self.Console = Console()
self.UpdateConsole = Console()
self.cmdList = []
self.unwanted_extensions = ('-dbg', '-dev', '-doc', '-staticdev', '-src')
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def statusCallback(self, status, progress):
pass
def startSoftwareTools(self, callback=None):
if callback is not None:
self.NotifierCallback = callback
iNetwork.checkNetworkState(self.checkNetworkCB)
def checkNetworkCB(self, data):
if data is not None:
if data <= 2:
self.NetworkConnectionAvailable = True
self.getUpdates()
else:
self.NetworkConnectionAvailable = False
self.getUpdates()
def getUpdates(self, callback=None):
if self.lastDownloadDate is None:
if self.NetworkConnectionAvailable:
self.lastDownloadDate = time()
if self.list_updating is False and callback is None:
self.list_updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is False and callback is not None:
self.list_updating = True
self.NotifierCallback = callback
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is True and callback is not None:
self.NotifierCallback = callback
else:
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
else:
if self.NetworkConnectionAvailable:
self.lastDownloadDate = time()
if self.list_updating is False and callback is None:
self.list_updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is False and callback is not None:
self.list_updating = True
self.NotifierCallback = callback
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
elif self.list_updating is True and callback is not None:
self.NotifierCallback = callback
else:
if self.list_updating and callback is not None:
self.NotifierCallback = callback
self.startIpkgListAvailable()
else:
self.list_updating = False
if callback is not None:
callback(False)
elif self.NotifierCallback is not None:
self.NotifierCallback(False)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
self.list_updating = False
if self.NotifierCallback is not None:
self.NotifierCallback(False)
elif event == IpkgComponent.EVENT_DONE:
if self.list_updating:
self.startIpkgListAvailable()
def startIpkgListAvailable(self, callback=None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = self.ipkg.ipkg + " list"
self.UpdateConsole.ePopen(cmd, self.IpkgListAvailableCB, callback)
def IpkgListAvailableCB(self, result, retval, extra_args=None):
(callback) = extra_args or None
if result:
if self.list_updating:
self.available_packetlist = []
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 1 and tokens[1].strip() or ""
descr = l > 2 and tokens[2].strip() or ""
self.available_packetlist.append([name, version, descr])
if callback is None:
self.startInstallMetaPackage()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def startInstallMetaPackage(self, callback=None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if self.NetworkConnectionAvailable:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = self.ipkg.ipkg + " install enigma2-meta enigma2-plugins-meta enigma2-skins-meta"
self.UpdateConsole.ePopen(cmd, self.InstallMetaPackageCB, callback)
else:
self.InstallMetaPackageCB(True)
def InstallMetaPackageCB(self, result, retval=None, extra_args=None):
(callback) = extra_args or None
if result:
self.fillPackagesIndexList()
if callback is None:
self.startIpkgListInstalled()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def startIpkgListInstalled(self, callback=None):
if callback is not None:
self.list_updating = True
if self.list_updating:
if not self.UpdateConsole:
self.UpdateConsole = Console()
cmd = self.ipkg.ipkg + " list_installed"
self.UpdateConsole.ePopen(cmd, self.IpkgListInstalledCB, callback)
def IpkgListInstalledCB(self, result, retval, extra_args=None):
(callback) = extra_args or None
if result:
self.installed_packetlist = {}
for x in result.splitlines():
tokens = x.split(' - ')
name = tokens[0].strip()
if not any(name.endswith(x) for x in self.unwanted_extensions):
l = len(tokens)
version = l > 1 and tokens[1].strip() or ""
self.installed_packetlist[name] = version
for package in self.packagesIndexlist[:]:
if not self.verifyPrerequisites(package[0]["prerequisites"]):
self.packagesIndexlist.remove(package)
for package in self.packagesIndexlist[:]:
attributes = package[0]["attributes"]
if "packagetype" in attributes:
if attributes["packagetype"] == "internal":
self.packagesIndexlist.remove(package)
if callback is None:
self.countUpdates()
else:
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
callback(True)
else:
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(False)
def countUpdates(self, callback=None):
self.available_updates = 0
self.available_updatelist = []
for package in self.packagesIndexlist[:]:
attributes = package[0]["attributes"]
packagename = attributes["packagename"]
for x in self.available_packetlist:
if x[0] == packagename:
if packagename in self.installed_packetlist:
if self.installed_packetlist[packagename] != x[1]:
self.available_updates += 1
self.available_updatelist.append([packagename])
self.list_updating = False
if self.UpdateConsole:
if len(self.UpdateConsole.appContainers) == 0:
if callback is not None:
callback(True)
callback = None
elif self.NotifierCallback is not None:
self.NotifierCallback(True)
self.NotifierCallback = None
def startIpkgUpdate(self, callback=None):
if not self.Console:
self.Console = Console()
cmd = self.ipkg.ipkg + " update"
self.Console.ePopen(cmd, self.IpkgUpdateCB, callback)
def IpkgUpdateCB(self, result, retval, extra_args=None):
(callback) = extra_args or None
if result:
if self.Console:
if len(self.Console.appContainers) == 0:
if callback is not None:
callback(True)
callback = None
def cleanupSoftwareTools(self):
self.list_updating = False
if self.NotifierCallback is not None:
self.NotifierCallback = None
self.ipkg.stop()
if self.Console is not None:
if len(self.Console.appContainers):
for name in self.Console.appContainers.keys():
self.Console.kill(name)
if self.UpdateConsole is not None:
if len(self.UpdateConsole.appContainers):
for name in self.UpdateConsole.appContainers.keys():
self.UpdateConsole.kill(name)
def verifyPrerequisites(self, prerequisites):
if "hardware" in prerequisites:
hardware_found = False
for hardware in prerequisites["hardware"]:
if hardware == getBoxType():
hardware_found = True
if not hardware_found:
return False
return True
class UpdatePlugin(Screen):
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software Update"))
self.sliderPackages = {"dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3}
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
status_msgs = {
"stable": _("Feeds status: Stable"),
"unstable": _("Feeds status: Unstable"),
"updating": _("Feeds status: Updating"),
"unknown": _("No connection"),
}
self["tl_off"] = Pixmap()
self["tl_red"] = Pixmap()
self["tl_yellow"] = Pixmap()
self["tl_green"] = Pixmap()
self.feedsStatus()
self["feedStatusMSG"] = Label(status_msgs[self.trafficLight])
self.channellist_only = 0
self.channellist_name = ""
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.checkNetworkState()
def feedsStatus(self):
from urllib import urlopen
import socket
self["tl_red"].hide()
self["tl_yellow"].hide()
self["tl_green"].hide()
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
try:
d = urlopen("http://openvix.co.uk/TrafficLightState.php")
self.trafficLight = d.read()
if self.trafficLight == "unstable":
self["tl_off"].hide()
self["tl_red"].show()
elif self.trafficLight == "updating":
self["tl_off"].hide()
self["tl_yellow"].show()
elif self.trafficLight == "stable":
self["tl_off"].hide()
self["tl_green"].show()
else:
self.trafficLight = "unknown"
self["tl_off"].show()
except:
self.trafficLight = "unknown"
self["tl_off"].show()
socket.setdefaulttimeout(currentTimeoutDefault)
def checkNetworkState(self):
cmd1 = "opkg update"
self.CheckConsole = Console()
self.CheckConsole.ePopen(cmd1, self.checkNetworkStateFinished)
def checkNetworkStateFinished(self, result, retval, extra_args=None):
if "bad address" in result:
self.session.openWithCallback(
self.close,
MessageBox,
_("Your %s %s is not connected to the internet, please check your network settings and try again.")
% (getMachineBrand(), getMachineName()),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True,
)
elif ("wget returned 1" or "wget returned 255" or "404 Not Found") in result:
self.session.openWithCallback(
self.close,
MessageBox,
_(
"Sorry feeds are down for maintenance, please try again later. If this issue persists please check openvix.co.uk or world-of-satellite.com."
),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True,
)
elif "Collected errors" in result:
self.session.openWithCallback(
self.close,
MessageBox,
_("A background update check is in progress, please wait a few minutes and try again."),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True,
)
else:
self.startCheck()
def startCheck(self):
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.updating = False
self["actions"] = ActionMap(["WizardActions"], {"ok": self.exit, "back": self.exit}, -1)
self.updating = True
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(
ngettext(
"Update completed, %d package was installed.",
"Update completed, %d packages were installed.",
self.packages,
)
% self.packages
)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_(
"A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?"
)
% param,
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
from urllib import urlopen
import socket
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
status = urlopen("http://www.openvix.co.uk/feeds/status").read()
if "404 Not Found" in status:
status = "1"
config.softwareupdate.updateisunstable.setValue(status)
socket.setdefaulttimeout(currentTimeoutDefault)
self.total_packages = None
if config.softwareupdate.updateisunstable.value == "1" and config.softwareupdate.updatebeta.value:
self.total_packages = len(self.ipkg.getFetchedList())
message = (
_("The current update may be unstable")
+ "\n"
+ _("Are you sure you want to update your %s %s ?") % (getMachineBrand(), getMachineName())
+ "\n("
+ (
ngettext(
"%s updated package available", "%s updated packages available", self.total_packages
)
% self.total_packages
)
+ ")"
)
elif config.softwareupdate.updateisunstable.value == "0":
self.total_packages = len(self.ipkg.getFetchedList())
message = (
_("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName())
+ "\n("
+ (
ngettext(
"%s updated package available", "%s updated packages available", self.total_packages
)
% self.total_packages
)
+ ")"
)
if self.total_packages:
global ocram
for package_tmp in self.ipkg.getFetchedList():
if package_tmp[0].startswith("enigma2-plugin-picons-tv-ocram"):
ocram = (
ocram
+ "[ocram-picons] "
+ package_tmp[0].split("enigma2-plugin-picons-tv-ocram.")[1]
+ "updated "
+ package_tmp[2]
+ "\n"
)
elif package_tmp[0].startswith("enigma2-plugin-settings-ocram"):
ocram = (
ocram
+ "[ocram-settings] "
+ package_tmp[0].split("enigma2-plugin-picons-tv-ocram.")[1]
+ "updated "
+ package_tmp[2]
+ "\n"
)
config.softwareupdate.updatefound.setValue(True)
choices = [(_("View the changes"), "changes"), (_("Upgrade and reboot system"), "cold")]
if path.exists("/usr/lib/enigma2/python/Plugins/SystemPlugins/ViX/BackupManager.pyo"):
if (
not config.softwareupdate.autosettingsbackup.value
and config.backupmanager.backuplocation.value
):
choices.append(
(
_("Perform a settings backup,")
+ "\n\t"
+ _("making a backup before updating")
+ "\n\t"
+ _("is strongly advised."),
"backup",
)
)
if not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
upgrademessage = self.session.openWithCallback(
self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices,
skin_name="SoftwareUpdateChoices",
var=self.trafficLight,
)
upgrademessage.setTitle(_("Software update"))
else:
upgrademessage = self.session.openWithCallback(
self.close,
MessageBox,
_("Nothing to upgrade"),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True,
)
upgrademessage.setTitle(_("Software update"))
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {"package": self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {"package": self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
"Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s."
) % (getMachineBrand(), getMachineName(), getMachineBrand(), getMachineName())
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _("Update failed. Your %s %s does not have a working internet connection.") % (
getMachineBrand(),
getMachineName(),
)
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if "enigma2-plugin-settings-" in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
# print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "menu":
if config.softwareupdate.updateisunstable.value == "1":
message = (
_("The current update may be unstable")
+ "\n"
+ _("Are you sure you want to update your %s %s ?") % (getMachineBrand(), getMachineName())
+ "\n(%s " % self.total_packages
+ _("Packages")
+ ")"
)
elif config.softwareupdate.updateisunstable.value == "0":
message = (
_("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName())
+ "\n(%s " % self.total_packages
+ _("Packages")
+ ")"
)
choices = [(_("View the changes"), "changes"), (_("Upgrade and reboot system"), "cold")]
if (
not self.SettingsBackupDone
and not config.softwareupdate.autosettingsbackup.value
and config.backupmanager.backuplocation.value
):
choices.append(
(_("Perform a settings backup, making a backup before updating is strongly advised."), "backup")
)
if (
not self.ImageBackupDone
and not config.softwareupdate.autoimagebackup.value
and config.imagemanager.backuplocation.value
):
choices.append((_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
upgrademessage = self.session.openWithCallback(
self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices,
skin_name="SoftwareUpdateChoices",
var=self.trafficLight,
)
upgrademessage.setTitle(_("Software update"))
elif answer[1] == "changes":
self.session.openWithCallback(self.startActualUpgrade, SoftwareUpdateChanges)
elif answer[1] == "backup":
self.doSettingsBackup()
elif answer[1] == "imagebackup":
self.doImageBackup()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args={"installed_only": True})
elif answer[1] == "cold":
if (config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value) or (
config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value
):
self.doAutoBackup()
else:
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def doSettingsBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.BackupManager import BackupFiles
self.BackupFiles = BackupFiles(self.session, True)
Components.Task.job_manager.AddJob(self.BackupFiles.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext("vix", "Backup Manager"):
break
self.showJobView(job)
def doImageBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.ImageManager import ImageBackup
self.ImageBackup = ImageBackup(self.session, True)
Components.Task.job_manager.AddJob(self.ImageBackup.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext("vix", "Image Manager"):
break
self.showJobView(job)
def doAutoBackup(self, val=False):
self.autobackuprunning = True
if (
config.softwareupdate.autosettingsbackup.value
and config.backupmanager.backuplocation.value
and not self.SettingsBackupDone
):
self.doSettingsBackup()
elif (
config.softwareupdate.autoimagebackup.value
and config.imagemanager.backuplocation.value
and not self.ImageBackupDone
):
self.doImageBackup()
else:
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
def showJobView(self, job):
if job.name == dgettext("vix", "Image Manager"):
self.ImageBackupDone = True
elif job.name == dgettext("vix", "Backup Manager"):
self.SettingsBackupDone = True
from Screens.TaskView import JobView
Components.Task.job_manager.in_background = False
if not self.autobackuprunning:
self.session.openWithCallback(
self.startActualUpgrade(("menu", "menu")),
JobView,
job,
cancelable=False,
backgroundable=False,
afterEventChangeable=False,
afterEvent="close",
)
else:
self.session.openWithCallback(
self.doAutoBackup,
JobView,
job,
cancelable=False,
backgroundable=False,
afterEventChangeable=False,
afterEvent="close",
)
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(
self.exitAnswer,
MessageBox,
_("Upgrade finished.")
+ " "
+ _("Do you want to reboot your %s %s") % (getMachineBrand(), getMachineName()),
)
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
class CleanupWizard(WizardLanguage, Rc):
skin = """
<screen name="CleanupWizard" position="0,0" size="720,576" title="Welcome..." flags="wfNoBorder" >
<widget name="text" position="153,40" size="380,330" font="Regular;22" />
<widget source="list" render="Listbox" position="43,300" size="460,220" scrollbarMode="showOnDemand" >
<convert type="StringList" />
</widget>
<widget name="config" position="53,340" zPosition="1" size="440,180" transparent="1" scrollbarMode="showOnDemand" />
<ePixmap pixmap="skin_default/buttons/button_red.png" position="40,225" zPosition="0" size="15,16" transparent="1" alphatest="on" />
<widget name="languagetext" position="55,225" size="95,30" font="Regular;18" />
<widget name="wizard" pixmap="skin_default/wizard.png" position="40,50" zPosition="10" size="110,174" alphatest="on" />
<widget name="rc" pixmaps="skin_default/rc0.png,skin_default/rc1.png,skin_default/rc2.png" position="530,50" zPosition="10" size="154,500" alphatest="on" />
<widget name="arrowdown" pixmap="skin_default/arrowdown.png" position="-100,-100" zPosition="11" size="37,70" alphatest="on" />
<widget name="arrowdown2" pixmap="skin_default/arrowdown.png" position="-100,-100" zPosition="11" size="37,70" alphatest="on" />
<widget name="arrowup" pixmap="skin_default/arrowup.png" position="-100,-100" zPosition="11" size="37,70" alphatest="on" />
<widget name="arrowup2" pixmap="skin_default/arrowup.png" position="-100,-100" zPosition="11" size="37,70" alphatest="on" />
</screen>"""
def __init__(self, session):
self.xmlfile = resolveFilename(SCOPE_PLUGINS, "SystemPlugins/CleanupWizard/cleanupwizard.xml")
WizardLanguage.__init__(self, session, showSteps = False, showStepSlider = False)
Rc.__init__(self)
self.session = session
self["wizard"] = Pixmap()
self.selectedAction = None
self.selectedPackage = None
self.NextStep = None
self.Text = None
self.buildListRef = None
self.RemoveRef = None
self.excluded_extensions = ('-skins', '-streamproxy', '-frontprocessorupgrade', '-crashlogautosubmit', '-hotplug', '-webinterface', '-mediascanner', '-genuinedreambox', '-mediaplayer', '-pictureplayer', '-dvdplayer', '-dvdburn', '-videotune', '-videomode', '-softwaremanager', '-skinselector', '-satfinder' )
self.Console = Console()
self.installed_packetlist = []
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def markDone(self):
pass
def listAction(self):
list = []
list.append((_("OK, remove some extensions"), "removeextensions"))
list.append((_("Exit the cleanup wizard"), "end"))
return list
def listAgainAction(self):
list = []
list.append((_("OK, remove another extensions"), "removeextensions"))
list.append((_("Exit the cleanup wizard"), "end"))
return list
def ActionSelectionMade(self, index):
self.selectedAction = index
self.ActionSelect(index)
def ActionSelect(self, index):
if index == 'end':
self.NextStep = 'end'
else:
self.NextStep = 'removeextensions'
def ActionSelectionMoved(self):
self.ActionSelect(self.selection)
def buildList(self,action):
if self.NextStep is not 'end':
if not self.Console:
self.Console = Console()
cmd = "opkg list_installed | grep enigma2"
self.Console.ePopen(cmd, self.buildListInstalled_Finished)
self.buildListRef = self.session.openWithCallback(self.buildListfinishedCB, MessageBox, _("Please wait while searching for removable packages..."), type = MessageBox.TYPE_INFO, enable_input = False)
else:
self.buildListfinishedCB(False)
def buildListInstalled_Finished(self, result, retval, extra_args = None):
if len(result):
self.installed_packetlist = []
for x in result.splitlines():
split = x.split(' - ')
if not any(split[0].strip().endswith(x) for x in self.excluded_extensions): #ignore some base plugins
if split[0].strip() != 'enigma2':
self.installed_packetlist.append((split[0].strip()))
self.buildListRef.close(True)
def buildListfinishedCB(self,data):
self.buildListRef = None
if data is True:
self.currStep = self.getStepWithID(self.NextStep)
self.afterAsyncCode()
else:
self.currStep = self.getStepWithID(self.NextStep)
self.afterAsyncCode()
def listInstalledPackages(self):
list = []
if self.installed_packetlist and len(self.installed_packetlist):
for x in self.installed_packetlist:
if x.startswith('enigma2-plugin-'):
pluginname = x.replace("enigma2-plugin-","")
elif x.startswith('enigma2-skin-'):
pluginname = x.replace("enigma2-","")
else:
pluginname = x
list.append( (pluginname,x) )
return list
def PackageSelectionMade(self, index):
self.PackageSelect(index)
def PackageSelectionMoved(self):
self.PackageSelect(self.selection)
def PackageSelect(self, package):
self.selectedPackage = package
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_ERROR:
freeSpace = checkFreeSpaceAvailable()
txt_line1 = _("There was an error. The package:") + "\n" + str(self.selectedPackage) + "\n" + _("could not be removed") + "\n"
txt_line2 = _("There are now ") + str(freeSpace) + " kB " + _("available") + "\n\n"
txt_line3 = _("Please select an option below.")
self.Text = txt_line1 + txt_line2 + txt_line3
self.NextStep = 'StatusRemoveERROR'
self.RemoveRef.close(True)
elif event == IpkgComponent.EVENT_DONE:
freeSpace = checkFreeSpaceAvailable()
txt_line1 = _("The package:") + "\n" + str(self.selectedPackage) + "\n" + _("was removed successfully") + "\n"
txt_line2 = _("There are now ") + str(freeSpace) + " kB " + _("available") + "\n\n"
txt_line3 = _("Please select an option below.")
self.Text = txt_line1 + txt_line2 + txt_line3
self.NextStep = 'StatusRemoveOK'
self.RemoveRef.close(True)
pass
def removeExtension(self,extension):
if self.NextStep is not 'end':
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': extension})
self.RemoveRef = self.session.openWithCallback(self.removeExtensionFinishedCB, MessageBox, _("Please wait while removing selected package..."), type = MessageBox.TYPE_INFO, enable_input = False)
else:
self.buildListfinishedCB(False)
def removeExtensionFinishedCB(self,data):
self.RemoveRef = None
if data is True:
self.currStep = self.getStepWithID(self.NextStep)
self.afterAsyncCode()
else:
self.currStep = self.getStepWithID(self.NextStep)
self.afterAsyncCode()
class UpdatePlugin(Screen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software Update"))
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.checkNetworkState()
def checkNetworkState(self):
cmd1 = "opkg update"
self.CheckConsole = Console()
self.CheckConsole.ePopen(cmd1, self.checkNetworkStateFinished)
def checkNetworkStateFinished(self, result, retval,extra_args=None):
if 'bad address' in result:
self.session.openWithCallback(self.close, MessageBox, _("Your %s %s is not connected to the internet, please check your network settings and try again.") % (getMachineBrand(), getMachineName()), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif ('wget returned 1' or 'wget returned 255' or '404 Not Found') in result:
self.session.openWithCallback(self.close, MessageBox, _("Sorry feeds are down for maintenance, please try again later."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif 'Collected errors' in result:
self.session.openWithCallback(self.close, MessageBox, _("A background update check is in progress, please wait a few minutes and try again."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
else:
self.startCheck()
def startCheck(self):
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self.updating = False
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self.updating = True
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % (param)
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
message = _("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
(_("Update channel list only"), "channels"),
(_("Cancel"), "")]
self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices)
else:
self.session.openWithCallback(self.close, MessageBox, _("No updates available"), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s.") % (getMachineBrand(), getMachineName(), getMachineBrand(), getMachineName())
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _("Update failed. Your %s %s does not have a working internet connection.") % (getMachineBrand(), getMachineName())
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args = {'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Upgrade finished.") +" "+_("Do you want to reboot your %s %s") % (getMachineBrand(), getMachineName()))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop,retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class UpdatePlugin(Screen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
Screen.setTitle(self, _("Software Update"))
self.sliderPackages = {
"dreambox-dvb-modules": 1,
"enigma2": 2,
"tuxbox-image-info": 3
}
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.checkNetworkState()
def checkNetworkState(self):
cmd1 = "opkg update"
self.CheckConsole = Console()
self.CheckConsole.ePopen(cmd1, self.checkNetworkStateFinished)
def checkNetworkStateFinished(self, result, retval, extra_args=None):
if 'bad address' in result:
self.session.openWithCallback(
self.close,
MessageBox,
_("Your %s %s is not connected to the internet, please check your network settings and try again."
) % (getMachineBrand(), getMachineName()),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
elif ('wget returned 1' or 'wget returned 255'
or '404 Not Found') in result:
self.session.openWithCallback(
self.close,
MessageBox,
_("Sorry feeds are down for maintenance, please try again later."
),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
elif 'Collected errors' in result:
self.session.openWithCallback(
self.close,
MessageBox,
_("A background update check is in progress, please wait a few minutes and try again."
),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
else:
self.startCheck()
def startCheck(self):
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self.updating = False
self["actions"] = ActionMap(["WizardActions"], {
"ok": self.exit,
"back": self.exit
}, -1)
self.updating = True
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(
ngettext("Update completed, %d package was installed.",
"Update completed, %d packages were installed.",
self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(
_("Upgrading") + ": %s/%s" %
(self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in (
"N", "Y"):
self.ipkg.write(
True and
config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback, MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?"
) % param)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
message = _("Do you want to update your %s %s ?") % (
getMachineBrand(), getMachineName()) + "\n(" + (
ngettext("%s updated package available",
"%s updated packages available",
self.total_packages) %
self.total_packages) + ")"
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
(_("Update channel list only"), "channels"),
(_("Cancel"), "")]
self.session.openWithCallback(self.startActualUpgrade,
ChoiceBox,
title=message,
list=choices)
else:
self.session.openWithCallback(self.close,
MessageBox,
_("No updates available"),
type=MessageBox.TYPE_INFO,
timeout=10,
close_on_any_key=True)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(
_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _(
"Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s."
) % (getMachineBrand(), getMachineName(), getMachineBrand(),
getMachineName())
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _(
"Update failed. Your %s %s does not have a working internet connection."
) % (getMachineBrand(), getMachineName())
self.status.setText(_("Error") + " - " + error)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[
0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
fobj_in = open("/etc/image-version")
fobj_out = open("/etc/image-version_new", "w")
for line in fobj_in:
if "date" in line:
line = "date=" + time.strftime("%Y%m%d%H%M%S") + '\n'
fobj_out.write(line)
else:
fobj_out.write(line)
fobj_in.close()
fobj_out.close()
os.system("mv /etc/image-version_new /etc/image-version")
self.session.open(TryQuitMainloop, retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST,
args={'installed_only': True})
else:
fobj_in = open("/etc/image-version")
fobj_out = open("/etc/image-version_new", "w")
for line in fobj_in:
if "date" in line:
line = "date=" + time.strftime("%Y%m%d%H%M%S") + '\n'
fobj_out.write(line)
else:
fobj_out.write(line)
fobj_in.close()
fobj_out.close()
os.system("mv /etc/image-version_new /etc/image-version")
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE,
args={'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(
self.exitAnswer, MessageBox,
_("Upgrade finished.") + " " +
_("Do you want to reboot your %s %s") %
(getMachineBrand(), getMachineName()))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class UpdatePlugin(Screen, ProtectedScreen):
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
screentitle = _("Software Update")
self.menu_path = args[0]
if config.usage.show_menupath.value == 'large':
self.menu_path += screentitle
self.title = self.menu_path
self.menu_path_compressed = ""
self.menu_path += ' / '
elif config.usage.show_menupath.value == 'small':
self.title = screentitle
condtext = ""
if self.menu_path and not self.menu_path.endswith(' / '):
condtext = self.menu_path + " >"
elif self.menu_path:
condtext = self.menu_path[:-3] + " >"
self.menu_path_compressed = condtext
self.menu_path += screentitle + ' / '
else:
self.title = screentitle
self.menu_path_compressed = ""
self["menu_path_compressed"] = StaticText(self.menu_path_compressed)
Screen.setTitle(self, self.title)
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self['actions'].csel = self
self["actions"].setEnabled(False)
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self['tl_off'] = Pixmap()
self['tl_red'] = Pixmap()
self['tl_yellow'] = Pixmap()
self['tl_green'] = Pixmap()
self['feedStatusMSG'] = Label()
self.channellist_only = 0
self.channellist_name = ''
self.SettingsBackupDone = False
self.ImageBackupDone = False
self.autobackuprunning = False
self.updating = False
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.onFirstExecBegin.append(self.checkNetworkState)
def checkNetworkState(self):
self['tl_red'].hide()
self['tl_yellow'].hide()
self['tl_green'].hide()
self['tl_off'].hide()
self.trafficLight = feedsstatuscheck.getFeedsBool()
if self.trafficLight in feedsstatuscheck.feed_status_msgs:
status_text = feedsstatuscheck.feed_status_msgs[self.trafficLight]
else:
status_text = _('Feeds status: Unexpected')
if self.trafficLight:
self['feedStatusMSG'].setText(status_text)
if self.trafficLight == 'stable':
self['tl_green'].show()
elif self.trafficLight == 'unstable':
self['tl_red'].show()
elif self.trafficLight == 'updating':
self['tl_yellow'].show()
else:
self['tl_off'].show()
if (getImageType() != 'release' and self.trafficLight != 'unknown') or (getImageType() == 'release' and self.trafficLight not in ('stable', 'unstable')):
self.session.openWithCallback(self.close, MessageBox, feedsstatuscheck.getFeedsErrorMessage(), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
else:
if getImageType() != 'release' or (config.softwareupdate.updateisunstable.value == '1' and config.softwareupdate.updatebeta.value) or config.softwareupdate.updateisunstable.value == '0':
self.startCheck()
else:
self.session.openWithCallback(self.close, MessageBox, _("Sorry the feeds seem to be in an unstable state, if you wish to use them please enable 'Allow unstable (experimental) updates' in \"Software update settings\"."), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
def startCheck(self):
self.updating = True
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.doActivityTimer)
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.activityTimer.start(100, False)
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def isProtected(self):
return config.ParentalControl.setuppinactive.value and\
(not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and\
config.ParentalControl.config_sections.software_update.value
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event == IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event == IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event == IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self["actions"].setEnabled(True)
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % param
)
elif event == IpkgComponent.EVENT_ERROR:
self.error += 1
self.updating = False
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = None
if getImageType() != 'release' or (config.softwareupdate.updateisunstable.value == '1' and config.softwareupdate.updatebeta.value):
self.total_packages = len(self.ipkg.getFetchedList())
message = _("The current update may be unstable") + "\n" + _("Are you sure you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
elif config.softwareupdate.updateisunstable.value == '0':
self.total_packages = len(self.ipkg.getFetchedList())
message = _("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
if self.total_packages > 150:
message += " " + _("Reflash recommended!")
if self.total_packages:
global ocram
ocram = ''
for package_tmp in self.ipkg.getFetchedList():
if package_tmp[0].startswith('enigma2-plugin-picons-snp'):
ocram = ocram + '[ocram-picons] ' + package_tmp[0].split('enigma2-plugin-picons-snp-')[1].replace('.',' ') + ' updated ' + package_tmp[2].replace('--',' ') + '\n'
elif package_tmp[0].startswith('enigma2-plugin-picons-srp'):
ocram = ocram + '[ocram-picons] ' + package_tmp[0].split('enigma2-plugin-picons-srp-')[1].replace('.',' ') + ' updated ' + package_tmp[2].replace('--',' ') + '\n'
config.softwareupdate.updatefound.setValue(True)
choices = [(_("View the changes"), "changes"),
(_("Upgrade and reboot system"), "cold")]
if path.exists("/usr/lib/enigma2/python/Plugins/SystemPlugins/ViX/BackupManager.pyo"):
if not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_("Perform a settings backup,") + '\n\t' + _("making a backup before updating") + '\n\t' +_("is strongly advised."), "backup"))
if not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
self["actions"].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name = "SoftwareUpdateChoices", var=self.trafficLight, menu_path=self.menu_path_compressed)
upgrademessage.setTitle(self.title)
else:
self["actions"].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.close, MessageBox, _("Nothing to upgrade"), type=MessageBox.TYPE_INFO, timeout=10, close_on_any_key=True)
upgrademessage.setTitle(_('Software update'))
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your %s %s might be unusable now. Please consult the manual for further assistance before rebooting your %s %s.") % (getMachineBrand(), getMachineName(), getMachineBrand(), getMachineName())
if self.packages == 0:
error = _("A background update check is in progress,\nplease wait a few minutes and try again.")
if self.updating:
error = _("Update failed. Your %s %s does not have a working internet connection.") % (getMachineBrand(), getMachineName())
self.status.setText(_("Error") + " - " + error)
self["actions"].setEnabled(True)
elif event == IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "menu":
if config.softwareupdate.updateisunstable.value == '1':
message = _("The current update may be unstable") + "\n" + _("Are you sure you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(%s " % self.total_packages + _("Packages") + ")"
elif config.softwareupdate.updateisunstable.value == '0':
message = _("Do you want to update your %s %s ?") % (getMachineBrand(), getMachineName()) + "\n(%s " % self.total_packages + _("Packages") + ")"
choices = [(_("View the changes"), "changes"),
(_("Upgrade and reboot system"), "cold")]
if not self.SettingsBackupDone and not config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value:
choices.append((_("Perform a settings backup, making a backup before updating is strongly advised."), "backup"))
if not self.ImageBackupDone and not config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value:
choices.append((_("Perform a full image backup"), "imagebackup"))
choices.append((_("Update channel list only"), "channels"))
choices.append((_("Cancel"), ""))
self["actions"].setEnabled(True)
upgrademessage = self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices, skin_name="SoftwareUpdateChoices", var=self.trafficLight, menu_path=self.menu_path_compressed)
upgrademessage.setTitle(self.title)
elif answer[1] == "changes":
self.session.openWithCallback(self.startActualUpgrade,SoftwareUpdateChanges, self.menu_path)
elif answer[1] == "backup":
self.doSettingsBackup()
elif answer[1] == "imagebackup":
self.doImageBackup()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
elif answer[1] == "cold":
if (config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value) or (config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value):
self.doAutoBackup()
else:
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def doSettingsBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.BackupManager import BackupFiles
self.BackupFiles = BackupFiles(self.session, True)
Components.Task.job_manager.AddJob(self.BackupFiles.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('vix', 'Backup Manager'):
break
self.showJobView(job)
def doImageBackup(self):
backup = None
from Plugins.SystemPlugins.ViX.ImageManager import ImageBackup
self.ImageBackup = ImageBackup(self.session, True)
Components.Task.job_manager.AddJob(self.ImageBackup.createBackupJob())
Components.Task.job_manager.in_background = False
for job in Components.Task.job_manager.getPendingJobs():
if job.name == dgettext('vix', 'Image Manager'):
break
self.showJobView(job)
def doAutoBackup(self, val = False):
self.autobackuprunning = True
if config.softwareupdate.autosettingsbackup.value and config.backupmanager.backuplocation.value and not self.SettingsBackupDone:
self.doSettingsBackup()
elif config.softwareupdate.autoimagebackup.value and config.imagemanager.backuplocation.value and not self.ImageBackupDone:
self.doImageBackup()
else:
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
def showJobView(self, job):
if job.name == dgettext('vix', 'Image Manager'):
self.ImageBackupDone = True
elif job.name == dgettext('vix', 'Backup Manager'):
self.SettingsBackupDone = True
from Screens.TaskView import JobView
Components.Task.job_manager.in_background = False
if not self.autobackuprunning:
self.session.openWithCallback(self.startActualUpgrade(("menu", "menu")), JobView, job, cancelable = False, backgroundable = False, afterEventChangeable = False, afterEvent="close")
else:
self.session.openWithCallback(self.doAutoBackup, JobView, job, cancelable = False, backgroundable = False, afterEventChangeable = False, afterEvent="close")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Upgrade finished.") +" "+_("Do you want to reboot your %s %s") % (getMachineBrand(), getMachineName()))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop, retvalue=2)
self.close()
class DaemonsList(Screen):
def __init__(self, session, args = 0):
Screen.__init__(self, session)
self.running = list()
self.installed = list()
self.daemons = list()
self['menu'] = ExtrasList(list())
self['menu'].onSelectionChanged.append(self.selectionChanged)
self['key_green'] = Button('')
self['key_red'] = Button('')
self['key_blue'] = Button(_('Exit'))
self['key_yellow'] = Button('')
self['actions'] = ActionMap(['OkCancelActions', 'ColorActions'], {'blue': self.quit,
'yellow': self.yellow,
'red': self.red,
'green': self.green,
'cancel': self.quit}, -2)
self.onFirstExecBegin.append(self.drawList)
self.onShown.append(self.setWindowTitle)
def setWindowTitle(self):
self.setTitle(_('Daemons'))
def selectionChanged(self):
if len(self.daemons) > 0:
index = self['menu'].getSelectionIndex()
if self.installed[index]:
if self.running[index]:
self['key_red'].setText(_('Stop'))
else:
self['key_red'].setText(_('Start'))
if self.daemons[index][6]:
self['key_yellow'].setText(_('Configure'))
else:
self['key_yellow'].setText('')
self['key_green'].setText('')
else:
self['key_red'].setText('')
self['key_yellow'].setText('')
if self.daemons[index][9]:
self['key_green'].setText(_('Install'))
else:
self['key_green'].setText('')
def drawList(self, ret = None):
self.session.open(ExtraActionBox, _('Checking daemons status...'), _('Daemons'), self.actionDrawList)
def actionDrawList(self):
self.ishowed = True
if len(self.daemons) == 0:
self.loadList()
self.checkInstalled()
self.checkRunning()
list = []
i = 0
for daemon in self.daemons:
list.append(DaemonEntry(daemon[0], 'Daemons/%s' % daemon[2], daemon[1], self.running[i], self.installed[i]))
i += 1
self['menu'].setList(list)
def checkRunning(self):
self.running = list()
for daemon in self.daemons:
self.running.append(daemon[3]())
def checkInstalled(self):
self.installed = list()
for daemon in self.daemons:
self.installed.append(daemon[7]())
def loadList(self):
self.daemons = list()
tdaemons = crawlDirectory('%s/Daemons/' % os.path.dirname(sys.modules[__name__].__file__), '.*\\.ext$')
tdaemons.sort()
for daemon in tdaemons:
if daemon[1][:1] != '.':
try:
src = open(os.path.join(daemon[0], daemon[1]))
exec src.read()
src.close()
self.daemons.append((daemon_name,
daemon_description,
daemon_icon,
daemon_fnc_status,
daemon_fnc_start,
daemon_fnc_stop,
daemon_class_config,
daemon_fnc_installed,
daemon_fnc_boot,
daemon_package))
except TypeError:
print '[CTPanel] Could not parse daemonlist while Directory crawl. Please check .ext Files for errors.'
def yellow(self):
index = self['menu'].getSelectionIndex()
try:
if self.installed[index]:
if self.daemons[index][6]:
if self.daemons[index][6] == 'XTOpenvpn':
from plugin import XTOpenvpn
self.session.open(XTOpenvpn)
elif self.daemons[index][6] == 'NFSServerSetup':
from Plugins.PLi.NFSServer.plugin import NFSServerSetup
self.session.open(NFSServerSetup)
elif self.daemons[index][6] == 'XTCronMang':
from plugin import XTCronMang
self.session.open(XTCronMang)
elif self.daemons[index][6] == 'XTNTPdConf':
self.session.open(MessageBox, _('Please visit the following Website:\nhttp://linux-fuer-alle.de/doc_show.php?docid=7\nto gain further instructions how to configure your STB as NTP-Client/Server.'), MessageBox.TYPE_INFO)
except IndexError:
print '[XTPANEL] no Daemon .ext files found.'
def green(self):
index = self['menu'].getSelectionIndex()
if not self.installed[index]:
if self.daemons[index][9]:
filename = self.daemons[index][9]
self.oktext = _('\nAfter pressing OK, please wait!')
self.cmdList = []
if not fileExists('/var/lib/opkg/openpli-all') and not fileExists('/var/lib/opkg/openpli-mipsel') and not fileExists('/var/lib/opkg/openpli-3rd-party'):
self.ipkg = IpkgComponent()
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
sleep(5)
self.cmdList.append((IpkgComponent.CMD_INSTALL, {'package': filename}))
if len(self.cmdList):
self.session.openWithCallback(self.runUpgrade, MessageBox, _('Do you want to install the package:\n') + filename + '\n' + self.oktext)
def red(self):
if len(self.daemons) > 0:
index = self['menu'].getSelectionIndex()
if self.running[index]:
self.session.openWithCallback(self.drawList, ExtraActionBox, _('Stopping %s...') % self.daemons[index][0], _('Daemons'), self.startstop)
else:
self.session.openWithCallback(self.drawList, ExtraActionBox, _('Starting %s...') % self.daemons[index][0], _('Daemons'), self.startstop)
def startstop(self):
if len(self.daemons) > 0:
index = self['menu'].getSelectionIndex()
if self.installed[index]:
if self.running[index]:
self.daemons[index][5]()
else:
self.daemons[index][4]()
self.daemons[index][8](self.daemons[index][3]())
def quit(self):
self.close()
def runUpgrade(self, result):
if result:
self.session.openWithCallback(self.runUpgradeFinished, Ipkg, cmdList=self.cmdList)
def runUpgradeFinished(self):
self.session.openWithCallback(self.UpgradeReboot, MessageBox, _('Installation/Upgrade finished.') + ' ' + _('Do you want to restart Enigma2?'), MessageBox.TYPE_YESNO)
def UpgradeReboot(self, result):
if result is None or result is False:
self.session.open(ExtraActionBox, _('Checking daemons status...'), _('Daemons'), self.actionDrawList)
if result:
quitMainloop(3)
class PackageInfoHandler:
STATUS_WORKING = 0
STATUS_DONE = 1
STATUS_ERROR = 2
STATUS_INIT = 4
def __init__(self,
statusCallback,
blocking=False,
neededTag=None,
neededFlag=None):
self.hardware_info = HardwareInfo()
self.directory = "/"
self.neededTag = neededTag
self.neededFlag = neededFlag
# caution: blocking should only be used, if further execution in enigma2 depends on the outcome of
# the installer!
self.blocking = blocking
self.currentlyInstallingMetaIndex = None
self.console = eConsoleAppContainer()
self.console.appClosed.append(self.installNext)
self.reloadFavourites = False
self.statusCallback = statusCallback
self.setStatus(self.STATUS_INIT)
self.packageslist = []
self.packagesIndexlist = []
self.packageDetails = []
def readInfo(self, directory, file):
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageslist.append((entry, file))
except InfoHandlerParseError:
pass
def readIndex(self, directory, file):
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packagesIndexlist.append((entry, file))
except InfoHandlerParseError:
pass
def readDetails(self, directory, file):
self.packageDetails = []
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageDetails.append((entry, file))
except InfoHandlerParseError:
pass
def fillPackagesList(self, prerequisites=True):
self.packageslist = []
packages = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for directory in self.directory:
packages += crawlDirectory(directory, ".*\.info$")
for package in packages:
self.readInfo(package[0] + "/", package[0] + "/" + package[1])
if prerequisites:
for package in self.packageslist[:]:
if not self.prerequisiteMet(package[0]["prerequisites"]):
self.packageslist.remove(package)
return self.packageslist
def fillPackagesIndexList(self, prerequisites=True):
self.packagesIndexlist = []
indexfileList = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for indexfile in os.listdir(self.directory[0]):
if indexfile.startswith("index-"):
if indexfile.endswith(".xml"):
if indexfile[-7:-6] == "_":
continue
indexfileList.append(indexfile)
if len(indexfileList):
for file in indexfileList:
neededFile = self.directory[0] + "/" + file
if os.path.isfile(neededFile):
self.readIndex(self.directory[0] + "/", neededFile)
if prerequisites:
for package in self.packagesIndexlist[:]:
if not self.prerequisiteMet(package[0]["prerequisites"]):
self.packagesIndexlist.remove(package)
return self.packagesIndexlist
def fillPackageDetails(self, details=None):
self.packageDetails = []
detailsfile = details
if not isinstance(self.directory, list):
self.directory = [self.directory]
self.readDetails(self.directory[0] + "/",
self.directory[0] + "/" + detailsfile)
return self.packageDetails
def prerequisiteMet(self, prerequisites):
met = True
if self.neededTag is None:
if prerequisites.has_key("tag"):
return False
elif self.neededTag == 'ALL_TAGS':
return True
else:
if prerequisites.has_key("tag"):
if not self.neededTag in prerequisites["tag"]:
return False
else:
return False
if self.neededFlag is None:
if prerequisites.has_key("flag"):
return False
else:
if prerequisites.has_key("flag"):
if not self.neededFlag in prerequisites["flag"]:
return False
else:
return True
if prerequisites.has_key("satellite"):
for sat in prerequisites["satellite"]:
if int(sat) not in nimmanager.getConfiguredSats():
return False
if prerequisites.has_key("bcastsystem"):
has_system = False
for bcastsystem in prerequisites["bcastsystem"]:
if nimmanager.hasNimType(bcastsystem):
has_system = True
if not has_system:
return False
if prerequisites.has_key("hardware"):
hardware_found = False
for hardware in prerequisites["hardware"]:
if hardware == self.hardware_info.device_name:
hardware_found = True
if not hardware_found:
return False
return True
def installPackages(self, indexes):
if len(indexes) == 0:
self.setStatus(self.STATUS_DONE)
return
self.installIndexes = indexes
self.currentlyInstallingMetaIndex = 0
self.installPackage(
self.installIndexes[self.currentlyInstallingMetaIndex])
def installPackage(self, index):
if len(self.packageslist) <= index:
return
attributes = self.packageslist[index][0]["attributes"]
self.installingAttributes = attributes
self.attributeNames = [
"skin", "config", "favourites", "package", "services"
]
self.currentAttributeIndex = 0
self.currentIndex = -1
self.installNext()
def setStatus(self, status):
self.status = status
self.statusCallback(self.status, None)
def installNext(self, *args, **kwargs):
if self.reloadFavourites:
self.reloadFavourites = False
db = eDVBDB.getInstance().reloadBouquets()
self.currentIndex += 1
attributes = self.installingAttributes
if self.currentAttributeIndex >= len(self.attributeNames):
if self.currentlyInstallingMetaIndex is None or self.currentlyInstallingMetaIndex >= len(
self.installIndexes) - 1:
self.setStatus(self.STATUS_DONE)
return
else:
self.currentlyInstallingMetaIndex += 1
self.currentAttributeIndex = 0
self.installPackage(
self.installIndexes[self.currentlyInstallingMetaIndex])
return
self.setStatus(self.STATUS_WORKING)
currentAttribute = self.attributeNames[self.currentAttributeIndex]
if attributes.has_key(currentAttribute):
if self.currentIndex >= len(attributes[currentAttribute]):
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
else:
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
if currentAttribute == "skin":
skin = attributes["skin"][self.currentIndex]
self.installSkin(skin["directory"], skin["name"])
elif currentAttribute == "config":
if self.currentIndex == 0:
from Components.config import configfile
configfile.save()
config = attributes["config"][self.currentIndex]
self.mergeConfig(config["directory"], config["name"])
elif currentAttribute == "favourites":
favourite = attributes["favourites"][self.currentIndex]
self.installFavourites(favourite["directory"], favourite["name"])
elif currentAttribute == "package":
package = attributes["package"][self.currentIndex]
self.installIPK(package["directory"], package["name"])
elif currentAttribute == "services":
service = attributes["services"][self.currentIndex]
self.mergeServices(service["directory"], service["name"])
def readfile(self, filename):
if not os.path.isfile(filename):
return []
fd = open(filename)
lines = fd.readlines()
fd.close()
return lines
def mergeConfig(self, directory, name, merge=True):
if os.path.isfile(directory + name):
config.loadFromFile(directory + name, base_file=False)
configfile.save()
self.installNext()
def installIPK(self, directory, name):
if self.blocking:
os.system("opkg install " + directory + name)
self.installNext()
else:
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': directory + name})
def ipkgCallback(self, event, param):
if event == IpkgComponent.EVENT_DONE:
self.installNext()
elif event == IpkgComponent.EVENT_ERROR:
self.installNext()
def installSkin(self, directory, name):
if self.blocking:
copytree(directory, resolveFilename(SCOPE_SKIN))
self.installNext()
else:
if self.console.execute("cp -a %s %s" %
(directory, resolveFilename(SCOPE_SKIN))):
self.installNext()
def mergeServices(self, directory, name, merge=False):
if os.path.isfile(directory + name):
db = eDVBDB.getInstance()
db.reloadServicelist()
db.loadServicelist(directory + name)
db.saveServicelist()
self.installNext()
def installFavourites(self, directory, name):
self.reloadFavourites = True
if self.blocking:
copyfile(directory + name, resolveFilename(SCOPE_CONFIG))
self.installNext()
else:
if self.console.execute(
"cp %s %s" %
((directory + name), resolveFilename(SCOPE_CONFIG))):
self.installNext()
class FeedsStatusCheck:
def __init__(self):
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def IsInt(self, val):
try:
int(val)
return True
except ValueError:
return False
def getFeedStatus(self):
status = '1'
trafficLight = 'unknown'
# TODO: Enable traffic status for Obh
# if about.getIfConfig('eth0').has_key('addr') or about.getIfConfig('eth1').has_key('addr') or about.getIfConfig('wlan0').has_key('addr') or about.getIfConfig('ra0').has_key('addr'):
# try:
#
# print '[OnlineVersionCheck] Checking feeds state'
# req = urllib2.Request('http://www.vuplus-community.net/TrafficLightState.php')
# d = urllib2.urlopen(req)
# trafficLight = d.read()
# except urllib2.HTTPError, err:
# print '[OnlineVersionCheck] ERROR:',err
# trafficLight = err.code
# except urllib2.URLError, err:
# print '[OnlineVersionCheck] ERROR:',err.reason[0]
# trafficLight = err.reason[0]
# except urllib2, err:
# print '[OnlineVersionCheck] ERROR:',err
# trafficLight = err
# except:
# print '[OnlineVersionCheck] ERROR:', sys.exc_info()[0]
# trafficLight = -2
# if not self.IsInt(trafficLight) and getImageType() != 'release':
# trafficLight = 'unknown'
# elif trafficLight == 'stable':
# status = '0'
# config.softwareupdate.updateisunstable.setValue(status)
# print '[OnlineVersionCheck] PASSED:',trafficLight
# return trafficLight
# else:
# print '[OnlineVersionCheck] ERROR: -2'
# return -2
# HACK OBH
trafficLight = 'stable'
status = '0'
config.softwareupdate.updateisunstable.setValue(status)
return trafficLight
# END
# We need a textual mapping for all possible return states for use by
# SoftwareUpdate::checkNetworkState() and ChoiceBox::onshow()
# Declared here for consistency and co-location with choices.
feed_status_msgs = {
'stable':
_('Feeds status: Stable'),
'unstable':
_('Feeds status: Unstable'),
'updating':
_('Feeds status: Updating'),
'-2':
_('ERROR: No network found'),
'403':
_('ERROR: Forbidden'),
'404':
_('ERROR: No internet found'),
'inprogress':
_('ERROR: Check is already running in background, please wait a few minutes and try again'
),
'unknown':
_('Feeds status: Unknown'),
}
def getFeedsBool(self):
global error
feedstatus = feedsstatuscheck.getFeedStatus()
if feedstatus in (-2, 403, 404):
print '[OnlineVersionCheck] Error %s' % feedstatus
return str(feedstatus)
elif error:
print '[OnlineVersionCheck] Check already in progress'
return 'inprogress'
elif feedstatus == 'updating':
print '[OnlineVersionCheck] Feeds Updating'
return 'updating'
elif feedstatus in ('stable', 'unstable', 'unknown'):
print '[OnlineVersionCheck]', feedstatus.title()
return str(feedstatus)
def getFeedsErrorMessage(self):
global error
feedstatus = feedsstatuscheck.getFeedsBool()
if feedstatus == -2:
return _(
"Your %s %s has no network access, please check your network settings and make sure you have network cable connected and try again."
) % (getMachineBrand(), getMachineName())
elif feedstatus == 404:
return _(
"Your %s %s is not connected to the internet, please check your network settings and try again."
) % (getMachineBrand(), getMachineName())
elif feedstatus in ('updating', 403):
return _(
"Sorry feeds are down for maintenance, please try again later. If this issue persists please check vuplus-community.net."
)
elif error:
return _(
"There has been an error, please try again later. If this issue persists, please check vuplus-community.net"
)
def startCheck(self):
global error
error = 0
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
def ipkgCallback(self, event, param):
config.softwareupdate.updatefound.setValue(False)
if event == IpkgComponent.EVENT_ERROR:
global error
error += 1
elif event == IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand == IpkgComponent.CMD_UPGRADE_LIST:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages and (
getImageType() != 'release' or
(config.softwareupdate.updateisunstable.value == '1'
and config.softwareupdate.updatebeta.value) or
config.softwareupdate.updateisunstable.value == '0'):
print('[OnlineVersionCheck] %s Updates available' %
self.total_packages)
config.softwareupdate.updatefound.setValue(True)
pass
class UpdatePlugin(Screen, ProtectedScreen):
skin = """
<screen name="UpdatePlugin" position="center,center" size="550,300">
<widget name="activityslider" position="0,0" size="550,5" />
<widget name="slider" position="0,150" size="550,30" />
<widget source="package" render="Label" position="10,30" size="540,20" font="Regular;18" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
<widget source="status" render="Label" position="10,180" size="540,100" font="Regular;20" halign="center" valign="center" backgroundColor="#25062748" transparent="1" />
</screen>"""
def __init__(self, session, *args):
Screen.__init__(self, session)
ProtectedScreen.__init__(self)
self.sliderPackages = { "dreambox-dvb-modules": 1, "enigma2": 2, "tuxbox-image-info": 3 }
self.setTitle(_("Software update"))
self.slider = Slider(0, 4)
self["slider"] = self.slider
self.activityslider = Slider(0, 100)
self["activityslider"] = self.activityslider
self.status = StaticText(_("Please wait..."))
self["status"] = self.status
self.package = StaticText(_("Package list update"))
self["package"] = self.package
self.oktext = _("Press OK on your remote control to continue.")
self.packages = 0
self.error = 0
self.processed_packages = []
self.total_packages = None
self.channellist_only = 0
self.channellist_name = ''
self.updating = False
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onClose.append(self.__close)
self["actions"] = ActionMap(["WizardActions"],
{
"ok": self.exit,
"back": self.exit
}, -1)
self.activity = 0
self.activityTimer = eTimer()
self.activityTimer.callback.append(self.checkTraficLight1)
self.activityTimer.callback.append(self.doActivityTimer)
self.activityTimer.start(20, True)
def checkTraficLight1(self):
self.activityTimer.callback.remove(self.checkTraficLight1)
self.activityTimer.start(100, False)
self.showDisclaimer()
def isProtected(self):
return config.ParentalControl.setuppinactive.value and\
(not config.ParentalControl.config_sections.main_menu.value and not config.ParentalControl.config_sections.configuration.value or hasattr(self.session, 'infobar') and self.session.infobar is None) and\
config.ParentalControl.config_sections.software_update.value
def checkTraficLight(self):
self.activityTimer.callback.remove(self.checkTraficLight)
self.activityTimer.start(100, False)
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
message = ""
picon = None
default = True
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
status = urlopen("http://openpli.org/status/").read().split('!', 1)
if getBoxType() in status[0].split(','):
message = len(status) > 1 and status[1] or _("The current beta image might not be stable.\nFor more information see %s.") % ("www.openpli.org")
picon = MessageBox.TYPE_ERROR
default = False
except:
message = _("The status of the current beta image could not be checked because %s can not be reached.") % ("www.openpli.org")
picon = MessageBox.TYPE_ERROR
default = False
socket.setdefaulttimeout(currentTimeoutDefault)
if default:
self.showDisclaimer()
else:
message += "\n" + _("Do you want to update your receiver?")
self.session.openWithCallback(self.startActualUpdate, MessageBox, message, default = default, picon = picon)
def showDisclaimer(self, justShow=False):
if config.usage.show_update_disclaimer.value or justShow:
message = _("The OpenPLi team would like to point out that upgrading to the latest nightly build comes not only with the latest features, but also with some risks. After the update, it is possible that your device no longer works as expected. We recommend you create backups with Autobackup or Backupsuite. This allows you to quickly and easily restore your device to its previous state, should you experience any problems. If you encounter a 'bug', please report the issue on www.openpli.org.\n\nDo you understand this?")
list = not justShow and [(_("no"), False), (_("yes"), True), (_("yes") + " " + _("and never show this message again"), "never")] or []
self.session.openWithCallback(boundFunction(self.disclaimerCallback, justShow), MessageBox, message, list=list)
else:
self.startActualUpdate(True)
def disclaimerCallback(self, justShow, answer):
if answer == "never":
config.usage.show_update_disclaimer.value = False
config.usage.show_update_disclaimer.save()
if justShow and answer:
self.ipkgCallback(IpkgComponent.EVENT_DONE, None)
else:
self.startActualUpdate(answer)
def getLatestImageTimestamp(self):
# TODO: Impement own sh4 timestamp
return ""
currentTimeoutDefault = socket.getdefaulttimeout()
socket.setdefaulttimeout(3)
latestImageTimestamp = ""
try:
# TODO: Use Twisted's URL fetcher, urlopen is evil. And it can
# run in parallel to the package update.
latestImageTimestamp = re.findall('<dd>(.*?)</dd>', urlopen("http://openpli.org/download/"+getBoxType()+"/").read())[0][:16]
latestImageTimestamp = time.strftime(_("%d-%b-%Y %-H:%M"), time.strptime(latestImageTimestamp, "%Y/%m/%d %H:%M"))
except:
pass
socket.setdefaulttimeout(currentTimeoutDefault)
return latestImageTimestamp
def startActualUpdate(self,answer):
if answer:
self.updating = True
self.ipkg.startCmd(IpkgComponent.CMD_UPDATE)
else:
self.close()
def doActivityTimer(self):
self.activity += 1
if self.activity == 100:
self.activity = 0
self.activityslider.setValue(self.activity)
def showUpdateCompletedMessage(self):
self.setEndMessage(ngettext("Update completed, %d package was installed.", "Update completed, %d packages were installed.", self.packages) % self.packages)
def ipkgCallback(self, event, param):
if event is IpkgComponent.EVENT_DOWNLOAD:
self.status.setText(_("Downloading"))
elif event is IpkgComponent.EVENT_UPGRADE:
if self.sliderPackages.has_key(param):
self.slider.setValue(self.sliderPackages[param])
self.package.setText(param)
self.status.setText(_("Upgrading") + ": %s/%s" % (self.packages, self.total_packages))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event is IpkgComponent.EVENT_INSTALL:
self.package.setText(param)
self.status.setText(_("Installing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event is IpkgComponent.EVENT_REMOVE:
self.package.setText(param)
self.status.setText(_("Removing"))
if not param in self.processed_packages:
self.processed_packages.append(param)
self.packages += 1
elif event is IpkgComponent.EVENT_CONFIGURING:
self.package.setText(param)
self.status.setText(_("Configuring"))
elif event is IpkgComponent.EVENT_MODIFIED:
if config.plugins.softwaremanager.overwriteConfigFiles.value in ("N", "Y"):
self.ipkg.write(True and config.plugins.softwaremanager.overwriteConfigFiles.value)
else:
self.session.openWithCallback(
self.modificationCallback,
MessageBox,
_("A configuration file (%s) has been modified since it was installed.\nDo you want to keep your modifications?") % (param)
)
elif event is IpkgComponent.EVENT_ERROR:
self.error += 1
elif event is IpkgComponent.EVENT_DONE:
if self.updating:
self.updating = False
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE_LIST)
elif self.ipkg.currentCommand is IpkgComponent.CMD_UPGRADE_LIST and self.error == 0:
self.total_packages = len(self.ipkg.getFetchedList())
if self.total_packages:
latestImageTimestamp = self.getLatestImageTimestamp()
if latestImageTimestamp:
message = _("Do you want to update your receiver to %s?") % self.getLatestImageTimestamp() + "\n"
else:
message = _("Do you want to update your receiver?") + "\n"
message += "(" + (ngettext("%s updated package available", "%s updated packages available", self.total_packages) % self.total_packages) + ")"
if self.total_packages > 150:
message += " " + _("Reflash recommended!")
choices = [(_("Update and reboot (recommended)"), "cold"),
(_("Update and ask to reboot"), "hot"),
(_("Update channel list only"), "channels"),
(_("Show updated packages"), "showlist")]
else:
message = _("No updates available")
choices = []
if fileExists("/hdd/ipkgupgrade.log"):
choices.append((_("Show latest upgrade log"), "log"))
choices.append((_("Show latest commits"), "commits"))
if not config.usage.show_update_disclaimer.value:
choices.append((_("Show disclaimer"), "disclaimer"))
choices.append((_("Cancel"), ""))
self.session.openWithCallback(self.startActualUpgrade, ChoiceBox, title=message, list=choices)
elif self.channellist_only > 0:
if self.channellist_only == 1:
self.setEndMessage(_("Could not find installed channel list."))
elif self.channellist_only == 2:
self.slider.setValue(2)
self.ipkg.startCmd(IpkgComponent.CMD_REMOVE, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 3:
self.slider.setValue(3)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL, {'package': self.channellist_name})
self.channellist_only += 1
elif self.channellist_only == 4:
self.showUpdateCompletedMessage()
eDVBDB.getInstance().reloadBouquets()
eDVBDB.getInstance().reloadServicelist()
elif self.error == 0:
self.showUpdateCompletedMessage()
else:
self.activityTimer.stop()
self.activityslider.setValue(0)
error = _("Your receiver might be unusable now. Please consult the manual for further assistance before rebooting your receiver.")
if self.packages == 0:
error = _("No updates available. Please try again later.")
if self.updating:
error = _("Update failed. Your receiver does not have a working internet connection.")
self.status.setText(_("Error") + " - " + error)
elif event is IpkgComponent.EVENT_LISTITEM:
if 'enigma2-plugin-settings-' in param[0] and self.channellist_only > 0:
self.channellist_name = param[0]
self.channellist_only = 2
#print event, "-", param
pass
def setEndMessage(self, txt):
self.slider.setValue(4)
self.activityTimer.stop()
self.activityslider.setValue(0)
self.package.setText(txt)
self.status.setText(self.oktext)
def startActualUpgrade(self, answer):
if not answer or not answer[1]:
self.close()
return
if answer[1] == "cold":
self.session.open(TryQuitMainloop,retvalue=42)
self.close()
elif answer[1] == "channels":
self.channellist_only = 1
self.slider.setValue(1)
self.ipkg.startCmd(IpkgComponent.CMD_LIST, args = {'installed_only': True})
elif answer[1] == "commits":
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), CommitInfo)
elif answer[1] == "disclaimer":
self.showDisclaimer(justShow=True)
elif answer[1] == "showlist":
text = ""
for i in [x[0] for x in sorted(self.ipkg.getFetchedList(), key=lambda d: d[0])]:
text = text and text + "\n" + i or i
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), TextBox, text, _("Packages to update"))
elif answer[1] == "log":
text = ""
for i in open("/hdd/ipkgupgrade.log", "r").readlines():
text += i
self.session.openWithCallback(boundFunction(self.ipkgCallback, IpkgComponent.EVENT_DONE, None), TextBox, text, _("Packages to update"))
else:
self.ipkg.startCmd(IpkgComponent.CMD_UPGRADE, args = {'test_only': False})
def modificationCallback(self, res):
self.ipkg.write(res and "N" or "Y")
def exit(self):
if not self.ipkg.isRunning():
if self.packages != 0 and self.error == 0 and self.channellist_only == 0:
self.session.openWithCallback(self.exitAnswer, MessageBox, _("Update completed. Do you want to reboot your receiver?"))
else:
self.close()
else:
if not self.updating:
self.close()
def exitAnswer(self, result):
if result is not None and result:
self.session.open(TryQuitMainloop,retvalue=2)
self.close()
def __close(self):
self.ipkg.removeCallback(self.ipkgCallback)
class DreamInfoHandler:
STATUS_WORKING = 0
STATUS_DONE = 1
STATUS_ERROR = 2
STATUS_INIT = 4
def __init__(self,
statusCallback,
blocking=False,
neededTag=None,
neededFlag=None,
language=None):
self.hardware_info = HardwareInfo()
self.directory = "/"
self.neededTag = neededTag
self.neededFlag = neededFlag
self.language = language
# caution: blocking should only be used, if further execution in enigma2 depends on the outcome of
# the installer!
self.blocking = blocking
self.currentlyInstallingMetaIndex = None
self.console = eConsoleAppContainer()
self.console.appClosed.append(self.installNext)
self.reloadFavourites = False
self.statusCallback = statusCallback
self.setStatus(self.STATUS_INIT)
self.packageslist = []
self.packagesIndexlist = []
self.packageDetails = []
def readInfo(self, directory, file):
print "Reading .info file", file
handler = InfoHandler(self.prerequisiteMet, directory)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageslist.append((entry, file))
except InfoHandlerParseError:
print "file", file, "ignored due to errors in the file"
#print handler.list
def readIndex(self, directory, file):
print "Reading .xml meta index file", file
handler = InfoHandler(self.prerequisiteMet, directory, self.language)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packagesIndexlist.append((entry, file))
except InfoHandlerParseError:
print "file", file, "ignored due to errors in the file"
#print handler.list
def readDetails(self, directory, file):
self.packageDetails = []
print "Reading .xml meta details file", file
handler = InfoHandler(self.prerequisiteMet, directory, self.language)
try:
xml.sax.parse(file, handler)
for entry in handler.list:
self.packageDetails.append((entry, file))
except InfoHandlerParseError:
print "file", file, "ignored due to errors in the file"
#print handler.list
# prerequisites = True: give only packages matching the prerequisites
def fillPackagesList(self, prerequisites=True):
self.packageslist = []
packages = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for directory in self.directory:
packages += crawlDirectory(directory, ".*\.info$")
for package in packages:
self.readInfo(package[0] + "/", package[0] + "/" + package[1])
if prerequisites:
for package in self.packageslist[:]:
if not self.prerequisiteMet(package[0]["prerequisites"]):
self.packageslist.remove(package)
return self.packageslist
# prerequisites = True: give only packages matching the prerequisites
def fillPackagesIndexList(self, prerequisites=True):
self.packagesIndexlist = []
indexfileList = []
if not isinstance(self.directory, list):
self.directory = [self.directory]
for indexfile in os.listdir(self.directory[0]):
if indexfile.startswith("index"):
if indexfile.endswith(
"_en.xml"): #we first catch all english indexfiles
indexfileList.append(os.path.splitext(indexfile)[0][:-3])
if len(indexfileList):
for file in indexfileList:
neededFile = self.directory[0] + "/" + file
if self.language is not None:
if os.path.exists(neededFile + '_' + self.language +
'.xml'):
#print "translated index file found",neededFile + '_' + self.language + '.xml'
self.readIndex(
self.directory[0] + "/",
neededFile + '_' + self.language + '.xml')
else:
#print "reading original index file"
self.readIndex(self.directory[0] + "/",
neededFile + '_en.xml')
if prerequisites:
for package in self.packagesIndexlist[:]:
if not self.prerequisiteMet(package[0]["prerequisites"]):
self.packagesIndexlist.remove(package)
return self.packagesIndexlist
# prerequisites = True: give only packages matching the prerequisites
def fillPackageDetails(self, details=None):
self.packageDetails = []
detailsfile = details
if not isinstance(self.directory, list):
self.directory = [self.directory]
self.readDetails(self.directory[0] + "/",
self.directory[0] + "/" + detailsfile)
return self.packageDetails
def prerequisiteMet(self, prerequisites):
# TODO: we need to implement a hardware detection here...
print "prerequisites:", prerequisites
met = True
if self.neededTag is None:
if prerequisites.has_key("tag"):
return False
elif self.neededTag == 'ALL_TAGS':
return True
else:
if prerequisites.has_key("tag"):
if not self.neededTag in prerequisites["tag"]:
return False
else:
return False
if self.neededFlag is None:
if prerequisites.has_key("flag"):
return False
else:
if prerequisites.has_key("flag"):
if not self.neededFlag in prerequisites["flag"]:
return False
else:
return True # No flag found, assuming all flags valid
if prerequisites.has_key("satellite"):
for sat in prerequisites["satellite"]:
if int(sat) not in nimmanager.getConfiguredSats():
return False
if prerequisites.has_key("bcastsystem"):
has_system = False
for bcastsystem in prerequisites["bcastsystem"]:
if nimmanager.hasNimType(bcastsystem):
has_system = True
if not has_system:
return False
if prerequisites.has_key("hardware"):
hardware_found = False
for hardware in prerequisites["hardware"]:
if hardware == self.hardware_info.device_name:
hardware_found = True
if not hardware_found:
return False
return True
def installPackages(self, indexes):
print "installing packages", indexes
if len(indexes) == 0:
self.setStatus(self.STATUS_DONE)
return
self.installIndexes = indexes
print "+++++++++++++++++++++++bla"
self.currentlyInstallingMetaIndex = 0
self.installPackage(
self.installIndexes[self.currentlyInstallingMetaIndex])
def installPackage(self, index):
print "self.packageslist:", self.packageslist
if len(self.packageslist) <= index:
print "no package with index", index, "found... installing nothing"
return
print "installing package with index", index, "and name", self.packageslist[
index][0]["attributes"]["name"]
attributes = self.packageslist[index][0]["attributes"]
self.installingAttributes = attributes
self.attributeNames = [
"skin", "config", "favourites", "package", "services"
]
self.currentAttributeIndex = 0
self.currentIndex = -1
self.installNext()
def setStatus(self, status):
self.status = status
self.statusCallback(self.status, None)
def installNext(self, *args, **kwargs):
if self.reloadFavourites:
self.reloadFavourites = False
db = eDVBDB.getInstance().reloadBouquets()
self.currentIndex += 1
attributes = self.installingAttributes
#print "attributes:", attributes
if self.currentAttributeIndex >= len(
self.attributeNames): # end of package reached
print "end of package reached"
if self.currentlyInstallingMetaIndex is None or self.currentlyInstallingMetaIndex >= len(
self.installIndexes) - 1:
print "set status to DONE"
self.setStatus(self.STATUS_DONE)
return
else:
print "increment meta index to install next package"
self.currentlyInstallingMetaIndex += 1
self.currentAttributeIndex = 0
self.installPackage(
self.installIndexes[self.currentlyInstallingMetaIndex])
return
self.setStatus(self.STATUS_WORKING)
print "currentAttributeIndex:", self.currentAttributeIndex
currentAttribute = self.attributeNames[self.currentAttributeIndex]
print "installing", currentAttribute, "with index", self.currentIndex
if attributes.has_key(currentAttribute):
if self.currentIndex >= len(
attributes[currentAttribute]
): # all jobs done for current attribute
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
else: # nothing to install here
self.currentIndex = -1
self.currentAttributeIndex += 1
self.installNext()
return
if currentAttribute == "skin":
skin = attributes["skin"][self.currentIndex]
self.installSkin(skin["directory"], skin["name"])
elif currentAttribute == "config":
if self.currentIndex == 0:
from Components.config import configfile
configfile.save()
config = attributes["config"][self.currentIndex]
self.mergeConfig(config["directory"], config["name"])
elif currentAttribute == "favourites":
favourite = attributes["favourites"][self.currentIndex]
self.installFavourites(favourite["directory"], favourite["name"])
elif currentAttribute == "package":
package = attributes["package"][self.currentIndex]
self.installIPK(package["directory"], package["name"])
elif currentAttribute == "services":
service = attributes["services"][self.currentIndex]
self.mergeServices(service["directory"], service["name"])
def readfile(self, filename):
if not os.path.isfile(filename):
return []
fd = open(filename)
lines = fd.readlines()
fd.close()
return lines
def mergeConfig(self, directory, name, merge=True):
print "merging config:", directory, " - ", name
if os.path.isfile(directory + name):
config.loadFromFile(directory + name)
configfile.save()
self.installNext()
def installIPK(self, directory, name):
if self.blocking:
os.system("ipkg install " + directory + name)
self.installNext()
else:
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.ipkg.startCmd(IpkgComponent.CMD_INSTALL,
{'package': directory + name})
def ipkgCallback(self, event, param):
print "ipkgCallback"
if event == IpkgComponent.EVENT_DONE:
self.installNext()
elif event == IpkgComponent.EVENT_ERROR:
self.installNext()
def installSkin(self, directory, name):
print "installing skin:", directory, " - ", name
print "cp -a %s %s" % (directory, resolveFilename(SCOPE_SKIN))
if self.blocking:
copytree(directory, resolveFilename(SCOPE_SKIN))
self.installNext()
else:
if self.console.execute("cp -a %s %s" %
(directory, resolveFilename(SCOPE_SKIN))):
print "execute failed"
self.installNext()
def mergeServices(self, directory, name, merge=False):
print "merging services:", directory, " - ", name
if os.path.isfile(directory + name):
db = eDVBDB.getInstance()
db.reloadServicelist()
db.loadServicelist(directory + name)
db.saveServicelist()
self.installNext()
def installFavourites(self, directory, name):
print "installing favourites:", directory, " - ", name
self.reloadFavourites = True
if self.blocking:
copyfile(directory + name, resolveFilename(SCOPE_CONFIG))
self.installNext()
else:
if self.console.execute(
"cp %s %s" %
((directory + name), resolveFilename(SCOPE_CONFIG))):
print "execute failed"
self.installNext()
