Esempio n. 1
0
    def deployServices(self, env, services, phone_number):
        self.env = env
        self.services = services
        self.phone_number = phone_number
        result = []
        obj = winconf.objects.filter(env=self.env).filter(
            servicename=self.services)
        for name in obj:
            stop = self.salt.cmd(name.hostname.saltname, 'cmd.run',
                                 ['net stop %s' % name.servicename])
            result.append(stop)
            while True:
                task_list = self.salt.cmd(
                    name.hostname.saltname, 'cmd.run',
                    ['tasklist | findstr %s' % name.tasklist_name])
                if not task_list[name.hostname.saltname]:
                    print 'proccess has been exit.'
                    break
                time.sleep(3)
            update = self.salt.cmd(name.hostname.saltname, 'cmd.run', [
                'svn up %s --username=%s --password=%s' %
                (name.localpath, name.username, name.password)
            ])
            result.append(update)
            start = self.salt.cmd(name.hostname.saltname, 'cmd.run',
                                  ['net start %s' % name.servicename])
            result.append(start)

            action = 'deploy ' + name.servicename
            logs(self.user, self.ip, action, result)
            servicename = name.servicename.strip('"')
            dingding_robo(name.hostname.saltname, servicename, start,
                          self.user, self.phone_number)

        return result
Esempio n. 2
0
    def servicesAction(self, services, action, phone_number):
        self.services = services
        self.action = action
        self.phone_number = phone_number

        result = []

        for s in self.services:
            sName, host = s.split(',')
            if action == 'start':
                getMes = self.salt.cmd(host, 'cmd.run',
                                       ['net start %s' % sName])

            elif action == 'stop':
                getMes = self.salt.cmd(host, 'cmd.run',
                                       ['net stop %s' % sName])

            elif action == 'restart':
                getMes = self.salt.cmd(host, 'cmd.run',
                                       ['net stop %s' % sName])
                result.append(getMes)
                getMes = self.salt.cmd(host, 'cmd.run',
                                       ['net start %s' % sName])

            result.append(getMes)
            info = self.action + ' ' + sName.strip('"')
            dingding_robo(host, info, getMes, self.user, self.phone_number)
            logs(self.user, self.ip, info, result)

        return result
Esempio n. 3
0
    def __nginx_backup(self, proxy_server, web_server, nginx_module,
                       deploy_pillar):
        self.proxy_server = proxy_server
        self.web_server = web_server
        self.nginx_module = nginx_module
        self.deploy_pillar = deploy_pillar

        try:  ##########nginx backup#######

            s, backup = commands.getstatusoutput("salt " + self.proxy_server +
                                                 " state.sls queue=True " +
                                                 self.nginx_module + " " +
                                                 self.deploy_pillar)
            self.f.write(backup)
            self.f.flush()
            self.result.append(backup)

            if backup.find('Failed:     0') < 0:
                print "!!!!!!!!!!!!!!!!!! [backup server] ERROR !!!!!!!!!!!!!!!!!!!"
                return 1
            self.f.write('\n\n\n\n\n')
            return 0
        except Exception, e:
            print e
            self.f.write('error')
            self.f.close()
            dingding_robo(self.web_server, self.site, 'error', self.username,
                          self.phone_number)
            logs(self.username, self.ip, self.site, 'Failed')
            return 1
Esempio n. 4
0
    def __svn_update(self, web_server, svn_path, svn_username, svn_password,
                     svn_revision):
        self.web_server = web_server
        self.svn_path = svn_path
        self.svn_username = svn_username
        self.svn_password = svn_password
        self.svn_revision = svn_revision

        try:  #####svn update########
            update_cmd = 'svn update -r %s %s --username=%s --password=%s' % (
                self.svn_revision, self.svn_path, self.svn_username,
                self.svn_password)

            print '-----svn----', update_cmd
            data = {
                'client': 'local',
                'tgt': self.web_server,
                'fun': 'cmd.run',
                'arg': update_cmd
            }
            update = salt_api.salt_cmd(data)
            print update
            if update['return'][0][self.web_server].find(
                    'Error') > 0 or update['return'][0][self.web_server].find(
                        'error') > 0:
                print "!!!!!!!!!!!!!!!!!! [update svn] ERROR !!!!!!!!!!!!!!!!!!!"
                return 1
        except Exception, e:
            print e
            self.f.write('error')
            self.f.close()
            dingding_robo(self.web_server, self.site, 'error', self.username,
                          self.phone_number)
            logs(self.username, self.ip, self.site, 'Failed')
            return 1
Esempio n. 5
0
def salt_run_sls(login_user, svnrepo, projectname, salt_hostname, login_ip):
    errcode = 0
    msg = 'ok'
    try:
        pillar = '''pillar=\"{'svnrepo': '%s', 'goprograme': '%s'}\"''' % (
            svnrepo, projectname)
        pull_svn_cmd = "salt " + salt_hostname + " state.sls queue=True goservices.pull_svn " + pillar
        print 'pull_svn_cmd : '
        print pull_svn_cmd
        s, result = commands.getstatusoutput(pull_svn_cmd)
        if result.find('Failed:    0') < 0:
            utils.logs(login_user, login_ip, 'pull svn ' + projectname,
                       'Failed')
            print 'result : '
            print result
            errcode = 501
            msg = u'salt执行不成功:\n'
            msg += result.split('\n')[0]
        else:
            utils.logs(login_user, login_ip, 'pull svn ' + projectname,
                       'Successful')
    except Exception as e:
        errcode = 500
        msg = u'salt执行失败'
    return errcode, msg
