def create(self, request, *args, **kwargs):
ret = res.get_ret()
new_pass = self.check_password(request.data)
instance = request.user
instance.set_password(new_pass)
instance.save()
return Response(ret)
def rollback(self, request, *args, **kwargs):
ret = res.get_ret()
instance = self.get_object()
self.filter_select_type(instance)
self.check_rollbackable(instance)
dbobj = instance.db
rollback_opid_list = instance.rollback_opid
rollback_db = instance.rollback_db
back_sqls = ''
for opid in eval(rollback_opid_list):
back_source = 'select tablename from $_$Inception_backup_information$_$ where opid_time = "{}" '.format(opid)
back_table = Inception(back_source, rollback_db).get_back_table()
statement_sql = 'select rollback_statement from {} where opid_time = "{}" '.format(back_table, opid)
rollback_statement = Inception(statement_sql, rollback_db).get_back_sql()
if not rollback_statement:
raise ParseError(self.get_rollback_fail)
back_sqls += rollback_statement
db_addr = self.get_db_addr(dbobj.user, dbobj.password, dbobj.host, dbobj.port, self.action_type_execute)
execute_results = Inception(back_sqls, dbobj.name).inception_handle(db_addr).get('result')
success_num = 0
for result in execute_results:
if result[4] == 'None':
success_num += 1
if success_num != len(execute_results):
ret['status'] = -1
status = -4
roll_affected_rows = None
else:
status = -3
roll_affected_rows = ret['data']['affected_rows'] = len(execute_results) - 1
instance.status = status
instance.handle_result_rollback = json.dumps(execute_results)
instance.roll_affected_rows = roll_affected_rows
self.replace_remark(instance)
return Response(ret)
def create(self, request, *args, **kwargs):
request_data = request.data
self.check_db(request_data)
request_data['group'] = self.check_user_group(request)
request_data['treater'] = request_data.pop('treater_username')
request_data['is_manual_review'] = self.get_strategy_is_manual_review(
request_data.get('env'))
sql_content = request_data.get('sql_content')
select = re.search(self.type_select_tag, sql_content, re.IGNORECASE)
self.check_forbidden_words(sql_content)
if bool(select):
handle_result_check = None
request_data['type'] = self.type_select_tag
else:
handle_result_check = self.check_execute_sql(
request_data.get('db'), sql_content,
self.action_type_check)[-1]
workorder_serializer = self.serializer_order(data={})
workorder_serializer.is_valid()
workorder_instance = workorder_serializer.save()
request_data['handle_result_check'] = handle_result_check
request_data['workorder'] = workorder_instance.id
serializer = self.serializer_class(data=request_data)
serializer.is_valid(raise_exception=True)
instance = serializer.save()
self.create_step(instance, request_data['users'])
self.mail(instance, self.action_type_check)
return Response(res.get_ret())
def get_db_list(self, request):
ret = res.get_ret()
target_databases = self.get_target_databases(request)
alive_databases = self.get_alive_databases()
databases = set(target_databases) - set(alive_databases)
ret['data'] = databases
return ret
def reject(self, request, *args, **kwargs):
instance = self.get_object()
instance.status = 1
self.replace_remark(instance)
role_step = self.get_reject_step(instance)
self.handle_approve(3,3,role_step)
return Response(res.get_ret())
def create(self, request, *args, **kwargs):
# save user
user = request.user
user_serializer = self.serializer_class(user, data=request.data)
user_serializer.is_valid()
user_serializer.save()
# save dbconf
cluster, dbs, env = self.check_data(request.data)
if cluster and dbs:
# check permission
group = user.groups.first()
permission_user = self.get_permission_objects(
user.userobjectpermission_set.all())
permission_group = self.get_permission_objects(
group.groupobjectpermission_set.all()) if group else []
permission_user.extend(permission_group)
permission_db_list = list(set(permission_user))
no_permission = [
DbConf.objects.get(pk=pk).name for pk in dbs
if pk not in permission_db_list
]
if no_permission:
raise ParseError(self.permission_warning.format(no_permission))
alter_qs = user.dbconf_set.filter(cluster=cluster, env=env)
for obj in alter_qs:
user.dbconf_set.remove(obj)
for db_id in dbs:
user.dbconf_set.add(db_id)
return Response(res.get_ret())
class DbViewSet(PermissionDatabases, GuardianPermission, BulkCreateModelMixin, BaseView):
'''
目标数据库CURD
'''
serializer_class = DbSerializer
permission_classes = [IsSuperUser]
search_fields = ['name','host','port','user','remark']
ret = res.get_ret()
def perform_destroy(self, instance):
self.delete_relation(instance)
instance.delete()
def get_queryset(self):
user = self.request.user
queryset = DbConf.objects.all()
env = self.request.GET.get('env')
if env:
queryset = queryset.filter(env=env)
if user.is_superuser:
return queryset
return self.filter_databases(queryset)
@detail_route(methods=['post'], permission_classes=[])
def sql_advisor(self, request, *args, **kwargs):
instance = self.get_object()
sql = request.data.get('sql')
res = SqlQuery(instance).sql_advisor(sql)
self.ret['results'] = res
return Response(self.ret)
@detail_route(methods=['post'], permission_classes=[])
def sql_soar(self, request, *args, **kwargs):
instance = self.get_object()
sql = request.data.get('sql')
soar_type = request.data.get('soar_type')
res = SqlQuery(instance).sql_soar(sql, soar_type)
self.ret['results'] = res
return Response(self.ret)
@detail_route()
def tables(self, request, *args, **kwargs):
instance = self.get_object()
tables = SqlQuery(instance).get_tables()
self.ret['results'] = tables
return Response(self.ret)
@detail_route()
def table_info(self, request, *args, **kwargs):
instance = self.get_object()
table_name = request.GET.get('table_name')
table_info = SqlQuery(instance).get_table_info(table_name)
self.ret['results'] = table_info
return Response(self.ret)
@detail_route()
def relate_permission(self, request, *args, **kwargs):
instance = self.get_object()
self.ret['results'] = self.get_related_status(instance)
return Response(self.ret)
def inception_backup(self, request):
self.conf.read(self.file_path)
password = self.conf.get('inception', 'inception_remote_system_password')
params = request.data
params['password'] = password
params['db'] = 'inception'
self.conn_database(params)
return res.get_ret()
def list(self, request, *args, **kwargs):
ret = res.get_ret()
ret['data']['user_info'] = self.get_user_info
ret['data']['count_data'] = self.get_count_data
ret['data']['sql_status_data'] = self.get_status_data
ret['data']['sql_trend_data'] = self.get_trend_data
ret['data']['sql_today_data'] = self.get_today_data
ret['data']['sql_type_data'] = self.get_type_data
return Response(ret)
def get_db_list(self, request):
ret = res.get_ret()
cluster = request.data.pop('cluster')
env = request.data.pop('env')
target_databases = self.get_target_databases(request)
alive_databases = self.get_alive_databases(cluster, env)
databases = set(target_databases) - set(alive_databases)
ret['data'] = databases
return ret
def inception_conn(self, *args):
ret = res.get_ret()
sub_cmd = "inception get variables"
cmd = self.get_cmd(sub_cmd)
result = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
lines = result.stdout.readlines()
last_item = lines[-1].decode('gbk') if len(lines) > 0 else ''
if self.error_tag in last_item.lower():
ret['status'] = -1
ret['data'] = last_item
return ret
def create(self, request, *args, **kwargs):
cluster, dbs, env = self.check_data(request.data)
user = request.user
user_serializer = self.serializer_class(user, data=request.data)
user_serializer.is_valid()
user_serializer.save()
alter_qs = user.dbconf_set.filter(cluster=cluster, env=env)
for obj in alter_qs:
user.dbconf_set.remove(obj)
for db_id in dbs:
user.dbconf_set.add(db_id)
return Response(res.get_ret())
def update_target_db(self, request):
pk = request.data.get('id')
instance = DbConf.objects.get(pk=pk)
params = {
'db': instance.name,
'host': instance.host,
'port': instance.port,
'user': instance.user,
'password': prpcrypt.decrypt(instance.password)
}
self.conn_database(params)
return res.get_ret()
def create(self, request, *args, **kwargs):
env = request.data.get('env')
cluster = request.data.get('cluster') or None
qs = self.queryset.filter(env=env, cluster_id=cluster)
ret = res.get_ret()
ret['data']['dbs'] = self.serializer_class(qs, many=True).data
userobj = request.user
user_data = self.serializer_user(userobj).data
ret['data']['commiter'] = user_data
if userobj.is_superuser or env == self.env_test or userobj.role != self.dev:
treaters = [user_data]
else:
group = userobj.groups.first()
treaters = self.serializer_user(group.user_set.filter(role=self.dev_mng), many=True).data if group else []
ret['data']['treaters'] = treaters
return Response(ret)
class DbViewSet(BaseView):
'''
目标数据库的CURD
'''
serializer_class = DbSerializer
#permission_classes = [IsSuperUser]
search_fields = ['name', 'host', 'port', 'user', 'remark']
ret = res.get_ret()
def get_queryset(self):
env = self.request.GET.get('env')
queryset = Dbconf.objects.all()
if env:
queryset = queryset.filter(env=env)
return queryset
@detail_route(methods=['post'])
def sql_advisor(self, request, *args, **kwargs):
instance = self.get_object()
sql = request.data.get('sql')
res = SqlQuery(instance).sql_advisor(sql)
self.ret['results'] = res
return Response(self.ret)
@detail_route(methods=['post'])
def sql_soar(self, request, *args, **kwargs):
instance = self.get_object()
sql = request.data.get('sql')
soar_type = request.data.get('soar_type')
res = SqlQuery(instance).sql_soar(sql, soar_type)
self.ret['results'] = res
return Response(self.ret)
@detail_route()
def tables(self, request, *args, **kwargs):
instance = self.get_object()
tables = SqlQuery(instance).get_tables()
self.ret['results'] = tables
return Response(self.ret)
@detail_route()
def table_info(self, request, *args, **kwargs):
instance = self.get_object()
table_name = request.GET.get('table_name')
table_info = SqlQuery(instance).get_table_info(table_name)
self.ret['results'] = table_info
return Response(self.ret)
def create(self, request, *args, **kwargs):
# save user
request_data = request.data
instance = request.user
user_serializer = self.serializer_class(
instance, data={'leader': request_data.get('leader')})
user_serializer.is_valid()
user_serializer.save()
cluster = request_data.get('cluster')
dbs = request_data.get('dbs')
env = request_data.get('env')
alter_qs = instance.dbconf_set.filter(cluster=cluster, env=env)
for obj in alter_qs:
instance.dbconf_set.remove(obj)
for db_id in dbs:
instance.dbconf_set.add(db_id)
return Response(res.get_ret())
def create(self, request, *args, **kwargs):
# save user
request_data = request.data
cluster, dbs, env = self.check_data(request_data)
user = request.user
data = {
'leader': request_data.get('leader'),
'admin_mail': request_data.get('admin_mail')
}
user_serializer = self.serializer_class(user, data=data)
user_serializer.is_valid()
user_serializer.save()
alter_qs = user.dbconf_set.filter(cluster=cluster, env=env)
for obj in alter_qs:
user.dbconf_set.remove(obj)
for db_id in dbs:
user.dbconf_set.add(db_id)
return Response(res.get_ret())
def execute(self, request, *args, **kwargs):
ret = res.get_ret()
instance = self.get_object()
if instance.status != -1:
ret = {'status': -2, 'msg': self.executed}
return Response(ret)
affected_rows = 0
instance.status = 0
if instance.type == self.type_select_tag:
sql_query = SqlQuery(instance.db)
data = sql_query.main(instance.sql_content)
affected_rows = len(data)
instance.handle_result_execute = json.dumps(
[list(row) for row in data], cls=DateEncoder)
else:
execute_time = 0
opids = []
rollback_able = False
success_sqls, exception_sqls, handle_result_execute = self.check_execute_sql(
instance.db.id, instance.sql_content, self.action_type_execute)
for success_sql in success_sqls:
instance.rollback_db = success_sql[8]
affected_rows += success_sql[6]
execute_time += float(success_sql[9])
if re.findall(self.success_tag, success_sql[3]):
rollback_able = True
opids.append(success_sql[7].replace("'", ""))
if exception_sqls:
instance.status = 2
instance.execute_errors = exception_sqls
ret['status'] = -1
instance.rollback_opid = opids
instance.rollback_able = rollback_able
instance.handle_result_execute = handle_result_execute
ret['data']['execute_time'] = '%.3f' % execute_time
instance.exe_affected_rows = affected_rows
ret['data']['affected_rows'] = affected_rows
self.replace_remark(instance)
self.handle_approve(2, 1, 2)
self.mail(instance, self.action_type_execute)
return Response(ret)
def create(self, request, *args, **kwargs):
ret = res.get_ret()
env = request.data.get('env')
cluster = request.data.get('cluster') or None
qs_db = self.queryset.filter(env=env, cluster_id=cluster)
qs_admin = self.serializer_user.Meta.model.objects.filter(
is_superuser=True)
ret['data']['dbs'] = self.serializer_class(qs_db, many=True).data
ret['data']['admins'] = self.serializer_user(qs_admin, many=True).data
user_instance = request.user
user_data = self.serializer_user(user_instance).data
ret['data']['commiter'] = user_data
if user_instance.is_superuser or env == self.env_test or user_instance.role != self.dev:
treaters = [user_data]
else:
group = user_instance.groups.first()
treaters = self.serializer_user(group.user_set.filter(
role=self.dev_mng),
many=True).data if group else []
ret['data']['treaters'] = treaters
return Response(ret)
def check(self, request):
ret = res.get_ret()
request_data = request.data
check_type = request_data.get('check_type')
if check_type == 'inception_conn':
sub_cmd = "inception get variables"
cmd = self.get_cmd(sub_cmd)
else:
params = {}
if check_type == 'inception_backup':
self.conf.read(self.file_path)
password = self.conf.get('inception',
'inception_remote_system_password')
params = request_data
params['password'] = password
params['db'] = 'inception'
elif check_type == 'update_target_db':
db_id = request_data.get('id')
instance = Dbconf.objects.get(id=db_id)
params = {
'db': instance.name,
'host': instance.host,
'port': instance.port,
'user': instance.user,
'password': prpcrypt.decrypt(instance.password)
}
elif check_type == 'create_target_db':
params = request_data
cmd = self.get_mysql_conn(params)
popen = subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
lines = popen.stdout.readlines()
last_item = lines[-1].decode('gbk') if len(lines) > 0 else ''
if self.error_tag in last_item.lower():
ret['status'] = -1
ret['data'] = last_item
return ret
def handle_get_databases(self, request):
ret = res.get_ret()
databases = self.get_databases(request.data)
ret['data'] = [item[0] for item in databases]
return ret
def disapprove(self, request, *args, **kwargs):
self.handle_approve(1,2,1)
return Response(res.get_ret())
def disapprove(self, request, *args, **kwargs):
self.handle_approve(1, 2, 1)
self.mail(self.get_object(), self.disapprove.__name__)
return Response(res.get_ret())
def create(self, request, *args, **kwargs):
model = self.serializer_class.Meta.model
model.objects.all().update(value=False)
model.objects.filter(name__in=request.data).update(value=True)
return Response(res.get_ret())
def create(self, request, *args, **kwargs):
self.set_variable(request)
return Response(res.get_ret())
def get(self, request, *args, **kwargs):
ret = res.get_ret()
ret['data'] = self.get_inception_backup()
return Response(ret)
