def create_user(username,
password,
name=None,
phone=None,
email=None,
operator=None):
'''
创建用户
'''
user_obj = UserModel.objects.filter(username=username).first()
if user_obj:
raise errors.CommonError('用户已存在')
data = {
'username': username,
'name': name,
'phone': phone,
'email': email,
}
with transaction.atomic():
user_obj = base_ctl.create_obj(UserModel, data, operator)
if not password:
password = '******'
user_obj.set_password(password)
data = user_obj.to_dict()
return data
def sync_slb_backend_servers():
'''
同步SLB默认服务器组服务器
'''
with transaction.atomic():
slb_objs = SlbModel.objects.all()
query = {
'server_group__typ': SlbServerGroupModel.TYP_DEFAULT,
}
old_ids = SlbServerGroupEcsModel.objects.filter(**query).values_list(
'id', flat=True).all()
old_ids = list(set(old_ids))
existed_ids = []
ecs_list = []
key, secret = aliyun_key_ctl.get_enabled_aliyun_key()
ali_cli = AliyunSLB(key, secret, 'cn-beijing')
for slb_obj in slb_objs:
group_obj = SlbServerGroupModel.objects.filter(slb_id=slb_obj.id)\
.filter(typ=SlbServerGroupModel.TYP_DEFAULT).first()
if not group_obj:
data = {
'slb_id': slb_obj.id,
'name': 'default',
'instance_id': 'default',
'typ': SlbServerGroupModel.TYP_DEFAULT,
}
group_obj = base_ctl.create_obj(SlbServerGroupModel, data)
ali_cli.reset_region(slb_obj.region_id)
ecses = ali_cli.get_slb_info(
slb_obj.instance_id).get('backend_servers')
for ecs in ecses:
ecs_instance_id = ecs.get('ServerId')
ecs_obj = EcsModel.objects.filter(
instance_id=ecs_instance_id).first()
weight = ecs.get('Weight')
obj = SlbServerGroupEcsModel.objects.filter(slb_id=slb_obj.id)\
.filter(server_group_id=group_obj.id, ecs_id=ecs_obj.id).first()
data = {
'slb_id': slb_obj.id,
'server_group_id': group_obj.id,
'ecs_id': ecs_obj.id,
'weight': weight,
}
if not obj:
ecs_list.append(data)
else:
base_ctl.update_obj(SlbServerGroupEcsModel, obj.id, data)
existed_ids.append(obj.id)
base_ctl.create_objs(SlbServerGroupEcsModel, ecs_list)
deleted_ids = list(set(set(old_ids) - set(existed_ids)))
if deleted_ids:
base_ctl.delete_objs(SlbServerGroupEcsModel, deleted_ids)
sync_slb_vserver_groups()
def create_berry(name,
typ,
time_mode=BerryModel.TIME_MODE_NOW,
dt_start=None,
input_params={},
operator=None):
'''
创建任务
params: dict
'''
query = {
'sign': typ,
}
typ_obj = BerryTypeModel.objects.filter(**query).first()
if not typ_obj:
raise errors.CommonError('任务类型不存在')
if not BerryModel.check_choices('time_mode', time_mode):
raise errors.CommonError('时间模式值不正确')
now = time_utils.now()
countdown = 0
if time_mode == BerryModel.TIME_MODE_CRONTAB:
if not dt_start:
raise errors.CommonError('定时任务必须传开始时间')
if dt_start <= now:
raise errors.CommonError('不能指定过去的时间')
countdown = dt_start - now
countdown = int(countdown.total_seconds())
if countdown < 5 * 60:
raise errors.CommonError('定时任务必须指定五分钟以后的时间')
else:
dt_start = time_utils.now()
user_id = None
if operator:
user_id = operator.id
data = {
'name': name,
'typ_id': typ_obj.id,
'time_mode': time_mode,
'dt_start': dt_start,
'input_params': json.dumps(input_params),
'user_id': user_id,
}
berry_obj = base_ctl.create_obj(BerryModel, data)
result = berry_tasks.apply_task.apply_async(countdown=countdown,
args=[berry_obj.id])
data = {
'task_id': result.task_id,
}
base_ctl.update_obj(BerryModel, berry_obj.id, data)
def create_aliyun_key(key, secret, operator):
'''
创建阿里云key
'''
if AliyunKeyModel.objects.filter(key=key).exists():
raise errors.CommonError('此Key已经存在')
data = {
'key': key,
'secret': secret,
}
obj = base_ctl.create_obj(AliyunKeyModel, data, operator)
data = obj.to_dict()
return data
def create_service_department(obj_id, department_id, operator=None):
'''
创建服务关联部门
'''
query = {
'service_id': obj_id,
'department_id': department_id,
}
if DepartmentServiceModel.objects.filter(**query).exists():
raise errors.CommonError('服务已关联此部门')
data = query
obj = base_ctl.create_obj(DepartmentServiceModel, data, operator)
data = obj.to_dict()
return data
def create_service_environment(obj_id, environment_id, operator=None):
'''
创建服务关联环境
'''
query = {
'service_id': obj_id,
'environment_id': environment_id,
}
if ServiceEnvironmentModel.objects.filter(**query).exists():
raise errors.CommonError('服务已关联此环境')
data = query
obj = base_ctl.create_obj(ServiceEnvironmentModel, data, operator)
data = obj.to_dict()
return data
def create_role_user(role_id, user_id, operator=None):
'''
创建角色关联用户
'''
query = {
'user_id': user_id,
'role_id': role_id,
}
if RoleUserModel.objects.filter(**query).exists():
raise errors.CommonError('用户已关联此角色')
data = query
obj = base_ctl.create_obj(RoleUserModel, data, operator)
data = obj.to_dict()
return data
def create_role_mod(role_id, mod_id, operator=None):
'''
创建角色关联模块
'''
query = {
'role_id': role_id,
'mod_id': mod_id,
}
if RoleModModel.objects.filter(**query).exists():
raise errors.CommonError('角色已关联此模块')
data = query
obj = base_ctl.create_obj(RoleModModel, data, operator)
data = obj.to_dict()
return data
def create_role_permission(role_id, permission_id, operator=None):
'''
创建角色关联权限
'''
query = {
'role_id': role_id,
'permission_id': permission_id,
}
if RolePermissionModel.objects.filter(**query).exists():
raise errors.CommonError('角色已关联此权限')
data = query
with transaction.atomic():
obj = base_ctl.create_obj(RolePermissionModel, data, operator)
mod_id = obj.permission.mod_id
if not RoleModModel.objects.filter(role_id=role_id,
mod_id=mod_id).exists():
data = {
'role_id': role_id,
'mod_id': mod_id,
}
base_ctl.create_obj(RoleModModel, data)
data = obj.to_dict()
return data
def create_service_asset(obj_id, asset_id, operator=None):
'''
创建服务关联资产模块
'''
query = {
'service_id': obj_id,
'asset_id': asset_id,
}
if ServiceAssetModel.objects.filter(**query).exists():
raise errors.CommonError('服务已关联此资产模块')
data = query
obj = base_ctl.create_obj(ServiceAssetModel, data, operator)
data = obj.to_dict()
return data
def create_department(name, sign, operator=None):
'''
创建部门
'''
if DepartmentModel.objects.filter(name=name).exists():
raise errors.CommonError('部门名称已存在')
if DepartmentModel.objects.filter(sign=sign).exists():
raise errors.CommonError('部门标识已存在')
data = {
'name': name,
'sign': sign,
}
obj = base_ctl.create_obj(DepartmentModel, data, operator)
data = obj.to_dict()
return data
def create_frame(name, sign, language_id, operator=None):
'''
创建框架
'''
if FrameModel.objects.filter(name=name).exists():
raise errors.CommonError('框架名称已存在')
if FrameModel.objects.filter(sign=sign).exists():
raise errors.CommonError('框架标识已存在')
data = {
'name': name,
'sign': sign,
'language_id': language_id,
}
obj = base_ctl.create_obj(FrameModel, data, operator)
data = obj.to_dict()
return data
def create_mod(name, sign, rank, operator=None):
'''
创建模块
'''
if ModModel.objects.filter(name=name).exists():
raise errors.CommonError('名称已存在')
if ModModel.objects.filter(sign=sign).exists():
raise errors.CommonError('标识已存在')
data = {
'name': name,
'sign': sign,
'rank': rank,
}
obj = base_ctl.create_obj(ModModel, data, operator)
data = obj.to_dict()
return data
def create_role(name, sign, operator=None):
'''
创建角色
'''
obj = RoleModel.objects.filter(name=name).first()
if obj:
raise errors.CommonError('角色已存在')
obj = RoleModel.objects.filter(sign=sign).first()
if obj:
raise errors.CommonError('标识已存在')
data = {
'name': name,
'sign': sign,
}
obj = base_ctl.create_obj(RoleModel, data, operator)
data = obj.to_dict()
return data
def create_asset(name, sign, rank, remark='', operator=None):
'''
创建资产模块
'''
if AssetModel.objects.filter(name=name).exists():
raise errors.CommonError('资产模块名称已经存在')
if AssetModel.objects.filter(sign=sign).exists():
raise errors.CommonError('资产模块标识已经存在')
data = {
'name': name,
'sign': sign,
'rank': rank,
'remark': remark,
}
obj = base_ctl.create_obj(AssetModel, data, operator)
data = obj.to_dict()
return data
def create_environment(name, sign, rank=0, remark='', operator=None):
'''
创建环境
'''
if EnvironmentModel.objects.filter(name=name).exists():
raise errors.CommonError('环境名称已存在')
if EnvironmentModel.objects.filter(sign=sign).exists():
raise errors.CommonError('环境标识已存在')
data = {
'name': name,
'sign': sign,
'rank': rank,
'remark': remark,
}
obj = base_ctl.create_obj(EnvironmentModel, data, operator)
data = obj.to_dict()
return data
def create_service(name, sign, project_id, remark=None, operator=None):
'''
创建服务
'''
if ServiceModel.objects.filter(name=name).exists():
raise errors.CommonError('服务名称已存在')
if ServiceModel.objects.filter(sign=sign).exists():
raise errors.CommonError('服务标识已存在')
data = {
'name': name,
'sign': sign,
'project_id': project_id,
'remark': remark,
}
obj = base_ctl.create_obj(ServiceModel, data, operator)
data = obj.to_dict()
return data
def update_ldap_config(host, admin_dn, admin_password, member_base_dn, operator=None):
'''
编辑服务配置
'''
# TODO: 这里应该增加校验ldap参数对不对的逻辑，但是我有点不会
obj = LdapConfigModel.objects.first()
data = {
'host': host,
'admin_dn': admin_dn,
'admin_password': admin_password,
'member_base_dn': member_base_dn,
}
if obj:
obj = base_ctl.update_obj(LdapConfigModel, obj.id, data, operator)
else:
obj = base_ctl.create_obj(LdapConfigModel, data, operator)
data = obj.to_dict()
return data
def create_gitlab_server(name, host, username, password, token, operator=None):
'''
创建Gitlab服务
'''
if GitlabServerModel.objects.filter(name=name).exists():
raise errors.CommonError('Gitlab已经存在')
if GitlabServerModel.objects.filter(host=host).exists():
raise errors.CommonError('Gitlab已经存在')
data = {
'name': name,
'host': host,
'username': username,
'password': password,
'token': token,
}
obj = base_ctl.create_obj(GitlabServerModel, data, operator)
data = obj.to_dict()
return data
def create_service_user(obj_id, user_id, typ, operator=None):
'''
创建服务关联用户
'''
query = {
'service_id': obj_id,
'user_id': user_id,
}
if ServiceUserModel.objects.filter(**query).exists():
raise errors.CommonError('用户已在此服务中')
if not ServiceUserModel.check_choices('typ', typ):
raise errors.CommonError('类型值不正确')
data = {
'service_id': obj_id,
'user_id': user_id,
'typ': typ,
}
obj = base_ctl.create_obj(ServiceUserModel, data, operator)
data = obj.to_dict()
return data
def create_department_user(department_id, user_id, typ, operator=None):
'''
创建部门关联用户
'''
query = {
'user_id': user_id,
'department_id': department_id,
}
if DepartmentUserModel.objects.filter(**query).exists():
raise errors.CommonError('用户已在此部门中')
if not DepartmentUserModel.check_choices('typ', typ):
raise errors.CommonError('类型值不正确')
data = {
'user_id': user_id,
'department_id': department_id,
'typ': typ,
}
obj = base_ctl.create_obj(DepartmentUserModel, data, operator)
data = obj.to_dict()
return data
def create_asset(name, password, remark, operator):
'''
创建资产
'''
query = {
'user_id': operator.id,
'name': name,
}
obj = AssetModel.objects.filter(**query).first()
if obj:
raise errors.CommonError('资产已存在')
data = {
'user_id': operator.id,
'name': name,
'password': password,
'remark': remark,
}
obj = base_ctl.create_obj(AssetModel, data, operator)
data = obj.to_dict()
return data
def create_berry_type(name, sign, parent_id, operator=None):
'''
创建任务类型
'''
query = {
'name': name,
}
if BerryTypeModel.objects.filter(**query).exists():
raise errors.CommonError('任务类型名称已经存在')
query = {
'sign': sign,
}
if BerryTypeModel.objects.filter(**query).exists():
raise errors.CommonError('任务类型标识已经存在')
data = {
'name': name,
'sign': sign,
'parent_id': parent_id,
}
obj = base_ctl.create_obj(BerryTypeModel, data, operator)
data = obj.to_dict()
return data
def create_permission(mod_id, name, sign, typ, rank, operator=None):
'''
创建权限
'''
obj = PermissionModel.objects.filter(name=name).first()
if obj:
raise errors.CommonError('权限已存在')
obj = PermissionModel.objects.filter(sign=sign).first()
if obj:
raise errors.CommonError('标识已存在')
if not PermissionModel.check_choices('typ', typ):
raise errors.CommonError('类型值不正确')
data = {
'mod_id': mod_id,
'name': name,
'sign': sign,
'typ': typ,
'rank': rank,
}
obj = base_ctl.create_obj(PermissionModel, data, operator)
data = obj.to_dict()
return data
def create_service_asset_obj(obj_id,
environment_id,
typ,
asset_obj_id,
operator=None):
'''
创建服务关联资产实例
'''
# 零：判断typ值
if not ServiceAssetObjModel.check_choices('typ', typ):
raise errors.CommonError('资产实例类型值不正确')
# 一：判断服务是否关联对应资产模块
query = {
'service_id': obj_id,
'asset__sign': typ,
}
if not ServiceAssetModel.objects.filter(**query).exists():
raise errors.CommonError('服务需要先关联此资产模块')
# 二：判断资产实例是否存在
if not is_existed_asset_obj(typ, asset_obj_id):
raise errors.CommonError('资产实例不存在')
# 三：判断是否已经关联此资产实例
query = {
'service_id': obj_id,
'environment_id': environment_id,
'typ': typ,
'asset_obj_id': asset_obj_id,
'status': ServiceAssetObjModel.ST_PENDING_ADD,
}
if ServiceAssetObjModel.objects.filter(**query).exists():
raise errors.CommonError('服务已关联此资产实例')
# 四：建立关联关系
data = query
obj = base_ctl.create_obj(ServiceAssetObjModel, data, operator)
#TODO 五：调用异步任务完成添加的具体操作
data = obj.to_dict()
return data
def update_service_config(obj_id,
environment_id,
port,
dns_typ,
artifact_typ,
deploy_typ,
operator=None):
'''
编辑服务配置
'''
# TODO: 有关端口号的验证
if not ServiceConfigModel.check_choices('dns_typ', dns_typ):
raise errors.CommonError('解析类型不正确')
if not ServiceConfigModel.check_choices('artifact_typ', artifact_typ):
raise errors.CommonError('制品类型不正确')
if not ServiceConfigModel.check_choices('deploy_typ', deploy_typ):
raise errors.CommonError('部署类型不正确')
query = {
'service_id': obj_id,
'environment_id': environment_id,
}
obj = ServiceConfigModel.objects.filter(**query).first()
data = {
'service_id': obj_id,
'environment_id': environment_id,
'port': port,
'dns_typ': dns_typ,
'artifact_typ': artifact_typ,
'deploy_typ': deploy_typ,
}
if obj:
obj = base_ctl.update_obj(ServiceConfigModel, obj.id, data, operator)
else:
obj = base_ctl.create_obj(ServiceConfigModel, data, operator)
data = obj.to_dict()
return data
