def SendingTask(self):
sends = self.RunSend()
self.sendTaskDelay = misc.LoopAttenuation(
self.sendTaskDelay, sends > 0, settings.MinimumSendingDelay(),
settings.MaximumSendingDelay())
# attenuation
self.sendTask = reactor.callLater(self.sendTaskDelay, self.SendingTask)
def process_sessions(sessions_to_process=None):
global _ProcessSessionsTask
global _ProcessSessionsDelay
has_activity = False
if not sessions_to_process:
sessions_to_process = sessions().values()
for s in sessions_to_process:
if not s.peer_id:
continue
if not s.file_queue:
continue
if s.state != 'CONNECTED':
continue
has_outbox = s.file_queue.process_outbox_queue()
has_sends = s.file_queue.process_outbox_files()
if has_sends or has_outbox:
has_activity = True
if _ProcessSessionsTask is None or _ProcessSessionsTask.called:
if has_activity:
_ProcessSessionsDelay = MIN_PROCESS_SESSIONS_DELAY
else:
_ProcessSessionsDelay = misc.LoopAttenuation(
_ProcessSessionsDelay,
has_activity,
MIN_PROCESS_SESSIONS_DELAY,
MAX_PROCESS_SESSIONS_DELAY,
)
# attenuation
_ProcessSessionsTask = reactor.callLater(_ProcessSessionsDelay,
process_sessions)
def RequestTask(self):
if self.shutdown:
self.StopAllRequests()
return
requests = self.RunRequest()
self.requestTaskDelay = misc.LoopAttenuation(
self.requestTaskDelay, requests > 0,
settings.MinimumReceivingDelay(), settings.MaximumReceivingDelay())
# attenuation
self.requestTask = reactor.callLater(
self.requestTaskDelay, self.RequestTask) # @UndefinedVariable
def SendingTask(self):
if self.shutdown:
self.StopAllSindings()
return
sends = self.RunSend()
self.sendTaskDelay = misc.LoopAttenuation(
self.sendTaskDelay, sends > 0, settings.MinimumSendingDelay(),
settings.MaximumSendingDelay())
# attenuation
self.sendTask = reactor.callLater(
self.sendTaskDelay, self.SendingTask) # @UndefinedVariable
def process_queues():
global _ProcessQueuesDelay
global _ProcessQueuesTask
global _ProcessQueuesLastTime
has_activity = do_consume()
_ProcessQueuesLastTime = time.time()
if _ProcessQueuesTask is None or _ProcessQueuesTask.called:
_ProcessQueuesDelay = misc.LoopAttenuation(
_ProcessQueuesDelay, has_activity,
MIN_PROCESS_QUEUES_DELAY,
MAX_PROCESS_QUEUES_DELAY,
)
# attenuation
_ProcessQueuesTask = reactor.callLater(_ProcessQueuesDelay, process_queues)
def RequestTask(self):
if self.shutdown:
return
# if self.RunRequest() > 0:
# self.requestTaskDelay = 0.1
# else:
# if self.requestTaskDelay < 8.0:
# self.requestTaskDelay *= 2.0
requests = self.RunRequest()
self.requestTaskDelay = misc.LoopAttenuation(
self.requestTaskDelay, requests > 0,
settings.MinimumReceivingDelay(), settings.MaximumReceivingDelay())
# attenuation
self.requestTask = reactor.callLater(
self.requestTaskDelay, self.RequestTask) # @UndefinedVariable
def process_streams():
from transport.tcp import tcp_node
global _ProcessStreamsDelay
global _ProcessStreamsTask
has_activity = False
for connections in tcp_node.opened_connections().values():
for connection in connections:
has_timeouts = False # connection.stream.timeout_incoming_files()
has_sends = False # connection.stream.process_sending_data()
has_outbox = connection.process_outbox_queue()
if has_timeouts or has_sends or has_outbox:
has_activity = True
_ProcessStreamsDelay = misc.LoopAttenuation(
_ProcessStreamsDelay, has_activity,
MIN_PROCESS_STREAMS_DELAY,
MAX_PROCESS_STREAMS_DELAY,)
# attenuation
_ProcessStreamsTask = reactor.callLater( # @UndefinedVariable
_ProcessStreamsDelay, process_streams)
