Beispiel #1
0
    def post(self, request):
        server_id = request.POST.get('server_id', '')
        try:
            server = BkServer.objects.get(id=server_id)
        except Exception:
            logger.exception("服务器信息[id:%s]不存在", server_id)
            return FailJsonResponse("服务器信息不存在,请重新添加")

        if server.is_active:
            return OKJsonResponse("服务器已激活")

        # V1 版本 判断 测试环境/正式环境 分别只能激活一台服务器
        active_server = BkServer.objects.category_has_active_server(
            server.category, server_id)
        if active_server:
            message = "已经有一台{} [IP:{}, 端口:{}] 被激活<br><br>不能再激活其他{}".format(
                active_server.get_category_display(), active_server.ip_address,
                active_server.ip_port, active_server.get_category_display())
            return FailJsonResponse(message)

        ok, message = activate_agent(server_id)
        if not ok:
            return FailJsonResponse("服务器激活失败: {}".format(message))

        return OKJsonResponse("服务器已激活")
Beispiel #2
0
    def post(self, request):
        """添加/编辑第三方服务信息
        """
        form = ExternalServerForm(request.POST)
        if not form.is_valid():
            message = first_error_message(form)
            raise BadRequestException(message)

        server_id = form.cleaned_data["server_id"]
        server_ip = form.cleaned_data["server_ip"]
        server_port = form.cleaned_data["server_port"]
        server_cate = form.cleaned_data["server_cate"]
        username = form.cleaned_data["username"]
        password = form.cleaned_data["password"]

        if ThirdServer.objects.is_server_exists(server_id, server_ip,
                                                server_port):
            message = "IP为[{ip}], 端口为 [{port}] 的服务器已经存在".format(
                ip=server_ip, port=server_port)
            return FailJsonResponse(message)

        try:
            data = ThirdServer.objects.update_or_create_server(
                server_id, server_ip, server_port, username, password,
                server_cate)
            return OKJsonResponse("保存成功", data=data)
        except Exception as e:
            logger.exception("保存服务信息异常:%s", e)
            return FailJsonResponse("保存出错", data={})
Beispiel #3
0
    def post(self, request):
        """添加/编辑AppServer信息
        """
        form = ServerForm(request.POST)
        if not form.is_valid():
            message = first_error_message(form)
            raise BadRequestException(message)

        server_id = form.cleaned_data["server_id"]
        server_ip = form.cleaned_data["server_ip"]
        server_port = form.cleaned_data["server_port"]
        app_port = form.cleaned_data["app_port"]
        server_cate = form.cleaned_data["server_cate"]

        # 验证 ip & port 是否重复
        if BkServer.objects.is_server_exists(server_id, server_ip,
                                             server_port):
            message = "IP为[{ip}], 端口为 [{port}] 的服务器已经存在".format(
                ip=server_ip, port=server_port)
            return FailJsonResponse(message)

        # 编辑信息
        try:
            data = BkServer.objects.update_or_create_server(
                server_id, server_ip, server_port, app_port, server_cate)
            return OKJsonResponse("保存成功", data=data)
        except Exception as e:
            logger.exception("保存应用服务器信息异常:%s", e)
            return FailJsonResponse("保存出错", data={})
Beispiel #4
0
 def delete(self, request, app_code, var_id):
     try:
         AppEnvVar.objects.filter(id=var_id).delete()
     except Exception:
         logger.exception("删除app环境变量失败")
         return FailJsonResponse("删除app环境变量失败")
     return OKJsonResponse("删除成功")
Beispiel #5
0
 def post(self, request, *args, **kwargs):
     app_code = self.kwargs["app_code"]
     username = request.user.username
     ok, message = delete_saas_app(app_code, username)
     if ok:
         return OKJsonResponse(message)
     return FailJsonResponse(message)
