def runTest(self):
super(Sysupgrade, self).runTest()
if not hasattr(self.config, "SYSUPGRADE_NEW"):
self.skipTest("no sysupgrade specified")
# output some stuff before we kill all the logs in the system, just
# to be able to review these logs later
board.sendline('logread')
board.expect(prompt, timeout=120)
board.sendline('dmesg')
board.expect(prompt)
# This test can damage flash, so to properly recover we need
# to reflash upon recovery
self.reflash = True
board.sendline('touch /etc/config/TEST')
board.expect('/etc/config/TEST')
board.expect(prompt)
board.sendline("cd /tmp")
filename = board.prepare_file(self.config.SYSUPGRADE_NEW)
new_filename = board.tftp_get_file(board.tftp_server, filename, 240)
board.sendline("sysupgrade -v /tmp/%s" % new_filename)
board.expect("Restarting system", timeout=180)
lib.common.wait_for_boot(board)
board.boot_linux()
board.wait_for_linux()
board.sendline('ls -alh /etc/config/TEST')
board.expect('/etc/config/TEST\r\n')
board.expect(prompt)
def recover(self):
if board.has_cmts:
from boardfarm.devices import provisioner
# TODO: there are more missing ones CDrouter expects
provisioner.sendline('ip route del 200.0.0.0/8 via 192.168.3.2')
provisioner.expect(prompt)
provisioner.sendline('ip route del 3.3.3.3 via 192.168.3.2')
provisioner.expect(prompt)
provisioner.sendline(
'ip route del 3001:cafe:1::/64 via 2001:dead:beef:1::2')
provisioner.expect(prompt)
provisioner.sendline(
'ip route del 3001:51a:cafe::1 via 2001:dead:beef:1::2')
provisioner.expect(prompt)
if hasattr(self, 'results'):
r = self.results.get(self.job_id)
if r.status == "running":
self.results.stop(self.job_id)
# TODO: full recovery...
for d in [wan, lan]:
d.sendline('ifconfig %s up' % d.iface_dut)
d.expect(prompt)
# make sure board is back in a sane state
board.sendcontrol('c')
board.sendline()
if 0 != board.expect([pexpect.TIMEOUT] + board.uprompt, timeout=5):
board.reset()
board.wait_for_linux()
def runTest(self):
for i in range(1000):
print(
"\nRunning iteration of ubus json-rpc system reboot nubmer %s\n"
% i)
session_id = ubus_login_session()
print("\nLogged in with sessionid = %s\n" % session_id)
ubus_system_reboot(session_id)
board.wait_for_linux()
def recover(self):
if board.has_cmts and wan.wan_cmts_provisioner:
# TODO: there are more missing ones (see above)
wan.sendline('ip route del 200.0.0.0/8 via 192.168.3.2')
wan.expect(prompt)
if hasattr(self, 'results'):
r = self.results.get(self.job_id)
if r.status == "running":
self.results.stop(self.job_id)
# TODO: full recovery...
for d in [wan,lan]:
d.sendline('ifconfig %s up' % d.iface_dut)
d.expect(prompt)
# make sure board is back in a sane state
board.sendcontrol('c')
board.sendline()
if 0 != board.expect([pexpect.TIMEOUT] + board.uprompt, timeout=5):
board.reset()
board.wait_for_linux()
def runTest(self):
if 'cdrouter_server' in self.config.board:
self.cdrouter_server = self.config.board['cdrouter_server']
elif self.config.cdrouter_server is not None:
self.cdrouter_server = self.config.cdrouter_server
if 'cdrouter_wan_iface' in self.config.board:
self.cdrouter_wan_iface = self.config.board['cdrouter_wan_iface']
else:
self.cdrouter_wan_iface = self.config.cdrouter_wan_iface
if 'cdrouter_lan_iface' in self.config.board:
self.cdrouter_lan_iface = self.config.board['cdrouter_lan_iface']
else:
self.cdrouter_lan_iface = self.config.cdrouter_lan_iface
if self.tests is None:
self.skipTest("No tests defined!")
if self.cdrouter_server is None:
self.skipTest("No cdrouter server specified")
lan.sendline('ifconfig %s down' % lan.iface_dut)
lan.expect(prompt)
if not board.has_cmts:
wan.sendline('ifconfig %s down' % wan.iface_dut)
wan.expect(prompt)
c = CDRouter(self.cdrouter_server)
try:
board.sendcontrol('c')
board.expect(prompt)
board.sendline('reboot')
board.expect('reboot: Restarting system')
except:
board.reset()
board.wait_for_linux()
board.wait_for_network()
# Add extra board specific delay
board.expect(pexpect.TIMEOUT, timeout=getattr(board, 'cdrouter_bootdelay', 0))
# If alt mac addr is specified in config, use that..
# CMTS = we route so no wan mac is used
# if we route, we need to add routes
wandutmac = None
if board.has_cmts and wan.wan_cmts_provisioner:
# TODO: there are more missing ones CDrouter expects
wan.sendline('ip route add 200.0.0.0/8 via 192.168.3.2')
wan.expect(prompt)
elif not wan.static_ip:
for device in self.config.board['devices']:
if device['name'] == 'wan':
if 'alt_macaddr' in device:
wandutmac = device['alt_macaddr']
break
# Otherwise grab this from the device interface
if wandutmac is None:
board.sendline('ifconfig %s' % board.wan_iface)
board.expect('([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})')
wandutmac = board.match.group()
board.expect(prompt)
print("Using %s for WAN mac address" % wandutmac)
lan.vlan = wan.vlan = 0
for device in self.config.board['devices']:
d = None
if device['name'] == 'wan':
d = wan
elif device['name'] == 'lan':
d = lan
else:
continue
if d is not None:
d.vlan = getattr(device, 'vlan', 0)
if d.vlan == 0:
d.sendline('cat /proc/net/vlan/config')
d.expect_exact('cat /proc/net/vlan/config')
if 0 == d.expect([pexpect.TIMEOUT, '%s.*\|\s([0-9]+).*\|' % d.iface_dut], timeout=5):
d.vlan = 0
else:
d.vlan = d.match.group(1)
d.expect(prompt)
print("Using %s for WAN vlan" % wan.vlan)
print("Using %s for LAN vlan" % lan.vlan)
# TODO: move wan and lan interface to bft config?
contents="""
testvar wanInterface """ + self.cdrouter_wan_iface
if wandutmac is not None:
contents=contents +"""
testvar wanDutMac """ + wandutmac
if wan.vlan != 0:
contents=contents + """
testvar wanVlanId """ + wan.vlan
contents=contents + """
testvar lanInterface """ + self.cdrouter_lan_iface
if lan.vlan != 0:
contents=contents + """
testvar lanVlanId """ + lan.vlan
def add_cdrouter_config(config):
cdr_conf = None
# TODO: make a generic helper to search path and overlays
if os.path.isfile(config):
cdr_conf = open(config, 'r').readlines()
elif 'BFT_OVERLAY' in os.environ:
for p in os.environ['BFT_OVERLAY'].split(' '):
p = os.path.realpath(p)
try:
cdr_conf = open(os.path.join(p, config), 'r').readlines()
except:
continue
else:
break
return "\n" + "".join(cdr_conf)
# Take config from overall config, but fallback to board config
if self.config.cdrouter_config is not None:
contents = contents + add_cdrouter_config(self.config.cdrouter_config)
elif board.cdrouter_config is not None:
contents = contents + add_cdrouter_config(board.cdrouter_config)
if self.extra_config:
contents=contents + "\n" + self.extra_config.replace(',', '\n')
if board.has_cmts:
for i in range(5):
try:
wan_ip = board.get_interface_ipaddr(board.erouter_iface)
except:
board.expect(pexpect.TIMEOUT, timeout=15)
continue
else:
if i == 4:
raise Exception("Failed to get erouter ip address")
break
# TODO: mask from config? wanNatIp vs. wanIspAssignGateway?
contents=contents + """
testvar wanMode static
testvar wanIspIp %s
testvar wanIspGateway %s
testvar wanIspMask 255.255.255.0
testvar wanIspAssignIp %s
testvar wanNatIp %s
testvar IPv4HopCount %s
testvar lanDnsServer %s
testvar wanDnsServer %s""" % (self.config.board['cdrouter_wanispip'], \
self.config.board['cdrouter_wanispgateway'], \
wan_ip, wan_ip, \
self.config.board['cdrouter_ipv4hopcount'], \
board.get_dns_server(), \
board.get_dns_server_upstream())
print("Using below for config:")
print(contents)
print("#######################")
config_name="bft-automated-job-%s" % str(time.time()).replace('.', '')
cfg = c.configs.create(Config(name=config_name, contents=contents))
p = c.packages.create(Package(name=config_name,
testlist=self.tests,
config_id=cfg.id))
self.start_time = time.time()
j = c.jobs.launch(Job(package_id=p.id))
while j.result_id is None:
if (time.time() - self.start_time) > 300:
# delete job if it fails to start
c.jobs.delete(j.id)
raise Exception("Failed to start CDrouter job")
board.expect(pexpect.TIMEOUT, timeout=1)
j = c.jobs.get(j.id)
print('Job Result-ID: {0}'.format(j.result_id))
self.job_id = j.result_id
self.results = c.results
unpaused = False
end_of_start = False
no_more_pausing = False
while True:
r = c.results.get(j.result_id)
print(r.status)
# we are ready to go from boardfarm reset above
if r.status == "paused" and unpaused == False:
c.results.unpause(j.result_id)
unpaused = True
board.expect(pexpect.TIMEOUT, timeout=1)
c.results.pause(j.result_id, when="end-of-test")
end_of_start = True
continue
if r.status == "paused" and end_of_start == True:
end_of_start = False
# TODO: do we need this anymore? we have board specific cdrouter_bootdelay
board.expect(pexpect.TIMEOUT, timeout=60)
c.results.unpause(j.result_id)
board.expect(pexpect.TIMEOUT, timeout=1)
no_more_pausing = True
continue
if no_more_pausing and r.status == "paused":
print("Error: test is still paused")
c.results.stop(j.result_id)
break
if r.status != "running" and r.status != "paused":
break
board.expect(pexpect.TIMEOUT, timeout=5)
print(r.result)
self.result_message = r.result.encode('ascii','ignore')
# TODO: results URL?
elapsed_time = time.time() - self.start_time
print("Test took %s" % time.strftime("%H:%M:%S", time.gmtime(elapsed_time)))
summary = c.results.summary_stats(j.result_id)
self.result_message += " (Failed= %s, Passed = %s, Skipped = %s)" \
% (summary.result_breakdown.failed, \
summary.result_breakdown.passed, \
summary.result_breakdown.skipped)
for test in summary.test_summaries:
self.logged[test.name] = vars(test)
if str(test.name) not in ["start", "final"]:
from boardfarm.lib.common import TestResult
try:
grade_map = {"pass": "******", "fail": "FAIL", "skip": "SKIP"}[test.result]
tr = TestResult(test.name, grade_map, test.description)
if test.started is not None:
tr.start_time = test.started
tr.stop_time = test.started + test.duration
else:
tr.elapsed_time = test.duration
self.subtests.append(tr)
except:
continue
# TODO: handle skipped tests
try:
metric = c.results.get(j.result_id, test.name, "bandwidth")
print(vars(metric))
# TODO: decide how to export data to kibana
except:
# Not all tests have this metric, no other way?
pass
assert (r.result == "The package completed successfully")
self.recover()
def boot(self, reflash=True):
# start tftpd server on appropriate device
tftp_servers = [
x['name'] for x in self.config.board['devices']
if 'tftpd-server' in x.get('options', "")
]
tftp_device = None
# start all tftp servers for now
for tftp_server in tftp_servers:
# This is a mess, just taking the last tftpd-server?
tftp_device = getattr(self.config, tftp_server)
# start dhcp servers
for device in self.config.board['devices']:
if 'options' in device and 'no-dhcp-sever' in device['options']:
continue
if 'options' in device and 'dhcp-server' in device['options']:
getattr(self.config, device['name']).setup_dhcp_server()
if not wan and len(tftp_servers) == 0:
msg = 'No WAN Device or tftp_server defined, skipping flash.'
lib.common.test_msg(msg)
self.skipTest(msg)
# This still needs some clean up, the fall back is to assuming the
# WAN provides the tftpd server, but it's not always the case
if wan:
wan.configure(kind="wan_device", config=self.config.board)
if tftp_device is None:
tftp_device = wan
tftp_device.start_tftp_server()
prov = getattr(self.config, 'provisioner', None)
if prov is not None:
prov.tftp_device = tftp_device
board.reprovision(prov)
if hasattr(prov, 'prov_gateway'):
gw = prov.prov_gateway if wan.gw in prov.prov_network else prov.prov_ip
for nw in [
prov.cm_network, prov.mta_network, prov.open_network
]:
wan.sendline('ip route add %s via %s' % (nw, gw))
wan.expect(prompt)
# TODO: don't do this and sort out two interfaces with ipv6
wan.disable_ipv6('eth0')
if hasattr(prov, 'prov_gateway_v6'):
wan.sendline('ip -6 route add default via %s' %
str(prov.prov_gateway_v6))
wan.expect(prompt)
wan.sendline('ip route')
wan.expect(prompt)
wan.sendline('ip -6 route')
wan.expect(prompt)
if lan:
lan.configure(kind="lan_device")
# tftp_device is always None, so we can set it from config
board.tftp_server = tftp_device.ipaddr
# then these are just hard coded defaults
board.tftp_port = 22
# but are user/password used for tftp, they are likely legacy and just need to go away
board.tftp_username = "******"
board.tftp_password = "******"
board.reset()
rootfs = None
# Reflash only if at least one or more of these
# variables are set, or else there is nothing to do in u-boot
meta_interrupt = False
if self.config.META_BUILD and not board.flash_meta_booted:
meta_interrupt = True
if reflash and (meta_interrupt or self.config.ROOTFS or\
self.config.KERNEL or self.config.UBOOT):
# Break into U-Boot, set environment variables
board.wait_for_boot()
board.setup_uboot_network(tftp_device.gw)
if self.config.META_BUILD:
for attempt in range(3):
try:
board.flash_meta(self.config.META_BUILD, wan, lan)
break
except Exception as e:
print(e)
tftp_device.restart_tftp_server()
board.reset(break_into_uboot=True)
board.setup_uboot_network(tftp_device.gw)
else:
raise Exception('Error during flashing...')
if self.config.UBOOT:
board.flash_uboot(self.config.UBOOT)
if self.config.ROOTFS:
# save filename for cases where we didn't flash it
# but will use it later to load from memory
rootfs = board.flash_rootfs(self.config.ROOTFS)
if self.config.NFSROOT:
board.prepare_nfsroot(self.config.NFSROOT)
if self.config.KERNEL:
board.flash_linux(self.config.KERNEL)
# Boot from U-Boot to Linux
board.boot_linux(rootfs=rootfs, bootargs=self.config.bootargs)
if hasattr(board, "pre_boot_linux"):
board.pre_boot_linux(wan=wan, lan=lan)
board.linux_booted = True
board.wait_for_linux()
if self.config.META_BUILD and board.flash_meta_booted:
board.flash_meta(self.config.META_BUILD, wan, lan)
linux_booted_seconds_up = board.get_seconds_uptime()
# Retry setting up wan protocol
if self.config.setup_device_networking:
for i in range(2):
time.sleep(10)
try:
if "pppoe" in self.config.WAN_PROTO:
wan.turn_on_pppoe()
board.config_wan_proto(self.config.WAN_PROTO)
break
except:
print("\nFailed to check/set the router's WAN protocol.")
pass
board.wait_for_network()
board.wait_for_mounts()
# Give other daemons time to boot and settle
if self.config.setup_device_networking:
for i in range(5):
board.get_seconds_uptime()
time.sleep(5)
try:
board.sendline("passwd")
board.expect("password:"******"password")
board.expect("password:"******"password")
board.expect(prompt)
except:
print("WARNING: Unable to set root password on router.")
board.sendline('cat /proc/cmdline')
board.expect(prompt)
board.sendline('uname -a')
board.expect(prompt)
# we can't have random messsages messages
board.set_printk()
if hasattr(self.config,
'INSTALL_PKGS') and self.config.INSTALL_PKGS != "":
for pkg in self.config.INSTALL_PKGS.split(' '):
if len(pkg) > 0:
board.install_package(pkg)
if board.has_cmts:
board.check_valid_docsis_ip_networking()
# Try to verify router has stayed up (and, say, not suddenly rebooted)
end_seconds_up = board.get_seconds_uptime()
print("\nThe router has been up %s seconds." % end_seconds_up)
if self.config.setup_device_networking:
assert end_seconds_up > linux_booted_seconds_up
self.logged['boot_time'] = end_seconds_up
if board.routing and lan and self.config.setup_device_networking:
if wan is not None:
lan.start_lan_client(wan_gw=wan.gw)
else:
lan.start_lan_client()