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())
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())
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 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): 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 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 get_status(self, variable_name): filter_words = [variable_name, '\t', '\n'] sub_cmd = "inception get variables '{}'".format(variable_name) cmd = self.get_cmd(sub_cmd) popen = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) lines = popen.stdout.readlines() if not lines: return None res = lines[-1].decode('gbk') if self.error_tag in res.lower(): return None for word in filter_words: res = res.replace(word, '') return res
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 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): 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 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 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 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): 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)
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())