Esempio n. 6
0
    def __svn_update(self, web_server, svn_path, svn_username, svn_password,
                     svn_revision):
        self.web_server = web_server
        self.svn_path = svn_path
        self.svn_username = svn_username
        self.svn_password = svn_password
        self.svn_revision = svn_revision

        try:  #####svn update########
            update_cmd = '\'svn update -r %s %s --username=%s --password=%s \'' % (
                self.svn_revision, self.svn_path, self.svn_username,
                self.svn_password)
            s, update = commands.getstatusoutput("salt " + self.web_server +
                                                 " cmd.run " + update_cmd)
            self.f.write(update)
            self.f.flush()
            self.result.append(update)

            if update.find('Error') > 0 or update.find('error') > 0:
                print "!!!!!!!!!!!!!!!!!! [update svn] ERROR !!!!!!!!!!!!!!!!!!!"
                return 1
            self.f.write('\n\n\n\n\n')
            return 0
        except Exception, e:
            print e
            self.f.write('error')
            self.f.close()
            dingding_robo(self.web_server, self.site, 'error', self.username,
                          self.phone_number)
            logs(self.username, self.ip, self.site, 'Failed')
            return 1
Esempio n. 7
0
    def deploy(self, site, action='svn', revision='HEAD'):

        self.site = site
        self.action = action
        self.revision = revision
        obj = webSite.objects.filter(env=self.env).filter(webSite=self.site)

        for info in obj:
            for host in info.checkUrl.values():
                print host['host']
                for m in info.state_module.values():
                    deploy_pillar = "pillar=\"{'deployserver':'" + host[
                        'host'] + "', 'deployhost':'" + info.salt_pillar_host + "'}\""
                    nginx_backup = self.__nginx_backup(info.lb_server,
                                                       host['host'],
                                                       m['state_module'],
                                                       deploy_pillar)
                    if nginx_backup == 1:
                        self.f.write('error')
                        exit()
                if self.action in ['svn', 'revert']:
                    svn_up = self.__svn_update(host['host'], info.svn_path,
                                               info.svn_username,
                                               info.svn_password,
                                               self.revision)
                    if svn_up == 1:
                        self.f.write('error')
                        exit()
                elif self.action == 'recycle':
                    pass

                recycle = self.__iis_recycle(host['host'], info.recycle_cmd,
                                             host['url'], self.action)
                if recycle == 1:
                    self.f.write('error')
                    exit()

            for m in info.state_module.values(
            ):  ######nginx all online########
                print m['state_module']
                deploy_pillar = "pillar=\"{'deployserver':'none', 'deployhost':'none'}\""
                status = self.__nginx_backup(info.lb_server, host['host'],
                                             m['state_module'], deploy_pillar)

                if status == 1:
                    logs(self.username, self.ip, self.site, 'Failed')
                    self.f.write('error')
                    exit()

        self.f.write('done')
        self.f.flush()
        self.f.close()
        logs(self.username, self.ip, self.site, 'Successful')

        return self.result
Esempio n. 8
0
    def __iis_recycle(self, web_server, recycle_cmd, web_url, action):
        self.web_server = web_server
        self.recycle_cmd = recycle_cmd
        self.web_url = web_url
        self.action = action

        try:  ####recycle iis#######
            data = {
                'client': 'local',
                'tgt': self.web_server,
                'fun': 'cmd.run',
                'arg': self.recycle_cmd
            }

            print '----------', self.web_server, self.recycle_cmd
            recycle = salt_api.salt_cmd(data)
            print recycle
            if recycle['return'][0][self.web_server].find('successfully') < 0:
                print "!!!!!!!!!!!!!!!!!! [recycle iis] ERROR !!!!!!!!!!!!!!!!!!"
                return 1

            c = 6
            while c > 1:
                print c
                r = requests.get(self.web_url,
                                 headers={'Host': self.site},
                                 timeout=60,
                                 allow_redirects=False)
                c -= 1

            if self.action == 'recycle':
                dingding_robo(self.web_server, 'recycle ' + self.site,
                              'success', self.username, self.phone_number)
            elif self.action == 'revert':
                dingding_robo(self.web_server, 'revert ' + self.site,
                              'success', self.username, self.phone_number)
            else:
                dingding_robo(self.web_server, self.site, 'success',
                              self.username, self.phone_number)
            return 0
        except Exception, e:
            print e
            self.f.write('error')
            self.f.close()
            if self.action == 'recycle':
                dingding_robo(self.web_server, self.site, 'is error',
                              self.username, self.phone_number)
            elif self.action == 'revert':
                dingding_robo(self.web_server, self.site, 'is error',
                              self.username, self.phone_number)
            else:
                dingding_robo(self.web_server, self.site, 'is error',
                              self.username, self.phone_number)
            logs(self.username, self.ip, self.site, 'Failed')
            return 1
Esempio n. 9
0
    def deploy(self, site, action='svn', revision='HEAD'):

        self.site = site
        self.action = action
        self.revision = revision
        info = webSite.objects.filter(env=self.env).get(webSite=self.site)
        ip = []
        for i in info.checkUrl.values():
            ip.append(i['ip'])

        for host in info.checkUrl.values():

            print host['host']
            for m in info.state_module.values():
                nginx_backup = self.__nginx_backup(ip, host['ip'],
                                                   host['host'],
                                                   m['state_module'], 0)
                if nginx_backup == 1:
                    self.f.write('error')
                    exit()
            if self.action in ['svn', 'revert']:
                svn_up = self.__svn_update(host['host'], info.svn_path,
                                           info.svn_username,
                                           info.svn_password, self.revision)
                if svn_up == 1:
                    self.f.write('error')
                    exit()
            elif self.action == 'recycle':
                pass

            recycle = self.__iis_recycle(host['host'], info.recycle_cmd,
                                         host['url'], self.action)
            if recycle == 1:
                self.f.write('error')
                exit()

        for m in info.state_module.values():  ######nginx all online########
            status = self.__nginx_backup(ip, host['ip'], host['host'],
                                         m['state_module'], 1)

            if status == 1:
                logs(self.username, self.ip, self.site, 'Failed')
                self.f.write('error')
                exit()

        self.f.write('done')
        self.f.flush()
        self.f.close()
        logs(self.username, self.ip, self.site, 'Successful')

        return self.result
