def put(self, host):
"""Method to handle gateway PUT requests
Args:
host (str): Gateway host address
"""
try:
gateway = yield Gateway.find(where=['host = ?', host], limit=1)
# Return a 404 if not found.
if gateway is None:
abort(404, message={'error': "Gateway {} doesn't exist".format(host)})
kwargs = {}
for a,v in self.args.items():
if v is not None and v != getattr(gateway, a):
kwargs[a] = v
setattr(gateway, a, v)
(valid, message) = yield gateway.valid()
if not valid:
abort(400, message=message)
# Update the gateway and server with the new attributes
if kwargs:
gateway.update(**kwargs)
self.server.lora.updateGateway(host, gateway)
returnValue(({}, 200))
except TimeoutError:
log.error("REST API timeout retrieving gateway {host}",
host=host)
def test_addGateway(self):
""" Test addGateway method"""
address = '192.168.1.199'
expected = address
g = Gateway(host=address, name='Test Add', enabled=True, power=26)
self.lora.addGateway(g)
result = self.lora.gateways[1].host
self.assertEqual(expected, result)
def _test_gateway(self):
"""Create a test gateway object. We must load the device
dynamically as it depends on the adbapi intialisation"""
return Gateway(
host='192.168.1.125',
name='gateway',
eui=36028797019005945,
enabled=True,
power=20,
)
def get(self, host):
"""Method to handle gateway GET requests"""
try:
g = yield Gateway.find(where=['host = ?', host], limit=1)
# Return a 404 if not found.
if g is None:
abort(404, message={'error': "Gateway {} doesn't exist.".format(host)})
returnValue(marshal(g, self.fields))
except TimeoutError:
log.error("REST API timeout retrieving gateway {host}",
host=host)
def post(self):
"""Method to create a gateway"""
host = self.args['host']
name = self.args['name']
eui = self.args['eui']
enabled = self.args['enabled']
power = self.args['power']
message = {}
# Check for required args
required = {'host', 'name', 'eui', 'enabled', 'power'}
for r in required:
if self.args[r] is None:
message[r] = "Missing the {} parameter.".format(r)
if message:
abort(400, message=message)
# Ensure we have a valid address
try:
ipaddress.ip_address(host)
except (ipaddress.AddressValueError, ValueError):
message = {'error': "Invalid IP address {} ".format(host)}
abort(400, message=message)
# Ensure we have a valid EUI
if not isinstance(eui, (int, long)):
message = {'error': "Invalid gateway EUI {} ".format(eui)}
abort(400, message=message)
# Check this gateway does not currently exist
exists = yield Gateway.exists(where=['host = ?', host])
if exists:
message = {'error': "Gateway address {} ".format(host) + \
"currently exists."}
abort(400, message=message)
# Check the EUI does not currently exist
exists = yield Gateway.exists(where=['eui = ?', eui])
if exists:
message = {'error': "Gateway EUI {} ".format(eui) + \
"currently exists."}
abort(400, message=message)
# Create and validate
gateway = Gateway(host=host, eui=eui, name=name, enabled=enabled, power=power)
(valid, message) = gateway.valid()
if not valid:
abort(400, message=message)
try:
g = yield gateway.save()
if g is None:
abort(500, message={'error': "Error saving the gateway."})
# Add the new gateway to the server.
self.server.lora.addGateway(g)
location = self.restapi.api.prefix + '/gateway/' + str(host)
returnValue(({}, 201, {'Location': location}))
except TimeoutError:
# Exception returns 500 to client
log.error("REST API timeout for gateway POST request")
def setUp(self):
"""Test setup. Creates a new NetServer
"""
Registry.getConfig = MagicMock(return_value=None)
## Get factory default configuration
with patch.object(Model, 'save', MagicMock()):
config = yield Config.loadFactoryDefaults()
server = NetServer(config)
self.lora = lora_wan.LoraWAN(server)
g = Gateway(host='192.168.1.125', name='Test', enabled=True, power=26)
self.lora.gateways.append(g)
def test_updateGateway(self):
""" Test updateGateway method"""
address = '192.168.1.199'
expected = address
host = self.lora.gateways[0].host
gateway = Gateway(host=address,
name='Test Update',
enabled=True,
power=26)
self.lora.updateGateway(host, gateway)
result = self.lora.gateways[0].host
self.assertEqual(expected, result)
def get(self):
"""Method to get all gateways"""
try:
gateways = yield Gateway.all()
if gateways is None:
returnValue({})
data = {}
for i,g in enumerate(gateways):
data[i] = marshal(g, self.fields)
returnValue(data)
except TimeoutError:
# Exception returns 500 to client
log.error("REST API timeout retrieving all gateways")
def delete(self, host):
"""Method to handle gateway DELETE requests
Args:
host (str): Gateway host
"""
try:
g = yield Gateway.find(where=['host = ?', host], limit=1)
# Return a 404 if not found.
if g is None:
abort(404, message={'error': "Gateway {} doesn't exist.".format(host)})
deleted = yield g.delete()
self.server.lora.deleteGateway(g)
returnValue(({}, 200))
except TimeoutError:
log.error("REST API timeout retrieving gateway {host}",
host=host)
def test_txpkResponse(self):
self.server.lora = LoraWAN(self)
self.server.lora.addGateway(
Gateway(host='192.168.1.125', name='Test', enabled=True, power=26))
tmst = randrange(0, 4294967295)
rxpk = Rxpk(tmst=tmst,
chan=3,
freq=915.8,
datr='SF7BW125',
data="n/uSwM0LIED8X6QV0mJMjC6oc2HOWFpCfmTry",
size=54)
device = self._test_device()
device.rx = self.server.band.rxparams((rxpk.chan, rxpk.datr),
join=False)
gateway = self.server.lora.gateway(device.gw_addr)
expected = [
(True, device.rx[1]['freq'], device.rx[1]['datr']),
(True, device.rx[2]['freq'], device.rx[2]['datr']),
(tmst + 1000000, device.rx[1]['freq'], device.rx[1]['datr']),
(tmst + 2000000, device.rx[2]['freq'], device.rx[2]['datr'])
]
result = []
txpk = self.server._txpkResponse(device,
rxpk.data,
gateway,
tmst,
immediate=True)
for i in range(1, 3):
result.append((txpk[i].imme, txpk[i].freq, txpk[i].datr))
txpk = self.server._txpkResponse(device,
rxpk.data,
gateway,
tmst,
immediate=False)
for i in range(1, 3):
result.append((txpk[i].tmst, txpk[i].freq, txpk[i].datr))
self.assertEqual(expected, result)