class FeedsStatusCheck:
def __init__(self):
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def getFeedSatus(self):
status = '1'
if getImageType() == 'developer':
config.softwareupdate.updateisunstable.setValue(status)
return 'stable'
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:
req = urllib2.Request('http://openvix.co.uk/TrafficLightState.php')
d = urllib2.urlopen(req)
trafficLight = d.read()
except urllib2.HTTPError, err:
print 'ERROR:',err
trafficLight = err.code
except urllib2.URLError, err:
print 'ERROR:',err.reason[0]
trafficLight = err.reason[0]
except urllib2, err:
print 'ERROR:',err
trafficLight = err
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 = 'stable'
if getImageType() != 'rubbish':
status = '0'
config.softwareupdate.updateisunstable.setValue(status)
return 'stable'
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, 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
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 about.getIfConfig(adapter).has_key('addr'):
return True
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)
original_timeout = socket.getdefaulttimeout()
try:
socket.setdefaulttimeout(timeout)
socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect((host, port))
socket.setdefaulttimeout(original_timeout) # reset to previous
print "[OnlineUpdateCheck][OnlineCheck] PASSED"
return True
except Exception as ex:
print "[OnlineUpdateCheck][OnlineCheck] FAILED", ex.message
socket.setdefaulttimeout(original_timeout) # reset to previous
return False
def getFeedStatus(self):
status = '1'
trafficLight = 'unknown'
if self.adapterAvailable():
if self.NetworkUp():
if getImageType() == 'release': # we know the network is good now so only do this check on release images where the release domain applies
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, 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:
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 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()
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 __init__(self, session, args = None):
Screen.__init__(self, session)
self.sliderPackages = {'ini-dvb-modules': 1,
'enigma2': 2,
'egami-version-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.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)
iNetwork.checkNetworkState(self.checkNetworkCB)
self.onClose.append(self.cleanup)
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.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.runningCmd = None
self.runNextCmd()
self['actions'] = ActionMap(['WizardActions'], {'ok': self.exit,
'back': self.exit}, -1)
return
def __init__(self, session, restoretype, plugin_path):
Screen.__init__(self, session)
self.skin_path = plugin_path
self.restoretype = restoretype
self.title = _('VTI BackupSuite')
try:
self['title'] = StaticText(self.title)
except:
print 'self["title"] was not found in skin'
self['key_red'] = StaticText(_('Close'))
self['key_green'] = StaticText(_('Install'))
self['key_yellow'] = StaticText(_('Delete'))
self.sel = []
self.val = []
self.entry = False
self.exe = False
self.path = ''
self['actions'] = NumberActionMap(['SetupActions'], {'ok': self.KeyOk,
'cancel': self.keyCancel}, -1)
self['shortcuts'] = ActionMap(['ShortcutActions'], {'red': self.keyCancel,
'green': self.KeyOk,
'yellow': self.deleteFile})
self.flist = []
self['filelist'] = MenuList(self.flist)
self.fill_list()
self.cmdList = []
self.Console = ComConsole()
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
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.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 __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 __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 __init__(self, session, plugin_path, screen_type = 'backup'):
Screen.__init__(self, session)
self.skin_path = plugin_path
self.session = session
# checkvu.runcheck()
self.screentype = screen_type
self.reloadPluginlist = False
self.title = _('VTI BackupSuite')
self.backupactions = BackupActions('manual')
if self.screentype == 'restore':
self.screentype = 'restore'
self.title += ' (' + _('Restore') + ')'
else:
self.screentype = 'backup'
self.title += ' (' + _('Backup') + ')'
self['key_green'] = StaticText('')
self['key_yellow'] = StaticText('')
try:
self['title'] = StaticText(self.title)
except:
print 'self["title"] was not found in skin'
self.list = []
self['menu'] = List(self.list)
self['status'] = Label()
self['key_red'] = StaticText(_('Exit'))
self['shortcuts'] = ActionMap(['SetupActions', 'ColorActions', 'DirectionActions'], {'ok': self.runMenuEntry,
'cancel': self.keyCancel,
'red': self.keyCancel}, -2)
self.cmdList = []
self.Console = ComConsole()
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
self.onLayoutFinish.append(self.createMenu)
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 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)
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 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)
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)
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 FeedsStatusCheck:
def __init__(self):
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
def getFeedSatus(self):
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:
req = urllib2.Request('http://openvix.co.uk/TrafficLightState.php')
d = urllib2.urlopen(req)
trafficLight = d.read()
except urllib2.HTTPError, err:
print 'ERROR:',err
trafficLight = err.code
except urllib2.URLError, err:
print 'ERROR:',err.reason[0]
trafficLight = err.reason[0]
except urllib2, err:
print 'ERROR:',err
trafficLight = err
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 __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 __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 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 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 __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, 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 __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 __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 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()
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()
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('bad address') != -1:
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 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('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.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 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 about.getIfConfig(adapter).has_key('addr'):
return True
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)
original_timeout = socket.getdefaulttimeout()
try:
socket.setdefaulttimeout(timeout)
socket.socket(socket.AF_INET, socket.SOCK_STREAM).connect(
(host, port))
socket.setdefaulttimeout(original_timeout) # reset to previous
print "[OnlineUpdateCheck][OnlineCheck] PASSED"
return True
except Exception as ex:
print "[OnlineUpdateCheck][OnlineCheck] FAILED", ex.message
socket.setdefaulttimeout(original_timeout) # reset to previous
return False
def getFeedStatus(self):
status = '1'
trafficLight = 'unknown'
if self.adapterAvailable():
if self.NetworkUp():
if getImageType(
) == 'release': # we know the network is good now so only do this check on release images where the release domain applies
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, 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:
def __init__(self):
self.ipkg = IpkgComponent()
self.ipkg.addCallback(self.ipkgCallback)
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.")
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('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('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('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/" + 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() and config.backupmanager.backuplocation.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() and config.imagemanager.backuplocation.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() and config.backupmanager.backuplocation.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() and config.imagemanager.backuplocation.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() and config.backupmanager.backuplocation.getValue()) or (config.softwareupdate.autoimagebackup.getValue() and config.imagemanager.backuplocation.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, 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.getValue() and config.backupmanager.backuplocation.getValue() and not self.SettingsBackupDone:
self.doSettingsBackup()
elif config.softwareupdate.autoimagebackup.getValue() and config.imagemanager.backuplocation.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()
