def MSTrigUpdate_Master(AnotherFunctionName, AnotherRegion, AnotherNamespace,
TriggerName, FunctionName, Namespace):
global SecretId, SecretKey, Region
try:
cred = credential.Credential(SecretId, SecretKey)
client = scf_client.ScfClient(cred, AnotherRegion)
except TencentCloudSDKException as err:
print(err)
# 启动从函数
pass_params = {
"FunctionName": FunctionName,
"Region": Region,
"Namespace": Namespace,
"TriggerName": TriggerName,
"SecretId": SecretId,
"SecretKey": SecretKey
}
pass_params_str = json.dumps(pass_params)
req = models.InvokeRequest()
params = '{"FunctionName":"' + AnotherFunctionName + '",'
params += '"InvocationType":"Event",'
params += '"ClientContext":"' + pass_params_str + '",'
params += '"Namespace":"' + AnotherNamespace + '"}'
req.from_json_string(params)
return
def __init__(self):
uc = UserConfig()
self._cred = credential.Credential(secretId=uc.secret_id,
secretKey=uc.secret_key)
self._region = uc.region
cp = ClientProfile("TC3-HMAC-SHA256")
self._client = scf_client.ScfClient(self._cred, self._region, cp)
def __init__(self):
self.name = QC_NAME
self.region = REGION
self.logger = getLogger()
self.logger.info("Init Qcloud SCF Client...\n")
self.logger.info("The region is: %s\n" % self.region)
cred = credential.Credential(QC_API_ID, QC_API_KEY)
self.logger.info("The secert info:")
self.logger.info("Secret Id: %s" % (QC_API_ID[0:5]+"******"))
self.logger.info("Secret Key: %s\n" % (QC_API_KEY[0:5]+"******"))
httpProfile = HttpProfile()
httpProfile.reqMethod = "GET"
httpProfile.reqTimeout = 30
httpProfile.endpoint = QC_ENDPOINT_MODEL % self.region
self.logger.info("The request endpoint is: %s\n" % httpProfile.endpoint)
httpProfile.keepAlive = True
clientProfile = ClientProfile()
clientProfile.signMethod = "HmacSHA256"
clientProfile.httpProfile = httpProfile
self.client = scf_client.ScfClient(cred, 'ap-' + self.region, clientProfile)
self.logger.info("SCF client init success!\n")
self.logger.info("Start to get VPC info...")
self.logger.info("VPC id is: %s"% QC_VPC)
self.logger.info("VPC-Subnet id is: %s\n" % QC_SUBNET)
def __init__(self,
region=None,
secret_id=None,
secret_key=None,
token=None):
self.region = region if region is not None \
else os.environ.get("TENCENTCLOUD_REGION", "ap-guangzhou")
self.secret_id = secret_id if secret_id is not None \
else os.environ.get("TENCENTCLOUD_SECRETID", None)
self.secret_key = secret_key if secret_key is not None \
else os.environ.get("TENCENTCLOUD_SECRETKEY", None)
self.token = token if token is not None \
else os.environ.get("TENCENTCLOUD_SESSIONTOKEN", None)
self.env = os.environ.get("TENCENTCLOUD_RUNENV", None)
self.endpoint = "scf.internal.tencentcloudapi.com" if self.env == "SCF" \
else "scf.tencentcloudapi.com"
cred = credential.Credential(self.secret_id, self.secret_key, self.token)
profile = ClientProfile(httpProfile=HttpProfile(reqTimeout=300, keepAlive=True))
self.client = scf_client.ScfClient(cred, self.region, profile=profile)
def __init__(self):
uc = UserConfig()
self._cred = credential.Credential(secretId=uc.secret_id, secretKey=uc.secret_key)
self._region = uc.region
hp = HttpProfile(reqTimeout=ScfClient.CLOUD_API_REQ_TIMEOUT)
cp = ClientProfile("TC3-HMAC-SHA256", hp)
self._client = scf_client.ScfClient(self._cred, self._region, cp)
self._client._sdkVersion = "TCFCLI"
def get_scf_client(secret_info: Dict[str, str]):
cred = credential.Credential(secret_info.get("TENCENT_SECRET_ID"),
secret_info.get("TENCENT_SECRET_KEY"))
http_profile = HttpProfile()
http_profile.endpoint = config.QCLOUD_API_ENDPOINT
client_profile = ClientProfile()
client_profile.httpProfile = http_profile
return scf_client.ScfClient(cred, config.QCLOUD_REGION, client_profile)
def __init__(self, secretId, secretKey, endpoint="scf.tencentcloudapi.com", region_id="ap-hongkong", function_name=None):
cred = credential.Credential(secretId, secretKey)
httpProfile = HttpProfile()
httpProfile.endpoint = endpoint
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
self.client = scf_client.ScfClient(cred, region_id, clientProfile)
self._func_name = function_name
def __init__(self, config):
self.config = config
# scf api client
cred = credential.Credential(config['secret_id'], config['secret_key'])
self.scf_client = scf_client.ScfClient(cred, config['scf_region'])
# cdn api client
cdn_config = {
'Region': 'ap-guangzhou',
'method': 'GET',
'secretId': config['secret_id'],
'secretKey': config['secret_key'],
'SignatureMethod': 'HmacSHA1',
}
self.cdn_client = QcloudApi("cdn", cdn_config)
self.cos_path = config['cos_path']
def ABTrigUpdate(AnotherFunctionName, AnotherRegion, AnotherNamespace,
TriggerName):
global SecretId, SecretKey, Region
try:
cred = credential.Credential(SecretId, SecretKey)
client = scf_client.ScfClient(cred, AnotherRegion)
except TencentCloudSDKException as err:
print(err)
# 删除旧触发器
try:
req = models.DeleteTriggerRequest()
params = '{"FunctionName":"' + AnotherFunctionName + '",'
params += '"TriggerName":"' + TriggerName + '",'
params += '"Namespace":"' + AnotherNamespace + '",'
params += '"Type":"timer"}'
req.from_json_string(params)
resp = client.DeleteTrigger(req)
print(resp.to_json_string())
except TencentCloudSDKException as err:
print(err)
# 添加新触发器
try:
next_time = time.time()
next_time += random.randint(random_time_lowerlimit,
random_time_toplimit)
req = models.CreateTriggerRequest()
params = '{"FunctionName":"' + AnotherFunctionName + '",'
params += '"TriggerName":"' + TriggerName + '",'
params += '"Namespace":"' + AnotherNamespace + '",'
params += '"Type":"timer",'
params += '"Enable":"OPEN",'
params += '"TriggerDesc":"' + \
to_china_timezone_cron(next_time) + '"}'
req.from_json_string(params)
resp = client.CreateTrigger(req)
print(resp.to_json_string())
except TencentCloudSDKException as err:
print(err)
return
def kafka_consumer_api_handler(cred, partition_id, region, consumer_function_name, namespace):
try:
# 实例化要请求产品的client对象，以及函数所在的地域
client = scf_client.ScfClient(cred, region)
# 接口参数,输入需要调用的函数名，RequestResponse(同步) 和 Event(异步)
function_name = consumer_function_name
logger.debug('Start Hello World function')
# 调用接口，发起请求，并打印返回结果
req = scf_models.InvokeRequest()
req.FunctionName = function_name
req.Namespace = namespace
req.InvocationType = "Event"
client_param = {"partition_id": partition_id}
req.ClientContext = json.dumps(client_param)
ret = client.Invoke(req)
ret_value = json.loads(s=ret.to_json_string())
logger.debug("ret_value: %s", str(ret_value["Result"]))
except TencentCloudSDKException as err:
logger.error(err)
def EnvWrite(FunctionName,
Namespace,
ms_id,
ms_secret,
refresh_token,
Another=None):
global SecretId, SecretKey, Region
try:
cred = credential.Credential(SecretId, SecretKey)
client = scf_client.ScfClient(cred, Region)
except TencentCloudSDKException as err:
print(err)
req = models.UpdateFunctionConfigurationRequest()
params = '{"FunctionName":"' + FunctionName + '",'
params += '"Namespace":"' + Namespace + '",'
params += '"Environment":{"Variables":['
params += '{"Key":"Region","Value":"' + Region + '"},'
params += '{"Key":"refresh_token","Value":"' + refresh_token + '"},'
params += '{"Key":"ms_id","Value":"' + ms_id + '"},'
params += '{"Key":"ms_secret","Value":"' + ms_secret + '"},'
params += '{"Key":"SecretId","Value":"' + SecretId + '"},'
params += '{"Key":"SecretKey","Value":"' + SecretKey + '"},'
if Another:
for key in Another:
if Another[key]:
params += '{"Key":"' + key + '","Value":"' + Another[
key] + '"},'
params = params.rstrip(",")
params += ']}}'
#print(params)
req.from_json_string(params)
try:
# 以下照抄腾讯云sdk例程
resp = client.UpdateFunctionConfiguration(req)
print(resp.to_json_string())
except TencentCloudSDKException as err:
print(err)
return
def addTags(mapper, connection, target):
print("add tags")
try:
cred = credential.Credential(os.environ.get('tencent_secret_id'),
os.environ.get('tencent_secret_key'))
httpProfile = HttpProfile()
httpProfile.endpoint = "scf.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = scf_client.ScfClient(cred, os.environ.get("region"),
clientProfile)
req = models.InvokeRequest()
params = '{"FunctionName":"Blog_Admin_updateArticle","InvocationType":"Event","ClientContext":"{\\"id\\": %s}","Namespace":"default"}' % (
target.aid)
req.from_json_string(params)
resp = client.Invoke(req)
print(resp)
except TencentCloudSDKException as err:
print(err)
print("end add")
def main_handler(event, context):
try:
provision_params = json.loads(event['Message'])
if len(provision_params) < 4:
return ("Missing parameters")
cred = credential.Credential(
os.environ.get('TENCENTCLOUD_SECRETID'),
os.environ.get('TENCENTCLOUD_SECRETKEY'),
os.environ.get('TENCENTCLOUD_SESSIONTOKEN'))
httpProfile = HttpProfile()
httpProfile.endpoint = "scf.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = scf_client.ScfClient(cred, provision_params["Region"],
clientProfile)
req = models.PutProvisionedConcurrencyConfigRequest()
params = {
"FunctionName":
provision_params.get("FunctionName"),
"Namespace":
provision_params.get("Namespace"),
"Qualifier":
provision_params.get("Qualifier"),
"VersionProvisionedConcurrencyNum":
provision_params.get("VersionProvisionedConcurrencyNum")
}
req.from_json_string(json.dumps(params))
resp = client.PutProvisionedConcurrencyConfig(req)
print(resp.to_json_string())
except TencentCloudSDKException as err:
print(err)
return ("Hello Serverless")
from tencentcloud.common import credential
from tbp import tbp_client, models as tbp_models
from tts import tts_client, models as tts_models
from tencentcloud.scf.v20180416 import scf_client, models as scf_models
bot_id = os.environ.get('bot_id')
bucket = os.environ.get('bucket')
secret_id = os.environ.get('secret_id')
secret_key = os.environ.get('secret_key')
region = os.environ.get('region')
wxtoken = os.environ.get('wxtoken')
appid = os.environ.get('appid')
secret = os.environ.get('secret')
cosClient = CosS3Client(
CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key))
scfClient = scf_client.ScfClient(credential.Credential(secret_id, secret_key),
region)
tbpClient = tbp_client.TbpClient(credential.Credential(secret_id, secret_key),
region)
ttsClient = tts_client.TtsClient(credential.Credential(secret_id, secret_key),
region)
key = 'news/content.json'
indexKey = 'news/content_index.json'
accessTokenKey = 'access/token.json'
accessToken = None
articlesList = None
def getAccessToken():
'''
文档地址：https://developers.weixin.qq.com/doc/offiaccount/Basic_Information/Get_access_token.html
def invoke(self,
function_name,
namespace="default",
log_type="None",
qualifier="$LATEST",
invocation_type="RequestResponse",
data=None):
self.region = self.region if self.region is not None \
else os.environ.get("TENCENTCLOUD_REGION", "ap-guangzhou")
self.secret_id = self.secret_id if self.secret_id is not None \
else os.environ.get("TENCENTCLOUD_SECRETID", None)
self.secret_key = self.secret_key if self.secret_key is not None \
else os.environ.get("TENCENTCLOUD_SECRETKEY", None)
self.token = self.token if self.token is not None \
else os.environ.get("TENCENTCLOUD_SESSIONTOKEN", None)
self.env = os.environ.get("TENCENTCLOUD_RUNENV", None)
self.endpoint = "scf.internal.tencentcloudapi.com" if self.env == "SCF" \
else "scf.tencentcloudapi.com"
cred = credential.Credential(self.secret_id, self.secret_key,
self.token)
self.profile = ClientProfile(httpProfile=HttpProfile(
endpoint=self.endpoint, reqTimeout=300, keepAlive=True))
self.client = scf_client.ScfClient(cred,
self.region,
profile=self.profile)
client_context = None
if data:
client_context = json.dumps(data)
action_params = {
"Namespace": namespace,
"LogType": log_type,
"ClientContext": client_context,
"Qualifier": qualifier,
"InvocationType": invocation_type,
"FunctionName": function_name,
}
res = json.loads(self.client.call("Invoke", action_params))
if "Error" in res["Response"]:
raise TencentCloudSDKException(
code=res["Response"]["Error"]["Code"],
message=res["Response"]["Error"]["Message"],
requestId=res["Response"]["RequestId"])
elif "InvokeResult" in res["Response"]["Result"]:
if res["Response"]["Result"]["InvokeResult"] == 1:
exceptions = json.loads(res["Response"]["Result"]["RetMsg"])
stack_trace = exceptions[
"stackTrace"] if "stackTrace" in exceptions else ""
raise TencentServerlessSDKException(
code=exceptions["errorCode"],
message=exceptions["errorMessage"],
response=res,
stack_trace=stack_trace,
request_id=res["Response"]['RequestId'])
elif res["Response"]["Result"]["InvokeResult"] == -1:
raise TencentServerlessSDKException(
code=-1,
message=res["Response"]["Result"]["RetMsg"],
response=res,
request_id=res["Response"]['RequestId'])
else:
return res["Response"]["Result"]["RetMsg"]
else:
raise TencentServerlessSDKException(
code=-1,
message='Internal server error',
response=res,
request_id=res["Response"]['RequestId'])
