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)