def _connect(self):
try:
if not self._connected:
if not self._attempts < self.kMaxAttempts:
if not self._resetTimer.isActive():
Log.progress(Settings.getMeta("name") + ": Max connection attempts reached - waiting " + str(self.kResetTimer) + " seconds before retrying" )
self._resetTimer.start(self.kResetTimer*1000) # 1 minute parameterise
return
if self._attempts > 0 and (time.time() - pow(2,self._attempts +1)) < self._attemped:
return
Log.debug("Trying to connect")
self._attemped = time.time()
result = self.mqttc.connect(str(self._host), int(self._port),int( self._keepAlive), 1)
self._connected = result == mqtt.MQTT_ERR_SUCCESS # paho
# self._connected = result == mqtt.MOSQ_ERR_SUCCESS # mosquitto
if not self._connected:
self._attempts += 1
Log.progress(mqtt.connack_string(connResult))
self.mqttConnectionError.emit(self, mqtt.connack_string(connResult))
except Exception as e:
msg = 'MQTT: ' + str(e)
self.mqttConnectionError.emit(self, msg)
#Log.progress(msg)
Log.debug(msg)
#exc_type, exc_value, exc_traceback = sys.exc_info()
#Log.debug(repr(traceback.format_exception(exc_type, exc_value,
# exc_traceback)))
self._attempts += 1
self._connected = False
def tearDown(self):
Log.debug("Tear down TLayer")
self._dirty = False # Don't commit any changes if we are being torn down
if self.isRunning():
self.stop()
self.commitChanges.disconnect(self._commitChanges)
self.layer().attributeValueChanged.disconnect(self.attributeValueChanged)
def loop(self, timeout=0.1):
if not self.isConnected():
if not self._killing:
self._connect()
return
try:
connResult = self.mqttc.loop(timeout)
if connResult == mqtt.MQTT_ERR_SUCCESS: # paho
# if connResult == mqtt.MOSQ_ERR_SUCCESS: # mosquitto
return
self._connected = False
self._attempts += 1
Log.warn("MQTT: An error occurred while looping")
QObject.emit(self, SIGNAL('mqttConnectionError'), self, mqtt.error_string(connResult))
except ValueError as e:
if e == 'Invalid timeout.':
QObject.emit(self, SIGNAL('mqttOnTimeout'), self, "Connection Timeout")
else:
Log.debug("Paho Client ValueError" + str(e))
except Exception as e:
QObject.emit(self, SIGNAL('mqttConnectionError'), self, str(e))
Log.debug("MQTT Connect: Unknown exception raised " + str(e))
def _showFeatureDialog(self, modelIdx):
item = self.tableFeatureList.item(modelIdx.row(), self.kDataCol)
layer = QgsMapLayerRegistry.instance().mapLayer(
item.data(self.kLayerId))
modifiers = QtGui.QApplication.keyboardModifiers()
try:
if layer.isEditable() or modifiers == QtCore.Qt.ControlModifier:
self._creator.showEditFeature(layer,
item.data(self.kFeatureId))
#self._iface.openFeatureForm(layer, feature, True,False)
else:
feature = next(
layer.getFeatures(
QgsFeatureRequest(item.data(self.kFeatureId))), None)
self._layerManager.showFeatureDock(layer, feature)
# self._fd = tlFeatureDialogWrapper(self._iface,
# self._layerManager.getTLayer(layer.id()),
# feature)
except Exception as e:
Log.debug(e)
exc_type, exc_value, exc_traceback = sys.exc_info()
print(
repr(
traceback.format_exception(exc_type, exc_value,
exc_traceback)))
pass
def _processQueue(self):
"""
Process incoming message queue
"""
if not self._canRun():
return
try:
while (not self.Q.empty()):
msg = self.Q.get()
if not self.topicManager().onMessage(self, msg):
continue
for feat in self._layer.getFeatures():
topic = str(feat.attribute("topic"))
key = msg.topic + ':' + str(feat.id())
with QMutexLocker(self._mutex):
if key in self._dict:
self.updateFeature(feat, msg.topic, msg.payload)
elif Mosquitto.topic_matches_sub(topic, msg.topic):
self._dict[key] = feat.id()
self.updateFeature(feat, msg.topic, msg.payload)
except Queue.Empty:
Log.debug("Empty Queue")
return
except Exception as e:
Log.critical("MQTT Client - Error updating features! " + str(e))
finally:
if self._dirty:
self.triggerRepaint()
def on_disconnect(self, client, obj, rc):
Log.debug("disconnecting rc: " + str(rc) + " " + str(self._connected))
if self._killing:
Log.debug("killing")
self._kill()
self.onDisConnect(client, obj, rc)
self._connected = False
def _commitChanges(self):
self._processQueue()
if not self._dirty or self._isEditing():
return
try:
fids = []
with QMutexLocker(self._mutex):
if len(self._values) == 0:
return
self._layer.startEditing()
for key, val in self._values.iteritems():
fid, fieldId = key
self._layer.changeAttributeValue(fid, fieldId, val)
if fid not in fids:
fids.append(fid)
self._layer.commitChanges()
self._values.clear()
self._dirty = False
for fid in fids:
request = QgsFeatureRequest(fid)
feat = next(self.layer().getFeatures(request), None)
if feat is not None:
self.featureUpdated.emit(self, feat)
except AttributeError:
pass
except Exception as e:
Log.debug("Error committing " + str(e))
def onConnect(self, mosq, obj, rc):
# Log.debug(self._layer.rendererV2().dump())
self._dict = {}
self.updateConnected(True)
for feat in self._layer.getFeatures():
if feat.id() < 0:
continue
try:
topic = str(feat.attribute("topic"))
qos = int(feat.attribute("qos"))
if not qos in range(3):
Log.warn("Topic QoS must be beween 0 and 2")
continue
if topic is not None:
self.subscribe(topic, qos)
else:
Log.critical("Invalid topic")
except TypeError:
Log.debug("Error adding features from layer")
pass
self.triggerRepaint()
def unload(self):
# Remove the plugin menu item and icon
if not self.installed:
return
try:
self.runTeardown()
self.iface.removePluginMenu(u"&Telemetry Layer", self.aboutA)
self.iface.removePluginMenu(u"&Telemetry Layer", self.configureA)
self.iface.removeToolBarIcon(self.aboutA)
self.iface.removeToolBarIcon(self.configureA)
self.iface.newLayerMenu().removeAction(
self.newLayerA) # API >= 1.9
self.iface.projectRead.disconnect(self.layerManager.rebuildLegend)
self.iface.newProjectCreated.disconnect(
self.layerManager.rebuildLegend)
#Brokers.instance().brokersLoaded.disconnect(self.layerManager.brokersLoaded)
except Exception as e:
Log.debug(e)
pass
finally:
if self.layerManager:
self.layerManager.deleteLater()
if self.telemetryLayer:
self.telemetryLayer.deleteLater()
if Brokers:
Brokers.instance().deleteLater()
TopicManagerFactory.tearDown()
gc.collect()
Log.debug("Plugin unloaded")
def _commitChanges(self):
self._processQueue()
if not self._dirty or self._isEditing():
return
try:
fids = []
with QMutexLocker(self._mutex):
if len(self._values) == 0:
return
self._layer.startEditing()
for key, val in self._values.iteritems():
fid, fieldId = key
self._layer.changeAttributeValue(fid, fieldId, val)
if fid not in fids:
fids.append(fid)
self._layer.commitChanges()
self._values.clear()
self._dirty = False
for fid in fids:
request = QgsFeatureRequest(fid)
feat = next(self.layer().getFeatures(request), None)
if feat is not None:
self.featureUpdated.emit(self, feat)
except AttributeError:
pass
except Exception as e:
Log.debug("Error committing " + str(e))
def _kill(self):
self._loopTimer.stop() # Stopped in self.stop but lets preempt this to avoid self.loop being called by running thread
self._killTimer.stop()
self._killing = False
self._reset() # reset timer
self.stop()
Log.debug("killed")
def on_disconnect(self, client, obj, rc):
Log.debug("disconnecting rc: " + str(rc) + " " + str(self._connected))
if self._killing:
Log.debug("killing")
self._kill()
self.onDisConnect(client, obj, rc)
self._connected = False
def _processQueue(self):
"""
Process incoming message queue
"""
if not self._canRun():
return
try:
while(not self.Q.empty()):
msg =self.Q.get()
if not self.topicManager().onMessage(self,msg):
continue
for feat in self._layer.getFeatures():
topic = str(feat.attribute("topic"))
key = msg.topic + ':' + str(feat.id())
with QMutexLocker(self._mutex):
if key in self._dict:
self.updateFeature(feat, msg.topic, msg.payload)
elif Mosquitto.topic_matches_sub(topic, msg.topic):
self._dict[key] = feat.id()
self.updateFeature(feat, msg.topic, msg.payload)
except Queue.Empty:
Log.debug("Empty Queue")
return
except Exception as e:
Log.critical("MQTT Client - Error updating features! " + str(e))
finally:
if self._dirty:
self.triggerRepaint()
def _showFeatureDialog(self, modelIdx):
item = self.tableFeatureList.item(modelIdx.row(), self.kDataCol)
layer = QgsMapLayerRegistry.instance().mapLayer(item.data(self.kLayerId))
modifiers = QtGui.QApplication.keyboardModifiers()
try:
if layer.isEditable() or modifiers == QtCore.Qt.ControlModifier:
self._creator.showEditFeature(layer,item.data(self.kFeatureId))
#self._iface.openFeatureForm(layer, feature, True,False)
else:
feature = next(layer.getFeatures(QgsFeatureRequest(item.data(self.kFeatureId))), None)
self._layerManager.showFeatureDock(layer,
feature)
# self._fd = tlFeatureDialogWrapper(self._iface,
# self._layerManager.getTLayer(layer.id()),
# feature)
except Exception as e:
Log.debug(e)
exc_type, exc_value, exc_traceback = sys.exc_info()
print(repr(traceback.format_exception(exc_type, exc_value,
exc_traceback)))
pass
def onConnect(self, mosq, obj, rc):
# Log.debug(self._layer.rendererV2().dump())
self._dict = {}
self.updateConnected(True)
for feat in self._layer.getFeatures():
if feat.id() < 0:
continue
try:
topic = str(feat.attribute("topic"))
qos = int(feat.attribute("qos"))
if not qos in range(3):
Log.warn("Topic QoS must be beween 0 and 2")
continue
if topic is not None:
self.subscribe(topic, qos)
else:
Log.critical("Invalid topic")
except TypeError:
Log.debug("Error adding features from layer")
pass
self.triggerRepaint()
def applyFeature(self,feature):
found = False
if feature.id() > 0 and not feature.id() in self.establishedFeatures:
# Log.debug("No feature to Apply") # must be an Add
self._lastFid = feature.id()
if self._deferredEdit:
self._deferredEdit = False
self._deferredTimer = QTimer()
self._deferredTimer.setSingleShot(True)
self._deferredTimer.timeout.connect(lambda:telemetryLayer.instance().showEditFeature(self.layer(),feature.id()))
self._deferredTimer.start(100)
return
fid = next(iter(self.layer().selectedFeaturesIds()),None)
if not fid:
return
feat = next(self.layer().getFeatures(QgsFeatureRequest(fid)), None)
try:
fmap = self._layer.dataProvider().fieldNameMap()
fmax = self._layer.dataProvider().fieldNameIndex("context")
for key,fieldId in fmap.iteritems():
if key in ['qos','visible'] or fieldId > fmax:
# Log.debug("changing value " + key + " " + str(feat[key]) + " to " + str(feature[key]))
self._layer.changeAttributeValue(feat.id(), fieldId, feature[key])
self._layer.deleteFeature(feature.id())
self._layer.commitChanges()
self._layer.deselect(self.layer().selectedFeaturesIds())
except Exception as e:
Log.debug("Error applying feature " + str(e))
def unload(self):
# Remove the plugin menu item and icon
if not self.installed:
return
try:
self.runTeardown()
self.iface.removePluginMenu(u"&Telemetry Layer", self.aboutA)
self.iface.removePluginMenu(u"&Telemetry Layer", self.configureA)
self.iface.removeToolBarIcon(self.aboutA)
self.iface.removeToolBarIcon(self.configureA)
self.iface.newLayerMenu().removeAction(self.newLayerA) # API >= 1.9
self.iface.projectRead.disconnect(self.layerManager.rebuildLegend)
self.iface.newProjectCreated.disconnect(self.layerManager.rebuildLegend)
TopicManagerFactory.unregisterAll()
#Brokers.instance().brokersLoaded.disconnect(self.layerManager.brokersLoaded)
except Exception as e:
Log.debug(e)
TopicManagerFactory.unregisterAll()
pass
finally:
if self.layerManager:
self.layerManager.deleteLater()
if self.telemetryLayer:
self.telemetryLayer.deleteLater()
if Brokers:
Brokers.instance().deleteLater()
gc.collect()
Log.debug("Plugin unloaded")
def createEmptyLayer(self):
try:
telemetryLayer.instance().checkBrokerConfig()
except BrokerNotSynced:
Log.progress("Please save any broker configurations first")
except BrokersNotDefined:
Log.progress("Please configure your MQTT Brokers first - see Plugin -> Telemetry Layer -> Configure")
return
dlg = layerConfig(self)
result = dlg.exec_()
if result == 0: # object will be garbage collected
return False
geomType = 'Point' + '?crs=proj4:' + QgsProject.instance().readEntry("SpatialRefSys", "/ProjectCRSProj4String")[
0] # dodana linia - from Menory Layer Module
broker = dlg.getBroker()
topicType = dlg.getTopicType()
layer = QgsVectorLayer(geomType, topicType, 'memory') # zmieniona linia
tLayer = self.initLayer(layer, broker, topicType)
# self._iface.legendInterface().setCurrentLayer(layer)
Log.debug("telemetrylayermanager - set Current Layer")
self.rebuildLegend()
layer.triggerRepaint()
def registerAll():
Log.debug("Loading Topic Managers")
tlTopicManagerFactory.topicManagers = topicmanagers.register()
for _id in tlTopicManagerFactory.getTopicManagerIds():
tlTopicManagerFactory.registerTopicManager(_id)
def featureAdded(self, fid):
# Log.debug("feature Added" + str(fid))
request = QgsFeatureRequest(fid)
layer = self._iface.activeLayer()
feature = next(layer.getFeatures(request), None)
try:
featureExists = feature and feature['topic']
except IndexError:
featureExists = False
#if fid < 0 and "Feature Attributes" in QgsApplication.activeWindow().windowTitle():
# return
#if fid >0:
# return
layer = self._iface.activeLayer()
if layer is None:
return
tLayer = self.getTLayer(layer.id())
if featureExists:
tLayer.applyFeature(feature)
return
if tLayer is None:
Log.debug("Error Loading tLayer")
return
result = tLayer.addFeature(fid)
Log.debug("Adding Feature")
if result is not None:
tLayer.restart()
def stop(self):
super(tLayer, self).stop()
try:
iter = self._layer.getFeatures()
if iter.next():
self.triggerRepaint()
except Exception as e: #if the broker is deleted, the layer has been removed - don't repaint
Log.debug(e)
def loadStyle(self, layer, filename):
qfile = QFile(filename)
if not qfile.open(QIODevice.ReadOnly):
Log.debug("Unable to open file " + filename)
return
rules = qfile.readData(qfile.size())
qfile.close()
layer.loadNamedStyle(filename)
def tearDown():
try:
print "topicmanagerfactory tearDown"
for item in _tMF.list():
_tMF.unregister(item.id)
_tMF.unregisterFuncs()
except Exceptions as e:
Log.debug("Error tearing down Topic Managers: " + str(e))
def onConnect(self, mqtt, obj, rc):
Log.debug("Connect rc = " + str(rc))
if len(self._subTopics) == 0:
self._connectError(False, "No Subcription Topic defined")
for topic in self._subTopics:
self.subscribe(str(topic), self._qos)
if self._pubTopic is not None:
self.publish(str(self._pubTopic), str(self._pubData), self._qos)
def stop(self):
super(tLayer, self).stop()
try:
iter = self._layer.getFeatures()
if iter.next():
self.triggerRepaint()
except Exception as e: #if the broker is deleted, the layer has been removed - don't repaint
Log.debug(e)
def tearDown(self):
Log.debug("Tear down TLayer")
self._dirty = False # Don't commit any changes if we are being torn down
if self.isRunning():
self.stop()
self.commitChanges.disconnect(self._commitChanges)
self.layer().attributeValueChanged.disconnect(
self.attributeValueChanged)
def runTeardown(self):
try:
self.layerManager.tearDown()
self.telemetryLayer.tearDown()
except Exception as e:
Log.debug(e)
pass
def runTeardown(self):
try:
self.layerManager.tearDown()
self.telemetryLayer.tearDown()
except Exception as e:
Log.debug(e)
pass
def loadStyle(self, layer, filename):
qfile = QFile(filename)
if not qfile.open(QIODevice.ReadOnly):
Log.debug("Unable to open file " + filename)
return
rules = qfile.readData(qfile.size())
qfile.close()
layer.loadNamedStyle(filename)
def readProject(self):
return
for lid, tLayer in self.getTLayers().iteritems():
Log.debug("Adding V2 Format data to loaded layers")
# Change this to add in only the path details!
tLayer._setFormatters(True) # Memory Layer Saver doesn't save some V2 format data
return
def _connectError(self,client, msg):
Log.debug(msg)
QObject.emit(self, SIGNAL('mqttOnCompletion'), self, False, msg)
if not self._callbackonerr is None:
self._callbackonerr(self,False,msg)
elif not self._callback is None:
self._callback(self,False,msg)
self.kill()
def _connectError(self, client, msg):
Log.debug(msg)
QObject.emit(self, SIGNAL('mqttOnCompletion'), self, False, msg)
if not self._callbackonerr is None:
self._callbackonerr(self, False, msg)
elif not self._callback is None:
self._callback(self, False, msg)
self.kill()
def on_connect(self, client, obj,flags, rc): # paho
# def on_connect(self, client, obj, rc): # mosquitto
Log.debug("Connected " + str(rc))
if rc != mqtt.MQTT_ERR_SUCCESS: # paho
# if rc != mqtt.MOSQ_ERR_SUCCESS: # mosquitto
return
self._connected = True
self._attempts = 0
self.onConnect(client, obj, rc)
def subscribe(self, topic, qos =0):
if self.isConnected() and not str(topic) in self._subscribed:
try:
self.mqttc.subscribe(str(topic), int(qos))
self._subscribed.append(str(topic))
Log.debug('Subscribed to ' + topic + " " + str(qos))
except Exception as e:
Log.debug("Error on subscribe " + str(e))
raise e
def onMessage(self, mq, obj, msg):
"""
onMessage handler for all incoming messages for this layer
"""
Log.debug('Got ' + msg.topic+" "+str(msg.qos)+" "+str(len(msg.payload)) + " bytes")
if not self.Q.full() and self._canRun():
self.Q.put(msg)
self.commitChanges.emit()
def subscribe(self, topic, qos=0):
if self.isConnected() and not str(topic) in self._subscribed:
try:
self.mqttc.subscribe(str(topic), int(qos))
self._subscribed.append(str(topic))
Log.debug('Subscribed to ' + topic + " " + str(qos))
except Exception as e:
Log.debug("Error on subscribe " + str(e))
raise e
def featureUpdated(self,tlayer,feat):
try:
# self.symbol.setPixmap(ActiveLayerSymbolPixmap(self._layer,feat))
self.dockWidget.setWindowTitle(feat['match'])
# feat['context'] = 'dock-content'
# self.name.setText(feat['name'])
except Exception as e:
Log.debug("SVGFeatureDock - featureUpdated: " + str(e))
pass
def readProject(self):
return
for lid, tLayer in self.getTLayers().iteritems():
Log.debug("Adding V2 Format data to loaded layers")
# Change this to add in only the path details!
tLayer._setFormatters(
True) # Memory Layer Saver doesn't save some V2 format data
return
def onMessage(self, mq, obj, msg):
"""
onMessage handler for all incoming messages for this layer
"""
Log.debug('Got ' + msg.topic + " " + str(msg.qos) + " " +
str(len(msg.payload)) + " bytes")
if not self.Q.full() and self._canRun():
self.Q.put(msg)
self.commitChanges.emit()
def restart(self):
Log.debug("Restarting")
if self.isRunning():
self._restarting = True
self._thread.finished.connect(self.run)
if not self._killing:
self.kill()
else:
self.run()
def featureDeleted(self, fid):
if fid < 0:
return
Log.debug(str(fid) + " Deleted")
layer = self._iface.activeLayer()
if layer is None:
return
tLayer = self.getTLayer(layer.id())
Log.debug("Feature Deleted " + str(fid))
tLayer.restart()
def restart(self):
Log.debug("Restarting")
if self.isRunning():
self._restarting = True
self._thread.finished.connect(self.run)
if not self._killing:
self.kill()
else:
self.run()
def featureDeleted(self, fid):
if fid < 0:
return
Log.debug(str(fid) + " Deleted")
layer = self._iface.activeLayer()
if layer is None:
return
tLayer = self.getTLayer(layer.id())
Log.debug("Feature Deleted " + str(fid))
tLayer.restart()
def getTopicManagerById(_id):
_obj = None
for topicManager in tlTopicManagerFactory.getTopicManagers():
if topicManager['id'] == _id:
try:
_obj = topicManager['class']
except Exception as e:
Log.debug(str(e))
break
return _obj
def __init__(self,
creator,
clientId,
broker,
cleanSession=True):
super(MQTTClient, self).__init__()
# Load settings
self._creator = creator
# create client id
self._cleanSession = cleanSession
self._resetTimer = QTimer()
self._resetTimer.setSingleShot(True)
self._resetTimer.timeout.connect(self._reset)
self._killTimer = QTimer()
self._killTimer.setSingleShot(True)
self._killTimer.timeout.connect(self._kill)
self._killing = False
self._loopTimer = QTimer()
self._loopTimer.setSingleShot(False)
self._loopTimer.timeout.connect(self._loop)
self._clientId = clientId
self._host = broker.host()
self._port = int(broker.port())
self._poll = int(broker.poll())
self.setKeepAlive(broker.keepAlive())
self._attempts = 0
self._attempted = 0
self._connected = False
self._thread = QThread(self)
self._thread.started.connect(lambda: self._loopTimer.start(self._poll))
self._thread.finished.connect(self._loopTimer.stop)
self._thread.started.connect(lambda:Log.debug("Thread started"))
self._thread.finished.connect(lambda:Log.debug("Thread stopped"))
self._thread.terminated.connect(lambda:Log.debug("Thread terminated"))
self._restarting = False
self._subscribed =[]
# self.mqttc = mqtt.Client(self._clientId, self._cleanSession)
self.mqttc = mqtt.Mosquitto(self._clientId, self._cleanSession)
if broker.username(): # Basic Auth!
self.mqttc.username_pw_set(broker.username(), broker.password())
self.mqttc.on_connect = self.on_connect
self.mqttc.on_disconnect = self.on_disconnect
self.mqttc.on_message = self.onMessage
self.mqttc.on_publish = self.onPublish
self.mqttc.on_subscribe = self.onSubscribe
# self.mqttc.on_unsubscribe = self.onSubscribe - not implemented - remove element from self._subscribed
self.mqttc.on_log = self.onLog
def on_connect(self, client, obj, flags, rc): # paho
# def on_connect(self, client, obj, rc): # mosquitto
Log.debug("Connected " + str(rc))
if rc != mqtt.MQTT_ERR_SUCCESS: # paho
# if rc != mqtt.MOSQ_ERR_SUCCESS: # mosquitto
return
self._connected = True
self._attempts = 0
self._subscribed = []
self.onConnect(client, obj, rc)
def onConnect(self, mqtt, obj, rc):
Log.debug("Connect rc = " + str(rc))
self.mqttOnConnect.emit(self, obj, rc)
# QObject.emit(self, SIGNAL('mqttOnConnect'), self, obj, rc)
if len(self._subTopics) == 0:
# self._connectError(False, "No Subcription Topic defined")
return
for topic in self._subTopics:
self.subscribe(str(topic), self._qos)
if self._pubTopic is not None:
self.publish(str(self._pubTopic), str(self._pubData), self._qos)
def featureUpdated(self,tlayer,feat):
try:
self.symbol.setPixmap(ActiveLayerSymbolPixmap(self._layer,feat))
self.dockWidget.setWindowTitle(feat['match'])
feat['context'] = 'dock-content'
payload = self._palyr.getLabelExpression().evaluate(feat)
self.payload.setText(payload)
self.name.setText(feat['name'])
except Exception as e:
Log.debug("TextFeatureDock - featureUpdated: " + str(e))
pass
def run(self):
Log.debug("MQTT client run")
if self.isRunning() or self._killing:
self.restart()
return
if self._restarting:
self._thread.finished.disconnect(self.run)
self._restarting = False
self._thread.start(QThread.LowestPriority)
def _addBrokerApply(self):
if not self._brokerDlg.validate():
self._brokers.load()
return
self._brokerDlg.dockWidget.setVisible(False)
self.dockWidget.setFixedHeight(self.height()) # paramterise
broker = self._brokerDlg.getBroker()
self._brokers.update(broker)
self._brokers.sync(True)
self._buildBrokerTable()
Log.debug("Brokers reloaded")
self._brokerDlg.connectApply.setEnabled(False)
self.brokerManagerWidget.setCurrentIndex(self.kBrokerListTabId)
def __init__(self, creator, clientId, broker, cleanSession=True):
super(MQTTClient, self).__init__()
# Load settings
self._creator = creator
# create client id
self._cleanSession = cleanSession
self._resetTimer = QTimer()
self._resetTimer.setSingleShot(True)
self._resetTimer.timeout.connect(self._reset)
self._killTimer = QTimer()
self._killTimer.setSingleShot(True)
self._killTimer.timeout.connect(self._kill)
self._killing = False
self._loopTimer = QTimer()
self._loopTimer.setSingleShot(False)
self._loopTimer.timeout.connect(self._loop)
self._clientId = clientId
self._host = broker.host()
self._port = int(broker.port())
self._poll = int(broker.poll())
self.setKeepAlive(broker.keepAlive())
self._attempts = 0
self._attempted = 0
self._connected = False
self._thread = QThread(self)
self._thread.started.connect(lambda: self._loopTimer.start(self._poll))
self._thread.finished.connect(self._loopTimer.stop)
self._thread.started.connect(lambda: Log.debug("Thread started"))
self._thread.finished.connect(lambda: Log.debug("Thread stopped"))
self._thread.terminated.connect(lambda: Log.debug("Thread terminated"))
self._restarting = False
self._subscribed = []
# self.mqttc = mqtt.Client(self._clientId, self._cleanSession)
self.mqttc = mqtt.Mosquitto(self._clientId, self._cleanSession)
if broker.username(): # Basic Auth!
self.mqttc.username_pw_set(broker.username(), broker.password())
self.mqttc.on_connect = self.on_connect
self.mqttc.on_disconnect = self.on_disconnect
self.mqttc.on_message = self.onMessage
self.mqttc.on_publish = self.onPublish
self.mqttc.on_subscribe = self.onSubscribe
# self.mqttc.on_unsubscribe = self.onSubscribe - not implemented - remove element from self._subscribed
self.mqttc.on_log = self.onLog
def showFeatureDock(self, layer, feature):
try:
key = (layer.id(), feature.id())
if key in self._featureDocks:
dock = self._featureDocks[key]
if dock is not None:
if dock.isVisible():
return
else:
Log.debug(str(dock) + ' show')
dock.show()
return
tlayer = self.getTLayer(layer.id(), False)
try:
self._featureDocks[key] = tlayer.topicManager().getFeatureDock(
self._iface, tlayer, feature)
except AttributeError:
Log.warn("Unable to load feature dock")
exc_type, exc_value, exc_traceback = sys.exc_info()
Log.debug(
repr(
traceback.format_exception(exc_type, exc_value,
exc_traceback)))
except Exception as e:
Log.debug('showFeatureDock: ' + str(e))
exc_type, exc_value, exc_traceback = sys.exc_info()
Log.debug(
repr(
traceback.format_exception(exc_type, exc_value,
exc_traceback)))
def importFile(self, filename=None):
try:
if not filename:
filename = self._jsonfile
if os.path.exists(filename):
return json.loads(open(filename).read())
else:
# no file available
Log.debug("Broker file " + filename + " not found!")
except Exception as e:
Log.critical(e)
self._dirty = False
return ""
pass
def _updateBrokerApply(self):
if not self._brokerDlg.validate():
return
Log.debug("_updateBrokerApply")
broker = self._brokerDlg.getBroker()
#for key, val in broker.properties().iteritems():
# Log.debug(key + " " + str(val))
self._brokers.update(broker)
self._brokers.sync(True)
broker.setDirty(False)
self._brokerDlg.connectApply.setEnabled(False)
Log.progress("Broker updated")
for tLayer in self._layerManager.getTLayers().itervalues():
if tLayer.isRunning():
tLayer.restart();
def _updateBroker(self, broker, groupClicked=False):
if self._brokerDlg is not None:
self._brokerDlg.dockWidget.setVisible(False)
self._brokerDlg = None
Log.debug("Update broker")
self._brokerDlg = BrokerConfig(self, broker, False)
self._brokerDlg.connectApply.clicked.connect(self._updateBrokerApply)
self._brokerDlg.connectClose.clicked.connect(self._updateBrokerClose)
self.dockWidget.setFixedHeight(25) # paramterise
# self.dockWidget.setMaximumHeight(25) # paramterise
if groupClicked:
self._brokerDlg.Tabs.setCurrentIndex(self._brokerDlg.kFeatureListTabId) # kBrokerConfigTabId or kFeatureListTabId
self.dockWidget.repaint()
self.iface.addDockWidget(Qt.LeftDockWidgetArea, self._brokerDlg.dockWidget)
def saveDocks(self, layerId=None, close=False):
reopen = []
for (lid, fid) in self._featureDocks.keys():
if layerId is not None and lid != layerId:
continue
try:
dock = self._featureDocks[(lid, fid)]
if dock and dock.isVisible():
dock.saveGeometry()
reopen.append((lid, fid))
if close:
dock.close()
except Exception as e:
Log.debug(e)
Settings.setp('featureDocks', json.dumps(reopen))
def layerWillBeRemoved(self, layerId):
layer = QgsMapLayerRegistry.instance().mapLayer(layerId)
try:
self._iface.legendInterface().setLayerVisible(layer, False)
tLayer = self.getTLayer(layerId)
if tLayer is not None:
self.tearDownDocks(layerId)
tLayer.tearDown()
self.delTLayer(layerId)
self.rebuildLegend()
except Exception as e:
self.delTLayer(layerId)
Log.debug(e)
