def test_add_successfully_adds_network(self):
pool = IPPool(network='192.168.1.1/32')
db.session.add(pool)
db.session.commit()
res = ippool.IpAddrPool().get()
first_net = {
'allocation': [('192.168.1.1', None, 'free')],
'blocked_list': [],
'free_hosts': ['192.168.1.1'],
'id': u'192.168.1.1/32',
'ipv6': False,
'network': u'192.168.1.1/32',
'node': None,
'page': 1,
'pages': 1,
}
self.assertEqual(res, [first_net])
pool = IPPool(network='192.168.1.2/32')
db.session.add(pool)
db.session.commit()
res = ippool.IpAddrPool().get()
self.assertEqual(len(res), 2)
res = ippool.IpAddrPool().get(net='192.168.1.3/32')
self.assertIsNone(res)
res = ippool.IpAddrPool().get(net='192.168.1.1/32')
self.assertEqual(res, first_net)
res = ippool.IpAddrPool().get(net='192.168.1.1/32', page=1000)
self.assertEqual(res, first_net)
def test_cant_add_overlapping_network(self):
current_app.config['FIXED_IP_POOLS'] = False
# 192.168.0.9 - 192.168.0.10
ippool.IpAddrPool().create({'network': u'192.168.1.8/30'})
with self.assertRaisesRegexp(APIError, 'overlaps'):
ippool.IpAddrPool().create({'network': u'192.168.1.9/32'})
with self.assertRaisesRegexp(APIError, 'overlaps'):
ippool.IpAddrPool().create({'network': u'192.168.1.0/24'})
with self.assertRaisesRegexp(APIError, 'overlaps'):
ippool.IpAddrPool().create({'network': u'192.168.0.0/16'})
def _create_network(self, network, autoblock=None):
data = {
'network': network,
'autoblock': '' if autoblock is None else autoblock,
'node': self.node.hostname,
}
ippool.IpAddrPool().create(data)
def test_delete_correctly_decreases_public_ip_counter(self):
# Networks contains 28 IPs
networks = [u'192.168.2.0/28', u'192.168.3.0/28']
for net in networks:
self._create_network(net)
ippool.IpAddrPool().delete(networks[0])
node = K8SNode(hostname=self.node.hostname)
self.assertEqual(node.free_public_ip_count, 16)
def test_update_decreases_public_ip_counter_on_block_ip_request(self):
# Network contains 14 IPs
# 192.168.2.1 - 192.168.2.14
network = u'192.168.2.0/28'
self._create_network(network)
params = {'block_ip': u'192.168.2.1', 'node': self.node.hostname}
ippool.IpAddrPool().update(network, params)
node = K8SNode(hostname=self.node.hostname)
self.assertEqual(node.free_public_ip_count, 16 - 1)
def test_delete(self, network_check_mock):
"""Test IpAddrPool.delete method."""
network = u'192.168.1.0/24'
with self.assertRaises(APIError) as err:
ippool.IpAddrPool().delete(network)
self.assertEqual(err.exception.status_code, 404)
pool = IPPool(network=network)
db.session.add(pool)
db.session.commit()
network_check_mock.side_effect = APIError()
with self.assertRaises(APIError):
ippool.IpAddrPool().delete(network)
network_check_mock.side_effect = None
ippool.IpAddrPool().delete(network)
all_ = IPPool.query.all()
self.assertEqual(all_, [])
def test_create_successfully_creates_network_instance(self):
data = {
'network': u'192.168.1.1/32',
'node': self.node.hostname,
}
pool = ippool.IpAddrPool().create(data)
self.assertEqual(pool.network, data['network'])
self.assertEqual(pool.node, self.node)
self.assertEqual(pool.get_blocked_set(), set([]))
self.assertEqual(pool.ipv6, False)
self.assertEqual(pool.free_hosts(), ['192.168.1.1'])
def run(self, subnet, exclude, include, node=None):
if exclude and include:
raise InvalidCommand('Can\'t specify both -e and -i')
if include:
to_include = ippool.IpAddrPool().parse_autoblock(include)
net = IPv4Network(unicode(subnet))
hosts = {str(i) for i in net.hosts()}
# Do not include network and broadcast IP address
# TODO: Fix according to AC-4044
hosts.add(str(net.network_address))
hosts.add(str(net.broadcast_address))
exclude = ','.join(hosts - to_include)
ippool.IpAddrPool().create({
'network': subnet.decode(),
'autoblock': exclude,
'node': node
})
def test_get_networks_list(self):
network = u'192.168.2.0/32'
self._create_network(network)
res = ippool.IpAddrPool().get_networks_list()
self.assertEqual(res,
[{'node': self.node.hostname,
'free_host_count': 1,
'ipv6': False,
'id': '192.168.2.0/32',
'network': '192.168.2.0/32'}]
)
def test_get_network_ips_aws(self, LoadBalanceService):
LoadBalanceService.return_value = mock.Mock(
get_dns_by_pods=lambda x: {y: y for y in x})
p = pod()
res = ippool.IpAddrPool().get_network_ips(None)
expected_blocks = [(p.id, p.id, 'busy', p.name, p.owner.username)]
self.assertEqual(res,
{'blocks': expected_blocks,
'free_host_count': 0, 'id': 'aws', 'ipv6': False,
'network': None, 'node': None}
)
def test_get_network_ips_24(self):
network = u'192.168.2.0/24'
self._create_network(network)
res = ippool.IpAddrPool().get_network_ips(network)
self.assertEqual(res,
{'node': self.node.hostname,
'free_host_count': 256,
'ipv6': False,
'id': '192.168.2.0/24',
'network': '192.168.2.0/24',
'blocks': [(3232236032, 3232236287, 'free')]}
)
def test_create_correctly_excludes_blocks(self):
pool = IPPool(network='192.168.1.1/32')
db.session.add(pool)
db.session.commit()
expected_block_ips = {u'192.168.2.1', u'192.168.2.3', u'192.168.2.4',
u'192.168.2.5', u'192.168.2.7'}
block = '192.168.2.1,192.168.2.3-192.168.2.5,192.168.2.7'
data = {
'network': u'192.168.2.0/24',
'autoblock': block,
'node': self.node.hostname,
}
pool = ippool.IpAddrPool().create(data)
self.assertEqual({
'network': pool.network,
'blocked_list': pool.get_blocked_set()
}, {
'network': data['network'],
'blocked_list': expected_block_ips,
})
invalid_block = 'qwerty'
data = {
'network': '192.168.4.0/24',
'autoblock': invalid_block
}
with self.assertRaises(APIError):
ippool.IpAddrPool().create(data)
networks = db.session.query(IPPool).order_by(IPPool.network)
self.assertEqual(
[item.network for item in networks],
[u'192.168.1.1/32', u'192.168.2.0/24'],
)
def test_update_fails_on_ip_block_if_free_ip_counter_is_zero(self):
# We have one ip in out network
network = u'192.168.2.0/32'
self._create_network(network)
node = K8SNode(hostname=self.node.hostname)
# Emulate situation when scheduler decreased counter in parallel
node.update_free_public_ip_count(0)
# Should fail as we try to block the only existing IP which was
# reserved by pod not yet started but already scheduled by scheduler
with self.assertRaises(APIError):
ippool.IpAddrPool().update(network, {
'block_ip': u'192.168.2.1',
'node': self.node.hostname
})
def test_create_raises_if_given_data_is_invalid(self):
for invalid in (None, {}):
with self.assertRaises(APIError):
ippool.IpAddrPool().create(invalid)
def test_add_raises_if_pool_network_is_incorrect(self):
pool = IPPool(network='somegarbage')
db.session.add(pool)
db.session.commit()
with self.assertRaises(ValueError):
ippool.IpAddrPool().get()
def test_get_returns_none_if_network_does_not_exist(self):
res = ippool.IpAddrPool().get(net='somegarbage')
self.assertIsNone(res)
def test_get_returns_emtpy_list_by_default(self):
res = ippool.IpAddrPool().get()
self.assertEqual(res, [])
def test_get_free_host_returns_first_ip_of_a_net_if_all_are_free(self):
pool = IPPool(network='192.168.1.0/24')
db.session.add(pool)
db.session.commit()
res = ippool.IpAddrPool().get_free()
self.assertEqual(res, '192.168.1.0')
def run(self, subnet):
ippool.IpAddrPool().delete(subnet.decode())
def test_update(self, remove_public_mock):
"""Test IpAddrPool.update method."""
network = u'192.168.2.0/24'
with self.assertRaises(APIError):
ippool.IpAddrPool().update(network, None)
pool = IPPool(network='192.168.1.0/24')
node = self.node
db.session.add(pool)
db.session.commit()
block = '192.168.2.1,192.168.2.3-192.168.2.5,192.168.2.7'
data = {
'network': network,
'autoblock': block,
'node': node.hostname,
}
ippool.IpAddrPool().create(data)
pool = ippool.IpAddrPool().update(network, None)
self.assertIsNotNone(pool)
blocked_list1 = pool.get_blocked_set()
self.assertEqual(pool.network, network)
# add already blocked ip
block_ip = u'192.168.2.1'
params = {'block_ip': block_ip}
with self.assertRaises(APIError):
ippool.IpAddrPool().update(network, params)
# block new ip
block_ip1 = u'192.168.2.111'
params = {'block_ip': block_ip1}
blocked_list = ippool.IpAddrPool().update(network, params)\
.get_blocked_set()
self.assertEqual(
blocked_list,
blocked_list1 | {block_ip1}
)
# and one else
block_ip2 = u'192.168.2.112'
params = {'block_ip': block_ip2}
blocked_list = ippool.IpAddrPool().update(network, params)\
.get_blocked_set()
self.assertEqual(
blocked_list,
blocked_list1 | {block_ip1, block_ip2}
)
unblock_ip = block_ip1
params = {'unblock_ip': unblock_ip}
blocked_list = ippool.IpAddrPool().update(network, params)\
.get_blocked_set()
self.assertEqual(
blocked_list,
blocked_list1 | {block_ip2}
)
self.assertFalse(remove_public_mock.called)
unbind_ip = '192.168.2.222'
params = {'unbind_ip': unbind_ip}
blocked_list = ippool.IpAddrPool().update(network, params)\
.get_blocked_set()
self.assertEqual(
blocked_list,
blocked_list1 | {block_ip2}
)
remove_public_mock.assert_called_once_with(ip=unbind_ip)
pool = ippool.IpAddrPool().update(network, {'node': node.hostname})
self.assertEqual(pool.node, node)
def run(self):
print(json.dumps(ippool.IpAddrPool().get()))
def test_get_free_host_returns_none_when_there_are_no_ips(self):
res = ippool.IpAddrPool().get_free()
self.assertIsNone(res)