Esempio n. 10
0
def command_exec(username, phone, ip, svc_name, cmd, zone, output):
    cmd_host = cmd_host_qcd if zone == 'qcd' else cmd_host_aws

    _cmd = 'svn co http://svn.65dg.me/svn/gotemplate /srv/gotemplate ' \
           ' --non-interactive --username={username} --password={password} && ' \
           'svn co http://svn.65dg.me/svn/{svc_name} /srv/{svc_name} ' \
           ' --non-interactive --username={username} --password={password} && ' \
           'mkdir -p {log_path} && ' \
           'cd /srv/{svc_name} && ' \
           '/srv/{svc_name}/{cmd} -c /srv/gotemplate/{svc_name}/conf.ctmpl >> {output} 2>&1' \
           ''.format(username=svn_username, password=svn_password,
                     svc_name=svc_name, cmd=cmd, output=output, log_path=os.path.dirname(output))
    print(_cmd)

    salt_api = SaltApi()
    data = {
        'client': 'local',
        'fun': 'cmd.run',
        'tgt': cmd_host,
        'arg': _cmd
    }
    result = salt_api.salt_cmd(data)
    if result != 0:
        result = result['return']

    if not os.path.exists(os.path.dirname(output)):
        try:
            os.makedirs(os.path.dirname(output))
        except Exception as e:
            print(e)
            logs(username, ip, cmd, e)
            dingding_robo(cmd_host, 'command job', ' error ', username, phone)
            return str(e)

    with open(output, 'w') as f:
        if isinstance(result, list):
            for r in result:
                if isinstance(r, dict):
                    for k, v in r.items():
                        f.write('--> ')
                        f.write(k)
                        f.write('\n')
                        f.write(v)
                else:
                    f.write(str(r))
        else:
            f.write(str(result))

    logs(username, ip, cmd, 'running')
    dingding_robo(cmd_host, 'command job', result, username, phone)
    return result
Esempio n. 11
0
def ack_job(request):
    user = request.user
    ip = request.META['REMOTE_ADDR']
    env = request.POST['env']
    jobIds = request.POST.getlist('jobIds', [])
    if not user.groups.filter(name__in=['admin', 'dba', 'disque']).exists():
        logs(user, ip, 'ack job: %s , zone: %s' % (jobIds, env),
             'permission denied')
        return HttpResponse(json.dumps({'errcode': 403}),
                            content_type=default_content_type)

    if not (env in clientEnvMap.keys()):
        logs(user, ip, 'ack job: %s' % jobIds, 'unknown disque zone: %s' % env)
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'unknown disque zone:%s' % env
        }),
                            content_type=default_content_type)

    if len(jobIds) == 0:
        logs(user, ip, 'ack job: zone-%s' % env, 'empty jobIds')
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'empty jobIds'
        }),
                            content_type=default_content_type)
    jobIds = map(lambda x: x.encode('utf-8'), jobIds)
    print user, env, jobIds

    try:
        client = clientEnvMap[env]
        client.ack_job(*jobIds)
    except Exception as e:
        print e
        logs(user, ip, 'ack job: %s , zone: %s' % (jobIds, env), str(e))
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': str(e)
        }),
                            content_type=default_content_type)
    logs(user, ip, 'ack job: %s , zone: %s' % (jobIds, env), 'success')
    return HttpResponse(json.dumps({'errcode': 200}),
                        content_type=default_content_type)
Esempio n. 12
0
    def __nginx_backup(self, hosts, block_ip, block_server, nginx_upstream,
                       is_block):
        self.hosts = hosts
        self.block_ip = block_ip
        self.block_server = block_server
        self.nginx_upstream = nginx_upstream
        upstream_host = ''

        try:
            for ip in self.hosts:
                if is_block == 1:
                    upstream_host += 'server %s; ' % ip
                else:
                    if len(self.hosts) == 1:
                        upstream_host += 'server %s; ' % ip
                    elif ip != self.block_ip:
                        upstream_host += 'server %s; ' % ip
            if not upstream_host:
                print 'not upstream_host!!!!'
                exit()

            for lb in nginx_api:
                url = "%s/upstream/%s" % (lb, self.nginx_upstream)
                r = requests.post(url, data=upstream_host)
                self.f.write('curl ' + url)
                self.f.write('\n\n\n\n\n')
                self.f.flush()
                if r.text != 'success':
                    exit()
                r = requests.get(url)
                self.f.write(r.text)
                self.f.flush()

            self.f.write('\n\n\n\n\n')
            return 0
        except Exception, e:
            print e
            self.f.write('error')
            self.f.close()
            dingding_robo(self.block_server, self.site, 'is error',
                          self.username, self.phone_number)
            logs(self.username, self.ip, self.site, 'Failed')
            return 1
Esempio n. 13
0
def kettle_run(user, ip, cmd_type, file_path, kettle_log_file, phone_number):
    salt_api = SaltApi()
    file_path = kettle_svn_path + file_path
    kettle_log_file = kettle_log_path + kettle_log_file

    if int(cmd_type) == 1:
        cmd = '%span.sh -file %s -logfile %s' % (kettle_install_dir, file_path,
                                                 kettle_log_file)
    elif int(cmd_type) == 2:
        cmd = '%skitchen.sh -file %s -logfile %s' % (
            kettle_install_dir, file_path, kettle_log_file)

    exists_file_cmd = 'ls %s' % file_path
    exists_file = {
        'client': 'local',
        'tgt': kettle_host,
        'fun': 'cmd.run',
        'arg': exists_file_cmd
    }

    file_result = salt_api.salt_cmd(exists_file)
    if file_result['return'][0][kettle_host] != file_path:
        logs(user, ip, cmd, 'not %s file.' % file_path)
        dingding_robo(kettle_host, 'kettle job', 'it is error', user,
                      phone_number)
        return 0

    data = {
        'client': 'local',
        'tgt': kettle_host,
        'fun': 'cmd.run',
        'arg': cmd
    }

    result = salt_api.salt_cmd(data)
    if result != 0:
        result = result['return']

    logs(user, ip, cmd, 'running')
    dingding_robo(kettle_host, 'kettle job', result, user, phone_number)
    return result
