3882d88a005b990a2197e7ae7d4fd2e4dcbdee78
[tests.git] / qaapi / qa / tests / boot_node.py
1 #!/usr/bin/python
2
3 import os
4 import sys
5 import signal
6 import time
7 import tempfile
8 import select
9 import base64
10 import traceback
11 from Test import Test
12 from qa import utils
13 from qa.Nodes import Node, Nodes
14
15 image_types = ['node-iso', 'node-usb', 'generic-iso', 'generic-usb']
16
17 def killqemu(pid):
18     try:
19         os.kill(pid, signal.SIGKILL)
20         os.waitpid(pid,os.WNOHANG)
21     except:
22         pass
23
24 class boot_node(Test):
25     """
26     Attempts to boot the specified node using qemu. 
27     """
28
29     def state_nanny(self):
30         hostname = self.hostname
31         nodes = self.config.api.GetNodes(self.config.auth, [hostname], ['boot_state'])
32         node = nodes[0]
33         boot_state = node['boot_state']
34         if True or self.config.verbose:
35             utils.header("%(hostname)s boot_state is %(boot_state)s" % locals(), False) 
36             
37         if boot_state in ['boot']:
38             self.exit = True
39
40         if self.config.verbose:
41             if boot_state in ['boot']:
42                 utils.header("%(hostname)s correctly installed and booted" % locals(), False)
43             else:
44                 utils.header("%(hostname)s not fully booted" % locals(), False)
45         self.boot_state = boot_state
46         return self.exit
47         
48     def console_nanny(self,console_states):
49         #ready = select.select([],[self.stdout],[],1)[1]
50         output = 0
51         if True or len(ready)>0:
52             output = 1
53             retry = True
54             while retry:
55                 try:
56                     lines = self.stdout.readlines()
57                     retry = False
58                 except IOError, e:
59                     pass
60
61             #for searchstring in console_states.keys():
62             #    result = line.find(searchstring)
63                 # if result... ret = console_states[searchstring]
64             #    break
65                 # check result for whether we found it
66
67             # for now just print it out
68             for line in lines:
69                 print line
70                 utils.header(line) 
71             # should be parsing for special strings that indicate whether
72             # we've reached a particular state within the boot sequence
73
74         return output
75
76     def call(self, plc_name, hostname, image_type = 'node-iso', disk_size="17G", wait = 30):
77
78         
79         # Get this nodes configuration 
80         node = self.config.get_node(hostname)
81         # Which plc does this node talk to 
82         plc = self.config.get_plc(plc_name)
83         api = plc.config.api
84         auth = plc.config.auth
85         path = node.get_path()
86         host = node['host']
87         homedir = node['homedir']
88         tmpdir = '/usr/tmp/'
89         bootimage_filename = "%(hostname)s-bootcd.iso" % locals()
90         diskimage_filename = "%(hostname)s-hda.img" % locals() 
91         bootimage = "%(homedir)s/%(bootimage_filename)s" % locals()
92         diskimage = "%(homedir)s/%(diskimage_filename)s" % locals() 
93         diskimage_path = "/%(path)s/%(diskimage_filename)s" % locals() 
94         bootimage_tmppath = "%(tmpdir)s/%(bootimage_filename)s" % locals()
95         bootimage_path = "%(path)s/%(bootimage_filename)s" % locals()
96         remote_bootimage_path = "%(homedir)s/%(bootimage_filename)s" % locals() 
97          
98         # wait up to 30 minutes for a node to boot and install itself correctly
99         self.hostname = hostname
100         self.totaltime = 60*60*wait
101
102         # validate hostname
103         nodes = api.GetNodes(auth, [hostname], ['hostname', 'boot_state'])
104         if not nodes:
105             raise Exception, "%s not found at plc  %s" % (hostname, plc['name'])
106         node.update(nodes[0])
107
108         # try reinstalling the node if it is in debug state
109         if node['boot_state'] in ['dbg']:
110             if self.config.verbose:
111                 utils.header("%(hostname)s is in debug state. Attempting a re-install" % locals())
112             api.UpdateNode(auth, node['node_id'], {'boot_state': 'rins'}) 
113         
114         # Create boot image
115         if self.config.verbose:
116             utils.header("Creating bootcd for %(hostname)s at %(bootimage_path)s" % locals())   
117         nodeimage = api.GetBootMedium(auth, hostname, image_type, '', ['serial'])
118         fp = open(bootimage_tmppath, 'w')
119         fp.write(base64.b64decode(nodeimage))
120         fp.close()
121
122         # Move the boot image to the nodes home directory
123         node.host_commands("mkdir -p %(homedir)s" % locals())
124         node.scp_to_host(bootimage_tmppath, "%(remote_bootimage_path)s" % locals())
125         
126         # Create a temporary disk image if it doesnt already exist or we are reinstalling
127         img_check_cmd =  "ls -ld %(diskimage)s" % locals()
128         (status, output) = node.host_commands(img_check_cmd, False)
129         if status != 0 or node['boot_state'] in ['rins', 'inst']:
130             qemu_img_cmd = "qemu-img create -f qcow2 %(diskimage)s %(disk_size)s" % locals()
131             node.host_commands(qemu_img_cmd)
132
133         
134         if self.config.verbose:
135             utils.header("Booting %(hostname)s" % locals())
136
137         # Attempt to boot this node image
138
139         # generate a temp filename to which qemu should store its pid (crappy approach)
140         tmp = tempfile.mkstemp(".pid","qemu_")
141         pidfile=tmp[1]
142         os.unlink(pidfile)
143         
144         os.close(tmp[0])
145         # boot node with ramsize memory
146         ramsize=1024
147
148         # always use the 64 bit version of qemu, as this will work on both 32 & 64 bit host kernels
149         bootcmd = "qemu-system-x86_64" 
150         # tell qemu to store its pid ina  file
151         bootcmd = bootcmd + " -pidfile %(pidfile)s " % locals()
152         # boot with ramsize memory
153         bootcmd = bootcmd + " -m %(ramsize)s" % locals()
154         # uniprocessor only
155         bootcmd = bootcmd + " -smp 1"
156         # redirect incomming tcp connections on specified port to guest node
157         if 'redir_ssh_port' in node and node['redir_ssh_port']:
158             port = node['redir_ssh_port']
159             ip = node['nodenetworks'][0]['ip']
160             bootcmd = bootcmd + " -redir tcp:%(port)s:%(ip)s:22" % locals() 
161         # no graphics support -> assume we are booting via serial console
162         bootcmd = bootcmd + " -nographic"
163         # boot from the supplied cdrom iso file
164         bootcmd = bootcmd + " -boot d"
165         bootcmd = bootcmd + " -cdrom %(bootimage)s" % locals()
166         # hard disk image to use for the node
167         bootcmd = bootcmd + " %(diskimage)s" % locals()
168         # redirect stdout, stderr to logfile
169         bootcmd = bootcmd + " 2>&1 >> %s " % (node.logfile.filename)
170         
171         # kill any old qemu processes for this node
172         pid_cmd = "ps -elfy | grep qemu | grep %(hostname)s | awk '{print$3}'" % locals()
173         (status, output) = node.host_commands(pid_cmd)
174         pids = " ".join(output.split("\n")).strip() 
175         if pids:
176             kill_cmd = "kill %(pids)s" % locals()  
177             (status, output) = node.host_commands(kill_cmd)
178         
179         time.sleep(2)
180         # Rotate node's logfile
181         node.rotate_logfile()
182         
183         # launch qemu
184         (self.stdin, self.stdout, self.stderr) = node.host_popen3(bootcmd)
185         
186         # wait for qemu to start up
187         time.sleep(5)
188         # get qemu's pid from its pidfile (crappy approach)
189         pid_cmd = "cat %(pidfile)s" % locals()
190         (staus, output)  = node.host_commands(pid_cmd)
191         self.pid = output.strip()   
192         #fp = file(pidfile)
193         #buf=fp.read()
194         #self.pid=int(buf)
195         #fp.close()
196         #os.unlink(pidfile)
197         
198         # loop until the node is either fully booted, some error
199         # occured, or we've reached our totaltime out
200         def catch(sig, frame):
201             self.totaltime = self.totaltime -1
202             utils.header("beep %d\n" %self.totaltime, False)
203             total = self.totaltime
204             if (total == 0) or \
205                    (((total % 60)==0) and self.state_nanny()):
206                 killqemu(self.pid)
207                 self.exit = True
208             else:
209                 signal.alarm(1)
210
211         try:
212             signal.signal(signal.SIGALRM, catch)
213             signal.alarm(1)
214             self.exit = False
215
216             #console_states = {"login:":1}
217             while not self.exit:
218                 pass
219                 #try:
220                 #    self.console_nanny(console_states)
221                 #except: # need a better way to catch exceptions
222                 #    traceback.print_exc()
223                 #    pass
224
225             signal.alarm(0)
226         except:
227             signal.alarm(0)
228
229         killqemu(self.pid)
230         return 1
231
232 if __name__ == '__main__':
233     args = tuple(sys.argv[1:])
234     boot_node()(*args)