Python lru_cache.LRUCache方法代码示例

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self, server_list=None):
        self._loop = None
        self._hosts = {}
        self._hostname_status = {}
        self._hostname_to_cb = {}
        self._cb_to_hostname = {}
        self._cache = lru_cache.LRUCache(timeout=300)
        self._sock = None
        if server_list is None:
            self._servers = None
            self._parse_resolv()
        else:
            self._servers = server_list
        self._parse_hosts()
        # TODO monitor hosts change and reload hosts
        # TODO parse /etc/gai.conf and follow its rules 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self, block_hostname_list=None):
        self._loop = None
        self._hosts = {}
        self._hostname_status = {}
        self._hostname_to_cb = {}
        self._cb_to_hostname = {}
        self._cache = lru_cache.LRUCache(timeout=300)
        
        # block hostname
        if type(block_hostname_list) != list:
            self._block_hostname_list = []
        else:
            self._block_hostname_list = []
            for item in block_hostname_list:
                if type(item) != btyes:
                    item = item.encode('utf-8')
                self._block_hostname_list.appemd(item)
        logging.info("block_hostname_list is as: " + str(self._block_hostname_list))

        self._sock = None
        self._servers = None
        self._parse_resolv()
        self._parse_hosts()
        # TODO monitor hosts change and reload hosts
        # TODO parse /etc/gai.conf and follow its rules 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self, black_hostname_list=None):
        self._loop = None
        self._hosts = {}
        self._hostname_status = {}
        self._hostname_to_cb = {}
        self._cb_to_hostname = {}
        self._cache = lru_cache.LRUCache(timeout=300)
        # read black_hostname_list from config
        if type(black_hostname_list) != list:
            self._black_hostname_list = []
        else:
            self._black_hostname_list = list(map(
                (lambda t: t if type(t) == bytes else t.encode('utf8')),
                black_hostname_list
            ))
        logging.info('black_hostname_list init as : ' + str(self._black_hostname_list))
        self._sock = None
        self._servers = None
        self._parse_resolv()
        self._parse_hosts()
        # TODO monitor hosts change and reload hosts
        # TODO parse /etc/gai.conf and follow its rules 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self):
        # 时间循环
        self._loop = None
        # host文件中的IP地址
        self._hosts = {}
        # 记录请求的hostname的状态
        self._hostname_status = {}
        # 记录{hostname:callback}对
        self._hostname_to_cb = {}
        # 记录{callback:hostname}对
        self._cb_to_hostname = {}
        # LRU缓存
        self._cache = lru_cache.LRUCache(timeout=300)
        # 套接字
        self._sock = None
        # DNS服务器地址
        self._servers = None
        self._parse_resolv()
        self._parse_hosts()
        # TODO monitor hosts change and reload hosts
        # TODO parse /etc/gai.conf and follow its rules 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self, server_list=None, prefer_ipv6=False):
        self._loop = None
        self._hosts = {}
        self._hostname_status = {}
        self._hostname_to_cb = {}
        self._cb_to_hostname = {}
        self._cache = lru_cache.LRUCache(timeout=300)
        self._sock = None
        if server_list is None:
            self._servers = None
            self._parse_resolv()
        else:
            self._servers = server_list
        if prefer_ipv6:
            self._QTYPES = [QTYPE_AAAA, QTYPE_A]
        else:
            self._QTYPES = [QTYPE_A, QTYPE_AAAA]
        self._parse_hosts()
        # TODO monitor hosts change and reload hosts
        # TODO parse /etc/gai.conf and follow its rules 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self, config, dns_resolver, is_local, stat_callback=None):
        self._config = config
        if is_local:
            self._listen_addr = config['local_address']
            self._listen_port = config['local_port']
            self._remote_addr = config['server']
            self._remote_port = config['server_port']
        else:
            self._listen_addr = config['server']
            self._listen_port = config['server_port']
            self._remote_addr = None
            self._remote_port = None
        self._dns_resolver = dns_resolver
        self._password = common.to_bytes(config['password'])
        self._method = config['method']
        self._timeout = config['timeout']
        self._is_local = is_local
        self._cache = lru_cache.LRUCache(timeout=config['timeout'],
                                         close_callback=self._close_client)
        self._client_fd_to_server_addr = \
            lru_cache.LRUCache(timeout=config['timeout'])
        self._dns_cache = lru_cache.LRUCache(timeout=300)
        self._eventloop = None
        self._closed = False
        self._sockets = set()
        if 'forbidden_ip' in config:
            self._forbidden_iplist = config['forbidden_ip']
        else:
            self._forbidden_iplist = None

        addrs = socket.getaddrinfo(self._listen_addr, self._listen_port, 0,
                                   socket.SOCK_DGRAM, socket.SOL_UDP)
        if len(addrs) == 0:
            raise Exception("can't get addrinfo for %s:%d" %
                            (self._listen_addr, self._listen_port))
        af, socktype, proto, canonname, sa = addrs[0]
        server_socket = socket.socket(af, socktype, proto)
        server_socket.bind((self._listen_addr, self._listen_port))
        server_socket.setblocking(False)
        self._server_socket = server_socket
        self._stat_callback = stat_callback 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self):
        self._loop = None
        self._hosts = {}
        self._hostname_status = {}
        self._hostname_to_cb = {}
        self._cb_to_hostname = {}
        self._cache = lru_cache.LRUCache(timeout=300)
        self._sock = None
        self._servers = None
        self._parse_resolv()
        self._parse_hosts()
        # TODO monitor hosts change and reload hosts
        # TODO parse /etc/gai.conf and follow its rules 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self):
        self.client_id = lru_cache.LRUCache()
        self.local_client_id = b''
        self.connection_id = 0
        self.set_max_client(64) # max active client count 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def update(self, user_id, client_id, connection_id):
        if user_id not in self.user_id:
            self.user_id[user_id] = lru_cache.LRUCache()
        local_client_id = self.user_id[user_id]

        if client_id in local_client_id:
            local_client_id[client_id].update() 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def insert(self, user_id, client_id, connection_id):
        if user_id not in self.user_id:
            self.user_id[user_id] = lru_cache.LRUCache()
        local_client_id = self.user_id[user_id]

        if local_client_id.get(client_id, None) is None or not local_client_id[client_id].enable:
            if local_client_id.first() is None or len(local_client_id) < self.max_client:
                if client_id not in local_client_id:
                    #TODO: check
                    local_client_id[client_id] = client_queue(connection_id)
                else:
                    local_client_id[client_id].re_enable(connection_id)
                return local_client_id[client_id].insert(connection_id)

            if not local_client_id[local_client_id.first()].is_active():
                del local_client_id[local_client_id.first()]
                if client_id not in local_client_id:
                    #TODO: check
                    local_client_id[client_id] = client_queue(connection_id)
                else:
                    local_client_id[client_id].re_enable(connection_id)
                return local_client_id[client_id].insert(connection_id)

            logging.warn('auth_aes128: no inactive client')
            return False
        else:
            return local_client_id[client_id].insert(connection_id) 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self):
        self.client_data = lru_cache.LRUCache(60 * 5)
        self.client_id = os.urandom(32)
        self.startup_time = int(time.time() - 60 * 30) & 0xFFFFFFFF
        self.ticket_buf = {} 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def insert(self, user_id, client_id, connection_id):
        if user_id not in self.user_id:
            self.user_id[user_id] = lru_cache.LRUCache()
        local_client_id = self.user_id[user_id]

        if local_client_id.get(client_id, None) is None or not local_client_id[client_id].enable:
            if local_client_id.first() is None or len(local_client_id) < self.max_client:
                if client_id not in local_client_id:
                    #TODO: check
                    local_client_id[client_id] = client_queue(connection_id)
                else:
                    local_client_id[client_id].re_enable(connection_id)
                return local_client_id[client_id].insert(connection_id)

            if not local_client_id[local_client_id.first()].is_active():
                del local_client_id[local_client_id.first()]
                if client_id not in local_client_id:
                    #TODO: check
                    local_client_id[client_id] = client_queue(connection_id)
                else:
                    local_client_id[client_id].re_enable(connection_id)
                return local_client_id[client_id].insert(connection_id)

            logging.warn(self.name + ': no inactive client')
            return False
        else:
            return local_client_id[client_id].insert(connection_id) 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self):
		import threading
		self.event = threading.Event()
		self.key_list = ['port', 'u', 'd', 'transfer_enable', 'passwd', 'enable']
		self.last_get_transfer = {} #上一次的实际流量
		self.last_update_transfer = {} #上一次更新到的流量（小于等于实际流量）
		self.force_update_transfer = set() #强制推入数据库的ID
		self.port_uid_table = {} #端口到uid的映射（仅v3以上有用）
		self.onlineuser_cache = lru_cache.LRUCache(timeout=60*30) #用户在线状态记录
		self.pull_ok = False #记录是否已经拉出过数据
		self.mu_ports = {} 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self):
        self.client_data = lru_cache.LRUCache(60 * 5)
        self.client_id = os.urandom(32)
        self.startup_time = int(time.time() - 60 * 30) & 0xFFFFFFFF 

# 需要导入模块: from shadowsocks import lru_cache [as 别名]
# 或者: from shadowsocks.lru_cache import LRUCache [as 别名]
def __init__(self):
		import threading
		self.event = threading.Event()
		self.key_list = ['port', 'u', 'd', 'transfer_enable', 'passwd', 'enable']
		self.last_get_transfer = {} #上一次的实际流量
		self.last_update_transfer = {} #上一次更新到的流量（小于等于实际流量）
		self.force_update_transfer = set() #强制推入数据库的ID
		self.port_uid_table = {} #端口到uid的映射（仅v3以上有用）
		self.onlineuser_cache = lru_cache.LRUCache(timeout=60*30) #用户在线状态记录
		self.pull_ok = False #记录是否已经拉出过数据