Esempio n. 14
0
def mautic_restart(request):
    user = request.user
    ip = request.META['REMOTE_ADDR']
    host = request.POST['host']

    try:
        if not user.groups.filter(name__in=['admin', 'mautic']).exists():
            raise Exception('Permission Denied!')

        salt_api = SaltApi()
        data = {
            'client': 'local',
            'fun': 'cmd.run',
            'tgt': host,
            'arg': 'service php7.1-fpm restart',
        }
        result = salt_api.salt_cmd(data)['return']
        logs(user, ip, host, 'service php7.1-fpm restart')
    except Exception as e:
        print e
        result = [{'restart mautic failed': str(e)}]

    return render(request, 'getdata.html', {'result': result})
Esempio n. 15
0
             result = [{'HandleTasks':'The task_id handle to failed!'}]
 elif content['ticket_type'] == 'webpage':
     try:
         data = {
             'client':'local',
             'tgt': webpage_host,
             'fun':'cmd.script',
             'arg':['salt://scripts/webpage.py','"%s"' % str(content['site_name'])] 
         }
         salt_api.salt_cmd(data)
     except Exception, e:
         print e
         handle_result = 1
         TicketTasks.objects.filter(tasks_id=task_id).update(state='5')
         TicketOperating.objects.create(operating_id=operating_id,handler=username,content=reply,result='3',submitter=content['owner'])
         logs(user=request.user,ip=request.META['REMOTE_ADDR'],action='handle ticket (%s)' % content['title'],result='failed')
         info = 'The "%s" order is failed,please check in %s host.' % (content['title'],host)
         dingding_robo(phone_number=phone_number,types=2,info=info)
         result = [{'HandleTasks':'The task_id handle to failed!'}]
 elif content['ticket_type'] == 'uat_jenkins':
     try:
         jenkins = existGitlabProject(content['jenkins_name'],content['uat_env'])
         print '-----jenkins---',jenkins
         if jenkins == 2:
             result = [{'HandleTasks': 'The project name is not exist.'}]
             handle_result = 1
         elif jenkins == 3:
             result = [{'HandleTasks': 'jenkins creating is error.'}]
             handle_result = 1
         elif jenkins == 4:
             result = [{'HandleTasks': 'svn repo creating is error.'}]
Esempio n. 16
0
def ack_job(request):
    user = request.user
    ip = request.META['REMOTE_ADDR']
    zone = request.POST['zone']
    jobIds = request.POST.getlist('jobIds', [])
    if not user.groups.filter(name__in=['admin', 'dba', 'disque']).exists():
        logs(user, ip, 'ack job: %s , zone: %s' % (jobIds, zone),
             'permission denied')
        return HttpResponse(json.dumps({'errcode': 403}),
                            content_type=DEFAULT_CONTENT_TYPE)
    try:
        clusterInfo = ClusterInfo.objects.get(name=zone)
        print clusterInfo.addr
    except ClusterInfo.DoesNotExist:
        logs(user, ip, 'ack job: %s' % jobIds,
             'unknown disque zone: %s' % zone)
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'unknown disque zone:%s' % zone
        }),
                            content_type=DEFAULT_CONTENT_TYPE)
    except ClusterInfo.MultipleObjectsReturned:
        logs(user, ip, 'ack job: %s' % jobIds,
             'multi objects returned for zone: %s' % zone)
        return HttpResponse(json.dumps({
            'errcode':
            400,
            'msg':
            'multi objects returned for zone:%s' % zone
        }),
                            content_type=DEFAULT_CONTENT_TYPE)
    except Exception as e:
        print e
        logs(user, ip, 'ack job: %s , zone: %s' % (jobIds, zone), str(e))
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': str(e)
        }),
                            content_type=DEFAULT_CONTENT_TYPE)

    if len(jobIds) == 0:
        logs(user, ip, 'ack job: zone-%s' % zone, 'empty jobIds')
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'empty jobIds'
        }),
                            content_type=DEFAULT_CONTENT_TYPE)
    jobIds = map(lambda x: x.encode('utf-8'), jobIds)
    print user, zone, jobIds

    try:
        addr = clusterInfo.addr.split(',')
        client = Client(addr)
        client.connect()
        client.ack_job(*jobIds)
    except Exception as e:
        print e
        logs(user, ip, 'ack job: %s , zone: %s' % (jobIds, zone), str(e))
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': str(e)
        }),
                            content_type=DEFAULT_CONTENT_TYPE)
    logs(user, ip, 'ack job: %s , zone: %s' % (jobIds, zone), 'success')
    return HttpResponse(json.dumps({'errcode': 200}),
                        content_type=DEFAULT_CONTENT_TYPE)
Esempio n. 17
0
                mes = {host: repo_info}
                result.append(mes)
                notification_mes = 'It is successful.'
            else:
                notification_mes = 'It is error.'
        else:
            result.append(cmdinfo)
            notification_mes = 'It is error.'
    except Exception, e:
        print e
        result.append(cmdinfo)
        notification_mes = 'The system is error.....'

    dingding_robo(host, 'create svn repo "%s"' % svnName, notification_mes,
                  username, request.POST['phone_number'])
    logs(username, ip, 'create svn repo "%s"' % svnName, notification_mes)

    return render(request, 'getdata.html', {'result': result})


@login_required
@deny_resubmit(page_key='deploy_svn_add_user')
def svnAddUser(request):
    username = request.user
    ip = request.META['REMOTE_ADDR']
    env = request.POST['env']
    host = request.POST['hostname']
    svnName = request.POST['svnName']
    svnPassword = request.POST['svnPassword']
    result = []
