wintest: make expect calls case insensitive by default
[samba.git] / wintest / wintest.py
1 #!/usr/bin/env python
2
3 '''automated testing library for testing Samba against windows'''
4
5 import pexpect, subprocess
6 import sys, os, time, re
7
8 class wintest():
9     '''testing of Samba against windows VMs'''
10
11     def __init__(self):
12         self.vars = {}
13         self.list_mode = False
14         self.vms = None
15         os.putenv('PYTHONUNBUFFERED', '1')
16
17     def setvar(self, varname, value):
18         '''set a substitution variable'''
19         self.vars[varname] = value
20
21     def getvar(self, varname):
22         '''return a substitution variable'''
23         if not varname in self.vars:
24             return None
25         return self.vars[varname]
26
27     def setwinvars(self, vm, prefix='WIN'):
28         '''setup WIN_XX vars based on a vm name'''
29         for v in ['VM', 'HOSTNAME', 'USER', 'PASS', 'SNAPSHOT', 'BASEDN', 'REALM', 'DOMAIN', 'IP']:
30             vname = '%s_%s' % (vm, v)
31             if vname in self.vars:
32                 self.setvar("%s_%s" % (prefix,v), self.substitute("${%s}" % vname))
33             else:
34                 self.vars.pop("%s_%s" % (prefix,v), None)
35
36     def info(self, msg):
37         '''print some information'''
38         if not self.list_mode:
39             print(self.substitute(msg))
40
41     def load_config(self, fname):
42         '''load the config file'''
43         f = open(fname)
44         for line in f:
45             line = line.strip()
46             if len(line) == 0 or line[0] == '#':
47                 continue
48             colon = line.find(':')
49             if colon == -1:
50                 raise RuntimeError("Invalid config line '%s'" % line)
51             varname = line[0:colon].strip()
52             value   = line[colon+1:].strip()
53             self.setvar(varname, value)
54
55     def list_steps_mode(self):
56         '''put wintest in step listing mode'''
57         self.list_mode = True
58
59     def set_skip(self, skiplist):
60         '''set a list of tests to skip'''
61         self.skiplist = skiplist.split(',')
62
63     def set_vms(self, vms):
64         '''set a list of VMs to test'''
65         self.vms = vms.split(',')
66
67     def skip(self, step):
68         '''return True if we should skip a step'''
69         if self.list_mode:
70             print("\t%s" % step)
71             return True
72         return step in self.skiplist
73
74     def substitute(self, text):
75         """Substitute strings of the form ${NAME} in text, replacing
76         with substitutions from vars.
77         """
78         if isinstance(text, list):
79             ret = text[:]
80             for i in range(len(ret)):
81                 ret[i] = self.substitute(ret[i])
82             return ret
83
84         """We may have objects such as pexpect.EOF that are not strings"""
85         if not isinstance(text, str):
86             return text
87         while True:
88             var_start = text.find("${")
89             if var_start == -1:
90                 return text
91             var_end = text.find("}", var_start)
92             if var_end == -1:
93                 return text
94             var_name = text[var_start+2:var_end]
95             if not var_name in self.vars:
96                 raise RuntimeError("Unknown substitution variable ${%s}" % var_name)
97             text = text.replace("${%s}" % var_name, self.vars[var_name])
98         return text
99
100     def have_var(self, varname):
101         '''see if a variable has been set'''
102         return varname in self.vars
103
104     def have_vm(self, vmname):
105         '''see if a VM should be used'''
106         if not self.have_var(vmname + '_VM'):
107             return False
108         if self.vms is None:
109             return True
110         return vmname in self.vms
111
112     def putenv(self, key, value):
113         '''putenv with substitution'''
114         os.putenv(key, self.substitute(value))
115
116     def chdir(self, dir):
117         '''chdir with substitution'''
118         os.chdir(self.substitute(dir))
119
120     def del_files(self, dirs):
121         '''delete all files in the given directory'''
122         for d in dirs:
123             self.run_cmd("find %s -type f | xargs rm -f" % d)
124
125     def write_file(self, filename, text, mode='w'):
126         '''write to a file'''
127         f = open(self.substitute(filename), mode=mode)
128         f.write(self.substitute(text))
129         f.close()
130
131     def run_cmd(self, cmd, dir=".", show=None, output=False, checkfail=True):
132         '''run a command'''
133         cmd = self.substitute(cmd)
134         if isinstance(cmd, list):
135             self.info('$ ' + " ".join(cmd))
136         else:
137             self.info('$ ' + cmd)
138         if output:
139             return subprocess.Popen([cmd], shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=dir).communicate()[0]
140         if isinstance(cmd, list):
141             shell=False
142         else:
143             shell=True
144         if checkfail:
145             return subprocess.check_call(cmd, shell=shell, cwd=dir)
146         else:
147             return subprocess.call(cmd, shell=shell, cwd=dir)
148
149
150     def run_child(self, cmd, dir="."):
151         '''create a child and return the Popen handle to it'''
152         cwd = os.getcwd()
153         cmd = self.substitute(cmd)
154         if isinstance(cmd, list):
155             self.info('$ ' + " ".join(cmd))
156         else:
157             self.info('$ ' + cmd)
158         if isinstance(cmd, list):
159             shell=False
160         else:
161             shell=True
162         os.chdir(dir)
163         ret = subprocess.Popen(cmd, shell=shell, stderr=subprocess.STDOUT)
164         os.chdir(cwd)
165         return ret
166
167     def cmd_output(self, cmd):
168         '''return output from and command'''
169         cmd = self.substitute(cmd)
170         return self.run_cmd(cmd, output=True)
171
172     def cmd_contains(self, cmd, contains, nomatch=False, ordered=False, regex=False,
173                      casefold=False):
174         '''check that command output contains the listed strings'''
175
176         if isinstance(contains, str):
177             contains = [contains]
178
179         out = self.cmd_output(cmd)
180         self.info(out)
181         for c in self.substitute(contains):
182             if regex:
183                 m = re.search(c, out)
184                 if m is None:
185                     start = -1
186                     end = -1
187                 else:
188                     start = m.start()
189                     end = m.end()
190             elif casefold:
191                 start = out.upper().find(c.upper())
192                 end = start + len(c)
193             else:
194                 start = out.find(c)
195                 end = start + len(c)
196             if nomatch:
197                 if start != -1:
198                     raise RuntimeError("Expected to not see %s in %s" % (c, cmd))
199             else:
200                 if start == -1:
201                     raise RuntimeError("Expected to see %s in %s" % (c, cmd))
202             if ordered and start != -1:
203                 out = out[end:]
204
205     def retry_cmd(self, cmd, contains, retries=30, delay=2, wait_for_fail=False,
206                   ordered=False, regex=False, casefold=False):
207         '''retry a command a number of times'''
208         while retries > 0:
209             try:
210                 self.cmd_contains(cmd, contains, nomatch=wait_for_fail,
211                                   ordered=ordered, regex=regex, casefold=casefold)
212                 return
213             except:
214                 time.sleep(delay)
215                 retries -= 1
216                 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
217         raise RuntimeError("Failed to find %s" % contains)
218
219     def pexpect_spawn(self, cmd, timeout=60, crlf=True, casefold=True):
220         '''wrapper around pexpect spawn'''
221         cmd = self.substitute(cmd)
222         self.info("$ " + cmd)
223         ret = pexpect.spawn(cmd, logfile=sys.stdout, timeout=timeout)
224
225         def sendline_sub(line):
226             line = self.substitute(line)
227             if crlf:
228                 line = line.replace('\n', '\r\n') + '\r'
229             return ret.old_sendline(line)
230
231         def expect_sub(line, timeout=ret.timeout, casefold=casefold):
232             line = self.substitute(line)
233             if casefold:
234                 line = "(?i)" + line
235             return ret.old_expect(line, timeout=timeout)
236
237         ret.old_sendline = ret.sendline
238         ret.sendline = sendline_sub
239         ret.old_expect = ret.expect
240         ret.expect = expect_sub
241
242         return ret
243
244     def get_nameserver(self):
245         '''Get the current nameserver from /etc/resolv.conf'''
246         child = self.pexpect_spawn('cat /etc/resolv.conf', crlf=False)
247         i = child.expect(['Generated by wintest', 'nameserver'])
248         if i == 0:
249             child.expect('your original resolv.conf')
250             child.expect('nameserver')
251         child.expect('\d+.\d+.\d+.\d+')
252         return child.after
253
254     def vm_poweroff(self, vmname, checkfail=True):
255         '''power off a VM'''
256         self.setvar('VMNAME', vmname)
257         self.run_cmd("${VM_POWEROFF}", checkfail=checkfail)
258
259     def vm_reset(self, vmname):
260         '''reset a VM'''
261         self.setvar('VMNAME', vmname)
262         self.run_cmd("${VM_RESET}")
263
264     def vm_restore(self, vmname, snapshot):
265         '''restore a VM'''
266         self.setvar('VMNAME', vmname)
267         self.setvar('SNAPSHOT', snapshot)
268         self.run_cmd("${VM_RESTORE}")
269
270     def ping_wait(self, hostname):
271         '''wait for a hostname to come up on the network'''
272         hostname = self.substitute(hostname)
273         loops=10
274         while loops > 0:
275             try:
276                 self.run_cmd("ping -c 1 -w 10 %s" % hostname)
277                 break
278             except:
279                 loops = loops - 1
280         if loops == 0:
281             raise RuntimeError("Failed to ping %s" % hostname)
282         self.info("Host %s is up" % hostname)
283
284     def port_wait(self, hostname, port, retries=200, delay=3, wait_for_fail=False):
285         '''wait for a host to come up on the network'''
286         self.retry_cmd("nc -v -z -w 1 %s %u" % (hostname, port), ['succeeded'],
287                        retries=retries, delay=delay, wait_for_fail=wait_for_fail)
288
289     def run_net_time(self, child):
290         '''run net time on windows'''
291         child.sendline("net time \\\\${HOSTNAME} /set")
292         child.expect("Do you want to set the local computer")
293         child.sendline("Y")
294         child.expect("The command completed successfully")
295
296     def run_date_time(self, child, time_tuple=None):
297         '''run date and time on windows'''
298         if time_tuple is None:
299             time_tuple = time.localtime()
300         child.sendline("date")
301         child.expect("Enter the new date:")
302         i = child.expect(["dd-mm-yy", "mm-dd-yy"])
303         if i == 0:
304             child.sendline(time.strftime("%d-%m-%y", time_tuple))
305         else:
306             child.sendline(time.strftime("%m-%d-%y", time_tuple))
307         child.expect("C:")
308         child.sendline("time")
309         child.expect("Enter the new time:")
310         child.sendline(time.strftime("%H:%M:%S", time_tuple))
311         child.expect("C:")
312
313     def get_ipconfig(self, child):
314         '''get the IP configuration of the child'''
315         child.sendline("ipconfig /all")
316         child.expect('Ethernet adapter ')
317         child.expect("[\w\s]+")
318         self.setvar("WIN_NIC", child.after)
319         child.expect(['IPv4 Address', 'IP Address'])
320         child.expect('\d+.\d+.\d+.\d+')
321         self.setvar('WIN_IPV4_ADDRESS', child.after)
322         child.expect('Subnet Mask')
323         child.expect('\d+.\d+.\d+.\d+')
324         self.setvar('WIN_SUBNET_MASK', child.after)
325         child.expect('Default Gateway')
326         child.expect('\d+.\d+.\d+.\d+')
327         self.setvar('WIN_DEFAULT_GATEWAY', child.after)
328         child.expect("C:")
329
330     def run_tlntadmn(self, child):
331         '''remove the annoying telnet restrictions'''
332         child.sendline('tlntadmn config maxconn=1024')
333         child.expect("The settings were successfully updated")
334         child.expect("C:")
335
336     def disable_firewall(self, child):
337         '''remove the annoying firewall'''
338         child.sendline('netsh advfirewall set allprofiles state off')
339         i = child.expect(["Ok", "The following command was not found: advfirewall set allprofiles state off"])
340         child.expect("C:")
341         if i == 1:
342             child.sendline('netsh firewall set opmode mode = DISABLE profile = ALL')
343             i = child.expect(["Ok", "The following command was not found"])
344             if i != 0:
345                 self.info("Firewall disable failed - ignoring")
346             child.expect("C:")
347  
348     def set_dns(self, child):
349         child.sendline('netsh interface ip set dns "${WIN_NIC}" static ${INTERFACE_IP} primary')
350         i = child.expect(['C:', pexpect.EOF, pexpect.TIMEOUT], timeout=5)
351         if i > 0:
352             return True
353         else:
354             return False
355
356     def set_ip(self, child):
357         """fix the IP address to the same value it had when we
358         connected, but don't use DHCP, and force the DNS server to our
359         DNS server.  This allows DNS updates to run"""
360         self.get_ipconfig(child)
361         if self.getvar("WIN_IPV4_ADDRESS") != self.getvar("WIN_IP"):
362             raise RuntimeError("ipconfig address %s != nmblookup address %s" % (self.getvar("WIN_IPV4_ADDRESS"),
363                                                                                 self.getvar("WIN_IP")))
364         child.sendline('netsh')
365         child.expect('netsh>')
366         child.sendline('offline')
367         child.expect('netsh>')
368         child.sendline('routing ip add persistentroute dest=0.0.0.0 mask=0.0.0.0 name="${WIN_NIC}" nhop=${WIN_DEFAULT_GATEWAY}')
369         child.expect('netsh>')
370         child.sendline('interface ip set address "${WIN_NIC}" static ${WIN_IPV4_ADDRESS} ${WIN_SUBNET_MASK} ${WIN_DEFAULT_GATEWAY} 1 store=persistent')
371         i = child.expect(['The syntax supplied for this command is not valid. Check help for the correct syntax', 'netsh>', pexpect.EOF, pexpect.TIMEOUT], timeout=5)
372         if i == 0:
373             child.sendline('interface ip set address "${WIN_NIC}" static ${WIN_IPV4_ADDRESS} ${WIN_SUBNET_MASK} ${WIN_DEFAULT_GATEWAY} 1')
374             child.expect('netsh>')
375         child.sendline('commit')
376         child.sendline('online')
377         child.sendline('exit')
378
379         child.expect([pexpect.EOF, pexpect.TIMEOUT], timeout=5)
380         return True
381
382
383     def resolve_ip(self, hostname, retries=60, delay=5):
384         '''resolve an IP given a hostname, assuming NBT'''
385         while retries > 0:
386             child = self.pexpect_spawn("bin/nmblookup %s" % hostname)
387             i = child.expect(['\d+.\d+.\d+.\d+', "Lookup failed"])
388             if i == 0:
389                 return child.after
390             retries -= 1
391             time.sleep(delay)
392             self.info("retrying (retries=%u delay=%u)" % (retries, delay))
393         raise RuntimeError("Failed to resolve IP of %s" % hostname)
394
395
396     def open_telnet(self, hostname, username, password, retries=60, delay=5, set_time=False, set_ip=False,
397                     disable_firewall=True, run_tlntadmn=True):
398         '''open a telnet connection to a windows server, return the pexpect child'''
399         set_route = False
400         set_dns = False
401         if self.getvar('WIN_IP'):
402             ip = self.getvar('WIN_IP')
403         else:
404             ip = self.resolve_ip(hostname)
405             self.setvar('WIN_IP', ip)
406         while retries > 0:
407             child = self.pexpect_spawn("telnet " + ip + " -l '" + username + "'")
408             i = child.expect(["Welcome to Microsoft Telnet Service",
409                               "Denying new connections due to the limit on number of connections",
410                               "No more connections are allowed to telnet server",
411                               "Unable to connect to remote host",
412                               "No route to host",
413                               "Connection refused",
414                               pexpect.EOF])
415             if i != 0:
416                 child.close()
417                 time.sleep(delay)
418                 retries -= 1
419                 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
420                 continue
421             child.expect("password:")
422             child.sendline(password)
423             i = child.expect(["C:",
424                               "Denying new connections due to the limit on number of connections",
425                               "No more connections are allowed to telnet server",
426                               "Unable to connect to remote host",
427                               "No route to host",
428                               "Connection refused",
429                               pexpect.EOF])
430             if i != 0:
431                 child.close()
432                 time.sleep(delay)
433                 retries -= 1
434                 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
435                 continue
436             if set_dns:
437                 set_dns = False
438                 if self.set_dns(child):
439                     continue;
440             if set_route:
441                 child.sendline('route add 0.0.0.0 mask 0.0.0.0 ${WIN_DEFAULT_GATEWAY}')
442                 child.expect("C:")
443                 set_route = False
444             if set_time:
445                 self.run_date_time(child, None)
446                 set_time = False
447             if run_tlntadmn:
448                 self.run_tlntadmn(child)
449                 run_tlntadmn = False
450             if disable_firewall:
451                 self.disable_firewall(child)
452                 disable_firewall = False
453             if set_ip:
454                 set_ip = False
455                 if self.set_ip(child):
456                     set_route = True
457                     set_dns = True
458                 continue
459             return child
460         raise RuntimeError("Failed to connect with telnet")
461
462     def kinit(self, username, password):
463         '''use kinit to setup a credentials cache'''
464         self.run_cmd("kdestroy")
465         self.putenv('KRB5CCNAME', "${PREFIX}/ccache.test")
466         username = self.substitute(username)
467         s = username.split('@')
468         if len(s) > 0:
469             s[1] = s[1].upper()
470         username = '@'.join(s)
471         child = self.pexpect_spawn('kinit ' + username)
472         child.expect("Password")
473         child.sendline(password)
474         child.expect(pexpect.EOF)
475         child.close()
476         if child.exitstatus != 0:
477             raise RuntimeError("kinit failed with status %d" % child.exitstatus)
478
479     def get_domains(self):
480         '''return a dictionary of DNS domains and IPs for named.conf'''
481         ret = {}
482         for v in self.vars:
483             if v[-6:] == "_REALM":
484                 base = v[:-6]
485                 if base + '_IP' in self.vars:
486                     ret[self.vars[base + '_REALM']] = self.vars[base + '_IP']
487         return ret
488
489     def wait_reboot(self, retries=3):
490         '''wait for a VM to reboot'''
491
492         # first wait for it to shutdown
493         self.port_wait("${WIN_IP}", 139, wait_for_fail=True, delay=6)
494
495         # now wait for it to come back. If it fails to come back
496         # then try resetting it
497         while retries > 0:
498             try:
499                 self.port_wait("${WIN_IP}", 139)
500                 return
501             except:
502                 retries -= 1
503                 self.vm_reset("${WIN_VM}")
504                 self.info("retrying reboot (retries=%u)" % retries)
505         raise RuntimeError(self.substitute("VM ${WIN_VM} failed to reboot"))