def _get_module_class(self):
image = self.IMAGE_NAME_FORMAT % self.test_name
LOGGER.debug("%s running docker test %s", self, image)
cls = docker_host.make_docker_host(image, prefix=self.CONTAINER_PREFIX)
# Work around an instability in the faucet/clib/docker library, b/152520627.
setattr(cls, 'pullImage', self._check_image)
return cls
def _get_host_class(self):
network = 'none' if self._ext_intf else 'bridge'
cls = docker_host.make_docker_host('daqf/networking', prefix='daq', network=network)
# Work around an instability in the faucet/clib/docker library, b/152520627.
if getattr(cls, 'pullImage'):
setattr(cls, 'pullImage', lambda x: True)
return cls
class FaucetDockerHostTest(FaucetSimpleTest):
"""Test basic docker host functionality"""
N_UNTAGGED = 2
N_EXTENDED = 2
EXTENDED_CLS = make_docker_host('faucet/test-host')
def test_containers(self):
"""Test containers to make sure they're actually docker."""
count = 0
host_name = None
for host in self.net.hosts:
marker = host.cmd('cat /root/test_marker.txt').strip()
if marker == 'faucet-test-host':
host_name = host.name
count = count + 1
host.activate()
host.wait()
self.assertTrue(
count == self.N_EXTENDED,
'Found %d containers, expected %d' % (count, self.N_EXTENDED))
self.assertTrue(
os.path.exists(os.path.join(self.tmpdir, host_name, 'tmp')),
'container tmp dir missing')
host_log = os.path.join(self.tmpdir, host_name, 'activate.log')
with open(host_log, 'r') as host_log_file:
lines = host_log_file.readlines()
output = ' '.join(lines).strip()
self.assertEqual(output, 'hello faucet')
def _initialize(self):
host_name = 'gw%02d' % self.port_set
host_port = self._switch_port(self.GATEWAY_OFFSET)
LOGGER.info('Initializing gateway %s as %s/%d', self.name, host_name,
host_port)
self.tmpdir = self._setup_tmpdir(host_name)
cls = docker_host.make_docker_host('daqf/networking',
prefix='daq',
network='bridge')
# Work around an instability in the faucet/clib/docker library, b/152520627.
if getattr(cls, 'pullImage'):
setattr(cls, 'pullImage', lambda x: True)
vol_maps = [os.path.abspath('inst/config') + ':/config/inst']
host = self.runner.add_host(host_name,
port=host_port,
cls=cls,
tmpdir=self.tmpdir,
vol_maps=vol_maps)
host.activate()
self.host = host
self._change_lease_time(
self.runner.config.get('initial_dhcp_lease_time'))
LOGGER.info("Added networking host %s on port %d at %s", host_name,
host_port, host.IP())
dummy_name = 'dummy%02d' % self.port_set
dummy_port = self._switch_port(self.DUMMY_OFFSET)
dummy = self.runner.add_host(dummy_name, port=dummy_port)
# Dummy does not use DHCP, so need to set default route manually.
dummy.cmd('route add -net 0.0.0.0 gw %s' % host.IP())
self.dummy = dummy
LOGGER.info("Added dummy target %s on port %d at %s", dummy_name,
dummy_port, dummy.IP())
self.fake_target = self.TEST_IP_FORMAT % self.port_set
self.host_intf = self.runner.get_host_interface(host)
LOGGER.debug('Adding fake target at %s to %s', self.fake_target,
self.host_intf)
host.cmd('ip addr add %s dev %s' % (self.fake_target, self.host_intf))
self._startup_scan(host)
log_file = os.path.join(self.tmpdir, 'dhcp_monitor.txt')
self.dhcp_monitor = dhcp_monitor.DhcpMonitor(self.runner, host,
self._dhcp_callback,
log_file)
self.dhcp_monitor.start()
ping_retry = self._PING_RETRY_COUNT
while not self._ping_test(host, dummy):
ping_retry -= 1
LOGGER.info('Gateway %s warmup failed at %s with %d', host_name,
datetime.datetime.now(), ping_retry)
assert ping_retry, 'warmup ping failure'
assert self._ping_test(host, dummy), 'dummy ping failed'
assert self._ping_test(dummy, host), 'host ping failed'
assert self._ping_test(dummy, self.fake_target), 'fake ping failed'
assert self._ping_test(
host, dummy, src_addr=self.fake_target), 'reverse ping failed'
def start(self, port, params, callback):
"""Start the docker test"""
LOGGER.debug('Target port %d starting docker test %s',
self.target_port, self.test_name)
self.start_time = datetime.datetime.now()
self.callback = callback
env_vars = [
"TARGET_NAME=" + self.host_name,
"TARGET_IP=" + params['target_ip'],
"TARGET_MAC=" + params['target_mac'],
"GATEWAY_IP=" + params['gateway_ip'],
"GATEWAY_MAC=" + params['gateway_mac']
]
if 'local_ip' in params:
env_vars += [
"LOCAL_IP=" + params['local_ip'],
"SWITCH_PORT=" + params['switch_port'],
"SWITCH_IP=" + params['switch_ip']
]
vol_maps = [params['scan_base'] + ":/scans"]
conf_base = params.get('conf_base')
if conf_base:
vol_maps += [conf_base + ":/config"]
image = self.IMAGE_NAME_FORMAT % self.test_name
LOGGER.debug("Target port %d running docker test %s", self.target_port,
image)
cls = docker_host.make_docker_host(image, prefix=self.CONTAINER_PREFIX)
host = self.runner.add_host(self.host_name,
port=port,
cls=cls,
env_vars=env_vars,
vol_maps=vol_maps,
tmpdir=self.tmpdir)
self.docker_host = host
try:
LOGGER.debug("Target port %d activating docker test %s",
self.target_port, image)
host = self.docker_host
pipe = host.activate(log_name=None)
# Docker tests don't use DHCP, so manually set up DNS.
host.cmd('echo nameserver $GATEWAY_IP > /etc/resolv.conf')
self.docker_log = host.open_log()
self.runner.monitor_stream(self.host_name,
pipe.stdout,
copy_to=self.docker_log,
hangup=self._docker_complete,
error=self._docker_error)
except:
host.terminate()
self.runner.remove_host(host)
raise
LOGGER.info("Target port %d test %s running", self.target_port,
self.test_name)
def _initialize(self):
host_name = 'gw%02d' % self.port_set
host_port = self._switch_port(self.GATEWAY_OFFSET)
LOGGER.info('Initializing gateway %s as %s/%d', self.name, host_name,
host_port)
self.tmpdir = self._setup_tmpdir(host_name)
cls = docker_host.make_docker_host('daq/networking',
prefix='daq',
network='bridge')
host = self.runner.add_host(host_name,
port=host_port,
cls=cls,
tmpdir=self.tmpdir)
host.activate()
LOGGER.info("Adding networking host %s on port %d at %s", host_name,
host_port, host.IP())
dummy_name = 'dummy%02d' % self.port_set
dummy_port = self._switch_port(self.DUMMY_OFFSET)
self.dummy = self.runner.add_host(dummy_name, port=dummy_port)
dummy = self.dummy
LOGGER.info("Added dummy target %s on port %d at %s", dummy_name,
dummy_port, dummy.IP())
self.fake_target = self.TEST_IP_FORMAT % self.port_set
self.host_intf = self.runner.get_host_interface(host)
LOGGER.debug('Adding fake target at %s to %s', self.fake_target,
self.host_intf)
host.cmd('ip addr add %s dev %s' % (self.fake_target, self.host_intf))
self._startup_scan(host)
# Dummy doesn't use DHCP, so need to set default route manually.
dummy.cmd('route add -net 0.0.0.0 gw %s' % host.IP())
log_file = os.path.join(self.tmpdir, 'dhcp_monitor.txt')
self.dhcp_monitor = dhcp_monitor.DhcpMonitor(self.runner, host,
self._dhcp_callback,
log_file)
self.dhcp_monitor.start()
ping_retry = self._PING_RETRY_COUNT
while not self._ping_test(host, dummy) and ping_retry:
ping_retry -= 1
LOGGER.info('Gateway %s warmup ping failed at %s', host_name,
datetime.datetime.now())
assert self._ping_test(host, dummy), 'dummy ping failed'
assert self._ping_test(dummy, host), 'host ping failed'
assert self._ping_test(dummy, self.fake_target), 'fake ping failed'
assert self._ping_test(
host, dummy, src_addr=self.fake_target), 'reverse ping failed'
self.host = host
def start(self, port, params, callback):
"""Start the docker test"""
LOGGER.debug('Target port %d running test %s', self.target_port,
self.test_name)
self.callback = callback
env_vars = [
"TARGET_NAME=" + self.host_name,
"TARGET_IP=" + params['target_ip'],
"TARGET_MAC=" + params['target_mac'],
"GATEWAY_IP=" + params['gateway_ip'],
"GATEWAY_MAC=" + params['gateway_mac']
]
vol_maps = [params['scan_base'] + ":/scans"]
image = self.IMAGE_NAME_FORMAT % self.test_name
LOGGER.debug("Target port %d running docker test %s", self.target_port,
image)
cls = docker_host.make_docker_host(image, prefix=self.CONTAINER_PREFIX)
host = self.runner.add_host(self.host_name,
port=port,
cls=cls,
env_vars=env_vars,
vol_maps=vol_maps,
tmpdir=self.tmpdir)
self.docker_host = host
try:
host = self.docker_host
pipe = host.activate(log_name=None)
self.docker_log = host.open_log()
self.runner.monitor_stream(self.host_name,
pipe.stdout,
copy_to=self.docker_log,
hangup=self._docker_complete,
error=self._docker_error)
except:
host.terminate()
self.runner.remove_host(host)
raise
def initialize(self):
"""Fully initialize a new host set"""
LOGGER.info('Set %d initializing...', self.port_set)
# There is a race condition here with ovs assigning ports, so wait a bit.
time.sleep(2)
shutil.rmtree(self.tmpdir, ignore_errors=True)
networking_name = 'gw%02d' % self.port_set
networking_port = self.pri_base + self.NETWORKING_OFFSET
LOGGER.debug("Adding networking host on port %d", networking_port)
cls = docker_host.make_docker_host('daq/networking',
prefix='daq',
network='bridge')
try:
self.networking = self.runner.add_host(networking_name,
port=networking_port,
cls=cls,
tmpdir=self.tmpdir)
self._create_config(self.networking.tmpdir)
self.record_result('startup')
except Exception as e:
self._state_transition(_STATE.ERROR)
self.record_result('startup', exception=e)
def start(self, port, params, callback, finish_hook):
"""Start the docker test"""
LOGGER.debug('Target port %d starting docker test %s', self.target_port, self.test_name)
self.start_time = datetime.datetime.now()
self.callback = callback
self._finish_hook = finish_hook
env_vars = self.env_vars + ["TARGET_NAME=" + self.host_name,
"TARGET_IP=" + params['target_ip'],
"TARGET_MAC=" + params['target_mac'],
"GATEWAY_IP=" + params['gateway_ip'],
"GATEWAY_MAC=" + params['gateway_mac']]
if 'local_ip' in params:
env_vars += ["LOCAL_IP=" + params['local_ip'],
"SWITCH_PORT=" + params['switch_port'],
"SWITCH_IP=" + params['switch_ip'],
"SWITCH_MODEL=" + params['switch_model']]
vol_maps = [params['scan_base'] + ":/scans"]
self._map_if_exists(vol_maps, params, 'inst')
self._map_if_exists(vol_maps, params, 'port')
self._map_if_exists(vol_maps, params, 'device')
self._map_if_exists(vol_maps, params, 'type')
image = self.IMAGE_NAME_FORMAT % self.test_name
LOGGER.debug("Target port %d running docker test %s", self.target_port, image)
cls = docker_host.make_docker_host(image, prefix=self.CONTAINER_PREFIX)
# Work around an instability in the faucet/clib/docker library, b/152520627.
if getattr(cls, 'pullImage'):
setattr(cls, 'pullImage', lambda x: True)
try:
host = self.runner.add_host(self.host_name, port=port, cls=cls, env_vars=env_vars,
vol_maps=vol_maps, tmpdir=self.tmpdir)
self.docker_host = host
except Exception as e:
# pylint: disable=no-member
raise wrappers.DaqException(e)
try:
LOGGER.debug("Target port %d activating docker test %s", self.target_port, image)
pipe = host.activate(log_name=None)
# Docker tests don't use DHCP, so manually set up DNS.
host.cmd('echo nameserver $GATEWAY_IP > /etc/resolv.conf')
self.docker_log = host.open_log()
if self._should_raise_test_exception('initialize'):
LOGGER.error('Target port %d inducing initialization failure', self.target_port)
raise Exception('induced initialization failure')
self.runner.monitor_stream(self.host_name, pipe.stdout, copy_to=self.docker_log,
hangup=self._docker_complete,
error=self._docker_error)
self.pipe = pipe
if self._should_raise_test_exception('callback'):
LOGGER.error('Target port %d will induce callback failure', self.target_port)
# Closing this now will cause error when attempting to write outoput.
self.docker_log.close()
except Exception as e:
host.terminate()
self.runner.remove_host(host)
self.docker_host = None
if self.pipe:
self.runner.monitor_forget(self.pipe.stdout)
self.pipe = None
raise e
LOGGER.info("Target port %d test %s running", self.target_port, self.test_name)
