def create_queue(self, req, resp):
#check parameter
CreateQueueValidator.validate(req)
#make request internal
req_inter = RequestInternal(req.method,
"/%s/%s" % (URISEC_QUEUE, req.queue_name))
req_inter.data = QueueEncoder.encode(req)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
lheader = self.lower_header(resp.header)
resp.queue_url = lheader["location"]
raise_logger(
"CreateQueue RequestId:%s QueueName:%s QueueURL:%s" %
(resp.get_requestid(), req.queue_name, resp.queue_url),
'rs_info')
def list_topic(self, req, resp):
#check parameter
ListTopicValidator.validate(req)
#make request internal
req_inter = RequestInternal(req.method, "/%s" % URISEC_TOPIC)
if req.prefix != "":
req_inter.header["x-mns-prefix"] = req.prefix
if req.ret_number != -1:
req_inter.header["x-mns-ret-number"] = str(req.ret_number)
if req.marker != "":
req_inter.header["x-mns-marker"] = str(req.marker)
if req.with_meta:
req_inter.header["x-mns-with-meta"] = "true"
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
resp.topicurl_list, resp.next_marker, resp.topicmeta_list = ListTopicDecoder.decode(
resp_inter.data, req.with_meta, req_inter.get_req_id())
first_topicurl = "" if len(
resp.topicurl_list) == 0 else resp.topicurl_list[0]
last_topicurl = "" if len(
resp.topicurl_list) == 0 else resp.topicurl_list[
len(resp.topicurl_list) - 1]
raise_logger("ListTopic RequestId:%s Prefix:%s RetNumber:%s Marker:%s TopicCount:%s FirstTopicURL:%s LastTopicURL:%s NextMarker:%s" % \
(resp.get_requestid(), req.prefix, req.ret_number, req.marker,\
len(resp.topicurl_list), first_topicurl, last_topicurl, resp.next_marker))
def send_request(self, req_inter):
try:
raise_logger("SendRequest %s" % req_inter)
self.conn.request(req_inter.method, req_inter.uri, req_inter.data,
req_inter.header)
self.conn.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY,
1)
try:
http_resp = self.conn.getresponse()
except BadStatusLine:
#open another connection when keep-alive timeout
#httplib will not handle keep-alive timeout, so we must handle it ourself
self.conn.close()
self.conn.request(req_inter.method, req_inter.uri,
req_inter.data, req_inter.header)
self.conn.sock.setsockopt(socket.IPPROTO_TCP,
socket.TCP_NODELAY, 1)
http_resp = self.conn.getresponse()
headers = dict(http_resp.getheaders())
resp_inter = ResponseInternal(status=http_resp.status,
header=headers,
data=http_resp.read())
resp_inter.data = resp_inter.data.decode('utf-8')
self.request_size = self.conn.request_length
self.response_size = len(resp_inter.data)
if not self.is_keep_alive():
self.conn.close()
raise_logger("GetResponse %s" % resp_inter)
return resp_inter
except Exception as e:
self.conn.close()
raise MNSClientNetworkException(
"NetWorkException", str(e),
req_inter.get_req_id()) #raise netException
def main(ip_addr,
port,
endpoint_class=server.SimpleHttpNotifyEndpoint,
msg_type=u"XML",
prefix=u"http://"):
#init logger
global logger
endpoint_class.access_log_file = "access_log.%s" % port
endpoint_class.msg_type = msg_type
log_file = "endpoint_log.%s" % port
logger = logging.getLogger()
file_handler = logging.handlers.RotatingFileHandler(log_file,
maxBytes=100 * 1024 *
1024)
formatter = logging.Formatter(
'[%(asctime)s] [%(name)s] [%(levelname)s] [%(filename)s:%(lineno)d] [%(thread)d] %(message)s',
'%Y-%m-%d %H:%M:%S')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.setLevel(logging.INFO)
#start endpoint
addr_info = "Start Endpoint! Address: %s%s:%s" % (prefix, ip_addr, port)
print(addr_info)
try:
raise_logger(addr_info)
httpd = server.ThreadedHTTPServer(('', port), endpoint_class)
httpd.serve_forever()
except KeyboardInterrupt:
print("Shutting down the simple notify endpoint!")
httpd.socket.close()
def subscribe(self, req, resp):
#check parameter
SubscribeValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
uri="/%s/%s/%s/%s" % (URISEC_TOPIC, req.topic_name,
URISEC_SUBSCRIPTION, req.subscription_name))
req_inter.data = SubscriptionEncoder.encode(req)
self.build_header(req, req_inter)
#send request
req_inter.data = req_inter.data.decode('utf-8')
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
lheader = self.lower_header(resp.header)
resp.subscription_url = lheader["location"]
raise_logger("Subscribe RequestId:%s TopicName:%s SubscriptionName:%s SubscriptionURL:%s" % \
(resp.get_requestid(), req.topic_name, req.subscription_name, resp.subscription_url))
def get_subscription_attributes(self, req, resp):
#check parameter
GetSubscriptionAttrValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
"/%s/%s/%s/%s" % (URISEC_TOPIC, req.topic_name,
URISEC_SUBSCRIPTION, req.subscription_name))
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
subscription_attr = GetSubscriptionAttrDecoder.decode(
resp_inter.data, req_inter.get_req_id())
resp.topic_owner = subscription_attr["TopicOwner"]
resp.topic_name = subscription_attr["TopicName"]
resp.subscription_name = subscription_attr["SubscriptionName"]
resp.endpoint = subscription_attr["Endpoint"]
resp.filter_tag = subscription_attr[
"FilterTag"] if "FilterTag" in subscription_attr.keys() else ""
resp.notify_strategy = subscription_attr["NotifyStrategy"]
resp.notify_content_format = subscription_attr[
"NotifyContentFormat"]
resp.create_time = int(subscription_attr["CreateTime"])
resp.last_modify_time = int(subscription_attr["LastModifyTime"])
raise_logger("GetSubscriptionAttributes RequestId:%s TopicName:%s SubscriptionName:%s" % \
(resp.get_requestid(), req.topic_name, req.subscription_name))
def list_queue(self, req, resp):
#check parameter
ListQueueValidator.validate(req)
#make request internal
req_inter = RequestInternal(req.method, "/%s" % URISEC_QUEUE)
if req.prefix != u"":
req_inter.header["x-mns-prefix"] = req.prefix
if req.ret_number != -1:
req_inter.header["x-mns-ret-number"] = str(req.ret_number)
if req.marker != u"":
req_inter.header["x-mns-marker"] = str(req.marker)
if req.with_meta:
req_inter.header["x-mns-with-meta"] = u"true"
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
resp.queueurl_list, resp.next_marker, resp.queuemeta_list = ListQueueDecoder.decode(
resp_inter.data, req.with_meta, req_inter.get_req_id())
firstQueueURL = "" if resp.queueurl_list == [] else resp.queueurl_list[
0]
lastQueueURL = "" if resp.queueurl_list == [] else resp.queueurl_list[
len(resp.queueurl_list) - 1]
raise_logger("ListQueue RequestId:%s Prefix:%s RetNumber:%s Marker:%s QueueCount:%s FirstQueueURL:%s LastQueueURL:%s NextMarker:%s" % \
(resp.get_requestid(), req.prefix, req.ret_number, req.marker, len(resp.queueurl_list), firstQueueURL, lastQueueURL, resp.next_marker)
, 'rs_info')
def get_topic_attributes(self, req, resp):
#check parameter
GetTopicAttrValidator.validate(req)
#make request internal
req_inter = RequestInternal(req.method,
"/%s/%s" % (URISEC_TOPIC, req.topic_name))
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
topic_attr = GetTopicAttrDecoder.decode(resp_inter.data,
req_inter.get_req_id())
resp.message_count = int(topic_attr["MessageCount"])
resp.create_time = int(topic_attr["CreateTime"])
resp.last_modify_time = int(topic_attr["LastModifyTime"])
resp.maximum_message_size = int(topic_attr["MaximumMessageSize"])
resp.message_retention_period = int(
topic_attr["MessageRetentionPeriod"])
resp.topic_name = topic_attr["TopicName"]
resp.logging_enabled = True if topic_attr["LoggingEnabled"].lower(
) == "true" else False
raise_logger("GetTopicAttributes RequestId:%s TopicName:%s" %
(resp.get_requestid(), req.topic_name))
def peek_message(self, req, resp):
#check parameter
PeekMessageValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method, "/%s/%s/%s?peekonly=true" %
(URISEC_QUEUE, req.queue_name, URISEC_MESSAGE))
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
data = PeekMessageDecoder.decode(resp_inter.data, req.base64decode,
req_inter.get_req_id())
self.make_peekresp(data, resp)
raise_logger("PeekMessage RequestId:%s QueueName:%s MessageInfo \
MessageId:%s BodyMD5:%s EnqueueTime:%s DequeueCount:%s" % \
(resp.get_requestid(), req.queue_name, resp.message_id, resp.message_body_md5,\
resp.enqueue_time, resp.dequeue_count))
def wrapped_func(*args, **kwargs):
try:
func_data = func(*args, **kwargs)
return func_data
except HTTPException as e:
if not self.cover_http_exception:
raise e
else:
exceptions = traceback.format_exc()
if exceptions:
exception_list = exceptions.split(':')
if not exception_list[0] == 'NoneType':
for i in exception_list:
for j in i.split("\n"):
raise_logger(j, 'rs_error')
pass
return_msg = self.get_return_msg()
return return_msg
except Exception:
exceptions = traceback.format_exc()
if exceptions:
exception_list = exceptions.split(':')
if not exception_list[0] == 'NoneType':
for i in exception_list:
for j in i.split("\n"):
raise_logger(j, 'rs_error')
return_msg = self.get_return_msg()
return return_msg
def batch_receive_message(self, req, resp):
#check parameter
BatchReceiveMessageValidator.validate(req)
#make request internal
req_url = "/%s/%s/%s?numOfMessages=%s" % (
URISEC_QUEUE, req.queue_name, URISEC_MESSAGE, req.batch_size)
if req.wait_seconds != -1:
req_url += "&waitseconds=%s" % req.wait_seconds
req_inter = RequestInternal(req.method, req_url)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
resp.message_list = BatchRecvMessageDecoder.decode(
resp_inter.data, req.base64decode, req_inter.get_req_id())
raise_logger("BatchReceiveMessage RequestId:%s QueueName:%s WaitSeconds:%s BatchSize:%s MessageCount:%s \
MessagesInfo\n%s" % (resp.get_requestid(), req.queue_name, req.wait_seconds, req.batch_size, len(resp.message_list),\
"\n".join(["MessageId:%s MessageBodyMD5:%s NextVisibilityTime:%s ReceiptHandle:%s EnqueueTime:%s DequeueCount:%s" % \
(msg.message_id, msg.message_body_md5, msg.next_visible_time, msg.receipt_handle, msg.enqueue_time, msg.dequeue_count) for msg in resp.message_list])))
def list_subscription_by_topic(self, req, resp):
#check parameter
ListSubscriptionByTopicValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
"/%s/%s/%s" % (URISEC_TOPIC, req.topic_name, URISEC_SUBSCRIPTION))
if req.prefix != "":
req_inter.header["x-mns-prefix"] = req.prefix
if req.ret_number != -1:
req_inter.header["x-mns-ret-number"] = str(req.ret_number)
if req.marker != "":
req_inter.header["x-mns-marker"] = req.marker
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
resp.subscriptionurl_list, resp.next_marker = ListSubscriptionByTopicDecoder.decode(
resp_inter.data, req_inter.get_req_id())
first_suburl = "" if len(resp.subscriptionurl_list
) == 0 else resp.subscriptionurl_list[0]
last_suburl = "" if len(
resp.subscriptionurl_list) == 0 else resp.subscriptionurl_list[
len(resp.subscriptionurl_list) - 1]
raise_logger("ListSubscriptionByTopic RequestId:%s TopicName:%s Prefix:%s RetNumber:%s \
Marker:%s SubscriptionCount:%s FirstSubscriptionURL:%s LastSubscriptionURL:%s" % \
(resp.get_requestid(), req.topic_name, req.prefix, req.ret_number, \
req.marker, len(resp.subscriptionurl_list), first_suburl, last_suburl))
def receive_message(self, req, resp):
#check parameter
ReceiveMessageValidator.validate(req)
#make request internal
req_url = "/%s/%s/%s" % (URISEC_QUEUE, req.queue_name, URISEC_MESSAGE)
if req.wait_seconds != -1:
req_url += "?waitseconds=%s" % req.wait_seconds
req_inter = RequestInternal(req.method, req_url)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
data = RecvMessageDecoder.decode(resp_inter.data, req.base64decode,
req_inter.get_req_id())
self.make_recvresp(data, resp)
raise_logger("ReceiveMessage RequestId:%s QueueName:%s WaitSeconds:%s MessageId:%s MessageBodyMD5:%s NextVisibilityTime:%s ReceiptHandle:%s EnqueueTime:%s DequeueCount:%s" % \
(resp.get_requestid(), req.queue_name, req.wait_seconds, resp.message_id, \
resp.message_body_md5, resp.next_visible_time, resp.receipt_handle, resp.enqueue_time, resp.dequeue_count))
def batch_send_message(self, req, resp):
#check parameter
BatchSendMessageValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
uri="/%s/%s/%s" % (URISEC_QUEUE, req.queue_name, URISEC_MESSAGE))
req_inter.data = MessagesEncoder.encode(req.message_list,
req.base64encode)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp, BatchSendMessageDecoder)
if resp.error_data == "":
resp.message_list = BatchSendMessageDecoder.decode(
resp_inter.data, req_inter.get_req_id())
raise_logger("BatchSendMessage RequestId:%s QueueName:%s MessageCount:%s MessageInfo\n%s" % \
(resp.get_requestid(), req.queue_name, len(req.message_list), \
"\n".join(["MessageId:%s MessageBodyMD5:%s" % (msg.message_id, msg.message_body_md5) for msg in resp.message_list])))
def get(self, path):
argument_dict = self.get_request_content(set_default=False)
raise_logger('CommonTransferToPlatformController' +
json.dumps(argument_dict))
transfer_url = get_transfer_to_platform_config(
)['default_ip'] + request.path
response_dict = transfer_to_platform(transfer_url, data=argument_dict)
return response_dict
def post(self, path):
all_path_list = request.path.split("/")[1:]
path_list = path.split("/")
# 1.0 区别前后台用户
if all_path_list[0] == 'bg':
if len(path_list) < 2:
self.return_error(10043)
self.user_type = _USER_TYPE_ADMIN
# 后台用户需要校验ip
result = check_bg_ip()
if result is False:
self.return_error(30000)
elif all_path_list[0] == 'users':
pass
else:
self.return_error(10004)
# 2.0 获取参数
argument_dict, share_key, nonce = self.get_argument_dict(
must_keys=self.must_keys,
is_transfer=True,
api_type=self.user_type,
request_type=self.request_type,
invariable_key=self.invariable_key,
check_token=self.check_token,
check_user_id=self.check_user_id,
verify_timeliness=self.verify_timeliness,
encrypt=self.encrypt,
check_form_token=self.check_form_token)
raise_logger('UsersTransferToPlatformController' +
json.dumps(argument_dict))
# 3.0 后台用户校验权限
user_service = UserBaseService(aes_share_key=share_key,
aes_nonce=nonce)
if self.user_type == _USER_TYPE_ADMIN:
user_id = argument_dict['user_id']
module_url = path_list[0]
transfer_check_result = user_service.check_admin_user_module_rights_by_user_id(
user_id, module_url)
if not transfer_check_result:
self.return_error(30232)
transfer_url = get_transfer_to_platform_config(
)['default_ip'] + request.path
response_dict = transfer_to_platform(transfer_url, data=argument_dict)
if self.return_aes:
return response_dict, share_key, nonce
else:
return response_dict
def __init__(self,
host,
access_id,
access_key,
version="2015-06-06",
security_token="",
logger=None):
self.host, self.is_https = self.process_host(host)
self.access_id = access_id
self.access_key = access_key
self.version = version
self.security_token = security_token
self.logger = logger
self.http = MNSHttp(self.host, logger=logger, is_https=self.is_https)
raise_logger("InitClient Host:%s Version:%s" % (host, version))
def get_account_attributes(self, req, resp):
#make request internal
req_inter = RequestInternal(req.method, "/?accountmeta=true")
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
account_attr = GetAccountAttrDecoder.decode(
resp_inter.data, req_inter.get_req_id())
resp.logging_bucket = account_attr["LoggingBucket"]
raise_logger("GetAccountAttributes RequestId:%s LoggingBucket:%s" %
(resp.get_requestid(), resp.logging_bucket))
def delete_topic(self, req, resp):
#check parameter
DeleteTopicValidator.validate(req)
#make request internal
req_inter = RequestInternal(req.method,
"/%s/%s" % (URISEC_TOPIC, req.topic_name))
self.build_header(req, req_inter)
#send reqeust
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
raise_logger("DeleteTopic RequestId:%s TopicName:%s" %
(resp.get_requestid(), req.topic_name))
def delete_message(self, req, resp):
#check parameter
DeleteMessageValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method, "/%s/%s/%s?ReceiptHandle=%s" %
(URISEC_QUEUE, req.queue_name, URISEC_MESSAGE, req.receipt_handle))
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
raise_logger("DeleteMessage RequestId:%s QueueName:%s ReceiptHandle:%s" % \
(resp.get_requestid(), req.queue_name, req.receipt_handle))
def delete_queue(self, req, resp):
#check parameter
DeleteQueueValidator.validate(req)
#make request internal
req_inter = RequestInternal(req.method,
"/%s/%s" % (URISEC_QUEUE, req.queue_name))
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
raise_logger(
"DeleteQueue RequestId:%s QueueName:%s" %
(resp.get_requestid(), req.queue_name), 'rs_info')
def __init__(self,
host,
connection_timeout=60,
keep_alive=True,
logger=None,
is_https=False):
if is_https:
self.conn = MNSHTTPSConnection(host)
else:
self.conn = MNSHTTPConnection(
host, connection_timeout=connection_timeout)
self.host = host
self.is_https = is_https
self.connection_timeout = connection_timeout
self.keep_alive = keep_alive
self.request_size = 0
self.response_size = 0
self.logger = logger
raise_logger("InitMNSHttp KeepAlive:%s ConnectionTime:%s" %
(self.keep_alive, self.connection_timeout))
def set_topic_attributes(self, req, resp):
#check parameter
SetTopicAttrValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
"/%s/%s?metaoverride=true" % (URISEC_TOPIC, req.topic_name))
req_inter.data = TopicEncoder.encode(req)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
raise_logger("SetTopicAttributes RequestId:%s TopicName:%s" %
(resp.get_requestid(), req.topic_name))
def main(ip_addr,
port,
endpoint_class=server.SimpleHttpNotifyEndpoint,
msg_type=u"XML",
prefix=u"https://"):
#init logger
global logger
endpoint_class.access_log_file = "access_log.%s" % port
endpoint_class.msg_type = msg_type
log_file = "endpoint_log.%s" % port
logger = logging.getLogger()
file_handler = logging.handlers.RotatingFileHandler(log_file,
maxBytes=100 * 1024 *
1024)
formatter = logging.Formatter(
'[%(asctime)s] [%(name)s] [%(levelname)s] [%(filename)s:%(lineno)d] [%(thread)d] %(message)s',
'%Y-%m-%d %H:%M:%S')
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
logger.setLevel(logging.INFO)
tmpcertfile = "x509_public_certificate_checkhttp.pem"
tmpkeyfile = "rsa_private_key_checkhttp.pem"
open(tmpcertfile, 'w').write(CERTIFICATE)
open(tmpkeyfile, 'w').write(RSA_PRIVATE_KEY)
#start endpoint
addr_info = "Start Endpoint! Address: %s%s:%s" % (prefix, ip_addr, port)
print(addr_info)
try:
raise_logger(addr_info)
httpd = HTTPServer((ip_addr, port), endpoint_class)
httpd.socket = ssl.wrap_socket(httpd.socket,
keyfile=tmpkeyfile,
certfile=tmpcertfile,
server_side=True)
httpd.serve_forever()
#httpd = server.ThreadedHTTPServer(('', port), endpoint_class)
except KeyboardInterrupt:
print("Shutting down the simple notify endpoint!")
httpd.socket.close()
def set_queue_attributes(self, req, resp):
#check parameter
SetQueueAttrValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
"/%s/%s?metaoverride=true" % (URISEC_QUEUE, req.queue_name))
req_inter.data = QueueEncoder.encode(req, False)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
raise_logger(
"SetQueueAttributes RequestId:%s QueueName:%s" %
(resp.get_requestid(), req.queue_name), 'rs_info')
def batch_delete_message(self, req, resp):
#check parameter
BatchDeleteMessageValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
"/%s/%s/%s" % (URISEC_QUEUE, req.queue_name, URISEC_MESSAGE))
req_inter.data = ReceiptHandlesEncoder.encode(req.receipt_handle_list)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp,
BatchDeleteMessageDecoder)
raise_logger("BatchDeleteMessage RequestId:%s QueueName:%s ReceiptHandles\n%s" % \
(resp.get_requestid(), req.queue_name, "\n".join(req.receipt_handle_list)))
def create_topic(self, req, resp):
#check parameter
CreateTopicValidator.validate(req)
#make request internal
req_inter = RequestInternal(req.method,
"/%s/%s" % (URISEC_TOPIC, req.topic_name))
req_inter.data = TopicEncoder.encode(req)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
resp.topic_url = self.lower_header(resp.header)["location"]
raise_logger("CreateTopic RequestId:%s TopicName:%s TopicURl:%s" % \
(resp.get_requestid(), req.topic_name, resp.topic_url))
def unsubscribe(self, req, resp):
#check parameter
UnsubscribeValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
"/%s/%s/%s/%s" % (URISEC_TOPIC, req.topic_name,
URISEC_SUBSCRIPTION, req.subscription_name))
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
raise_logger(
"Unsubscribe RequestId:%s TopicName:%s SubscriptionName:%s" %
(resp.get_requestid(), req.topic_name, req.subscription_name))
def publish_message(self, req, resp):
#check parameter
PublishMessageValidator.validate(req)
#make request internal
req_inter = RequestInternal(
req.method,
uri="/%s/%s/%s" % (URISEC_TOPIC, req.topic_name, URISEC_MESSAGE))
req_inter.data = TopicMessageEncoder.encode(req)
self.build_header(req, req_inter)
#send request
resp_inter = self.http.send_request(req_inter)
#handle result, make response
resp.status = resp_inter.status
resp.header = resp_inter.header
self.check_status(req_inter, resp_inter, resp)
if resp.error_data == "":
resp.message_id, resp.message_body_md5 = PublishMessageDecoder.decode(
resp_inter.data, req_inter.get_req_id())
raise_logger("PublishMessage RequestId:%s TopicName:%s MessageId:%s MessageBodyMD5:%s" % \
(resp.get_requestid(), req.topic_name, resp.message_id, resp.message_body_md5))
def check_vcode_picture(self,
vcode_str,
vcode_key='',
vcode_type=_REQUEST_TYPE_REGISTER,
user_type=_USER_TYPE_INVEST):
env = get_conf('env')
if vcode_str == "111111" and env == 'dev':
return True
if vcode_key == '':
redis_key = self.vcode_picture_key + str(vcode_type) + ':' + str(
user_type) + ':' + str(vcode_str).lower()
else:
redis_key = self.vcode_picture_key + str(vcode_type) + ':' + str(
user_type) + ':' + str(vcode_key)
redis_tools = RedisTools()
redis_result = redis_tools.get(redis_key)
raise_logger('check vcode' + ' ' + str(redis_key))
if redis_result is None:
self.return_aes_error(30052)
if str(redis_result,
encoding='utf-8').lower() != str(vcode_str).lower():
self.return_aes_error(30060)
redis_tools.delete(redis_key)
return True