Esempio n. 18
0
    def __iis_recycle(self, web_server, recycle_cmd, web_url, action):
        self.web_server = web_server
        self.recycle_cmd = recycle_cmd
        self.web_url = web_url
        self.action = action

        try:  ####recycle iis#######
            s, recycle = commands.getstatusoutput("salt " + self.web_server +
                                                  " cmd.run '" +
                                                  self.recycle_cmd + "'")
            self.f.write(recycle)
            self.f.flush()
            self.result.append(recycle)

            if recycle.find('Fail') > 0 or recycle.find('fail') > 0:
                print "!!!!!!!!!!!!!!!!!! [recycle iis] ERROR !!!!!!!!!!!!!!!!!!"
                return 1
            self.f.write('\n\n\n\n\n')

            i = 0
            while i < 5:
                start_time = time.time()
                s, testUrl = commands.getstatusoutput("curl -H \"Host:" +
                                                      self.site + "\" -I " +
                                                      self.web_url)
                self.f.write(testUrl)
                self.f.flush()
                self.f.write('\n\n\n\n\n')
                print time.time() - start_time
                if time.time() - start_time < 2:
                    break
                i = i + 1
            if i == 5:
                print "!!!!!!!!!!!!!!!!!! [recycle iis] TIMEOUT !!!!!!!!!!!!!!!!!!"
                self.f.write('error')
                self.f.close()
                return 1
            if self.action == 'recycle':
                dingding_robo(self.web_server, 'recycle ' + self.site,
                              'success', self.username, self.phone_number)
            elif self.action == 'revert':
                dingding_robo(self.web_server, 'revert ' + self.site,
                              'success', self.username, self.phone_number)
            else:
                dingding_robo(self.web_server, self.site, 'success',
                              self.username, self.phone_number)
            return 0
        except Exception, e:
            print e
            self.f.write('error')
            self.f.close()
            if self.action == 'recycle':
                dingding_robo(self.web_server, self.site, 'error',
                              self.username, self.phone_number)
            elif self.action == 'revert':
                dingding_robo(self.web_server, self.site, 'error',
                              self.username, self.phone_number)
            else:
                dingding_robo(self.web_server, self.site, 'error',
                              self.username, self.phone_number)
            logs(self.username, self.ip, self.site, 'Failed')
            return 1
Esempio n. 19
0
def add_job(request):
    user = request.user
    ip = request.META['REMOTE_ADDR']
    zone = request.POST['zone']
    queue = request.POST['queue_name']
    # timeout_ms = request.POST['timeout_ms']
    # replicate = request.POST['replicate']
    # retry_sec = request.POST['retry_sec']
    # delay_sec = request.POST['delay_sec']
    # ttl_sec = request.POST['ttl_sec']
    jobs = request.POST.getlist('jobs', [])
    # print user, env, queue, timeout_ms, replicate, retry_sec, delay_sec, ttl_sec
    print user, zone, queue
    print jobs

    if not user.groups.filter(name__in=['admin', 'dba', 'disque']).exists():
        logs(user, ip, 'add job: %s - %s' % (zone, queue), 'permission denied')
        return HttpResponse(json.dumps({'errcode': 403}),
                            content_type=DEFAULT_CONTENT_TYPE)

    try:
        clusterInfo = ClusterInfo.objects.get(name=zone)
        print clusterInfo.addr
    except ClusterInfo.DoesNotExist:
        logs(user, ip, 'add job: %s - %s' % (zone, queue),
             'unknown disque zone: %s' % zone)
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'unknown disque zone:%s' % zone
        }),
                            content_type=DEFAULT_CONTENT_TYPE)
    except ClusterInfo.MultipleObjectsReturned:
        logs(user, ip, 'add job: %s - %s' % (zone, queue),
             'multi objects returned for zone: %s' % zone)
        return HttpResponse(json.dumps({
            'errcode':
            400,
            'msg':
            'multi objects returned for zone:%s' % zone
        }),
                            content_type=DEFAULT_CONTENT_TYPE)
    except Exception as e:
        print e
        logs(user, ip, 'add job: %s - %s' % (zone, queue), str(e))
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': str(e)
        }),
                            content_type=DEFAULT_CONTENT_TYPE)

    if (not queue) or len(queue) == 0:
        logs(user, ip, 'add job: %s - %s' % (zone, queue), 'empty queue name')
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'empty queue name'
        }),
                            content_type=DEFAULT_CONTENT_TYPE)
    if len(jobs) == 0:
        logs(user, ip, 'add job: %s - %s' % (zone, queue), 'empty jobs')
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'empty jobs'
        }),
                            content_type=DEFAULT_CONTENT_TYPE)

    jobs = map(lambda x: x.encode('utf-8'), jobs)
    jobIds = []
    errJob = []
    addr = clusterInfo.addr.split(',')
    client = Client(addr)
    client.connect()
    for job in jobs:
        try:
            print job
            jobId = client.add_job(queue, job)
            # jobId = client.add_job(queue, job, timeout=timeout_ms, replicate=replicate, delay=delay_sec, retry=retry_sec, ttl=ttl_sec)
            jobIds.append(jobId)
        except Exception as e:
            print e
            errJob.append(job)
    logs(user, ip, 'add job: %s - %s' % (zone, queue), 'success')
    return HttpResponse(json.dumps({
        'errcode': 200,
        'jobIds': jobIds,
        'failJobs': errJob
    }),
                        content_type=DEFAULT_CONTENT_TYPE)
