def test_ensure_mapping_uninitialized(self):
attr = 'get_interfaces'
with mock.patch.object(ip.IPManager, attr) as get_ifaces:
mgr = ip.IPManager()
mgr.ensure_mapping()
get_ifaces.assert_called_once_with()
def configure_gunicorn():
"""
"""
mgr = ip.IPManager()
listen_ip = mgr.get_management_address(ensure_configuration=True)
if not listen_ip:
sys.stderr.write('Unable to bring up first interface (ge0)!\n')
sys.exit(1)
args = {'host': listen_ip,
'port': defaults.API_SERVICE}
config = """
import multiprocessing
bind = '[%(host)s]:%(port)d'
workers = workers = multiprocessing.cpu_count() * 2 + 1
backlog = 2048
worker_class ="sync"
debug = False
daemon = True
pidfile = "/var/run/gunicorn.pid"
logfile = "/tmp/gunicorn.log"
"""
config = textwrap.dedent(config % args).lstrip()
try:
open('/etc/akanda_gunicorn_config', 'w+').write(config)
sys.stderr.write('http configured to listen on %s\n' % listen_ip)
except:
sys.stderr.write('Unable to write gunicorn configuration file.')
def test_address_add(self):
cmd = '/sbin/ip'
v4 = netaddr.IPNetwork('192.168.105.2/24')
v6 = netaddr.IPNetwork('fdca:3ba5:a17a:acda:20c:29ff:fe94:723d/64')
iface = mock.Mock(all_addresses=[v4, v6], ifname='em0')
old_iface = mock.Mock(all_addresses=[], ifname='em0')
mgr = ip.IPManager()
with mock.patch.object(mgr, 'generic_to_host',
lambda x: x.replace('ge', 'em')):
mgr._update_addresses('em0', iface, old_iface)
assert self.mock_execute.call_args_list == [
mock.call([
cmd, 'addr', 'add', '192.168.105.2/24', 'brd', '+', 'dev',
'em0'
], 'sudo'),
mock.call([cmd, 'link', 'set', 'em0', 'up'], 'sudo'),
mock.call([cmd, 'addr', 'show', 'em0']),
mock.call([
cmd, '-6', 'addr', 'add',
'fdca:3ba5:a17a:acda:20c:29ff:fe94:723d/64', 'dev', 'em0'
], 'sudo'),
mock.call([cmd, 'link', 'set', 'em0', 'up'], 'sudo'),
mock.call([cmd, 'addr', 'show', 'em0'])
]
def test_ensure_mapping_initialized(self):
attr = 'get_interfaces'
with mock.patch.object(ip.IPManager, attr) as get_ifaces:
mgr = ip.IPManager()
mgr.host_mapping['em0'] = 'ge0'
mgr.ensure_mapping()
self.assertEqual(get_ifaces.call_count, 0)
def test_dad_for_external(self):
mgr = ip.IPManager()
with mock.patch.object(mgr, 'generic_to_host', lambda x: x):
mgr.disable_duplicate_address_detection(
models.Network('ABC123',
models.Interface('eth1'),
network_type=models.Network.TYPE_EXTERNAL))
assert self.mock_execute.call_count == 0
def test_update_interfaces(self):
iface_a = mock.Mock()
iface_b = mock.Mock()
attr = 'update_interface'
with mock.patch.object(ip.IPManager, attr) as update:
mgr = ip.IPManager()
mgr.update_interfaces([iface_a, iface_b])
update.assert_has_calls([mock.call(iface_a), mock.call(iface_b)])
def update_hosts(self, config):
mgr = ip.IPManager()
listen_ip = mgr.get_management_address()
config_data = [
'127.0.0.1 localhost',
'::1 localhost ip6-localhost ip6-loopback',
'%s %s' % (listen_ip, config.hostname)
]
utils.replace_file('/tmp/hosts', '\n'.join(config_data))
utils.execute(['mv', '/tmp/hosts', '/etc/hosts'], self.root_helper)
def test_update_addresses(self):
iface = mock.Mock()
old_iface = mock.Mock()
with mock.patch.object(ip.IPManager, '_update_set') as us:
mgr = ip.IPManager()
mgr._update_addresses('em0', iface, old_iface)
us.assert_called_once_with('em0', iface, old_iface,
'all_addresses', mock.ANY, mock.ANY,
mock.ANY)
def test_dad_for_internal(self):
mgr = ip.IPManager()
with mock.patch.object(mgr, 'generic_to_host', lambda x: x):
mgr.disable_duplicate_address_detection(
models.Network('ABC123',
models.Interface('eth2'),
network_type=models.Network.TYPE_INTERNAL))
assert self.mock_execute.call_count == 1
assert self.mock_execute.call_args_list == [
mock.call(['sysctl', '-w', 'net.ipv6.conf.eth2.accept_dad=0'],
'sudo'),
]
def test_down(self):
iface = mock.Mock()
iface.ifname = 'ge0'
mgr = ip.IPManager()
mgr.host_mapping = {'em0': 'ge0'}
mgr.generic_mapping = {'ge0': 'em0'}
mgr.down(iface)
self.mock_execute.assert_has_calls(
[mock.call(['/sbin/ip', 'link', 'set', 'em0', 'down'], 'sudo')])
def test_update_set_no_diff(self):
iface = mock.Mock()
iface.all_addresses = ['a', 'b']
old_iface = mock.Mock()
old_iface.all_addresses = ['a', 'b']
add = lambda g: ('em0', 'add', g)
delete = lambda g: ('em0', 'del', g)
mgr = ip.IPManager()
mgr._update_set('em0', iface, old_iface, 'all_addresses', add, delete)
self.assertEqual(self.mock_execute.call_count, 0)
def test_get_management_address(self):
# Mark eth0 as DOWN
output = """2: eth0: <BROADCAST,MULTICAST> mtu 1500 qdisc pfifo_fast state DOWN qlen 1000
link/ether fa:16:3e:34:ba:28 brd ff:ff:ff:ff:ff:ff
valid_lft forever preferred_lft forever""" # noqa
fake_output = lambda *x: output
with mock.patch.object(ip.IPManager, 'do', fake_output):
mgr = ip.IPManager()
addr = mgr.get_management_address()
assert addr == 'fdca:3ba5:a17a:acda:f816:3eff:fe34:ba28'
assert self.mock_execute.call_args_list == [
mock.call(['/sbin/ip', 'link', 'set', 'eth0', 'up'], 'sudo'),
]
def test_get_interfaces(self):
iface_a = mock.Mock()
iface_a.ifname = 'em0'
iface_b = mock.Mock()
iface_b.ifname = 'em1'
ifaces = 'akanda.router.drivers.ip._parse_interfaces'
with mock.patch(ifaces) as parse:
parse.return_value = [iface_a, iface_b]
mgr = ip.IPManager()
interfaces = mgr.get_interfaces()
self.assertEqual(interfaces, [iface_a, iface_b])
self.mock_execute.assert_has_calls(
[mock.call(['/sbin/ip', 'addr', 'show'])])
def test_get_interface(self):
iface_a = mock.Mock()
iface_a.ifname = 'em0'
iface = 'akanda.router.drivers.ip._parse_interface'
ifaces = 'akanda.router.drivers.ip._parse_interfaces'
with mock.patch(iface) as parse:
with mock.patch(ifaces) as pi:
pi.return_value = [iface_a]
parse.return_value = iface_a
mgr = ip.IPManager()
interface = mgr.get_interface('ge0')
self.assertEqual(interface, iface_a)
self.assertEqual(iface_a.ifname, 'ge0')
self.mock_execute.assert_has_calls(
[mock.call(['/sbin/ip', 'addr', 'show'])])
def test_address_remove(self):
cmd = '/sbin/ip'
v4 = netaddr.IPNetwork('192.168.105.2/24')
v6 = netaddr.IPNetwork('fdca:3ba5:a17a:acda:20c:29ff:fe94:723d/64')
iface = mock.Mock(all_addresses=[])
old_iface = mock.Mock(all_addresses=[v4, v6])
mgr = ip.IPManager()
mgr._update_addresses('em0', iface, old_iface)
assert self.mock_execute.call_args_list == [
mock.call(
[cmd, 'addr', 'del', str(v4), 'dev', 'em0'], 'sudo'),
mock.call(
['conntrack', '-D', '-d', str(v4.ip)], 'sudo'),
mock.call(
['conntrack', '-D', '-q', str(v4.ip)], 'sudo'),
mock.call([cmd, '-6', 'addr', 'del',
str(v6), 'dev', 'em0'], 'sudo'),
]
def test_sysctl_failure(self):
logger = ip.LOG
logger.level = logging.DEBUG
buff = StringIO()
handler = logging.StreamHandler(buff)
self.mock_execute.side_effect = RuntimeError
mgr = ip.IPManager()
with mock.patch.object(mgr, 'generic_to_host', lambda x: x):
try:
logger.addHandler(handler)
mgr.disable_duplicate_address_detection(
models.Network(
'ABC123',
models.Interface('eth0'),
network_type=models.Network.TYPE_MANAGEMENT))
assert 'Failed to disable v6 dad on eth0' in buff.getvalue()
finally:
logger.removeHandler(handler)
def _update_interface_test_hlpr(self,
new_iface,
old_iface,
ignore_link_local=True):
mock_methods = {
'generic_to_host': mock.Mock(return_value='em0'),
'get_interface': mock.Mock(return_value=old_iface),
'_update_addresses': mock.Mock()
}
with mock.patch.multiple(ip.IPManager, **mock_methods):
mgr = ip.IPManager()
mgr.update_interface(
new_iface,
ignore_link_local=ignore_link_local,
)
mock_methods['generic_to_host'].assert_called_once_with('ge0')
mock_methods['get_interface'].assert_called_once_with('ge0')
mock_methods['_update_addresses'].assert_called_once_with(
'em0', new_iface, old_iface)
def test_update_set(self):
iface = mock.Mock()
a = netaddr.IPNetwork('192.168.101.2/24')
b = netaddr.IPNetwork('192.168.102.2/24')
c = netaddr.IPNetwork('192.168.103.2/24')
iface.all_addresses = [a, b]
iface.ifname = 'em0'
old_iface = mock.Mock()
old_iface.all_addresses = [b, c]
old_iface.ifname = 'em0'
add = lambda g: ('addr', 'add', '/'.join(map(str, g)), 'dev', 'em0')
delete = lambda g: ('addr', 'del', '/'.join(map(str, g)), 'dev', 'em0')
mutator = lambda x: (x.ip, x.prefixlen)
mgr = ip.IPManager()
with mock.patch.object(mgr, 'generic_to_host',
lambda x: x.replace('ge', 'em')):
mgr._update_set('em0',
iface,
old_iface,
'all_addresses',
add,
delete,
mutator=mutator)
assert self.mock_execute.call_args_list == [
mock.call(['/sbin/ip', 'addr', 'add',
str(a), 'dev', 'em0'], 'sudo'),
mock.call(['/sbin/ip', 'link', 'set', 'em0', 'up'], 'sudo'),
mock.call(['/sbin/ip', 'addr', 'show', 'em0']),
mock.call(['/sbin/ip', 'addr', 'del',
str(c), 'dev', 'em0'], 'sudo'),
mock.call(['conntrack', '-D', '-d',
str(c.ip)], 'sudo'),
mock.call(['conntrack', '-D', '-q',
str(c.ip)], 'sudo'),
]
def configure_ssh():
"""
"""
mgr = ip.IPManager()
listen_ip = mgr.get_management_address(ensure_configuration=True)
if not listen_ip:
sys.stderr.write('Unable to bring up first interface (ge0)!\n')
sys.exit(1)
config = open('/etc/ssh/sshd_config', 'r').read()
config = re.sub('(^|\n)(#)?(ListenAddress|AddressFamily) .*', '', config)
config += '\n'.join([
'', # make sure we have a blank line at the end before adding more
'AddressFamily inet6',
'ListenAddress ' + listen_ip,
'UseDNS no'
])
try:
open('/etc/ssh/sshd_config', 'w+').write(config)
sys.stderr.write('sshd configured to listen on %s\n' % listen_ip)
except:
sys.stderr.write('Unable to write sshd configuration file.')
def update_routes(self, cache):
mgr = ip.IPManager()
mgr.update_default_gateway(self.config)
mgr.update_host_routes(self.config, cache)
def __init__(self, state_path='.'):
self.state_path = os.path.abspath(state_path)
self.ip_mgr = ip.IPManager()
self.ip_mgr.ensure_mapping()
self._config = models.Configuration()
def setUp(self):
super(RouteTest, self).setUp()
self.mgr = ip.IPManager()
self.host_patch = mock.patch.object(self.mgr, 'generic_to_host',
lambda x: x.replace('ge', 'eth'))
self.host_patch.start()
def test_is_valid(self):
mgr = ip.IPManager()
mgr.host_mapping = {'em0': 'ge0'}
mgr.generic_mapping = {'ge0': 'em0'}
self.assertTrue(mgr.is_valid('ge0'))
def test_host_to_generic(self):
mgr = ip.IPManager()
mgr.host_mapping = {'em0': 'ge0'}
mgr.generic_mapping = {'ge0': 'em0'}
self.assertEqual(mgr.host_to_generic('em0'), 'ge0')
self.assertIsNone(mgr.host_to_generic('em1'))
def test_init(self):
mgr = ip.IPManager()
self.assertEqual(mgr.host_mapping.keys(), [])
