Example #1
0
 def make_statusrequest(self, event = None):
     """Make status request."""
     df = launch_coroutine(self.gui_wrap, self.update_status)
     def errback(e):
         self.logger.error("update_status failed", exc_info=e)
     df.addErrback(errback)
     return True
Example #2
0
 def callback(metainfo):
     def open(metainfo):
         df = self.multitorrent.torrent_known(metainfo.infohash)
         yield df
         known = df.getResult()
         if known:
             self.torrent_already_open(metainfo)
         else:
             df = self.open_torrent_metainfo(metainfo)
             if df is not None:
                 yield df
                 try:
                     df.getResult()
                 except TorrentAlreadyInQueue:
                     pass
                 except TorrentAlreadyRunning:
                     pass
     launch_coroutine(self.gui_wrap, open, metainfo)
Example #3
0
 def external_command(self, action, *datas):
     """For communication via IPC"""
     datas = [ d.decode('utf-8') for d in datas ]
     if action == 'start_torrent':
         assert len(datas) == 1
         self.append_external_torrents(*datas)
         self.logger.info('got external_command:start_torrent: "%s"' % datas[0])
         # this call does Ye Olde Threadede Deferrede:
         self.open_external_torrents()
     elif action == 'publish_torrent':
         self.logger.info('got external_command:publish_torrent: "%s" as "%s"' % datas)
         launch_coroutine(self.gui_wrap, self.publish_torrent, datas[0], datas[1])
     elif action == 'show_error':
         assert len(datas) == 1
         self.logger.error(datas[0])
     elif action == 'no-op':
         self.logger.info('got external_command: no-op')
     else:
         self.logger.warning('got unknown external_command: %s' % str(action))
 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)
Example #5
0
    def open_external_torrents(self):
        """Open torrents added externally (on the command line before startup)."""
        if self.open_external_torrents_deferred is None and \
               len(self.external_torrents):
            self.open_external_torrents_deferred = launch_coroutine(self.gui_wrap, self._open_external_torrents)
            def callback(*a):
                self.open_external_torrents_deferred = None
            def errback(e):
                callback()
                self.logger.error("open_external_torrents failed:", exc_info=e)

            self.open_external_torrents_deferred.addCallback(callback)
            self.open_external_torrents_deferred.addErrback(errback)
 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