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))