def select(self):
alld = self.init_data_Text.get(1.0, END).strip()
for domain in alld.split():
domain = domain.strip()
try:
request = DescribeDomainRecordsRequest()
request.set_DomainName(domain)
a=self.client.do_action_with_exception(request).decode()
json.loads(a)
b = json.loads(a)
self.name_data_Text.insert(END, f'{domain}\n', "tag2")
for i in b['DomainRecords']['Record']:
self.name_data_Text.insert(END, f"{self.duiqi(i['RR'],i['Line'],i['Type'],i['Value'],i['Status'],i['RecordId'])}\n", "tag2")
except Exception as err:
if 'domain name does not exist' in str(err):
self.name_data_Text.insert(END, f'{domain} 没有这条域名\n', "tag1")
elif "The domain name belongs to other users" in str(err):
self.name_data_Text.insert(END, f'{domain} 域名已被其他账户添加\n', "tag1")
elif "DNS record is invalid or in the wrong format" in str(err):
self.name_data_Text.insert(END, f'{domain} 格式错误\n', "tag1")
elif "InvalidDomainName.Format Invalid domain name" in str(err):
self.name_data_Text.insert(END, f'{domain} 域名格式无效\n', "tag1")
elif "The specified domain name does not exist" in str(err):
self.name_data_Text.insert(END, f'{domain} 此账户没有这条域名\n', "tag1")
elif "DomainRecordDuplicate The DNS record already exists" in str(err):
self.name_data_Text.insert(END, f'{domain} 解析值已存在\n', "tag1")
elif "type record is in conflict the" in str(err):
self.name_data_Text.insert(END, f'{domain} 记录类型冲突\n', "tag1")
else:
self.name_data_Text.insert(END, "========================================\n", "tag1")
self.name_data_Text.insert(END, f"{domain} {err}\n", "tag1")
self.name_data_Text.insert(END, "========================================\n", "tag1")
def get_record_page(self, domain_name, page_number=1):
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_PageNumber(page_number)
request.set_PageSize(self.page_size)
request.set_DomainName(domain_name)
response = self.__client.do_action_with_exception(request)
return json.loads(str(response, encoding="utf8"))['DomainRecords']
def getvalue(domain, cgy, csy):
D1 = f"{domain.rsplit('.')[-2]}.{domain.rsplit('.')[-1]}"
D2 = domain.rsplit('.')[0]
client = AcsClient(cgy, csy, 'cn-hangzhou')
request = DescribeDomainRecordsRequest()
request.set_DomainName(D1)
mess = json.loads(client.do_action_with_exception(request).decode())
for i in mess['DomainRecords']['Record']:
if i['RR'] == D2:
return i
def Get_Result(self, keyword, domain, Type):
self.request = DescribeDomainRecordsRequest()
self.request.set_accept_format('json')
self.request.set_RRKeyWord(keyword)
self.request.set_DomainName(domain)
response = self.client.do_action_with_exception(self.request)
jsonObj = json.loads(response.decode("UTF-8"))
try:
for i in jsonObj['DomainRecords']['Record']:
if i['Type'] == Type and i['RR'] == keyword:
return i['Value']
except:
return '127.0.0.1'
def get_dns_domain(self, format, page, limit, domain):
from aliyunsdkalidns.request.v20150109.DescribeDomainRecordsRequest import DescribeDomainRecordsRequest
request = DescribeDomainRecordsRequest()
request.set_accept_format(format)
request.set_DomainName(domain)
request.set_PageNumber(page)
request.set_PageSize(limit)
try:
response = self.client.do_action_with_exception(request)
except:
return False
return response
def __getRecordValue(self):
self.__requireParmSet()
# create request and set parm
request = DescribeDomainRecordsRequest()
request.set_DomainName(self.domain_name)
request.set_TypeKeyWord(self.record_type)
request.set_RRKeyWord(self.sub_domain_name)
# execute
res = self.__tryExecute(request)
if res[0]:
print "ok: " + res[1]
resJsonObj = json.loads(res[1])
for record in resJsonObj["DomainRecords"]["Record"]:
if record["RR"] == self.sub_domain_name:
self.has_remote_record = True
self.record_id = record["RecordId"]
self.remote_record_value = record["Value"]
return True, record["Value"]
self.has_remote_record = False
self.record_id = ""
self.remote_record_value = ""
return True, None
else:
print "error: " + res[1]
return res
def get_dns_record_id(client, domain, host, ip_address):
r"""
Get DNS RecordId from Aliyun
:param client: client object
:param domain: domain name, e.g. "dongs.xyz"
:param host: host, e.g. "www"
:param ip_address: new Ip address, e.g. "127.0.0.1"
:return: record id
"""
try:
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domain)
request.set_PageSize(100)
response = client.do_action_with_exception(request)
json_data = json.loads(str(response, encoding='utf-8'))
for RecordId in json_data['DomainRecords']['Record']:
if host == RecordId['RR']:
logging.info("Found a matched RecordId: {_record_id}.".format(
_record_id=RecordId["RecordId"]))
if ip_address == RecordId['Value']:
return None
else:
return RecordId['RecordId']
except Exception as e:
logging.error("Unable to get RecordId.")
logging.error(e)
sys.exit(-1)
def get(self, request, format=None):
domain_name = request.GET.get('domain_name')
page = request.GET.get('page')
per_page = request.GET.get('per_page')
client = settings.ALIAPI_LINGFANNAO
req = DescribeDomainRecordsRequest()
req.set_accept_format('json')
req.set_DomainName(domain_name)
req.set_PageNumber(page)
req.set_PageSize(per_page)
res = client.do_action_with_exception(req).decode('utf-8')
return Response(json.loads(res))
def get_dns_list(self):
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(self.get_data()['domainName'])
request.set_RRKeyWord(self.get_data()['tertiaryDomain'])
response = self.client.do_action_with_exception(request)
res_json = json.loads(str(response, encoding='utf-8'))
return res_json['DomainRecords']['Record']
def getRecords(client, rr, domain):
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domain)
request.set_RRKeyWord(rr)
response = client.do_action_with_exception(request)
print(str(response, encoding='utf-8'))
jsonData = json.loads(response)
return jsonData['DomainRecords']['Record']
def get_domain_records(self, domain_name, page_num=1, page_size=20):
'''
获取域名解析记录列表
'''
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domain_name)
request.set_PageNumber(page_num)
request.set_PageSize(page_size)
data = self._request(request)
total = data.get('TotalCount')
data = data.get('DomainRecords')
data_list = data.get('Record')
data = {
'total': total,
'data_list': data_list,
}
return data
def getRecord(_rr):
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domain)
response = client.do_action_with_exception(request)
response = json.loads(response.decode("UTF-8"))
for item in response["DomainRecords"]["Record"]:
if item['RR'] == _rr:
return item
def describe_full_records(domain_name):
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domain_name)
try:
response = client.do_action_with_exception(request)
return json.loads(response.decode())
except Exception as e:
code = "503.1"
serverchan_error_msg(domain_name, code, e)
error_response(code)
def get_record(rr=None):
client = AcsClient(accessKeyId, accessSecret, 'cn-hangzhou')
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName("henqy.club")
if not rr:
pass
else:
request.set_RRKeyWord(rr)
response = client.do_action_with_exception(request)
record = loads(response)['DomainRecords']['Record']
return record
def describe_domain_records(self, record_type, subdomain):
logging.info("域名解析记录查询")
from aliyunsdkalidns.request.v20150109.DescribeDomainRecordsRequest import DescribeDomainRecordsRequest
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_Type(record_type)
request.set_DomainName(subdomain)
response = self.client.do_action_with_exception(request)
response = str(response, encoding='utf-8')
result = json.loads(response)
logging.debug(result)
return result
def aliyunDomainRecord(domain, client, username):
"""
阿里云万网域名接口 内部调用域名解析记录详情
"""
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domain)
response = client.do_action_with_exception(request).decode('utf-8')
records = json.loads(response)['DomainRecords']['Record']
domaininfolist = []
if len(records) > 0:
for i in range(len(records)):
domaininfolist.append(
models.Domaininfo(register_website='www.aliyun.com',
name_account=username,
domain_name=records[i]['DomainName'],
fqdn=records[i]['RR'] + '.' +
records[i]['DomainName'],
type=records[i]['Type'],
answer=records[i]['Value']))
models.Domaininfo.objects.filter(
name_account=username,
domain_name=records[i]['DomainName']).delete()
models.Domaininfo.objects.bulk_create(domaininfolist)
def get_dns_record(client: AcsClient, subdomain: str, topdomain: str):
result = {"ipv4": None, "ipv6": None}
request = DescribeDomainRecordsRequest()
request.set_accept_format("json")
request.set_DomainName(topdomain)
request.set_RRKeyWord(subdomain)
response = client.do_action_with_exception(request)
response = json.loads(response)
for record in response["DomainRecords"]["Record"]:
if result["ipv4"] is None and record["Type"] == "AA":
result["ipv4"] = record
if result["ipv6"] is None and record["Type"] == "AAAA":
result["ipv6"] = record
return result
def get_domain_record_list(domain_name):
client = create_client()
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domain_name)
response = client.do_action_with_exception(request)
return response
def refresh_domain_records():
"""
更新域名 DNS
"""
try:
ip = get_ip()
client = AcsClient(ALI_AK, ALI_SECRET, ALI_REGION_ID)
req_get_records = DescribeDomainRecordsRequest()
req_get_records.set_accept_format('json')
req_get_records.set_DomainName(ALI_DOMAIN)
response = json.loads(client.do_action_with_exception(req_get_records))
msg = ""
for record in response["DomainRecords"]["Record"]:
recode_ip = record["Value"]
if recode_ip != ip:
req_set_record = UpdateDomainRecordRequest()
req_set_record.set_RecordId(record["RecordId"])
req_set_record.set_RR(record["RR"])
req_set_record.set_Type(record["Type"])
req_set_record.set_TTL(record["TTL"])
req_set_record.set_Value(ip)
req_set_record.set_accept_format('json')
client.do_action_with_exception(req_set_record)
info = str.format("{0}.{1} {2} --> {3}", record["RR"],
ALI_DOMAIN, recode_ip, ip)
logging.info(info)
msg += info + "\n"
if msg != "":
send_mail(msg)
except:
logging.exception("Exception occurred")
def RecordList(DomainName):
request = DescribeDomainRecordsRequest()
request.set_accept_format("json")
request.set_DomainName(DomainName)
response = client.do_action_with_exception(request)
records = json.loads(response)
return records
def get_record_id(self, rr):
"""
查询record id
:return: id|None
"""
try:
client = AcsClient(self.key, self.secret, 'cn-hangzhou')
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(self.second_level_domain)
response = client.do_action_with_exception(request)
response = json.loads(response)
records = response["DomainRecords"]["Record"]
if self.prefix_domain:
rr = ''.join([rr, ".", self.prefix_domain])
record_id = "".join([item["RecordId"] for item in records if item["RR"] == rr])
if record_id:
return record_id
logger.error(F"cat not get record id: {response}")
except Exception:
logger.error("get record id unknown exception")
logger.error(traceback.format_exc())
def getRecords():
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domainName)
response = client.do_action_with_exception(request)
# print(str(response, encoding='utf-8'))
jsonObj = json.loads(response.decode("UTF-8"))
return jsonObj["DomainRecords"]["Record"]
def query_domain_records(client):
"""query for all domain records"""
request = DescribeDomainRecordsRequest()
request.set_accept_format("json")
request.set_DomainName(config["domain"])
return client.do_action_with_exception(request)
def get_domain_name_records(self, obj):
self.client = AcsClient(obj.account.access_id, obj.account.access_key,
'cn-hangzhou')
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_PageSize(100)
request.set_DomainName(obj.domain_name)
try:
response = self.client.do_action_with_exception(request)
ret = json.loads(str(response,
encoding='utf-8'))['DomainRecords']['Record']
return {'code': 1, 'message': ret}
except Exception as e:
return {'code': 0, 'message': e}
def getRecordList(Domain: str) -> list:
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(Domain)
response = client.do_action_with_exception(request)
recordList = json.loads(str(response,
encoding='utf-8'))["DomainRecords"]["Record"]
# python2: print(response)
return recordList
def DescribeDomainRecordsRequestHelper(Client, DomainName):
Request = DescribeDomainRecordsRequest()
Request.set_accept_format('json')
Request.set_DomainName(DomainName)
result = ExecuteGetResults(Client,Request)
#print(result)
return result
def get_domain_ip(domainname, rrkeyworld, _type):
try:
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_TypeKeyWord(_type)
request.set_DomainName(domainname)
request.set_RRKeyWord(rrkeyworld)
response = client.do_action_with_exception(request)
try:
source_data = str(response, encoding='utf-8')
print('请求数据成功')
except Exception as e:
print('请求数据失败')
print(e)
sys.exit()
try:
datas = json.loads(source_data)['DomainRecords']['Record'][0]
print('找到主机记录')
except Exception:
print('没有找到主机记录')
sys.exit()
if datas:
print('\t域名\t: ' + str(datas['RR'] + '.' + datas['DomainName']))
print('\t类型\t: ' + str(datas['Type']))
print('\t记录值\t: ' + str(datas['Value']))
print('\tTTL\t: ' + str(datas['TTL']))
print('\tStatus\t: ' + str(datas['Status']))
return str(datas['Value']), str(datas['RR']), str(
datas['RecordId']), str(datas['Type'])
else:
print('请求数据失败')
print(source_data)
except Exception as e:
print('请求数据失败')
print(e)
def GetDNSRecord(yaml_data, client, DomainName):
try:
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(DomainName)
response = client.do_action_with_exception(request)
json_data = json.loads(str(response, encoding='utf-8'))
for Record in json_data['DomainRecords']['Record']:
if yaml_data['DnsData']['RR'] == Record['RR']:
return Record
except Exception as e:
print("获取RecordId失败")
print(e)
sys.exit(-1)
def Get_RecordId(self, DomainName, RR):
''' 获取域名的RecordId'''
self.request = CommonRequest()
self.request.set_domain('alidns.aliyuncs.com')
self.request.set_version('2015-01-09')
self.request.set_action_name('DescribeDomainRecords')
self.request.add_query_param('DomainName', DomainName)
try:
response = self.client.do_action_with_exception(self.request)
jsonObj = json.loads(response.decode("UTF-8"))
records = jsonObj["DomainRecords"]["Record"]
for code in records:
if code["RR"] == RR:
return code["RecordId"]
except:
Logger().info("Error")
def update_Domain_Record(self, RR, value, Type, DomainName):
'''修改域名解析记录'''
self.request = CommonRequest()
record_id = self.Get_RecordId(RR=RR, DomainName=DomainName)
self.request.set_accept_format('json')
self.request.set_domain('alidns.aliyuncs.com')
self.request.set_method('POST')
self.request.set_version('2015-01-09')
self.request.set_action_name('UpdateDomainRecord')
self.request.add_query_param('RR', RR)
self.request.add_query_param('Type', Type)
self.request.add_query_param('Value', value)
self.request.add_query_param('RecordId', record_id)
response = self.client.do_action(self.request)
jsonObj = json.loads(response.decode("UTF-8"))
Logger().info(jsonObj)
def update_domain(domain, new_ip, rrs):
cli = client.AcsClient(KEY, SECRET, REGION)
req = DescribeDomainRecordsRequest()
req.set_DomainName(domain)
req.set_accept_format('json')
resp = cli.do_action(req)
records = json.loads(resp)['DomainRecords']['Record']
for rec in records:
if rec['Type'] != 'A':
continue
if rec['RR'] not in rrs:
continue
if rec['Value'] == new_ip:
print_('Not need refresh, same as now.', new_ip, rec['RR'])
continue
req = UpdateDomainRecordRequest()
req.set_RecordId(rec['RecordId'])
req.set_Value(new_ip)
req.set_RR(rec['RR'])
req.set_Type(rec['Type'])
req.set_accept_format('json')
resp = cli.do_action(req)
result = json.loads(resp)
if 'Code' in result:
raise Exception(result['Message'])