Beispiel #6
0
    def post(self, request, *args, **kwargs):
        app_code = self.kwargs["app_code"]
        logger.info("[app:%s] 开始进行[删除]...", app_code)

        username = request.user.username

        app = App.objects.get(code=app_code)
        can_be_deleted, message = app.can_be_deleted(username)
        if not can_be_deleted:
            logger.info("[app:%s] %s", app_code, message)
            return FailJsonResponse(message)

        try:
            SecureInfo.objects.filter(app_code=app_code).delete()
            App.objects.filter(code=app_code).delete()
            # 将APP的发布记录保存为上一次,避免下次创建时显示冲突
            Record.objects.filter(app_code=app_code).update(version='last')
        except Exception:
            message = "删除失败!"
            logger.exception("[app:%s] %s", app_code, message)
            return FailJsonResponse(message)

        # 操作流水日志
        extra_data = {"username": username}
        _r(app_code, username, UserOperateTypeEnum.APP_DELETE.value,
           extra_data)

        message = "删除成功!"
        logger.info("[app:%s] %s", app_code, message)
        return OKJsonResponse(message)
Beispiel #7
0
    def post(self, request):
        server_id = request.POST.get('server_id', '')
        try:
            server = ThirdServer.objects.get(id=server_id)
        except Exception:
            logger.exception("服务信息[id:%s]不存在", server_id)
            return FailJsonResponse("服务信息不存在,请重新添加")

        if server.is_active:
            return FailJsonResponse("服务已激活")

        # V1 版本 判断只能激活一台服务器
        active_server = ThirdServer.objects.category_has_active_server(
            server.category, server_id)
        if active_server:
            message = "已经有一台 {} 服务被激活<br><br>不能再激活其他 {} 服务".format(
                active_server.get_category_display(),
                active_server.get_category_display())
            return FailJsonResponse(message)

        ok, message = activate_service(server.category, server_id)
        if not ok:
            return FailJsonResponse("服务激活失败: {}".format(message))

        return OKJsonResponse("服务已激活")
Beispiel #8
0
    def delete(self, request, server_id):
        """删除第三方服务
        """
        if not server_id:
            raise BadRequestException('请选择要删除的服务')

        try:
            ThirdServer.objects.filter(id=server_id).delete()
        except Exception:
            logger.exception("删除服务[id:%s]失败", server_id)
            return FailJsonResponse("删除服务失败")
        return OKJsonResponse("删除成功")
Beispiel #9
0
    def delete(self, request, server_id):
        """删除AppServer信息
        """
        if not server_id:
            raise BadRequestException("请选择要删除的服务器")

        try:
            BkServer.objects.filter(id=server_id).delete()
        except Exception:
            logger.exception("删除服务器[id:%s]失败", server_id)
            return FailJsonResponse("删除服务器失败")
        return OKJsonResponse("删除成功")
Beispiel #10
0
    def post(self, request):
        bk_token = request.COOKIES.get(settings.BK_COOKIE_NAME, None)
        data = {
            'chname': request.POST.get('chname').strip(),
            'phone': request.POST.get('phone').strip(),
            'email': request.POST.get('email').strip()
        }

        ok, message = modify_user_info(bk_token, data)
        if not ok:
            return FailJsonResponse(message or "个人信息修改失败")
        return OKJsonResponse("success")
Beispiel #11
0
    def post(self, request):
        server_id = request.POST.get('server_id', '')
        try:
            server = ThirdServer.objects.get(id=server_id)
        except Exception:
            logger.exception("服务器信息[id:%s]不存在", server_id)
            return FailJsonResponse("服务器信息不存在,请重新添加")

        ok, message = activate_service(server.category, server_id)
        if not ok:
            return FailJsonResponse("服务刷新失败: {}".format(message))

        return OKJsonResponse("服务刷新成功")
