def test_run_net_cmd_sup(self):
cmd_up0 = get_net_cmds(self.bin_dir, 'fpn0', True)
cmd_up1 = get_net_cmds(self.bin_dir, 'fpn1', True)
every().second.do(run_net_cmd, cmd_up0).tag('net-change')
every().second.do(run_net_cmd, cmd_up1).tag('net-change')
self.assertEqual(len(schedule.jobs), 2)
schedule.run_all(0, 'net-change')
self.assertEqual(len(schedule.jobs), 0)
def do_startup(nwid):
"""
Run network startup command once before the state runner is
available (if we have a network and interface up).
"""
import time
from node_tools.helper_funcs import AttrDict
from node_tools.network_funcs import do_net_cmd
from node_tools.network_funcs import get_net_cmds
from node_tools import state_data as st
run_ztcli_cmd(action='join', extra=nwid)
# time.sleep(1)
state = AttrDict.from_nested_dict(st.fpnState)
fpn_home = NODE_SETTINGS['home_dir']
nets = ['fpn_id0', 'fpn_id1']
ifaces = ['fpn0', 'fpn1']
for iface, net in zip(ifaces, nets):
if st.fpnState[iface] and net == nwid:
logger.debug('STARTUP: running setup on {}'.format(iface))
cmd = get_net_cmds(fpn_home, iface, True)
logger.debug('run_net_cmd using cmd: {}'.format(cmd))
schedule.every(1).seconds.do(run_net_cmd, cmd).tag('net-change')
def test_get_net_cmds_true(self):
up0, down0, up1, down1 = get_net_cmds(self.bin_dir)
# print(up0)
self.assertTrue(os.path.isfile(up0))
self.assertTrue(os.path.isfile(down0))
self.assertTrue(os.path.isfile(up1))
self.assertTrue(os.path.isfile(down1))
def test_run_net_cmd_sdown(self):
NODE_SETTINGS['route_dns_53'] = True
NODE_SETTINGS['private_dns_only'] = True
cmd_down0 = get_net_cmds(self.bin_dir, 'fpn0', False)
cmd_down1 = get_net_cmds(self.bin_dir, 'fpn1', False)
every().second.do(run_net_cmd, cmd_down0).tag('net-change')
every().second.do(run_net_cmd, cmd_down1).tag('net-change')
self.assertEqual(len(schedule.jobs), 2)
schedule.run_all(0, 'net-change')
self.assertEqual(len(schedule.jobs), 2)
schedule.run_all(0, 'net-change')
schedule.run_all(0, 'net-change')
self.assertEqual(len(schedule.jobs), 0)
def test_run_net_cmd_up0(self):
# expected command result is 'Success' so the return
# result is actually <schedule.CancelJob>
mock_job = make_mock_job()
cmd = get_net_cmds(self.bin_dir, 'fpn0', True)
tj = every().second.do(mock_job)
result = run_net_cmd(cmd)
self.assertIsInstance(result, type)
self.assertIn('CancelJob', str(result))
def do_cleanup(path=None, addr=None):
"""
Run network cleanup commands via daemon cleanup hook.
:param path: path to scripts dir
:param addr: moon address if known
"""
from node_tools.helper_funcs import AttrDict
from node_tools.network_funcs import do_net_cmd
from node_tools.network_funcs import get_net_cmds
from node_tools.helper_funcs import put_state_msg
from node_tools.network_funcs import send_req_msg
from node_tools import state_data as st
if NODE_SETTINGS['node_role'] == 'moon':
for script in ['msg_responder.py', 'msg_subscriber.py']:
res = control_daemon('stop', script)
logger.info('CLEANUP: shutting down {}'.format(script))
elif NODE_SETTINGS['node_role'] == 'controller':
for script in ['msg_subscriber.py']:
res = control_daemon('stop', script)
logger.info('CLEANUP: shutting down {}'.format(script))
else:
state = AttrDict.from_nested_dict(st.fpnState)
moon_addr = addr
moon_id = state.moon_id0
node_id = state.fpn_id
if not addr:
moon_addr = state.moon_addr
if not NODE_SETTINGS['use_localhost'] and not addr:
addr = moon_addr
if not path:
path = NODE_SETTINGS['home_dir']
nets = ['fpn_id0', 'fpn_id1']
ifaces = ['fpn0', 'fpn1']
put_state_msg('NONE')
for iface, net in zip(ifaces, nets):
if state[iface]:
logger.info('CLEANUP: shutting down {}'.format(iface))
cmd = get_net_cmds(path, iface)
res = do_net_cmd(cmd)
logger.debug('CLEANUP: {} shutdown returned {}'.format(
iface, res))
# logger.info('CLEANUP: leaving network ID: {}'.format(state[net]))
res = run_ztcli_cmd(action='leave', extra=state[net])
logger.debug('CLEANUP: action leave returned: {}'.format(res))
if moon_id is not None:
run_moon_cmd(moon_id, action='deorbit')
reply = send_req_msg(addr, 'offline', node_id)
logger.debug('CLEANUP: offline reply: {}'.format(reply))
def test_run_net_cmd_down0(self):
# expected command result is 'Fail' so the return
# result is the output of run_net_cmd()
mock_job = make_mock_job()
cmd = get_net_cmds(self.bin_dir, 'fpn0', False)
tj = every().second.do(mock_job)
state, res, ret = run_net_cmd(cmd)
self.assertFalse(state)
self.assertEqual(res, b'')
self.assertEqual(ret, 1)
def test_get_net_cmds_bad_path(self):
mock_job = make_mock_job()
tj = every().second.do(mock_job)
bad_dir = '/tmp/foobar/'
cmd = ['/tmp/foo0-down.sh']
self.assertFalse(os.path.isdir(bad_dir))
res = get_net_cmds(bad_dir, 'fpn0', True)
# print(cmd)
self.assertIsNone(res)
state, result, ret = run_net_cmd(cmd)
self.assertFalse(state)
self.assertRaises(FileNotFoundError)
def net_change_handler(iface, state):
"""
Net change event handler for configuring fpn network devices
(calls net cmds for a given interface/state). Schedules a new
run_net_cmd() job for each change event.
:param iface: <'fpn0'|'fpn1'> fpn interface to act on
:param state: <True|False> new iface state, ie, up|down
"""
import schedule
from node_tools.network_funcs import get_net_cmds
from node_tools.network_funcs import run_net_cmd
fpn_home = NODE_SETTINGS['home_dir']
cmd = get_net_cmds(fpn_home, iface, state)
if cmd:
if NODE_SETTINGS['mode'] == 'adhoc' and NODE_SETTINGS['nwid']:
cmd.append(NODE_SETTINGS['nwid'])
logger.debug('run_net_cmd using cmd: {}'.format(cmd))
schedule.every(1).seconds.do(run_net_cmd, cmd).tag('net-change')
else:
logger.error('get_net_cmds returned None')
def test_get_net_cmds_single_up(self):
cmd = get_net_cmds(self.bin_dir, 'fpn1', True)
path, name = os.path.split(cmd[0])
self.assertEqual(name, 'fpn1-setup.sh')
def test_get_net_cmds_single(self):
cmd = get_net_cmds(self.bin_dir, 'fpn0')
path, name = os.path.split(cmd[0])
self.assertEqual(name, 'fpn0-down.sh')
def test_get_net_cmds_false(self):
bin_path = '/bin'
self.assertIsNone(get_net_cmds(bin_path))
