def update_command(self, command, device_id = None, device_key = None):
if not ICommand.implementedBy(command.__class__) :
raise DhError('{0}.update_command expects ICommand'.format(self.__class__.__name__))
request = {'action': 'command/update', 'commandId': command.id, 'command': command.to_dict()}
if device_id is not None :
request['deviceId'] = device_id
if device_key is not None :
request['deviceKey'] = device_key
return self.send_message(request)
def subscribe(self, device_id = None, device_key = None):
if device_id in self.devices :
defer = Deferred()
factory = DevicePollFactory(self, self.devices[device_id], defer)
self.factories[device_id] = factory
LOG_MSG('Connecting command poll factory to {0}:{1}.'.format(self.host, self.port))
reactor.connectDeviceHive(self.url, factory)
return defer
else :
return fail(DhError('Failed to subscribe device "{0}".'.format(device_id)))
def on_command_insert(self, cmd, info):
"""
@type cmd: C{object}
@param cmd: object which implements C{ICommand}
@type info: C{object}
@param info: C{IDeviceInfo} object which is receiving the command
"""
LOG_MSG('Command {0} has been received for device {1}.'.format(
cmd, info))
def on_ok(result):
LOG_MSG('The command "{0}" successfully processed. Result: {1}.'.
format(cmd, result))
if isinstance(result, CommandResult):
cmd.status = result.status
cmd.result = result.result
else:
cmd.status = 'Success'
cmd.result = result
self.update_command(cmd, device_id=info.id, device_key=info.key)
#
def on_err(reason):
LOG_ERR('Failed to process command "{0}". Reason: {1}.'.format(
cmd, reason))
if isinstance(reason, Exception):
cmd.status = 'Failed'
cmd.result = reason.message
elif hasattr(reason, 'value'):
if isinstance(reason.value, CommandResult):
cmd.status = reason.value.status
cmd.result = reason.value.result
elif isinstance(reason.value, Exception):
cmd.status = 'Failed'
cmd.result = reason.value.message
else:
cmd.status = 'Failed'
cmd.result = reason.value
else:
cmd.status = 'Failed'
cmd.result = 'Unhandled Exception'
self.update_command(cmd, device_id=info.id, device_key=info.key)
#
finished = Deferred()
finished.addCallbacks(on_ok, on_err)
try:
self.handler.on_command(info.id, cmd, finished)
except Exception as ex:
err = DhError('Failed to invoke command {0}. Reason: {1}.'.format(
cmd, ex.message))
LOG_ERR(err.message)
on_err(err)
def notify(self, notification, params, device_id = None, device_key = None):
if (device_id is not None) and (device_id in self.devices) :
defer = Deferred()
def ok(res):
LOG_MSG('Notification has been successfully sent.')
defer.callback(res)
def err(reason):
LOG_ERR('Failed to send notification.')
defer.errback(reason)
self.execute_request(NotifyRequest(self.devices[device_id], self.url, self.host, notification, params), ok, err)
return defer
else :
return fail(DhError('device_id parameter expected'))
def subscribe(self, device_id=None, device_key=None):
"""
Subscribes a device to commands.
@type device_id: C{str}
@param device_id: device identifier (GUID)
@type device_key: C{str}
@param device_key: A device key. Optional parameter.
@return deferred
"""
if device_id in self.devices:
defer = Deferred()
return defer
else:
return fail(
DhError('Failed to subscribe device "{0}".'.format(device_id)))
def notify(self, notification, params, device_id=None, device_key=None):
"""
Sends notification message to devicehive server.
@param notification - notification identifier
@param param - dictionary of notification parameters
@return deferred
"""
if (device_id is not None) and (device_id in self.devices):
defer = Deferred()
def ok(res):
LOG_MSG('Test notification has been successfully sent.')
defer.callback(res)
def err(reason):
LOG_ERR('Failed to send notification.')
defer.errback(reason)
ok("OK")
self.notifications.append(notification)
return defer
else:
return fail(DhError('device_id parameter expected'))
def unsubscribe(self, device_id=None, device_key=None):
if (device_id in self.devices) and (device_id in self.factories):
factory = self.factories.pop(device_id)
return factory.stop()
else:
return fail(DhError('device_id parameter expected'))
def txterrf(errtxt):
LOG_ERR(
'Invalid response has been received during command polling. Reason: {0}.'
.format(errtxt))
self.failure(DhError(errtxt))
def on_get_response_text(error_text):
LOG_ERR(
'Invalid response has been received during command Testing. Reason: {0}.'
.format(error_text))
self.failure(DhError(error_text))
