def _get_services(self):
if not self.services or self.last_got_services + EXPIRE_CACHE < clock():
self.services = []
try:
f=win32com.client.Dispatch("UPnP.UPnPDeviceFinder")
for t in ( "urn:schemas-upnp-org:service:WANIPConnection:1",
"urn:schemas-upnp-org:service:WANPPPConnection:1" ):
try:
conns = f.FindByType(t,0)
for c in xrange(len(conns)):
try:
svcs = conns[c].Services
for s in xrange(len(svcs)):
try:
self.services.append(svcs[s])
except:
pass
except:
pass
except:
pass
except:
pass
self.last_got_services = clock()
return self.services
def _get_services(self):
if not self.services or self.last_got_services + EXPIRE_CACHE < clock():
self.services = []
try:
f = win32com.client.Dispatch("UPnP.UPnPDeviceFinder")
for t in (
"urn:schemas-upnp-org:service:WANIPConnection:1",
"urn:schemas-upnp-org:service:WANPPPConnection:1",
):
try:
conns = f.FindByType(t, 0)
for c in xrange(len(conns)):
try:
svcs = conns[c].Services
for s in xrange(len(svcs)):
try:
self.services.append(svcs[s])
except:
if DEBUG:
print_exc()
except:
if DEBUG:
print_exc()
except:
if DEBUG:
print_exc()
except:
if DEBUG:
print_exc()
self.last_got_services = clock()
return self.services
def listen_forever(self, handler):
print_stack()
if DEBUG:
print >>sys.stderr,"rawserver: listen forever()"
# handler=btlanuchmany: MultiHandler, btdownloadheadless: Encoder
self.sockethandler.set_handler(handler)
try:
while not self.doneflag.isSet():
try:
self.pop_external()
self._kill_tasks()
if self.funcs:
period = self.funcs[0][0] + 0.001 - clock()
else:
period = 2 ** 30
if period < 0:
period = 0
#if DEBUG:
# print >>sys.stderr,"rawserver: do_poll",period
events = self.sockethandler.do_poll(period)
if self.doneflag.isSet():
if DEBUG:
print >> sys.stderr,"rawserver: stopping because done flag set"
return
while self.funcs and self.funcs[0][0] <= clock():
garbage1, func, id = self.funcs.pop(0)
if id in self.tasks_to_kill:
pass
try:
# print func.func_name
if DEBUG:
if func.func_name != "_bgalloc":
print >> sys.stderr,"RawServer:f",func.func_name
#st = time.time()
func()
#et = time.time()
#diff = et - st
#print >>sys.stderr,func,"took %.5f" % (diff)
except (SystemError, MemoryError), e:
self.failfunc(e)
return
except KeyboardInterrupt,e:
# self.exception(e)
return
except error:
if DEBUG:
print >> sys.stderr,"rawserver: func: ERROR exception"
print_exc()
pass
except Exception,e:
if DEBUG:
print >> sys.stderr,"rawserver: func: any exception"
print_exc()
if self.noisy:
self.exception(e)
def _get_map(self):
if self.last_got_map + EXPIRE_CACHE < clock():
try:
dispatcher = win32com.client.Dispatch("HNetCfg.NATUPnP")
self.map = dispatcher.StaticPortMappingCollection
self.last_got_map = clock()
except:
self.map = None
return self.map
def _get_map(self):
if self.last_got_map + EXPIRE_CACHE < clock():
try:
dispatcher = win32com.client.Dispatch("HNetCfg.NATUPnP")
self.map = dispatcher.StaticPortMappingCollection
self.last_got_map = clock()
except:
self.map = None
return self.map
def test(lib, enc, dec, niter = 100000):
with clock(lib + ' encode:'):
for i in range(niter):
s = enc(data)
print lib, 'encode len:', len(s)
with clock(lib + ' decode:'):
for i in range(niter):
d = dec(s)
assert d == data
def listen_forever(self, handler):
self.sockethandler.set_handler(handler)
try:
while not self.doneflag.isSet():
try:
self.pop_external()
self._kill_tasks()
if self.funcs:
period = self.funcs[0][0] + 0.001 - clock()
else:
period = 2 ** 30
if period < 0:
period = 0
events = self.sockethandler.do_poll(period)
if self.doneflag.isSet():
return
while self.funcs and self.funcs[0][0] <= clock():
garbage1, func, id = self.funcs.pop(0)
if id in self.tasks_to_kill:
pass
try:
# print func.func_name
func()
except (SystemError, MemoryError) as e:
self.failfunc(str(e))
return
except KeyboardInterrupt:
# self.exception(True)
return
except:
if self.noisy:
self.exception()
self.sockethandler.close_dead()
self.sockethandler.handle_events(events)
if self.doneflag.isSet():
return
self.sockethandler.close_dead()
except (SystemError, MemoryError) as e:
self.failfunc(str(e))
return
except select.error:
if self.doneflag.isSet():
return
except KeyboardInterrupt:
# self.exception(True)
return
except:
self.exception()
if self.exccount > 10:
return
finally:
# self.sockethandler.shutdown()
self.finished.set()
def test(lib, enc, dec, niter=100000):
with clock(lib + ' encode:'):
for i in range(niter):
s = enc(data)
print lib, 'encode len:', len(s)
with clock(lib + ' decode:'):
for i in range(niter):
d = dec(s)
assert d == data
def listen_forever(self, handler):
self.sockethandler.set_handler(handler)
try:
while not self.doneflag.isSet():
try:
self.pop_external()
self._kill_tasks()
if self.funcs:
period = self.funcs[0][0] + 0.001 - clock()
else:
period = 2**30
if period < 0:
period = 0
events = self.sockethandler.do_poll(period)
if self.doneflag.isSet():
return
while self.funcs and self.funcs[0][0] <= clock():
garbage1, func, id = self.funcs.pop(0)
if id in self.tasks_to_kill:
pass
try:
# print func.func_name
func()
except (SystemError, MemoryError) as e:
self.failfunc(str(e))
return
except KeyboardInterrupt:
# self.exception(True)
return
except:
if self.noisy:
self.exception()
self.sockethandler.close_dead()
self.sockethandler.handle_events(events)
if self.doneflag.isSet():
return
self.sockethandler.close_dead()
except (SystemError, MemoryError) as e:
self.failfunc(str(e))
return
except select.error:
if self.doneflag.isSet():
return
except KeyboardInterrupt:
# self.exception(True)
return
except:
self.exception()
if self.exccount > 10:
return
finally:
# self.sockethandler.shutdown()
self.finished.set()
def option(message):
idG = up.verification(str(message.chat.id)) # получение группы из БД
sch = schedule(idGroups[idG]) # парс расписания
dateMon = time.strftime('%d.%m.%Y', time.localtime(clock() + 86400))
dateSat = time.strftime('%d.%m.%Y', time.localtime(clock() + 86400*6))
send = '{} - {}\n\n'.format(dateMon, dateSat)
for day in range(len(sch)-1):
send += weekDays[day] + ':\n'
for i in sch[day]:
send += i + '\n'
send += '\n'
bot.send_message(message.from_user.id, send)
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.resize(*配置.屏幕大小)
self.世界钟 = clock.clock()
self.周期钟 = clock.clock()
self.绘图钟 = clock.clock()
self.接管鼠标 = True
self.世界 = env.主世界
self.键盘控制 = [0, 0]
self.球控制 = [0, 0]
self.实际间隔 = 0
self.绘图间隔 = 0
self.逻辑间隔 = 0
self.t = 0
def get_time_left(self, left):
t = clock()
if not self.got_anything:
return None
if t - self.last > 15:
self.update(0)
try:
remaining = left / self.rate
if not self.lastten and remaining <= 10:
self.lastten = True
if self.lastten:
return remaining
delta = max(remaining / 20, 2)
if self.remaining is None:
self.remaining = remaining
elif abs(self.remaining - remaining) > delta:
self.remaining = remaining
else:
self.remaining -= t - self.last_checked
except ZeroDivisionError:
self.remaining = None
if self.remaining is not None and self.remaining < 0.1:
self.remaining = 0.1
self.last_checked = t
return self.remaining
def __init__(self): # configuration self.windowTitle = "" self.width = 600 self.height = 600 self.rotation = [0,0,0,0] self.camera_position = [0,0,0] self.keyboardTriggerCallback = lambda : None self.renderContext = lambda : None self.sceneContext = lambda : None # internal stuffff self.exit = False self.mouseData = [0,0,0,0,self.rotation[0],self.rotation[1]] self.clock = clock(); # // field of view, aspect ratio, near and far # This will squash and stretch our objects as the window is resized. self.initGLUT() self.initGLU() self.initGL() self.initShaders() self.objCoordsystem = objCoordsystem(0.1)
def onPause(self):
self.whenpaused = clock()
if not self.downloader:
return
self.downloader.pause(True)
self.encoder.pause(True)
self.choker.pause(True)
def update_rate(self, amount):
self.total += amount
t = clock()
self.rate = (self.rate * (self.last - self.ratesince) + amount) / (t - self.ratesince + 0.0001)
self.last = t
if self.ratesince < t - self.max_rate_period:
self.ratesince = t - self.max_rate_period
def try_send(self, check_time=False):
t = clock()
self.bytes_sent -= (t - self.lasttime) * self.upload_rate
#print 'try_send: bytes_sent: %s' % self.bytes_sent
self.lasttime = t
if check_time:
self.bytes_sent = max(self.bytes_sent, 0)
cur = self.last.next_upload
while self.bytes_sent <= 0:
bytes = cur.send_partial(self.unitsize)
self.bytes_sent += bytes
self.measure.update_rate(bytes)
if bytes == 0 or cur.backlogged():
if self.last is cur:
self.last = None
cur.next_upload = None
break
else:
self.last.next_upload = cur.next_upload
cur.next_upload = None
cur = self.last.next_upload
else:
# 2fastbt_
if not cur.connection.is_coordinator_con(
) or not cur.upload.buffer:
# _2fastbt
self.last = cur
cur = cur.next_upload
# 2fastbt_
else:
pass
# _2fastbt
else:
self.sched(self.try_send, self.bytes_sent / self.upload_rate)
def __init__(self, getfunc, minflush):
self.connections = {}
self.getfunc = getfunc
self.minflush = minflush
self.lastflush = clock()
if DEBUG:
log('HTTPHandler::__init__: ---')
def onPause(self):
self.whenpaused = clock()
if not self.downloader:
return
self.downloader.pause(True)
self.encoder.pause(True)
self.choker.pause(True)
def try_send(self, check_time=False):
if DEBUG:
print >> sys.stderr, 'RateLimiter: try_send'
t = clock()
self.bytes_sent -= (t - self.lasttime) * self.upload_rate
self.lasttime = t
if check_time:
self.bytes_sent = max(self.bytes_sent, 0)
cur = self.last.next_upload
while self.bytes_sent <= 0:
bytes = cur.send_partial(self.unitsize)
self.bytes_sent += bytes
self.measure.update_rate(bytes)
if bytes == 0 or cur.backlogged():
if self.last is cur:
self.last = None
cur.next_upload = None
break
else:
self.last.next_upload = cur.next_upload
cur.next_upload = None
cur = self.last.next_upload
elif not cur.connection.is_coordinator_con(
) or not cur.upload.buffer:
self.last = cur
cur = cur.next_upload
else:
delay = min(5.0, self.bytes_sent / self.upload_rate)
self.sched(self.try_send, delay)
def get_time_left(self, left):
t = clock()
if not self.got_anything:
return None
if t - self.last > 15:
self.update(0)
try:
remaining = left/self.rate
if not self.lastten and remaining <= 10:
self.lastten = True
if self.lastten:
return remaining
delta = max(remaining/20,2)
if self.remaining is None:
self.remaining = remaining
elif abs(self.remaining-remaining) > delta:
self.remaining = remaining
else:
self.remaining -= t - self.last_checked
except ZeroDivisionError:
self.remaining = None
if self.remaining is not None and self.remaining < 0.1:
self.remaining = 0.1
self.last_checked = t
return self.remaining
def try_send(self, check_time=False):
t = clock()
self.bytes_sent -= (t - self.lasttime) * self.upload_rate
self.lasttime = t
if check_time:
self.bytes_sent = max(self.bytes_sent, 0)
cur = self.last.next_upload
while self.bytes_sent <= 0:
bytes = cur.send_partial(self.unitsize)
self.bytes_sent += bytes
self.measure.update_rate(bytes)
if bytes == 0 or cur.backlogged():
if self.last is cur:
self.last = None
cur.next_upload = None
break
else:
self.last.next_upload = cur.next_upload
cur.next_upload = None
cur = self.last.next_upload
else:
self.last = cur
cur = cur.next_upload
else:
self.sched(self.try_send, self.bytes_sent / self.upload_rate)
def __init__(self, socket_handler, sock, handler, ip=None):
self.socket_handler = socket_handler
self.socket = sock
self.handler = handler
self.buffer = []
self.last_hit = clock()
self.fileno = sock.fileno()
self.connected = False
self.skipped = 0
self.myip = None
self.myport = -1
self.ip = None
self.port = -1
try:
myname = self.socket.getsockname()
self.myip = myname[0]
self.myport = myname[1]
peername = self.socket.getpeername()
self.ip = peername[0]
self.port = peername[1]
except:
if ip is None:
self.ip = 'unknown'
else:
self.ip = ip
self.data_sent = 0
self.data_received = 0
if DEBUG:
log('SingleSocket::__init__: myip', self.myip, 'myport',
self.myport, 'ip', self.ip, 'port', self.port, 'handler',
self.handler)
def __init__(self, socket_handler, sock, handler, ip = None):
self.socket_handler = socket_handler
self.socket = sock
self.handler = handler
self.buffer = []
self.last_hit = clock()
self.fileno = sock.fileno()
self.connected = False
self.skipped = 0
self.myip = None
self.myport = -1
self.ip = None
self.port = -1
try:
myname = self.socket.getsockname()
self.myip = myname[0]
self.myport = myname[1]
peername = self.socket.getpeername()
self.ip = peername[0]
self.port = peername[1]
except:
if ip is None:
self.ip = 'unknown'
else:
self.ip = ip
self.data_sent = 0
self.data_received = 0
if DEBUG:
log('SingleSocket::__init__: myip', self.myip, 'myport', self.myport, 'ip', self.ip, 'port', self.port, 'handler', self.handler)
def 生成地形(self, 世界, 块x, 块y):
if self.锁:
return True
self.锁 = True
assert (块x, 块y) not in 世界.已初始化区域
print('初始化:', 块x, 块y, '……')
c = clock.clock()
c.tick()
世界.已初始化区域.add((块x, 块y))
下界 = -16
a = self.生成矩阵(块x, 块y)
for 相对x in range(0, self.块边长):
for 相对y in range(0, self.块边长):
z = int(a[相对x, 相对y])
x = 相对x + self.块边长 * 块x
y = 相对y + self.块边长 * 块y
for zt in range(下界, z - 3):
世界.放块(x, y, zt, block.石, 初=True)
for zt in range(z - 3, z):
世界.放块(x, y, zt, block.土, 初=True)
世界.放块(x, y, z, block.草, 初=True)
R = random.Random(self.适应种子(块x, 块y))
for _ in range(15):
相对位置 = R.randint(4, self.块边长 - 5), R.randint(4, self.块边长 - 5)
位置 = 相对位置[0] + self.块边长 * 块x, 相对位置[1] + self.块边长 * 块y
self.放树(世界, *位置, int(a[相对位置]))
print('用时%.3fs。' % c.tick())
self.锁 = False
return False
def __init__(self, getfunc, minflush):
self.connections = {}
self.getfunc = getfunc
self.minflush = minflush
self.lastflush = clock()
if DEBUG:
log('HTTPHandler::__init__: ---')
def try_send(self, check_time = False):
if DEBUG: print >>sys.stderr, "RateLimiter: try_send"
t = clock()
self.bytes_sent -= (t - self.lasttime) * self.upload_rate
#print 'try_send: bytes_sent: %s' % self.bytes_sent
self.lasttime = t
if check_time:
self.bytes_sent = max(self.bytes_sent, 0)
cur = self.last.next_upload
while self.bytes_sent <= 0:
bytes = cur.send_partial(self.unitsize)
self.bytes_sent += bytes
self.measure.update_rate(bytes)
if bytes == 0 or cur.backlogged():
if self.last is cur:
self.last = None
cur.next_upload = None
break
else:
self.last.next_upload = cur.next_upload
cur.next_upload = None
cur = self.last.next_upload
else:
# 2fastbt_
if not cur.connection.is_coordinator_con() or not cur.upload.buffer:
# _2fastbt
self.last = cur
cur = cur.next_upload
# 2fastbt_
else:
pass
# _2fastbt
else:
self.sched(self.try_send, self.bytes_sent / self.upload_rate)
def try_send(self, check_time=False):
t = clock()
self.bytes_sent -= (t - self.lasttime) * self.upload_rate
self.lasttime = t
if check_time:
self.bytes_sent = max(self.bytes_sent, 0)
cur = self.last.next_upload
while self.bytes_sent <= 0:
bytes = cur.send_partial(self.unitsize)
self.bytes_sent += bytes
self.measure.update_rate(bytes)
if bytes == 0 or cur.backlogged():
if self.last is cur:
self.last = None
cur.next_upload = None
break
else:
self.last.next_upload = cur.next_upload
cur.next_upload = None
cur = self.last.next_upload
else:
self.last = cur
cur = cur.next_upload
else:
self.sched(self.try_send, self.bytes_sent / self.upload_rate)
def update_rate(self, amount):
self.total += amount
t = clock()
self.rate = (self.rate * (self.last - self.ratesince) + amount) / (t - self.ratesince + 0.0001)
self.last = t
if self.ratesince < t - self.max_rate_period:
self.ratesince = t - self.max_rate_period
return self.rate
def onUnpause(self):
if not self.downloader:
return
self.downloader.pause(False)
self.encoder.pause(False)
self.choker.pause(False)
# rerequest automatically if paused for >60 seconds
if self.rerequest and self.whenpaused and clock() - self.whenpaused > 60:
self.rerequest.announce(3)
def scan_for_timeouts(self):
t = clock() - self.timeout
tokill = []
for s in self.single_sockets.values():
if s.last_hit < t:
tokill.append(s)
for k in tokill:
if k.socket is not None:
self._close_socket(k)
def scan_for_timeouts(self):
t = clock() - self.timeout
tokill = []
for s in self.single_sockets.values():
if s.last_hit < t:
tokill.append(s)
for k in tokill:
if k.socket is not None:
self._close_socket(k)
def log(self, ip, ident, username, header, responsecode, length, referrer,
useragent):
year, month, day, hour, minute, second, a, b, c = time.localtime()
print '%s %s %s [%02d/%3s/%04d:%02d:%02d:%02d] "%s" %i %i "%s" "%s"' \
'' % (ip, ident, username, day, months[month], year, hour, minute,
second, header, responsecode, length, referrer, useragent)
t = clock()
if t - self.lastflush > self.minflush:
self.lastflush = t
sys.stdout.flush()
def __init__(self):
self.log = [[],[],[],[]]
self.running = False
self.mem = memory.memory(self.update_view)
self.dataBus = connexion.bus(self.mem, self.update_view)
self.clk = clock.clock(self.update_clock)
self.cores_list = []
self.local_total_list=[0,0,0,0]
for i in range(4):
self.cores_list.append(core.core(i,self.dataBus,self.clk,self.update_core))
def onUnpause(self):
if not self.downloader:
return
self.downloader.pause(False)
self.encoder.pause(False)
self.choker.pause(False)
# rerequest automatically if paused for >60 seconds
if self.rerequest and self.whenpaused and \
clock() - self.whenpaused > 60:
self.rerequest.announce(3)
def ping(self, delay):
##raise Exception('Is this called?')
if DEBUG:
print >> sys.stderr, delay
if not self.autoadjust:
return
self.pings.append(delay > PING_BOUNDARY)
if len(self.pings) < PING_SAMPLES + PING_DISCARDS:
return
if DEBUG:
print >> sys.stderr, 'RateLimiter: cycle'
pings = sum(self.pings[PING_DISCARDS:])
del self.pings[:]
if pings >= PING_THRESHHOLD: # assume flooded
if self.upload_rate == MAX_RATE:
self.upload_rate = self.measure.get_rate() * ADJUST_DOWN
else:
self.upload_rate = min(self.upload_rate,
self.measure.get_rate() * 1.1)
self.upload_rate = max(int(self.upload_rate * ADJUST_DOWN), 2)
self.slots = int(sqrt(self.upload_rate * SLOTS_FACTOR))
self.slotsfunc(self.slots)
if DEBUG:
print >> sys.stderr, 'RateLimiter: adjust down to ' + str(
self.upload_rate)
self.lasttime = clock()
self.bytes_sent = 0
self.autoadjustup = UP_DELAY_FIRST
else: # not flooded
if self.upload_rate == MAX_RATE:
return
self.autoadjustup -= 1
if self.autoadjustup:
return
self.upload_rate = int(self.upload_rate * ADJUST_UP)
self.slots = int(sqrt(self.upload_rate * SLOTS_FACTOR))
self.slotsfunc(self.slots)
if DEBUG:
print >> sys.stderr, 'RateLimiter: adjust up to ' + str(
self.upload_rate)
self.lasttime = clock()
self.bytes_sent = 0
self.autoadjustup = UP_DELAY_NEXT
def log(self, ip, ident, username, header,
responsecode, length, referrer, useragent):
year, month, day, hour, minute, second, a, b, c = time.localtime(time.time())
print '%s %s %s [%02d/%3s/%04d:%02d:%02d:%02d] "%s" %i %i "%s" "%s"' % (
ip, ident, username, day, months[month], year, hour,
minute, second, header, responsecode, length, referrer, useragent)
t = clock()
if t - self.lastflush > self.minflush:
self.lastflush = t
stdout.flush()
def scan_for_timeouts(self):
t = clock() - self.timeout
tokill = []
for s in self.single_sockets.values():
if s.last_hit < t:
tokill.append(s)
for k in tokill:
if k.socket is not None:
if DEBUG:
print >> sys.stderr,"SocketHandler: scan_timeout closing connection",k.get_ip()
self._close_socket(k)
def ping(self, delay):
##raise Exception('Is this called?')
if DEBUG:
print >>sys.stderr, delay
if not self.autoadjust:
return
self.pings.append(delay > PING_BOUNDARY)
if len(self.pings) < PING_SAMPLES+PING_DISCARDS:
return
if DEBUG:
print >>sys.stderr, 'RateLimiter: cycle'
pings = sum(self.pings[PING_DISCARDS:])
del self.pings[:]
if pings >= PING_THRESHHOLD: # assume flooded
if self.upload_rate == MAX_RATE:
self.upload_rate = self.measure.get_rate()*ADJUST_DOWN
else:
self.upload_rate = min(self.upload_rate,
self.measure.get_rate()*1.1)
self.upload_rate = max(int(self.upload_rate*ADJUST_DOWN), 2)
self.slots = int(sqrt(self.upload_rate*SLOTS_FACTOR))
self.slotsfunc(self.slots)
if DEBUG:
print >>sys.stderr, 'RateLimiter: adjust down to '+str(self.upload_rate)
self.lasttime = clock()
self.bytes_sent = 0
self.autoadjustup = UP_DELAY_FIRST
else: # not flooded
if self.upload_rate == MAX_RATE:
return
self.autoadjustup -= 1
if self.autoadjustup:
return
self.upload_rate = int(self.upload_rate*ADJUST_UP)
self.slots = int(sqrt(self.upload_rate*SLOTS_FACTOR))
self.slotsfunc(self.slots)
if DEBUG:
print >>sys.stderr, 'RateLimiter: adjust up to '+str(self.upload_rate)
self.lasttime = clock()
self.bytes_sent = 0
self.autoadjustup = UP_DELAY_NEXT
def listen_forever(self, handler):
self.sockethandler.set_handler(handler)
try:
while not self.doneflag.isSet():
try:
self.pop_external()
self._kill_tasks()
if self.funcs:
period = self.funcs[0][0] + 0.001 - clock()
else:
period = 2 ** 30
if period < 0:
period = 0
events = self.sockethandler.do_poll(period)
if self.doneflag.isSet():
return
while self.funcs and self.funcs[0][0] <= clock():
garbage1, func, id = self.funcs.pop(0)
if id in self.tasks_to_kill:
pass
try:
func()
except (SystemError, MemoryError), e:
print_exc()
self.failfunc(exceptionArgsToString(e))
return
except KeyboardInterrupt:
return
except:
if self.noisy:
self.exception()
self.sockethandler.close_dead()
self.sockethandler.handle_events(events)
if self.doneflag.isSet():
return
self.sockethandler.close_dead()
except (SystemError, MemoryError), e:
print_exc()
self.failfunc(exceptionArgsToString(e))
return
def scan_for_timeouts(self):
t = clock() - self.timeout
tokill = []
for s in self.single_sockets.values():
if s.last_hit < t:
tokill.append(s)
for k in tokill:
if k.socket is not None:
if DEBUG:
print >> sys.stderr, "SocketHandler: scan_timeout closing connection", k.get_ip(
)
self._close_socket(k)
def scan_for_timeouts(self):
t = clock() - self.timeout
tokill = []
for s in self.single_sockets.values():
if type(s) is SingleSocket and s.last_hit < t:
tokill.append(s)
for k in tokill:
if k.socket is not None:
if DEBUG:
log('SocketHandler::scan_for_timeouts: closing connection', k.get_ip())
self._close_socket(k)
def get_ip(self):
if self.last_got_ip + EXPIRE_CACHE < clock():
local_ips = IP_List()
local_ips.set_intranet_addresses()
try:
for info in socket.getaddrinfo(socket.gethostname(),0,socket.AF_INET):
# exception if socket library isn't recent
self.local_ip = info[4][0]
if local_ips.includes(self.local_ip):
self.last_got_ip = clock()
if DEBUG:
print 'Local IP found: '+self.local_ip
break
else:
raise ValueError('couldn\'t find intranet IP')
except:
self.local_ip = None
if DEBUG:
print 'Error finding local IP'
print_exc()
return self.local_ip
def get_ip(self):
if self.last_got_ip + EXPIRE_CACHE < clock():
local_ips = IP_List()
local_ips.set_intranet_addresses()
try:
for info in socket.getaddrinfo(socket.gethostname(),0,socket.AF_INET):
# exception if socket library isn't recent
self.local_ip = info[4][0]
if local_ips.includes(self.local_ip):
self.last_got_ip = clock()
if DEBUG:
print 'Local IP found: '+self.local_ip
break
else:
raise ValueError('couldn\'t find intranet IP')
except:
self.local_ip = None
if DEBUG:
print 'Error finding local IP'
print_exc()
return self.local_ip
def scan_for_timeouts(self):
t = clock() - self.timeout
tokill = []
for s in self.single_sockets.values():
if type(s) is SingleSocket and s.last_hit < t:
tokill.append(s)
for k in tokill:
if k.socket is not None:
if DEBUG:
log('SocketHandler::scan_for_timeouts: closing connection',
k.get_ip())
self._close_socket(k)
def get_ip(self):
if self.last_got_ip + EXPIRE_CACHE < clock():
if self.local_ip is None:
local_ips = IP_List()
local_ips.set_intranet_addresses()
try:
for info in socket.getaddrinfo(socket.gethostname(), 0, socket.AF_INET):
self.local_ip = info[4][0]
if local_ips.includes(self.local_ip):
self.last_got_ip = clock()
if DEBUG:
print >> sys.stderr, 'upnpX: Local IP found: ' + self.local_ip
break
else:
raise ValueError("upnpX: couldn't find intranet IP")
except:
self.local_ip = None
if DEBUG:
print >> sys.stderr, 'upnpX: Error finding local IP'
print_exc()
return self.local_ip
def update(self, amount):
t = clock()
t1 = int(t)
l1 = int(self.last)
for i in xrange(l1,t1):
self.time *= FACTOR
self.got *= FACTOR
self.got += amount
if t - self.last < 20:
self.time += t - self.last
self.last = t
try:
self.rate = self.got / self.time
except ZeroDivisionError:
pass
def get_ip(self):
if self.last_got_ip + EXPIRE_CACHE < clock():
if self.local_ip is None:
local_ips = IP_List()
local_ips.set_intranet_addresses()
try:
for info in socket.getaddrinfo(socket.gethostname(), 0,
socket.AF_INET):
self.local_ip = info[4][0]
if local_ips.includes(self.local_ip):
self.last_got_ip = clock()
if DEBUG:
print >> sys.stderr, 'upnpX: Local IP found: ' + self.local_ip
break
else:
raise ValueError("upnpX: couldn't find intranet IP")
except:
self.local_ip = None
if DEBUG:
print >> sys.stderr, 'upnpX: Error finding local IP'
print_exc()
return self.local_ip
def update(self, amount):
t = clock()
t1 = int(t)
l1 = int(self.last)
for i in xrange(l1, t1):
self.time *= FACTOR
self.got *= FACTOR
self.got += amount
if t - self.last < 20:
self.time += t - self.last
self.last = t
try:
self.rate = self.got / self.time
except ZeroDivisionError:
pass
def try_send(self, check_time=False):
if DEBUG: print >> sys.stderr, "RateLimiter: try_send"
t = clock()
self.bytes_sent -= (t - self.lasttime) * self.upload_rate
#print >> sys.stderr, 'try_send: bytes_sent: %s' % self.bytes_sent
self.lasttime = t
if check_time and (self.upload_rate < MAX_RATE * 1000):
#do not set self.bytes_sent to 0 if we are unlimited...
self.bytes_sent = max(self.bytes_sent, 0)
cur = self.last.next_upload
while self.bytes_sent <= 0:
#we would like to send up to self.bytes_sent data to someone
#why not try to send this at once?
#bytes = cur.send_partial(self.unitsize)
remaining_bytes = max(self.unitsize, int(1 - self.bytes_sent))
bytes = cur.send_partial(remaining_bytes)
self.bytes_sent += bytes
self.measure.update_rate(bytes)
if bytes == 0 or cur.backlogged():
if self.last is cur:
self.last = None
cur.next_upload = None
break
else:
self.last.next_upload = cur.next_upload
cur.next_upload = None
cur = self.last.next_upload
else:
#does this connection still have a buffer?
if not cur.upload.buffer:
self.last = cur
cur = cur.next_upload #switch to the next one
else:
pass
else:
# 01/04/10 Boudewijn: because we use a -very- small value
# to indicate a 0bps rate, we will schedule the call to be
# made in a very long time. This results in no upload for
# a very long time.
#
# the try_send method has protection again calling to
# soon, so we can simply schedule the call to be made
# sooner.
delay = min(5.0, self.bytes_sent / self.upload_rate)
self.sched(self.try_send, delay)
def __init__(self, socket_handler, sock, handler, ip = None):
self.socket_handler = socket_handler
self.socket = sock
self.handler = handler
self.buffer = []
self.last_hit = clock()
self.fileno = sock.fileno()
self.connected = False
self.skipped = 0
# self.check = StreamCheck()
try:
self.ip = self.socket.getpeername()[0]
except:
if ip is None:
self.ip = 'unknown'
else:
self.ip = ip
def __init__(self, socket_handler, sock, handler, ip = None):
self.socket_handler = socket_handler
self.socket = sock
self.handler = handler
self.buffer = []
self.last_hit = clock()
self.fileno = sock.fileno()
self.connected = False
self.skipped = 0
# self.check = StreamCheck()
try:
self.ip = self.socket.getpeername()[0]
except:
if ip is None:
self.ip = 'unknown'
else:
self.ip = ip
def set_upload_rate(self, rate):
# rate = -1 # test automatic
if rate < 0:
if self.autoadjust:
return
self.autoadjust = True
self.autoadjustup = 0
self.pings = []
rate = MAX_RATE
self.slots = SLOTS_STARTING
self.slotsfunc(self.slots)
else:
self.autoadjust = False
if not rate:
rate = MAX_RATE
self.upload_rate = rate * 1000
self.lasttime = clock()
self.bytes_sent = 0
def set_upload_rate(self, rate):
# rate = -1 # test automatic
if rate < 0:
if self.autoadjust:
return
self.autoadjust = True
self.autoadjustup = 0
self.pings = []
rate = MAX_RATE
self.slots = SLOTS_STARTING
self.slotsfunc(self.slots)
else:
self.autoadjust = False
if not rate:
rate = MAX_RATE
self.upload_rate = rate * 1000
self.lasttime = clock()
self.bytes_sent = 0
def handle_events(self, events):
for sock, event in events:
s = self.servers.get(sock)
if s:
if event & (POLLHUP | POLLERR) != 0:
self.poll.unregister(s)
s.close()
del self.servers[sock]
print "lost server socket"
elif len(self.single_sockets) < self.max_connects:
try:
newsock, addr = s.accept()
newsock.setblocking(0)
nss = SingleSocket(self, newsock, self.handler)
self.single_sockets[newsock.fileno()] = nss
self.poll.register(newsock, POLLIN)
self.handler.external_connection_made(nss)
except socket.error:
self._sleep()
else:
s = self.single_sockets.get(sock)
if not s:
continue
s.connected = True
if (event & (POLLHUP | POLLERR)):
self._close_socket(s)
continue
if (event & POLLIN):
try:
s.last_hit = clock()
data = s.socket.recv(100000)
if not data:
self._close_socket(s)
else:
s.handler.data_came_in(s, data)
except socket.error, e:
code, msg = e
if code != EWOULDBLOCK:
self._close_socket(s)
continue
if (event & POLLOUT) and s.socket and not s.is_flushed():
s.try_write()
if s.is_flushed():
s.handler.connection_flushed(s)
def handle_events(self, events):
for sock, event in events:
s = self.servers.get(sock)
if s:
if event & (POLLHUP | POLLERR) != 0:
self.poll.unregister(s)
s.close()
del self.servers[sock]
print "lost server socket"
elif len(self.single_sockets) < self.max_connects:
try:
newsock, addr = s.accept()
newsock.setblocking(0)
nss = SingleSocket(self, newsock, self.handler)
self.single_sockets[newsock.fileno()] = nss
self.poll.register(newsock, POLLIN)
self.handler.external_connection_made(nss)
except socket.error:
self._sleep()
else:
s = self.single_sockets.get(sock)
if not s:
continue
s.connected = True
if (event & (POLLHUP | POLLERR)):
self._close_socket(s)
continue
if (event & POLLIN):
try:
s.last_hit = clock()
data = s.socket.recv(100000)
if not data:
self._close_socket(s)
else:
s.handler.data_came_in(s, data)
except socket.error, e:
code, msg = e
if code != EWOULDBLOCK:
self._close_socket(s)
continue
if (event & POLLOUT) and s.socket and not s.is_flushed():
s.try_write()
if s.is_flushed():
s.handler.connection_flushed(s)
def set_upload_rate(self, rate):
if DEBUG:
print >> sys.stderr, 'RateLimiter: set_upload_rate', rate
if rate < 0:
if self.autoadjust:
return
self.autoadjust = True
self.autoadjustup = 0
self.pings = []
rate = MAX_RATE
self.slots = SLOTS_STARTING
self.slotsfunc(self.slots)
else:
self.autoadjust = False
if not rate:
rate = MAX_RATE
self.upload_rate = rate * 1000
self.lasttime = clock()
self.bytes_sent = 0
def try_send(self, check_time = False):
if DEBUG: print >>sys.stderr, time.asctime(),'-', "RateLimiter: try_send"
t = clock()
self.bytes_sent -= (t - self.lasttime) * self.upload_rate
#print 'try_send: bytes_sent: %s' % self.bytes_sent
self.lasttime = t
if check_time:
self.bytes_sent = max(self.bytes_sent, 0)
cur = self.last.next_upload
while self.bytes_sent <= 0:
bytes = cur.send_partial(self.unitsize)
self.bytes_sent += bytes
self.measure.update_rate(bytes)
if bytes == 0 or cur.backlogged():
if self.last is cur:
self.last = None
cur.next_upload = None
break
else:
self.last.next_upload = cur.next_upload
cur.next_upload = None
cur = self.last.next_upload
else:
# 2fastbt_
if not cur.connection.is_coordinator_con() or not cur.upload.buffer:
# _2fastbt
self.last = cur
cur = cur.next_upload
# 2fastbt_
else:
pass
# _2fastbt
else:
# 01/04/10 Boudewijn: because we use a -very- small value
# to indicate a 0bps rate, we will schedule the call to be
# made in a very long time. This results in no upload for
# a very long time.
#
# the try_send method has protection again calling to
# soon, so we can simply schedule the call to be made
# sooner.
delay = min(5.0, self.bytes_sent / self.upload_rate)
self.sched(self.try_send, delay)
def log(self, ip, ident, username, header, responsecode, length, referrer, useragent):
year, month, day, hour, minute, second, a, b, c = time.localtime(time.time())
if DEBUG:
print >> sys.stderr, time.asctime(), "-", 'HTTPHandler: %s %s %s [%02d/%3s/%04d:%02d:%02d:%02d] "%s" %i %i "%s" "%s"' % (
ip,
ident,
username,
day,
months[month],
year,
hour,
minute,
second,
header,
responsecode,
length,
referrer,
useragent,
)
t = clock()
if t - self.lastflush > self.minflush:
self.lastflush = t
sys.stdout.flush()
def _add_task(self, func, delay, id = None):
if delay < 0:
delay = 0
insort(self.funcs, (clock() + delay, func, id))
