class ProxyTester(object):
def __init__(self):
# 创建操作数据库的mongoPool对象
self.mongo_pool = MongoPool()
self.queue = Queue()
self.coroutine_pool = Pool()
def __check_callback(self,temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,callback=self.__check_callback)
def run(self):
# 提供一个run方法，用于处理检测代理IP核心逻辑
# 2.1 从数据库中获取所有代理IP
proxies = self.mongo_pool.find_all()
for proxy in proxies:
# self.__check_one_proxy(proxy)
# 把代理IP添加到队列中
self.queue.put(proxy)
# 3.5 开启多个一个异步任务，来处理代理IP的检测，可以通过配置文件指定异步数量
for i in range(TEST_PROXIES_ASYNC_COUNT):
# 3.4 通过异步回调，使用死循环不断执行这个方法
self.coroutine_pool.apply_async(self.__check_one_proxy,callback=self.__check_callback)
# 让当前线程，等待队列任务完成
self.queue.join()
def __check_one_proxy(self):
# 3.3 把检查一个代理可用性的代码，抽取到一个方法中，
# 从队列中获取代理IP,进行检查，检查完毕
proxy = self.queue.get()
# 2.3 检查代理可用性
proxy = check_proxy(proxy)
# 如果代理不可用，让代理分数-1
if proxy.speed == -1:
proxy.score -= 1
# 如果代理分数等于0,就从数据库中删除该代理
if proxy.score <= 45:
self.mongo_pool.delete_one(proxy)
else:
# 更新代理IP
self.mongo_pool.update_one(proxy)
else:
# 2.5 如果代理可用，就恢复该代理分数，更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 调度队列的task_done方法
self.queue.task_done()
@classmethod
def start(cls):
proxy_tester = cls()
proxy_tester.run()
schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTester(object):
def __init__(self):
self.mongo_pool = MongoPool()
self.queue = Queue()
self.coroutine_pool = Pool()
def _check_callback(self, temp):
self.coroutine_pool.apply_async(self._check_one_proxy, callback=self._check_callback)
def run(self):
# 检测所有ip可用性
# 获取数据库的ip
proxies = self.mongo_pool.find_all()
# 遍历代理ip列表
for proxy in proxies:
# 把代理ip添加到队列中
self.queue.put(proxy)
# 开启异步检测
for i in range(TEST_PROXIES_ASYNC_COUNT):
# 通过异步回调 使用循环不停的执行
self.coroutine_pool.apply_async(self._check_one_proxy, callback=self._check_callback)
# 让当前线程，等待队列完成
self.queue.join()
def _check_one_proxy(self):
# print(proxy)
# 检测ip可用性
# 从队列里面获取队列
proxy = self.queue.get()
proxy = check_proxy(proxy)
# 如果可用 代理分数减掉1
if proxy.speed == -1:
proxy.score -= 1
# 判断分数是否为零
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
# 更新代理ip
self.mongo_pool.update_one(proxy)
else:
# 如果代理可用， 就恢复代理的分数， 更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
self.queue.task_done()
@classmethod
def start(cls):
# 创建对象
proxy_tester = cls()
proxy_tester.run()
# 每隔一定的时间执行一次
schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTester(object):
def __init__(self):
self.mongo_pool = MongoPool()
self.queue = Queue()
self.coroutine_pool = Pool()
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
def run(self):
# 提供一个 run 方法，用于处理检测代理IP核心逻辑
# 2.1 从数据库中获取所以代理IP
proxies = self.mongo_pool.find_all()
# 2.2 遍历代理IP列表
for proxy in proxies:
# self.__check_one_proxy(proxy)
# 把代理ip添加到队列中
self.queue.put(proxy)
for i in range(TEST_PROXIES_ASYNC_COUNT):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
self.queue.join()
def __check_one_proxy(self):
''' 检查一个代理IP的可用性 '''
proxy = self.queue.get()
# 2.3 检测代理可用性
print(proxy)
proxy = check_proxy(proxy)
if proxy.speed == -1:
proxy.score -= 1
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
# 否则更新该代理ip
self.mongo_pool.update_one(proxy)
else:
# 2.5 如果代理可用，就恢复该代理的分数，更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
self.queue.task_done()
@classmethod
def start(cls):
# 4.2.1 创建本类对象
proxy_tester = cls()
proxy_tester.run()
schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTester(object):
def __init__(self):
self.mongo_pool = MongoPool()
self.coroutine_pool = Pool()
self.queue = Queue()
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
def run(self):
# 获取所有代理ip
proxies = self.mongo_pool.find_all()
for proxy in proxies:
# 把要检测的代理放到队列中
self.queue.put(proxy)
for i in range(TEST_PROXY_ASYNC_COUNT):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
# 当前线程等待队列的完成
self.queue.join()
def __check_one_proxy(self):
# 检查代理的可用性
proxy = self.queue.get()
proxy = check_proxy(proxy)
if proxy.speed == -1:
proxy.score -= 1
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
self.mongo_pool.update_one(proxy)
else:
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
self.queue.task_done()
@classmethod
def start(cls):
proxy_tester = cls()
proxy_tester.run()
schedule.every(TEST_PROXY_INTERVAL).minutes.do(proxy_tester.run)
while True:
schedule.run_pending()
class ProxyCheck(object):
def __init__(self):
self.mongo_pool = MongoPool()
self.queue = Queue()
self.coroutine_pool = Pool()
def run(self):
proxies = self.mongo_pool.find_all()
for proxy in proxies:
self.queue.put(proxy)
# 异步回调函数
for i in range(CHECK_PROXY_ASYNC):
self.coroutine_pool.apply_async(self._check_one_proxy,
callback=self._callback_check)
# 让当前线程等待队列任务完成
self.queue.join()
def _callback_check(self, tmp):
self.coroutine_pool.apply_async(self._check_one_proxy,
callback=self._callback_check)
def _check_one_proxy(self):
proxy = self.queue.get()
proxy = check_proxy(proxy)
if proxy.speed == -1:
proxy.score -= 1
print(proxy.score)
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
self.mongo_pool.update_one(proxy)
else:
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
self.queue.task_done()
@classmethod
def start(cls):
pc = ProxyCheck()
pc.run()
schedule.every(CHECK_PROXY_INTERVAL).do(pc.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTest(object):
def __init__(self):
self.mongo_pool = MongoPool()
self.queue = Queue()
self.coroutine_pool = Pool()
#回调函数
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
#队列实现
def run(self):
proxies = self.mongo_pool.find_all()
for proxy in proxies:
self.queue.put(proxy)
for i in range(ASYNC_NUM):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
self.queue.task_done()
def __check_one_proxy(self):
proxy = self.queue.get()
proxy = check_proxy(proxy)
if proxy.delay == -1:
proxy.score -= 1
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
self.mongo_pool.update_one(proxy)
else:
proxy.score == MAX_SCROE
self.mongo_pool.update_one(proxy)
self.queue.task_done()
#调用接口，定时任务
@classmethod
def start(cls):
rs = ProxyTest()
rs.run()
schedule.every().hours.do(rs.run)
while True:
schedule.run_pending()
time.sleep(30)
class ProxyTester(object):
def __init__(self):
self.mongo_pool = MongoPool()
self.q = Queue()
self.coroutine_pool = Pool()
def run(self):
proxies = self.mongo_pool.find_all()
for proxy in proxies:
self.q.put(proxy)
for i in range(TEST_PROXIES_ASCYNC_COUNT):
self.coroutine_pool.apply_async(self.__task, callback=self.__check_callback)
self.q.join()
def __check_callback(self, tmp):
self.coroutine_pool.apply_async(self.__task, callback=self.__check_callback)
def __task(self):
proxy = check_proxy(self.q.get())
if proxy.idle == -1:
proxy.score -= 1
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
self.mongo_pool.update_one(proxy)
else:
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
self.q.task_done()
@classmethod
def start(cls):
proxy_tester = cls()
proxy_tester.run()
schedule.every(TEST_PROXIES_INTERVAL).minutes.do(proxy_tester.run)
while True:
schedule.run_pending()
time.sleep(60)
class ProxyTester():
def __init__(self):
#创建操作数据库的MonggoPool对象
self.mongo_pool = MongoPool()
# 在init方法中创建队列和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
#提供一个run方法，用于处理检测代理IP核心逻辑
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
def run(self):
# 从数据库中获取所有代理IP
proxies = self.mongo_pool.find_all()
# 遍历IP列表
for proxy in proxies:
#把要检测的代理IP,放到队列中
self.queue.put(proxy)
# 开启多个一个异步任务，来处理代理IP的检测；可以通过配置文件指定异步数量
for i in range(TEST_PROXIES_ASYNC_COUNT):
#通过异步回调，使用死循环不断执行这个方法，
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
#让当前线程，等待队列任务完成
self.queue.join()
def __check_one_proxy(self):
#检查一个代理IP的可用性
#把检查一个代理可用性的代码，抽取到一个方法中；
# 从队列中获取代理IP，进行检查；检查完毕
proxy = self.queue.get()
# 检查代理IP可用性
proxy = check_proxy(proxy)
# 如果代理不可用，让代理分数减一，如果代理分数等于0则从数据库中删除该代理
if proxy.speed == -1:
proxy.score -= 1
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
self.mongo_pool.update_one(proxy) # 否则更新该ip
else:
proxy.score = MAX_SCORE # 如果代理可用，就恢复该代理的分数，更新到数据库中
self.mongo_pool.update_one(proxy)
#调度队列的task_done方法
self.queue.task_done()
@classmethod
def start(cls):
# 1，定义一个start的类方法
# 2，创建当前类的对象，调用run方法
rs = ProxyTester()
rs.run()
# 3，使用schedule模块，每隔一定时间，执行当前对象的run方法
# 修改配置文件，增加爬虫运行时间间隔的配置，单位为小时
schedule.every(TEST_PROXIES_INTERVAL).hours.do(rs.run)
while True:
schedule.run_pending()
time.sleep(2)
class ProxyTest(object):
def __init__(self):
# 创建操作数据库的MongoPool对象
self.mongo_pool = MongoPool()
# 创建队列和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy)
def run(self):
# 提供一个run 方法，用于处理检测代理命核心逻辑
# - 从数据库中获取所有代理IP
proxies = self.mongo_pool.find_all()
# - 遍历代理IP列表
for proxy in proxies:
# 把代理IP添加到队列中
self.queue.put(proxy)
# .开启多个异步任务，来处理代理IP的检测；可以通过配置文件指定异步数量
for i in range(TES_PROXIES_ASYNC_COUNT):
# 通过异步回调，使用死循环不断执行这个方法
self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback)
# 让当前线程等待队列的完成
self.queue.join()
def __check_one_proxy(self):
# 从队列中获取代理IP，进行检查
proxy = self.queue.get()
# 检查代理可用性
proxy = check_proxt(proxy)
# 如果代理不可用，让代理分数 - 1，如果代理分数等于0就从数据库中删除该代理
if proxy.speed == -1:
proxy.score -= 1
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
# 否则更新该代理IP
self.mongo_pool.update_one(proxy)
else:
# 如果代理可用，就恢复该代理的分数，更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 检查完毕，调度队列的task_done方法
self.queue.task_done()
@classmethod
def start(cls):
# 创建本类对象
proxy_tester = cls()
# 调用run方法
proxy_tester.run()
# 每间隔一定时间，执行一下，run方法
schedule.every(TEST_SPIDERS_INTERVAL).hours.do(proxy_tester.run())
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTester(object):
def __init__(self):
# 创建操作数据库的MongoPool对象
self.mongo_pool = MongoPool()
# 3.1 在`init`方法, 创建队列和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
def run(self):
# 提供一个 run 方法, 用于处理检测代理IP核心逻辑
# 2.1 从数据库中获取所有代理IP
proxies = self.mongo_pool.find_all()
# 2.2 遍历代理IP列表
for proxy in proxies:
# 3.2 把要检测的代理IP, 放到队列中
self.queue.put(proxy)
# 3.5 开启多个一个异步任务, 来处理代理IP的检测; 可以通过配置文件指定异步数量
for i in range(TEST_PROXIES_ASYNC_COUNT):
# 3.4 通过异步回调, 使用死循环不断执行这个方法,
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
# 让当前线程, 等待队列任务完成
self.queue.join()
def __check_one_proxy(self):
# 检查一个代理IP的可用性
# 3.3 把检查一个代理可用性的代码, 抽取到一个方法中;
# 从队列中获取代理IP, 进行检查; 检查完毕
proxy = self.queue.get()
# 2.3 检查代理可用性
proxy = check_proxy(proxy)
# 2.4 如果代理不可用, 让代理分数-1,
if proxy.speed == -1:
proxy.score -= 1
# 如果代理分数等于0就从数据库中删除该代理
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
# 否则更新该代理IP
self.mongo_pool.update_one(proxy)
else:
# 2.5 如果代理可用, 就恢复该代理的分数, 更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 调度队列的task_done方法
self.queue.task_done()
@classmethod
def start(cls):
# 4.2.1 创建本类对象
proxy_tester = cls()
# 4.2.2 调用run方法
proxy_tester.run()
# 4.2.3 每间隔一定时间, 执行一下, run方法
schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTester(object):
def __init__(self):
# 创建操作数据库的MongoPool对象
self.mongo_pool = MongoPool()
# 创建队列和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
def __chech_callbake(self, temp):
self.coroutine_pool.apply_async(self.__chech_one_proxy,
callback=self.__chech_callbake)
def run(self):
# 提供一个run方法，用于处理检测代理IP的核心逻辑
# 1. 从数据库里面获取所有IP
proxies = self.mongo_pool.find_all()
# 2. 遍历代理IP列表
for proxy in proxies:
# 把代理IP添加到队列里去
self.queue.put(proxy)
for i in range(TEST_PROXIES_ASYNC_COUNT):
# 通过异步回调，使用死循环不断执行这个方法
self.coroutine_pool.apply_async(self.__chech_one_proxy,
callback=self.__chech_callbake)
# 守护线程
self.queue.join()
def __chech_one_proxy(self):
# 从队列中获取代理IP，进行检查
proxy = self.queue.get()
# 3. 检测代理可用性
proxy = check_proxy(proxy)
# 4. 如果代理不可用，让代理分数-1
if proxy.speed == -1:
proxy.score -= 1
# 5. 如果代理分数等于0，就从数据库中删除该IP
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
# 6. 否则更新该IP
self.mongo_pool.update_one(proxy)
else:
# 如果代理可用，就恢复该代理分数，更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 调度队列的tesk_done方法
self.queue.task_done()
@classmethod
def start(cls):
# 创建本类对象
proxy_tester = cls()
# 调用run方法
proxy_tester.run()
# 每隔一段时间执行一次run方法
schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTester(object):
def __init__(self):
# 创建操作数据库的MongoPool对象
self.mongo_pool = MongoPool()
# 3.1 在`init`的方法中,创建队列和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
def run(self):
# 提供一个run方法,用于处理检测代理IP核心逻辑
# 2.1 从数据库中获取所有代理IP
proxies = self.mongo_pool.find_all()
# 2.2 遍历代理IP
for proxy in proxies:
# 把代理IP添加到队列中
self.queue.put(proxy)
# 3.5 开启多个一个异步任务,来处理代理IP的检测；可以通过配置文件指定异步数量
for i in range(TEST_PROXIES_ASYNC_COUNT):
self.coroutine_pool.apply_async(self.__check_one_proxy(),
callback=self.__check_callback)
# 让当前线程等待队列的完成
self.queue.join()
def __check_one_proxy(self):
"""
检查一个代理IP的可读性
:param proxy:
:return:
"""
# 3.3 把检查一个代理可用性的代码,抽取到一个方法中；从队列中获取代理IP,进行检查；检查完毕,调度队列的task_done方法
proxy = self.queue.get()
# 2.3 检查代理IP的可用性
proxy = check_proxy(proxy)
# 2.4 如果代理不可用,让代理分数-1
if proxy.speed == -1:
proxy.score -= 1
# 如果代理分数等于0就从数据库中删除该代理IP
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
# 否则更新代理IP
else:
self.mongo_pool.update_one(proxy)
else:
# 2.5 如果代理可用,就恢复该代理的分数,更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 调度队列的task_done方法
self.queue.task_done()
@classmethod
def start(cls):
proxy_tester = cls()
proxy_tester.run()
schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTester(object):
def __init__(self):
#创建操作数据库的MongoDB兑现
self.mongo_pool = MongoPool()
#在init方法中创建队列和协程池
self.queue =Queue()
self.coroutine_pool = Pool()
def __check_callback(self,temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,callback=self.__check_callback)
def run(self):
# 提供一个run方法，用于处理检测代理IP核心逻辑
# 2.1 从数据库中获取所有代理IP
proxies = self.mongo_pool.find_all()
# 2.2 遍历代理IP列表
for proxy in proxies:
#把代理IP添加到队列中
self.queue.put(proxy)
for i in range(TEST_PROXIES_ASYNC_COUNT):
# 通过异步回调，使用死循环不断执行这个方法
self.coroutine_pool.apply_async(self.__check_one_proxy,callback=self.__check_callback)
# 让当前线程，等待队里了任务完成
self.queue.join()
def __check_one_proxy(self):
# 调度队列的task_done方法
proxy = self.queue.get()
proxy = check_proxy(proxy)
if proxy.speed == -1:
proxy.score -= 1
# 如果代理分数等于0就从数据库中删除
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
self.mongo_pool.update_one(proxy)
else:
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 调用队列的task_done方法
self.queue.task_done()
@classmethod
def start(cls):
"""
在start方法中创建本类对象
用run方法每隔一段时间，执行一次，run方法
:return:
"""
proxy_tester = cls()
proxy_tester.run()
schedule.every(TEST_PROXIES_INTERVAL).hours.do(proxy_tester.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTester(object):
def __init__(self):
# 创建操作数据库的MongoPool对象
self.mongo_pool = MongoPool()
# 3.1 在init方法中创建队列和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
# 回调函数
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
def run(self):
"""提供run方法,用于处理检测代理IP可用性的核心逻辑"""
# 2.1 从数据库中获取所有的代理IP
proxies = self.mongo_pool.find_all()
# 2.2 遍历代理IP列表
for proxy in proxies:
# 3.2 把要检测的代理IP,放到队列中
self.queue.put(proxy)
# 3.5 开启多个异步任务,来处理代理IP的检测,可以通过配置文件指定异步数量
for i in range(TEST_PROXIES_ASYNC_COUNT):
# 3.4 通过异步回调,使用死循环不断执行这个方法
self.coroutine_pool.apply_async(self.__check_one_proxy,
callback=self.__check_callback)
# 让当前线程,等待队列任务的完成
self.queue.join()
def __check_one_proxy(self):
"""检测一个代理IP的可用性"""
# 3.3 把要检测一个代理IP的可用性代码抽取到一个方法中;从队列中获取代理IP,进行检测,检测完毕;调度队列的task_done方法
proxy = self.queue.get()
# 2.3 检查代理IP可用性
proxy = check_proxy(proxy)
# 2.4 如果代理IP不可用, 就让代理IP分值减一, 如果代理IP分值等于0就从数据库中删除该代理IP, 否则就更新该代理IP
if proxy.protocol == -1:
proxy.score -= 1 # 代理IP减一
if proxy.score == 0: # 如果代理IP分值等于0
# 从数据库中删除该代理IP
self.mongo_pool.delete_one(proxy)
else:
# 否则就更新该代理IP
self.mongo_pool.update_one(proxy)
else:
# 2.5 如果代理IP可用, 就让代理IP分值恢复, 并且更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 调度队列的task_done方法
self.queue.task_done()
# 4.1 定义类方法start(),用于启动检测代理IP
@classmethod
def start(cls):
# 4.2 创建当前类的对象,调用run方法
pt = cls()
pt.run()
# 4.3 使用schedule模块,每个一定时间间隔,执行一下run方法
# 修改配置文件,配置检测代理IP的时间间隔,单位为小时
schedule.every(TEST_SPIDRS_INTERVAL).hours.do(pt.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTest(object):
def __init__(self):
# 创建mongopool对象
self.mongo_pool = MongoPool()
# 3.1 在init方法，创建队列和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
def __check_callback(self, temp):
# 死循环
self.coroutine_pool.apply_async(self._check_one_proxy,
callback=self.__check_callback)
def run(self):
# 2)提供一个run方法，用于处理检测代理IP的核心逻辑
# - 2.1）从数据库中获取代理IP
proxies = self.mongo_pool.find_all()
# 2.2）遍历代理IP列表
for proxy in proxies:
print(proxy)
self.queue.put(proxy)
# 3.4）开启多个异步任务，来处理代理IP的检测，通过配置文件指定异步数量
for i in range(TEST_PROXIES_ASYNC_COUNT):
# 3.3）通过异步回调，使用死循环不断执行此方法
self.coroutine_pool.apply_async(self._check_one_proxy,
callback=self.__check_callback)
# 让当前线程等待任务完成
self.queue.join()
def _check_one_proxy(self):
# 3.2）把检查一个代理可用性的代码抽取到一个方法中，
# 从队列中获取IP，进行检查，检查完毕
proxy = self.queue.get()
proxy = check_proxy(proxy)
if proxy.speed == -1:
# 如果不可用，该代理 - 1，
proxy.score -= 1
# 若分数变为0，就从数据库中删除该ip，
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
# 否则更新该代理ip
else:
self.mongo_pool.update_one(proxy)
print(proxy.score)
else:
# 如果可用，则回复该代理ip的分数，更新到数据库中
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 调取队列中的task_done方法
self.queue.task_done()
# 4）使用schedule模块，每个一段时间，执行一次检测任务
@classmethod
def start(cls):
# - 4.1）定义一个start的类方法
# - 4.2）创建当前类的对象，调用run方法
pt = cls()
pt.run()
# - 4.3）使用schedule模块，每个一定时间，执行当前对象的run方法
schedule.every(TEST_PROXIES_INTERVAL).hours.do(pt.run)
while True:
schedule.run_pending()
time.sleep(1)
class ProxyTest(object):
def __init__(self):
self.mongo_pool = MongoPool()
# 创建Queue和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
def __modify_one_proxy(self, proxy):
proxy = check_proxy(proxy)
if proxy.speed == -1:
proxy.score -= 1
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
self.mongo_pool.update_one(proxy)
else:
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
return proxy
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__execute_queued_task,
callback=self.__check_callback)
def __execute_queued_task(self):
# 从Queue中获取一个代理IP
proxy = self.queue.get()
proxy = self.__modify_one_proxy(proxy)
# 调用Queue的task done方法表示检测完毕一个代理IP
self.queue.task_done()
def __get_all_proxies_from_mongodb(self):
return self.mongo_pool.find_all()
def run(self):
proxies = self.__get_all_proxies_from_mongodb()
for proxy in proxies:
# 把代理IP添加到Queue中
self.queue.put(proxy)
# self.__modify_one_proxy(proxy)
# 开启多个异步任务，开始数量有settings设置
for i in range(PROXY_TEST_ASYNC_TASK_AMOUNT):
# 开始协程池进行单线程异步任务
self.coroutine_pool.apply_async(self.__execute_queued_task,
callback=self.__check_callback)
# 让当前线程等待队列任务的完成
self.queue.join()
@classmethod
def start(cls):
pt = cls()
pt.run()
logger.info('*****************本次检测完毕，等待下次检测*****************')
schedule.every(PROXY_TEST_INTERVAL).minutes.do(pt.run)
while True:
# print("等待下次更新")
schedule.run_pending()
# time.sleep(PROXY_TEST_INTERVAL * 60 /2 + 1)
time.sleep(1)
class ProxyTester(object):
def __init__(self):
# 创建操作数据库的MongoPool对象
self.mongo_pool = MongoPool()
# 3.1 在'init' 方法中创建队列和协程池
self.queue = Queue()
self.coroutine_pool = Pool()
def __check_callback(self, temp):
self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback)
def run(self):
# 提供一个 run 方法, 用于处理检测代理IP的核心逻辑
# 2.1 从数据库中获取所有代理IP
proxies = self.mongo_pool.find_all()
# 2.2 遍历代理Ip列表
for proxy in proxies:
# 3.2 把要检测的代理IP, 放入队列
self.queue.put(proxy)
# 3.5 开启多个异步任务, 来处理代理IP的检测, 可以通过配置文件控制异步任务数量
for i in range(TEST_PROXIES_ASYNC_COUNT):
# 3.4 通过异步回调, 使用死循环不断执行这个方法
self.coroutine_pool.apply_async(self.__check_one_proxy, callback=self.__check_callback)
# 让当前线程 等待队列中所有任务完成
self.queue.join()
def __check_one_proxy(self):
# 检查一个代理IP的可用性
# 3.3从队列中获取代理IP, 进行检查
proxy = self.queue.get()
# 2.3 检查代理可用性
proxy = check_proxy(proxy)
# 2.4 如果代理不可用, 让代理分数-1
if proxy.speed == -1:
proxy.score -= 1
# 如果代理分数等于0就从数据库中删除该代理IP
if proxy.score == 0:
self.mongo_pool.delete_one(proxy)
else:
# 否则更新该代理IP分数
self.mongo_pool.update_one(proxy)
else:
# 如果代理IP可用, 并且此时分数不为满分时, 就恢复该代理的分数,并更新
if proxy.score != MAX_SCORE:
proxy.score = MAX_SCORE
self.mongo_pool.update_one(proxy)
# 调度队列的task_done方法, 通知队列当前单位任务已完成
self.queue.task_done()
@classmethod
def start(cls):
# 4.2.1 调用run方法
cls().run()
# 4.2.2 每间隔一定时间, 执行一下, run方法
schedule.every(TEST_PROXIES_INTERVAL).hours.do(cls().run)
while True:
schedule.run_pending()
time.sleep(1)
