def on_connect(self, client, userdata, flags, rc):
"""
This is called after the client has received a CONNACK message from the broker
in response to calling connect().
Parameters
----------
client : ?
userdata : ?
flags : ?
rc : {0,1,2,3,4,5}
An integer giving the return code:
0: Success
1: Refused - unacceptable protocol version
2: Refused - identifier rejected
3: Refused - server unavailable
4: Refused - bad user name or password (MQTT v3.1 broker only)
5: Refused - not authorised (MQTT v3.1 broker only)
"""
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s" % (self.clientId))
# Restoring previous subscriptions
with self._subLock:
if len(self._subscriptions) > 0:
for subscription in self._subscriptions:
self.client.subscribe(subscription, qos=self._subscriptions[subscription])
self.logger.debug("Restored %s previous subscriptions" % len(self._subscriptions))
elif rc == 5:
self.logAndRaiseException(ConnectionException("Not authorized: (%s, %s, %s)" % (self.clientId, self.username, self.password)))
else:
self.logAndRaiseException(ConnectionException("Connection failed: RC= %s" % (rc)))
def on_connect(self, client, userdata, flags, rc):
'''
This is called after the client has received a CONNACK message from the broker in response to calling connect().
The parameter rc is an integer giving the return code:
0: Success
1: Refused - unacceptable protocol version
2: Refused - identifier rejected
3: Refused - server unavailable
4: Refused - bad user name or password
5: Refused - not authorised
'''
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s" % (self.clientId))
if self._options['org'] != "quickstart":
self.__subscribeToCommands()
elif rc == 5:
self.logAndRaiseException(
ConnectionException(
"Not authorized: s (%s, %s, %s)" %
(self.clientId, self.username, self.password)))
else:
self.logAndRaiseException(
ConnectionException("Connection failed: RC= %s" % (rc)))
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s, Port: %s" %
(self.clientId, self.port))
if self._options['org'] != "quickstart":
dm_response_topic = ManagedClient.DM_RESPONSE_TOPIC_TEMPLATE % (
self._gatewayType, self._gatewayId)
dm_observe_topic = ManagedClient.DM_OBSERVE_TOPIC_TEMPLATE % (
self._gatewayType, self._gatewayId)
(self.dmSubscriptionResult,
self.dmSubscriptionMid) = self.client.subscribe([
(dm_response_topic, 1), (dm_observe_topic, 1),
(self.COMMAND_TOPIC, 1)
])
if self.dmSubscriptionResult != paho.MQTT_ERR_SUCCESS:
self._logAndRaiseException(
ConnectionException(
"Unable to subscribe to device management topics"))
elif rc == 5:
self._logAndRaiseException(
ConnectionException(
"Not authorized: s (%s, %s, %s)" %
(self.clientId, self.username, self.password)))
else:
self._logAndRaiseException(
ConnectionException("Connection failed: RC= %s" % (rc)))
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s, Port: %s" %
(self.clientId, self.port))
if self._options['org'] != "quickstart":
self.client.subscribe([
(ManagedClient.DM_RESPONSE_TOPIC, 1),
(ManagedClient.DM_OBSERVE_TOPIC, 1),
(ManagedClient.DM_REBOOT_TOPIC, 1),
(ManagedClient.DM_FACTORY_REESET, 1),
(ManagedClient.DM_UPDATE_TOPIC, 1),
(ManagedClient.DM_FIRMWARE_UPDATE_TOPIC, 1),
(ManagedClient.DM_FIRMWARE_DOWNLOAD_TOPIC, 1),
(ManagedClient.DM_CANCEL_OBSERVE_TOPIC, 1),
(Client.COMMAND_TOPIC, 1),
(ManagedClient.DME_ACTION_TOPIC, 1)
])
elif rc == 5:
self.logAndRaiseException(
ConnectionException(
"Not authorized: s (%s, %s, %s)" %
(self.clientId, self.username, self.password)))
else:
self.logAndRaiseException(
ConnectionException("Connection failed: RC= %s" % (rc)))
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s" % self.clientId)
elif rc == 5:
self.logAndRaiseException(ConnectionException("Not authorized: (%s, %s, %s)" % (self.clientId, self.username, self.password)))
else:
self.logAndRaiseException(ConnectionException("Connection failed: RC= %s" % (rc)))
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s" % self.clientId)
if self._options['org'] != "quickstart":
self.client.subscribe( [(ManagedClient.DM_RESPONSE_TOPIC, 1), (ManagedClient.DM_OBSERVE_TOPIC, 1), (Client.COMMAND_TOPIC, 1)] )
elif rc == 5:
self.logAndRaiseException(ConnectionException("Not authorized: s (%s, %s, %s)" % (self.clientId, self.username, self.password)))
else:
self.logAndRaiseException(ConnectionException("Connection failed: RC= %s" % (rc)))
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s" % (self.clientId))
#if self._options['org'] != "quickstart":
#self.subscribeToGatewayCommands()
elif rc == 5:
self.logAndRaiseException(ConnectionException("Not authorized: s (%s, %s, %s)" % (self.clientId, self.username, self.password)))
else:
self.logAndRaiseException(ConnectionException("Connection failed: RC= %s" % (rc)))
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s, Port: %s" % (self.clientId,self.port))
if self._options['org'] != "quickstart":
dm_response_topic = ManagedGateway.DM_RESPONSE_TOPIC_TEMPLATE % (self._gatewayType,self._gatewayId)
dm_observe_topic = ManagedGateway.DM_OBSERVE_TOPIC_TEMPLATE % (self._gatewayType,self._gatewayId)
self.client.subscribe( [(dm_response_topic, 1), (dm_observe_topic, 1), (Client.COMMAND_TOPIC, 1)] )
elif rc == 5:
self.logAndRaiseException(ConnectionException("Not authorized: s (%s, %s, %s)" % (self.clientId, self.username, self.password)))
else:
self.logAndRaiseException(ConnectionException("Connection failed: RC= %s" % (rc)))
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s" % self.clientId)
# Restoring previous subscriptions
if len(self._subscriptions) > 0:
for subscription in self._subscriptions:
self.client.subscribe(subscription["topic"], qos=subscription["qos"])
self.logger.debug("Restored %s previous subscriptions" % len(self._subscriptions))
elif rc == 5:
self.logAndRaiseException(ConnectionException("Not authorized: (%s, %s, %s)" % (self.clientId, self.username, self.password)))
else:
self.logAndRaiseException(ConnectionException("Connection failed: RC= %s" % (rc)))
def publishEventOverHTTP(self, event, data):
self.logger.debug("Sending event %s with data %s" % (event, json.dumps(data)))
templateUrl = '%s://%s.%s/api/v0002/device/types/%s/devices/%s/events/%s'
# Extracting all the values needed for the ReST operation
# Checking each value for 'None' is not needed as the device itself would not have got created, if it had any 'None' values
orgid = self._options['org']
deviceType = self._options['type']
deviceId = self._options['id']
authMethod = self._options['auth-method']
authToken = self._options['auth-token']
credentials = (authMethod, authToken)
if orgid == 'quickstart':
protocol = 'http'
else:
protocol = 'https'
# String replacement from template to actual URL
intermediateUrl = templateUrl % (protocol, orgid, self._options['domain'], deviceType, deviceId, event)
try:
msgFormat = "json"
payload = self._messageEncoderModules[msgFormat].encode(data, datetime.now(pytz.timezone('UTC')))
response = requests.post(intermediateUrl, auth = credentials, data = payload, headers = {'content-type': 'application/json'})
except Exception as e:
self.logger.error("POST Failed")
self.logger.error(e)
raise ConnectionException("Server not found")
if response.status_code >= 300:
self.logger.warning(response.headers)
return response.status_code
def publishEventOverHTTP(self, event, data):
self.logger.debug("Sending event %s with data %s" % (event, json.dumps(data)))
templateUrl = '%s://%s.%s/api/v0002/device/types/%s/devices/%s/events/%s'
orgid = self._options['org']
deviceType = self._options['type']
deviceId = self._options['id']
authMethod = self._options['auth-method']
authToken = self._options['auth-token']
credentials = (authMethod, authToken)
if orgid == 'quickstart':
protocol = 'http'
else:
protocol = 'https'
intermediateUrl = templateUrl % (protocol, orgid, self._options['domain'], deviceType, deviceId, event)
try:
msgFormat = "json"
payload = self._messageEncoderModules[msgFormat].encode(data, datetime.now(pytz.timezone('UTC')))
response = requests.post(intermediateUrl, auth = credentials, data = payload, headers = {'content-type': 'application/json'})
except Exception as e:
self.logger.error("POST Failed")
self.logger.error(e)
raise ConnectionException("Server not found")
# print ("Response status = ", response.status_code, "\tResponse ", response.headers)
if response.status_code >= 300:
self.logger.warning(response.headers)
return response.status_code
def publishCommand(self, deviceType, deviceId, event, cmdData, cmdFormat="json"):
'''
This method is used by the application to publish device command over HTTP(s)
Parameters - deviceType, deviceId, event, cmdData and cmdFormat by default JSON
It throws a ConnectionException with the message "Server not found" if the
application is unable to reach the server, Otherwise it returns the
HTTP status code, (200 - 207 for success)
'''
self.logger.debug("Sending event %s with command format %s" % (event, json.dumps(cmdData)))
templateUrl = 'https://%s.messaging.%s/api/v0002/application/types/%s/devices/%s/commands/%s'
orgid = self._options['org']
if orgid == 'quickstart':
authKey = None
authToken = None
else:
authKey = self._options['auth-key']
authToken = self._options['auth-token']
credentials = (authKey, authToken)
#String replacement from template to actual URL
intermediateUrl = templateUrl % (orgid, self._options['domain'], deviceType, deviceId, event)
try:
self.logger.debug("Data Format = %s",(cmdFormat))
contentType = self.getContentType(cmdFormat)
self.logger.debug("contentType = %s",(contentType))
payload = self._messageEncoderModules[cmdFormat].encode(cmdData, datetime.now())
response = requests.post(intermediateUrl, auth = credentials, data = payload, headers = {'content-type': contentType})
except Exception as e:
self.logger.error("POST Failed")
self.logger.error(e)
raise ConnectionException("Server not found")
if response.status_code >= 300:
self.logger.warning(response.headers)
return response.status_code
def _onConnect(self, mqttc, userdata, flags, rc):
"""
This is called after the client has received a `CONNACK` message
from the broker in response to calling connect().
See [paho.mqtt.python#on_connect](https://github.com/eclipse/paho.mqtt.python#on_connect) for more information
# Parameters
mqttc (paho.mqtt.client.Client): The client instance for this callback
userdata: The private user data as set in `Client()` or `user_data_set()`
flags: response flags sent by the broker
rc (int): the connection result.
The value of `rc` indicates success or not
- `0` Success
- `1` Refused - incorrect protocol version
- `2` Refused - invalid client identifier
- `3` Refused - server unavailable
- `4` Refused - bad user name or password
- `5` Refused - not authorised
"""
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s" % (self.clientId))
# Restoring previous subscriptions
with self._subLock:
if len(self._subscriptions) > 0:
for subscription in self._subscriptions:
self.client.subscribe(
subscription,
qos=self._subscriptions[subscription])
self.logger.debug("Restored %s previous subscriptions" %
len(self._subscriptions))
elif rc == 5:
self._logAndRaiseException(
ConnectionException(
"Not authorized: (%s, %s, %s)" %
(self.clientId, self.username, self.password)))
else:
self._logAndRaiseException(
ConnectionException("Connection failed: RC= %s" % (rc)))
def publishEventOverHTTP(self, deviceType, deviceId, event, data):
self.logger.debug("Sending event %s with data %s" %
(event, json.dumps(data)))
# Kept this as a template
# orgUrl = 'http://quickstart.internetofthings.ibmcloud.com/api/v0002/application/types/arduino/devices/00aabbccde02/events/status'
templateUrl = '%s://%s.internetofthings.ibmcloud.com/api/v0002/application/types/%s/devices/%s/events/%s'
# Extracting all the values needed for the ReST operation
# Checking each value for 'None' is not needed as the application itself would not have got created, if it had any 'None' values
orgid = self._options['org']
authKey = self._options['auth-key']
authToken = self._options['auth-token']
credentials = (authKey, authToken)
if orgid == 'quickstart':
protocol = 'http'
else:
protocol = 'https'
# String replacement from template to actual URL
intermediateUrl = templateUrl % (protocol, orgid, deviceType, deviceId,
event)
try:
msgFormat = "json"
payload = self._messageEncoderModules[msgFormat].encode(
data, datetime.now())
response = requests.post(
intermediateUrl,
auth=credentials,
data=payload,
headers={'content-type': 'application/json'})
except Exception as e:
self.logger.error("POST Failed")
self.logger.error(e)
raise ConnectionException("Server not found")
# print ("Response status = ", response.status_code, "\tResponse ", response.headers)
if response.status_code >= 300:
self.logger.warning(response.headers)
return response.status_code
def publishEvent(self, event, data, dataFormat="json"):
"""
Publish an event over HTTP(s) as given supported format
Throws a ConnectionException with the message "Server not found" if the client is unable to reach the server
Otherwise it returns the HTTP status code, (200 - 207 for success)
"""
self.logger.debug("Sending event %s with data %s" %
(event, json.dumps(data)))
templateUrl = 'https://%s.messaging.%s/api/v0002/device/types/%s/devices/%s/events/%s'
orgid = self._options['org']
deviceType = self._options['type']
deviceId = self._options['id']
authMethod = "use-token-auth"
authToken = self._options['auth-token']
credentials = (authMethod, authToken)
if orgid == 'quickstart':
authMethod = None
authToken = None
intermediateUrl = templateUrl % (orgid, self._options['domain'],
deviceType, deviceId, event)
self.logger.debug("URL: %s", intermediateUrl)
try:
self.logger.debug("Data Format = %s", (dataFormat))
contentType = self.getContentType(dataFormat)
self.logger.debug("contentType = %s", (contentType))
payload = self._messageEncoderModules[dataFormat].encode(
data, datetime.now(pytz.timezone('UTC')))
self.logger.debug("payload = %s", (payload))
response = requests.post(intermediateUrl,
auth=credentials,
data=payload,
headers={'content-type': contentType})
except Exception as e:
self.logger.error("POST Failed")
self.logger.error(e)
raise ConnectionException("Server not found")
if response.status_code >= 300:
self.logger.warning(response.headers)
return response.status_code
def publishEvent(self, deviceType, deviceId, event, data):
'''
This method is used by the application to publish events over HTTP(s)
It accepts 4 parameters, deviceType, deviceId, event which denotes event type and data which is the message to be posted
It throws a ConnectionException with the message "Server not found" if the application is unable to reach the server
Otherwise it returns the HTTP status code, (200 - 207 for success)
'''
self.logger.debug("Sending event %s with data %s" %
(event, json.dumps(data)))
templateUrl = 'https://%s.messaging.%s/api/v0002/application/types/%s/devices/%s/events/%s'
orgid = self._options['org']
if orgid == 'quickstart':
authKey = None
authToken = None
else:
authKey = self._options['auth-key']
authToken = self._options['auth-token']
credentials = (authKey, authToken)
#String replacement from template to actual URL
intermediateUrl = templateUrl % (orgid, self._options['domain'],
deviceType, deviceId, event)
try:
msgFormat = "json"
payload = self._messageEncoderModules[msgFormat].encode(
data, datetime.now())
response = requests.post(
intermediateUrl,
auth=credentials,
data=payload,
headers={'content-type': 'application/json'})
except Exception as e:
self.logger.error("POST Failed")
self.logger.error(e)
raise ConnectionException("Server not found")
if response.status_code >= 300:
self.logger.warning(response.headers)
return response.status_code
def on_connect(self, client, userdata, flags, rc):
if rc == 0:
self.connectEvent.set()
self.logger.info("Connected successfully: %s" % (self.clientId))
# Restoring previous subscriptions
with self._subLock:
if len(self._subscriptions) > 0:
for subscription in self._subscriptions:
self.client.subscribe(
subscription,
qos=self._subscriptions[subscription])
self.logger.debug("Restored %s previous subscriptions" %
len(self._subscriptions))
elif rc == 1:
self._logAndRaiseException(
ConnectionException("Incorrect protocol version"))
elif rc == 2:
self._logAndRaiseException(
ConnectionException("Invalid client identifier"))
elif rc == 3:
self._logAndRaiseException(
ConnectionException("Server unavailable"))
elif rc == 4:
self._logAndRaiseException(
ConnectionException("Bad username or password: (%s, %s)" %
(self.username, self.password)))
elif rc == 5:
self._logAndRaiseException(
ConnectionException(
"Not authorized: s (%s, %s, %s)" %
(self.clientId, self.username, self.password)))
else:
self._logAndRaiseException(
ConnectionException("Unexpected connection failure: %s" %
(rc)))
