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)