class OverlappedOp:
def initiateOp(self, handle, seekpos, buffer):
assert len(buffer) > 0
assert seekpos >= 0
df = Deferred()
try:
self.op(handle, seekpos, buffer,
self.ovDone, (handle, buffer))
except:
df.errback(Failure())
else:
self.df = df
return df
def op(self, *a, **kw):
raise NotImplementedError
def ovDone(self, ret, bytes, (handle, buffer)):
df = self.df
del self.df
if ret or not bytes:
try:
raise ctypes.WinError()
except:
df.errback(Failure())
else:
self.opComplete(df, bytes, buffer)
def _rerequest(self, url):
self.peers = ""
try:
self.dht.getPeersAndAnnounce(str(self.announce_infohash),
self.port, self._got_peers)
except Exception, e:
self._postrequest(failure=Failure())
def _close_files(self, df, file_set):
failure = None
done = False
filenames = self.open_file_to_handles.keys()
for filename in filenames:
if filename not in file_set:
continue
handles = self.open_file_to_handles.poprow(filename)
for handle in handles:
try:
handle.close()
except:
failure = Failure()
done = True
for filename in file_set.iterkeys():
if filename in self.active_file_to_handles:
done = False
break
if failure is not None:
df.errback(failure)
if not done:
# it would be nice to wait on the deferred for the outstanding ops
self.add_task(0.5, self._close_files, df, file_set)
else:
df.callback(True)
def _recall(self):
try:
t = self.gen.next()
except StopIteration:
self.deferred.callback(None)
self.cleanup()
except Exception, e:
exc_type, value, tb = sys.exc_info()
## Magic Traceback Hacking
if debug:
# interpreter shutdown
if not sys:
return
stream = sys.stderr
# HERE. This should really be logged or else bittorrent-
# curses will never be able to properly output. --Dave
_print_traceback(
stream, self.stack,
"generator %s" % self.gen.gi_frame.f_code.co_name, 0,
exc_type, value, tb)
else:
#if (tb.tb_lineno != self.gen.gi_frame.f_lineno or
# tb.f_code.co_filename != self.gen.gi_frame.f_code.co_filename):
# tb = FakeTb(self.gen.gi_frame, tb)
pass
## Magic Traceback Hacking
self.deferred.errback(Failure(value, exc_type, tb))
del tb
self.cleanup()
def launch_coroutine(queue_task, f, *args, **kwargs):
main_df = Deferred()
try:
g = f(*args, **kwargs)
except Exception, e:
if debug:
traceback.print_exc()
main_df.errback(Failure())
def _disk_thread(self):
while not self.doneflag.isSet():
df, func, args, kwargs = self.diskq.get(True)
try:
v = func(*args, **kwargs)
except:
self.external_add_task(0, df.errback, Failure())
else:
self.external_add_task(0, df.callback, v)
def initiateOp(self, handle, seekpos, buffer):
assert len(buffer) > 0
assert seekpos >= 0
df = Deferred()
try:
self.op(handle, seekpos, buffer, self.ovDone, (handle, buffer))
except:
df.errback(Failure())
else:
self.df = df
return df
def run():
global queue
while True:
df = queue.get()
if df is None:
break
if df.error:
try:
fdsfs = tasty
except:
reactor.callFromThread(df.errback, Failure())
else:
reactor.callFromThread(df.callback, 'post')
def _close_all(self, df):
failures = {}
while len(self.open_file_to_handles) > 0:
filename, handle = self.open_file_to_handles.popitem()
try:
handle.close()
except:
failures[self.file_to_torrent[filename]] = Failure()
for torrent, failure in failures.iteritems():
torrent.got_exception(failure)
if self.get_open_file_count() > 0:
# it would be nice to wait on the deferred for the outstanding ops
self.add_task(0.5, self._close_all, df)
else:
df.callback(True)
def _make_wrapped_call(self, _f, *args, **kwargs):
wrapper = kwargs.pop('wrapper', None)
try:
_f(*args, **kwargs)
except KeyboardInterrupt:
raise
except Exception, e: # hopefully nothing raises strings
# Incoming sockets can be assigned to a particular torrent during
# a data_came_in call, and it's possible (though not likely) that
# there could be a torrent-specific exception during the same call.
# Therefore read the context after the call.
context = None
if wrapper is not None:
context = wrapper.context
if context is not None:
context.got_exception(Failure())
elif self.noisy:
rawserver_logger.exception(
"Error in _make_wrapped_call for %s", _f.__name__)