def _check_next_update(self):
if self._cancelling or len(self._bundles_to_check) == 0:
self._completion_cb(self._updates)
return
total = self._total_bundles_to_check
current = total - len(self._bundles_to_check)
progress = current / float(total)
self._bundle_update = self._bundles_to_check.pop()
_logger.debug("Check %s", self._bundle_update.bundle_id)
# There is no need for a special name lookup for an automatic update.
# The name lookup is only for UI purposes, but we are running in the
# background.
if self._bundle_update.name is None and self._auto:
self._bundle_update.name = self._bundle_update.bundle_id
if self._bundle_update.name is not None:
# if we know the name, we just perform an asynchronous size check
_logger.debug("Performing async size lookup")
size_check = Downloader(self._bundle_update.link)
size_check.connect('complete', self._size_lookup_cb)
size_check.get_size()
self._progress_cb(self._bundle_update.name, progress)
else:
# if we don't know the name, we run a metadata lookup and get
# the size and name that way
_logger.debug("Performing metadata lookup")
namelookup = MetadataLookup(self._bundle_update.link)
namelookup.connect('complete', self._name_lookup_complete)
namelookup.run()
self._progress_cb(self._bundle_update.bundle_id, progress)
def test_get_size(self):
downloader = Downloader("http://0.0.0.0:%d/data/test.txt" % self._port)
self._complete = False
downloader.connect('complete', self.download_complete_cb)
downloader.get_size()
while not self._complete:
Gtk.main_iteration()
self.assertEqual(6, self._result)
def test_download_to_temp(self):
downloader = Downloader("http://0.0.0.0:%d/data/test.txt" % self._port)
self._complete = False
downloader.connect('complete', self.download_complete_cb)
downloader.download_to_temp()
while not self._complete:
Gtk.main_iteration()
self.assertIsNone(self._result)
path = downloader.get_local_file_path()
text = open(path, "r").read()
self.assertEqual("hello\n", text)
def _do_download(self, method, **kwargs):
# set up Downloader, call method on it with given kwargs, wait for
# response
self._complete = False
downloader = Downloader(self._url)
downloader.connect('complete', self._downloader_complete_cb)
getattr(downloader, method)(**kwargs)
while not self._complete:
Gtk.main_iteration()
if isinstance(self._result, Exception):
raise self._result
def check(self, bundle):
# ASLO knows only about stable SP releases
major, minor = config.version.split('.')[0:2]
sp_version = '%s.%s' % (major, int(minor) + int(minor) % 2)
url = '%s?id=%s&appVersion=%s' % \
(_UPDATE_PATH, bundle.get_bundle_id(), sp_version)
self._bundle = bundle
_logger.debug('Fetch %s', url)
self._downloader = Downloader(url)
self._downloader.connect('complete', self.__downloader_complete_cb)
self._downloader.download()
def fetch_update_info(self, installed_bundles, auto, progress_cb,
completion_cb, error_cb):
self._completion_cb = completion_cb
self._progress_cb = progress_cb
self._error_cb = error_cb
self._bundles = installed_bundles
self._progress_cb('', 0) # Set the status to 'Looking for updates'
settings = Gio.Settings('org.sugarlabs.update')
data_json_url = settings.get_string('new-aslo-url')
self._downloader = Downloader(data_json_url)
self._downloader.connect('complete',
self.__data_json_download_complete_cb)
self._downloader.download()
def _query(self):
self.clean()
settings = Gio.Settings.new(_MICROFORMAT_URL_PATH)
url = settings.get_string(_MICROFORMAT_URL_KEY)
_logger.debug("Query %s %r", url, url)
if url == "":
self._completion_cb([])
return
self._parser = _UpdateHTMLParser(url)
# wiki.laptop.org have agresive cache, we set max-age=600
# to be sure the page is no older than 10 minutes
request_headers = {'Cache-Control': 'max-age=600'}
downloader = Downloader(url, request_headers=request_headers)
downloader.connect('got-chunk', self._got_chunk_cb)
downloader.connect('complete', self._complete_cb)
downloader.download_chunked()
self._progress_cb(None, 0)
def _download_next_update(self):
if self._cancelling:
self._finished(True)
return
if len(self._bundles_to_update) == 0:
self._finished()
return
self._state = STATE_DOWNLOADING
self._bundle_update = self._bundles_to_update.pop()
_logger.debug("Downloading update for %s",
self._bundle_update.bundle_id)
total = self._total_bundles_to_update * 2
current = total - len(self._bundles_to_update) * 2 - 2
progress = current / float(total)
self.emit('progress', self._state, self._bundle_update.name, progress)
self._downloader = Downloader(self._bundle_update.link)
self._downloader.connect('progress', self.__downloader_progress_cb)
self._downloader.connect('complete', self.__downloader_complete_cb)
self._downloader.download_to_temp()
