一、概念与原理
MQTT（Message Queuing Telemetry Transport，消息队列遥测传输协议），是一种基于发布/订阅（publish/subscribe）模式的轻量级协议，该协议构建于TCP/IP协议之上，MQTT最大优点在于，可以以极少的代码和有限的带宽，为连接远程设备提供实时可靠的消息服务。作为一种低开销、低带宽占用的即时通讯协议，使其在物联网、小型设备、移动应用等方面有较广泛的应用。
MQTT是一个基于客户端-服务器的消息发布/订阅传输协议。MQTT协议是轻量、简单、开放和易于实现的，这些特点使它适用范围非常广泛。在很多情况下，包括受限的环境中，如：机器与机器（M2M）通信和物联网（IoT）。其在，通过卫星链路通信传感器、偶尔拨号的医疗设备、智能家居、及一些小型化设备中已广泛使用。
MQTT协议工作在低带宽、不可靠的网络的远程传感器和控制设备通讯而设计的协议，它具有以下主要的几项特性：
（1）使用发布/订阅消息模式，提供一对多的消息发布，解除应用程序耦合。
（2）对负载内容屏蔽的消息传输。
（3）使用TCP/IP提供网络连接。
主流的MQTT是基于TCP连接进行数据推送的，但是同样有基于UDP的版本，叫做MQTT-SN。这两种版本由于基于不同的连接方式，优缺点自然也就各有不同了。
（4）有三种消息发布服务质量(qss)：
“至多一次”，消息发布完全依赖底层TCP/IP网络。会发生消息丢失或重复。这一级别可用于如下情况，环境传感器数据，丢失一次读记录无所谓，因为不久后还会有第二次发送。这一种方式主要普通APP的推送，倘若你的智能设备在消息推送时未联网，推送过去没收到，再次联网也就收不到了。
“至少一次”，确保消息到达，但消息重复可能会发生。
“只有一次”，确保消息到达一次。在一些要求比较严格的计费系统中，可以使用此级别。在计费系统中，消息重复或丢失会导致不正确的结果。这种最高质量的消息发布服务还可以用于即时通讯类的APP的推送，确保用户收到且只会收到一次。
当然了这个数字越小,带宽带站越低
实现MQTT协议需要客户端和服务器端通讯完成，在通讯过程中，MQTT协议中有三种身份：发布者（Publish）、代理（Broker）（服务器）、订阅者（Subscribe）。其中，消息的发布者和订阅者都是客户端，消息代理是服务器，消息发布者可以同时是订阅者。
MQTT传输的消息分为：主题（Topic）和负载（payload）两部分：
（1）Topic，可以理解为消息的类型，订阅者订阅（Subscribe）后，就会收到该主题的消息内容（payload）；
（2）payload，可以理解为消息的内容，是指订阅者具体要使用的内容。
二、环境准备
1、安装paho-mqtt
命令 pip install paho-mqtt
2、安装peewee
pip install peewee
运用命令python -m pwiz -e mysql -H 127.0.0.1 -p 3306 -u root -P dbname >model.py
python -m pwiz -e mysql -H {主机地址} -p 3306 -u root -- password {数据库名称} > {生成的代码文件 例model.py}
-e数据库类型 比如mysql
-H数据库ip
-p端口
-u数据库用户名
-P密码
dbname为db名
db.py自动生成的py文件名
因为我做的时候，订阅跟推送都需要从数据库取公司编码以及推送还需要从数据库取得用户ID
三、订阅
啥也不说 直接上代码：
"""
@Desc: 订阅
@Time: 2021/8/8 10:00
@Author: kally
@Version: 1.0
@FileName: subscribe.py
"""
# coding=utf-8
import datetime
import time
import paho.mqtt.client as mqtt
import logging
from models.dev_weigh import CoTpSiteProgress #利用peewee生成的.py文件
logging.basicConfig(filename='resp.txt', level='INFO')
file = open("resp.txt", 'w').close() # 清空文件之前的内容
def findStr(str):
with open("resp.txt", 'r') as f:
counts = 0
for line in f.readlines():
time = line.count(str)
counts += time
print("%s出现的次数：%d" % (str, counts))
num = 1
host = "*****.com" # 主机地址
port = 1883
client = mqtt.Client()
def get_data():
'''从数据库获取公司编码拼接成需要订阅的主题列表'''
cocode_list = []
sub_topic = []
driver = CoTpSiteProgress.select().where((CoTpSiteProgress.status == 1))
# 遍历数据
for p in driver:
cocode_list.append(p.co_code)
print(f"一共{len(cocode_list)}条数据")
cocode_list = set(cocode_list)
cocode_list = list(cocode_list)
for i in range(len(cocode_list)):
coCode = cocode_list[i]
sub_topic.append("LMS/uat10/toClient/{}/1".format(coCode)) # 要订阅的主题列表
print(sub_topic)
return sub_topic
def on_connect(client, userdata, flags, rc):
if rc == 0:
print("Connected to MQTT Broker!")
else:
print("Failed to connect, return code %d\n", rc)
print("Connected with result code: " + str(rc))
def on_log(client, obj, level, string):
print("Log:" + string)
def on_message(client, obj, msg):
'''接受到的服务器返回的消息格式处理'''
global num
curtime = datetime.datetime.now()
strcurtime = curtime.strftime("%Y-%m-%d %H:%M:%S")
print("index: " + str(num) + " " + strcurtime + ": " + msg.topic + " " + str(msg.qos) + " " + str(msg.payload))
logging.info(
"index: " + str(num) + " " + strcurtime + ": " + msg.topic + " " + str(msg.qos) + " " + str(msg.payload))
on_exec(str(msg.payload))
num = num + 1
def on_exec(strcmd):
print("Exec:", strcmd)
def mqtt_connect():
'''链接到MQTT服务器'''
client.username_pw_set("user_test", "user_test")
# client.username_pw_set("admin", "public")
client.on_connect = on_connect
client.on_message = on_message
client.connect(host, 1883, 6000) # 600为keepalive的时间间隔 1883为broker默认端
time.sleep(2)
def mqtt_sub():
'''循环方式订阅所有的主题函数'''
sub_topic = get_data()
mqtt_connect()
print("beign sub")
for i in range(len(sub_topic)):
client.subscribe(sub_topic[i], qos=2)
print("index: " + str(i + 1) + " " + sub_topic[i])
print(f"订阅了{len(sub_topic)}个公司")
print("end sub")
client.loop_forever() # 保持连接
if __name__ == '__main__':
mqtt_sub()
findStr("ack")
四、推送
"""
@Desc: 推送
@Time: 2021/8/8 10:00
@Author: kally
@Version: 1.0
@FileName: locustfile.py
"""
# coding=utf-8
import datetime
import os
import random
import paho.mqtt.client as mqtt
import time
import logging
import sys
import queue
from locust import task, HttpUser, constant, TaskSet, between
import json
from models.dev_weigh import CoTpSiteProgress
host = "*******.com" # 主机地址
port = 1883 # 端口号
client = mqtt.Client()
file = open("locust.log", 'w').close() # 清空文件之前的内容
def get_XS_one_data(): # 销售
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.node_now == "040") & (CoTpSiteProgress.business_type == 2))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(driverIdCard_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def get_XS_two_data(): # 销售二次过磅
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.node_now == "070") & (CoTpSiteProgress.business_type == 2))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def get_CG_one_data(): # 采购1次过磅
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.node_now == "040") & (CoTpSiteProgress.business_type == 1))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def get_CG_two_data(): # 采购二次过磅
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.node_now == "070") & (CoTpSiteProgress.business_type == 1))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def get_DD_1_one_data(): # 短倒先毛后皮1次过磅 # 短导一次过磅，先毛后皮 短倒一次过磅 先皮后毛 过磅类型 1=仙茅后皮，2=先皮后毛，3=单次计量
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.node_now == "040") & (
CoTpSiteProgress.business_type == 3) & (CoTpSiteProgress.weigh_type == 1))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def get_DD_1_two_data(): # 短倒先毛后皮2次过磅
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.node_now == "070") & (
CoTpSiteProgress.business_type == 3) & (CoTpSiteProgress.weigh_type == 1))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def get_DD_2_one_data(): # 短导一次过磅，先毛后皮 短倒一次过磅 先皮后毛 过磅类型 1=仙茅后皮，2=先皮后毛，3=单次计量 #短倒先皮后毛1次过磅
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.node_now == "040") & (
CoTpSiteProgress.business_type == 3) & (CoTpSiteProgress.weigh_type == 2))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def get_DD_2_two_data(): # 短倒先皮后毛2次过磅
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.node_now == "070") & (
CoTpSiteProgress.business_type == 3) & (CoTpSiteProgress.weigh_type == 2))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def get_JL_data(): # 单次计量
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where(
(CoTpSiteProgress.status == 1) & (CoTpSiteProgress.weigh_type == 3) & (CoTpSiteProgress.business_type == 3))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
print(cocode_list)
print(len(cocode_list))
return cocode_list, driverIdCard_list
def findStr(str): # 统计文件出现某个字符的个数，为了方便看数据有无丢失的情况
with open("locust.log", 'r') as f:
counts = 0
for line in f.readlines():
time = line.count(str)
counts += time
print("%s出现的次数：%d" % (str, counts))
def get_data():
driverIdCard_list = []
cocode_list = []
driver = CoTpSiteProgress.select().where((CoTpSiteProgress.status == 1))
# 遍历数据
for p in driver:
driverIdCard_list.append(p.driver_id_card)
cocode_list.append(p.co_code)
return cocode_list, driverIdCard_list
from gevent.lock import Semaphore
from locust import task, between, User
sem = Semaphore()
class Rendezvous:
target_user_count = 0
_current_user_count = 0
_sem = None
def __init__(self, user_count=1):
self.target_user_count = user_count
def _get_lock(self, name):
if self._sem is None:
self._sem = Semaphore()
self._sem.acquire()
logging.info(f"Rendezvous: acquire by {name} !!!!!!")
return self._sem
def wait(self, name=""):
self._current_user_count += 1
_sem = self._get_lock(name)
if self._current_user_count >= self.target_user_count:
self._current_user_count = 0
self._sem = None
logging.info(f"Rendezvous: release by {name}!!!!!!")
_sem.release()
else:
logging.info(f"Rendezvous: wait by {name}")
_sem.wait()
class TestPublish(TaskSet):
mqtt_connect()
wait_time = constant(0)
user_data_queue = queue.Queue()
cocode_list = get_XS_one_data()[0]
id = 0
count = 0
driverIdCard_list = get_XS_one_data()[1]
Rendezvous = Rendezvous(10) # 10个集合到一起冲上去 10个集合到一起还是可以的
for i in range(len(cocode_list)):
data = json.dumps({"ack": str(random.randint(1, 10000)), "type": "weighing",
"data": {"driverIdCard": driverIdCard_list[i], "weighing": random.randint(1, 1000),
"coCode": cocode_list[i]}}) # 发布信息
pub_topic = "LMS/uat10/toServer/{}/1".format(cocode_list[i]) # uat
user_data_queue.put_nowait((data, pub_topic))
# print(user_data_queue.queue)
def __init__(self, parent):
super().__init__(parent)
self.__class__.count += 1
self.id = self.__class__.count
@task
def test_publish(self, name=""):
self.Rendezvous.wait(str(self.id))
try:
data, pub_topic = self.user_data_queue.get()
except queue.Empty:
print('account data run out, test ended.')
sys.exit(0)
client.connect(host, port, 6000) # 6000为keepalive的时间间隔1883
result = client.publish(pub_topic, payload=data, qos=2)
curtime = datetime.datetime.now()
strcurtime = curtime.strftime("%Y-%m-%d %H:%M:%S")
status = result[0]
if status == 0:
print(
f"index:{result[1]} strcurtime:{strcurtime} id:{str(self.id)} time:{time.time()} Send `{data}` to topic `{pub_topic}`")
else:
print(f"Failed to send message `{data}` to topic {pub_topic}")
logging.info(
f"index:{result[1]} strcurtime:{strcurtime} id:{str(self.id)} time:{time.time()} Send `{data}` to topic `{pub_topic}`")
time.sleep(30) # 开启的每个进程延时10秒
class User(HttpUser):
tasks = [TestPublish]
wait_time = between(1, 2)
host = "emq1.esyds.com"
stop_timeout = 3
if __name__ == '__main__':
os.system(f'locust -f mqtt_publish.py --headless -u 10 -r 5 --run-time 600s --csv=example')
findStr("***/***/toServer")
'''几个参数说明
常用：
--headless >>> 无web界面运行脚本
-u 1000 -r 100 >>> 共有1000个用户，每秒启动100个
--run-time 1h30m >>> 共运行1小时30分
--csv=example >>> 脚本目录下，生成含数据的csv文件
很少用：
--expect-workers >>> 分布式无web界面的运行要在配置文件指定该参数
--stop-timeout 99 >>> 到指定时间后，再停99秒结束运行
'''
运用python中的locust，无web界面运行脚本的方式。
同时打印出相应的日志
host =****.com
users = 5
spawn-rate = 1
logfile = locust.log
loglevel = INFO