def test_release_unknown_sid_apn_ip_tuple(self):
""" releasing unknown sid-apn-ip tuple should raise NOT_FOUND """
self._stub.AddIPBlock(self._block_msg)
alloc_request0 = AllocateIPRequest(sid=self._sid0,
version=AllocateIPRequest.IPV4,
apn=self._apn0)
ip_msg0 = self._stub.AllocateIPAddress(alloc_request0)
request = ReleaseIPRequest(sid=SIDUtils.to_pb("IMSI12345"),
ip=ip_msg0.ip_list[0],
apn=self._apn0)
with self.assertRaises(grpc.RpcError) as err:
self._stub.ReleaseIPAddress(request)
self.assertEqual(err.exception.code(), grpc.StatusCode.NOT_FOUND)
ip_bytes = bytes(map(int, '10.0.0.0'.split('.')))
request.ip.CopyFrom(IPAddress(version=IPAddress.IPV4,
address=ip_bytes))
with self.assertRaises(grpc.RpcError) as err:
self._stub.ReleaseIPAddress(request)
self.assertEqual(err.exception.code(), grpc.StatusCode.NOT_FOUND)
request = ReleaseIPRequest(sid=self._sid0,
ip=ip_msg0.ip_list[0],
apn=self._apn1)
with self.assertRaises(grpc.RpcError) as err:
self._stub.ReleaseIPAddress(request)
self.assertEqual(err.exception.code(), grpc.StatusCode.NOT_FOUND)
def test_release_ip_address(self):
""" test ReleaseIPAddress """
self._stub.AddIPBlock(self._block_msg)
alloc_request0 = AllocateIPRequest(sid=self._sid0,
version=AllocateIPRequest.IPV4,
apn=self._apn0)
ip_msg0 = self._stub.AllocateIPAddress(alloc_request0)
alloc_request1 = AllocateIPRequest(sid=self._sid1,
version=AllocateIPRequest.IPV4,
apn=self._apn0)
ip_msg1 = self._stub.AllocateIPAddress(alloc_request1)
# release ip_msg0
release_request0 = ReleaseIPRequest(sid=self._sid0,
ip=ip_msg0.ip_list[0],
apn=self._apn0)
resp = self._stub.ReleaseIPAddress(release_request0)
self.assertEqual(resp, Void())
resp = self._stub.ListAllocatedIPs(self._block_msg)
tmp = ListAllocatedIPsResponse()
tmp.ip_list.extend([ip_msg1.ip_list[0]])
self.assertEqual(resp, tmp)
# release ip_msg1
release_request1 = ReleaseIPRequest(sid=self._sid1,
ip=ip_msg1.ip_list[0],
apn=self._apn0)
resp = self._stub.ReleaseIPAddress(release_request1)
resp = self._stub.ListAllocatedIPs(self._block_msg)
self.assertEqual(len(resp.ip_list), 0)
def release_ip_handler(client, args):
try:
sid_msg = SIDUtils.to_pb(args.sid)
except ValueError:
print("Error: invalid SubscriberID format: %s" % args.sid)
return
try:
ip = ipaddress.ip_address(args.ip)
except ValueError:
print("Error: invalid IP format: %s" % args.ip)
return
apn = args.apn
ip_msg = IPAddress()
if ip.version == 4:
ip_msg.version = IPAddress.IPV4
elif ip.version == 6:
ip_msg.version = IPAddress.IPV6
else:
print("Error: unknown IP version")
return
ip_msg.address = ip.packed
request = ReleaseIPRequest()
request.sid.CopyFrom(sid_msg)
request.ip.CopyFrom(ip_msg)
request.apn = apn
client.ReleaseIPAddress(request)
print("IPv6 address released: %s" % ipaddress.ip_address(ip_msg.address))
def test_remove_after_releasing_all_addresses(self):
""" remove after releasing all addresses should remove block """
# Assign IP block
self._stub.AddIPBlock(self._block_msg)
# Allocate 2 IPs
alloc_request0 = AllocateIPRequest(sid=self._sid0,
version=AllocateIPRequest.IPV4,
apn=self._apn0)
ip_msg0 = self._stub.AllocateIPAddress(alloc_request0)
alloc_request1 = AllocateIPRequest(sid=self._sid1,
version=AllocateIPRequest.IPV4,
apn=self._apn0)
ip_msg1 = self._stub.AllocateIPAddress(alloc_request1)
# Test remove without force -- should not remove block
remove_request0 = RemoveIPBlockRequest(ip_blocks=[self._block_msg],
force=False)
resp = self._stub.RemoveIPBlock(remove_request0)
expect = RemoveIPBlockResponse()
self.assertEqual(expect, resp)
# Ensure that block has not been removed
resp = self._stub.ListAddedIPv4Blocks(Void())
expect = ListAddedIPBlocksResponse()
expect.ip_block_list.extend([self._block_msg])
self.assertEqual(expect, resp)
# Release the allocated IPs
release_request0 = ReleaseIPRequest(sid=self._sid0,
ip=ip_msg0.ip_list[0],
apn=self._apn0)
resp = self._stub.ReleaseIPAddress(release_request0)
self.assertEqual(resp, Void())
release_request1 = ReleaseIPRequest(sid=self._sid1,
ip=ip_msg1.ip_list[0],
apn=self._apn0)
resp = self._stub.ReleaseIPAddress(release_request1)
self.assertEqual(resp, Void())
# Test remove without force -- should remove block
remove_request1 = RemoveIPBlockRequest(ip_blocks=[self._block_msg],
force=False)
resp = self._stub.RemoveIPBlock(remove_request1)
expect = RemoveIPBlockResponse()
expect.ip_blocks.extend([self._block_msg])
self.assertEqual(expect, resp)
# Ensure that block has been removed
resp = self._stub.ListAddedIPv4Blocks(Void())
expect = ListAddedIPBlocksResponse()
self.assertEqual(expect, resp)
def test_ipv6_unimplemented(self):
""" ipv6 requests should raise UNIMPLEMENTED """
ip = ipaddress.ip_address("fc::")
block = IPBlock(version=IPBlock.IPV6,
net_address=ip.packed,
prefix_len=120)
# AddIPBlock
with self.assertRaises(grpc.RpcError) as err:
self._stub.AddIPBlock(block)
self.assertEqual(err.exception.code(), grpc.StatusCode.UNIMPLEMENTED)
# ListAllocatedIPs
with self.assertRaises(grpc.RpcError) as err:
self._stub.ListAllocatedIPs(block)
self.assertEqual(err.exception.code(), grpc.StatusCode.UNIMPLEMENTED)
# AllocateIPAddress
request = AllocateIPRequest(sid=self._sid1,
version=AllocateIPRequest.IPV6,
apn=self._apn0)
with self.assertRaises(grpc.RpcError) as err:
self._stub.AllocateIPAddress(request)
self.assertEqual(err.exception.code(), grpc.StatusCode.UNIMPLEMENTED)
# ReleaseIPAddress
release_request = ReleaseIPRequest(
sid=self._sid0,
ip=IPAddress(version=IPAddress.IPV6),
apn=self._apn0)
with self.assertRaises(grpc.RpcError) as err:
self._stub.ReleaseIPAddress(release_request)
self.assertEqual(err.exception.code(), grpc.StatusCode.UNIMPLEMENTED)
def test_get_subscriber_ip_table(self):
""" test GetSubscriberIPTable """
self._stub.AddIPBlock(self._block_msg)
resp = self._stub.GetSubscriberIPTable(Void())
self.assertEqual(len(resp.entries), 0)
alloc_request0 = AllocateIPRequest(sid=self._sid0,
version=AllocateIPRequest.IPV4)
ip_msg0 = self._stub.AllocateIPAddress(alloc_request0)
entry0 = SubscriberIPTableEntry(sid=self._sid0, ip=ip_msg0)
resp = self._stub.GetSubscriberIPTable(Void())
self.assertTrue(entry0 in resp.entries)
alloc_request1 = AllocateIPRequest(sid=self._sid1,
version=AllocateIPRequest.IPV4)
ip_msg1 = self._stub.AllocateIPAddress(alloc_request1)
entry1 = SubscriberIPTableEntry(sid=self._sid1, ip=ip_msg1)
resp = self._stub.GetSubscriberIPTable(Void())
self.assertTrue(entry0 in resp.entries)
self.assertTrue(entry1 in resp.entries)
# keep in table after in release
release_request0 = ReleaseIPRequest(sid=self._sid0, ip=ip_msg0)
resp = self._stub.ReleaseIPAddress(release_request0)
resp = self._stub.GetSubscriberIPTable(Void())
self.assertTrue(entry0 in resp.entries)
self.assertTrue(entry1 in resp.entries)
def _build_release_ip_data(client):
release_ip_reqs = []
table = client.GetSubscriberIPTable(Void())
if not table.entries:
print('No IPs allocated to be freed, please run allocate test first')
exit(1)
for entry in table.entries:
release_ip_req = ReleaseIPRequest(sid=entry.sid, ip=entry.ip,
apn=entry.apn)
release_ip_dict = json_format.MessageToDict(release_ip_req)
# Dumping ReleaseIP request into json
release_ip_reqs.append(release_ip_dict)
with open('release_data.json', 'w') as file:
json.dump(release_ip_reqs, file)
def test_ipv6(self):
""" ipv6 requests should work for allocate / release IP requests """
# AllocateIPAddress
request = AllocateIPRequest(sid=self._sid1,
version=AllocateIPRequest.IPV6,
apn=self._apn0)
ip_msg = self._stub.AllocateIPAddress(request)
self.assertTrue(
ipaddress.ip_address(ip_msg.ip_list[0].address) in
self._ipv6_block)
# ReleaseIPAddress
release_request = ReleaseIPRequest(sid=self._sid1,
ip=ip_msg.ip_list[0],
apn=self._apn0)
self._stub.ReleaseIPAddress(release_request)
