def handle(self):
global brokers, clients, options, break_connections, control_broker
if not hasattr(self, "ids"):
self.ids = {}
if not hasattr(self, "versions"):
self.versions = {}
inbuf = True
i = o = e = None
try:
clients = self.request
brokers = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
brokers.connect((brokerhost, brokerport))
while inbuf != None:
(i, o, e) = select.select([clients, brokers], [], [])
for s in i:
if s == clients:
inbuf = MQTTV3.getPacket(clients) # get one packet
if inbuf == None:
break
try:
packet = MQTTV3.unpackPacket(inbuf)
if packet.fh.MessageType == MQTTV3.CONNECT:
self.ids[id(clients)] = packet.ClientIdentifier
self.versions[id(clients)] = 3
logger.debug("C to S " + self.ids[id(clients)] +
" " + repr(packet))
#logger.debug([hex(b) for b in inbuf])
#logger.debug(inbuf)
except:
traceback.print_exc()
brokers.send(inbuf) # pass it on
elif s == brokers:
inbuf = MQTTV3.getPacket(brokers) # get one packet
if inbuf == None:
break
try:
logger.debug("S to C " + self.ids[id(clients)] +
" " +
repr(MQTTV3.unpackPacket(inbuf)))
except:
traceback.print_exc()
clients.send(inbuf)
if id(clients) in self.ids.keys():
logger.info("client " + self.ids[id(clients)] +
" connection closing")
except:
#logger.debug(repr((i, o, e)) + " " + repr(inbuf))
traceback.print_exc()
if id(clients) in self.ids.keys():
del self.ids[id(clients)]
elif id(clients) in self.versions.keys():
del self.versions[id(clients)]
def handle(self):
global brokers, clients, options, break_connections, control_broker
if not hasattr(self, "ids"):
self.ids = {}
if not hasattr(self, "versions"):
self.versions = {}
inbuf = True
i = o = e = None
try:
clients = self.request
brokers = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
brokers.connect((brokerhost, brokerport))
while inbuf != None:
(i, o, e) = select.select([clients, brokers], [], [])
for s in i:
if s == clients:
inbuf = MQTTV3.getPacket(clients) # get one packet
if inbuf == None:
break
try:
packet = MQTTV3.unpackPacket(inbuf)
if packet.fh.MessageType == MQTTV3.CONNECT:
self.ids[id(clients)] = packet.ClientIdentifier
self.versions[id(clients)] = 3
logger.debug("C to S "+self.ids[id(clients)]+" "+repr(packet))
#logger.debug([hex(b) for b in inbuf])
#logger.debug(inbuf)
except:
traceback.print_exc()
brokers.send(inbuf) # pass it on
elif s == brokers:
inbuf = MQTTV3.getPacket(brokers) # get one packet
if inbuf == None:
break
try:
logger.debug("S to C "+self.ids[id(clients)]+" "+repr(MQTTV3.unpackPacket(inbuf)))
except:
traceback.print_exc()
clients.send(inbuf)
if id(clients) in self.ids.keys():
logger.info("client "+self.ids[id(clients)]+" connection closing")
except:
#logger.debug(repr((i, o, e)) + " " + repr(inbuf))
traceback.print_exc()
if id(clients) in self.ids.keys():
del self.ids[id(clients)]
elif id(clients) in self.versions.keys():
del self.versions[id(clients)]
def handleRequest(self, sock):
"this is going to be called from multiple threads, so synchronize"
self.lock.acquire()
terminate = False
try:
try:
raw_packet = MQTTV3.getPacket(sock)
except:
raise MQTTV3.MQTTException(
"[MQTT-4.8.0-1] 'transient error' reading packet, closing connection"
)
if raw_packet == None:
# will message
self.disconnect(sock, None, terminate=True)
terminate = True
else:
packet = MQTTV3.unpackPacket(raw_packet)
if packet:
terminate = self.handlePacket(packet, sock)
else:
raise MQTTV3.MQTTException(
"[MQTT-2.0.0-1] handleRequest: badly formed MQTT packet"
)
finally:
self.lock.release()
return terminate
def __call__(self, sockid):
logger.debug("*** running")
self.running = True
packet = None
try:
while True:
packet = MQTTV3.unpackPacket(MQTTV3.getPacket(state.sockets[sockid]))
if packet == None:
break
if test:
logger.debug("received result %s", (sockid, packet))
test.addResult((sockid, packet))
if packet.fh.MessageType == MQTTV3.CONNACK:
self.packets.append(packet)
else:
mbt.observe((sockid, packet))
if packet.fh.MessageType == MQTTV3.PUBREC:
mbt.execution.pools["pubrecs"].append(mbt.Choices((sockid, packet)))
elif packet.fh.MessageType == MQTTV3.PUBLISH and packet.fh.QoS in [1, 2]:
mbt.execution.pools["publishes"].append(mbt.Choices((sockid, packet)))
elif packet.fh.MessageType == MQTTV3.PUBREL:
mbt.execution.pools["pubrels"].append(mbt.Choices((sockid, packet)))
elif packet.fh.MessageType == MQTTV3.CONNACK:
self.packets.append(packet)
except:
if sys.exc_info()[0] != socket.error:
logger.debug("unexpected exception %s", sys.exc_info())
#mbt.log(traceback.format_exc())
self.running = False
logger.debug("*** stopping "+str(packet))
def __call__(self, sockid):
logger.debug("*** running")
self.running = True
packet = None
try:
while True:
packet = MQTTV3.unpackPacket(MQTTV3.getPacket(state.sockets[sockid]))
if packet == None:
break
if test:
logger.debug("received result %s", (sockid, packet))
test.addResult((sockid, packet))
if packet.fh.MessageType == MQTTV3.CONNACK:
self.packets.append(packet)
else:
mbt.observe((sockid, packet))
if packet.fh.MessageType == MQTTV3.PUBREC:
mbt.execution.pools["pubrecs"].append(mbt.Choices((sockid, packet)))
elif packet.fh.MessageType == MQTTV3.PUBLISH and packet.fh.QoS in [1, 2]:
mbt.execution.pools["publishes"].append(mbt.Choices((sockid, packet)))
elif packet.fh.MessageType == MQTTV3.PUBREL:
mbt.execution.pools["pubrels"].append(mbt.Choices((sockid, packet)))
elif packet.fh.MessageType == MQTTV3.CONNACK:
self.packets.append(packet)
except:
if sys.exc_info()[0] != socket.error:
logger.debug("unexpected exception %s", sys.exc_info())
#mbt.log(traceback.format_exc())
self.running = False
logger.debug("*** stopping "+str(packet))
def connect2(self, host, port, cleansession, keepalive, newsocket,
protocolName, willFlag, willTopic, willMessage, willQoS,
willRetain, username, password):
if newsocket:
try:
self.sock.close()
except:
pass
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(.5)
self.sock.connect((host, port))
connect = MQTTV3.Connects() #mqtt login
connect.ClientIdentifier = self.clientid
connect.CleanSession = cleansession
connect.KeepAliveTimer = keepalive
if protocolName:
connect.ProtocolName = protocolName
if willFlag:
connect.WillFlag = True
connect.WillTopic = willTopic
connect.WillMessage = willMessage
connect.WillQoS = willQoS
connect.WillRETAIN = willRetain
if username:
connect.usernameFlag = True
connect.username = username
if password:
connect.passwordFlag = True
connect.password = password
sendtosocket(self.sock, connect.pack())
response = MQTTV3.unpackPacket(MQTTV3.getPacket(self.sock))
if not response:
raise MQTTV3.MQTTException(
"connect failed - socket closed, no connack")
assert response.fh.MessageType == MQTTV3.CONNACK
self.cleansession = cleansession
assert response.returnCode == 0, "connect was %s" % str(response)
if self.cleansession or self.__receiver == None:
self.__receiver = internal.Receivers(self.sock)
else:
self.__receiver.socket = self.sock
if self.callback:
id = _thread.start_new_thread(self.__receiver, (self.callback, ))
return response
def connect(self, host="localhost", port=1883, cleansession=True, keepalive=0, newsocket=True, protocolName=None,
willFlag=False, willTopic=None, willMessage=None, willQoS=2, willRetain=False, username=None, password=None):
if newsocket:
try:
self.sock.close()
except:
pass
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.settimeout(.5)
self.sock.connect((host, port))
connect = MQTTV3.Connects()
connect.ClientIdentifier = self.clientid
connect.CleanSession = cleansession
connect.KeepAliveTimer = keepalive
if protocolName:
connect.ProtocolName = protocolName
if willFlag:
connect.WillFlag = True
connect.WillTopic = willTopic
connect.WillMessage = willMessage
connect.WillQoS = willQoS
connect.WillRETAIN = willRetain
if username:
connect.usernameFlag = True
connect.username = username
if password:
connect.passwordFlag = True
connect.password = password
sendtosocket(self.sock, connect.pack())
response = MQTTV3.unpackPacket(MQTTV3.getPacket(self.sock))
if not response:
raise MQTTV3.MQTTException("connect failed - socket closed, no connack")
assert response.fh.MessageType == MQTTV3.CONNACK
self.cleansession = cleansession
assert response.returnCode == 0, "connect was %s" % str(response)
if self.cleansession or self.__receiver == None:
self.__receiver = internal.Receivers(self.sock)
else:
self.__receiver.socket = self.sock
if self.callback:
id = _thread.start_new_thread(self.__receiver, (self.callback,))
return response
def handleRequest(self, sock):
"this is going to be called from multiple threads, so synchronize"
self.lock.acquire()
terminate = False
try:
try:
raw_packet = MQTTV3.getPacket(sock)
except:
raise MQTTV3.MQTTException("[MQTT-4.8.0-1] 'transient error' reading packet, closing connection")
if raw_packet == None:
# will message
self.disconnect(sock, None, terminate=True)
terminate = True
else:
packet = MQTTV3.unpackPacket(raw_packet)
if packet:
terminate = self.handlePacket(packet, sock)
else:
raise MQTTV3.MQTTException("[MQTT-2.0.0-1] handleRequest: badly formed MQTT packet")
finally:
self.lock.release()
return terminate
def handle(self):
if not hasattr(self, "ids"):
self.ids = {}
if not hasattr(self, "versions"):
self.versions = {}
inbuf = True
i = o = e = None
try:
clients = self.request
brokers = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
brokers.connect((brokerhost, brokerport))
while inbuf != None:
(i, o, e) = select.select([clients, brokers], [], [])
for s in i:
if s == clients:
inbuf = MQTTV3.getPacket(clients) # get one packet
if inbuf == None:
break
try:
packet = MQTTV3.unpackPacket(inbuf)
if (
packet.fh.MessageType == MQTTV3.PUBLISH
and packet.topicName == "MQTTSAS topic"
and packet.data == "TERMINATE"
):
print("Terminating client", self.ids[id(clients)])
brokers.close()
clients.close()
break
else:
if packet.fh.MessageType == MQTTV3.CONNECT:
self.ids[id(clients)] = packet.ClientIdentifier
self.versions[id(clients)] = 3
wx.CallAfter(myWindow.log, timestamp(), "C to S", self.ids[id(clients)], repr(packet))
except:
traceback.print_exc()
# next line should not be needed once things work properly
print("C to S", timestamp(), repr(inbuf))
sys.exit()
# print "C to S", timestamp(), repr(inbuf)
brokers.send(inbuf) # pass it on
elif s == brokers:
inbuf = MQTTV3.getPacket(brokers) # get one packet
if inbuf == None:
break
try:
wx.CallAfter(
myWindow.log,
timestamp(),
"S to C",
self.ids[id(clients)],
repr(MQTTV3.unpackPacket(inbuf)),
)
except:
traceback.print_exc()
# next line should not be needed once things work properly
print("S to C", timestamp(), repr(inbuf))
sys.exit()
# print "S to C", timestamp(), repr(inbuf)
clients.send(inbuf)
wx.CallAfter(myWindow.status, timestamp() + " client " + self.ids[id(clients)] + " connection closing")
except:
print(repr((i, o, e)), repr(inbuf))
traceback.print_exc()
if self.ids.has_key(id(clients)):
del self.ids[id(clients)]
elif self.versions.has_key(id(clients)):
del self.versions[id(clients)]
def receive(self, callback=None):
packet = None
try:
packet = MQTTV3.unpackPacket(MQTTV3.getPacket(self.socket))
except:
if not self.stopping and sys.exc_info()[0] != socket.timeout:
logging.error("receive: unexpected exception %s", str(sys.exc_info()))
#traceback.print_exc()
raise
if packet == None:
time.sleep(0.1)
return
logging.debug("in :%s", str(packet))
if packet.fh.MessageType == MQTTV3.SUBACK:
if hasattr(callback, "subscribed"):
callback.subscribed(packet.messageIdentifier, packet.data)
elif packet.fh.MessageType == MQTTV3.UNSUBACK:
if hasattr(callback, "unsubscribed"):
callback.unsubscribed(packet.messageIdentifier)
elif packet.fh.MessageType == MQTTV3.PUBACK:
"check if we are expecting a puback"
if packet.messageIdentifier in self.outMsgs.keys() and \
self.outMsgs[packet.messageIdentifier].fh.QoS == 1:
del self.outMsgs[packet.messageIdentifier]
if hasattr(callback, "published"):
callback.published(packet.messageIdentifier)
else:
raise Exception("No QoS 1 with that message id sent")
elif packet.fh.MessageType == MQTTV3.PUBREC:
if packet.messageIdentifier in self.outMsgs.keys():
self.outMsgs[packet.messageIdentifier].pubrec_received == True
self.pubrel.messageIdentifier = packet.messageIdentifier
logging.debug("out: %s", str(self.pubrel))
self.socket.send(self.pubrel.pack())
else:
raise Exception("PUBREC received for unknown msg id "+ \
str(packet.messageIdentifier))
elif packet.fh.MessageType == MQTTV3.PUBREL:
"release QOS 2 publication to client, & send PUBCOMP"
msgid = packet.messageIdentifier
if packet.messageIdentifier not in self.inMsgs.keys():
pass # what should we do here?
else:
pub = self.inMsgs[packet.messageIdentifier]
if callback == None or \
callback.publishArrived(pub.topicName, pub.data, 2,
pub.fh.RETAIN, pub.messageIdentifier):
del self.inMsgs[packet.messageIdentifier]
self.pubcomp.messageIdentifier = packet.messageIdentifier
logging.debug("out: %s", str(self.pubcomp))
self.socket.send(self.pubcomp.pack())
if callback == None:
return (pub.topicName, pub.data, 2,
pub.fh.RETAIN, pub.messageIdentifier)
elif packet.fh.MessageType == MQTTV3.PUBCOMP:
"finished with this message id"
if packet.messageIdentifier in self.outMsgs.keys():
del self.outMsgs[packet.messageIdentifier]
if hasattr(callback, "published"):
callback.published(packet.messageIdentifier)
else:
raise Exception("PUBCOMP received for unknown msg id "+ \
str(packet.messageIdentifier))
elif packet.fh.MessageType == MQTTV3.PUBLISH:
if self.paused:
return
if packet.fh.QoS == 0:
if callback == None:
return (packet.topicName, packet.data, 0,
packet.fh.RETAIN, packet.messageIdentifier)
else:
callback.publishArrived(packet.topicName, packet.data, 0,
packet.fh.RETAIN, packet.messageIdentifier)
elif packet.fh.QoS == 1:
if callback == None:
return (packet.topicName, packet.data, 1,
packet.fh.RETAIN, packet.messageIdentifier)
else:
if callback.publishArrived(packet.topicName, packet.data, 1,
packet.fh.RETAIN, packet.messageIdentifier):
self.puback.messageIdentifier = packet.messageIdentifier
logging.debug("out: %s", str(self.puback))
self.socket.send(self.puback.pack())
elif packet.fh.QoS == 2:
self.inMsgs[packet.messageIdentifier] = packet
self.pubrec.messageIdentifier = packet.messageIdentifier
logging.debug("out: %s", str(self.pubrec))
self.socket.send(self.pubrec.pack())
else:
raise Exception("Unexpected packet"+str(packet))
def receive(self, callback=None):
packet = None
try:
packet = MQTTV3.unpackPacket(MQTTV3.getPacket(self.socket))
except:
if not self.stopping and sys.exc_info()[0] != socket.timeout:
logging.error("receive: unexpected exception %s",
str(sys.exc_info()))
#traceback.print_exc()
raise
if packet == None:
time.sleep(0.1)
return
logging.debug("in :%s", str(packet))
if packet.fh.MessageType == MQTTV3.SUBACK:
if hasattr(callback, "subscribed"):
callback.subscribed(packet.messageIdentifier, packet.data)
elif packet.fh.MessageType == MQTTV3.UNSUBACK:
if hasattr(callback, "unsubscribed"):
callback.unsubscribed(packet.messageIdentifier)
elif packet.fh.MessageType == MQTTV3.PUBACK:
"check if we are expecting a puback"
if packet.messageIdentifier in self.outMsgs.keys() and \
self.outMsgs[packet.messageIdentifier].fh.QoS == 1:
del self.outMsgs[packet.messageIdentifier]
if hasattr(callback, "published"):
callback.published(packet.messageIdentifier)
else:
raise Exception("No QoS 1 with that message id sent")
elif packet.fh.MessageType == MQTTV3.PUBREC:
if packet.messageIdentifier in self.outMsgs.keys():
self.outMsgs[packet.messageIdentifier].pubrec_received == True
self.pubrel.messageIdentifier = packet.messageIdentifier
logging.debug("out: %s", str(self.pubrel))
self.socket.send(self.pubrel.pack())
else:
raise Exception("PUBREC received for unknown msg id "+ \
str(packet.messageIdentifier))
elif packet.fh.MessageType == MQTTV3.PUBREL:
"release QOS 2 publication to client, & send PUBCOMP"
msgid = packet.messageIdentifier
if packet.messageIdentifier not in self.inMsgs.keys():
pass # what should we do here?
else:
pub = self.inMsgs[packet.messageIdentifier]
if callback == None or \
callback.publishArrived(pub.topicName, pub.data, 2,
pub.fh.RETAIN, pub.messageIdentifier):
del self.inMsgs[packet.messageIdentifier]
self.pubcomp.messageIdentifier = packet.messageIdentifier
logging.debug("out: %s", str(self.pubcomp))
self.socket.send(self.pubcomp.pack())
if callback == None:
return (pub.topicName, pub.data, 2, pub.fh.RETAIN,
pub.messageIdentifier)
elif packet.fh.MessageType == MQTTV3.PUBCOMP:
"finished with this message id"
if packet.messageIdentifier in self.outMsgs.keys():
del self.outMsgs[packet.messageIdentifier]
if hasattr(callback, "published"):
callback.published(packet.messageIdentifier)
else:
raise Exception("PUBCOMP received for unknown msg id "+ \
str(packet.messageIdentifier))
elif packet.fh.MessageType == MQTTV3.PUBLISH:
if self.paused:
return
if packet.fh.QoS == 0:
if callback == None:
return (packet.topicName, packet.data, 0, packet.fh.RETAIN,
packet.messageIdentifier)
else:
callback.publishArrived(packet.topicName, packet.data, 0,
packet.fh.RETAIN,
packet.messageIdentifier)
elif packet.fh.QoS == 1:
if callback == None:
return (packet.topicName, packet.data, 1, packet.fh.RETAIN,
packet.messageIdentifier)
else:
if callback.publishArrived(packet.topicName, packet.data,
1, packet.fh.RETAIN,
packet.messageIdentifier):
self.puback.messageIdentifier = packet.messageIdentifier
logging.debug("out: %s", str(self.puback))
self.socket.send(self.puback.pack())
elif packet.fh.QoS == 2:
self.inMsgs[packet.messageIdentifier] = packet
self.pubrec.messageIdentifier = packet.messageIdentifier
logging.debug("out: %s", str(self.pubrec))
self.socket.send(self.pubrec.pack())
else:
raise Exception("Unexpected packet" + str(packet))
def handle(self):
if not hasattr(self, "ids"):
self.ids = {}
if not hasattr(self, "versions"):
self.versions = {}
inbuf = True
i = o = e = None
try:
clients = self.request
brokers = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
brokers.connect((brokerhost, brokerport))
while inbuf is not None:
(i, o, e) = select.select([clients, brokers], [], [])
for s in i:
if s == clients:
inbuf = MQTTV3.getPacket(clients) # get one packet
if inbuf is None:
break
try:
packet = MQTTV3.unpackPacket(inbuf)
if packet.fh.MessageType == MQTTV3.PUBLISH and \
packet.topicName == "MQTTSAS topic" and \
packet.data == b"TERMINATE":
print("Terminating client", self.ids[id(clients)])
brokers.close()
clients.close()
break
else:
if packet.fh.MessageType == MQTTV3.CONNECT:
self.ids[id(clients)] = packet.ClientIdentifier
self.versions[id(clients)] = 3
wx.CallAfter(myWindow.log, timestamp() , "C to S",
self.ids[id(clients)], repr(packet))
except:
traceback.print_exc()
# next line should not be needed once things work properly
print("C to S", timestamp(), repr(inbuf))
sys.exit()
#print "C to S", timestamp(), repr(inbuf)
brokers.sendall(inbuf) # pass it on
elif s == brokers:
inbuf = MQTTV3.getPacket(brokers) # get one packet
if inbuf is None:
break
try:
wx.CallAfter(myWindow.log, timestamp(), "S to C", self.ids[id(clients)],
repr(MQTTV3.unpackPacket(inbuf)))
except:
traceback.print_exc()
# next line should not be needed once things work properly
print("S to C", timestamp(), repr(inbuf))
sys.exit()
#print "S to C", timestamp(), repr(inbuf)
clients.sendall(inbuf)
wx.CallAfter(myWindow.status, timestamp()+" client "+self.ids[id(clients)]+\
" connection closing")
except:
print(repr((i, o, e)), repr(inbuf))
traceback.print_exc()
if self.ids.has_key(id(clients)):
del self.ids[id(clients)]
elif self.versions.has_key(id(clients)):
del self.versions[id(clients)]
