def build_publish_pkt(self, mid, topic, payload, qos, retain, dup):
"""Build PUBLISH packet."""
pkt = MqttPkt()
payloadlen = len(payload)
packetlen = 2 + len(topic) + payloadlen
if qos > 0:
packetlen += 2
pkt.mid = mid
pkt.command = NC.CMD_PUBLISH | ((dup & 0x1) << 3) | (qos << 1) | retain
pkt.remaining_length = packetlen
ret = pkt.alloc()
if ret != NC.ERR_SUCCESS:
return ret, None
#variable header : Topic String
pkt.write_string(topic)
if qos > 0:
pkt.write_uint16(mid)
#payloadlen
if payloadlen > 0:
pkt.write_bytes(payload, payloadlen)
return NC.ERR_SUCCESS, pkt
def send_simple_command(self, cmd):
"""Send simple mqtt commands."""
pkt = MqttPkt()
pkt.command = cmd
pkt.remaining_length = 0
ret = pkt.alloc()
if ret != NC.ERR_SUCCESS:
return ret
return self.packet_queue(pkt)
def __init__(self, client_id, username, password, server, port, keepalive,
ssl, ssl_opts):
''' Constructor '''
self.client_id = client_id
self.username = username
self.password = password
self.server = server
self.port = port
self.ssl = ssl
self.ssl_opts = ssl_opts
self.address = ""
self.keep_alive = keepalive
self.clean_session = 1
self.state = NC.CS_NEW
self.last_msg_in = time.time()
self.last_msg_out = time.time()
self.last_mid = 0
#output packet queue
self.out_packet = []
#input packet queue
self.in_packet = MqttPkt()
self.in_packet.packet_cleanup()
#networking
self.sock = NC.INVALID_SOCKET
self.will = None
self.message_retry = NC.MESSAGE_RETRY
self.last_retry_check = 0
self.messages = None
self.bridge = None
#LOGGING Option:TODO
self.log_priorities = -1
self.log_destinations = -1
self.host = None
#hack var
self.as_broker = False
#event list
self.event_list = []
def pubcomp(self, mid):
"""Send PUBCOMP response to server."""
if self.sock == NC.INVALID_SOCKET:
return NC.ERR_NO_CONN
self.logger.info("Send PUBCOMP (msgid=%s)", mid)
pkt = MqttPkt()
pkt.command = NC.CMD_PUBCOMP
pkt.remaining_length = 2
ret = pkt.alloc()
if ret != NC.ERR_SUCCESS:
return ret
#variable header: acknowledged message id
pkt.write_uint16(mid)
return self.packet_queue(pkt)
def send_unsubscribe(self, dup, topic):
"""Send unsubscribe COMMAND to server."""
pkt = MqttPkt()
pktlen = 2 + 2 + len(topic)
pkt.command = NC.CMD_UNSUBSCRIBE | (dup << 3) | (1 << 1)
pkt.remaining_length = pktlen
ret = pkt.alloc()
if ret != NC.ERR_SUCCESS:
return ret
#variable header
mid = self.mid_generate()
pkt.write_uint16(mid)
#payload
pkt.write_string(topic)
return self.packet_queue(pkt)
def connect(self, clean_session=1):
"""Connect to server."""
self.clean_session = clean_session
#CONNECT packet
pkt = MqttPkt()
pkt.connect_build(self, self.keep_alive, clean_session)
#create socket
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
nyamuk_net.setkeepalives(self.sock)
self.logger.info("Connecting to server ....%s", self.server)
err = nyamuk_net.connect(self.sock, (self.server, self.port))
if err != None:
self.logger.error(err[1])
return NC.ERR_UNKNOWN
#set to nonblock
self.sock.setblocking(0)
return self.packet_queue(pkt)
def connect(self, version=3, clean_session=1, will=None):
"""Connect to server."""
self.clean_session = clean_session
self.will = None
if will is not None:
self.will = NyamukMsg(
topic=will['topic'],
# unicode text needs to be utf8 encoded to be sent on the wire
# str or bytearray are kept as it is
payload=utf8encode(will.get('message', '')),
qos=will.get('qos', 0),
retain=will.get('retain', False))
#CONNECT packet
pkt = MqttPkt()
pkt.connect_build(self,
self.keep_alive,
clean_session,
version=version)
#create socket
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if self.ssl:
opts = {
'do_handshake_on_connect': True,
'ssl_version': ssl.PROTOCOL_TLSv1
}
opts.update(self.ssl_opts)
#print opts, self.port
try:
self.sock = ssl.wrap_socket(self.sock, **opts)
except Exception, e:
self.logger.error(
"failed to initiate SSL connection: {0}".format(e))
return NC.ERR_UNKNOWN
def connect(self, clean_session=1):
"""Connect to server."""
self.clean_session = clean_session
#CONNECT packet
pkt = MqttPkt()
pkt.connect_build(self, self.keep_alive, clean_session)
#create socket
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if self.ssl:
opts = {
'do_handshake_on_connect': True,
'ssl_version': ssl.PROTOCOL_TLSv1
}
opts.update(self.ssl_opts)
#print opts, self.port
try:
self.sock = ssl.wrap_socket(self.sock, **opts)
except Exception, e:
self.logger.error(
"failed to initiate SSL connection: {0}".format(e))
return NC.ERR_UNKNOWN
