class MessageQueueUtils:
def __init__(self):
self._account = Account(MNS_ENDPOINT, ALI_ACCESSKEYID,
ALI_ACCESSKEYSECRET)
def create_queue(self, queue_name):
self._q = self._account.get_queue(queue_name)
try:
self._q_url = self._q.create(QueueMeta())
logger.info(f'q: {queue_name} created at url {self._q_url}')
except MNSExceptionBase as e:
if e.type == "QueueAlreadyExist":
logger.error(f'q: {queue_name} already exists')
logger.error(f'error creating queue: {e}')
def send_msg(self, queue_name, msg_body):
self._q = self._account.get_queue(queue_name)
try:
msg = self._q.send_message(Message(msg_body))
logger.info(f'msg sent: {msg.message_id}, {msg_body}')
except MNSExceptionBase as e:
if e.type == "QueueNotExist":
logger.error(
f'q {queue_name} does not exist, you need to create it first'
)
logger.error(f'error sending message: {e}')
def recv_msg(self, queue_name, wait_seconds=3, delete=True):
self._q = self._account.get_queue(queue_name)
try:
msg = self._q.receive_message(wait_seconds)
logger.info(
f'msg received: {msg.receipt_handle}, {msg.message_body}, {msg.message_id}'
)
except MNSExceptionBase as e:
if e.type == "QueueNotExist":
logger.error(
f'q {queue_name} does not exist, you need to create it first'
)
elif e.type == "MessageNotExist":
logger.info(f'q {queue_name} is empty')
else:
logger.error(f'cannot receive msg: {e}')
return None
else:
if delete:
try:
self._q.delete_message(msg.receipt_handle)
logger.info('msg deleted from queue')
except MNSExceptionBase as e:
logger.error(f'could not delete msg: {e}')
return msg
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)) + "/..")
import time
from sample_common import MNSSampleCommon
from mns.mns_account import Account
from mns.mns_queue import *
#从sample.cfg中读取基本配置信息
## WARNING： Please do not hard code your accessId and accesskey in next line.(more information: https://yq.aliyun.com/articles/55947)
accid,acckey,endpoint,token = MNSSampleCommon.LoadConfig()
#初始化 my_account, my_queue
my_account = Account(endpoint, accid, acckey, token)
queue_name = MNSSampleCommon.LoadIndexParam(1)
if not queue_name:
print("Error: get parameter failed")
sys.exit(0)
my_queue = my_account.get_queue(queue_name)
#创建队列, 具体属性请参考mns/queue.py中的QueueMeta结构
queue_meta = QueueMeta()
try:
queue_url = my_queue.create(queue_meta)
print("Create Queue Succeed! QueueName:%s\n" % queue_name)
except MNSExceptionBase as e:
if e.type == "QueueAlreadyExist":
print("Queue already exist, please delete it before creating or use it directly.")
sys.exit(0)
print("Create Queue Fail! Exception:%s\n" % e)
## AccessKeySecret 阿里云官网获取
## Endpoint 阿里云消息和通知服务官网获取, Example: http://$AccountId.mns.cn-hangzhou.aliyuncs.com
## WARNING： Please do not hard code your accessId and accesskey in next line.(more information: https://yq.aliyun.com/articles/55947)
accessKeyId = parser.get("Base", "AccessKeyId")
accessKeySecret = parser.get("Base", "AccessKeySecret")
endpoint = parser.get("Base", "Endpoint")
securityToken = ""
if parser.has_option("Optional", "SecurityToken") and parser.get(
"Optional", "SecurityToken") != "$SecurityToken":
securityToken = parser.get("Optional", "SecurityToken")
#初始化my_account
my_account = Account(endpoint, accessKeyId, accessKeySecret, securityToken)
##############Queue 相关操作#####################
my_queue = my_account.get_queue(
"MyQueue-%s" % time.strftime("%y%m%d-%H%M%S", time.localtime()))
#创建队列
## message被receive后，持续不可消费的时间 100秒
## message body的最大长度 10240Byte
## message最长存活时间 3600秒
## 新message可消费的默认延迟时间 10秒
## receive message时，长轮询时间 20秒
queue_meta = QueueMeta()
queue_meta.set_visibilitytimeout(100)
queue_meta.set_maximum_message_size(10240)
queue_meta.set_message_retention_period(3600)
queue_meta.set_delay_seconds(10)
queue_meta.set_polling_wait_seconds(20)
queue_meta.set_logging_enabled(True)
try:
self.__expire_time = response_body.get("MessageTokenDTO").get(
"ExpireTime")
self.__token = response_body.get("MessageTokenDTO").get(
"SecurityToken")
print(("key=%s, id=%s, expire_time=%s, token=%s" \
% (self.__tmp_access_key, self.__tmp_access_id, self.__expire_time, self.__token)))
print("finsh refresh token...")
# 初始化 my_account, my_queue
token = Token()
token.refresh()
my_account = Account(endpoint, token.get_tmp_access_id(),
token.get_tmp_access_key(), token.get_token())
my_queue = my_account.get_queue(qname)
# my_queue.set_encoding(False)
# 循环读取删除消息直到队列空
# receive message请求使用long polling方式，通过wait_seconds指定长轮询时间为3秒
## long polling 解析:
### 当队列中有消息时，请求立即返回；
### 当队列中没有消息时，请求在MNS服务器端挂3秒钟，在这期间，有消息写入队列，请求会立即返回消息，3秒后，请求返回队列没有消息；
wait_seconds = 3
print((
"%sReceive And Delete Message From Queue%s\nQueueName:%s\nWaitSeconds:%s\n"
% (10 * "=", 10 * "=", qname, wait_seconds)))
while True:
# 读取消息
try:
accid,acckey,endpoint,token = MNSSampleCommon.LoadConfig()
#初始化 my_account, my_queue
my_account = Account(endpoint, accid, acckey, token)
queue_name = MNSSampleCommon.LoadIndexParam(1)
if not queue_name:
print("Error: get parameter failed")
sys.exit(0)
param_base64 = MNSSampleCommon.LoadIndexParam(2)
if param_base64 and param_base64 == u'true':
base64 = True
else:
base64 = False
my_queue = my_account.get_queue(queue_name)
my_queue.set_encoding(base64)
#循环读取删除消息直到队列空
#receive message请求使用long polling方式，通过wait_seconds指定长轮询时间为3秒
## long polling 解析:
### 当队列中有消息时，请求立即返回；
### 当队列中没有消息时，请求在MNS服务器端挂3秒钟，在这期间，有消息写入队列，请求会立即返回消息，3秒后，请求返回队列没有消息；
wait_seconds = 3
print("%sReceive And Delete Message From Queue%s\nQueueName:%s\nWaitSeconds:%s\n" % (10*"=", 10*"=", queue_name, wait_seconds))
while True:
#读取消息
try:
self.__tmp_access_key = response_body.get("MessageTokenDTO").get("AccessKeySecret")
self.__tmp_access_id = response_body.get("MessageTokenDTO").get("AccessKeyId")
self.__expire_time = response_body.get("MessageTokenDTO").get("ExpireTime")
self.__token = response_body.get("MessageTokenDTO").get("SecurityToken")
print("key=%s, id=%s, expire_time=%s, token=%s" \
% (self.__tmp_access_key, self.__tmp_access_id, self.__expire_time, self.__token))
print("finsh refresh token...")
# 初始化 my_account, my_queue
token = Token()
token.refresh()
my_account = Account(endpoint, token.get_tmp_access_id(), token.get_tmp_access_key(), token.get_token())
my_queue = my_account.get_queue(qname)
# my_queue.set_encoding(False)
# 循环读取删除消息直到队列空
# receive message请求使用long polling方式，通过wait_seconds指定长轮询时间为3秒
## long polling 解析:
### 当队列中有消息时，请求立即返回；
### 当队列中没有消息时，请求在MNS服务器端挂3秒钟，在这期间，有消息写入队列，请求会立即返回消息，3秒后，请求返回队列没有消息；
wait_seconds = 3
print("%sReceive And Delete Message From Queue%s\nQueueName:%s\nWaitSeconds:%s\n" % (
10 * "=", 10 * "=", qname, wait_seconds))
while True:
# 读取消息
try:
# token过期是否需要刷新
## AccessKeySecret 阿里云官网获取
## Endpoint 阿里云消息和通知服务官网获取, Example: http://$AccountId.mns.cn-hangzhou.aliyuncs.com
## WARNING： Please do not hard code your accessId and accesskey in next line.(more information: https://yq.aliyun.com/articles/55947)
accessKeyId = parser.get("Base", "AccessKeyId")
accessKeySecret = parser.get("Base", "AccessKeySecret")
endpoint = parser.get("Base", "Endpoint")
securityToken = ""
if parser.has_option("Optional", "SecurityToken") and parser.get("Optional", "SecurityToken") != "$SecurityToken":
securityToken = parser.get("Optional", "SecurityToken")
#初始化my_account
my_account = Account(endpoint, accessKeyId, accessKeySecret, securityToken)
##############Queue 相关操作#####################
my_queue = my_account.get_queue("MyQueue-%s" % time.strftime("%y%m%d-%H%M%S", time.localtime()))
#创建队列
## message被receive后，持续不可消费的时间 100秒
## message body的最大长度 10240Byte
## message最长存活时间 3600秒
## 新message可消费的默认延迟时间 10秒
## receive message时，长轮询时间 20秒
queue_meta = QueueMeta()
queue_meta.set_visibilitytimeout(100)
queue_meta.set_maximum_message_size(10240)
queue_meta.set_message_retention_period(3600)
queue_meta.set_delay_seconds(10)
queue_meta.set_polling_wait_seconds(20)
queue_meta.set_logging_enabled(True)
try:
