class Client:
def __init__(self,filepath,ip):
self.filepath = filepath
with open(filepath, 'r') as f:
self.config = json.load(f)
self.clt = AcsClient(self.config.get('Key'), self.config.get('Secret'), self.config.get('Region'))
if not self.config.get('RecordID'):
self.GetRecordID()
self.config['IP']=ip
self.UpdateRecord()
def GetRecordID(self):
id_r = DescribeDomainRecordsRequest.DescribeDomainRecordsRequest()
id_r.set_DomainName(self.config.get('Domain'))
id_r.set_RRKeyWord(self.config.get('RR'))
id_re = self.clt.do_action(id_r)
id_xml = fromstring(id_re.decode())
self.config['RecordID'] = id_xml.find('DomainRecords/Record/RecordId').text
with open(self.filepath, "w") as f:
f.write(json.dumps(self.config))
def UpdateRecord(self):
ur_r = UpdateDomainRecordRequest.UpdateDomainRecordRequest()
ur_r.set_RR(self.config['RR'])
ur_r.set_RecordId(self.config['RecordID'])
ur_r.set_Type('A')
ur_r.set_Value(self.config['IP'])
ur_r.set_Line("default")
ur_re = self.clt.do_action(ur_r)
Log(ur_re)
def __init__(self,filepath,ip):
self.filepath = filepath
with open(filepath, 'r') as f:
self.config = json.load(f)
self.clt = AcsClient(self.config.get('Key'), self.config.get('Secret'), self.config.get('Region'))
if not self.config.get('RecordID'):
self.GetRecordID()
self.config['IP']=ip
self.UpdateRecord()
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import CommonRequest
import random
import json
client = AcsClient('LTAIkQEh2SFTBmfn', 'oeUgaDcSvRE9QLvIo0mrqO3G04o6kj',
'default')
code = random.randrange(1000, 10000) # 生成随机验证码
# code = random.randrange(1000, 10000) # 生成随机验证码
# params = {
# 'code': code
# }
# request = CommonRequest()
# request.set_accept_format('json')
# request.set_domain('dysmsapi.aliyuncs.com')
# request.set_method('POST')
# request.set_protocol_type('https') # https | http
# request.set_version('2017-05-25')
# request.set_action_name('SendSms')
#
# request.add_query_param('PhoneNumbers', "13526678185")
# request.add_query_param('SignName', "亿程软件")
# request.add_query_param('TemplateCode', "SMS_168821509")
# #request.add_query_param('TemplateParam', "{\"code\":\"1234\"}")
# request.add_query_param('TemplateParam', json.dumps(params))
#
# response = client.do_action(request)
# # python2: print(response)
# print(str(response, encoding='utf-8'))
from datetime import datetime
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import CommonRequest
rc_rr = "www" # 指代二级域名（子域名，空则使用 @ 代替）
rc_domain = "example.org" # 指代完整域名，若未配置阿里云 NameServer 解析修改也无效
rc_format = "json" # 指定返回数据格式，目前本例使用 JSON 数据
rc_type = "A" # 指定修改记录类型，目前本例使用 A 记录
rc_ttl = "600" # 指定修改 TTL 值，目前本例使用 600 秒
rc_format = "json" # 使用 JSON 返回数据，也可以填写为 XML
access_key_id = "" # 这里为 Aliyun AccessKey 信息
access_key_secret = "" # 这里为 Aliyun AccessKey 信息
clt = AcsClient(access_key_id, access_key_secret, 'default')
def check_record_id(dns_rr, dns_domain):
times = 0 # 用于检查对应子域名的记录信息
check = 0 # 用于确认对应子域名的记录信息
request = CommonRequest()
request.set_accept_format('json') # 设置返回格式
request.set_domain('alidns.aliyuncs.com') # 阿里云服务
request.set_method('POST')
request.set_protocol_type('https')
request.set_version('2015-01-09')
request.set_action_name('DescribeDomainRecords')
request.add_query_param('DomainName', rc_domain) # 设置请求域名
request.add_query_param('RRKeyWord', rc_rr)
request.add_query_param('TypeKeyWord', rc_type)
import os
import json
import ConfigParser
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.profile import region_provider
from aliyunsdkcore.http import format_type
from aliyunsdkcore.request import CommonRequest
from aliyunsdkcore.acs_exception import exceptions
cf = ConfigParser.ConfigParser()
config_file = os.path.expanduser('~') + "/aliyun-sdk.ini"
cf.read(config_file)
client = AcsClient(cf.get("daily_access_key", "id"),
cf.get("daily_access_key", "secret"), 'cn-hangzhou')
assert client
class TestCommonApi(object):
acs_client = client
def set_client(self, acs_client=client):
self.acs_client = acs_client
def test_roa_form_with_init(self):
request = CommonRequest(domain='ft.aliyuncs.com',
version='2016-01-02',
action_name='TestRoaApi',
uri_pattern='/web/cloudapi')
request.set_method('POST')
"""
短信业务调用接口示例，版本号：v20170525
Created on 2017-06-12
"""
ACCESS_KEY_ID = "LTAI5U4PiVykexVV"
ACCESS_KEY_SECRET = "7A4WVVaiUwxVKrpWSCwxXdoNiMJoQk"
# 注意：不要更改
REGION = "cn-hangzhou"
PRODUCT_NAME = "Dysmsapi"
DOMAIN = "dysmsapi.aliyuncs.com"
acs_client = AcsClient(ACCESS_KEY_ID, ACCESS_KEY_SECRET, REGION)
region_provider.add_endpoint(PRODUCT_NAME, REGION, DOMAIN)
def send_sms(phone_numbers, code):
business_id = uuid.uuid1()
sign_name = '小饭桌应用'
template_code = 'SMS_68465012'
template_param = json.dumps({"code": code})
smsRequest = SendSmsRequest.SendSmsRequest()
# 申请的短信模板编码,必填
smsRequest.set_TemplateCode(template_code)
# 短信模板变量参数
if template_param is not None:
smsRequest.set_TemplateParam(template_param)
# 设置业务请求流水号，必填。
#!/usr/bin/env python
#coding=utf-8
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkalidns.request.v20150109.DescribeDomainRecordsRequest import DescribeDomainRecordsRequest
from aliyunsdkalidns.request.v20150109.UpdateDomainRecordRequest import UpdateDomainRecordRequest
import json
import requests
import re
client = AcsClient(' ', ' ', 'cn-hangzhou')
domainname = 'insert your ddns domain name'
tagetrecord = 'insert you A record'
def getCurrentIp() -> str:
try:
taobaoInterface = requests.get(
'http://ip.taobao.com/service/getIpInfo.php?ip=myip', timeout=1)
ip = taobaoInterface.json(
)['data']['ip'] if taobaoInterface.status_code == 200 else ''
except Exception as e:
souhuInterface = requests.get('http://pv.sohu.com/cityjson?ie=utf-8',
timeout=1)
if souhuInterface.status_code == 200:
ip = re.search(
r'(((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[0-1]?\d{1,2})){3})',
souhuInterface.text)
ip = ip.group()
return ip
def __buildClient(self, json_config):
return AcsClient(str(json_config['id']), str(json_config['secret']),
"cn-shanghai")
def set_client(cfg_file, region_id, top_dir=None):
"""
Configure client
:param cfg_file: specify the configuration file
:param region_id: specify region id
:param top_dir: working path
:return: None
"""
global ACCESS_KEY_ID
global ACCESS_KEY_SECRET
global REGION_ID
global client
global JSON_INDENT
global ROS_DEBUG
if top_dir is None:
default_file = 'ros/ros.conf'
else:
default_file = os.path.normpath(top_dir + '/ros/ros.conf')
cf = NewConfigParser.NewConfigParser()
if cfg_file is None:
if ROS_DEBUG:
print("Use default config file: %s\n" % default_file)
cfg_file = default_file
if os.path.isfile(cfg_file):
pass
else:
if os.path.isdir(top_dir + '/ros'):
pass
else:
os.mkdir(top_dir + '/ros')
print('Please set Aliyun access info first.')
access_key_id = raw_input('Enter your access key id:')
while check_access_info(access_key_id) is False:
access_key_id = raw_input('Enter your access key id, only characters and numbers:')
access_key_secret = raw_input('Enter your access key secret, without quote:')
while check_access_info(access_key_secret) is False:
access_key_secret = raw_input('Enter your access key secret, only characters and numbers:')
default_region_id = raw_input('Enter default region id, without quote:')
cf.add_section('ACCESS')
cf.set('ACCESS', 'ACCESS_KEY_ID', access_key_id)
cf.set('ACCESS', 'ACCESS_KEY_SECRET', access_key_secret)
cf.set('ACCESS', 'REGION_ID', default_region_id)
cf.add_section('OTHER')
cf.set('OTHER', 'JSON_INDENT', 2)
cf.set('OTHER', 'DEBUG', False)
with open(cfg_file, 'w') as configfile:
cf.write(configfile)
try:
cf.read(cfg_file)
except BaseException:
print("""Config file (%s) error, please write it like:
[ACCESS]
ACCESS_KEY_ID = YOUR_KEY_ID
ACCESS_KEY_SECRET = YOUR_KEY_SECRET
REGION_ID = cn-beijing
[OTHER]
JSON_INDENT = 2
DEBUG = False
""" % cfg_file)
sys.exit(1)
ACCESS_KEY_ID = cf.get("ACCESS", "ACCESS_KEY_ID")
ACCESS_KEY_SECRET = cf.get("ACCESS", "ACCESS_KEY_SECRET")
if region_id is None:
REGION_ID = cf.get("ACCESS", "REGION_ID")
else:
REGION_ID = region_id
JSON_INDENT = int(cf.get("OTHER", "JSON_INDENT"))
ROS_DEBUG = bool(cf.get("OTHER", "DEBUG") == 'True')
client = AcsClient(
ACCESS_KEY_ID,
ACCESS_KEY_SECRET,
REGION_ID
)
if ROS_DEBUG:
current_conf()
class SendSms(object):
def __init__(self, phone: str = None, category: str = None, template_param=None):
"""
:param phone: 发送的手机号
:param category: 选择短信模板
:param template_param: 短信验证码或者短信模板中需要替换的变量用字典传入 类似：{"code":123456}
"""
access_key_id = current_app.config.get('SMS_ACCESS_KEY_ID', None)
access_key_secret = current_app.config.get('SMS_ACCESS_KEY_SECRET', None)
sign_name = current_app.config.get("SMS_SIGN_NAME", None)
if access_key_id is None:
raise ValueError("缺失短信key")
if access_key_secret is None:
raise ValueError("缺失短信secret")
if phone is None:
raise ValueError("手机号错误")
if template_param is None:
raise ValueError("短信模板参数无效")
if category is None:
raise ValueError("短信模板编码无效")
if sign_name is None:
raise ValueError("短信签名错误")
self.acs_client = AcsClient(access_key_id, access_key_secret)
self.phone = phone
self.category = category
self.template_param = template_param
self.template_code = self.template_code()
self.sign_name = sign_name
def template_code(self):
"""
选择模板编码
:param self.category
authentication: 身份验证
login_confirmation: 登陆验证
login_exception: 登陆异常
user_registration: 用户注册
change_password:修改密码
information_change:信息修改
:return:
"""
if self.category == "authentication":
code = current_app.config.get('AUTHENTICATION', None)
if code is None:
raise ValueError("配置文件中未找到模板编码AUTHENTICATION")
return code
elif self.category == "login_confirmation":
code = current_app.config.get('LOGIN_CONFIRMATION', None)
if code is None:
raise ValueError("配置文件中未找到模板编码LOGIN_CONFIRMATION")
return code
elif self.category == "login_exception":
code = current_app.config.get('LOGIN_EXCEPTION', None)
if code is None:
raise ValueError("配置文件中未找到模板编码LOGIN_EXCEPTION")
return code
elif self.category == "user_registration":
code = current_app.config.get('USER_REGISTRATION', None)
if code is None:
raise ValueError("配置文件中未找到模板编码USER_REGISTRATION")
return code
elif self.category == "change_password":
code = current_app.config.get('CHANGE_PASSWORD', None)
if code is None:
raise ValueError("配置文件中未找到模板编码CHANGE_PASSWORD")
return code
elif self.category == "information_change":
code = current_app.config.get('INFORMATION_CHANGE', None)
if code is None:
raise ValueError("配置文件中未找到模板编码INFORMATION_CHANGE")
return code
else:
raise ValueError("短信模板编码无效")
def send_sms(self):
"""
发送短信
:return:
"""
sms_request = CommonRequest()
# 固定设置
sms_request.set_accept_format('json')
sms_request.set_domain('dysmsapi.aliyuncs.com')
sms_request.set_method('POST')
sms_request.set_protocol_type('https') # https | http
sms_request.set_version('2017-05-25')
sms_request.set_action_name('SendSms')
# 短信发送的号码列表，必填。
sms_request.add_query_param('PhoneNumbers', self.phone)
# 短信签名，必填。
sms_request.add_query_param('SignName', self.sign_name)
# 申请的短信模板编码,必填
sms_request.add_query_param('TemplateCode', self.template_code)
# 短信模板变量参数 类似{"code":"12345"}，必填。
sms_request.add_query_param('TemplateParam', self.template_param)
# 设置业务请求流水号，必填。暂用UUID1代替
build_id = uuid.uuid1()
sms_request.add_query_param('OutId', build_id)
# 调用短信发送接口，返回json
sms_response = self.acs_client.do_action_with_exception(sms_request)
return sms_response
from aliyunsdkcore.client import AcsClient
from aliyunsdkchatbot.request.v20171011 import ChatRequest
import json
# 创建AcsClient实例
client = AcsClient("LTAIjgiPhdMbT2F9", "n1RHkNGL7KnVPDRjWbKfr5qK7YKS2G",
"cn-shanghai")
# 创建request，并设置参数
SessionId = ""
while 1:
height = input()
if "exit" == height:
break
request = ChatRequest.ChatRequest()
request.set_SessionId(SessionId)
request.set_InstanceId("chatbot-cn-mp90vh2if0005g")
# request.set_Utterance("订餐厅")
request.set_Utterance(height)
# 发起API请求并显示返回值
response = client.do_action_with_exception(request)
# bytes to str
bs = str(response, encoding="utf8")
chat_bot_msg = json.loads(bs)
SessionId = chat_bot_msg["SessionId"]
Messages = chat_bot_msg["Messages"]
print(chat_bot_msg)
for message in Messages:
text = message["Text"]
content = text["Content"]
print(content)
# 创建 AcsClient 实例
#
with open('E:\\03.devops\\django\\test\\jsm_aliyun_id.txt','r') as jsm_aliyun_id:
jsm_aliyun_id_info = jsm_aliyun_id.readline()
# print(jsm_aliyun_id_info)
jsm_aliyun_id_info_json = json.loads(jsm_aliyun_id_info)
#
# print(type(jsm_aliyun_id_info_json))
ak = jsm_aliyun_id_info_json['ak']
secret = jsm_aliyun_id_info_json['secret']
region_id = jsm_aliyun_id_info_json['region_id']
client = AcsClient(
ak,
secret,
region_id)
# 获取RDS实例的备份数
#
def jsm_get_rds_backup(client, rds_instance_id, rds_instance_name):
''
request = DescribeBinlogFilesRequest.DescribeBinlogFilesRequest()
request.set_DBInstanceId(rds_instance_id)
# 获取昨天到今天凌晨的备份时间
request.set_StartTime(yestoday_format)
request.set_EndTime(today_format)
response = client.do_action_with_exception(request)
print(response)
from aliyunsdkros.request.v20150901 import \
DescribeRegionsRequest
from aliyunsdkvpc.request.v20160428 import \
DescribeVSwitchesRequest
from aliyunsdkecs.request.v20140526 import \
DescribeZonesRequest, \
DescribeImagesRequest, \
DescribeInstanceTypesRequest, \
DescribeSecurityGroupsRequest, \
DescribeSecurityGroupAttributeRequest
pp = pprint.PrettyPrinter(indent=2)
access_key = ''
access_key_secret = ''
client = AcsClient(access_key, access_key_secret, 'cn-beijing')
# print Regions
req = DescribeRegionsRequest.DescribeRegionsRequest()
body = client.do_action_with_exception(req)
pp.pprint(json.loads(body.decode("utf-8")))
# VSwitch
req = DescribeVSwitchesRequest.DescribeVSwitchesRequest()
req.set_query_params({'PageSize': 50})
body = client.do_action_with_exception(req)
pp.pprint(json.loads(body.decode("utf-8")))
# zone
req = DescribeZonesRequest.DescribeZonesRequest()
body = client.do_action_with_exception(req)
def __init__(self, access_key, access_secret, region="cn-beijing"):
self.region = region
self.client = AcsClient(access_key, access_secret, self.region)
self.zones = None
pass
# Note: Do NOT change
PRODUCT_NAME = "Dybaseapi"
DOMAIN = "dybaseapi.ap-southeast-1.aliyuncs.com"
REGION = "ap-southeast-1"
# TODO : Need to replace below field into the message type you want. Delivery Report:SmsReport, Replied Message: Smsup
msgtype = "SmsReport"
# TODO Need to replace below field into the Queune name which you can get from SMS Console.
qname = "Alicom-Queue-xxxxxx-SmsReport"
# Do NOT change
endpoint = "http://1493622401794734.mns.ap-southeast-1.aliyuncs.com"
acs_client = AcsClient(const.ACCESS_KEY_ID, const.ACCESS_KEY_SECRET, REGION)
region_provider.add_endpoint(PRODUCT_NAME, REGION, DOMAIN)
# The expiry time set for Short Message Service
class Token():
def __init__(self,
token=None,
tmp_access_id=None,
tmp_access_key=None,
expire_time=None):
self.__token = token
self.__tmp_access_id = tmp_access_id
self.__tmp_access_key = tmp_access_key
self.__expire_time = expire_time
class AliYunDNSManager:
def __init__(self):
self.client = AcsClient(configs.ALIYUN_ACCESS_KEY_ID,
configs.ALIYUN_SECRET)
@staticmethod
def _data_valid(data) -> bool:
if type(data) == str:
return data is not None and len(data) > 0
else:
return data is not None
def add_or_update_domain_record(self,
domain_name: str,
host_record_keyword: str,
type_keyword: str = 'A',
old_value_keyword: str = None,
value: str = None):
response_data = self.get_domain_records(domain_name,
host_record_keyword,
type_keyword,
old_value_keyword)
record_count = response_data['TotalCount']
if record_count == 0:
response_data = self._add_domain_record(
domain_name=domain_name,
host_record=host_record_keyword,
record_type=type_keyword,
value=value)
print(response_data)
return
elif record_count > 1:
raise RuntimeError('匹配的解析记录大于1条，无法确定需要修改的记录，请提高搜索精度')
record = response_data['DomainRecords']['Record'][0]
record_id = record['RecordId']
response_data = self._update_domain_record(
record_id=record_id,
host_record=host_record_keyword,
record_type=type_keyword,
value=value)
print(response_data)
def delete_domain_record(self,
domain_name: str,
host_record_keyword: str,
type_keyword: str = 'A',
value_keyword: str = None):
response_data = self.get_domain_records(domain_name,
host_record_keyword,
type_keyword, value_keyword)
record_count = response_data['TotalCount']
if record_count == 0:
raise RuntimeError('无法找到需要删除的解析记录')
elif record_count > 1:
raise RuntimeError('匹配的解析记录大于1条，无法确定需要修改的记录，请提高搜索精度')
record = response_data['DomainRecords']['Record'][0]
record_id = record['RecordId']
response_data = self._delete_domain_record(record_id)
print(response_data)
def _add_domain_record(self, domain_name: str, host_record: str,
record_type: str, value: str):
request = AddDomainRecordRequest()
request.set_accept_format('json')
request.set_DomainName(domain_name)
request.set_RR(host_record)
request.set_Type(record_type)
request.set_Value(value)
response = self.client.do_action_with_exception(request)
response = response.decode('utf-8')
return json.loads(response)
def _update_domain_record(self, record_id: str, host_record: str,
record_type: str, value: str):
request = UpdateDomainRecordRequest()
request.set_accept_format('json')
request.set_RecordId(record_id)
request.set_RR(host_record)
request.set_Type(record_type)
request.set_Value(value)
response = self.client.do_action_with_exception(request)
response = response.decode('utf-8')
return json.loads(response)
def _delete_domain_record(self, record_id: str):
request = DeleteDomainRecordRequest()
request.set_accept_format('json')
request.set_RecordId(record_id)
response = self.client.do_action_with_exception(request)
response = response.decode('utf-8')
return json.loads(response)
def get_domain_records(self,
domain_name: str,
host_record_keyword: str = None,
type_keyword: str = 'A',
value_keyword: str = None) -> dict:
if not self._data_valid(domain_name):
raise RuntimeError('缺少域名名称')
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(domain_name)
# request.set_PageSize('100')
if self._data_valid(host_record_keyword):
request.set_RRKeyWord(host_record_keyword)
request.set_TypeKeyWord(type_keyword)
if self._data_valid(value_keyword):
request.set_ValueKeyWord(value_keyword)
response = self.client.do_action_with_exception(request) # type: bytes
response_data = json.loads(response.decode('utf-8'))
return response_data
class AlibabaSDK(object):
def __init__(self, params):
# Alibaba connection credentials
access_key_id = params['Credential'].get('access_key_id')
access_key_secret = params['Credential'].get('secretaccess_key')
region = params['VM'].get('region')
AliyunConfig(access_key_id=access_key_id,
access_key_secret=access_key_secret,
region=region).update()
self.clt = AcsClient(access_key_id, access_key_secret, region)
# VM parameters
self.vm_params = dict()
self.vm_params["InstanceType"] = params['Flavor'].get('name')
self.vm_params["RegionId"] = region
self.vm_params["InstanceName"] = params['VM'].get('vm_name').replace(
'_', '-')
self.vm_params["HostName"] = self.vm_params["InstanceName"]
self.vm_params["Username"] = params['VM'].get('username')
self.vm_params["Password"] = params['VM'].get('password')
self.vm_params["KeyPairName"] = params['VM'].get('keypair')
self.vm_params["ZoneId"] = params['VM'].get('az')
self.vm_params["ImageName"] = params['Image'].get('name')
self.vm_params["ImageId"] = params['Image'].get('id', '*/Image/*')
self.vm_params["SecurityGroupId"] = params['SecurityGroup'].get('id')
self.vm_params["VSwitchId"] = params["Network"]["VSwitch"].get('id')
self.vm_params["DiskName"] = params['Disk'].get('cloud_disk_name')
self.vm_params["Size"] = params['Disk'].get('cloud_disk_size')
self.vm_params["NetworkInterfaceName"] = params['NIC'].get('nic_name')
# Assign SystemDiskCategory and DiskCategory
self.vm_params["SystemDiskCategory"] = self.select_disk_category(
'SystemDisk')
self.vm_params["DiskCategory"] = self.select_disk_category('DataDisk')
logging.info(
'Assigned. SystemDiskCategory="{}"; DiskCategory="{}".'.format(
self.vm_params['SystemDiskCategory'],
self.vm_params['DiskCategory']))
def _send_request(self, request):
request.set_accept_format('json')
try:
logging.debug("Run: {0}".format(request.__class__.__name__))
# logging.debug(
# "Request: %s" % request.get_query_params())
response_str = self.clt.do_action_with_exception(request)
response_detail = json.loads(response_str)
# logging.debug("Response: %s" % response_detail)
return response_detail
except Exception as e:
logging.error(e)
return e
@staticmethod
def _add_params(request, key_list=None, params=None):
if params is None:
return request
if key_list:
for key in key_list:
if params.get(key) is not None:
value = params.get(key)
if "Ids" in key or "Names" in key:
value = str(value.split(',')).replace('\'', '"')
eval("request.set_{0}('{1}')".format(key, value))
request.get_query_params()
return request
# Instance
def describe_instances(self):
request = DescribeInstancesRequest.DescribeInstancesRequest()
key_list = ["InstanceName", "InstanceIds"]
self.vm_params.setdefault("InstanceName",
self.vm_params["InstanceName"])
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def create_instance(self, authentication="publickey"):
request = CreateInstanceRequest.CreateInstanceRequest()
key_list = [
"InstanceChargeType", "ImageId", "InstanceType",
"InternetChargeType", "SecurityGroupId", "VSwitchId",
"SystemDiskCategory", "HostName", "InstanceName",
"InternetMaxBandwidthOut", "InternetMaxBandwidthIn", "ZoneId"
]
self.vm_params.setdefault("InstanceChargeType", "PostPaid")
self.vm_params.setdefault("InternetChargeType", "PayByTraffic")
self.vm_params.setdefault("SystemDiskCategory",
self.vm_params['DiskCategory'])
self.vm_params.setdefault("InternetMaxBandwidthIn", "5")
self.vm_params.setdefault("InternetMaxBandwidthOut", "5")
if authentication == "publickey":
key_list.append("KeyPairName")
elif authentication == "password":
key_list.append("Password")
request = self._add_params(request, key_list, self.vm_params)
response = self._send_request(request)
if isinstance(response, Exception):
raise response
return response
def start_instance(self, instance_id):
request = StartInstanceRequest.StartInstanceRequest()
key_list = ["InstanceId"]
self.vm_params["InstanceId"] = instance_id
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def stop_instance(self, instance_id, force=False):
request = StopInstanceRequest.StopInstanceRequest()
key_list = ["InstanceId", "ForceStop"]
self.vm_params["InstanceId"] = instance_id
if force:
self.vm_params["ForceStop"] = force
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def reboot_instance(self, instance_id, force=False):
request = RebootInstanceRequest.RebootInstanceRequest()
key_list = ["InstanceId", "ForceStop"]
self.vm_params["InstanceId"] = instance_id
if force:
self.vm_params["ForceStop"] = force
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def delete_instance(self, instance_id):
request = DeleteInstanceRequest.DeleteInstanceRequest()
key_list = ["InstanceId"]
self.vm_params["InstanceId"] = instance_id
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def describe_instance_attribute(self, instance_id):
request = DescribeInstanceAttributeRequest.\
DescribeInstanceAttributeRequest()
key_list = ["InstanceId"]
self.vm_params["InstanceId"] = instance_id
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def modify_instance_attribute(self, instance_id, new_password):
request = ModifyInstanceAttributeRequest.\
ModifyInstanceAttributeRequest()
key_list = ["InstanceId", "Password"]
self.vm_params["InstanceId"] = instance_id
self.vm_params["Password"] = new_password
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def modify_instance_spec(self, instance_id, new_type):
request = ModifyInstanceSpecRequest.ModifyInstanceSpecRequest()
key_list = [
"InstanceId", "InstanceType", "InternetMaxBandwidthIn",
"InternetMaxBandwidthOut"
]
self.vm_params["InstanceId"] = instance_id
self.vm_params["InstanceType"] = new_type
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
# Resource
def describe_available_resource(self, destination_resource):
# destination_resource: ['Zone', 'IoOptimized', 'InstanceType',
# 'SystemDisk', 'DataDisk', 'Network', 'ddh']
request = DescribeAvailableResourceRequest.DescribeAvailableResourceRequest(
)
key_list = ["DestinationResource", "ZoneId", "InstanceType"]
self.vm_params["DestinationResource"] = destination_resource
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def select_disk_category(self, category):
"""Select Available Disk Category by ZoneId and InstanceType."""
if category not in ('SystemDisk', 'DataDisk'):
logging.error(
'Unsupported category! category = {}'.format(category))
return 'cloud_efficiency'
_data = self.describe_available_resource(category)
_azone = _data.get('AvailableZones', {}).get('AvailableZone', [])
if len(_azone) != 1 or _azone[0].get('Status') != 'Available':
logging.error('Resource unavailable! _azone = {}'.format(_azone))
return 'cloud_efficiency'
_resource = _azone[0].get('AvailableResources',
{}).get('AvailableResource', [])
if len(_resource) != 1 or _resource[0].get('Type') != category:
logging.error(
'Resource unavailable! _resource = {}'.format(_resource))
return 'cloud_efficiency'
_disk = _resource[0].get('SupportedResources',
{}).get('SupportedResource', [])
_disk_categories = [
x.get('Value') for x in _disk if x.get('Status') == 'Available'
]
if len(_disk_categories) == 0:
logging.error('Resource unavailable! _disk_categories = []')
return 'cloud_efficiency'
if 'cloud_essd' in _disk_categories:
disk_category = 'cloud_essd'
elif 'cloud_ssd' in _disk_categories:
disk_category = 'cloud_ssd'
elif 'cloud_efficiency' in _disk_categories:
disk_category = 'cloud_efficiency'
else:
disk_category = _disk_categories[0]
logging.info('Selected {} Category "{}" from {}'.format(
category, disk_category, _disk_categories))
return disk_category
# Public IP
def allocate_public_ip_address(self, instance_id):
request = AllocatePublicIpAddressRequest.\
AllocatePublicIpAddressRequest()
key_list = ["InstanceId"]
self.vm_params["InstanceId"] = instance_id
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
# KeyPair
def describe_keypairs(self):
request = DescribeKeyPairsRequest.DescribeKeyPairsRequest()
key_list = ["KeyPairName", "RegionId"]
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def create_keypair(self):
request = CreateKeyPairRequest.CreateKeyPairRequest()
key_list = ["KeyPairName", "RegionId"]
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def import_keypair(self):
request = ImportKeyPairRequest.ImportKeyPairRequest()
key_list = ["KeyPairName", "RegionId", "PublicKeyBody"]
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def delete_keypair(self):
request = DeleteKeyPairsRequest.DeleteKeyPairsRequest()
key_list = ["KeyPairNames", "RegionId"]
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
# Image
def describe_images(self):
request = DescribeImagesRequest.DescribeImagesRequest()
key_list = ["ImageName", "ImageId"]
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def create_image(self):
request = CreateImageRequest.CreateImageRequest()
key_list = ["ImageName", "SnaoshotId", "Platform"]
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
# Disk
def describe_disks(self, diskids=None):
"""Describe cloud disks.
diskids should be a string like '"id1","id2","id3"'.
"""
request = DescribeDisksRequest.DescribeDisksRequest()
key_list = ["ZoneId", "DiskName", "Category", "PageSize"]
self.vm_params.setdefault("Category", self.vm_params['DiskCategory'])
self.vm_params.setdefault("PageSize", "100")
if diskids:
key_list.append("DiskIds")
self.vm_params["DiskIds"] = diskids
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def create_disk(self):
request = CreateDiskRequest.CreateDiskRequest()
key_list = ["ZoneId", "DiskName", "DiskCategory", "Size"]
self.vm_params.setdefault("DiskCategory",
self.vm_params['DiskCategory'])
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def delete_disk(self, diskid):
request = DeleteDiskRequest.DeleteDiskRequest()
key_list = ["DiskId"]
self.vm_params["DiskId"] = diskid
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def attach_disk(self, instance_id, diskid=None):
request = AttachDiskRequest.AttachDiskRequest()
key_list = ["InstanceId", "DiskId"]
self.vm_params["InstanceId"] = instance_id
self.vm_params["DiskId"] = diskid
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def detach_disk(self, instance_id, diskid=None):
request = DetachDiskRequest.DetachDiskRequest()
key_list = ["InstanceId", "DiskId"]
self.vm_params["InstanceId"] = instance_id
self.vm_params["DiskId"] = diskid
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def create_nic(self, primary_ip_address=None):
request = CreateNetworkInterfaceRequest.CreateNetworkInterfaceRequest()
key_list = [
"NetworkInterfaceName", "PrimaryIpAddress", "VSwitchId",
"SecurityGroupId"
]
self.vm_params["PrimaryIpAddress"] = primary_ip_address
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def attach_nic(self, instance_id, nic_id):
request = AttachNetworkInterfaceRequest.AttachNetworkInterfaceRequest()
key_list = ["InstanceId", "NetworkInterfaceId"]
self.vm_params["InstanceId"] = instance_id
self.vm_params["NetworkInterfaceId"] = nic_id
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def describe_nics(self,
instance_id=None,
nic_type=None,
nic_name="default",
nic_ids=None):
request = DescribeNetworkInterfacesRequest.\
DescribeNetworkInterfacesRequest()
key_list = ["InstanceId", "Type"]
self.vm_params["InstanceId"] = instance_id
self.vm_params["Type"] = nic_type
if nic_name:
if not nic_name == "default":
self.vm_params["NetworkInterfaceName"] = nic_name
key_list.append("NetworkInterfaceName")
if nic_ids:
if not isinstance(nic_ids, str):
nic_ids = ','.join(nic_ids)
key_list.append("NetworkInterfaceIds")
self.vm_params["NetworkInterfaceIds"] = nic_ids
key_list.append("PageSize")
self.vm_params["PageSize"] = 500
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def detach_nic(self, instance_id, nic_id):
request = DetachNetworkInterfaceRequest.DetachNetworkInterfaceRequest()
key_list = ["InstanceId", "NetworkInterfaceId"]
self.vm_params["InstanceId"] = instance_id
self.vm_params["NetworkInterfaceId"] = nic_id
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def delete_nic(self, nic_id):
request = DeleteNetworkInterfaceRequest.DeleteNetworkInterfaceRequest()
key_list = ["NetworkInterfaceId"]
self.vm_params["NetworkInterfaceId"] = nic_id
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
def get_console_log(self, instance_id):
request = GetInstanceConsoleOutputRequest.GetInstanceConsoleOutputRequest(
)
key_list = ['InstanceId']
self.vm_params["InstanceId"] = instance_id
request = self._add_params(request, key_list, self.vm_params)
return self._send_request(request)
class Aliyun(object):
"""
:param access_key: access_key.
:param access_secret: access_secret.
:param region: region.
"""
def __init__(self, access_key, access_secret, region="cn-beijing"):
self.region = region
self.client = AcsClient(access_key, access_secret, self.region)
self.zones = None
def request_page_query(self, req):
page_size = 50
index = 1
req.set_query_params({'PageSize': page_size})
req.set_query_params({'PageNumber', index})
body = self.client.do_action_with_exception(req)
res = json.loads(body.decode("utf-8"))
total_count = res['TotalCount']
if total_count <= page_size:
yield res
else:
current_count = total_count
while current_count < total_count:
index += 1
req.set_query_params({'PageNumber', index})
body = self.client.do_action_with_exception(req)
current_count += page_size
yield json.loads(body.decode("utf-8"))
def get_zone(self, zone_id):
if not self.zones:
self.zones = self.__request_zones()
for zone in self.zones:
if zone['ZoneId'] == zone_id:
return zone
raise ValueError("Invalid ZoneId.")
def __request_zones(self):
req = DescribeZonesRequest.DescribeZonesRequest()
result = self.__do_request(req)["Zones"]["Zone"]
return result
def __do_request(self, req):
body = self.client.do_action_with_exception(req)
return json.loads(body.decode("utf-8"))
def create_instance(self, instance):
"""
:param Instance instance: class Instance
:param callback: callback function run after instance creation successfully.
"""
c = instance.config
zone = self.get_zone(c.ZoneId)
check_resource_types(zone)
check_instance_type(zone, instance.is_io_optimized, c.InstanceType)
req = self.prepare_instance_create_request(zone, instance)
res = self.__do_request(req)
return res
def prepare_instance_create_request(self, zone, instance):
c = instance.config
request = CreateInstanceRequest.CreateInstanceRequest()
request.set_accept_format('json')
request.add_query_param('RegionId', self.region)
for k, v in c.items():
request.add_query_param(k, v)
check_system_disk_categories(zone, instance.is_io_optimized, instance.system_disk.category)
request.add_query_param('SystemDisk.Category', instance.system_disk.category)
request.add_query_param('SystemDisk.Size', instance.system_disk.size)
index = 1
for disk in instance.data_disks:
check_data_disk_categories(zone, instance.is_io_optimized, disk.category)
request.add_query_param('DataDisk.%d.Category' % index, disk.category)
request.add_query_param('DataDisk.%d.Size' % index, disk.size)
index += 1
index = 1
for tag in instance.tags:
request.add_query_param('Tag.%d.Key' % index, tag.key)
request.add_query_param('Tag.%d.Value' % index, tag.value)
index += 1
return request
class Subtitle:
'''
Example:
>>> s = Subtitle('cache')
>>> s.from_audio('target.mp3')
>>> s.to_srt('target.srt)
'''
def __init__(self, dirname=config.cache_dir):
self._dirname = pathlib.Path(dirname)
self._dirname.mkdir(exist_ok=True)
self._data = None
self._client = None
@property
def data(self):
return self._data
@property
def from_(self):
return {
'audio': self.from_audio,
'json': self.from_json,
'srt': self.from_srt,
}
@property
def to(self):
return {
'json': self.to_json,
'srt': self.to_srt,
}
def from_audio(self, filename, delay=10, **kwargs):
# https://help.aliyun.com/document_detail/90727.html
path = self._dirname / filename
with OSS(str(path)) as oss:
task_id = self._trans(oss.url, **kwargs)
response = self._polling(task_id, delay=delay)
self._data = response['Result']['Sentences']
def from_json(self, filename):
self._data = json.loads((self._dirname / filename).read_text())
def from_srt(self, filename, channel_id=0):
def f(pattern):
(h, m, s), (ms, ) = (map(int, p.split(':'))
for p in pattern.split(','))
return 1000 * (60 * (60 * h + m) + s) + ms
def g(part):
_, times, text = part.splitlines()
begin, end = map(f, times.split(' --> '))
return dict(BeginTime=begin,
EndTime=end,
Text=text,
ChannelId=channel_id)
self._data = list(
g(p) for p in (self._dirname / filename).read_text().split('\n\n')
if p)
def to_json(self, filename):
(self._dirname / filename).write_text(
json.dumps(self._data, ensure_ascii=False))
def to_srt(self, filename, channel_id=0):
path = self._dirname / filename
data = filter(lambda x: x['ChannelId'] == channel_id, self._data)
pattern = '{h:02}:{m:02}:{s:02},{ms:03}'
with open(str(path), 'w') as f:
for ith, item in enumerate(
sorted(data, key=lambda x: x['BeginTime'])):
start, end = (self._time(item[k], pattern)
for k in ('BeginTime', 'EndTime'))
f.write(f'{ith}\n{start} --> {end}\n{item["Text"]}\n\n')
def _trans(self, url, **kwargs):
# 创建 AcsClient 实例
self._client = AcsClient(
config.access_key['id'],
config.access_key['secret'],
'cn-shanghai',
)
# 提交录音文件识别请求
request = self._request(get_or_post=False)
task = dict(
appkey=config.clound['app_key'],
file_link=url,
version='4.0',
enable_words=True,
enable_sample_rate_adaptive=True,
)
task.update(kwargs)
request.add_body_params('Task', json.dumps(task))
try:
response = json.loads(
self._client.do_action_with_exception(request))
if response['StatusText'] == 'SUCCESS':
return response['TaskId']
except (ServerException, ClientException):
pass
def _polling(self, task_id, delay=10):
# 创建 CommonRequest，设置任务 ID
request = self._request(get_or_post=True)
request.add_query_param('TaskId', task_id)
# 提交录音文件识别结果查询请求
while True:
try:
response = json.loads(
self._client.do_action_with_exception(request))
if response['StatusText'] not in ('RUNNING', 'QUEUEING'):
return response
time.sleep(delay)
except (ServerException, ClientException):
pass
def _request(self, get_or_post=True):
# 'get' if get_or_post else 'post'
request = CommonRequest()
request.set_domain('filetrans.cn-shanghai.aliyuncs.com')
request.set_version('2018-08-17')
request.set_product('nls-filetrans')
request.set_action_name(
'GetTaskResult' if get_or_post else 'SubmitTask')
request.set_method('GET' if get_or_post else 'POST')
return request
def _time(self, microsecond, pattern='{h:02}:{m:02}:{s:02},{ms:03}'):
def f(microsecond):
for c in (1000, 60, 60, 60):
yield microsecond % c
microsecond //= c
ms, s, m, h = f(microsecond)
return pattern.format(ms=ms, s=s, m=m, h=h)
else:
# 正常不应该有多条相同的记录，如果存在这种情况，应该手动去网站检查核实是否有操作失误
logger.debug("存在多个相同子域名解析记录值，请核查删除后再操作！")
if __name__ == "__main__":
# 获取阿里云keyid和secret
keyid = config.get("access", "keyid")
secret = config.get("access", "secret")
regionId = config.get("access", "regionId")
DomainName = config.get("domain", "domain_name")
SubDomainList = config.get_all("subdomain")
# 配置认证信息
client = AcsClient(keyid, secret, regionId)
dynamicIP = getIp()
for subdomain in SubDomainList:
setDomainRecord(client, dynamicIP, subdomain, DomainName)
# 删除记录测试
# delDomainRecord(client,'b.jsoner.com')
# 新增或更新记录测试
# setDomainRecord(client,'192.168.3.222','a',DomainName)
# 获取记录测试
# logger.debug (getDomainInfo(DomainName, 'y'))
def get_client():
global client
if client is None:
from django.conf import settings
client = AcsClient(settings.SMS_ACCESS_KEY_ID, settings.SMS_ACCESS_KEY_SECRET, 'cn-hangzhou')
return client
logger.setLevel(logging.INFO)
handler1.setLevel(logging.INFO)
handler2.setLevel(logging.INFO)
formatter = logging.Formatter("%(asctime)s %(name)s %(levelname)s %(message)s")
handler1.setFormatter(formatter)
handler2.setFormatter(formatter)
logger.addHandler(handler1)
logger.addHandler(handler2)
f = open(os.path.join(path, 'alyDDNS.json'))
config = json.load(f)
f.close()
client = AcsClient(config['access_key'], config['access_secret'],
'cn-hangzhou')
ip = get_wan_ip()
if not ip:
logger.info('can not get ip, abort')
logger.info('local wan ip: ' + ip)
for sub in config['sub']:
domain_name = sub + '.' + config['domain']
logger.info('run update for domain: ' + domain_name)
records = list_domain_records(client, domain_name)
exist = False
rid = None
for record in records:
if record['Type'] == 'A':
exist = True
class ALiApi:
accessKeyId = ""
accessSecret = ""
productKey = ""
client = AcsClient(accessKeyId, accessSecret, 'cn-shanghai')
def __new__(cls, *args, **kwargs):
if not hasattr(cls, 'instance'):
cls.instance = super().__new__(cls)
if os.path.exists("config/productkey.config"):
with open("config/productkey.config", "r") as f:
ALiApi.productKey = f.readline()
ALiApi().get_infor_data()
else:
QMessageBox.critical(QWidget(), "错误", "请设置有效产品验证码！")
exit(1)
return cls.instance
@staticmethod
def get_current_th(devicename):
request = QueryDevicePropertyStatusRequest()
request.set_accept_format('json')
request.set_ProductKey(ALiApi.productKey)
request.set_DeviceName(devicename)
response = ALiApi.client.do_action_with_exception(request)
data = json.loads(str(response, encoding='utf-8'))
return data["Data"]["List"]["PropertyStatusInfo"][0]["Value"], data[
"Data"]["List"]["PropertyStatusInfo"][1]["Value"]
@staticmethod
def get_history_data():
pass
@staticmethod
def get_infor_version(devicename):
request = QueryDeviceDesiredPropertyRequest()
request.set_accept_format('json')
request.set_ProductKey(ALiApi.productKey)
request.set_DeviceName(devicename)
request.set_Identifiers(["infor"])
response = ALiApi.client.do_action_with_exception(request)
data = json.loads(str(response, encoding='utf-8'))
return int(data["Data"]["List"]["DesiredPropertyInfo"][0]["Version"])
@staticmethod
def get_infor_data():
request = QueryProductRequest()
request.set_accept_format('json')
request.set_ProductKey(ALiApi.productKey)
response = ALiApi.client.do_action_with_exception(request)
data = json.loads(str(response, encoding='utf-8'))
if not data["Success"]:
QMessageBox.critical(QWidget(), "错误", "产品验证码有误！")
exit(1)
return False
else:
data_list = str(data["Data"]["Description"]).split("\n")
return data_list[0], data_list[1], data_list[2]
@staticmethod
def get_propertyinfo(devicename, property_name, start_time, end_time):
request = QueryDevicePropertyDataRequest()
request.set_accept_format('json')
request.set_StartTime(ALiApi.to_datatime(start_time))
request.set_EndTime(ALiApi.to_datatime(end_time))
request.set_Asc("0")
request.set_PageSize(50)
request.set_Identifier(property_name)
request.set_ProductKey(ALiApi.productKey)
request.set_DeviceName(devicename)
response = ALiApi.client.do_action_with_exception(request)
data = json.loads(str(response, encoding='utf-8'))
return data
@staticmethod
def set_infor_data(username, passwd, email):
request = UpdateProductRequest()
request.set_accept_format('json')
request.set_ProductName("温湿度监测")
request.set_ProductKey(ALiApi.productKey)
data = username + "\n" + passwd + "\n" + email + "\n"
request.set_Description(data)
response = ALiApi.client.do_action_with_exception(request)
data = json.loads(str(response, encoding='utf-8'))
if not data["Success"]:
return False
else:
return True
@staticmethod
def register_device(device_name):
request = RegisterDeviceRequest()
request.set_accept_format('json')
request.set_ProductKey(ALiApi.productKey)
request.set_DeviceName(device_name)
response = ALiApi.client.do_action_with_exception(request)
data = json.loads(str(response, encoding='utf-8'))
if not data["Success"]:
return False, data["ErrorMessage"]
else:
return True, "注册成功"
@staticmethod
def to_datatime(string):
time_array = time.strptime(string, "%Y/%m/%d %H:%M:%S")
time_stamp = int(time.mktime(time_array))
return int(str(time_stamp) + "000")
from conf import alert_conf
from src.lib import db_mysql
try:
import simplejson as json
except ImportError:
import json
file_path = os.path.join(os.path.dirname(__file__), "../../../conf/key.conf")
cf = configparser.ConfigParser()
cf.read(file_path)
ak_section = "aliyun_master"
accessid = cf.get(ak_section, 'AccessKeyId')
accesssecret = cf.get(ak_section, 'AccessKeySecret')
regionid = cf.get(ak_section, 'DefaultRegionId')
client = AcsClient(accessid, accesssecret, regionid)
page_size = 100 # 单个页面的最大告警条数
def get_LoadBalancerName(loadbalancerid): # 通过slb api获取loadbalancername
request = DescribeLoadBalancerAttributeRequest()
request.set_accept_format('json')
request.set_LoadBalancerId(loadbalancerid)
loadbalancername = ''
try:
response = client.do_action_with_exception(request)
except aliyunsdkcore.acs_exception.exceptions.ServerException:
print("aliyunsdkcore.acs_exception.exceptions.ServerException")
except:
print("except")
else:
import socket, fcntl, struct, sys
rc_rr = "i" # 指代二级域名（子域名，空则使用 @ 代替）
rc_domain = "aharobo.com" # 指代完整域名，若未配置阿里云 NameServer 解析修改也无效
rc_format = "json" # 指定返回数据格式，目前本例使用 JSON 数据
rc_type = "A" # 指定修改记录类型，目前本例使用 A 记录
rc_ttl = "600" # 指定修改 TTL 值，目前本例使用 600 秒
rc_format = "json" # 使用 JSON 返回数据，也可以填写为 XML
access_key_id = "" # 这里为 Aliyun AccessKey 信息
access_key_secret = "" # 这里为 Aliyun AccessKey 信息
ID = "LTAI4Fuk8cLyiBCyevEYW29V"
Secret = "ydd39f2iV0HtlvnS101JwfgXxSYDsv"
Zone = 'cn-zhangjiakou'
clt = AcsClient(ID, Secret, Zone)
def check_record_id(dns_rr, dns_domain):
times = 0 # 用于检查对应子域名的记录信息
check = 0 # 用于确认对应子域名的记录信息
request = CommonRequest()
request.set_accept_format('json') # 设置返回格式
request.set_domain('alidns.aliyuncs.com') # 阿里云服务
request.set_method('POST')
request.set_protocol_type('https')
request.set_version('2015-01-09')
request.set_action_name('DescribeDomainRecords')
request.add_query_param('DomainName', rc_domain) # 设置请求域名
request.add_query_param('RRKeyWord', rc_rr)
request.add_query_param('TypeKeyWord', rc_type)
#!/usr/bin/env python
# coding=utf-8
import os
from aliyunsdkcore.client import AcsClient
from aliyunsdkemr.request.v20160408.CreateClusterV2Request import CreateClusterV2Request
client = AcsClient(os.environ['ACCESS_KEY_ID'],
os.environ['ACCESS_KEY_SECRET'],
'eu-central-1',
timeout=40,
max_retry_time=5)
request = CreateClusterV2Request()
request.set_accept_format('json')
request.set_EasEnable(False)
request.set_IsOpenPublicIp(False)
request.set_SshEnable(True)
request.set_InstanceGeneration("ecs-3")
request.set_KeyPairName("alibaba-de")
request.set_Period(1)
request.set_MachineType("ECS")
request.set_MasterPwd("Lenin1922$")
request.set_DepositType("HALF_MANAGED")
request.set_ZoneId("eu-central-1a")
request.set_SecurityGroupName("emr-security-group")
request.set_ChargeType("PostPaid")
request.set_NetType("vpc")
request.set_VSwitchId("vsw-gw8ue96459069ui8pl8pc")
request.set_VpcId("vpc-gw8b865ld4labpkquw3di")
#!/usr/bin/env python3 # coding=utf-8 # [email protected] # 需要先安装阿里云的接口 # pip3 install aliyun-python-sdk-core-v3 import sys import json import argparse from aliyunsdkcore.client import AcsClient from aliyunsdkcore.request import CommonRequest # 需要先获取 aliyun 账号的 AccessKey 信息 client = AcsClient('AccessKeyID', 'AccessKeySecret', 'default') domain_name = 'xxx.com' def help_doc(): aaa = ''' !!!something wrong, plz check it!!! usage: alidns.py [-h] [--add | --delete | --update | --get] RR TYPE ADDRESS [RR TYPE ADDRESS ...] 针对 xxx.com 域名记录进行相关操作 positional arguments: RR TYPE ADDRESS 记录 类型 地址 optional arguments: -h, --help show this help message and exit -a, --add add domain record. (e.g. --add RR TYPE ADDRESS)
def fileTrans(akId, akSecret, appKey, fileLink):
# 地域ID，常量内容，请勿改变
REGION_ID = "cn-shanghai"
PRODUCT = "nls-filetrans"
DOMAIN = "filetrans.cn-shanghai.aliyuncs.com"
API_VERSION = "2018-08-17"
POST_REQUEST_ACTION = "SubmitTask"
GET_REQUEST_ACTION = "GetTaskResult"
# 请求参数key
KEY_APP_KEY = "appkey"
KEY_FILE_LINK = "file_link"
KEY_VERSION = "version"
KEY_ENABLE_WORDS = "enable_words"
# 是否开启智能分轨
KEY_AUTO_SPLIT = "auto_split"
# 响应参数key
KEY_TASK = "Task"
KEY_TASK_ID = "TaskId"
KEY_STATUS_TEXT = "StatusText"
KEY_RESULT = "Result"
# 状态值
STATUS_SUCCESS = "SUCCESS"
STATUS_RUNNING = "RUNNING"
STATUS_QUEUEING = "QUEUEING"
# 创建AcsClient实例
client = AcsClient(akId, akSecret, REGION_ID)
# 提交录音文件识别请求
postRequest = CommonRequest()
postRequest.set_domain(DOMAIN)
postRequest.set_version(API_VERSION)
postRequest.set_product(PRODUCT)
postRequest.set_action_name(POST_REQUEST_ACTION)
postRequest.set_method('POST')
# 新接入请使用4.0版本，已接入(默认2.0)如需维持现状，请注释掉该参数设置
# 设置是否输出词信息，默认为false，开启时需要设置version为4.0
task = {
KEY_APP_KEY: appKey,
KEY_FILE_LINK: fileLink,
KEY_VERSION: "4.0",
KEY_ENABLE_WORDS: False
}
# 开启智能分轨，如果开启智能分轨 task中设置KEY_AUTO_SPLIT : True
# task = {KEY_APP_KEY : appKey, KEY_FILE_LINK : fileLink, KEY_VERSION : "4.0", KEY_ENABLE_WORDS : False, KEY_AUTO_SPLIT : True}
task = json.dumps(task)
print(task)
postRequest.add_body_params(KEY_TASK, task)
taskId = ""
try:
postResponse = client.do_action_with_exception(postRequest)
postResponse = json.loads(postResponse)
print(postResponse)
statusText = postResponse[KEY_STATUS_TEXT]
if statusText == STATUS_SUCCESS:
print("录音文件识别请求成功响应！")
taskId = postResponse[KEY_TASK_ID]
else:
print("录音文件识别请求失败！")
return
except ServerException as e:
print(e)
except ClientException as e:
print(e)
# 创建CommonRequest，设置任务ID
getRequest = CommonRequest()
getRequest.set_domain(DOMAIN)
getRequest.set_version(API_VERSION)
getRequest.set_product(PRODUCT)
getRequest.set_action_name(GET_REQUEST_ACTION)
getRequest.set_method('GET')
getRequest.add_query_param(KEY_TASK_ID, taskId)
# 提交录音文件识别结果查询请求
# 以轮询的方式进行识别结果的查询，直到服务端返回的状态描述符为"SUCCESS"、"SUCCESS_WITH_NO_VALID_FRAGMENT"，
# 或者为错误描述，则结束轮询。
statusText = ""
while True:
try:
getResponse = client.do_action_with_exception(getRequest)
getResponse = json.loads(getResponse)
print(getResponse)
statusText = getResponse[KEY_STATUS_TEXT]
if statusText == STATUS_RUNNING or statusText == STATUS_QUEUEING:
# 继续轮询
time.sleep(10)
else:
# 退出轮询
break
except ServerException as e:
print(e)
except ClientException as e:
print(e)
if statusText == STATUS_SUCCESS:
print("录音文件识别成功！")
print(getResponse['Result'])
else:
print("录音文件识别失败！")
return
#!/usr/bin/env python
#coding=utf-8
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkiot.request.v20180120.CreateRuleActionRequest import CreateRuleActionRequest
client = AcsClient('<accessKeyId>', '<accessSecret>', 'cn-shanghai')
request = CreateRuleActionRequest()
request.set_accept_format('json')
request.set_Type("REPUBLISH")
request.set_Configuration({
"topic":"/a19wpcZaBOO/FaUcrp722sDCzr2tSeXe/user/update",
"topicType":1
})
request.set_RuleId("330322")
request.set_ErrorActionFlag(False)
response = client.do_action_with_exception(request)
# python2: print(response)
print(response)
def clt(self):
clt = AcsClient(self.accesskey,self.accesssecret,self.regionid)
return clt
#!/usr/bin/env python
#coding=utf-8
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import CommonRequest
client = AcsClient('<accessKeyId>', '<accessSecret>', 'cn-hangzhou')
request = CommonRequest()
request.set_accept_format('json')
request.set_domain('dysmsapi.aliyuncs.com')
request.set_method('POST')
request.set_protocol_type('https') # https | http
request.set_version('2017-05-25')
request.set_action_name('SendSms')
request.add_query_param('RegionId', "cn-hangzhou")
request.add_query_param('PhoneNumbers', "17645109827")
request.add_query_param('SignName', "红茶不加冰")
request.add_query_param('TemplateCode', "SMS_185840990")
request.add_query_param('TemplateParam', "{\"code\":\"4564\"}")
response = client.do_action(request)
# python2: print(response)
print(str(response, encoding='utf-8'))
class DDNS:
'''针对指定域名的主机记录为A的动态域名解析'''
my_ip = None
def __init__(self, access_key_id, access_key_secret, domain, rr="@"):
'''针对指定域名的DDNS初始化'''
self.domain = domain
self.rr = rr
self.type = type
# AcsClient连接
self.__client = AcsClient(access_key_id, access_key_secret,
'cn-hangzhou')
# 使用CommonRequest进行调用
self.__request = CommonRequest()
# CommonRequest请求公共参数
self.__public_request()
# 初次请求
response = self.__Initial_request(domain, rr)
#保存返回解析记录
self.save_record(response)
def __public_request(self):
# 设置CommonRequest返回格式
self.__request.set_accept_format('json')
# 设置CommonRequest服务地址
self.__request.set_domain('alidns.aliyuncs.com')
# 设置CommonRequest提交方式
self.__request.set_method('POST')
# 设置CommonRequest通讯协议
self.__request.set_protocol_type('https') # https | http
# 设置CommonRequest版本信息
self.__request.set_version('2015-01-09')
def __Initial_request(self, domain_name, rr_word, type_word='A'):
# 请求操作接口名：DescribeDomainRecords
self.__request.set_action_name('DescribeDomainRecords')
# 请求指定域名
self.__request.add_query_param('DomainName', domain_name)
# 请求指定主机记录
self.__request.add_query_param('RRKeyWord', rr_word)
# 请求指定解析类型
self.__request.add_query_param('TypeKeyWord', type_word)
# 发送请求,并获取返回参数或错误
response = self.__client.do_action_with_exception(self.__request)
return response
def save_record(self, response):
'''保存需要的解析记录'''
if sys.version_info > (3, 0):
response = response.decode('utf-8')
# json转换
response = json.JSONDecoder().decode(response)
if 'DomainRecords' in response:
# 获取解析记录
response = response['DomainRecords']
if 'Record' in response:
response = response['Record']
if len(response) == 0:
print(
cprint('No ', '31') +
cprint(self.rr + "." + self.domain, '36') +
cprint(" parsing record!", '31'))
self.__status = False
return
elif len(response) == 1:
response = response[0]
# 获取解析记录IP
self.__parser_ip = response['Value']
# 获取解析记录RecordId
self.__record_id = response['RecordId']
# 获取解析记录RR
self.__rr = response['RR']
# 获取解析记录Type
self.__type = response['Type']
# 获取解析记录ttl
self.__ttl = response['TTL']
# DDNS状态
self.__status = True
@staticmethod
def native_ip(url="http://txt.go.sohu.com/ip/soip"):
'''获取本机当前公网ip'''
# 判断当前python版本
if sys.version_info < (3, 0):
# python2.*导入的模块
import urllib2
url = urllib2.urlopen(url)
text = url.read()
ip = re.findall(r'\d+.\d+.\d+.\d+', text)
DDNS.my_ip = "{0}".join(ip)
return "{0}".join(ip)
else:
# python3.*导入的模块
import urllib
url = urllib.request.urlopen(url)
text = url.read().decode('utf-8')
ip = re.findall(r'\d+.\d+.\d+.\d+', text)
DDNS.my_ip = "{0}".join(ip)
return "{0}".join(ip)
def parser_ip(self):
'''获取解析记录IP'''
# 判断DDNS初始化是否成功
if not self.__status:
return
# 请求操作接口名：DescribeDomainRecordInfo
self.__request.set_action_name('DescribeDomainRecordInfo')
# 请求指定解析记录的ID
self.__request.add_query_param('RecordId', self.__record_id)
# 发送请求,并获取返回参数或错误
response = self.__client.do_action_with_exception(self.__request)
# 保存新的解析记录
self.save_record(response)
return self.__parser_ip
def update_ip(self, dns_value, dns_ttl='600'):
'''更新解析ip'''
# 判断DDNS初始化是否成功
if not self.__status:
return
# 请求操作接口名：UpdateDomainRecord
self.__request.set_action_name('UpdateDomainRecord')
# 请求解析记录的ID：RecordId
self.__request.add_query_param('RecordId', self.__record_id)
# 请求设置解析记录的主机记录：RR
self.__request.add_query_param('RR', self.__rr)
# 请求设置解析记录类型：Type
self.__request.add_query_param('Type', self.__type)
# 请求设置解析记录的记录值：IP
self.__request.add_query_param('Value', dns_value)
# 请求设置生存时间：TTL
self.__request.add_query_param('TTL', dns_ttl)
# 发送请求,并获取返回参数或错误
response = self.__client.do_action_with_exception(self.__request)
return response
# @Time : 2020/9/17 11:09
# @Software: PyCharm
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from aliyunsdkbssopenapi.request.v20171214.QueryInstanceBillRequest import QueryInstanceBillRequest
from cmdb import models as cmdbmodels
from midplatform import settings
from common import baseconfig
import json
accesskeyId = baseconfig.getconfig()['accessKey']
accessSecret = baseconfig.getconfig()['accessSecret']
client = AcsClient(accesskeyId, accessSecret, 'cn-hangzhou')
request = QueryInstanceBillRequest()
request.set_accept_format('json')
def syncMonthBill(month, pagesize):
if pagesize not in range(20, 301):
settings.RESULT['code'] = 2009
settings.RESULT['msg'] = 'fail'
settings.RESULT['data'] = 'pagesize 请选择[20,300]之间'
return settings.RESULT
request.set_BillingCycle(month)
request.set_PageSize(1)
def __init__(self):
self.client = AcsClient(configs.ALIYUN_ACCESS_KEY_ID,
configs.ALIYUN_SECRET)
class RsaKeyPairSigner(Signer):
_MIN_SESSION_PERIOD = 900
_MAX_SESSION_PERIOD = 3600
_RETRY_DELAY_FAST = 3
_PRIORITY = 1
def __init__(self, rsa_key_pair_credential, region_id, debug=False):
if not debug and rsa_key_pair_credential.session_period < self._MIN_SESSION_PERIOD \
or rsa_key_pair_credential.session_period > self._MAX_SESSION_PERIOD:
raise exceptions.ClientException(
error_code.SDK_INVALID_SESSION_EXPIRATION,
error_msg.get_msg('SDK_INVALID_SESSION_EXPIRATION').format(self._MIN_SESSION_PERIOD,
self._MAX_SESSION_PERIOD))
rsa_key_pair_credential.region_id = region_id
self._public_key_id = rsa_key_pair_credential.public_key_id
self._private_key = rsa_key_pair_credential.private_key
self._session_period = rsa_key_pair_credential.session_period
self._schedule_interval = rsa_key_pair_credential.session_period if debug \
else max(rsa_key_pair_credential.session_period * 0.8, 5)
from aliyunsdkcore.client import AcsClient
self._sts_client = AcsClient(self._public_key_id, self._private_key, rsa_key_pair_credential.region_id)
self._session_credential = None
self._get_session_ak_and_sk()
self._scheduler = sched.scheduler(time.time, time.sleep)
self._daemon_thread = threading.Thread(target=self._refresh_session_ak_and_sk, args=[True, 0])
self._daemon_thread.setDaemon(True)
self._daemon_thread.start()
def sign(self, region_id, request):
session_ak, session_sk = self._session_credential
header = request.get_signed_header(region_id, session_ak, session_sk)
url = request.get_url(region_id, session_ak, session_sk)
return header, url
def _get_session_ak_and_sk(self):
request = GetSessionAkRequest()
request.set_method("GET")
request.set_duration_seconds(self._session_period)
try:
response_str = self._sts_client.do_action_with_exception(request)
response = json.loads(response_str)
session_ak = str(response.get("SessionAccessKey").get("SessionAccessKeyId"))
session_sk = str(response.get("SessionAccessKey").get("SessionAccessKeySecret"))
self._session_credential = session_ak, session_sk
except exceptions.ServerException as srv_ex:
if srv_ex.error_code == 'InvalidAccessKeyId.NotFound' or srv_ex.error_code == 'SignatureDoesNotMatch':
raise exceptions.ClientException(error_code.SDK_INVALID_CREDENTIAL,
error_msg.get_msg('SDK_INVALID_CREDENTIAL'))
else:
raise
# no-limit-retry if failed with any conditions.
# fast retry in first 3 times, then the interval becomes incremental.
# the max interval is 10 minutes.
def _refresh_session_ak_and_sk(self, is_init, retry_times=0):
delay = self._schedule_interval
next_retry_time = 0
try:
if not is_init:
self._get_session_ak_and_sk()
except (Exception, socket.error) as ex:
if retry_times <= 3:
delay = self._RETRY_DELAY_FAST
else:
delay = 60 * min(10, retry_times)
next_retry_time = retry_times + 1
logging.warn(
'refresh session ak failed, auto retry after {} seconds. message = {}'.format(delay, ex))
finally:
self._scheduler.enter(delay, self._PRIORITY, self._refresh_session_ak_and_sk, [False, next_retry_time])
self._scheduler.run()
def __init__(self, REGION, DOMAIN, PRODUCT_NAME, sms_access_key_id, sms_access_key_secret, ):
self.acs_client = AcsClient(sms_access_key_id, sms_access_key_secret, REGION)
region_provider.add_endpoint(PRODUCT_NAME, REGION, DOMAIN)
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
# coding=utf-8
import os
import sys
parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, parent_dir)
from aliyunsdkcore.client import AcsClient
from aliyunsdkcore.request import RpcRequest
client = AcsClient('your_access_key', 'your_access_secret', 'cn-hangzhou')
location_service = client.get_location_service()
location_service.set_location_service_attr(region='cn-beijing',
product_name="Location",
domain="location.aliyuncs.com")
domain = location_service.find_product_domain(client.get_region_id(), 'oss');
print domain
domain = location_service.find_product_domain(client.get_region_id(), 'oss');
print domain
class DescribeRegionsRequest(RpcRequest):
def __init__(self, OwnerId = None, ResourceOwnerAccount = None,
ResourceOwnerId = None, OwnerAccount = None):
RpcRequest.__init__(self, 'Ecs', '2014-05-26', 'DescribeRegions', 'oss')
