def release_docker():
"""
由接口解压容器主线功能
@return:
"""
logger.info(f'<GeventSchedule> Release docker || Do {docker.__name__}')
exec(f'docker().{interface}()')
def run(self, speed_up=True, use_bar=False) -> None:
"""
协程任务接口
:return:
"""
task_list = []
if isinstance(self.docker, list):
# 刷新任务队列
self.load_tasks(tasks=self.docker)
else:
# 业务交接
self.work_Q = self.docker
# 弹性协程
if not speed_up:
self.power = 1
else:
self.flexible_power()
logger.info(
f'<Gevent> Flexible Power:{self.power} || Queue Capacity:{self.max_queue_size}'
)
# 启动进度条
if use_bar:
import threading
threading.Thread(target=self.progress_manager,
args=(self.max_queue_size, self.progress_name +
'[{}]'.format(self.power))).start()
for x in range(self.power):
task = gevent.spawn(self.launch)
task_list.append(task)
gevent.joinall(task_list)
def _deploy_jobs(self):
"""
@return:
"""
try:
for docker in self.dockers:
# 添加任务
self.scheduler_.add_job(
func=docker['api'],
trigger=IntervalTrigger(seconds=self.interval_[docker['name']]),
id=docker['name'],
jitter=5
)
# 打印日志
logger.info(
f'<BlockingScheduler> Add job -- <{docker["name"]}>'
f' IntervalTrigger: {self.interval_[docker["name"]]}s'
)
# 启动任务
self.scheduler_.start()
except KeyboardInterrupt as err:
logger.stop('Forced stop ||{}'.format(err))
except Exception as err:
logger.exception(f'<BlockingScheduler>||{err}')
def run(self):
logger.info("DO -- <{}>:beat_sync:{}".format(self.__class__.__name__, self.beat_sync))
api = self.set_spider_option()
api.get(self.register_url)
try:
self.sign_up(api)
self.wait(api, 20, "//div[@class='card-body']")
# get v2ray link
if self.hyper_params['v2ray']:
self.load_any_subscribe(
api,
"//div[@class='buttons']//a[contains(@class,'v2ray')]",
'data-clipboard-text',
'v2ray'
)
# get ssr link
if self.hyper_params['ssr']:
self.load_any_subscribe(
api,
"""//a[@onclick="importSublink('ssr')"]/..//a[contains(@class,'copy')]""",
'data-clipboard-text',
'ssr'
)
# if self.hyper_params['trojan']: ...
# if self.hyper_params['kit']: ...
# if self.hyper_params['qtl']: ...
except TimeoutException:
logger.error(f'>>> TimeoutException <{self.__class__.__name__}> -- {self.register_url}')
except WebDriverException as e:
logger.exception(f">>> Exception <{self.__class__.__name__}> -- {e}")
finally:
# Middleware.hera.put_nowait("push")
api.quit()
def __init__(self):
super(RedisDataDisasterTolerance, self).__init__()
from BusinessCentralLayer.setting import REDIS_SLAVER_DDT
if not REDIS_SLAVER_DDT.get('host'):
logger.warning('未设置数据容灾服务器，该职能将由Master执行')
# 拷贝参数
redis_virtual = REDIS_MASTER
# 改动浅拷贝数据库
redis_virtual.update({'db': redis_virtual['db'] + 1})
logger.debug("备份重定向 --> {}".format(redis_virtual))
else:
redis_virtual = REDIS_SLAVER_DDT
# 容器初始化
self.docker = {}
try:
self.acm = RedisClient(host=redis_virtual['host'], port=redis_virtual['port'],
password=redis_virtual['password'])
logger.info("DDT: Master({}) -> Slaver({})".format(REDIS_MASTER['host'], redis_virtual['host']))
except redis.exceptions.ConnectionError as e:
logger.exception(e)
finally:
self.redis_virtual = redis_virtual
def __init__(self) -> None:
logger.info(f'<系统初始化> SystemEngine -> {platform}')
# 读取配置序列
logger.info(f'<定位配置> check_sequence:{CRAWLER_SEQUENCE}')
# 默认linux下自动部署
logger.info(f'<部署设置> enable_deploy:{ENABLE_DEPLOY}')
# 协程加速配置
logger.info(f"<协程加速> Coroutine:{enable_coroutine}")
# 解压接口容器
logger.info("<解压容器> DockerEngineInterface")
# 初始化进程
logger.info(f'<加载队列> IndexQueue:{actions.__all__}')
logger.success('<Gevent> 工程核心准备就绪 任务即将开始')
def _sync_actions(
class_: str,
mode_sync: str = None,
only_sync=False,
beat_sync=True,
):
"""
@param class_:
@param mode_sync: 是否同步消息队列。False：同步本机任务队列，True：同步Redis订阅任务
@param only_sync:
@param beat_sync:
@return:
"""
logger.info(
f"<TaskManager> Sync{mode_sync.title()} || 正在同步<{class_}>任务队列...")
# TODO 原子化同步行为
rc = RedisClient()
# 拷贝生成队列，需使用copy()完成拷贝，否则pop()会影响actions-list本体
task_list: list = actions.__all__.copy()
random.shuffle(task_list)
# 在本机环境中生成任务并加入消息队列
if mode_sync == 'upload':
# 持续实例化采集任务
while True:
if task_list.__len__() == 0:
logger.success("<TaskManager> EmptyList -- 本机任务为空或已完全生成")
break
else:
slave_ = task_list.pop()
# 将相应的任务执行语句转换成exec语法
expr = f'from BusinessLogicLayer.cluster.slavers.actions import {slave_}\n' \
f'{slave_}(beat_sync={beat_sync}).run()'
# 将执行语句同步至消息队列
rc.sync_message_queue(mode='upload', message=expr)
# 节拍同步线程锁
if only_sync:
logger.warning(
"<TaskManager> OnlySync -- 触发节拍同步线程锁，仅上传一枚原子任务")
break
logger.info(
f"<TaskManager> 本节点任务({actions.__all__.__len__()})已同步至消息队列，"
f"待集群接收订阅后既可完成后续任务")
# 同步分布式消息队列的任务
elif mode_sync == 'download':
while True:
# 判断同步状态
# 防止过载。当本地缓冲任务即将突破容载极限时停止同步
# _state 状态有三，continue/offload/stop
_state = _is_overflow(task_name=class_, rc=rc)
if _state != 'continue':
return _state
# 获取原子任务，该任务应已封装为exec语法
# todo 将入队操作封装到redis里，以获得合理的循环退出条件
atomic = rc.sync_message_queue(mode='download')
# 若原子有效则同步数据
if atomic:
# 将执行语句推送至Poseidon本机消息队列
Middleware.poseidon.put_nowait(atomic)
logger.info(f'<TaskManager> offload atomic<{class_}>')
# 节拍同步线程锁
if only_sync:
logger.warning(
f"<TaskManager> OnlySync -- <{class_}>触发节拍同步线程锁，仅下载一枚原子任务"
)
return 'offload'
# 否则打印警告日志并提前退出同步
else:
logger.warning(f"<TaskManager> SyncFinish -- <{class_}>无可同步任务")
break
elif mode_sync == 'force_run':
for slave_ in task_list:
# force_run ：适用于单机部署或单步调试下
_state = _is_overflow(task_name=class_, rc=rc)
# 需要确保无溢出风险，故即使是force_run的启动模式，任务执行数也不应逾越任务容载数
if _state == 'stop':
return 'stop'
# 将相应的任务执行语句转换成exec语法
expr = f'from BusinessLogicLayer.cluster.slavers.actions import {slave_}\n' \
f'{slave_}(beat_sync={beat_sync}).run()'
# 将执行语句推送至Poseidon本机消息队列
Middleware.poseidon.put_nowait(expr)
# 在force_run模式下仍制约于节拍同步线程锁
# 此举服务于主机的订阅补充操作
# 优先级更高，不受队列可用容载影响强制中断同步操作
if only_sync:
logger.warning(
f"<TaskManager> OnlySync -- <{class_}>触发节拍同步线程锁，仅下载一枚原子任务")
return 'stop'
else:
logger.success(f"<TaskManager> ForceCollect"
f" -- 已将本地预设任务({actions.__all__.__len__()})录入待执行队列")
return 'offload'
def manage_task(class_: str = 'v2ray',
speedup: bool = True,
only_sync=False,
startup=None,
beat_sync=True,
force_run=None) -> bool:
"""
加载任务
@param force_run: debug模式下的强制运行，可逃逸队列满载检测
@param startup:创建协程工作空间，并开始并发执行队列任务。
@param only_sync:节拍同步线程锁。当本机任务数大于0时，将1枚原子任务推送至Poseidon协程空间。
@param class_: 任务类型,必须在 crawler seq内,如 ssr,v2ray or trojan。
@param speedup: 使用加速插件。默认使用coroutine-speedup。
@param beat_sync:
@return:
"""
# ----------------------------------------------------
# 参数审查与转译
# ----------------------------------------------------
# 检查输入
if class_ not in CRAWLER_SEQUENCE or not isinstance(class_, str):
return False
# 审核采集权限，允许越权传参。当手动指定参数时，可授予本机采集权限，否则使用配置权限
local_work: bool = startup if startup else ENABLE_DEPLOY.get('tasks').get(
'collector')
# 强制运行：指定参数优先级更高，若不指定则以是否单机部署模式决定运行force_run是否开启
# 默认单机模式下开启force_run
# 若未传参时也未定义部署形式（null），则默认不使用force_run
force_run = force_run if force_run else SINGLE_DEPLOYMENT
# ----------------------------------------------------
# 解析同步模式
# ----------------------------------------------------
# 以本机是否有采集权限来区分download 以及upload两种同步模式
mode_sync = "download" if local_work else "upload"
# 以更高优先级的`force_run` 替代传统同步模式，执行强制采集方案
mode_sync = "force_run" if force_run else mode_sync
# ----------------------------------------------------
# 同步消息（任务）队列
# ----------------------------------------------------
# 当本机可采集时，将任务同步至本机执行，若消息队列为空则
# 若本机不可采集，则生成任务加入消息队列
response: str or bool = _sync_actions(
class_=class_,
only_sync=only_sync,
beat_sync=beat_sync,
mode_sync=mode_sync,
)
# ----------------------------------------------------
# 初始化协程空间（执行任务）
# ----------------------------------------------------
# 若本机开启了采集器权限则创建协程空间
# 若从control-deploy进入此函数，则说明本机必定具备创建协程空间权限
if force_run:
if response == 'offload':
logger.info(f'<TaskManager> ForceRun || <{class_}>采集任务启动')
vsu(core=PuppetCore(), docker=Middleware.poseidon).run(speedup)
logger.success(f'<TaskManager> ForceWorkFinish || <{class_}>采集任务结束')
return True
# if 'force_run' is False and the node has the permissions of collector
if local_work:
# if task queue can be work
if response == 'offload':
logger.info(f'<TaskManager> Run || <{class_}>采集任务启动')
vsu(core=PuppetCore(), docker=Middleware.poseidon).run(speedup)
logger.success(f'<TaskManager> Finish || <{class_}>采集任务结束')
return True
else:
logger.warning(f"<TaskManager> Hijack<{class_}> || 当前节点不具备采集权限")
return False