X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=system%2FTestNode.py;h=cdbf071b7c7a788be68c46cb9e87bc5d35390b77;hb=c8e2f4e3a327181b29521583770a6f0ff68ca6eb;hp=6bf40adc47ed62ef53729e70602b3131090ac7da;hpb=65c93a296f2e481a312e7846f518eb2eaa2fc080;p=tests.git diff --git a/system/TestNode.py b/system/TestNode.py index 6bf40ad..cdbf071 100644 --- a/system/TestNode.py +++ b/system/TestNode.py @@ -10,35 +10,39 @@ from TestSsh import TestSsh from Completer import CompleterTask class CompleterTaskNodeSsh (CompleterTask): - def __init__ (self, hostname, qemuname, local_key, command=None, boot_state="boot", expected=True, dry_run=False): - self.hostname=hostname - self.qemuname=qemuname - self.boot_state=boot_state - self.local_key=local_key - self.command=command if command is not None else "hostname;uname -a" - self.expected=expected + def __init__ (self, hostname, qemuname, local_key, command=None, + boot_state="boot", expected=True, dry_run=False): + self.hostname = hostname + self.qemuname = qemuname + self.boot_state = boot_state + self.local_key = local_key + self.command = command if command is not None else "hostname;uname -a" + self.expected = expected self.dry_run = dry_run - self.test_ssh = TestSsh (self.hostname,key=self.local_key) + self.test_ssh = TestSsh (self.hostname, key=self.local_key) def run (self, silent): command = self.test_ssh.actual_command(self.command) retcod = utils.system (command, silent=silent, dry_run=self.dry_run) - if self.expected: return retcod == 0 - else: return retcod != 0 + if self.expected: + return retcod == 0 + else: + return retcod != 0 def failure_epilogue (self): - print "Cannot reach %s in %s mode"%(self.hostname, self.boot_state) + print "Cannot reach {} in {} mode".format(self.hostname, self.boot_state) class TestNode: - def __init__ (self,test_plc,test_site,node_spec): - self.test_plc=test_plc - self.test_site=test_site - self.node_spec=node_spec + def __init__ (self, test_plc, test_site, node_spec): + self.test_plc = test_plc + self.test_site = test_site + self.node_spec = node_spec def name(self): return self.node_spec['node_fields']['hostname'] def dry_run (self): return self.test_plc.options.dry_run + @staticmethod def is_qemu_model (model): return model.find("qemu") >= 0 @@ -56,9 +60,9 @@ class TestNode: def nodedir (self): if self.is_qemu(): - return "qemu-%s"%self.name() + return "qemu-{}".format(self.name()) else: - return "real-%s"%self.name() + return "real-{}".format(self.name()) # this returns a hostname def host_box (self): @@ -84,12 +88,12 @@ class TestNode: user_spec = self.test_site.locate_user(ownername) test_user = TestUser(self.test_plc,self.test_site,user_spec) userauth = test_user.auth() - utils.header("node %s created by user %s"%(self.name(),test_user.name())) - rootauth=self.test_plc.auth_root() - server = self.test_plc.apiserver - node_id=server.AddNode(userauth, - self.test_site.site_spec['site_fields']['login_base'], - self.node_spec['node_fields']) + utils.header("node {} created by user {}".format(self.name(), test_user.name())) + rootauth = self.test_plc.auth_root() + server = self.test_plc.apiserver + node_id = server.AddNode(userauth, + self.test_site.site_spec['site_fields']['login_base'], + self.node_spec['node_fields']) server.SetNodePlainBootstrapfs(userauth, self.node_spec['node_fields']['hostname'], 'YES') @@ -107,8 +111,8 @@ class TestNode: server.UpdateNode (userauth, self.name(), self.node_spec['node_fields_nint']) interface_id = server.AddInterface (userauth, self.name(),self.node_spec['interface_fields_nint']) server.AddIpAddress (userauth, interface_id, self.node_spec['ipaddress_fields']) - route_fields=self.node_spec['route_fields'] - route_fields['interface_id']=interface_id + route_fields = self.node_spec['route_fields'] + route_fields['interface_id'] = interface_id server.AddRoute (userauth, node_id, self.node_spec['route_fields']) pass # populate network interfaces - others @@ -119,7 +123,7 @@ class TestNode: for (attribute,value) in interface['settings'].iteritems(): # locate node network interface = server.GetInterfaces(userauth,{'ip':interface['interface_fields']['ip']})[0] - interface_id=interface['interface_id'] + interface_id = interface['interface_id'] # locate or create node network attribute type try: interface_tagtype = server.GetTagTypes(userauth,{'name':attribute})[0] @@ -137,33 +141,34 @@ class TestNode: test_user = TestUser(self.test_plc,self.test_site,user_spec) auth = test_user.auth() except: - auth=self.test_plc.auth_root() + auth = self.test_plc.auth_root() self.test_plc.apiserver.DeleteNode(auth,self.name()) # Do most of the stuff locally - will be pushed on host_box - *not* the plc - later if needed def qemu_local_init(self): "all nodes : init a clean local directory for holding node-dep stuff like iso image..." - utils.system("rm -rf %s"%self.nodedir()) - utils.system("mkdir %s"%self.nodedir()) + utils.system("rm -rf {}".format(self.nodedir())) + utils.system("mkdir {}".format(self.nodedir())) if not self.is_qemu(): return True - return utils.system("rsync -v -a --exclude .svn template-qemu/ %s/"%self.nodedir())==0 + return utils.system("rsync -v -a --exclude .svn template-qemu/ {}/"\ + .format(self.nodedir())) == 0 def bootcd(self): "all nodes: invoke GetBootMedium and store result locally" - utils.header("Calling GetBootMedium for %s"%self.name()) + utils.header("Calling GetBootMedium for {}".format(self.name())) options = [] if self.is_qemu(): options.append('serial') options.append('no-hangcheck') options.append('systemd-debug') - encoded=self.test_plc.apiserver.GetBootMedium(self.test_plc.auth_root(), - self.name(), 'node-iso', '', options) + encoded = self.test_plc.apiserver.GetBootMedium(self.test_plc.auth_root(), + self.name(), 'node-iso', '', options) if (encoded == ''): raise Exception, 'GetBootmedium failed' - filename="%s/%s.iso"%(self.nodedir(),self.name()) - utils.header('Storing boot medium into %s'%filename) + filename = "{}/{}.iso".format(self.nodedir(), self.name()) + utils.header('Storing boot medium into {}'.format(filename)) if self.dry_run(): print "Dry_run: skipped writing of iso image" return True @@ -194,7 +199,7 @@ class TestNode: if self.dry_run(): print "Dry_run: skipped getting current node state" return True - state=self.test_plc.apiserver.GetNodes(self.test_plc.auth_root(), self.name(), ['boot_state'])[0]['boot_state'] + state = self.test_plc.apiserver.GetNodes(self.test_plc.auth_root(), self.name(), ['boot_state'])[0]['boot_state'] print self.name(),':',state return True @@ -202,28 +207,28 @@ class TestNode: "all nodes: compute qemu config qemu.conf and store it locally" if not self.is_qemu(): return - mac=self.node_spec['interface_fields']['mac'] - hostname=self.node_spec['node_fields']['hostname'] - ip=self.node_spec['interface_fields']['ip'] - auth=self.test_plc.auth_root() - target_arch=self.test_plc.apiserver.GetPlcRelease(auth)['build']['target-arch'] - conf_filename="%s/qemu.conf"%(self.nodedir()) + mac = self.node_spec['interface_fields']['mac'] + hostname = self.node_spec['node_fields']['hostname'] + ip = self.node_spec['interface_fields']['ip'] + auth = self.test_plc.auth_root() + target_arch = self.test_plc.apiserver.GetPlcRelease(auth)['build']['target-arch'] + conf_filename = "{}/qemu.conf".format(self.nodedir()) if self.dry_run(): print "dry_run: skipped actual storage of qemu.conf" return True - utils.header('Storing qemu config for %s in %s'%(self.name(),conf_filename)) - file=open(conf_filename,'w') - file.write('MACADDR=%s\n'%mac) - file.write('NODE_ISO=%s.iso\n'%self.name()) - file.write('HOSTNAME=%s\n'%hostname) - file.write('IP=%s\n'%ip) - file.write('TARGET_ARCH=%s\n'%target_arch) - file.close() + utils.header('Storing qemu config for {} in {}'.format(self.name(), conf_filename)) + with open(conf_filename,'w') as f: + file.write('MACADDR={}\n'.format(mac)) + file.write('NODE_ISO={}.iso\n'.format(self.name())) + file.write('HOSTNAME={}\n'.format(hostname)) + file.write('IP={}\n'.format(ip)) + file.write('TARGET_ARCH={}\n'.format(target_arch)) return True def qemu_clean (self): - utils.header("Cleaning up qemu for host %s on box %s"%(self.name(),self.test_box().hostname())) - dry_run=self.dry_run() + utils.header("Cleaning up qemu for host {} on box {}"\ + .format(self.name(),self.test_box().hostname())) + dry_run = self.dry_run() self.test_box().rmdir(self.nodedir(), dry_run=dry_run) return True @@ -232,40 +237,47 @@ class TestNode: # if relevant, push the qemu area onto the host box if self.test_box().is_local(): return True - dry_run=self.dry_run() - utils.header ("Cleaning any former sequel of %s on %s"%(self.name(),self.host_box())) - utils.header ("Transferring configuration files for node %s onto %s"%(self.name(),self.host_box())) - return self.test_box().copy(self.nodedir(),recursive=True,dry_run=dry_run)==0 + dry_run = self.dry_run() + utils.header ("Cleaning any former sequel of {} on {}"\ + .format(self.name(), self.host_box())) + utils.header ("Transferring configuration files for node {} onto {}"\ + .format(self.name(), self.host_box())) + return self.test_box().copy(self.nodedir(), recursive=True, dry_run=dry_run) == 0 def qemu_start (self): "all nodes: start the qemu instance (also runs qemu-bridge-init start)" - model=self.node_spec['node_fields']['model'] + model = self.node_spec['node_fields']['model'] #starting the Qemu nodes before if self.is_qemu(): self.start_qemu() else: - utils.header("TestNode.qemu_start : %s model %s taken as real node"%(self.name(),model)) + utils.header("TestNode.qemu_start : {} model {} taken as real node"\ + .format(self.name(), model)) return True def qemu_timestamp (self): "all nodes: start the qemu instance (also runs qemu-bridge-init start)" test_box = self.test_box() - test_box.run_in_buildname("mkdir -p %s"%self.nodedir(), dry_run=self.dry_run()) - now=int(time.time()) - return test_box.run_in_buildname("echo %d > %s/timestamp"%(now,self.nodedir()), dry_run=self.dry_run())==0 + test_box.run_in_buildname("mkdir -p {}".format(self.nodedir()), dry_run=self.dry_run()) + now = int(time.time()) + return test_box.run_in_buildname("echo {:d} > {}/timestamp"\ + .format(now, self.nodedir()), dry_run=self.dry_run()) == 0 def start_qemu (self): test_box = self.test_box() - utils.header("Starting qemu node %s on %s"%(self.name(),test_box.hostname())) + utils.header("Starting qemu node {} on {}".format(self.name(), test_box.hostname())) - test_box.run_in_buildname("%s/qemu-bridge-init start >> %s/log.txt"%(self.nodedir(),self.nodedir()), + test_box.run_in_buildname("{}/qemu-bridge-init start >> {}/log.txt"\ + .format(self.nodedir(), self.nodedir()), dry_run=self.dry_run()) # kick it off in background, as it would otherwise hang - test_box.run_in_buildname("%s/qemu-start-node 2>&1 >> %s/log.txt"%(self.nodedir(),self.nodedir())) + test_box.run_in_buildname("{}/qemu-start-node 2>&1 >> {}/log.txt"\ + .format(self.nodedir(), self.nodedir())) def list_qemu (self): - utils.header("Listing qemu for host %s on box %s"%(self.name(),self.test_box().hostname())) - command="%s/qemu-kill-node -l %s"%(self.nodedir(),self.name()) + utils.header("Listing qemu for host {} on box {}"\ + .format(self.name(), self.test_box().hostname())) + command = "{}/qemu-kill-node -l {}".format(self.nodedir(), self.name()) self.test_box().run_in_buildname(command, dry_run=self.dry_run()) return True @@ -273,16 +285,17 @@ class TestNode: #Prepare the log file before killing the nodes test_box = self.test_box() # kill the right processes - utils.header("Stopping qemu for node %s on box %s"%(self.name(),self.test_box().hostname())) - command="%s/qemu-kill-node %s"%(self.nodedir(),self.name()) + utils.header("Stopping qemu for node {} on box {}"\ + .format(self.name(), self.test_box().hostname())) + command = "{}/qemu-kill-node {}".format(self.nodedir(),self.name()) self.test_box().run_in_buildname(command, dry_run=self.dry_run()) return True def gather_qemu_logs (self): if not self.is_qemu(): return True - remote_log="%s/log.txt"%self.nodedir() - local_log="logs/node.qemu.%s.txt"%self.name() + remote_log = "{}/log.txt".format(self.nodedir()) + local_log = "logs/node.qemu.{}.txt".format(self.name()) self.test_box().test_ssh.fetch(remote_log,local_log,dry_run=self.dry_run()) def keys_clear_known_hosts (self): @@ -292,17 +305,17 @@ class TestNode: def create_test_ssh(self): # get the plc's keys for entering the node - vservername=self.test_plc.vservername + vservername = self.test_plc.vservername ### # assuming we've run testplc.fetch_keys() -### key = "keys/%(vservername)s.rsa"%locals() +### key = "keys/{vservername}.rsa".format(**locals()) # fetch_keys doesn't grab the root key anymore key = "keys/key_admin.rsa" return TestSsh(self.name(), buildname=self.buildname(), key=key) def check_hooks (self): extensions = [ 'py','pl','sh' ] - path='hooks/node' - scripts=utils.locate_hooks_scripts ('node '+self.name(), path,extensions) + path = 'hooks/node' + scripts = utils.locate_hooks_scripts ('node '+self.name(), path,extensions) overall = True for script in scripts: if not self.check_hooks_script (script): @@ -311,38 +324,41 @@ class TestNode: def check_hooks_script (self,local_script): # push the script on the node's root context - script_name=os.path.basename(local_script) - utils.header ("NODE hook %s (%s)"%(script_name,self.name())) - test_ssh=self.create_test_ssh() + script_name = os.path.basename(local_script) + utils.header ("NODE hook {} ({})".format(script_name, self.name())) + test_ssh = self.create_test_ssh() test_ssh.copy_home(local_script) if test_ssh.run("./"+script_name) != 0: - utils.header ("WARNING: node hooks check script %s FAILED (ignored)"%script_name) + utils.header ("WARNING: node hooks check script {} FAILED (ignored)"\ + .format(script_name)) #return False return True else: - utils.header ("SUCCESS: node hook %s OK"%script_name) + utils.header ("SUCCESS: node hook {} OK".format(script_name)) return True def has_libvirt (self): - test_ssh=self.create_test_ssh() - return test_ssh.run ("rpm -q --quiet libvirt-client")==0 + test_ssh = self.create_test_ssh() + return test_ssh.run ("rpm -q --quiet libvirt-client") == 0 - def _check_system_slice (self, slicename,dry_run=False): - sitename=self.test_plc.plc_spec['settings']['PLC_SLICE_PREFIX'] - vservername="%s_%s"%(sitename,slicename) - test_ssh=self.create_test_ssh() + def _check_system_slice (self, slicename, dry_run=False): + sitename = self.test_plc.plc_spec['settings']['PLC_SLICE_PREFIX'] + vservername = "{}_{}".format(sitename, slicename) + test_ssh = self.create_test_ssh() if self.has_libvirt(): - utils.header("Checking system slice %s using virsh"%slicename) - return test_ssh.run("virsh --connect lxc:// list | grep -q ' %s '"%vservername, - dry_run=dry_run)==0 + utils.header("Checking system slice {} using virsh".format(slicename)) + return test_ssh.run("virsh --connect lxc:// list | grep -q ' {} '".format(vservername), + dry_run = dry_run) == 0 else: - (retcod,output)=utils.output_of(test_ssh.actual_command("cat /vservers/%s/etc/slicefamily 2> /dev/null")%vservername) + (retcod,output) = \ + utils.output_of(test_ssh.actual_command("cat /vservers/{}/etc/slicefamily 2> /dev/null")\ + .format(vservername)) # get last line only as ssh pollutes the output - slicefamily=output.split("\n")[-1] - utils.header("Found slicefamily '%s'for slice %s"%(slicefamily,slicename)) + slicefamily = output.split("\n")[-1] + utils.header("Found slicefamily '{}'for slice {}".format(slicefamily,slicename)) if retcod != 0: return False - utils.header("Checking system slice %s using vserver-stat"%slicename) - return test_ssh.run("vserver-stat | grep %s"%vservername,dry_run=dry_run)==0 + utils.header("Checking system slice {} using vserver-stat".format(slicename)) + return test_ssh.run("vserver-stat | grep {}".format(vservername), dry_run=dry_run) == 0