def handle(self, *args, **options):
"""
access control register
"""
app_name = get_settings_value("SERVICE_CONF").get("NAME", None)
secret = get_settings_value("ACCESS_CONTROL").get("SECRET", None)
api_path = get_settings_value("ACCESS_CONTROL").get(
"REGISTER_API_PATH", None)
service_conf = get_settings_value("ACCESS_CONTROL").get(
"ACCESS_CONTROL_SERVICE", None)
access_control_class_path = get_settings_value("ACCESS_CONTROL").get(
"ACCESS_CONTROL_CLASS", None)
if all([access_control_class_path, app_name, secret, service_conf]):
access_control_cls = get_resource_cls()
attribute_name_list = [
_ for _ in dir(access_control_cls)
if _.startswith('permission_')
]
data = [
getattr(access_control_cls, _) for _ in attribute_name_list
]
payload = {"app_name": app_name, "secret": secret, "data": data}
try:
rest_client.post(service_conf, api_path=api_path, json=payload)
print("resource register success!!!")
except Exception as ex:
print("resource register failed, message:{}".format(
ex.__str__()))
def test_post_err(self, mock_post):
service_address = settings.SERVICE_ADDRESS
try:
rest_client.post(service_address=service_address, api_path=API_PATH, data=DATA)
except Exception as ex:
message = ex.__str__()
self.assertEqual(message, 'rest_client error, service_name:sparrow_cloud, protocol:http, method:post, '
'request_service_address:sparrow-test-svc:8000, api_path:/api/xxx/, message:')
def register(api_list):
sparrow_permission_register_conf = settings.SPARROW_PERMISSION_REGISTER_CONF
api_path = sparrow_permission_register_conf['API_PATH']
permission_service_conf = sparrow_permission_register_conf["PERMISSION_SERVICE"]
try:
rest_client.post(permission_service_conf, api_path, json=api_list)
print("api 注册成功")
except HTTPException as ex:
print("api 注册失败. message={}, service_name={}".format(ex.detail, "SPARROW_PERMISSION_REGISTER_NAME"))
def test_post(self, acl_token, mock_post, mock_service):
api_path = "/api/xxx/"
data = {
"key": "value",
}
from django.conf import settings
settings.CONSUL_CLIENT_ADDR = {"HOST": "127.0.0.1", "PORT": 8500}
settings.SERVICE_CONF = SERVICE_CONF
try:
rest_client.post(SERVICE_CONF, api_path, data=data)
except Exception as ex:
message = ex.__str__()
self.assertEqual(
message, 'rest_client error, service_name: , '
'request_service:sprrow-permission-svc, api_path:/api/xxx/, message: '
)
def add_lock(key: str, expire_time: int, *args, **kwargs):
"""
# ConfigMap:
SC_SPARROW_DISTRIBUTED_LOCK_SVC
SC_SPARROW_DISTRIBUTED_LOCK_API
"""
service_conf = get_settings_value("SERVICE_CONF")
service_name = service_conf.get("NAME", None)
service_secret = service_conf.get("SECRET", None)
if not service_name or not service_secret:
raise Exception(
"NAME or SECRET is not configured in SERVICE_CONF settings")
data = {
"service_name": service_name,
"secret": service_secret,
"key": key,
"expire_time": expire_time,
}
try:
res = rest_client.post(sc_distributed_lock_svc,
sc_distributed_lock_api,
json=data,
*args,
**kwargs)
logging.info(
"sparrow_cloud distributed lock add lock, data:{}".format(data))
return res
except HTTPException as ex:
logging.error(
"sparrow_cloud distributed lock add lock error: {}".format(ex))
raise HTTPException(ex)
def send_message(msg,
code_list,
channel="dingtalk",
message_type="text",
*args,
**kwargs):
"""钉钉群发消息机器人 client """
if not isinstance(msg, str) and not isinstance(code_list, list):
raise TypeError(
"参数类型错误：msg type not string or code_list type not list")
data = {
"msg": msg,
"group_code_list": code_list,
"channel": channel,
"message_type": message_type
}
sparrow_ding_talk_conf = get_settings_value("SPARROW_DING_TALK_CONF")
try:
res = rest_client.post(sparrow_ding_talk_conf["SERVICE_DING_TALK"],
sparrow_ding_talk_conf["PATH"],
data=data,
*args,
**kwargs)
logging.info(
"sparrow_cloud ding_talk send_message: msg:{}, group_code_list:{}".
format(msg, code_list))
return res
except HTTPException as ex:
logging.error(
"sparrow_cloud ding_talk send_message error: {}".format(ex))
raise HTTPException(ex)
def get_app_token():
"""
get app token
REGISTRY_APP_CONF = {
"SERVICE_ADDRESS": "sparrow-service-svc:8000",
"PATH": "/api/get_app_token/",
"ENABLE_TOKEN_CACHE": os.environ.get("ENABLE_TOKEN_CACHE", False)
}
:return:
"""
app_token_key = get_hash_key(key_type="app")
service_conf = get_settings_value("SERVICE_CONF")
registry_app_conf = get_settings_value("REGISTRY_APP_CONF")
enable_get_token_cache = registry_app_conf["ENABLE_TOKEN_CACHE"]
if enable_get_token_cache:
cache_app_token = cache.get(app_token_key)
if cache_app_token:
return cache_app_token["app_token"]
try:
data = {"name": service_conf["NAME"], "secret": service_conf["SECRET"]}
data_to_send = json.dumps(data).encode("utf-8")
app_token = rest_client.post(
service_address=registry_app_conf["SERVICE_ADDRESS"],
api_path=registry_app_conf["PATH"],
timeout=0.5,
data=data_to_send)
cache.set(app_token_key, {'app_token': app_token},
timeout=app_token["expires_in"] - 120)
return app_token["token"]
except Exception as ex:
raise Exception(
'get_app_token error, no token available in cache and registry_app_error, '
'message:{}'.format(ex.__str__()))
def update_task_result(self, task_id, consumer, **kwargs):
# 如果出现消息结果更新失败的情况，需要等待interval_time时间间隔来重试
interval_time = self._interval_time
error_message = None
for _ in range(self._retry_times):
try:
status = kwargs.get('status')
data = {
"task_id": task_id,
"consumer": consumer,
"status": status,
"result": kwargs.get('result'),
"traceback": kwargs.get('traceback'),
}
# sparrow_task服务重启的过程中，可能会遇到连接失败的情况
# 下次重试的时候需要通过consul重新获取新地址
backend_service_conf = self._message_backend_conf.get(
'BACKEND_SERVICE_CONF', None)
api_path = self._message_backend_conf.get('API_PATH', None)
response = rest_client.post(backend_service_conf,
api_path=api_path,
json=data)
logger.info(
' [*] Update task database info task_id is {0}, status is {1}'
.format(task_id, status))
return
except Exception as ex:
time.sleep(interval_time)
interval_time += 2
error_message = ex.__str__()
raise Exception(
"消息执行结果更新失败，消息id={}, 失败原因={},重试次数={}，消息执行状态={}，result={}, traceback={}"
.format(task_id, error_message, self._retry_times, status,
kwargs.get('result'), kwargs.get('traceback')))
def get_app_token():
"""
get app token
configmap：
SC_MANAGE_SVC
SC_MANAGE_API
"""
app_token_key = get_hash_key(key_type="app")
service_conf = get_settings_value("SERVICE_CONF")
sc_manage_svc = get_cm_value("SC_MANAGE_SVC")
sc_manage_api = get_cm_value("SC_MANAGE_API")
try:
cache_app_token = cache.get(app_token_key)
if cache_app_token:
return cache_app_token["app_token"]["token"]
else:
data = {
"name": service_conf["NAME"],
"secret": service_conf["SECRET"]
}
app_token = rest_client.post(service_address=sc_manage_svc,
api_path=sc_manage_api,
json=data)
cache.set(app_token_key, {'app_token': app_token},
timeout=app_token["expires_in"] - 120)
logger.info("sparrowcloud get app token: {}".format(
app_token["token"]))
return app_token["token"]
except Exception as ex:
raise Exception(
'sparrowcloud/get_app_token error, no token available in cache and app_manage_error, '
'message:{}'.format(ex.__str__()))
def register(schema):
sparrow_permission_register_conf = settings.SPARROW_SCHEMA_REGISTER_CONF
api_path = sparrow_permission_register_conf['API_PATH']
permission_service_conf = sparrow_permission_register_conf["SCHEMA_SERVICE"]
try:
r = rest_client.post(permission_service_conf, api_path, json=schema)
print("schema 注册成功 resp body={}".format(r))
except HTTPException as ex:
print("schema 注册失败. message={} ".format(ex.detail))
def test_post(self, mock_post, mock_service):
api_path = "/api/xxx/"
data = {
"key": "value",
}
from django.conf import settings
settings.CONSUL_CLIENT_ADDR = {"HOST": "127.0.0.1", "PORT": 8500}
settings.SERVICE_CONF = SERVICE_CONF
res = rest_client.post(SERVICE_CONF, api_path, data=data)
self.assertEqual(res, {'key1': 'value1'})
def register(schema):
'''
configmap ：
SC_SCHEMA_SVC
SC_SCHEMA_API
'''
sc_schema_svc = get_cm_value("SC_SCHEMA_SVC")
sc_schema_api = get_cm_value("SC_SCHEMA_API")
try:
r = rest_client.post(sc_schema_svc, sc_schema_api, json=schema)
print("schema 注册成功 resp body={}".format(r))
except HTTPException as ex:
print("schema 注册失败. message={} ".format(ex.detail))
def send_message(msg_data,
code_type,
content_type="text",
msg_sender=None,
*args,
**kwargs):
"""
# ConfigMap:
SC_LY_MESSAGE
SC_LY_MESSAGE_API
"""
if msg_sender is None:
msg_sender = get_service_name()
sc_ly_message = get_cm_value("SC_LY_MESSAGE")
sc_ly_message_api = get_cm_value("SC_LY_MESSAGE_API")
data = {
"shop_id": kwargs.pop("shop_id", None),
"msg_sender": msg_sender,
"code_type": code_type,
"user_id_list": kwargs.pop("user_id_list", []),
# msg数据格式是动态变化，由发送者根据服务要求填充发送该类型数据的必要数据
# "msg": {
# "content_type": content_type,
# "data": msg_data
# }
}
# 把kwargs里面剩余的有关数据放入msg中，发送的数据由服务发送者决定，此处不做校验
msg = {"content_type": content_type, "data": msg_data}
if kwargs.get("nickname"):
msg.update({"nickname": kwargs.pop("nickname")})
if kwargs.get("title"):
msg.update({"title": kwargs.pop("title")})
data.update({"msg": msg})
try:
res = rest_client.post(sc_ly_message,
sc_ly_message_api,
json=data,
*args,
**kwargs)
logging.info(
"sparrow_cloud ly_message send_message, data:{}, code_type:{}".
format(data, code_type))
return res
except HTTPException as ex:
logging.error(
"sparrow_cloud ly_message send_message error: {}".format(ex))
raise HTTPException(ex)
def send_log(data):
"""
:param data: dict
:return:True, False
"""
if not isinstance(data, dict):
raise TypeError("参数类型错误：except=%s, get=%s" % ("dict", type(data)))
service_conf = get_settings_value("SERVICE_CONF")
service_log_conf = get_settings_value("SPARROW_SERVICE_LOG_CONF")
data["service_name"] = service_conf["NAME"]
try:
response = post(service_log_conf["SERVICE_LOG"], service_log_conf["PATH"], data=data)
logging.info("sparrow_cloud: service log sent successfully, message:{}".format(response))
return True
except HTTPException as ex:
logging.error("sparrow_cloud: Service log sending failed, message:{}".format(ex.__str__()))
return False
def send_log(data):
"""
:param data: dict
:return:True, False
"""
if not isinstance(data, dict):
raise TypeError("参数类型错误：except=%s, get=%s" % ("dict", type(data)))
data["service_name"] = get_service_name()
service_log_svc = get_cm_value("SC_SERVICE_LOG_SVC")
service_log_api = get_cm_value("SC_SERVICE_LOG_API")
try:
response = post(service_log_svc, service_log_api, data=data)
logging.info(
"sparrow_cloud: service log sent successfully, message:{}".format(
response))
return True
except HTTPException as ex:
logging.error(
"sparrow_cloud: Service log sending failed, message:{}".format(
ex.__str__()))
return False
def send_message(msg,
code_list,
channel="dingtalk",
message_type="text",
*args,
**kwargs):
"""
群发消息机器人 client
configmap：
SC_MESSAGE_ROBOT
SC_MESSAGE_ROBOT_API
"""
if not isinstance(msg, str) and not isinstance(code_list, list):
raise TypeError(
"参数类型错误：msg type not string or code_list type not list")
sc_message_robot = get_cm_value("SC_MESSAGE_ROBOT")
sc_message_robot_api = get_cm_value("SC_MESSAGE_ROBOT_API")
data = {
"msg": msg,
"group_code_list": code_list,
"channel": channel,
"message_type": message_type
}
try:
res = rest_client.post(sc_message_robot,
sc_message_robot_api,
data=data,
*args,
**kwargs)
logging.info(
"sparrow_cloud ding_talk send_message: msg:{}, group_code_list:{}".
format(msg, code_list))
return res
except HTTPException as ex:
logging.error(
"sparrow_cloud ding_talk send_message error: {}".format(ex))
raise HTTPException(ex)
def test_post(self, mock_post):
service_address = settings.SERVICE_ADDRESS
res = rest_client.post(service_address=service_address, api_path=API_PATH, data=DATA)
self.assertEqual(res, {'key1': 'value1'})