Esempio n. 20
0
    def deploy(self, site, action='svn', revision='HEAD', group=None):
        self.action = action
        self.revision = revision
        if group:
            obj = groupName.objects.get(group_name=group).member.values()
        else:
            obj = []
            obj.append({'webSite': site})
        for s in obj:
            self.site = s['webSite']
            info = webSite.objects.filter(env=self.env).get(webSite=self.site)
            ip = []
            zbx = ZabbixMonitor(zabbix_url, zabbix_user, zabbix_password,
                                zabbix_userId)

            ## if the server is not normal.
            for h in info.checkUrl.values():
                cpu = zbx.cpu_percent_usage(h['host'])
                print "host:%s------cpu:%s" % (h['host'], cpu)
                if float(cpu) > 95:
                    self.f.write(
                        'The %s server has a problem. Please contact the devops...\n'
                        % h['host'])
                    self.f.write('error')
                    self.f.flush()
                    exit()

                ip.append(h['ip'])

            print '--------site--------------', info.webSite
            self.f.write('-----------------------%s---------------------\n' %
                         info.webSite)
            self.f.flush()
            for host in info.checkUrl.values():
                for m in info.state_module.values():
                    nginx_backup = self.__nginx_backup(ip, host['ip'],
                                                       host['host'],
                                                       m['state_module'], 0)
                    if nginx_backup == 1:
                        self.f.write(
                            'Step 1: blocking nginx traffic is failed.\n')
                        exit()
                self.f.write('Step 1: blocking nginx traffic is sucessful.\n')
                self.f.flush()
                if self.action in ['svn', 'revert']:
                    svn_up = self.__svn_update(host['host'], info.svn_path,
                                               info.svn_username,
                                               info.svn_password,
                                               self.revision)
                    if svn_up == 1:
                        self.f.write('error')
                        exit()
                    else:
                        self.f.write('Step 2: svn update is sucessful.\n')
                        self.f.flush()
                elif self.action == 'recycle':
                    pass

                recycle = self.__iis_recycle(host['host'], info.recycle_cmd,
                                             host['url'], self.action)
                if recycle == 1:
                    self.f.write('error')
                    exit()
                elif action == 'recycle':
                    self.f.write('Step 2: iis recycle is sucessful.\n')
                    self.f.flush()
                else:
                    self.f.write('Step 3: iis recycle is sucessful.\n')
                    self.f.flush()

            for m in info.state_module.values(
            ):  ######nginx all online########
                status = self.__nginx_backup(ip, host['ip'], host['host'],
                                             m['state_module'], 1)

                if status == 1:
                    logs(self.username, self.ip, self.site, 'Failed')
                    self.f.write('error')
                    exit()
            self.f.write('Last step: open nginx traffic is sucessful.\n')
            self.f.flush()
            logs(self.username, self.ip, self.site, 'Successful')
        self.f.write('done')
        self.f.flush()
        self.f.close()
        return self.result
Esempio n. 21
0
def submit_tickets(request):
    title = request.POST['title']
    ticket_type = request.POST['ticket_type']
    handler = request.POST['handler']
    owner = str(request.user)
    if ticket_type == 'go':
        function = request.POST['function']
        hosts = request.POST.getlist('hosts')
        project = request.POST['project']
        go_command = request.POST['go_command']
        supervisor_name = request.POST['supervisor_name']
        svn_repo = request.POST['svn_repo']
        statsd = request.POST['statsd']
        sentry = request.POST['sentry']
        go_command = go_command + " -c /srv/gotemplate/%s/conf.ctmpl" % project

        salt_command = {
            "title": title,
            "ticket_type": ticket_type,
            "function": function,
            "hosts": hosts,
            "project": project,
            "svn_repo": svn_repo,
            "supervisor_name": supervisor_name,
            "go_command": go_command,
            "statsd": statsd,
            "sentry": sentry,
            "handler": handler,
            "owner": owner
        }

    elif ticket_type == 'webpage':
        print '--------site_name-----:', request.POST.getlist('site_name')
        site_name = request.POST.getlist('site_name')
        salt_command = {
            "title": title,
            "ticket_type": ticket_type,
            "site_name": site_name,
            "handler": handler,
            "owner": owner
        }
    try:
        salt_command = json.dumps(salt_command)
        ticket_type = TicketType.objects.get(type_name=ticket_type)
        handler = User.objects.get(username=handler)
        task_id = str(uuid.uuid1())
        TicketTasks.objects.create(tasks_id=task_id,
                                   title=title,
                                   ticket_type=ticket_type,
                                   creator=request.user,
                                   content=salt_command,
                                   handler=handler,
                                   state='1')
        result = [{
            'TicketTasks':
            'The %s order submitted to success!' % (task_id)
        }]
        logs(user=request.user,
             ip=request.META['REMOTE_ADDR'],
             action='add ticket (%s)' % title,
             result='successful')
        user = User.objects.get(username=handler)

        phone_number = UserProfile.objects.get(user=user).phone_number
        info = 'You have a message,please visit to workflow page.'
        dingding_robo(phone_number=phone_number, types=2, info=info)
    except Exception, e:
        print e
        result = [{'TicketTasks': 'The order submitted to failed!'}]
        logs(user=request.user,
             ip=request.META['REMOTE_ADDR'],
             action='add ticket (%s)' % title,
             result='failed')
Esempio n. 22
0
@login_required
@deny_resubmit(page_key='memcache')
def flushMemcached(request):
    data = request.POST.getlist('mcName')
    project = 'memcache flush'
    username = request.user
    ip = request.META['REMOTE_ADDR']
    saltCmd = LocalClient()
    result = []

    for name in data:
        for info in memcache.objects.filter(memcacheName=name):
            try:
                cmd = saltCmd.cmd(
                    info.saltMinion.saltname, 'cmd.run',
                    ['echo "flush_all" | nc %s %s' % (info.ip, info.port)])
                result.append(cmd)
                if cmd[info.saltMinion.saltname] == 'OK':
                    msg = 'Success'
                else:
                    msg = 'error'
                host = info.ip + ":" + info.port
                dingding_robo(host, project, msg, username,
                              request.POST['phone_number'])
                print result
            except Exception, e:
                print e
    logs(username, ip, project, result)

    return render(request, 'getdata.html', {'result': result})
Esempio n. 23
0
def add_job(request):
    user = request.user
    ip = request.META['REMOTE_ADDR']
    env = request.POST['env']
    queue = request.POST['queue_name']
    # timeout_ms = request.POST['timeout_ms']
    # replicate = request.POST['replicate']
    # retry_sec = request.POST['retry_sec']
    # delay_sec = request.POST['delay_sec']
    # ttl_sec = request.POST['ttl_sec']
    jobs = request.POST.getlist('jobs', [])
    # print user, env, queue, timeout_ms, replicate, retry_sec, delay_sec, ttl_sec
    print user, env, queue
    print jobs

    if not user.groups.filter(name__in=['admin', 'dba', 'disque']).exists():
        logs(user, ip, 'add job: %s - %s' % (env, queue), 'permission denied')
        return HttpResponse(json.dumps({'errcode': 403}),
                            content_type=default_content_type)
    if not (env in clientEnvMap.keys()):
        logs(user, ip, 'add job: %s - %s' % (env, queue),
             'unknown disque zone:%s' % env)
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'unknown disque zone:%s' % env
        }),
                            content_type=default_content_type)
    if (not queue) or len(queue) == 0:
        logs(user, ip, 'add job: %s - %s' % (env, queue), 'empty queue name')
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'emtpy queue name'
        }),
                            content_type=default_content_type)
    if len(jobs) == 0:
        logs(user, ip, 'add job: %s - %s' % (env, queue), 'empty jobs')
        return HttpResponse(json.dumps({
            'errcode': 400,
            'msg': 'empty jobs'
        }),
                            content_type=default_content_type)

    jobs = map(lambda x: x.encode('utf-8'), jobs)
    client = clientEnvMap[env]
    jobIds = []
    errJob = []
    for job in jobs:
        try:
            print job
            jobId = client.add_job(queue, job)
            # jobId = client.add_job(queue, job, timeout=timeout_ms, replicate=replicate, delay=delay_sec, retry=retry_sec, ttl=ttl_sec)
            jobIds.append(jobId)
        except Exception as e:
            print e
            errJob.append(job)
    logs(user, ip, 'add job: %s - %s' % (env, queue), 'success')
    return HttpResponse(json.dumps({
        'errcode': 200,
        'jobIds': jobIds,
        'failJobs': errJob
    }),
                        content_type=default_content_type)
