def delete_domain_grow_task(
db: Session = Depends(get_db), *, grow_task_id: int):
celery_app.send_task("destroy_grow_domain", args=[grow_task_id])
delete_status = crud_domain_grow.remove(db_session=db, id=grow_task_id)
delete_result = dict(result={'status': delete_status})
return delete_result
def create_domain_grow_task(db: Session = Depends(get_db),
*,
domain_grow_profile: DomainGrowCreateSchema):
domain_grow_obj = crud_domain_grow.create(db_session=db,
obj_in=domain_grow_profile,
serializer=None)
celery_app.send_task("grow_domain", args=[domain_grow_obj.id])
return dict(result=domain_grow_obj)
def create_team_server(db: Session = Depends(get_db),
*,
team_server_profile: TeamServerCreateSchema):
team_server_obj = crud_team_server.create(db_session=db,
obj_in=team_server_profile,
serializer=None)
celery_app.send_task("deploy_team_server", args=[team_server_obj.id])
return dict(result=team_server_obj)
def create_redirector(db: Session = Depends(get_db),
*,
redirector_profile: RedirectorCreateSchema):
redirector_task_data = redirector_profile.dict()
redirector = crud_redirector.create(db_session=db,
obj_in=redirector_profile,
serializer=None)
celery_app.send_task("deploy_redirector", args=[redirector.id])
return dict(result=redirector)
def create_domain(
db: Session = Depends(get_db), *, domain_config: DomainCreate):
if crud_domain.exists(db_session=db, domain=domain_config.domain):
raise ValidationError(
[ErrorWrapper(Exception('domain already exists'), loc="domain")],
model=DomainCreate,
)
domain_data = crud_domain.create(db, obj_in=domain_config, serializer=None)
celery_app.send_task("load_domain_extra_data", args=[domain_data.id])
return dict(result=domain_data)
def create_vps_server(
db: Session = Depends(get_db), *, vps_profile: VpsCreateSchema):
# validate
vps_isp_obj = crud_isp.get(db_session=db, id=vps_profile.isp_id)
if not vps_isp_obj:
raise ValidationError(
[
ErrorWrapper(Exception('provider_name is not matched'),
loc="isp_id")
],
model=VpsCreateSchema,
)
# create base vps data
rp = RedisPool()
vps_spec_data = rp.get_vps_spec_value(db_session=db,
isp_id=vps_profile.isp_id,
os_code=vps_profile.os_code,
plan_code=vps_profile.plan_code,
region_code=vps_profile.region_code)
vps_config = dict(hostname=vps_profile.hostname,
isp_id=vps_profile.isp_id,
ssh_keys=vps_profile.ssh_keys,
remark=vps_profile.remark,
status=vps_profile.status,
**vps_spec_data)
vps_obj = crud_vps.create(db_session=db,
obj_in=vps_config,
serializer=None)
task = celery_app.send_task("create_vps",
args=[vps_profile.dict(), vps_obj.id])
return dict(result=task)
def get_purchasable_domain_data(
domain_profile: PurchasableDomainQuerySchema, ):
task = celery_app.send_task("detect_domain_purchasable",
kwargs=domain_profile.dict())
task_result = task.get()
return dict(result=task_result)
def destroy_redirector(db: Session = Depends(get_db), *, redirector_id: int):
redirector_obj = crud_redirector.get(db_session=db, id=redirector_id)
destroy_task = celery_app.send_task("destroy_vps",
args=[redirector_obj.vps_id])
with allow_join_result():
destroy_task.get()
delete_result = {
'status': crud_redirector.remove(db_session=db, id=redirector_id)
}
return dict(result=delete_result)
def destroy_team_server(db: Session = Depends(get_db), *, team_server_id: int):
# 1. destroy vps
# 2. delete ts and vps
team_server_obj = crud_team_server.get(db_session=db, id=team_server_id)
destroy_task = celery_app.send_task("destroy_vps",
args=[team_server_obj.vps_id])
with allow_join_result():
destroy_task.get()
delete_result = {
'status': crud_team_server.remove(db_session=db, id=team_server_id)
}
return dict(result=delete_result)
def destroy_vps_server(db: Session = Depends(get_db), *, vps_id: int):
# check exists of relation data
relation_data_exists = crud_vps.check_relation_data_exists(
db_session=db,
id=vps_id,
relation_key_list=['team_servers', 'redirector_c2s', 'smtp_servers'])
if relation_data_exists:
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="exists relation data",
)
destroy_task = celery_app.send_task("destroy_vps", args=[vps_id])
with allow_join_result():
destroy_task.get()
destroy_result = {'status': crud_vps.remove(db_session=db, id=vps_id)}
return dict(result=destroy_result)
def purchase_domain(
db: Session = Depends(get_db), *, domain_profile: PurchaseDomainSchema
):
domain_isp = crud_isp.get(
db_session=db,
id=domain_profile.isp_id,
)
if domain_isp and domain_isp.provider_name != domain_profile.provider_name:
raise ValidationError(
[
ErrorWrapper(Exception('provider_name is not matched'),
loc="provider_name")
],
model=PurchaseDomainSchema,
)
purchase_task = celery_app.send_task("purchase_domain",
kwargs=domain_profile.dict())
purchase_result = purchase_task.get()
return dict(result=purchase_result)
def reload_vps_config():
task = celery_app.send_task("reload_vps_isp_config")
return dict(result=task)
def reload_domain_data():
task = celery_app.send_task("reload_domain_dns_record")
task.get()
return dict(result=task)
def verify_domain(domain_profile: VerifyDomainSchema):
task = celery_app.send_task("verify_domain", kwargs=domain_profile.dict())
task_result = task.get()
return dict(result=task_result)
