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: