def run(self, grow_domain_id: int):
with session_manager() as db_session:
grow_domain_obj = crud_domain_grow.get(db_session=db_session, id=grow_domain_id)
if not grow_domain_obj:
return
ip_address = grow_domain_obj.vps.ip
if not ip_address:
return
tmp_dir = TemporaryDirectory()
ssh_obj = crud_ssh_config.get_config(db_session)
ssh_conn = self.gen_ssh_conn(
addr=f"root@{ip_address}",
tmp_dir=tmp_dir.name,
private_key=ssh_obj.private_key
)
self.exec_remote_cmd(
conn=ssh_conn,
command=(
"ps -aux | grep 'nginx:' | awk '{print $2}'| xargs kill"
),
warn=True
)
return self.set_result()
def run(self, domain_id):
with session_manager() as db_session:
domain = crud_domain.get(db_session=db_session, id=domain_id)
if domain:
self.load_domain_dns_record(db_session, domain)
self.load_domain_dns_server(db_session, domain)
return self.set_result()
def run(self, isp_id: int, domain: str):
with session_manager() as db_session:
isp = crud_isp.get(db_session=db_session, id=isp_id)
isp_instance = isp.isp_instance
if not isp:
result = {
'status': 'pass',
'msg': f"empty isp via isp_id: {isp_id}"
}
return self.set_result(result)
formatted_domain = self.format_domain(domain)
domain_detect_result = isp_instance.check_domain_raw(formatted_domain)
domain_detect_replay_data = domain_detect_result.get('reply', {})
available_domain_data = domain_detect_replay_data.get("available", {})
unavailable_domain_data = domain_detect_replay_data.get("unavailable", {})
domain_list = []
for available_domain_data in self.extract_domain_data(available_domain_data):
domain_list.append(dict(purchasable=True, **available_domain_data))
for unavailable_domain_data in self.extract_domain_data(unavailable_domain_data):
domain_list.append(dict(purchasable=False, **unavailable_domain_data))
return domain_list
def run(self, vps_id: int, *args, **kwargs):
task_result = {}
with session_manager() as db_session:
vps_obj = crud_vps.get(db_session=db_session, id=vps_id)
if vps_obj and vps_obj.server_id:
task_result = vps_obj.isp.isp_instance.destroy_server(vps_obj.server_id)
return task_result
def reload_vps_isp_config(self, vps_isp_id: int) -> bool:
with session_manager() as db_session:
rp = RedisPool()
try:
vps_raw_spec_data = rp.get_vps_spec_data(db_session=db_session,
isp_id=vps_isp_id,
reload=True)
except Exception:
vps_raw_spec_data = None
return bool(vps_raw_spec_data)
def on_failure(self, exc, task_id, args, kwargs, einfo) -> None:
vps_id = args[-1] if isinstance(args[-1], int) else None
if not vps_id:
return self.log_exception(exc)
with session_manager() as db_session:
error_data = dict(
status=VpsStatus.error,
status_msg=str(einfo)
)
crud_vps.update(db_session=db_session, obj_id=vps_id, obj_in=error_data)
def run(self, vps_profile: VpsCreateSchema, vps_id: int, *args, **kwargs) -> dict:
with session_manager() as db_session:
vps_isp_obj = crud_isp.get(db_session=db_session, id=vps_profile['isp_id'])
ssh_key_obj = crud_ssh_config.get_config(db_session)
extra_server_data = vps_isp_obj.isp_instance.create_server(vps_profile, ssh_key_obj.public_key)
vps_data = dict(
status=VpsStatus.running,
**extra_server_data
)
crud_vps.update(db_session=db_session, obj_id=vps_id, obj_in=vps_data)
return self.set_result()
def run(self, *args, **kwargs):
with session_manager() as db_session:
domain_list = crud_domain.get_domain_list(db_session)
load_domain_extra_data_task = group([
LoadDomainExtraDataTask().s(domain.id)
for domain in domain_list
])
load_result = load_domain_extra_data_task.delay()
with allow_join_result():
load_result.join()
return self.set_result()
def run(self, isp_id: int, domain: str, **kwargs: dict):
with session_manager() as db_session:
isp = crud_isp.get(db_session=db_session, id=isp_id)
try:
register_success = isp.isp_instance.register_domain(domain)
except Exception as e:
self.log_exception(e)
register_success = False
if register_success:
domain_profile = DomainCreate(
isp_id=isp_id,
domain=domain
)
crud_domain.create(db_session=db_session, obj_in=domain_profile, serializer=None)
return register_success
def run(self, team_server_id: int):
with session_manager() as db_session:
team_server_obj = crud_team_server.get(db_session=db_session,
id=team_server_id)
ssh_obj = crud_ssh_config.get_config(db_session)
if not ssh_obj:
return
tmp_dir = TemporaryDirectory()
ssh_conn = self.gen_ssh_conn(addr=f"root@{team_server_obj.ip}",
private_key=ssh_obj.private_key,
tmp_dir=tmp_dir.name)
# 1. install requirement
install_lib_script = "apt-get install -y wget unzip"
self.exec_remote_cmd(conn=ssh_conn, command=install_lib_script)
# 2. download c2 profile , teamserver, cs
template_render = TemplateRender()
c2_content = team_server_obj.c2_profile.profile_content
team_server_content = template_render.render(
'scripts/team_server.sh', **{'port': team_server_obj.port})
cs_content = template_render.render(
'scripts/cs_install.sh',
cs_url=team_server_obj.cs_download_url,
zip_pwd=team_server_obj.zip_password,
cs_pwd=team_server_obj.password,
kill_date=team_server_obj.kill_date)
c2_tmp_file = self.gen_tmp_file(content=c2_content,
dir_path=tmp_dir.name)
team_server_file = self.gen_tmp_file(content=team_server_content,
dir_path=tmp_dir.name)
cs_server_file = self.gen_tmp_file(content=cs_content,
dir_path=tmp_dir.name)
self.upload_remote_file(conn=ssh_conn,
source_file=c2_tmp_file.name,
remote_file='ok.profile')
self.upload_remote_file(conn=ssh_conn,
source_file=team_server_file.name,
remote_file='teamserver')
self.upload_remote_file(conn=ssh_conn,
source_file=cs_server_file.name,
remote_file='cs.sh')
# 3. exec cs.sh
self.exec_remote_cmd(conn=ssh_conn,
command='chmod +x cs.sh && bash cs.sh')
return self.set_result()
def run(self, *args, **kwargs) -> dict:
task_result = {'handled_vps_isp_list': []}
with session_manager() as db_session:
vps_isp_obj_list = crud_isp.get_vps_isp_list(db_session).all()
vps_isp_data_list = parse_obj_as(List[IspItem], vps_isp_obj_list)
for vps_isp_data in vps_isp_data_list:
isp_provider_name = vps_isp_data.provider_name
if isp_provider_name in task_result['handled_vps_isp_list']:
continue
reload_result = self.reload_vps_isp_config(vps_isp_data.id)
if reload_result:
task_result['handled_vps_isp_list'].append(
isp_provider_name)
return self.set_result(task_result)
def run(self, task_data: dict, *args, **kwargs):
with session_manager() as db_session:
domain_dns_obj_list = crud_domain_dns_record.filter_by(
db_session=db_session, domain_id=task_data['domain_id']
)
for domain_dns_obj in domain_dns_obj_list:
domain_dns_type = domain_dns_obj.type
if domain_dns_type.lower() in ['a', 'cname']:
domain_health_data = self.fetch_domain_health_record(
domain_name=task_data['domain_name']
)
domain_health_obj = dict(
domain_id=task_data['domain_id'],
task_id=task_data['id'],
host=domain_dns_obj.host,
**domain_health_data
)
crud_domain_health.create(db_session=db_session, obj_in=domain_health_obj, serializer=None)
def run(self, *args, **kwargs):
redis_pool = RedisPool()
with session_manager() as db_session:
active_task_obj_list = crud_domain_task.get_active_task(db_session=db_session).all()
for active_task_obj in active_task_obj_list:
active_task_data = {
'id': active_task_obj.id,
'interval': active_task_obj.interval,
'domain_id': active_task_obj.domain_id,
'domain_name': active_task_obj.domain_name
}
monitor_task_running_key = redis_pool.gen_task_status_key(
status=redis_pool.TASK_RUNNING_STATUS,
sequence=active_task_data['id']
)
monitor_already_scheduled = redis_pool.exists(monitor_task_running_key)
if not monitor_already_scheduled:
redis_pool.set_data_cache(monitor_task_running_key, 1, ex=active_task_data['interval'])
MonitorDomainRunnerTask().delay(active_task_data)
def run(self, redirector_id: int):
with session_manager() as db_session:
redirector_obj = crud_redirector.get(db_session=db_session,
id=redirector_id)
ssh_obj = crud_ssh_config.get_config(db_session)
if not ssh_obj:
return
tmp_dir = TemporaryDirectory()
ssh_conn = self.gen_ssh_conn(addr=f"root@{redirector_obj.ip}",
private_key=ssh_obj.private_key,
tmp_dir=tmp_dir.name)
template_render = TemplateRender()
c2_content = redirector_obj.team_server.c2_profile.profile_content
c2_tmp_file = self.gen_tmp_file(content=c2_content,
dir_path=tmp_dir.name)
self.upload_remote_file(conn=ssh_conn,
source_file=c2_tmp_file.name,
remote_file='c2.profile')
redirector_content = template_render.render(
'scripts/c2_redirectors.sh',
domain=redirector_obj.domain_name,
ssl=1,
c2_profile='~/c2.profile',
cs2_server_ip=redirector_obj.team_server.cs_conn_url,
redirect=redirector_obj.redirect_domain)
redirector_bash_file = self.gen_tmp_file(
content=redirector_content, dir_path=tmp_dir.name)
self.upload_remote_file(conn=ssh_conn,
source_file=redirector_bash_file.name,
remote_file='redirector.sh')
self.exec_remote_cmd(
conn=ssh_conn,
command='chmod +x redirector.sh && bash redirector.sh')
def run(self, grow_domain_id: int):
with session_manager() as db_session:
grow_domain_obj = crud_domain_grow.get(db_session=db_session, id=grow_domain_id)
if not grow_domain_obj:
return
ip_address = grow_domain_obj.vps.ip
tmp_dir = TemporaryDirectory()
ssh_obj = crud_ssh_config.get_config(db_session)
site_work_dir = f"/opt/{PROJECT_NAME}/site"
site_data_dir = f"/opt/{PROJECT_NAME}/data"
# 1. install nginx
ssh_conn = self.gen_ssh_conn(
addr=f"root@{ip_address}",
tmp_dir=tmp_dir.name,
private_key=ssh_obj.private_key
)
install_nginx_command = (
"command -v yum && yum install -y epel-release && yum install -y nginx unzip;"
"command -v apt-get && apt-get update -y && apt-get install -y nginx unzip;"
f"mkdir -p {site_work_dir} {site_data_dir}"
)
self.exec_remote_cmd(conn=ssh_conn, command=install_nginx_command)
# 2. upload template file
site_template_file_name = grow_domain_obj.template.zip_file_name
site_template_content = BytesIO(grow_domain_obj.template.zip_file_content).read()
site_template_tmp_file = self.gen_tmp_file(
content=site_template_content,
dir_path=tmp_dir.name
)
self.upload_remote_file(
conn=ssh_conn,
source_file=site_template_tmp_file.name,
remote_file=f"{site_data_dir}/{site_template_file_name}"
)
# 3. update nginx conf and configure nginx
self.exec_remote_cmd(
conn=ssh_conn,
command=(
f"rm -rf {site_work_dir} &&"
f"unzip -o -d {site_work_dir} {site_data_dir}/{site_template_file_name};"
)
)
nginx_config_content = TemplateRender().render_nginx_conf(
nginx_site_work_dir=site_work_dir
)
nginx_config_tmp_file = self.gen_tmp_file(
content=nginx_config_content,
dir_path=tmp_dir.name
)
nginx_conf_deploy_path = f"{site_data_dir}/{TemplateRender.NGINX_TEMPLATE_CONF}"
self.upload_remote_file(
conn=ssh_conn,
source_file=nginx_config_tmp_file.name,
remote_file=nginx_conf_deploy_path
)
self.exec_remote_cmd(
conn=ssh_conn,
command=(
"ps -aux | grep 'nginx:' | awk '{print $2}'| xargs kill"
),
warn=True
)
self.exec_remote_cmd(
conn=ssh_conn,
command=(
f"nginx -c {nginx_conf_deploy_path}"
)
)
# 4. set dns record
grow_domain_obj.isp.isp_instance.set_dns_a_record(
grow_domain_obj.domain_name, ip_address
)
return