Esempio n. 24
0
def handle_tickets(request):
    task_id = request.POST['id']
    submit = request.POST['submit']
    reply = request.POST['reply']
    operating_id = TicketTasks.objects.get(tasks_id=task_id)
    content = TicketTasks.objects.get(tasks_id=task_id).content
    content = json.loads(content)
    username = User.objects.get(username=content['handler'])
    phone_number = UserProfile.objects.get(user=username).phone_number  
    handle_result = 0

    if submit == 'reject':
        TicketTasks.objects.filter(tasks_id=task_id).update(state='4')
        TicketOperating.objects.create(operating_id=operating_id,handler=username,content=reply,result='2',submitter=content['owner'])
        
        logs(user=request.user,ip=request.META['REMOTE_ADDR'],action='handle ticket (%s)' % content['title'],result='successful')
        info = 'Your "%s" order be reject,please visit to workflow page.' % content['title']
        owner = User.objects.get(username=content['owner'])
        owner_phone_number = UserProfile.objects.get(user=owner).phone_number
        dingding_robo(phone_number=owner_phone_number,types=2,info=info)
        result = [{'HandleTasks':'The task_id handle to success!'}]
        return render(request,'getdata.html',{'result':result}) 

    if content['ticket_type'] == 'go':
        #'----------------------------ticket_type--------------------'
        for host in content['hosts']:
            data = {
                'client':'local',
                'tgt':host,
                'fun':'state.sls',
                'arg':['goservices.supervisor_submodule','pillar={"goprograme":"%s","svnrepo":"%s","supProgrameName":"%s","goRunCommand":"%s"}' % (content['project'],content['svn_repo'],content['supervisor_name'],content['go_command'])]
            }
            result = salt_api.salt_cmd(data)
            try:
                minion_host = minion.objects.get(saltname=host)    
                supervisor_info = gostatus.objects.get(hostname=minion_host)
                supervisor_obj = xmlrpclib.Server('http://%s:%s@%s:%s/RPC2' % (
                    supervisor_info.supervisor_username, supervisor_info.supervisor_password,
                    supervisor_info.supervisor_host, supervisor_info.supervisor_port))
                if supervisor_obj.supervisor.getProcessInfo(content['supervisor_name']):
                    deploy_result = 1
                    print '-------successful-----'
            except Exception, e:
                print e
                deploy_result = 0
                handle_result = 1
                TicketTasks.objects.filter(tasks_id=task_id).update(state='5')
                TicketOperating.objects.create(operating_id=operating_id,handler=username,content=reply,result='3',submitter=content['owner'])
                logs(user=request.user,ip=request.META['REMOTE_ADDR'],action='handle ticket (%s)' % content['title'],result='failed')
                info = 'The "%s" order is failed,please check in %s host.' % (content['title'],host)
                dingding_robo(phone_number=phone_number,types=2,info=info)
                result = [{'HandleTasks':'The task_id handle to failed!'}]
                print '------failed-------------'           
                return render(request,'getdata.html',{'result':result}) 
            
            #-------------------------new project-----------------------------------
            try:
                if deploy_result == 1:
                    if gogroup.objects.filter(name=content['project']):
                        print 'The %s project is existing!!' % content['project']
                    else:
                        obj = gogroup(name=content['project'])
                        obj.save()

                        project = gogroup.objects.get(name=content['project'])
                        obj = svn(username=svn_username,
                            password=svn_password,
                            repo=content['svn_repo'],
                            localpath=go_local_path + content['project'],
                            movepath=go_move_path + content['project'],
                            revertpath=go_revert_path,
                            executefile=go_local_path + content['project'] + '/' + content['project']
                            ,project=project)
                        obj.save()


                    #-------------------------gotemplate-----------------------------------
                    project = gogroup.objects.get(name=content['project'])
                    ip = minion_host.ip

                    if GOTemplate.objects.filter(hostname=minion_host).filter(project=project).filter(env=1):
                        print 'The %s gotemplate project is existing!!' % content['project']
                    else:
                        obj = GOTemplate(
                            username=svn_username,
                            password=svn_password,
                            repo=svn_gotemplate_repo,
                            localpath=svn_gotemplate_local_path,
                            env=1,
                            hostname=minion_host,
                            project=project)
                        obj.save()

                    #-------------------------goservices-----------------------------------
                    if goservices.objects.filter(saltminion=minion_host).filter(group=project).filter(name=content['supervisor_name']).filter(env=1):
                        print 'The %s goservice is existing!!' % content['supervisor_name']
                    else:
                        obj = goservices(
                            ip=ip,
                            name=content['supervisor_name'] ,
                            env=1,
                            group=project,
                            saltminion=minion_host,
                            owner=content['owner'],
                            has_statsd=content['statsd'],
                            has_sentry=content['sentry'],
                            comment=content['function'])
                        obj.save()                     
            except Exception, e:
                print e
                handle_result = 1
                TicketTasks.objects.filter(tasks_id=task_id).update(state='5')
                TicketOperating.objects.create(operating_id=operating_id,handler=username,content=reply,result='3',submitter=content['owner'])
                logs(user=request.user,ip=request.META['REMOTE_ADDR'],action='handle ticket (%s)' % content['title'],result='failed')
                result = [{'HandleTasks':'The task_id handle to failed!'}]