Beispiel #12
0
    def get(self, request, *args, **kwargs):
        app_code = self.kwargs["app_code"]

        app = App.objects.get(code=app_code)

        records = Record.objects.get_last_ongoing_records(app_code, size=10)
        for record in records:
            event_id = record.event_id
            event_ids = [event_id]
            if record.operate_id == OperateIDEnum.IN_OFFLINE.value:
                try:
                    event_ids = json.loads(record.extra_data).get(
                        "event_ids", [])
                except Exception:
                    event_ids = [event_id]

            ok, data = get_event_log(app_code=app_code,
                                     auth_token=app.auth_token,
                                     event_ids=event_ids)
            if not ok:
                continue

            status = data.get("status")
            # 判定操作时间, 超过了, 就判定是超时, 直接失败
            expire_seconds = (datetime.datetime.now() -
                              record.operate_time).total_seconds()
            if (expire_seconds > settings.HISTORY_EVENT_STATE_EXPIRE_SECONDS
                    and status != EventStatusEnum.SUCCESS.value):
                message = "check_unfinished_task, 事件超时({}s), 设置为失败".format(
                    settings.HISTORY_EVENT_STATE_EXPIRE_SECONDS)  # noqa
                logger.info("[app:%s] %s, event_id:%s", app_code, message,
                            event_id)
                record.message = message
                status = EventStatusEnum.FAILURE.value

            if status in (EventStatusEnum.SUCCESS.value,
                          EventStatusEnum.FAILURE.value):
                record.is_success = (status == EventStatusEnum.SUCCESS.value)

                to_operate_id = {
                    OperateIDEnum.IN_TEST.value: OperateIDEnum.TO_TEST.value,
                    OperateIDEnum.IN_ONLINE.value:
                    OperateIDEnum.TO_ONLINE.value,
                    OperateIDEnum.IN_OFFLINE.value:
                    OperateIDEnum.TO_OFFLINE.value
                }.get(record.operate_id, record.operate_id)
                record.operate_id = to_operate_id

                record.save()

        return OKJsonResponse("success")
Beispiel #13
0
    def put(self, request, user_id):
        request_param = QueryDict(request.body)
        form = SetPasswordForm(request_param)

        if not form.is_valid():
            message = first_error_message(form)
            return FailJsonResponse(message)

        # 修改密码
        result, message = BkUser.objects.modify_password_by_userid(
            user_id, form.cleaned_data['new_password1'])
        if not result:
            return FailJsonResponse(message)
        return OKJsonResponse(_("修改密码成功"))
Beispiel #14
0
    def post(self, request):
        form = PasswordChangeForm(request.POST)
        if not form.is_valid():
            message = first_error_message(form)
            raise BadRequestException(message)

        new_password1 = form.cleaned_data.get("new_password1")
        bk_token = request.COOKIES.get(settings.BK_COOKIE_NAME, None)
        data = {'new_password': new_password1}

        ok, message = change_password(bk_token, data)
        if not ok:
            return FailJsonResponse(message or "密码重置失败")
        return OKJsonResponse("success")
Beispiel #15
0
    def _add_or_update(self, request, app_code, var_id=None):
        if not var_id:
            form = AppEnvForm(request.POST)
        else:
            put = QueryDict(request.body)
            form = AppEnvForm(put)

        if not form.is_valid():
            message = first_error_message(form)
            # print form.errors
            raise BadRequestException(message)

        #  app_code = form.cleaned_data["app_code"]
        name = form.cleaned_data["name"]
        value = form.cleaned_data["value"]
        intro = form.cleaned_data["intro"]
        mode = form.cleaned_data["mode"]

        name = 'BKAPP_%s' % name

        # do add
        if not var_id:
            if AppEnvVar.objects.exists(app_code, mode, name):
                message = "变量名已经存在, 请勿重复添加!"
                return FailJsonResponse(message)

            try:
                env_var = AppEnvVar.objects.create(app_code=app_code,
                                                   mode=mode,
                                                   name=name,
                                                   value=value,
                                                   intro=intro)

                var_id = env_var.id
            except Exception:
                # 保存app环境变量异常
                message = "保存app环境变量失败"
                logger.exception(message)
                return FailJsonResponse(message)
        # do update
        else:
            if AppEnvVar.objects.update_target_exists(app_code, mode, name,
                                                      var_id):
                message = "同名变量已经存在! 无法对当前变量进行更新"
                return FailJsonResponse(message)

            AppEnvVar.objects.update(var_id, name, value, intro, mode)

        return OKJsonResponse("保存变量成功", id=var_id)
