def _check_version(self):
"""Actually check for an auto-update:
1. Check the version number from the file on the version site.
2. Check the stable version number from the file on the version site.
3. Notify the user and stop if they are on an OS with no installer.
4. Get the torrent file from the version site.
5. Get the signature from the version site.
6. Check the signature against the torrent file using the public key.
7a. Start the torrent if it's not in the client.
7b. Restart the torrent if it's in the client but not running.
8. Put the infohash of the torrent into estate so the butler knows
to butle it.
9. AutoUpdateButler.started() ensures that only the most recent
auto-update torrent is running.
10. AutoUpdateButler.finished() indicates the new version is available,
the UI polls for that value later.
Whether an auto-update was found and started or not, requeue
the call to check_version() to run a day later. This means
that the version check runs at startup, and once a day.
"""
debug_prefix = '_check_version() run#%d: '%self.runs
self.debug(debug_prefix + 'starting')
url = self.version_site + self.current_version.name()
df = ThreadedDeferred(_wrap_task(self.rawserver.external_add_task),
self._get_available, url, daemon=True)
yield df
try:
available_version = df.getResult()
except BTFailure, e:
self.debug(debug_prefix + 'failed to load %s' % url)
self._restart()
return
def check_version(self):
"""Launch the actual version check code in a coroutine since
it needs to make three (or four, in beta) http requests, one
disk read, and one decryption."""
df = launch_coroutine(_wrap_task(self.rawserver.external_add_task),
self._check_version)
def errback(e):
from traceback import format_exc
self.debug('check_version() run #%d: '%self.runs + format_exc(e))
df.addErrback(errback)
def _start_announce(*a):
self.running_df = ThreadedDeferred(_wrap_task(self.externalsched),
self._rerequest, s, self.peerid,
daemon=True)
def _rerequest_finish(x):
self.running_df = None
def _rerequest_error(e):
self.errorfunc(logging.ERROR, _("Rerequest failed!"),
exception=True, exc_info=e)
self.running_df.addCallbacks(_rerequest_finish, _rerequest_error)
if event == 'stopped':
# if self._rerequest needs any state, pass it through args
self.cleanup()
def initialize(self, save_path, files):
# a list of bytes ranges and filenames for window-based IO
self.ranges = []
# a dict of filename-to-ranges for piece priorities and filename lookup
self.range_by_name = {}
# a sparse set for smart allocation detection
self.allocated_regions = SparseSet()
# dict of filename-to-length on disk (for % complete in the file view)
self.undownloaded = {}
self.save_path = save_path
# Rather implement this as an ugly hack here than change all the
# individual calls. Affects all torrent instances using this module.
if self.config['bad_libc_workaround']:
bad_libc_workaround()
self.initialized = False
self.startup_df = ThreadedDeferred(_wrap_task(self.external_add_task),
self._build_file_structs,
self.filepool, files)
return self.startup_df
def initialize_torrents(self):
df = launch_coroutine(_wrap_task(self.rawserver.add_task), self._initialize_torrents)
df.addErrback(lambda e : self.logger.error('initialize_torrents failed!',
exc_info=e))
return df
def shutdown(self):
df = launch_coroutine(_wrap_task(self.rawserver.add_task), self._shutdown)
df.addErrback(lambda e : self.logger.error('shutdown failed!',
exc_info=e))
return df
def write(self, pos, s):
df = launch_coroutine(_wrap_task(self.add_task),
self._batch_write, pos, s)
return df
def read(self, pos, amount):
df = launch_coroutine(_wrap_task(self.add_task),
self._batch_read, pos, amount)
return df
df = ThreadedDeferred(_wrap_task(self.rawserver.external_add_task),
self._get_available, url, daemon=True)
yield df
try:
available_version = df.getResult()
except BTFailure, e:
self.debug(debug_prefix + 'failed to load %s' % url)
self._restart()
return
if available_version.is_beta():
if available_version[1] != self.current_version[1]:
available_version = self.current_version
if self.current_version.is_beta():
stable_url = self.version_site + 'stable'
df = ThreadedDeferred(_wrap_task(self.rawserver.external_add_task),
self._get_available, stable_url)
yield df
try:
available_stable_version = df.getResult()
except BTFailure, e:
self.debug(debug_prefix + 'failed to load %s' % url)
self._restart()
return
if available_stable_version > available_version:
available_version = available_stable_version
self.debug(debug_prefix + 'got %s' % str(available_version))
if available_version <= self.current_version:
