source: vendor/current/wintest/wintest.py@ 1025

Last change on this file since 1025 was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 37.9 KB
Line 
1#!/usr/bin/env python
2
3'''automated testing library for testing Samba against windows'''
4
5import pexpect, subprocess
6import optparse
7import sys, os, time, re
8
9class wintest():
10 '''testing of Samba against windows VMs'''
11
12 def __init__(self):
13 self.vars = {}
14 self.list_mode = False
15 self.vms = None
16 os.environ['PYTHONUNBUFFERED'] = '1'
17 self.parser = optparse.OptionParser("wintest")
18
19 def check_prerequesites(self):
20 self.info("Checking prerequesites")
21 self.setvar('HOSTNAME', self.cmd_output("hostname -s").strip())
22 if os.getuid() != 0:
23 raise Exception("You must run this script as root")
24 self.run_cmd('ifconfig ${INTERFACE} ${INTERFACE_NET} up')
25 if self.getvar('INTERFACE_IPV6'):
26 self.run_cmd('ifconfig ${INTERFACE} inet6 del ${INTERFACE_IPV6}/64', checkfail=False)
27 self.run_cmd('ifconfig ${INTERFACE} inet6 add ${INTERFACE_IPV6}/64 up')
28
29 self.run_cmd('ifconfig ${NAMED_INTERFACE} ${NAMED_INTERFACE_NET} up')
30 if self.getvar('NAMED_INTERFACE_IPV6'):
31 self.run_cmd('ifconfig ${NAMED_INTERFACE} inet6 del ${NAMED_INTERFACE_IPV6}/64', checkfail=False)
32 self.run_cmd('ifconfig ${NAMED_INTERFACE} inet6 add ${NAMED_INTERFACE_IPV6}/64 up')
33
34 def stop_vms(self):
35 '''Shut down any existing alive VMs, so they do not collide with what we are doing'''
36 self.info('Shutting down any of our VMs already running')
37 vms = self.get_vms()
38 for v in vms:
39 self.vm_poweroff(v, checkfail=False)
40
41 def setvar(self, varname, value):
42 '''set a substitution variable'''
43 self.vars[varname] = value
44
45 def getvar(self, varname):
46 '''return a substitution variable'''
47 if not varname in self.vars:
48 return None
49 return self.vars[varname]
50
51 def setwinvars(self, vm, prefix='WIN'):
52 '''setup WIN_XX vars based on a vm name'''
53 for v in ['VM', 'HOSTNAME', 'USER', 'PASS', 'SNAPSHOT', 'REALM', 'DOMAIN', 'IP']:
54 vname = '%s_%s' % (vm, v)
55 if vname in self.vars:
56 self.setvar("%s_%s" % (prefix,v), self.substitute("${%s}" % vname))
57 else:
58 self.vars.pop("%s_%s" % (prefix,v), None)
59
60 if self.getvar("WIN_REALM"):
61 self.setvar("WIN_REALM", self.getvar("WIN_REALM").upper())
62 self.setvar("WIN_LCREALM", self.getvar("WIN_REALM").lower())
63 dnsdomain = self.getvar("WIN_REALM")
64 self.setvar("WIN_BASEDN", "DC=" + dnsdomain.replace(".", ",DC="))
65 if self.getvar("WIN_USER") is None:
66 self.setvar("WIN_USER", "administrator")
67
68 def info(self, msg):
69 '''print some information'''
70 if not self.list_mode:
71 print(self.substitute(msg))
72
73 def load_config(self, fname):
74 '''load the config file'''
75 f = open(fname)
76 for line in f:
77 line = line.strip()
78 if len(line) == 0 or line[0] == '#':
79 continue
80 colon = line.find(':')
81 if colon == -1:
82 raise RuntimeError("Invalid config line '%s'" % line)
83 varname = line[0:colon].strip()
84 value = line[colon+1:].strip()
85 self.setvar(varname, value)
86
87 def list_steps_mode(self):
88 '''put wintest in step listing mode'''
89 self.list_mode = True
90
91 def set_skip(self, skiplist):
92 '''set a list of tests to skip'''
93 self.skiplist = skiplist.split(',')
94
95 def set_vms(self, vms):
96 '''set a list of VMs to test'''
97 if vms is not None:
98 self.vms = []
99 for vm in vms.split(','):
100 vm = vm.upper()
101 self.vms.append(vm)
102
103 def skip(self, step):
104 '''return True if we should skip a step'''
105 if self.list_mode:
106 print("\t%s" % step)
107 return True
108 return step in self.skiplist
109
110 def substitute(self, text):
111 """Substitute strings of the form ${NAME} in text, replacing
112 with substitutions from vars.
113 """
114 if isinstance(text, list):
115 ret = text[:]
116 for i in range(len(ret)):
117 ret[i] = self.substitute(ret[i])
118 return ret
119
120 """We may have objects such as pexpect.EOF that are not strings"""
121 if not isinstance(text, str):
122 return text
123 while True:
124 var_start = text.find("${")
125 if var_start == -1:
126 return text
127 var_end = text.find("}", var_start)
128 if var_end == -1:
129 return text
130 var_name = text[var_start+2:var_end]
131 if not var_name in self.vars:
132 raise RuntimeError("Unknown substitution variable ${%s}" % var_name)
133 text = text.replace("${%s}" % var_name, self.vars[var_name])
134 return text
135
136 def have_var(self, varname):
137 '''see if a variable has been set'''
138 return varname in self.vars
139
140 def have_vm(self, vmname):
141 '''see if a VM should be used'''
142 if not self.have_var(vmname + '_VM'):
143 return False
144 if self.vms is None:
145 return True
146 return vmname in self.vms
147
148 def putenv(self, key, value):
149 '''putenv with substitution'''
150 os.environ[key] = self.substitute(value)
151
152 def chdir(self, dir):
153 '''chdir with substitution'''
154 os.chdir(self.substitute(dir))
155
156 def del_files(self, dirs):
157 '''delete all files in the given directory'''
158 for d in dirs:
159 self.run_cmd("find %s -type f | xargs rm -f" % d)
160
161 def write_file(self, filename, text, mode='w'):
162 '''write to a file'''
163 f = open(self.substitute(filename), mode=mode)
164 f.write(self.substitute(text))
165 f.close()
166
167 def run_cmd(self, cmd, dir=".", show=None, output=False, checkfail=True):
168 '''run a command'''
169 cmd = self.substitute(cmd)
170 if isinstance(cmd, list):
171 self.info('$ ' + " ".join(cmd))
172 else:
173 self.info('$ ' + cmd)
174 if output:
175 return subprocess.Popen([cmd], shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=dir).communicate()[0]
176 if isinstance(cmd, list):
177 shell=False
178 else:
179 shell=True
180 if checkfail:
181 return subprocess.check_call(cmd, shell=shell, cwd=dir)
182 else:
183 return subprocess.call(cmd, shell=shell, cwd=dir)
184
185
186 def run_child(self, cmd, dir="."):
187 '''create a child and return the Popen handle to it'''
188 cwd = os.getcwd()
189 cmd = self.substitute(cmd)
190 if isinstance(cmd, list):
191 self.info('$ ' + " ".join(cmd))
192 else:
193 self.info('$ ' + cmd)
194 if isinstance(cmd, list):
195 shell=False
196 else:
197 shell=True
198 os.chdir(dir)
199 ret = subprocess.Popen(cmd, shell=shell, stderr=subprocess.STDOUT)
200 os.chdir(cwd)
201 return ret
202
203 def cmd_output(self, cmd):
204 '''return output from and command'''
205 cmd = self.substitute(cmd)
206 return self.run_cmd(cmd, output=True)
207
208 def cmd_contains(self, cmd, contains, nomatch=False, ordered=False, regex=False,
209 casefold=True):
210 '''check that command output contains the listed strings'''
211
212 if isinstance(contains, str):
213 contains = [contains]
214
215 out = self.cmd_output(cmd)
216 self.info(out)
217 for c in self.substitute(contains):
218 if regex:
219 if casefold:
220 c = c.upper()
221 out = out.upper()
222 m = re.search(c, out)
223 if m is None:
224 start = -1
225 end = -1
226 else:
227 start = m.start()
228 end = m.end()
229 elif casefold:
230 start = out.upper().find(c.upper())
231 end = start + len(c)
232 else:
233 start = out.find(c)
234 end = start + len(c)
235 if nomatch:
236 if start != -1:
237 raise RuntimeError("Expected to not see %s in %s" % (c, cmd))
238 else:
239 if start == -1:
240 raise RuntimeError("Expected to see %s in %s" % (c, cmd))
241 if ordered and start != -1:
242 out = out[end:]
243
244 def retry_cmd(self, cmd, contains, retries=30, delay=2, wait_for_fail=False,
245 ordered=False, regex=False, casefold=True):
246 '''retry a command a number of times'''
247 while retries > 0:
248 try:
249 self.cmd_contains(cmd, contains, nomatch=wait_for_fail,
250 ordered=ordered, regex=regex, casefold=casefold)
251 return
252 except:
253 time.sleep(delay)
254 retries -= 1
255 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
256 raise RuntimeError("Failed to find %s" % contains)
257
258 def pexpect_spawn(self, cmd, timeout=60, crlf=True, casefold=True):
259 '''wrapper around pexpect spawn'''
260 cmd = self.substitute(cmd)
261 self.info("$ " + cmd)
262 ret = pexpect.spawn(cmd, logfile=sys.stdout, timeout=timeout)
263
264 def sendline_sub(line):
265 line = self.substitute(line)
266 if crlf:
267 line = line.replace('\n', '\r\n') + '\r'
268 return ret.old_sendline(line)
269
270 def expect_sub(line, timeout=ret.timeout, casefold=casefold):
271 line = self.substitute(line)
272 if casefold:
273 if isinstance(line, list):
274 for i in range(len(line)):
275 if isinstance(line[i], str):
276 line[i] = '(?i)' + line[i]
277 elif isinstance(line, str):
278 line = '(?i)' + line
279 return ret.old_expect(line, timeout=timeout)
280
281 ret.old_sendline = ret.sendline
282 ret.sendline = sendline_sub
283 ret.old_expect = ret.expect
284 ret.expect = expect_sub
285
286 return ret
287
288 def get_nameserver(self):
289 '''Get the current nameserver from /etc/resolv.conf'''
290 child = self.pexpect_spawn('cat /etc/resolv.conf', crlf=False)
291 i = child.expect(['Generated by wintest', 'nameserver'])
292 if i == 0:
293 child.expect('your original resolv.conf')
294 child.expect('nameserver')
295 child.expect('\d+.\d+.\d+.\d+')
296 return child.after
297
298 def rndc_cmd(self, cmd, checkfail=True):
299 '''run a rndc command'''
300 self.run_cmd("${RNDC} -c ${PREFIX}/etc/rndc.conf %s" % cmd, checkfail=checkfail)
301
302 def named_supports_gssapi_keytab(self):
303 '''see if named supports tkey-gssapi-keytab'''
304 self.write_file("${PREFIX}/named.conf.test",
305 'options { tkey-gssapi-keytab "test"; };')
306 try:
307 self.run_cmd("${NAMED_CHECKCONF} ${PREFIX}/named.conf.test")
308 except subprocess.CalledProcessError:
309 return False
310 return True
311
312 def set_nameserver(self, nameserver):
313 '''set the nameserver in resolv.conf'''
314 self.write_file("/etc/resolv.conf.wintest", '''
315# Generated by wintest, the Samba v Windows automated testing system
316nameserver %s
317
318# your original resolv.conf appears below:
319''' % self.substitute(nameserver))
320 child = self.pexpect_spawn("cat /etc/resolv.conf", crlf=False)
321 i = child.expect(['your original resolv.conf appears below:', pexpect.EOF])
322 if i == 0:
323 child.expect(pexpect.EOF)
324 contents = child.before.lstrip().replace('\r', '')
325 self.write_file('/etc/resolv.conf.wintest', contents, mode='a')
326 self.write_file('/etc/resolv.conf.wintest-bak', contents)
327 self.run_cmd("mv -f /etc/resolv.conf.wintest /etc/resolv.conf")
328 self.resolv_conf_backup = '/etc/resolv.conf.wintest-bak';
329
330 def configure_bind(self, kerberos_support=False, include=None):
331 self.chdir('${PREFIX}')
332
333 if self.getvar('NAMED_INTERFACE_IPV6'):
334 ipv6_listen = 'listen-on-v6 port 53 { ${NAMED_INTERFACE_IPV6}; };'
335 else:
336 ipv6_listen = ''
337 self.setvar('BIND_LISTEN_IPV6', ipv6_listen)
338
339 if not kerberos_support:
340 self.setvar("NAMED_TKEY_OPTION", "")
341 elif self.getvar('NAMESERVER_BACKEND') != 'SAMBA_INTERNAL':
342 if self.named_supports_gssapi_keytab():
343 self.setvar("NAMED_TKEY_OPTION",
344 'tkey-gssapi-keytab "${PREFIX}/private/dns.keytab";')
345 else:
346 self.info("LCREALM=${LCREALM}")
347 self.setvar("NAMED_TKEY_OPTION",
348 '''tkey-gssapi-credential "DNS/${LCREALM}";
349 tkey-domain "${LCREALM}";
350 ''')
351 self.putenv('KEYTAB_FILE', '${PREFIX}/private/dns.keytab')
352 self.putenv('KRB5_KTNAME', '${PREFIX}/private/dns.keytab')
353 else:
354 self.setvar("NAMED_TKEY_OPTION", "")
355
356 if include and self.getvar('NAMESERVER_BACKEND') != 'SAMBA_INTERNAL':
357 self.setvar("NAMED_INCLUDE", 'include "%s";' % include)
358 else:
359 self.setvar("NAMED_INCLUDE", '')
360
361 self.run_cmd("mkdir -p ${PREFIX}/etc")
362
363 self.write_file("etc/named.conf", '''
364options {
365 listen-on port 53 { ${NAMED_INTERFACE_IP}; };
366 ${BIND_LISTEN_IPV6}
367 directory "${PREFIX}/var/named";
368 dump-file "${PREFIX}/var/named/data/cache_dump.db";
369 pid-file "${PREFIX}/var/named/named.pid";
370 statistics-file "${PREFIX}/var/named/data/named_stats.txt";
371 memstatistics-file "${PREFIX}/var/named/data/named_mem_stats.txt";
372 allow-query { any; };
373 recursion yes;
374 ${NAMED_TKEY_OPTION}
375 max-cache-ttl 10;
376 max-ncache-ttl 10;
377
378 forward only;
379 forwarders {
380 ${DNSSERVER};
381 };
382
383};
384
385key "rndc-key" {
386 algorithm hmac-md5;
387 secret "lA/cTrno03mt5Ju17ybEYw==";
388};
389
390controls {
391 inet ${NAMED_INTERFACE_IP} port 953
392 allow { any; } keys { "rndc-key"; };
393};
394
395${NAMED_INCLUDE}
396''')
397
398 if self.getvar('NAMESERVER_BACKEND') == 'SAMBA_INTERNAL':
399 self.write_file('etc/named.conf',
400 '''
401zone "%s" IN {
402 type forward;
403 forward only;
404 forwarders {
405 %s;
406 };
407};
408''' % (self.getvar('LCREALM'), self.getvar('INTERFACE_IP')),
409 mode='a')
410
411
412 # add forwarding for the windows domains
413 domains = self.get_domains()
414
415 for d in domains:
416 self.write_file('etc/named.conf',
417 '''
418zone "%s" IN {
419 type forward;
420 forward only;
421 forwarders {
422 %s;
423 };
424};
425''' % (d, domains[d]),
426 mode='a')
427
428
429 self.write_file("etc/rndc.conf", '''
430# Start of rndc.conf
431key "rndc-key" {
432 algorithm hmac-md5;
433 secret "lA/cTrno03mt5Ju17ybEYw==";
434};
435
436options {
437 default-key "rndc-key";
438 default-server ${NAMED_INTERFACE_IP};
439 default-port 953;
440};
441''')
442
443
444 def stop_bind(self):
445 '''Stop our private BIND from listening and operating'''
446 self.rndc_cmd("stop", checkfail=False)
447 self.port_wait("${NAMED_INTERFACE_IP}", 53, wait_for_fail=True)
448
449 self.run_cmd("rm -rf var/named")
450
451
452 def start_bind(self):
453 '''restart the test environment version of bind'''
454 self.info("Restarting bind9")
455 self.chdir('${PREFIX}')
456
457 self.set_nameserver(self.getvar('NAMED_INTERFACE_IP'))
458
459 self.run_cmd("mkdir -p var/named/data")
460 self.run_cmd("chown -R ${BIND_USER} var/named")
461
462 self.bind_child = self.run_child("${BIND9} -u ${BIND_USER} -n 1 -c ${PREFIX}/etc/named.conf -g")
463
464 self.port_wait("${NAMED_INTERFACE_IP}", 53)
465 self.rndc_cmd("flush")
466
467 def restart_bind(self, kerberos_support=False, include=None):
468 self.configure_bind(kerberos_support=kerberos_support, include=include)
469 self.stop_bind()
470 self.start_bind()
471
472 def restore_resolv_conf(self):
473 '''restore the /etc/resolv.conf after testing is complete'''
474 if getattr(self, 'resolv_conf_backup', False):
475 self.info("restoring /etc/resolv.conf")
476 self.run_cmd("mv -f %s /etc/resolv.conf" % self.resolv_conf_backup)
477
478
479 def vm_poweroff(self, vmname, checkfail=True):
480 '''power off a VM'''
481 self.setvar('VMNAME', vmname)
482 self.run_cmd("${VM_POWEROFF}", checkfail=checkfail)
483
484 def vm_reset(self, vmname):
485 '''reset a VM'''
486 self.setvar('VMNAME', vmname)
487 self.run_cmd("${VM_RESET}")
488
489 def vm_restore(self, vmname, snapshot):
490 '''restore a VM'''
491 self.setvar('VMNAME', vmname)
492 self.setvar('SNAPSHOT', snapshot)
493 self.run_cmd("${VM_RESTORE}")
494
495 def ping_wait(self, hostname):
496 '''wait for a hostname to come up on the network'''
497 hostname = self.substitute(hostname)
498 loops=10
499 while loops > 0:
500 try:
501 self.run_cmd("ping -c 1 -w 10 %s" % hostname)
502 break
503 except:
504 loops = loops - 1
505 if loops == 0:
506 raise RuntimeError("Failed to ping %s" % hostname)
507 self.info("Host %s is up" % hostname)
508
509 def port_wait(self, hostname, port, retries=200, delay=3, wait_for_fail=False):
510 '''wait for a host to come up on the network'''
511
512 while retries > 0:
513 child = self.pexpect_spawn("nc -v -z -w 1 %s %u" % (hostname, port), crlf=False, timeout=1)
514 child.expect([pexpect.EOF, pexpect.TIMEOUT])
515 child.close()
516 i = child.exitstatus
517 if wait_for_fail:
518 #wait for timeout or fail
519 if i == None or i > 0:
520 return
521 else:
522 if i == 0:
523 return
524
525 time.sleep(delay)
526 retries -= 1
527 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
528
529 raise RuntimeError("gave up waiting for %s:%d" % (hostname, port))
530
531 def run_net_time(self, child):
532 '''run net time on windows'''
533 child.sendline("net time \\\\${HOSTNAME} /set")
534 child.expect("Do you want to set the local computer")
535 child.sendline("Y")
536 child.expect("The command completed successfully")
537
538 def run_date_time(self, child, time_tuple=None):
539 '''run date and time on windows'''
540 if time_tuple is None:
541 time_tuple = time.localtime()
542 child.sendline("date")
543 child.expect("Enter the new date:")
544 i = child.expect(["dd-mm-yy", "mm-dd-yy"])
545 if i == 0:
546 child.sendline(time.strftime("%d-%m-%y", time_tuple))
547 else:
548 child.sendline(time.strftime("%m-%d-%y", time_tuple))
549 child.expect("C:")
550 child.sendline("time")
551 child.expect("Enter the new time:")
552 child.sendline(time.strftime("%H:%M:%S", time_tuple))
553 child.expect("C:")
554
555 def get_ipconfig(self, child):
556 '''get the IP configuration of the child'''
557 child.sendline("ipconfig /all")
558 child.expect('Ethernet adapter ')
559 child.expect("[\w\s]+")
560 self.setvar("WIN_NIC", child.after)
561 child.expect(['IPv4 Address', 'IP Address'])
562 child.expect('\d+.\d+.\d+.\d+')
563 self.setvar('WIN_IPV4_ADDRESS', child.after)
564 child.expect('Subnet Mask')
565 child.expect('\d+.\d+.\d+.\d+')
566 self.setvar('WIN_SUBNET_MASK', child.after)
567 child.expect('Default Gateway')
568 i = child.expect(['\d+.\d+.\d+.\d+', "C:"])
569 if i == 0:
570 self.setvar('WIN_DEFAULT_GATEWAY', child.after)
571 child.expect("C:")
572
573 def get_is_dc(self, child):
574 '''check if a windows machine is a domain controller'''
575 child.sendline("dcdiag")
576 i = child.expect(["is not a [Directory Server|DC]",
577 "is not recognized as an internal or external command",
578 "Home Server = ",
579 "passed test Replications"])
580 if i == 0:
581 return False
582 if i == 1 or i == 3:
583 child.expect("C:")
584 child.sendline("net config Workstation")
585 child.expect("Workstation domain")
586 child.expect('[\S]+')
587 domain = child.after
588 i = child.expect(["Workstation Domain DNS Name", "Logon domain"])
589 '''If we get the Logon domain first, we are not in an AD domain'''
590 if i == 1:
591 return False
592 if domain.upper() == self.getvar("WIN_DOMAIN").upper():
593 return True
594
595 child.expect('[\S]+')
596 hostname = child.after
597 if hostname.upper() == self.getvar("WIN_HOSTNAME").upper():
598 return True
599
600 def set_noexpire(self, child, username):
601 """Ensure this user's password does not expire"""
602 child.sendline('wmic useraccount where name="%s" set PasswordExpires=FALSE' % username)
603 child.expect("update successful")
604 child.expect("C:")
605
606 def run_tlntadmn(self, child):
607 '''remove the annoying telnet restrictions'''
608 child.sendline('tlntadmn config maxconn=1024')
609 child.expect(["The settings were successfully updated", "Access is denied"])
610 child.expect("C:")
611
612 def disable_firewall(self, child):
613 '''remove the annoying firewall'''
614 child.sendline('netsh advfirewall set allprofiles state off')
615 i = child.expect(["Ok", "The following command was not found: advfirewall set allprofiles state off", "The requested operation requires elevation", "Access is denied"])
616 child.expect("C:")
617 if i == 1:
618 child.sendline('netsh firewall set opmode mode = DISABLE profile = ALL')
619 i = child.expect(["Ok", "The following command was not found", "Access is denied"])
620 if i != 0:
621 self.info("Firewall disable failed - ignoring")
622 child.expect("C:")
623
624 def set_dns(self, child):
625 child.sendline('netsh interface ip set dns "${WIN_NIC}" static ${NAMED_INTERFACE_IP} primary')
626 i = child.expect(['C:', pexpect.EOF, pexpect.TIMEOUT], timeout=5)
627 if i > 0:
628 return True
629 else:
630 return False
631
632 def set_ip(self, child):
633 """fix the IP address to the same value it had when we
634 connected, but don't use DHCP, and force the DNS server to our
635 DNS server. This allows DNS updates to run"""
636 self.get_ipconfig(child)
637 if self.getvar("WIN_IPV4_ADDRESS") != self.getvar("WIN_IP"):
638 raise RuntimeError("ipconfig address %s != nmblookup address %s" % (self.getvar("WIN_IPV4_ADDRESS"),
639 self.getvar("WIN_IP")))
640 child.sendline('netsh')
641 child.expect('netsh>')
642 child.sendline('offline')
643 child.expect('netsh>')
644 child.sendline('routing ip add persistentroute dest=0.0.0.0 mask=0.0.0.0 name="${WIN_NIC}" nhop=${WIN_DEFAULT_GATEWAY}')
645 child.expect('netsh>')
646 child.sendline('interface ip set address "${WIN_NIC}" static ${WIN_IPV4_ADDRESS} ${WIN_SUBNET_MASK} ${WIN_DEFAULT_GATEWAY} 1 store=persistent')
647 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)
648 if i == 0:
649 child.sendline('interface ip set address "${WIN_NIC}" static ${WIN_IPV4_ADDRESS} ${WIN_SUBNET_MASK} ${WIN_DEFAULT_GATEWAY} 1')
650 child.expect('netsh>')
651 child.sendline('commit')
652 child.sendline('online')
653 child.sendline('exit')
654
655 child.expect([pexpect.EOF, pexpect.TIMEOUT], timeout=5)
656 return True
657
658
659 def resolve_ip(self, hostname, retries=60, delay=5):
660 '''resolve an IP given a hostname, assuming NBT'''
661 while retries > 0:
662 child = self.pexpect_spawn("bin/nmblookup %s" % hostname)
663 i = 0
664 while i == 0:
665 i = child.expect(["querying", '\d+.\d+.\d+.\d+', hostname, "Lookup failed"])
666 if i == 0:
667 child.expect("\r")
668 if i == 1:
669 return child.after
670 retries -= 1
671 time.sleep(delay)
672 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
673 raise RuntimeError("Failed to resolve IP of %s" % hostname)
674
675
676 def open_telnet(self, hostname, username, password, retries=60, delay=5, set_time=False, set_ip=False,
677 disable_firewall=True, run_tlntadmn=True, set_noexpire=False):
678 '''open a telnet connection to a windows server, return the pexpect child'''
679 set_route = False
680 set_dns = False
681 set_telnetclients = True
682 start_telnet = True
683 if self.getvar('WIN_IP'):
684 ip = self.getvar('WIN_IP')
685 else:
686 ip = self.resolve_ip(hostname)
687 self.setvar('WIN_IP', ip)
688 while retries > 0:
689 child = self.pexpect_spawn("telnet " + ip + " -l '" + username + "'")
690 i = child.expect(["Welcome to Microsoft Telnet Service",
691 "Denying new connections due to the limit on number of connections",
692 "No more connections are allowed to telnet server",
693 "Unable to connect to remote host",
694 "No route to host",
695 "Connection refused",
696 pexpect.EOF])
697 if i != 0:
698 child.close()
699 time.sleep(delay)
700 retries -= 1
701 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
702 continue
703 child.expect("password:")
704 child.sendline(password)
705 i = child.expect(["C:",
706 "TelnetClients",
707 "Denying new connections due to the limit on number of connections",
708 "No more connections are allowed to telnet server",
709 "Unable to connect to remote host",
710 "No route to host",
711 "Connection refused",
712 pexpect.EOF])
713 if i == 1:
714 if set_telnetclients:
715 self.run_cmd('bin/net rpc group add TelnetClients -S $WIN_IP -U$WIN_USER%$WIN_PASS')
716 self.run_cmd('bin/net rpc group addmem TelnetClients "authenticated users" -S $WIN_IP -U$WIN_USER%$WIN_PASS')
717 child.close()
718 retries -= 1
719 set_telnetclients = False
720 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
721 continue
722 else:
723 raise RuntimeError("Failed to connect with telnet due to missing TelnetClients membership")
724
725 if i == 6:
726 # This only works if it is installed and enabled, but not started. Not entirely likely, but possible
727 self.run_cmd('bin/net rpc service start TlntSvr -S $WIN_IP -U$WIN_USER%$WIN_PASS')
728 child.close()
729 start_telnet = False
730 retries -= 1
731 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
732 continue
733
734 if i != 0:
735 child.close()
736 time.sleep(delay)
737 retries -= 1
738 self.info("retrying (retries=%u delay=%u)" % (retries, delay))
739 continue
740 if set_dns:
741 set_dns = False
742 if self.set_dns(child):
743 continue;
744 if set_route:
745 child.sendline('route add 0.0.0.0 mask 0.0.0.0 ${WIN_DEFAULT_GATEWAY}')
746 child.expect("C:")
747 set_route = False
748 if set_time:
749 self.run_date_time(child, None)
750 set_time = False
751 if run_tlntadmn:
752 self.run_tlntadmn(child)
753 run_tlntadmn = False
754 if set_noexpire:
755 self.set_noexpire(child, username)
756 set_noexpire = False
757 if disable_firewall:
758 self.disable_firewall(child)
759 disable_firewall = False
760 if set_ip:
761 set_ip = False
762 if self.set_ip(child):
763 set_route = True
764 set_dns = True
765 continue
766 return child
767 raise RuntimeError("Failed to connect with telnet")
768
769 def kinit(self, username, password):
770 '''use kinit to setup a credentials cache'''
771 self.run_cmd("kdestroy")
772 self.putenv('KRB5CCNAME', "${PREFIX}/ccache.test")
773 username = self.substitute(username)
774 s = username.split('@')
775 if len(s) > 0:
776 s[1] = s[1].upper()
777 username = '@'.join(s)
778 child = self.pexpect_spawn('kinit ' + username)
779 child.expect("Password")
780 child.sendline(password)
781 child.expect(pexpect.EOF)
782 child.close()
783 if child.exitstatus != 0:
784 raise RuntimeError("kinit failed with status %d" % child.exitstatus)
785
786 def get_domains(self):
787 '''return a dictionary of DNS domains and IPs for named.conf'''
788 ret = {}
789 for v in self.vars:
790 if v[-6:] == "_REALM":
791 base = v[:-6]
792 if base + '_IP' in self.vars:
793 ret[self.vars[base + '_REALM']] = self.vars[base + '_IP']
794 return ret
795
796 def wait_reboot(self, retries=3):
797 '''wait for a VM to reboot'''
798
799 # first wait for it to shutdown
800 self.port_wait("${WIN_IP}", 139, wait_for_fail=True, delay=6)
801
802 # now wait for it to come back. If it fails to come back
803 # then try resetting it
804 while retries > 0:
805 try:
806 self.port_wait("${WIN_IP}", 139)
807 return
808 except:
809 retries -= 1
810 self.vm_reset("${WIN_VM}")
811 self.info("retrying reboot (retries=%u)" % retries)
812 raise RuntimeError(self.substitute("VM ${WIN_VM} failed to reboot"))
813
814 def get_vms(self):
815 '''return a dictionary of all the configured VM names'''
816 ret = []
817 for v in self.vars:
818 if v[-3:] == "_VM":
819 ret.append(self.vars[v])
820 return ret
821
822
823 def run_dcpromo_as_first_dc(self, vm, func_level=None):
824 self.setwinvars(vm)
825 self.info("Configuring a windows VM ${WIN_VM} at the first DC in the domain using dcpromo")
826 child = self.open_telnet("${WIN_HOSTNAME}", "administrator", "${WIN_PASS}", set_time=True)
827 if self.get_is_dc(child):
828 return
829
830 if func_level == '2008r2':
831 self.setvar("FUNCTION_LEVEL_INT", str(4))
832 elif func_level == '2003':
833 self.setvar("FUNCTION_LEVEL_INT", str(1))
834 else:
835 self.setvar("FUNCTION_LEVEL_INT", str(0))
836
837 child = self.open_telnet("${WIN_HOSTNAME}", "administrator", "${WIN_PASS}", set_ip=True, set_noexpire=True)
838
839 """This server must therefore not yet be a directory server, so we must promote it"""
840 child.sendline("copy /Y con answers.txt")
841 child.sendline('''
842[DCInstall]
843; New forest promotion
844ReplicaOrNewDomain=Domain
845NewDomain=Forest
846NewDomainDNSName=${WIN_REALM}
847ForestLevel=${FUNCTION_LEVEL_INT}
848DomainNetbiosName=${WIN_DOMAIN}
849DomainLevel=${FUNCTION_LEVEL_INT}
850InstallDNS=Yes
851ConfirmGc=Yes
852CreateDNSDelegation=No
853DatabasePath="C:\Windows\NTDS"
854LogPath="C:\Windows\NTDS"
855SYSVOLPath="C:\Windows\SYSVOL"
856; Set SafeModeAdminPassword to the correct value prior to using the unattend file
857SafeModeAdminPassword=${WIN_PASS}
858; Run-time flags (optional)
859RebootOnCompletion=No
860
861''')
862 child.expect("copied.")
863 child.expect("C:")
864 child.expect("C:")
865 child.sendline("dcpromo /answer:answers.txt")
866 i = child.expect(["You must restart this computer", "failed", "Active Directory Domain Services was not installed", "C:", pexpect.TIMEOUT], timeout=240)
867 if i == 1 or i == 2:
868 raise Exception("dcpromo failed")
869 if i == 4: # timeout
870 child = self.open_telnet("${WIN_HOSTNAME}", "administrator", "${WIN_PASS}")
871
872 child.sendline("shutdown -r -t 0")
873 self.port_wait("${WIN_IP}", 139, wait_for_fail=True)
874 self.port_wait("${WIN_IP}", 139)
875
876 child = self.open_telnet("${WIN_HOSTNAME}", "administrator", "${WIN_PASS}")
877 # Check if we became a DC by now
878 if not self.get_is_dc(child):
879 raise Exception("dcpromo failed (and wasn't a DC even after rebooting)")
880 # Give DNS registration a kick
881 child.sendline("ipconfig /registerdns")
882
883 self.retry_cmd("host -t SRV _ldap._tcp.${WIN_REALM} ${WIN_IP}", ['has SRV record'], retries=60, delay=5 )
884
885
886 def start_winvm(self, vm):
887 '''start a Windows VM'''
888 self.setwinvars(vm)
889
890 self.info("Joining a windows box to the domain")
891 self.vm_poweroff("${WIN_VM}", checkfail=False)
892 self.vm_restore("${WIN_VM}", "${WIN_SNAPSHOT}")
893
894 def run_winjoin(self, vm, domain, username="administrator", password="${PASSWORD1}"):
895 '''join a windows box to a domain'''
896 child = self.open_telnet("${WIN_HOSTNAME}", "${WIN_USER}", "${WIN_PASS}", set_time=True, set_ip=True, set_noexpire=True)
897 retries = 5
898 while retries > 0:
899 child.sendline("ipconfig /flushdns")
900 child.expect("C:")
901 child.sendline("netdom join ${WIN_HOSTNAME} /Domain:%s /UserD:%s /PasswordD:%s" % (domain, username, password))
902 i = child.expect(["The command completed successfully",
903 "The specified domain either does not exist or could not be contacted."], timeout=120)
904 if i == 0:
905 break
906 time.sleep(10)
907 retries -= 1
908
909 child.expect("C:")
910 child.sendline("shutdown /r -t 0")
911 self.wait_reboot()
912 child = self.open_telnet("${WIN_HOSTNAME}", "${WIN_USER}", "${WIN_PASS}", set_time=True, set_ip=True)
913 child.sendline("ipconfig /registerdns")
914 child.expect("Registration of the DNS resource records for all adapters of this computer has been initiated. Any errors will be reported in the Event Viewer")
915 child.expect("C:")
916
917
918 def test_remote_smbclient(self, vm, username="${WIN_USER}", password="${WIN_PASS}", args=""):
919 '''test smbclient against remote server'''
920 self.setwinvars(vm)
921 self.info('Testing smbclient')
922 self.chdir('${PREFIX}')
923 smbclient = self.getvar("smbclient")
924 self.cmd_contains("%s --version" % (smbclient), ["${SAMBA_VERSION}"])
925 self.retry_cmd('%s -L ${WIN_HOSTNAME} -U%s%%%s %s' % (smbclient, username, password, args), ["IPC"], retries=60, delay=5)
926
927 def test_net_use(self, vm, realm, domain, username, password):
928 self.setwinvars(vm)
929 self.info('Testing net use against Samba3 member')
930 child = self.open_telnet("${WIN_HOSTNAME}", "%s\\%s" % (domain, username), password)
931 child.sendline("net use t: \\\\${HOSTNAME}.%s\\test" % realm)
932 child.expect("The command completed successfully")
933
934
935 def setup(self, testname, subdir):
936 '''setup for main tests, parsing command line'''
937 self.parser.add_option("--conf", type='string', default='', help='config file')
938 self.parser.add_option("--skip", type='string', default='', help='list of steps to skip (comma separated)')
939 self.parser.add_option("--vms", type='string', default=None, help='list of VMs to use (comma separated)')
940 self.parser.add_option("--list", action='store_true', default=False, help='list the available steps')
941 self.parser.add_option("--rebase", action='store_true', default=False, help='do a git pull --rebase')
942 self.parser.add_option("--clean", action='store_true', default=False, help='clean the tree')
943 self.parser.add_option("--prefix", type='string', default=None, help='override install prefix')
944 self.parser.add_option("--sourcetree", type='string', default=None, help='override sourcetree location')
945 self.parser.add_option("--nocleanup", action='store_true', default=False, help='disable cleanup code')
946 self.parser.add_option("--use-ntvfs", action='store_true', default=False, help='use NTVFS for the fileserver')
947 self.parser.add_option("--dns-backend", type="choice",
948 choices=["SAMBA_INTERNAL", "BIND9_FLATFILE", "BIND9_DLZ", "NONE"],
949 help="The DNS server backend. SAMBA_INTERNAL is the builtin name server (default), " \
950 "BIND9_FLATFILE uses bind9 text database to store zone information, " \
951 "BIND9_DLZ uses samba4 AD to store zone information, " \
952 "NONE skips the DNS setup entirely (not recommended)",
953 default="SAMBA_INTERNAL")
954
955 self.opts, self.args = self.parser.parse_args()
956
957 if not self.opts.conf:
958 print("Please specify a config file with --conf")
959 sys.exit(1)
960
961 # we don't need fsync safety in these tests
962 self.putenv('TDB_NO_FSYNC', '1')
963
964 self.load_config(self.opts.conf)
965
966 nameserver = self.get_nameserver()
967 if nameserver == self.getvar('NAMED_INTERFACE_IP'):
968 raise RuntimeError("old /etc/resolv.conf must not contain %s as a nameserver, this will create loops with the generated dns configuration" % nameserver)
969 self.setvar('DNSSERVER', nameserver)
970
971 self.set_skip(self.opts.skip)
972 self.set_vms(self.opts.vms)
973
974 if self.opts.list:
975 self.list_steps_mode()
976
977 if self.opts.prefix:
978 self.setvar('PREFIX', self.opts.prefix)
979
980 if self.opts.sourcetree:
981 self.setvar('SOURCETREE', self.opts.sourcetree)
982
983 if self.opts.rebase:
984 self.info('rebasing')
985 self.chdir('${SOURCETREE}')
986 self.run_cmd('git pull --rebase')
987
988 if self.opts.clean:
989 self.info('cleaning')
990 self.chdir('${SOURCETREE}/' + subdir)
991 self.run_cmd('make clean')
992
993 if self.opts.use_ntvfs:
994 self.setvar('USE_NTVFS', "--use-ntvfs")
995 else:
996 self.setvar('USE_NTVFS', "")
997
998 self.setvar('NAMESERVER_BACKEND', self.opts.dns_backend)
999
1000 self.setvar('DNS_FORWARDER', "--option=dns forwarder=%s" % nameserver)
Note: See TracBrowser for help on using the repository browser.