def getdomains(self):
self.__warning = "\r\n".join([
'Attention: 腾讯云域名获取失败，请检查:'
'腾讯云URL: + %s' % tencent_url,
#'%s : %s' %(secretid, secretkey)
])
self.__params = {
'Action': 'DescribeCdnHosts',
'Nonce': random.randint(1, 1000000),
'SecretId': self.__secretid,
'Timestamp': int(time.time()),
}
self.signkey(self.__httpmethod)
url = "https://" + tencent_url
try:
ret = requests.post(url, data=self.__params, verify=False)
except Exception as e:
message['text'] = self.__warning + '\nException: ' + e.message
logger.error(message['text'])
sendTelegram(message).send()
return self.__params, False
else:
if ret.json()['code'] != 0:
message['text'] = self.__warning + '\n' + ret.json()['message']
logger.error(message['text'])
sendTelegram(message).send()
return ret.json(), False
else:
logger.info(str(self.__params) + ": 腾讯云域名获取成功！")
return ret.json(), True
def ExePost(self, uri, info):
url = self.__url + uri
self.__warning = "\r\n".join([
'@arno',
'Attention: %s 失败，请检查:' %info,
'URL: + %s' %url,
#'%s : %s' %(secretid, secretkey)
])
#logger.info(self.__data)
try:
ret = requests.post(url, data=self.__data, verify=False)
except Exception as e:
message['text'] = self.__warning + '\nException: ' + e.message
logger.error(message['text'])
sendTelegram(message).send()
return error, False
else:
result = ret.json()
if result['status']['code'] != "1":
message['text'] = self.__warning + '\n' + str(result['status'])
logger.error(message['text'])
sendTelegram(message).send()
return result, False
else:
logger.info("%s 成功！" %info)
return result, True
def purge(self, domains, uri="/"):
self.__params = {
'Action': 'RefreshCdnUrl',
'Nonce': random.randint(1, 1000000),
'SecretId': self.__secretid,
'Timestamp': int(time.time()),
}
self.signkey(self.__httpmethod, domains, uri)
url = "https://" + tencent_url
#logger.info(self.__params)
try:
ret = requests.post(url, data=self.__params, verify=False)
except Exception as e:
message[
'text'] = self.__warning + '\n%s | Exception: ' % url + e.message
logger.error(message['text'])
sendTelegram(message).send()
return self.__params, False
else:
if ret.json()['code'] != 0:
message['text'] = self.__warning + '\n%s: ' % url + ret.json(
)['message']
logger.error(message['text'])
sendTelegram(message).send()
return ret.json(), False
else:
logger.info(str(self.__params) + ": 缓存清理成功！")
return ret.json(), True
def purge(self, domains, uri='/'):
date = getDate()
headers = {'Date': date, 'Content-Type': 'application/json', 'Accept': 'application/json'}
url = 'http://open.chinanetcenter.com/ccm/purge/ItemIdReceiver'
signed_apikey = self.signApikey(date)
self.__warning = "\r\n".join([
'Attention: 网宿域名缓存清理失败，请检查:'
'网宿URL: + %s' %url,
#'headers: + %s' %headers,
'%s : %s' %(self.__username, signed_apikey)
])
#判断是目录刷新还是文件刷新
if uri == '/' or uri[-1] == '/':
type_f = 'dirs' #目录刷新
else:
type_f = 'urls' #文件刷新
data = {type_f: []} #需要刷新的域名或者文件链接
#格式化域名或者文件链接
for domain in domains:
data[type_f].append('%s%s' %(domain, uri))
#if domain['service-type'] == 'web-https':
# data[type_f].append('https://%s%s' %(domain['domain-name'], uri))
try:
ret = requests.post(url, headers=headers, auth=(self.__username, signed_apikey), data=json.dumps(data))
logger.info(str(ret.status_code)+': '+ret.content)
except Exception, e:
message['text'] = self.__warning + '\nException: ' + e.message
logger.error(message['text'])
sendTelegram(message).send()
return {}, False
def get_svn_lock_files(svn_master_id, excepts=[], key=None):
file_list = []
try:
svn_master = svn_master_t.objects.get(id=svn_master_id)
except Exception as e:
message['text'] = "@arno\r\nsvn master[id%s] 不存在\r\n%s" % (
svn_master_id, str(e))
logger.error(message['text'])
sendTelegram(message).send()
return False, file_list
else:
if key == "fenghuang_caipiao":
locks = svn_master.svn_gray_lock.all()
elif key == "fenghuang_zyp":
locks = svn_master.svnzyp_gray_lock.all()
elif key == "fenghuang_zyp_front":
locks = svn_master.svnzypfront_gray_lock.all()
elif key == "fenghuang_zyp_front2":
locks = svn_master.svnzypfront2_gray_lock.all()
else:
locks = []
for svn_record in locks:
isExcept = False
for excepti in excepts:
if svn_record.revision == excepti['revision']:
logger.info("排除svn锁: %s" % excepti['revision'])
isExcept = True
break
if isExcept: continue
for change in svn_record.changelist[1:-1].split('], ['):
file_list.append(change.split('\'')[3])
return True, file_list
def DeleteZoneRecord(self, zone_id, record_id):
'''
删除解析记录
'''
result = {}
url = self.__url + '/%s/' % zone_id + 'dns_records/' + record_id
self.__warning = "\r\n".join([
'@arno',
'Attention: CF域名解析删除失败，请检查:',
'URL: + %s' % url,
#'%s : %s' %(secretid, secretkey)
])
try:
ret = requests.delete(url, headers=self.__headers, verify=False)
result = ret.json()
except Exception as e:
result = {'result': None, 'errors': str(e), 'success': False}
if not result['success']:
message['text'] = self.__warning + '\n' + str(result)
logger.error(message['text'].replace('\r\n', '\n'))
sendTelegram(message).send()
return result
def purge(self, zone_id):
'''
清理缓存："purge_everything":true
'''
result = {}
data = {"purge_everything": True}
url = self.__url + '/%s/' % zone_id + 'purge_cache'
self.__warning = "\r\n".join([
'@arno',
'Attention: CF域名缓存清理失败，请检查:',
'URL: + %s' % url,
#'%s : %s' %(secretid, secretkey)
])
try:
ret = requests.post(url,
data=json.dumps(data),
headers=self.__headers,
verify=False)
result = ret.json()
except Exception as e:
result = {'result': None, 'errors': str(e), 'success': False}
if not result['success']:
message['text'] = self.__warning + '\n' + str(result)
logger.error(message['text'].replace('\r\n', '\n'))
sendTelegram(message).send()
return result
def getdomains(self):
date = getDate()
headers = {'Date': date, 'Accept': 'application/json'}
url = 'https://open.chinanetcenter.com/api/domain'
signed_apikey = self.signApikey(date)
self.__warning = "\r\n".join([
'Attention: 网宿域名获取失败，请检查:'
'网宿URL: + %s' % url,
#'headers: + %s' %headers,
'%s : %s' % (self.__username, signed_apikey)
])
try:
ret = requests.get(url,
headers=headers,
auth=(self.__username, signed_apikey))
except Exception as e:
message['text'] = self.__warning + '\nException: ' + e.message
logger.error(message['text'])
sendTelegram(message).send()
return {}, False
else:
if ret.status_code != 200:
message['text'] = self.__warning + '\n' + str(
ret.content.replace('<', '<').replace('>', '>'))
logger.error(message['text'])
sendTelegram(message).send()
return ret.content, False
else:
logger.info("网宿域名获取成功！")
return ret.json(), True
def getdomains(self, product=[]):
'''
通过aws 特有的标签，识别所需要的配置
'''
product = self.__product
# 建立aws 客户端
client = self.createCli()
# 警告信息
self.__warning = "\r\n".join([
'Attention: aws域名获取失败，请检查:',
'aws账号: + %s' % self.__username,
])
# 获取分发内容的列表
try:
ret = client.list_distributions()
except Exception as e:
content = self.__warning + '\r\n' + str(e).replace(
'<', '<').replace('>', '>')[:2047]
sendTelegramAlert(content)
return [], False
# 对域名进行筛选
try:
if ret['ResponseMetadata'][
'HTTPStatusCode'] != 200 or 'DistributionList' not in ret.keys(
):
content = self.__warning + '\r\n' + str(ret).replace(
'<', '<').replace('>', '>')[:2047]
sendTelegramAlert(content)
return [], False
except Exception as e:
message['text'] = self.__warning + '\r\n' + str(e).replace(
'<', '<').replace('>', '>')[:2047]
logger.error(message['text'])
sendTelegram(message).send()
return [], False
else:
tmplist = []
for item in ret['DistributionList']['Items']:
li = item['Comment'].replace(' ', '').split('-') # 获取注释，并拆分为列表
if len(li) < 2: continue
if li[0] in product: # 如果产品在所新人的列表中，则录入
tmpdict = {
'item': item,
'Id': item['Id'],
'domains': item['Aliases']['Items'],
'product': li[0],
'customer': li[1],
}
tmplist.append(tmpdict)
logger.info("%s: aws 账号 cdn云域名获取成功。" % self.__username)
return tmplist, True
def sendTelegramRe(message):
#message['group'] = 'arno_test'
if len(message["text"]) > 10:
message["text"] = '\n'.join(message["text"])
message["doc"] = True
message['doc_name'] = 'domain.txt'
else:
message["doc"] = False
message["text"] = '\r\n'.join(message["text"]) +'\r\n'+ message['caption']
sendTelegram(message).send()
def ExePost(self, uri, info):
url = self.__url + uri
self.__warning = "\r\n".join([
'@arno',
'Attention: %s 失败，请检查:' %info,
'URL: + %s' %url,
#'%s : %s' %(secretid, secretkey)
])
#logger.info(self.__data)
try:
ret = requests.post(url, data=self.__data, verify=False, timeout=15)
except Exception, e:
message['text'] = self.__warning + '\nException: ' + str(e.message)
logger.error(message['text'])
sendTelegram(message).send()
return str(e.message), False
def getdomains(self):
date = getDate()
headers = {'Date': date, 'Accept': 'application/json'}
url = 'https://open.chinanetcenter.com/api/domain'
signed_apikey = self.signApikey(date)
self.__warning = "\r\n".join([
'Attention: 网宿域名获取失败，请检查:'
'网宿URL: + %s' %url,
#'headers: + %s' %headers,
'%s : %s' %(self.__username, signed_apikey)
])
try:
ret = requests.get(url, headers=headers, auth=(self.__username, signed_apikey))
except Exception, e:
message['text'] = self.__warning + '\nException: ' + e.message
logger.error(message['text'])
sendTelegram(message).send()
return {}, False
def CreateZoneRecord(self,
zone_id,
record_type,
record_name,
record_content,
proxied=False):
'''
新增解析记录，{'type':'A', 'name':'example.com', 'content': '127.0.0.1', 'proxied':false}
'''
datas = {
'type': record_type,
'name': record_name,
'content': record_content,
'proxied': proxied
}
result = {}
url = self.__url + '/%s/' % zone_id + 'dns_records'
self.__warning = "\r\n".join([
'@arno',
'Attention: CF域名解析新增失败，请检查:',
'URL: + %s' % url,
#'%s : %s' %(secretid, secretkey)
])
try:
ret = requests.post(url,
data=json.dumps(datas),
headers=self.__headers,
verify=False)
result = ret.json()
except Exception as e:
result = {'result': None, 'errors': str(e), 'success': False}
if not result['success']:
message['text'] = self.__warning + '\n' + str(result)
logger.error(message['text'].replace('\r\n', '\n'))
sendTelegram(message).send()
return result
def SendTelegram(request):
title = u'发送telegram信息'
if request.META.has_key('HTTP_X_FORWARDED_FOR'):
clientip = request.META['HTTP_X_FORWARDED_FOR']
else:
clientip = request.META['REMOTE_ADDR']
logger.info('%s is requesting %s' % (clientip, request.get_full_path()))
if request.method == 'POST':
try:
message = json.loads(request.body)
if not isinstance(message, dict):
logger.error('%s is not dict.' % message)
s = sendTelegram({
'text': clientip + ': 发送telegram信息失败，参数不是字典！',
'bot': 'sa_monitor_bot',
'group': 'arno_test'
}) #arno_test
if s.send():
return HttpResponse(content='参数错误！', status=500)
else:
return HttpResponse(content='telegram 发送失败！', status=502)
except Exception as e:
logger.error(e.message)
s = sendTelegram({
'text': clientip + ': 发送telegram信息失败！\r\n' + e.message,
'bot': 'sa_monitor_bot',
'group': 'arno_test'
}) #arno_test
if s.send():
return HttpResponse(content='参数错误！', status=500)
else:
return HttpResponse(content='telegram 发送失败！', status=502)
s = sendTelegram(message)
if s.send():
return HttpResponse('发送成功！')
else:
return HttpResponse(content='telegram 发送失败，参数错误！', status=502)
else:
return HttpResponse(status=403)
def sendAlert(ip, results):
java = ""
ruiying = ""
fenghuang = ""
for result in results:
if result[0] == 26:
java += '\r\n' + result[1]
elif result[0] == 27:
ruiying += '\r\n' + result[1]
else:
fenghuang += '\r\n' + result[1]
if java:
message['doc'] = False
message['text'] = ip + java
message['group'] = 'java_domain' #java_domain
if len(message['text']) >= 4096:
message['doc'] = True
message['text'] = message['text'].replace('\r\n', '\n')
sendTelegram(message).send()
if ruiying:
message['doc'] = False
message['text'] = ip + ruiying
message['group'] = 'arno_test' #ruiying_domain
if len(message['text']) >= 4096:
message['doc'] = True
message['text'] = message['text'].replace('\r\n', '\n')
sendTelegram(message).send()
if fenghuang:
message['doc'] = False
message['text'] = ip + fenghuang
message['group'] = 'domain_alert' #domain_alert
if len(message['text']) >= 4096:
message['doc'] = True
message['text'] = message['text'].replace('\r\n', '\n')
sendTelegram(message).send()
def GetCdnMiddleSourceList(self):
self.__warning = "\r\n".join([
'Attention: 腾讯云中间源ip列表获取失败，请检查:'
'腾讯云URL: + %s' % tencent_url,
#'%s : %s' %(secretid, secretkey)
])
self.__params = {
'Action': 'GetCdnMiddleSourceList',
'Nonce': random.randint(1, 1000000),
'SecretId': self.__secretid,
'Timestamp': int(time.time()),
}
self.signkey(self.__httpmethod)
url = "https://" + tencent_url
#logger.info(self.__params)
try:
ret = requests.post(url, data=self.__params, verify=False)
except Exception, e:
message[
'text'] = self.__warning + '\n%s | Exception: ' % url + e.message
logger.error(message['text'])
sendTelegram(message).send()
return self.__params, False
def GetLog(self, limit=1):
'''
获取svn 提交日志
'''
logger.info("需要获取的日志是 %d 条" % limit)
log_list = []
try:
info = self.conn.log_default(limit=limit, changelist=True)
#logger.info(info)
except Exception as e:
message['text'] = '@arno\r\n%s: 获取svn信息失败！\r\n%s' % (self.__url,
str(e))
#logger.error(message['text'])
sendTelegram(message).send()
else:
for i in range(limit):
try:
t = info.next()
except Exception as e:
continue
if not t: break
tmpdict = {
'revision':
t.revision,
'author':
t.author,
'date':
t.date.astimezone(
get_localzone()).strftime('%Y/%m/%d %H:%M:%S'),
'log':
t.msg,
'changelist':
t.changelist,
}
log_list.append(tmpdict)
return log_list
def receive(self, text=None, bytes=None, **kwargs):
"""
Called when a message is received with either text or bytes
filled out.
"""
#self.close()
self.clientip = '127.0.0.1'
self.username = self.message.user.username
try:
self.role = self.message.user.userprofile.role
except:
self.role = 'none'
data = json.loads(self.message['text'])
step = 0
### step one ###
info = {}
info['step'] = 'one'
self.message.reply_channel.send({'text': json.dumps(info)})
### final step ###
info = {}
info['step'] = 'final'
info['results'] = {}
svn_customer_dict = {}
count = 1
for customer_id in data['customer']:
customer_name = 'none'
for value in data['item']['svn_customer']['in']:
if int(customer_id) == value['id']:
customer_name = value['name']
break
try:
svn_customer = svn_customer_t.objects.get(id=customer_id)
except Exception as e:
message[
'text'] = "所选中的客户[%s] 记录不存在，请联系管理员！" % customer_name + '\nException: ' + str(
e)
logger.error(message['text'])
sendTelegram(message).send()
info['results'][data['minion_id'] + '-' +
str(count)] = message['text']
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
count += 1
else:
if svn_customer.iscrond != 1:
message[
'text'] = "所选中的客户[%s] 不支持同步计划任务，请联系管理员！" % customer_name + '\nException: ' + str(
e)
logger.error(message['text'])
sendTelegram(message).send()
info['results'][data['minion_id'] + '-' +
str(count)] = message['text']
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
count += 1
svn_customer_dict[svn_customer.name] = {
'master_ip': [
ip.strip()
for ip in svn_customer.master_ip.split('\r\n')
if ip.strip() != ""
],
'ip': [
ip.strip()
for ip in svn_customer.crond_ip.split('\r\n')
if ip.strip() != ""
],
'port':
svn_customer.port,
'ismaster':
True if svn_customer.ismaster == 1 else False,
'crond_file':
svn_customer.crond_file,
}
try:
svn_master = svn_master_t.objects.get(id=data['svn_master_id'])
api = svn_master.api.strip('/') + '/crond_config'
logger.info('posting: %s' % api)
#logger.info('posting: %s' %svn_customer_dict)
ret = requests.post(api, data=json.dumps(svn_customer_dict))
except Exception as e:
message['text'] = 'Exception: ' + str(e)
logger.error(message['text'])
sendTelegram(message).send()
info['results'][data['minion_id']] = message['text']
else:
info['results'][data['minion_id']] = ret.content
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
def receive(self, text=None, bytes=None, **kwargs):
"""
Called when a message is received with either text or bytes
filled out.
"""
#self.close()
self.clientip = '127.0.0.1'
self.username = self.message.user.username
try:
self.role = self.message.user.userprofile.role
except:
self.role = 'none'
data = json.loads(self.message['text'])
step = 0
### step one ###
info = {}
info['step'] = 'one'
self.message.reply_channel.send({'text': json.dumps(info)})
### final step ###
info = {}
info['step'] = 'final'
info['results'] = {}
svn_customer_dict = {}
info['results'][data['minion_id']] = ""
#给升级的产品上锁
project = project_t.objects.get(id=data['id'])
if project.svn_mst_lock == 1:
info['results'][
data['minion_id']] = "此环境的升级已被锁，请等待其他人升级完成，或者请联系管理员！"
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
else:
project.svn_mst_lock = 1
project.save()
#获取需要同步的客户
svn_customer_l = []
for svn_customer_name in data['customer']['real']:
#customer_name = svn_customer_name.split(',')[0]
#info['results'][data['minion_id']] += name + '\r\n'
count = 1
for customer_name in svn_customer_name.split(','):
customer_name = customer_name.strip()
#if count > 1: continue
try:
svn_customer = svn_customer_t.objects.get(
name=customer_name)
except Exception as e:
message[
'text'] = "所选中的客户[%s] 记录不存在，请联系管理员！" % customer_name + '\nException: ' + str(
e)
logger.error(message['text'])
sendTelegram(message).send()
info['results'][data['minion_id']] = message['text']
project.svn_mst_lock = 0
project.save()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
else:
#if svn_customer.isrsynccode == 0: continue
svn_customer_l.append(svn_customer)
svn_customer_dict[svn_customer.name] = {
'master_ip': [
ip.strip()
for ip in svn_customer.master_ip.split('\r\n')
if ip.strip() != ""
],
'ip': [
ip.strip() for ip in svn_customer.ip.split('\r\n')
if ip.strip() != ""
] if count == 1 else [],
'port':
svn_customer.port,
'ismaster':
True if svn_customer.ismaster == 1 else False,
'isrsynccode':
True if count == 1 else False,
'cmd': [
cmd.strip()
for cmd in svn_customer.cmd.split('\r\n')
if cmd.strip() != ""
],
'gray_domain':
svn_customer.gray_domain,
'online_domain':
svn_customer.online_domain,
'src_d':
svn_customer.src_d,
'dst_d':
svn_customer.dst_d,
}
count += 1
#调用接口执行代码同步
numAll = len(svn_customer_dict)
#logger.info(numAll)
numExe = 0
numCon = 1
customerNameList = svn_customer_dict.keys()
while numExe < numAll:
try:
svn_master = svn_master_t.objects.get(id=data['svn_master_id'])
api = svn_master.api.strip('/') + '/remote/execute'
logger.info('posting: %s' % api)
ret = requests.post(api,
data=json.dumps({
'author':
self.username.replace('_', ''),
'svn_customer_dict':
svn_customer_dict,
'customers':
customerNameList[numExe:numExe +
numCon],
'script':
data['script'].split('\n'),
}))
logger.info(customerNameList[numExe:numExe + numCon])
numExe += numCon
except Exception as e:
message['text'] = api + '\nException: ' + str(e)
logger.error(message['text'])
sendTelegram(message).send()
info['results'][data['minion_id']] = message['text']
else:
info['results'][data['minion_id']] += ret.content
#给升级的产品解锁
project.svn_mst_lock = 0
project.save()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
def receive(self, text=None, bytes=None, **kwargs):
"""
Called when a message is received with either text or bytes
filled out.
"""
#self.close()
self.clientip = '127.0.0.1'
self.username = self.message.user.username
try:
self.role = self.message.user.userprofile.role
except:
self.role = 'none'
data = json.loads(self.message['text'])
step = 0
### step one ###
info = {}
info['step'] = 'one'
self.message.reply_channel.send({'text': json.dumps(info)})
### final step ###
info = {}
info['step'] = 'final'
info['results'] = {}
svn_customer_dict = {}
info['results'][data['minion_id']] = ""
#获取需要同步的文件
svn_files = []
svn_files_all = []
for svn_record in data['svn_records']:
changelist = svn_record['changelist']
if not isinstance(changelist, list):
for i in changelist[1:-1].split('], ['):
svn_files.append([i.split('\'')[1], i.split('\'')[3]])
svn_files_all.append([i.split('\'')[1], i.split('\'')[3]])
else:
svn_files += changelist
svn_files_all += changelist
# 这里做一个判断，如果升级文件超过一定数量，通知升级人员考虑全目录升级
limit = 20
if len(svn_files_all) > limit and self.username not in ['phexus_sa', 'arno']:
# if len(svn_files_all) > limit:
message['text'] = "升级文件数量: %s。超过 %s, 请考虑是否选择目录升级，或者联系管理员！" %(len(svn_files_all), limit)
info['results'][data['minion_id']] = message['text']
logger.error(message['text'])
sendTelegram(message).send()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
#给升级的产品上锁
project = project_t.objects.get(id=data['id'])
if project.svn_mst_lock == 1:
info['results'][data['minion_id']] = "此环境的升级已被锁，请等待其他人升级完成，或者请联系管理员！"
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
else:
project.svn_mst_lock = 1
project.save()
#给升级到灰度的svn 文件上锁以及解锁
if len(data['codeEnv']) == 1 and data['codeEnv'][0] == 'gray_env':
if data['end'] == 'front':
sr = svn_zyp_front_gray_lock_t()
elif data['end'] == 'front2':
sr = svn_zyp_front2_gray_lock_t()
for svn_record in data['svn_records']:
sr.revision = svn_record['revision']
sr.author = svn_record['author']
sr.date = svn_record['date']
sr.log = svn_record['log']
sr.changelist = svn_record['changelist']
try:
sr.save()
except Exception as e:
logger.error(str(e))
logger.error("svn 记录锁已存在：%s" %svn_record)
if data['end'] == 'front':
sr = svn_zyp_front_gray_lock_t.objects.get(revision=svn_record['revision'])
elif data['end'] == 'front2':
sr = svn_zyp_front2_gray_lock_t.objects.get(revision=svn_record['revision'])
else:
logger.info("svn 记录锁：%s" %svn_record)
try:
svn_master = svn_master_t.objects.get(id=data['svn_master_id'])
if data['end'] == 'front':
svn_master.svnzypfront_gray_lock.add(sr)
elif data['end'] == 'front2':
svn_master.svnzypfront2_gray_lock.add(sr)
except Exception as e:
message['text'] = "@arno\r\nsvn 记录锁 存入svn master 失败：%s\r\n%s" %(svn_record, str(e))
info['results'][data['minion_id']] = "svn 记录锁 存入svn master 失败：%s\r\n%s" %(svn_record, str(e))
logger.error(message['text'])
sendTelegram(message).send()
project.svn_mst_lock = 0
project.save()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
#info['results'][data['minion_id']] = "svn 记录锁 存入svn master 成功：%s" %svn_record
elif len(data['codeEnv']) == 1 and data['codeEnv'][0] == 'online_env':
#判断是否存在文件冲突
islock = False
status, svn_lock_files = get_svn_lock_files(data['svn_master_id'], data['svn_records'], data['key'])
logger.info(svn_lock_files)
for fileT in svn_files:
if is_file_in_list(fileT[1], svn_lock_files):
islock = True
logger.info(fileT[1])
info['results'][data['minion_id']] += str(fileT)
if islock:
info['results'][data['minion_id']] = "文件锁存在，无法将灰度升级到运营：\r\n%s" %info['results'][data['minion_id']]
logger.info(info['results'][data['minion_id']])
project.svn_mst_lock = 0
project.save()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
#判断是需要将灰度锁删除
if int(data['isdeletegraylock'][0]) == 1:
for svn_record in data['svn_records']:
try:
if data['key'] == "fenghuang_caipiao":
sr = svn_gray_lock_t.objects.filter(revision=svn_record['revision']).delete()
elif data['key'] == "fenghuang_zyp":
sr = svn_zyp_lottery_gray_lock_t.objects.filter(revision=svn_record['revision']).delete()
elif data['key'] == "fenghuang_zyp_front":
sr = svn_zyp_front_gray_lock_t.objects.filter(revision=svn_record['revision']).delete()
elif data['key'] == "fenghuang_zyp_front2":
sr = svn_zyp_front2_gray_lock_t.objects.filter(revision=svn_record['revision']).delete()
except Exception as e:
info['results'][data['minion_id']] = "svn 记录锁删除失败：%s" %svn_record
logger.error(info['results'][data['minion_id']])
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
else:
pass
#info['results'][data['minion_id']] = "svn 记录锁删除成功：%s" %svn_record
#logger.info(info['results'][data['minion_id']])
elif len(data['codeEnv']) == 2:
#判断是否存在文件冲突
islock = False
status, svn_lock_files = get_svn_lock_files(data['svn_master_id'], key=data['key'])
#logger.info(svn_lock_files)
for fileT in svn_files:
if is_file_in_list(fileT[1], svn_lock_files):
islock = True
info['results'][data['minion_id']] += str(fileT)
if islock:
info['results'][data['minion_id']] = "文件锁存在，无法直接升级到运营：\r\n%s" %info['results'][data['minion_id']]
logger.info(info['results'][data['minion_id']])
project.svn_mst_lock = 0
project.save()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
else:
info['results'][data['minion_id']] = "要升级的环境[%s]不存在，请联系管理员！" %data['codeEnv']
logger.error(info['results'][data['minion_id']])
project.svn_mst_lock = 0
project.save()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
#获取需要同步的客户
svn_customer_l = []
for svn_customer_name in data['customer']['real']:
#customer_name = svn_customer_name.split(',')[0]
#info['results'][data['minion_id']] += name + '\r\n'
count = 1
for customer_name in svn_customer_name.split(','):
customer_name = customer_name.strip()
try:
svn_customer = svn_customer_t.objects.get(name=customer_name)
except Exception as e:
message['text'] = "所选中的客户[%s] 记录不存在，请联系管理员！" %customer_name + '\nException: ' + str(e)
logger.error(message['text'])
sendTelegram(message).send()
info['results'][data['minion_id']] = message['text']
project.svn_mst_lock = 0
project.save()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
return False
else:
if svn_customer.isrsynczypcode == 0: continue
svn_customer_l.append(svn_customer)
svn_customer_dict[svn_customer.name] = {
'master_ip': [ ip.strip() for ip in svn_customer.master_ip.split('\r\n') if ip.strip() != "" ],
'ip': [ ip.strip() for ip in svn_customer.ip.split('\r\n') if ip.strip() != "" ],
'port': svn_customer.port,
'ismaster': True if svn_customer.iszypmaster == 1 else False,
'isrsynccode': True if count == 1 else False,
'cmd': [cmd.strip() for cmd in svn_customer.cmd.split('\r\n') if cmd.strip() != "" ],
'gray_domain': svn_customer.gray_domain,
'online_domain': svn_customer.online_domain,
'src_d': svn_customer.src_d,
'dst_d': svn_customer.dst_d,
'minion': [ minion.strip() for minion in svn_customer.minion.split('\r\n') if minion.strip() != "" ],
}
#获取minion ssh 登陆信息
minion_dict = {}
for minion_id in svn_customer_dict[svn_customer.name]['minion']:
try:
minion = minion_t.objects.get(minion_id=minion_id, status=1)
except Exception as e:
continue
else:
if not minion: continue
minion_dict[minion_id] = {
'ip': [],
'user': minion.user,
'port': minion.port,
}
minion_l = minion_ip_t.objects.filter(minion_id=minion_id).all()
minion_dict[minion_id]['ip'] = [ minion.ip_addr for minion in minion_l if minion.status == 1 and minion.alive == 1 ]
svn_customer_dict[svn_customer.name]['minion'] = minion_dict
count += 1
#获取需要通知的部门同事
atUsers = {}
for id in data['department']:
department = department_user_t.objects.get(id=int(id), status=1)
atUsers[department.name] = {
'department': department.department,
'atUsers': department.AtUsers(),
}
#执行代码同步
# if platform.system() != "Linux":
# message['text'] = "请在 linux 环境里面进行代码同步。"
# logger.error(message['text'])
# sendTelegram(message).send()
# info['results'][data['minion_id']] = message['text']
# project.svn_mst_lock = 0
# project.save()
# self.message.reply_channel.send({'text': json.dumps(info)})
# self.close()
# return False
# 调用接口执行代码同步
while len(svn_files) !=0 or int(data['isrsyncwhole'][0]) == 1:
#svn_files_c = svn_files[:20]
#svn_files = svn_files[20:]
svn_files_c = svn_files_all
svn_files = []
try:
svn_master = svn_master_t.objects.get(id=data['svn_master_id'])
api = svn_master.front_api.strip('/') + '/svn_code'
logger.info('posting: %s' %api)
logger.info('posting: %d' %int(data['isrsyncwhole'][0]))
ret = requests.post(api, data=json.dumps({
'author': self.username.replace('_', ''),
'svn_records': data['svn_records'],
'changelist_c': svn_files_c,
'changelist': svn_files_all,
'code_env': data['codeEnv'],
'isrsyncwhole': int(data['isrsyncwhole'][0]),
'svn_customer_dict': svn_customer_dict,
'atUsers': atUsers,
'end': data['end'],
}))
except Exception as e:
message['text'] = api + '\nException: ' + str(e)
logger.error(message['text'])
sendTelegram(message).send()
info['results'][data['minion_id']] = message['text']
else:
info['results'][data['minion_id']] += ret.content
break
#更新svn记录
# if data['key'] == "fenghuang_caipiao":
# for svn_record in data['svn_records']:
# if len(data['codeEnv']) == 1 and data['codeEnv'][0] == 'gray_env':
# updateSvnRecord(revision=svn_record['revision'], svn_gray_l=svn_customer_l)
# elif len(data['codeEnv']) == 1 and data['codeEnv'][0] == 'online_env':
# updateSvnRecord(revision=svn_record['revision'], svn_online_l=svn_customer_l)
# elif len(data['codeEnv']) == 2:
# updateSvnRecord(revision=svn_record['revision'], svn_gray_l=svn_customer_l, svn_online_l=svn_customer_l)
#给升级的产品解锁
project.svn_mst_lock = 0
project.save()
self.message.reply_channel.send({'text': json.dumps(info)})
self.close()
def sendTelegramAlert(self, content=""):
message['text'] = content
logger.error(message['text'])
sendTelegram(message).send()
'%s : %s' %(self.__username, signed_apikey)
])
try:
ret = requests.get(url, headers=headers, auth=(self.__username, signed_apikey))
except Exception, e:
message['text'] = self.__warning + '\nException: ' + e.message
logger.error(message['text'])
sendTelegram(message).send()
return {}, False
else:
if ret.status_code != 200:
message['text'] = self.__warning + '\n' + str(ret.content.replace('<', '<').replace('>', '>'))
logger.error(message['text'])
sendTelegram(message).send()
return ret.content, False
else:
logger.info("网宿域名获取成功！")
return ret.json(), True
def purge(self, domains, uri='/'):
date = getDate()
headers = {'Date': date, 'Content-Type': 'application/json', 'Accept': 'application/json'}
url = 'http://open.chinanetcenter.com/ccm/purge/ItemIdReceiver'
signed_apikey = self.signApikey(date)
self.__warning = "\r\n".join([
'Attention: 网宿域名缓存清理失败，请检查:'
'网宿URL: + %s' %url,
#'headers: + %s' %headers,
def UpdateServers(request):
if request.is_websocket():
clientip = getIp(request)
username = request.user.username
try:
role = request.user.userprofile.role
except:
role = 'none'
if not username:
request.websocket.send('userNone')
logger.info('user: 用户名未知 | [WS]%s is requesting. %s' %
(clientip, request.get_full_path()))
### close websocket ###
request.websocket.close()
logger.info('user:%s | [WS]%s is requesting. %s' %
(username, clientip, request.get_full_path()))
for postdata in request.websocket:
if not postdata:
### close websocket ###
request.websocket.close()
break
data = json.loads(postdata)
step = 0
for record in data['records']:
step += 1
return_info = {}
return_info['record'] = record
return_info['step'] = step
return_info['info'] = ""
return_info['permission'] = True
return_info['result'] = True
#判断是否有权限
if not HasServerPermission(request, record, "change"):
return_info['permission'] = False
return_info['result'] = False
request.websocket.send(json.dumps(return_info))
### close websocket ###
request.websocket.close()
break
#修改密码
cmd = 'echo "%s" |passwd root --stdin' % data[
'password'].replace('`', '\`') # `这个符号在Linux命令行有特殊含义，需要转义
result = Command(record['minion_id'], 'cmd.run', cmd,
'glob').CmdRun()[record['minion_id']]
if 'all authentication tokens updated successfully' not in result:
return_info['result'] = False
return_info['info'] = result
request.websocket.send(json.dumps(return_info))
continue
#密码加密并存放
crypto, status = encryptPasswd(data['password'], record)
if not status:
return_info['result'] = False
return_info['info'] = "密码修改成功，但是密码加密失败：" + result
message['text'] = "@arno\r\n" + return_info['info']
sendTelegram(message).send()
request.websocket.send(json.dumps(return_info))
continue
try:
update = minion_t.objects.get(
minion_id=record['minion_id'])
update.password = crypto
update.save()
except Exception as e:
sendTelegram(message).send()
return_info['result'] = False
return_info['info'] = "密码修改成功，但是密码存入失败：" + str(e)
message['text'] = "@arno\r\n" + return_info['info']
sendTelegram(message).send()
request.websocket.send(json.dumps(return_info))
continue
request.websocket.send(json.dumps(return_info))
### close websocket ###
request.websocket.close()
else:
return HttpResponseForbidden('nothing!')
def receive(self, text=None, bytes=None, **kwargs):
"""
Called when a message is received with either text or bytes
filled out.
"""
#self.close()
self.clientip = '127.0.0.1'
self.username = self.message.user.username
try:
self.role = self.message.user.userprofile.role
except:
self.role = 'none'
data = json.loads(self.message['text'])
step = 0
for record in data['records']:
step += 1
return_info = {}
return_info['record'] = record
return_info['step'] = step
return_info['info'] = ""
return_info['permission'] = True
return_info['result'] = True
#判断是否有权限
if not HasServerPermission(self.message, record, "change"):
return_info['permission'] = False
return_info['result'] = False
self.message.reply_channel.send(
{'text': json.dumps(return_info)})
### close websocket ###
self.close()
break
#修改密码
cmd = 'echo "%s" |passwd root --stdin' % data['password'].replace(
'`', '\`') # `这个符号在Linux命令行有特殊含义，需要转义
result = Command(record['minion_id'], 'cmd.run', cmd,
'glob').CmdRun()[record['minion_id']]
if 'all authentication tokens updated successfully' not in result:
return_info['result'] = False
return_info['info'] = result
self.message.reply_channel.send(
{'text': json.dumps(return_info)})
continue
#密码加密并存放
crypto, status = encryptPasswd(data['password'], record)
if not status:
return_info['result'] = False
return_info['info'] = "密码修改成功，但是密码加密失败：" + result
message['text'] = "@arno\r\n" + return_info['info']
sendTelegram(message).send()
self.message.reply_channel.send(
{'text': json.dumps(return_info)})
continue
try:
update = minion_t.objects.get(minion_id=record['minion_id'])
update.password = crypto
update.save()
except Exception as e:
sendTelegram(message).send()
return_info['result'] = False
return_info['info'] = "密码修改成功，但是密码存入失败：" + str(e)
message['text'] = "@arno\r\n" + return_info['info']
sendTelegram(message).send()
self.message.reply_channel.send(
{'text': json.dumps(return_info)})
continue
self.message.reply_channel.send({'text': json.dumps(return_info)})
self.close()
class CfApi(object):
def __init__(self, url, email, key):
self.__url = url.rstrip('/')
self.__email = email
self.__key = key
self.__headers = {
'X-Auth-Email': self.__email,
'X-Auth-Key': self.__key,
'Content-Type': 'application/json'
}
def GetDnsLists(self,
page=1,
status='active',
match='all',
order='name',
direction='asc'):
url = self.__url + '?per_page=50&page=%s&status=%s&match=%s&order=%s&direction=%s' % (
page, status, match, order, direction)
try:
ret = requests.get(url, headers=self.__headers, verify=False)
return ret.json()
except Exception as e:
logger.error("获取CF dns列表失败: %s" % str(e))
return {u'result': [str(e)], u'success': False}
def GetZoneId(self, zone):
url = self.__url + '?name=%s' % (zone)
try:
ret = requests.get(url, headers=self.__headers, verify=False)
zone_id = ret.json()['result'][0]['id']
#logger.info(ret.json())
return {u'zone_id': zone_id}
except:
return {u'zone_id': None}
def GetDnsRecord(self, zone, record_name):
self.__zone_id = self.GetZoneId(zone)['zone_id']
self.__record_id = self.GetDnsRecordId(self.__zone_id, record_name)
url = self.__url + '/%s/' % self.__zone_id + 'dns_records/%s' % self.__record_id
#logger.info(url)
try:
ret = requests.get(url, headers=self.__headers, verify=False)
return ret.json()
except:
return False
def GetZoneRecords(self, zone_id):
url = self.__url + '/%s/' % zone_id + 'dns_records?per_page=100'
try:
ret = requests.get(url, headers=self.__headers, verify=False)
return ret.json()
except:
return {'result': []}
def GetDnsRecordId(self, zone_id, record_name):
self.__record_id = ''
url = self.__url + '/%s/' % zone_id + 'dns_records?per_page=100&name=%s' % record_name
try:
ret = requests.get(url, headers=self.__headers, verify=False)
#logger.info(ret.json())
if len(ret.json()['result']) == 0:
pass
elif len(ret.json()['result']) == 1:
self.__record_id = ret.json()['result'][0]['id']
else:
self.__record_id = 'id more than one'
except:
self.__record_id = 'bad arguments'
return self.__record_id
def CreateZoneRecord(self,
zone_id,
record_type,
record_name,
record_content,
proxied=False):
'''
新增解析记录，{'type':'A', 'name':'example.com', 'content': '127.0.0.1', 'proxied':false}
'''
datas = {
'type': record_type,
'name': record_name,
'content': record_content,
'proxied': proxied
}
result = {}
url = self.__url + '/%s/' % zone_id + 'dns_records'
self.__warning = "\r\n".join([
'@arno',
'Attention: CF域名解析新增失败，请检查:',
'URL: + %s' % url,
#'%s : %s' %(secretid, secretkey)
])
try:
ret = requests.post(url,
data=json.dumps(datas),
headers=self.__headers,
verify=False)
result = ret.json()
except Exception, e:
result = {'result': None, 'errors': str(e), 'success': False}
if not result['success']:
message['text'] = self.__warning + '\n' + str(result)
logger.error(message['text'].replace('\r\n', '\n'))
sendTelegram(message).send()
return result