Beispiel #16
0
    def post(self, request, *args, **kwargs):
        app_code = self.kwargs["app_code"]
        username = request.user.username

        logger.info("[app:%s] 开始进行[正式部署]...", app_code)

        app = App.objects.get(code=app_code)

        try:
            form_data = json.loads(request.POST.get("form_data", '{}'))
        except Exception as e:
            message = "参数错误!"
            logger.exception("[app:%s] %s error=%s", app_code, message, e)
            return BadRequestException(message)

        is_prod_app_deployable = BkServer.objects.check_prod_app_deployable()
        if not is_prod_app_deployable:
            message = "当前没有可用的[正式服务器], 无法进行提测操作. 请到<a href='/engine/server/'> [蓝鲸智云-开发者中心-服务器信息] </a> 注册并激活服务器"
            logger.info("[app:%s] %s", app_code, message)
            return FailJsonResponse(message)

        # 前端变量不要一直向后, 限制
        is_tips = form_data.get("is_tips", 0)
        features = form_data.get("features", "")
        bugs = form_data.get("bugs", "")

        can_be_online, message = app.can_be_online()
        if not can_be_online:
            logger.info("[app:%s] %s", app_code, message)
            return FailJsonResponse(message)

        # 上线操作
        ok, event_id, message = app_to_online_task(app_code, app, username,
                                                   is_tips, features, bugs)

        # 操作流水日志
        extra_data = {"username": username, "form_data": form_data}
        _r(app_code, username, UserOperateTypeEnum.RELEASE_ONLINE.value,
           extra_data)

        if not ok:
            logger.info("[app:%s] %s event_id: %s", app_code, message,
                        event_id)
            return FailJsonResponse(message, event_id=event_id)

        message = "正式部署事件提交成功!"
        logger.info("[app:%s] %s event_id: %s", app_code, message, event_id)
        return OKJsonResponse(message, event_id=event_id)
Beispiel #17
0
    def _add_or_update(self, request, user_id=None):
        request_param = request.POST if user_id is None else QueryDict(
            request.body)
        form = UserInfoForm(request_param)

        if not form.is_valid():
            message = first_error_message(form)
            return FailJsonResponse(message)

        # 创建用户
        result, user_id, message = BkUser.objects.modify_or_create_user_by_userid(
            user_id, form.cleaned_data["username"],
            form.cleaned_data["chname"], form.cleaned_data["phone"],
            form.cleaned_data["email"], form.cleaned_data["role"])

        if not result:
            return FailJsonResponse(message)
        return OKJsonResponse(_("保存用户信息成功"), data={"user_id": user_id})
Beispiel #18
0
    def post(self, request, *args, **kwargs):
        app_code = self.kwargs["app_code"]
        username = request.user.username

        logger.info("[app:%s] 开始进行[下架]...", app_code)

        try:
            form_data = json.loads(request.POST.get("form_data", '{}'))
        except Exception:
            message = "参数错误!"
            logger.exception("[app:%s] %s", app_code, message)
            return BadRequestException(message)

        # NOTE: 下架不加检查服务器, 因为此时已经提测/上线的, 所以默认可以下架成功
        # 获取应用基本信息
        app = App.objects.get(code=app_code)

        # 状态判定
        mode = form_data.get("mode", "all")
        can_be_offline, message = app.can_be_offline(mode)
        if not can_be_offline:
            logger.info("[app:%s] %s", app_code, message)
            return FailJsonResponse(message)

        # 执行下架
        app_old_state = app.state
        auth_token = app.auth_token
        ok, event_id = app_to_offline_task(app_code, auth_token, username,
                                           mode, app_old_state)

        # 操作流水日志
        extra_data = {"username": username, "form_data": form_data}
        _r(app_code, username, UserOperateTypeEnum.RELEASE_OFFLINE.value,
           extra_data)

        if ok:
            message = "下架事件提交成功!"
            logger.info("[app:%s] %s event_id: %s", app_code, message,
                        event_id)
            return OKJsonResponse(message, event_id=event_id)

        message = "下架事件提交失败!"
        logger.info("[app:%s] %s event_id: %s", app_code, message, event_id)
        return FailJsonResponse(message, event_id=event_id)
