def run_produce():
account = Account(MNS_ENDPOINT, ALI_ACCESSKEYID, ALI_ACCESSKEYSECRET)
q = account.get_queue(QUEUE_NAME)
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:
q_url = q.create(queue_meta)
sys.stdout.write("Create Queue Succeed!\nQueueURL:%s\n\n" % q_url)
except MNSExceptionBase as e:
sys.stderr.write("Create Queue Fail!\nException:%s\n\n" % e)
sys.exit(1)
for i in range(1, 10):
msg_body = "Test Message n. {} at {}".format(
i,
datetime.now().isoformat())
message = Message(msg_body)
message.set_delayseconds(0)
message.set_priority(10)
try:
send_msg = q.send_message(message)
sys.stdout.write(
"Send Message Succeed.\nMessageBody:%s\nMessageId:%s\nMessageBodyMd5:%s\n\n"
% (msg_body, send_msg.message_id, send_msg.message_body_md5))
except MNSExceptionBase as e:
sys.stderr.write("Send Message Fail!\nException:%s\n\n" % e)
sys.exit(1)
def my_send_msg(num):
# 从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 = "MyQueue1"
my_queue = my_account.get_queue(queue_name)
try:
# msg_body = "I am test message %s." % i
msg_body = num
msg = Message(msg_body)
re_msg = my_queue.send_message(msg)
# print
# "Send Message Succeed! MessageBody:%s MessageID:%s" % (msg_body, re_msg.message_id)
except MNSExceptionBase, e:
if e.type == "QueueNotExist":
print
"Queue not exist, please create queue before send message."
sys.exit(0)
print
"Send Message Fail! Exception:%s\n" % e
def run_consume():
account = Account(MNS_ENDPOINT, ALI_ACCESSKEYID, ALI_ACCESSKEYSECRET)
q = account.get_queue(QUEUE_NAME)
while True:
try:
wait_seconds = 10
recv_msg = q.receive_message(wait_seconds)
sys.stdout.write(
"Receive Message Succeed! \
\nMessageId: %s\nMessageBodyMD5: %s \
\nMessageBody: %s\nDequeueCount: %s \
\nEnqueueTime: %s\nFirstDequeueTime: %s \
\nPriority: %s\nNextVisibleTime: %s \
\nReceiptHandle: %s\n\n" %
(recv_msg.message_id, recv_msg.message_body_md5,
recv_msg.message_body, recv_msg.dequeue_count,
recv_msg.enqueue_time, recv_msg.first_dequeue_time,
recv_msg.priority, recv_msg.next_visible_time,
recv_msg.receipt_handle))
q.delete_message(recv_msg.receipt_handle)
sys.stdout.write("Delete Message Succeed.\n\n")
except MNSExceptionBase as e:
sys.stderr.write("Receive Message Fail!\nException:%s\n\n" % e)
break
try:
q.delete()
sys.stdout.write("Delete Queue Succeed!\n\n")
except MNSExceptionBase as e:
sys.stderr.write("Delete Queue Fail!\nException:%s\n\n" % e)
sys.exit(1)
def __init__(self):
self.id = conf.access_key_id
self.secret = conf.access_key_secret
self.point = conf.queue_endpoint
self.queue_name = conf.queue_name
self.auth = oss2.Auth(conf.access_key_id, conf.access_key_secret)
self.bucket = oss2.Bucket(self.auth, conf.oss_endpoint,
conf.bucket_name)
self.oss_img_path = conf.oss_img_path
client = MongoClient(conf.mongo_host)
client['admin'].authenticate('root', 'qwer1234')
self.userdb = client['qp_account']
for index, subject in enumerate(_ALL_SUPPORT_SUBJECTS):
db_name = 'qp_' + subject
self.db[index] = client[db_name]
logging.critical('connect mongodb success:{}'.format(conf.mongo_host))
if self.id is None or self.secret is None or self.point is None or self.queue_name is None:
raise Exception('lose conf')
try:
self.account = Account(self.point, self.id, self.secret)
self.queue = self.account.get_queue(self.queue_name)
logging.critical('init_MNS success:')
logging.critical(u'id:{}, point:{}, queue_name'.format(
self.id, self.point, self.queue_name))
except:
traceback.print_exc()
raise Exception('connect MNS fail')
def __init__(self):
# 读取邮箱信息
self.db = Database(
'mysql+mysqldb://spider_admin:'
'[email protected]:'
'3306/spider?charset=utf8',
encoding='utf-8')
# 初始化数据库
self.db1 = Database(
'mysql+mysqldb://%s:%s@%s:%s/%s?charset=utf8' %
(MYSQL_USER, MYSQL_PASSWD, MYSQL_HOST, MYSQL_PORT, MYSQL_DB),
encoding='utf-8')
# 初始化MNS
self.mns_account = Account(MNS_ENDPOINT, MNS_ACCID, MNS_ACCKEY,
MNS_TOKEN)
self.mns_client = self.mns_account.get_queue(MNS_QUEUE)
self.logger = Logger.timed_rt_logger()
self.queue = RedisQueue('t_mail_by_date',
host=REDIS_HOST,
port=REDIS_PORT)
self.robot = DingDingRobot(
access_token="eb749abfe9080a69da6524b77f589b8f6ddbc"
"c182c7a41bf095b095336edb0a1")
def __init__(self):
self.set_logger()
#加载阿里云相关配置
self.mns_endpoint = get_config("MNS", "mns_endpoint")
self.mns_access_id = get_config("MNS", "mns_access_id")
self.mns_access_key = get_config("MNS", "mns_access_key")
self.mns_queue_name = get_config("MNS", "mns_queue_name")
self.oss_endpoint = get_config("OSS", "oss_endpoint")
self.oss_access_id = get_config("OSS", "oss_access_id")
self.oss_access_key = get_config("OSS", "oss_access_key")
self.oss_bucket_name = get_config("OSS", "oss_bucket_name")
#加载rtmp相关配置
self.max_stream_count = int(get_config("Base", "max_stream_count"))
self.max_retries = 3
#初始化 msn account, queue
self.mns_account = Account(self.mns_endpoint, self.mns_access_id,
self.mns_access_key)
self.mns_queue = self.mns_account.get_queue(self.mns_queue_name)
self.mns_queue.set_encoding(False)
self.publish_count = 0
self.publish_mutex = threading.Lock()
self.bucket = oss2.Bucket(
oss2.Auth(self.oss_access_id, self.oss_access_key),
self.oss_endpoint, self.oss_bucket_name)
def insert_db(self, item):
try:
self.sqlalchemy_handle.session.execute(
spider_search.ResumeRaw.__table__.insert(), item
)
self.sqlalchemy_handle.session.commit()
except Exception as e:
self.sqlalchemy_handle.session.rollback()
self.logger.exception("入库失败, 回滚： %s" % e)
raise e
sql_id = self.sqlalchemy_handle.session.execute(
"select last_insert_id()").first()[0]
self.logger.info("入库成功. %s" % str(sql_id))
try:
resume_uuid = uuid.uuid1()
mns_data = {
"channelType": "WEB",
"content": {
"content": item['content'],
"id": sql_id,
"createBy": "python",
"createTime": int(time.time() * 1000),
"ip": '',
'emailJobType': item['emailJobType'],
'emailCity': item['emailCity'],
'deliverJobName': '',
'deliverJobCity': '',
"resumeSubmitTime": '',
"resumeUpdateTime": '',
"source": item['source'],
"trackId": str(resume_uuid),
"avatarUrl": '',
},
"interfaceType": "PARSE",
"resourceDataType": "RAW",
"resourceType": "RESUME_SEARCH",
"source": item['source'],
"trackId": resume_uuid,
"traceID": resume_uuid,
"callSystemID": 'five_one_python3_scrapy'
}
dumps = json.dumps(mns_data, ensure_ascii=False)
buf = StringIO()
f = gzip.GzipFile(mode='wb', fileobj=buf)
f.write(dumps)
f.close()
msg_body = base64.b64encode(buf.getvalue())
msg = Message(msg_body)
# 初始化MNS
mns_account = Account(MNS_ENDPOINT, MNS_ACCID, MNS_ACCKEY,
MNS_TOKEN)
mns_client = mns_account.get_queue(MNS_QUEUE)
mns_client.send_message(msg)
self.logger.info("推送mns成功. %s" % str(sql_id))
except Exception as e:
self.logger.exception("推送mns失败: %s" % e)
def __init__(self):
"""客户端初始化"""
cf = ConfigParser.ConfigParser()
cf.read("aliyun.conf")
host = cf.get('AccessKey_mns',"Host")
accessid = cf.get('AccessKey_mns',"Access_ID")
accesskey = cf.get('AccessKey_mns',"Access_Key")
self.cli = Account(host,accessid,accesskey)
def __init__(self):
self.client = AcsClient(app.config.get("ALI_ACCESS_KEY"),
app.config.get("ALI_ACCESS_SECRET"),
app.config.get("BASE_REGION"))
self.account = Account(app.config.get("MNS_ENDPOINT"),
app.config.get("ALI_ACCESS_KEY"),
app.config.get("ALI_ACCESS_SECRET"), "")
self.wait_seconds = 10
self.kube = Kubernetes()
def token_and_queue_refresh(self):
""" Token过期刷新 """
if not self.token.need_refresh:
return
self.token.refresh()
if self.account:
self.account.mns_client.close_connection()
self.account = Account(endpoint, self.token.tmp_access_id, self.token.tmp_access_key, self.token.token)
self.queue = self.account.get_queue(self.queue_cfg.queue_name)
logger.info(f'{self.token.tk_desc} account and queue ready')
def get_producer(self, settings):
if self._mns_producer:
return self._mns_producer
account = Account(
host=settings['MNS_ACCOUNT_ENDPOINT'],
access_id=settings['MNS_ACCESSKEY_ID'],
access_key=settings['MNS_ACCESSKEY_SECRET'],
logger=logging.getLogger('evascrapy.pipelines.AliyunMnsPipeline'),
debug=False,
)
self._mns_producer = account.get_queue(settings['MNS_QUEUE_NAME'])
return self._mns_producer
def send_message(tel="18611846371", module="hadoop", message="error"):
# 从https://account.console.aliyun.com/#/secure获取$YourAccountid
# 从https://ak-console.aliyun.com/#/accesskey获取$YourAccessId和$YourAccessKey
# 从http://$YourAccountId.mns.cn-hangzhou.aliyuncs.com获取$YourMNSEndpoint, eg. http://1234567890123456.mns.cn-hangzhou.aliyuncs.com
YourMNSEndpoint = "http://1111641897067585.mns.cn-hangzhou-internal.aliyuncs.com/"
YourAccessId = "LTAIyhZeIPt8ivJd"
YourAccessKey = "myvAcplJMk32PHIt2DSmWhRqcz6CHv"
my_account = Account(YourMNSEndpoint, YourAccessId, YourAccessKey)
YourTopicName = "sms.topic-cn-hangzhou"
my_topic = my_account.get_topic(YourTopicName)
#print my_topic
'''
Step 2. 设置SMS消息体（必须）
注：目前暂时不支持消息内容为空，需要指定消息内容，不为空即可。
'''
msg_body1 = "报警短信消息"
'''
Step 3. 生成SMS消息属性，single=False表示每个接收者参数不一样，
single=True表示每个接收者参数一样
'''
# 3.1 设置SMSSignName和SMSTempateCode
YourSignName = "app运营助手"
YourSMSTemplateCode = "SMS_32785106"
direct_sms_attr1 = DirectSMSInfo(free_sign_name=YourSignName,
template_code=YourSMSTemplateCode,
single=True)
# 3.2 指定接收短信的手机号并指定发送给该接收人的短信中的参数值（在短信模板中定义的）
cur_time = time.strftime('%H:%M:%S', time.localtime()) #变量内容不能太长
direct_sms_attr1.add_receiver(receiver=tel)
direct_sms_attr1.set_params({
"machine": "短视频",
"module": module,
"time": cur_time,
"message": message
})
#Step 5. 生成SMS消息对象
msg1 = TopicMessage(msg_body1, direct_sms=direct_sms_attr1)
re_msg = my_topic.publish_message(msg1)
#print "Publish Message Succeed. MessageBody:%s MessageID:%s" % (msg_body1, re_msg.message_id)
return 0
def create_queue(self, broker):
"""
根据broker类型，创建相应的queue对象
"""
if broker == 'redis':
#创建redis queue
from util import redis_queue
queue = redis_queue.get_queue(settings.SUBSCRIBE_QUEUE_NAME)
elif broker == 'mns':
#创建aliyun mns queue
self.mns_account = Account(\
settings.MNS_ENDPOINT, \
settings.MNS_ACCESS_KEY_ID, \
settings.MNS_ACCESS_KEY_SECRET, \
settings.MNS_SECURITY_TOKEN)
queue = self.mns_account.get_queue(settings.SUBSCRIBE_QUEUE_NAME)
else:
queue = None
return queue
def aliyunMsg(user, *args):
code, product = args
my_account = Account(Config.MNS_ENDPOINT, Config.MNS_ACCESSID,
Config.MNS_ACCESSKEY)
my_topic = my_account.get_topic(Config.MNS_TOPIC)
msg_body1 = "sms-message1."
direct_sms_attr1 = DirectSMSInfo(free_sign_name=Config.MNS_SIGN,
template_code=Config.MNS_TEMPLATE_CODE,
single=True)
direct_sms_attr1.add_receiver(receiver=user)
direct_sms_attr1.set_params({"code": code, "product": product})
msg1 = TopicMessage(msg_body1, direct_sms=direct_sms_attr1)
try:
re_msg = my_topic.publish_message(msg1)
print "Publish Message Succeed. MessageBody:%s MessageID:%s" % (
msg_body1, re_msg.message_id)
except MNSExceptionBase, e:
if e.type == "TopicNotExist":
print "Topic not exist, please create it."
sys.exit(1)
print "Publish Message Fail. Exception:%s" % e
def my_recv_msg():
#从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 = "MyQueue1"
base64 = False if len(sys.argv) > 2 and sys.argv[2].lower() == "false" else True
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)
#读取消息
try:
recv_msg = my_queue.receive_message(wait_seconds)
# print "Receive Message Succeed! ReceiptHandle:%s MessageBody:%s MessageID:%s" % (recv_msg.receipt_handle, recv_msg.message_body, recv_msg.message_id)
except MNSExceptionBase, e:
if e.type == "QueueNotExist":
print
"Queue not exist, please create queue before receive message."
sys.exit(0)
elif e.type == "MessageNotExist":
print
"Queue is empty!"
sys.exit(0)
print
"Receive Message Fail! Exception:%s\n" % e
continue
def get_mns_client():
mns_account = Account(common_settings.ENDPOINT, common_settings.ACCID,
common_settings.ACCKEY, common_settings.TOKEN)
mns_client = mns_account.get_queue(common_settings.MNS_QUEUE)
return mns_client
#DB_PASSWORD = "******"
DB_HOST = "47.95.232.88"
DB_USERNAME = "******"
DB_PASSWORD = "******"
DB_DATABASE = "greengrass"
# Read the basic configurations from sample.cfg
# WARNING: Please do not hard code your accessId and accesskey in next line.
# (more information: https://yq.aliyun.com/articles/55947)
accessKeyId, accesskeySecret, endpoint, token = MNSSampleCommon.LoadConfig()
# create the connect for IoT Kit
clt = client.AcsClient(accessKeyId, accesskeySecret, 'cn-shanghai')
# Init my_account, my_queue
my_account = Account(endpoint, accessKeyId, accesskeySecret, token)
queue_name = sys.argv[1] if len(sys.argv) > 1 else queueName
boolbase64 = False if len(
sys.argv) > 2 and sys.argv[2].lower() == "false" else True
my_queue = my_account.get_queue(queue_name)
my_queue.set_encoding(boolbase64)
# get the connection to Amazon Greengrass RDS
db = MySQLdb.connect(DB_HOST, DB_USERNAME, DB_PASSWORD, DB_DATABASE)
# Read and delete the message from queue until the queue is empty
# receive message uses long polling mode, specify the long loop time to 3 second through wait_seconds
# long polling parsing
# Return the message when there are messages
# When queue is empty, request will wait for 3 second on server side.
# coding: utf-8
import sys
from mns.account import Account
from mns.topic import DirectSMSInfo, TopicMessage
from mns.mns_exception import MNSExceptionBase
accid = 'LTAIf6atnIup14AK'
acckey = 'zfoeCi2Au0le7vUbsFOmEVtPrtlfZf'
endpoint = 'http://1771999519197750.mns.cn-hangzhou.aliyuncs.com/'
topic_name = 'sms.topic-cn-hangzhou'
my_account = Account(endpoint, accid, acckey)
my_topic = my_account.get_topic(topic_name)
'''
Step 2. 设置SMS消息体（必须）
注：目前暂时不支持消息内容为空，需要指定消息内容，不为空即可。
'''
msg_body1 = "sms-message1."
'''
Step 3. 生成SMS消息属性，single=False表示每个接收者参数不一样，
'''
# 3.1 设置SMSSignName和SMSTemplateCode
direct_sms_attr1 = DirectSMSInfo(free_sign_name='宁师生活网', template_code='SMS_69460049', single=False)
# 3.2 指定接收短信的手机号并指定发送给该接收人的短信中的参数值（在短信模板中定义的）
direct_sms_attr1.add_receiver(receiver='18150850025', params={'code': '123456'})
'''
#Step 5. 生成SMS消息对象
'''
msg1 = TopicMessage(msg_body1, direct_sms=direct_sms_attr1)
print(direct_sms_attr1.sms_params)
try:
'''
Step 6. 发布SMS消息
import sys
import os
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)) + "/..")
import time
from sample_common import MNSSampleCommon
from mns.account import Account
from mns.topic 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_topic
my_account = Account(endpoint, accid, acckey, token)
topic_name = sys.argv[1] if len(sys.argv) > 1 else "MySampleTopic"
my_topic = my_account.get_topic(topic_name)
#创建主题, 具体属性请参考mns/topic.py中的TopicMeta结构
topic_meta = TopicMeta()
try:
topic_url = my_topic.create(topic_meta)
print("Create Topic Succeed! TopicName:%s\n" % topic_name)
except MNSExceptionBase, e:
if e.type == "TopicAlreadyExist":
print(
"Topic already exist, please delete it before creating or use it directly."
)
sys.exit(0)
print("Create Topic Fail! Exception:%s\n" % e)
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 "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:
#获取配置信息
## AccessKeyId 阿里云官网获取
## 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)
def handle(self, *args, **options):
global _SERVICE_LIST
# 准备访问MNS
self.mns_account = Account(\
settings.MNS_ENDPOINT, \
settings.MNS_ACCESS_KEY_ID, \
settings.MNS_ACCESS_KEY_SECRET, \
settings.MNS_SECURITY_TOKEN)
if hasattr(settings,
'MESSAGE_DEBUG_MODE') and settings.MESSAGE_DEBUG_MODE:
import redis_queue
queue = redis_queue.get_queue(settings.SUBSCRIBE_QUEUE_NAME)
logging.info("queue mode:{}".format('redis'))
else:
queue = self.mns_account.get_queue(settings.SUBSCRIBE_QUEUE_NAME)
logging.info("queue mode:{}".format('mns'))
logging.info('queue: {}'.format(queue.get_attributes().queue_name))
# TODO: 改成LongPoll更好
while True:
handler_func = None
handle_success = False
#读取消息
try:
recv_msg = queue.receive_message(WAIT_SECONDS)
logging.info(
"Receive Message Succeed! ReceiptHandle:%s MessageBody:%s MessageID:%s"
% (recv_msg.receipt_handle, recv_msg.message_body,
recv_msg.message_id))
# 处理消息(consume)
data = json.loads(recv_msg.message_body)
message_name = data['name']
handler_func = handler_register.find_message_handler(
message_name)
if handler_func:
try:
response = handler_func(data['data'], recv_msg)
logging.info("service response: {}".format(response))
handle_success = True
#只有正常才能删除消息，否则消息仍然在队列中
try:
time.sleep(3)
queue.delete_message(recv_msg.receipt_handle)
logging.debug(
"Delete Message Succeed! ReceiptHandle:%s" %
recv_msg.receipt_handle)
except MNSExceptionBase, e:
logging.debug(
"Delete Message Fail! Exception:%s\n" % e)
except:
logging.info(u"Service Exception: {}".format(
unicode_full_stack()))
else:
#TODO: 这里是否需要删除消息？
try:
queue.delete_message(recv_msg.receipt_handle)
logging.debug(
"Delete Message Succeed! ReceiptHandle:%s" %
recv_msg.receipt_handle)
except MNSExceptionBase, e:
logging.debug("Delete Message Fail! Exception:%s\n" %
e)
logging.info(u"Error: no such service found : {}".format(
message_name))
except MNSExceptionBase as e:
if e.type == "QueueNotExist":
logging.debug(
"Queue not exist, please create queue before receive message."
)
break
elif e.type == "MessageNotExist":
logging.debug("Queue is empty! Waiting...")
else:
logging.debug("Receive Message Fail! Exception:%s\n" % e)
time.sleep(SLEEP_SECONDS)
continue
except Exception as e:
print u"Exception: {}".format(unicode_full_stack())
finally:
if handler_func:
message = {
'message_id': recv_msg.message_id,
'message_body_md5': '',
'data': args,
'topic_name': '',
'msg_name': message_name,
'handel_success': handle_success
}
watchdog.info(message, log_type='MNS_RECEIVE_LOG')
return
for sec, op in required_ops:
if not parser.has_option(sec, op):
sys.stderr.write("ERROR: need (%s, %s) in %s.\n" % (sec, op, cfgFN))
sys.stderr.write("Read README to get help inforamtion.\n")
sys.exit(1)
#获取配置信息
## AccessKeyId 阿里云官网获取
## AccessKeySecret 阿里云官网获取
## Endpoint 阿里云消息和通知服务官网获取, Example: http://$AccountId.mns.cn-hangzhou.aliyuncs.com
accessKeyId = parser.get("Base", "AccessKeyId")
accessKeySecret = parser.get("Base", "AccessKeySecret")
endpoint = parser.get("Base", "Endpoint")
#初始化my_account和my_queue
my_account = Account(endpoint, accessKeyId, accessKeySecret)
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)
#! -*- coding: utf-8 -*-
import json
from mns.account import Account
from mns.mns_exception import MNSExceptionBase
from utils import post_slack
from config import QUEUE_NAME, END_POINT, ACCESS_KEY_ID, ACCESS_KEY_SECRET
account = Account(END_POINT, ACCESS_KEY_ID, ACCESS_KEY_SECRET)
queue = account.get_queue(QUEUE_NAME)
def run():
while True:
try:
recv_msg = queue.receive_message(wait_seconds=10)
message = json.loads(recv_msg.message_body)['message']
print message
if message['levelDescription'] == u'恢复正常':
color = 'good'
else:
color = 'danger'
post_slack(message['dimensions'], message['metricName'],
message['expression'], color)
queue.delete_message(recv_msg.receipt_handle)
except MNSExceptionBase, e:
print e.message
if __name__ == '__main__':
GPIO_clean()
if __name__ == '__main__':
print "start deamon!"
#init my_account, my_topic
endpoint = "http://1402010103453031.mns.cn-hangzhou.aliyuncs.com/"
access_id = "LTAIfpx57LeEmMKs"
access_key = "nUqBzUFc48cTVIZh3mkpcnmosxvGTz"
token = ""
quit = Queue()
dr = DryingRack()
GPIO_init()
#init my_account, my_topic
my_account = Account(endpoint, access_id, access_key, token)
# queue_name = "control-queue"
# my_queue = my_account.get_queue(queue_name)
#Thread(target=control_thread,args=(my_account,)).start()
#Thread(target=ioread_thread,args=(my_queue,)).start()
Process(target=ioread_thread, args=(my_account, quit)).start()
Process(target=control_thread, args=(my_account, quit)).start()
#ioread_thread(my_account)
while True:
s = raw_input("type quit to quit:")
if s == "quit":
quiting = True
quit.put("quit")
#coding:utf-8
import os
from flask import Flask, jsonify, request
from mns.account import Account
from mns.topic import DirectSMSInfo, TopicMessage, MNSExceptionBase
app = Flask(__name__)
account = Account(os.getenv('END_POINT'), os.getenv('ACCESS_ID'),
os.getenv('ACCESS_KEY'))
topic = account.get_topic(os.getenv('TOPIC'))
accessToken = os.getenv('ACCESS_TOKEN')
class InvalidUsage(Exception):
status_code = 400
def __init__(self, message, status_code=None, payload=None):
Exception.__init__(self)
self.message = message
if status_code is not None:
self.status_code = status_code
self.payload = payload
def to_dict(self):
rv = dict(self.payload or ())
rv['message'] = self.message
return rv
@app.errorhandler(InvalidUsage)
def handle_invalid_usage(error):
# -*- coding: utf-8 -*-
#you can get $accountid from https://account.console.aliyun.com/#/secure
#you can get $accid and $acckey from https://ak-console.aliyun.com/#/accesskey
#you can generate $endpoint: http://$accountid.mns.cn-hangzhou.aliyuncs.com, eg. http://1234567890123456.mns.cn-hangzhou.aliyuncs.com
import sys
import time
from mns.account import Account
from mns.queue import *
from mns.topic import *
from mns.subscription import *
import ConfigParser
my_account = Account("http://1037980991456445.mns.cn-hangzhou.aliyuncs.com/", "LTAI1waLaAYoSvm7", "Lt4u9GsiTCn9RVE7ITCE7crestypvH")
topic_name = "sms.topic-cn-hangzhou"
my_topic = my_account.get_topic(topic_name)
#attributes for Mail
#direct_mail = DirectMailInfo(account_name="*****@*****.**", subject="TestMailSubject", address_type=0, is_html=0, reply_to_address=0)
#attributes for SMS
#linename="Tom"
#devicename="001"
#message="duanlu"
def send_msg(phone,linename,devicename,message):
direct_sms_attr1 = DirectSMSInfo(free_sign_name="故指通知", template_code="SMS_51620020", single=False)
phonenumber=phone.split(',')
number=len(phonenumber)
while(number!=0):
number-=1
direct_sms_attr1.add_receiver(receiver=str(phonenumber[number]), params={"linename": str(linename) ,"devicename": str(devicename) ,"message": str(message) })
#direct_sms.add_receiver(receiver="$phone2", params={"name": "David"})
#init TopicMessage
msg_body = "I am test message."
def __init__(self):
super(ResumeExchange, self).__init__()
self.mns_account = Account(MNS_ENDPOINT, MNS_ACCID, MNS_ACCKEY,
MNS_TOKEN)
self.mns_client = self.mns_account.get_queue(MNS_QUEUE)
import time
from mns.account import Account
from mns.queue import *
from mns.topic import *
from mns.subscription import *
import ConfigParser
#获取配置信息
accessKeyId = ""
accessKeySecret = ""
endpoint = " "
securityToken = ""
#初始化my_account
my_account = Account("", "", "")
my_queue = my_account.get_queue("MyQueue-%s" % time.strftime("%y%m%d-%H%M%S", time.localtime()))
my_topic = my_account.get_topic("sms.topic-cn-shanghai")
'''
天气查询
'''
reload(sys)
sys.setdefaultencoding('utf-8')
#查询城市ID
baseurl = 'https://free-api.heweather.com/v5/'
ikey = '1be15036695c4206b949a3c1ffc7ce72'
print ("Please tell us city name")
city_n = raw_input("Enter your city nmae: ")
def __init__(self):
# initialize my_account, my_queue
my_account = Account(settings.ALIYUN_MNS_END_POINT,
settings.ALIYUN_MNS_ACCESS_KEY_ID,
settings.ALIYUN_MNS_ACCESS_KEY_SECRET, "")
self.my_queue = my_account.get_queue(settings.ALIYUN_MNS_QUEUE_NAME)
