Пример #1
0
def swan_push(request):
    """

    :param requests:
    :return:
    """
    sls = request.GET.get("sls")
    if request.method == 'POST':
        test = request.POST
        t = test.getlist("node_name")
        pull_list = []
        for i in t:
            t_data = Host.objects.get(node_name=i)
            pull_list.append({"ip": t_data.eth1, "fqdn": t_data.node_name})
        s = swan_push_api(sls)
        if s["status"] == 200:
            return render_to_response('swan/push.html',
                                      locals(),
                                      context_instance=RequestContext(request))

    return HttpResponse(
        json.dumps({
            "status": "403",
            "message": "Authentication failed"
        },
                   ensure_ascii=False,
                   indent=4))
Пример #2
0
def swan_push(request):
    """

    :param requests:
    :return:
    """
    sls = request.GET.get("sls")
    if request.method == 'POST':
        test = request.POST
        t = test.getlist("node_name")
        pull_list = []
        for i in t:
            t_data = Host.objects.get(node_name=i)
            pull_list.append({"ip": t_data.eth1, "fqdn": t_data.node_name})
        s = swan_push_api(sls)
        if s["status"] == 200:
            return render_to_response('swan/push.html', locals(), context_instance=RequestContext(request))

    return HttpResponse(json.dumps({"status": "403", "message": "Authentication failed"}, ensure_ascii=False, indent=4))
Пример #3
0
def swan_release(request):
    if request.method == 'POST':
        uid = str(uuid.uuid4())
        rst = request.POST
        # print rst
        project_name = rst.get("project_name", False)
        project_all_tag = rst.get("project_all_tag", False)
        tgt = rst.get("tgt", False)
        arg = rst.get("arg", False)
        log = rst.get("update_log", None)
        # print update_log
        business_id = Project.objects.get(uuid=project_name)
        server_list = {}
        ip_list = []
        node_list = business_id.host_set.all()
        # 根据项目名反查主机
        if len(rst.getlist("node_name")) == 0:
            return render_to_response('swan/swan_error.html', locals(), context_instance=RequestContext(request))
        else:
            for i in rst.getlist("node_name"):
                s = node_list.get(eth1=i)
                server_list[s.eth1] = s.node_name
                ip_list.append(s.eth1)
        # if arg:
        #     return render_to_response('swan/swan_error.html', locals(), context_instance=RequestContext(request))
        # 将所查数据post tornado接口进行异步操作
        swan_data = project_swan.objects.get(uuid=project_all_tag)
        choose = int(swan_data.choose)
        if choose == 2 or choose == 3:
            try:
                git_minion = swan_data.git_code.codeFqdn
            except:
                git_minion = False
            try:
                git_code_user = swan_data.git_code_user
            except:
                git_code_user = "******"
            try:
                git_minion_path = swan_data.git_code.codePath
            except:
                git_minion_path = ""
            try:
                tomcat_init = swan_data.tomcat_init
            except:
                tomcat_init = ""
            try:
                cache = swan_data.cache
            except:
                cache = ""

            data = {
                "choose": choose,
                "code_name": swan_data.code_name,
                "arg": arg,
                "host": server_list,
                "ip_data": ip_list,
                "uid": uid,
                "git_minion": git_minion,
                "git_minion_path": git_minion_path,
                "git_version": tgt,
                "code_path": swan_data.code_path,
                "reset_code": rst.get("reset_code"),
                "git_code_user": git_code_user,
                "tomcat_init": tomcat_init,
                "cache": cache,
                "CheckUrl": swan_data.CheckUrl,
                "tgt": tgt,
                "shell_status": swan_data.shell_status,
                "shell": swan_data.shell,
            }
        elif choose == 4:
            try:
                git_minion = swan_data.git_code.codeFqdn
            except:
                git_minion = False
            try:
                git_code_user = swan_data.git_code_user
            except:
                git_code_user = "******"
            try:
                git_minion_path = swan_data.git_code.codePath
            except:
                git_minion_path = ""
            data = {
                "choose": swan_data.choose,
                "code_name": swan_data.code_name,
                "arg": arg,
                "host": server_list,
                "ip_data": ip_list,
                "uid": uid,
                "git_minion": git_minion,
                "git_minion_path": git_minion_path,
                "git_version": tgt,
                "code_path": swan_data.code_path,
                "reset_code": rst.get("reset_code"),
                "git_code_user": git_code_user,
                "shell": swan_data.shell,
                "CheckUrl": swan_data.CheckUrl,
                "tgt": tgt,
                "shell_status": swan_data.shell_status,
            }

        else:
            data = {
                "choose": choose,
                "sls": swan_data.salt_sls,
                "check_port_status": swan_data.check_port_status,
                "check_port": swan_data.check_port,
                "bat_push": swan_data.bat_push,
                "script": swan_data.script,
                "tgt": tgt,
                "argall_str": swan_data.argall_str,
                "code_name": swan_data.code_name,
                "arg": arg,
                "host": server_list,
                "ip_data": ip_list,
                "CheckUrl": swan_data.CheckUrl,
                "uid": uid,
                "shell_status": swan_data.shell_status,
                "shell": swan_data.shell,
            }
        s = swan_push_api(data)
        if s["status"] == 200:
            try:
                log_data = SwanLog(username=request.user.first_name,
                              userID=request.user.uuid,
                              project_name=business_id.service_name,
                              project_uuid=str(business_id.uuid),
                              module_name=tgt,
                              module_args=arg,
                              swan_name=swan_data.swan_name,
                              status=True,
                              message=u'发布成功',
                              update_log=log

                              )
                log_data.save()
            except:
                pass
            return HttpResponse(
                json.dumps({"status": "200", "uid": uid, "message": "Authentication failed"}, ensure_ascii=False,
                           indent=4))
        else:
            # try:
            #     log_data = SwanLog(userID=str(request.user.uuid),
            #                   username=request.user.first_name,
            #                   project_name=business_id.service_name,
            #                   project_uuid=str(business_id.uuid),
            #                   module_name=tgt,
            #                   swan_name=swan_data.swan_name,
            #                   module_args=arg,
            #                   message=u'接口异常',
            #                   status=False,
            #                   update_log=log
            #                   )
            #     print log
            #     print SwanLog.update_log
            #     log_data.save()
            #
            # except:
            #     print "error"
            #     pass
            log_data = SwanLog(userID=str(request.user.uuid),
                              username=request.user.first_name,
                              project_name=business_id.service_name,
                              project_uuid=str(business_id.uuid),
                              module_name=tgt,
                              swan_name=swan_data.swan_name,
                              module_args=arg,
                              message=u'接口异常',
                              status=False,
                              update_log=log
                              )
            log_data.save()
            print log
            return render_to_response('swan/push_error.html', locals(), context_instance=RequestContext(request))

    return HttpResponse(json.dumps({"status": "403", "message": "Authentication failed"}, ensure_ascii=False, indent=4))
Пример #4
0
def swan_release(request):
    if request.method == 'POST':
        uid = str(uuid.uuid4())
        rst = request.POST
        # print rst
        project_name = rst.get("project_name", False)
        project_all_tag = rst.get("project_all_tag", False)
        tgt = rst.get("tgt", False)
        arg = rst.get("arg", False)
        log = rst.get("update_log", None)
        # print update_log
        business_id = Project.objects.get(uuid=project_name)
        server_list = {}
        ip_list = []
        node_list = business_id.host_set.all()
        # 根据项目名反查主机
        if len(rst.getlist("node_name")) == 0:
            return render_to_response('swan/swan_error.html',
                                      locals(),
                                      context_instance=RequestContext(request))
        else:
            for i in rst.getlist("node_name"):
                s = node_list.get(eth1=i)
                server_list[s.eth1] = s.node_name
                ip_list.append(s.eth1)
        # if arg:
        #     return render_to_response('swan/swan_error.html', locals(), context_instance=RequestContext(request))
        # 将所查数据post tornado接口进行异步操作
        swan_data = project_swan.objects.get(uuid=project_all_tag)
        choose = int(swan_data.choose)
        if choose == 2 or choose == 3:
            try:
                git_minion = swan_data.git_code.codeFqdn
            except:
                git_minion = False
            try:
                git_code_user = swan_data.git_code_user
            except:
                git_code_user = "******"
            try:
                git_minion_path = swan_data.git_code.codePath
            except:
                git_minion_path = ""
            try:
                tomcat_init = swan_data.tomcat_init
            except:
                tomcat_init = ""
            try:
                cache = swan_data.cache
            except:
                cache = ""

            data = {
                "choose": choose,
                "code_name": swan_data.code_name,
                "arg": arg,
                "host": server_list,
                "ip_data": ip_list,
                "uid": uid,
                "git_minion": git_minion,
                "git_minion_path": git_minion_path,
                "git_version": tgt,
                "code_path": swan_data.code_path,
                "reset_code": rst.get("reset_code"),
                "git_code_user": git_code_user,
                "tomcat_init": tomcat_init,
                "cache": cache,
                "CheckUrl": swan_data.CheckUrl,
                "tgt": tgt,
                "shell_status": swan_data.shell_status,
                "shell": swan_data.shell,
            }
        elif choose == 4:
            try:
                git_minion = swan_data.git_code.codeFqdn
            except:
                git_minion = False
            try:
                git_code_user = swan_data.git_code_user
            except:
                git_code_user = "******"
            try:
                git_minion_path = swan_data.git_code.codePath
            except:
                git_minion_path = ""
            data = {
                "choose": swan_data.choose,
                "code_name": swan_data.code_name,
                "arg": arg,
                "host": server_list,
                "ip_data": ip_list,
                "uid": uid,
                "git_minion": git_minion,
                "git_minion_path": git_minion_path,
                "git_version": tgt,
                "code_path": swan_data.code_path,
                "reset_code": rst.get("reset_code"),
                "git_code_user": git_code_user,
                "shell": swan_data.shell,
                "CheckUrl": swan_data.CheckUrl,
                "tgt": tgt,
                "shell_status": swan_data.shell_status,
            }

        else:
            data = {
                "choose": choose,
                "sls": swan_data.salt_sls,
                "check_port_status": swan_data.check_port_status,
                "check_port": swan_data.check_port,
                "bat_push": swan_data.bat_push,
                "script": swan_data.script,
                "tgt": tgt,
                "argall_str": swan_data.argall_str,
                "code_name": swan_data.code_name,
                "arg": arg,
                "host": server_list,
                "ip_data": ip_list,
                "CheckUrl": swan_data.CheckUrl,
                "uid": uid,
                "shell_status": swan_data.shell_status,
                "shell": swan_data.shell,
            }
        s = swan_push_api(data)
        if s["status"] == 200:
            try:
                log_data = SwanLog(username=request.user.first_name,
                                   userID=request.user.uuid,
                                   project_name=business_id.service_name,
                                   project_uuid=str(business_id.uuid),
                                   module_name=tgt,
                                   module_args=arg,
                                   swan_name=swan_data.swan_name,
                                   status=True,
                                   message=u'发布成功',
                                   update_log=log)
                log_data.save()
            except:
                pass
            return HttpResponse(
                json.dumps(
                    {
                        "status": "200",
                        "uid": uid,
                        "message": "Authentication failed"
                    },
                    ensure_ascii=False,
                    indent=4))
        else:
            # try:
            #     log_data = SwanLog(userID=str(request.user.uuid),
            #                   username=request.user.first_name,
            #                   project_name=business_id.service_name,
            #                   project_uuid=str(business_id.uuid),
            #                   module_name=tgt,
            #                   swan_name=swan_data.swan_name,
            #                   module_args=arg,
            #                   message=u'接口异常',
            #                   status=False,
            #                   update_log=log
            #                   )
            #     print log
            #     print SwanLog.update_log
            #     log_data.save()
            #
            # except:
            #     print "error"
            #     pass
            log_data = SwanLog(userID=str(request.user.uuid),
                               username=request.user.first_name,
                               project_name=business_id.service_name,
                               project_uuid=str(business_id.uuid),
                               module_name=tgt,
                               swan_name=swan_data.swan_name,
                               module_args=arg,
                               message=u'接口异常',
                               status=False,
                               update_log=log)
            log_data.save()
            print log
            return render_to_response('swan/push_error.html',
                                      locals(),
                                      context_instance=RequestContext(request))

    return HttpResponse(
        json.dumps({
            "status": "403",
            "message": "Authentication failed"
        },
                   ensure_ascii=False,
                   indent=4))