Esempio n. 25
0
def submit_tickets(request):
    tasks_info = ''
    title = request.POST['title']
    ticket_type = request.POST['ticket_type']
    handler = request.POST['handler']
    owner = str(request.user)
    if ticket_type == 'go':
        function = request.POST['function']
        hosts = request.POST.getlist('hosts')
        project = request.POST['project']
        project = project.strip()
        go_command = request.POST['go_command']
        supervisor_name = go_command.replace(" ", "_")
        svn_repo = svn_repo_url + project
        statsd = request.POST['statsd']
        sentry = request.POST['sentry']
        go_command = go_command + " -c /srv/gotemplate/%s/conf.ctmpl" % project
        
        salt_command = {
            "title":title,
            "ticket_type":ticket_type,
            "function":function,
            "hosts":hosts,
            "project":project,
            "svn_repo":svn_repo,
            "supervisor_name":supervisor_name,
            "go_command":go_command,
            "statsd":statsd,
            "sentry":sentry,
            "handler":handler,
            "owner":owner
        }
        ## create svn repo address
        if not gogroup.objects.filter(name=project):
            data = {
                'client':'local',
                'tgt': svn_host,
                'fun':'cmd.script',
                'arg':['salt://scripts/create_svn.sh',project] 
            }
            salt_result = salt_api.salt_cmd(data)
            if salt_result['return'][0][svn_host]['stdout'] == 'ok':
                tasks_info = 'Your project svn_repo is %s.\n\n' % (svn_repo)
                
            else:
                tasks_info = 'Error creating svn repo(%s),please tell ops..\n\n' % (svn_repo)
        else:
            tasks_info = 'Your project svn_repo is %s.\n\n' % (svn_repo)




    elif ticket_type == 'webpage':
        print '--------site_name-----:',request.POST.getlist('site_name')
        site_name = request.POST.getlist('site_name')
        salt_command = {
            "title":title,
            "ticket_type":ticket_type,
            "site_name":site_name,
            "handler":handler,
            "owner":owner
	    }
    elif ticket_type == 'uat_jenkins':
        print request.POST
        jenkins_name = request.POST['jenkins_name']
        uat_env = request.POST['uat_env']
        salt_command = {
            "title":title,
            "ticket_type":ticket_type,
            "uat_env": uat_env,
            "jenkins_name":jenkins_name,
            "handler":handler,
            "owner":owner
	    }
    try:
        salt_command = json.dumps(salt_command)
        ticket_type = TicketType.objects.get(type_name=ticket_type)
        handler = User.objects.get(username=handler)
        task_id = str(uuid.uuid1())
        TicketTasks.objects.create(tasks_id=task_id,title=title,ticket_type=ticket_type,creator=request.user,content=salt_command,handler=handler,state='1')
        tasks_info = tasks_info + 'The %s order submitted to success!' % task_id
        result = [{'TicketTasks':tasks_info}]
        logs(user=request.user,ip=request.META['REMOTE_ADDR'],action='add ticket (%s)' % title,result='successful')
        user = User.objects.get(username=handler)
                
        phone_number = UserProfile.objects.get(user=user).phone_number  
        info = 'You have a message,please visit to workflow page.'
        dingding_robo(phone_number=phone_number,types=2,info=info)
    except Exception, e:
        print e
        result = [{'TicketTasks':'The order submitted to failed!'}]
        logs(user=request.user,ip=request.META['REMOTE_ADDR'],action='add ticket (%s)' % title,result='failed')
Esempio n. 26
0
    def deploy(self, site, action='svn', revision='HEAD', group=None):
        self.action = action
        self.revision = revision
        if group:
            obj = groupName.objects.get(group_name=group).member.values()
        else:
            obj = []
            obj.append({'webSite': site})
        for s in obj:
            self.site = s['webSite']
            info = webSite.objects.filter(env=self.env).get(webSite=self.site)
            ip = []
            for i in info.checkUrl.values():
                ip.append(i['ip'])

            print '--------site--------------', info.webSite
            self.f.write('-----------------------%s---------------------\n' %
                         info.webSite)
            self.f.flush()
            for host in info.checkUrl.values():
                for m in info.state_module.values():
                    nginx_backup = self.__nginx_backup(ip, host['ip'],
                                                       host['host'],
                                                       m['state_module'], 0)
                    if nginx_backup == 1:
                        self.f.write(
                            'Step 1: blocking nginx traffic is failed.\n')
                        exit()
                self.f.write('Step 1: blocking nginx traffic is sucessful.\n')
                self.f.flush()
                if self.action in ['svn', 'revert']:
                    svn_up = self.__svn_update(host['host'], info.svn_path,
                                               info.svn_username,
                                               info.svn_password,
                                               self.revision)
                    if svn_up == 1:
                        self.f.write('error')
                        exit()
                    else:
                        self.f.write('Step 2: svn update is sucessful.\n')
                        self.f.flush()
                elif self.action == 'recycle':
                    pass

                recycle = self.__iis_recycle(host['host'], info.recycle_cmd,
                                             host['url'], self.action)
                if recycle == 1:
                    self.f.write('error')
                    exit()
                elif action == 'recycle':
                    self.f.write('Step 2: iis recycle is sucessful.\n')
                    self.f.flush()
                else:
                    self.f.write('Step 3: iis recycle is sucessful.\n')
                    self.f.flush()

            for m in info.state_module.values(
            ):  ######nginx all online########
                status = self.__nginx_backup(ip, host['ip'], host['host'],
                                             m['state_module'], 1)

                if status == 1:
                    logs(self.username, self.ip, self.site, 'Failed')
                    self.f.write('error')
                    exit()
            self.f.write('Last step: open nginx traffic is sucessful.\n')
            self.f.flush()
            logs(self.username, self.ip, self.site, 'Successful')
        self.f.write('done')
        self.f.flush()
        self.f.close()
        return self.result