Beispiel #19
0
    def get(self, request):
        # NOTE: better name is: target_app_codes
        app_codes = request.GET.get('target_app_code')

        query = App.objects.all()
        # 过滤查询的app_codes
        if app_codes:
            app_code_list = app_codes.split(';')

            query = query.filter(code__in=app_code_list)

        # 按照创建时间逆排序
        query = query.values('code', 'name').order_by('-created_date')
        app_list = [{
            'app_code': i['code'],
            'app_name': i['name']
        } for i in query]

        return OKJsonResponse("SUCCESS", data=app_list, code="00")
Beispiel #20
0
    def post(self, request, *args, **kwargs):
        app_code = self.kwargs["app_code"]

        operate = request.POST.get('operate', '')
        if not operate:
            raise BadRequestException("参数异常")

        # 保存基本信息
        try:
            if operate == 'base':
                self._update_base_info(request, app_code)
            elif operate == 'introduction':
                self._update_introduction(request, app_code)
            elif operate == 'vcs':
                self._update_vsc_info(request, app_code)
            elif operate == 'db':
                self._update_db_info(request, app_code)
        except BadRequestException as e:
            raise e
        except Exception as e:
            logger.exception("保存用户基本信息异常:%s", e)
            return FailJsonResponse("编辑失败")

        return OKJsonResponse("编辑成功")
Beispiel #21
0
 def delete(self, request, user_id):
     result, message = BkUser.objects.delete_user(user_id)
     if not result:
         return FailJsonResponse(message)
     return OKJsonResponse(_("用户删除成功"))
Beispiel #22
0
    def post(self, request, *args, **kwargs):
        app_code = self.kwargs["app_code"]
        username = request.user.username

        logger.info("[app:%s] 开始进行[测试部署]...", app_code)

        app = App.objects.get(code=app_code)

        # 检测测试服务器是否激活
        is_test_app_deployable = BkServer.objects.check_test_app_deployable()
        if not is_test_app_deployable:
            message = "当前没有可用的[测试服务器], 无法进行提测操作. 请到<a href='/engine/server/'> [蓝鲸智云-开发者中心-服务器信息] </a> 注册并激活服务器"
            logger.info("[app:%s] %s", app_code, message)
            return FailJsonResponse(message)

        # 只有[下架/开发/测试/上线]状态可操作
        can_be_test, message = app.can_be_test()
        if not can_be_test:
            logger.info("[app:%s] %s", app_code, message)
            return FailJsonResponse(message)

        # 启用服务
        form_data = request.POST.get("form_data", None)
        if form_data:
            try:
                form_data = json.loads(request.POST.get("form_data"))
            except Exception as e:
                message = "参数错误!"
                logger.exception("[app:%s] %s error=%s", app_code, message,
                                 str(e))
                return BadRequestException(message)

            is_use_celery = (form_data.get("is_use_celery") == "checked")
            is_use_celery_beat = (
                form_data.get("is_use_celery_beat") == "checked")

            try:
                app.trigger_celery(is_use_celery, is_use_celery_beat)
                logger.info(
                    "update app info [is_use_celery=%s, is_use_celery_beat=%s]",
                    app.is_use_celery, app.is_use_celery_beat)
            except Exception:
                logger.exception(
                    "Update is_use_celery/is_use_celery_beat fail!")

        # 提测
        ok, event_id, message = app_to_test_task(app_code, app, username)

        # 记录操作流水日志
        extra_data = {
            "username": username,
            "is_success": ok,
            "event_id": event_id
        }
        _r(app_code, username, UserOperateTypeEnum.RELEASE_TEST.value,
           extra_data)

        if ok:
            message = "测试部署事件提交成功!"
            logger.info("[app:%s] %s event_id: %s", app_code, message,
                        event_id)
            return OKJsonResponse(message, event_id=event_id)

        logger.info("[app:%s] %s event_id: %s", app_code, message, event_id)
        return FailJsonResponse(message, event_id=event_id)
Beispiel #23
0
 def post(self, request):
     username = request.user.username
     apps = request.POST.get('apps')
     if apps:
         UserSettings.objects.filter(username=username).update(apps=apps)
     return OKJsonResponse("排序成功")