1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
|
#!/usr/bin/env python
"""
Spice Migration test
Somewhat stressfull test of continuous migration with spice in VGA mode or QXL mode,
depends on supplying an image in IMAGE variable (if no image is supplied then
VGA mode since it will just be SeaBIOS).
Dependencies:
either qmp in python path or running with spice and qemu side by side:
qemu/QMP/qmp.py
spice/tests/migrate.py
Will create two temporary unix sockets in /tmp
Will leave a log file, migrate_test.log, in current directory.
"""
"""
uses glib event loop for timers
"""
#
# start one spiceclient, have two machines (active and target),
# and repeat:
# active wait until it's active
# active client_migrate_info
# active migrate tcp:localhost:9000
# _wait for event of quit
# active stop, active<->passive
#
# wait until it's active
# command query-status, if running good
# if not listen to events until event of running
try:
import qmp
except:
import sys
sys.path.append("../../qemu/QMP")
try:
import qmp
except:
print "can't find qmp"
raise SystemExit
import sys
from subprocess import Popen, PIPE
import os
import time
import socket
import datetime
import atexit
import argparse
import resource
import glib
def get_args():
parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('--qmp1', dest='qmp1', default='/tmp/migrate_test.1.qmp')
parser.add_argument('--qmp2', dest='qmp2', default='/tmp/migrate_test.2.qmp')
parser.add_argument('--spice_port1', dest='spice_port1', type=int, default=5911)
parser.add_argument('--spice_port2', dest='spice_port2', type=int, default=6911)
parser.add_argument('--migrate_port', dest='migrate_port', type=int, default=8000)
parser.add_argument('--client_count', dest='client_count', type=int, default=1)
parser.add_argument('--qemu', dest='qemu', default='qemu-system-x86_64')
parser.add_argument('--log_filename', dest='log_filename', default='migrate.log')
parser.add_argument('--image', dest='image', default='')
parser.add_argument('--client', dest='client', default='spicy')
parser.add_argument('--vdagent', choices=['on', 'off'], default='on')
parser.add_argument('--usbtablet', choices=['on', 'off'], default='on')
parser.add_argument('--secure', choices=['on', 'off'], default='off')
parser.add_argument('--sleep', default=20, type=float)
parser.add_argument('--glib', default=False, action='store_true')
args = parser.parse_args(sys.argv[1:])
if os.path.exists(args.qemu):
args.qemu_exec = args.qemu
else:
args.qemu_exec = os.popen("which %s" % args.qemu).read().strip()
if not os.path.exists(args.qemu_exec):
print "qemu not found (qemu = %r)" % args.qemu_exec
sys.exit(1)
orig_client = args.client
if not os.path.exists(args.client):
args.client = os.popen('which %s' % args.client).read().strip()
if not os.path.exists(args.client):
print "client %r not found" % orig_client
sys.exit(1)
print "qemu = %s" % args.qemu_exec
return args
def start_qemu(qemu_exec, image, spice_port, qmp_connection,
incoming_port=None, extra_args=[], secure=False,
debug=None, verbose=False):
incoming_args = []
if incoming_port:
incoming_args = ("-incoming tcp::%s" % incoming_port).split()
spice_params = ["disable-ticketing"]
if secure:
spice_params.extend(['tls-port=%s' % spice_port, 'x509-dir=%s' % os.getcwd()])
else:
spice_params.append("port=%s" % spice_port)
if ':' not in qmp_connection:
qmp_argument = "unix:%s,server,nowait" % qmp_connection
else:
host, port = qmp_connection.split(':')
qmp_argument = "socket:host=%s,port=%s,server,nowait" % (host, port)
args = ([qemu_exec, "--enable-kvm", "-qmp", qmp_argument,
'-spice', ','.join(spice_params)] + extra_args + incoming_args)
if os.path.exists(image):
args += ["-m", "512", "-drive",
"file=%s,index=0,media=disk,cache=unsafe" % image, "-snapshot"]
if debug:
executable = debug[0]
args = list(debug) + args
else:
executable = qemu_exec
if verbose:
print repr(args)
proc = Popen(args, executable=qemu_exec, stdin=PIPE, stdout=PIPE)
while not os.path.exists(qmp_connection):
time.sleep(0.1)
proc.qmp_connection = qmp_connection
proc.qmp = qmp.QEMUMonitorProtocol(qmp_connection)
while True:
try:
proc.qmp.connect()
break
except socket.error, err:
pass
proc.spice_port = spice_port
proc.incoming_port = incoming_port
return proc
def client_old_commandline(spice_port, secure, host_subject):
cmdline = ['-h', 'localhost']
if secure:
cmdline.extend(['-s', str(spice_port), '--host-subject', host_subject, '--ca-file',
os.path.join(os.getcwd(), 'ca-cert.pem')])
else:
cmdline.extend(['-p', str(spice_port)])
return cmdline
def client_url_commandline(spice_port, secure, host_subject):
if secure:
raise Exception("don't know how a spice:// works for secure connections")
return ['spice://localhost:%s' % (spice_port)]
def start_client(client, spice_port, secure, host_subject, verbose=False):
client = str(client)
if (client.endswith('remote-viewer')):
cmdline = client_url_commandline(spice_port, secure, host_subject)
else:
cmdline = client_old_commandline(spice_port, secure, host_subject)
cmdline = [client] + cmdline
if verbose:
print cmdline
print ' '.join(cmdline)
return Popen(cmdline, executable=client)
def _wait_active(q, active):
events = ["RESUME"] if active else ["STOP"]
while True:
try:
ret = q.cmd("query-status")
except:
# ValueError
yield 'sleep', (0.1)
continue
if ret and ret.has_key("return"):
if ret["return"]["running"] == active:
break
for e in q.get_events():
if e["event"] in events:
break
yield 'sleep', (0.5)
def _wait_for_event(q, event):
while True:
for e in q.get_events():
if e["event"] == event:
return
yield 'sleep', (0.5)
def cleanup(migrator):
print "doing cleanup"
migrator.close()
known_commands = {
'wait_active': _wait_active,
'wait_for_event': _wait_for_event
}
def blocker(it):
for cmd, args in it:
if not hasattr(args, '__len__'):
args = (args,)
if cmd in known_commands:
blocker(known_commands[cmd](*args))
elif cmd == 'sleep':
time.sleep(*args)
else:
import pdb; pdb.set_trace()
raise Exception('unhandled cmd %s' % cmd)
def glib_wrap_iter(it):
def sleep_done(*args):
glib_wrap_iter(it)
return False
try:
cmd, args = it.next()
except StopIteration:
return
if not hasattr(args, '__len__'):
args = (args,)
if cmd in known_commands:
def handle_and_continue(cmd1, args1):
it2 = known_commands[cmd1](*args1)
for cmd, args in it2:
yield cmd, args
glib_wrap_iter(it)
return glib_wrap_iter(handle_and_continue(cmd1=cmd, args1=args))
elif cmd == 'sleep':
assert(len(args) == 1)
glib.timeout_add(int(1000 * args[0]), sleep_done)
else:
raise Exception("unhandled cmd")
def test_glib_wrap_iter():
mainloop = glib.MainLoop()
def it():
t = time.time()
yield 'sleep', 0.1
t2 = time.time()
yield 'sleep', 0.3
t3 = time.time()
print ('%2.2f, %2.2f' % (t2 - t, t3 - t2))
mainloop.quit()
raise SystemExit
glib_wrap_iter(it())
mainloop.run()
class Migrator(object):
migration_count = 0
def __init__(self, log, client, qemu_exec, image, monitor_files, client_count=1,
spice_ports=[17000, 17001], migration_port=17002, vdagent=False,
usbtablet=False, secure=False, host_subject='',
extra_args=[], sound=False):
self.client = client
self.log = log
self.qemu_exec = qemu_exec
self.image = image
self.migration_port = migration_port
self.client_count = client_count
self.monitor_files = monitor_files
self.spice_ports = spice_ports
self.vdagent = vdagent
self.usbtablet = usbtablet
self.secure = secure
self.host_subject = host_subject
if self.vdagent:
extra_args.extend(['-device', 'virtio-serial',
'-chardev', 'spicevmc,name=vdagent,id=vdagent',
'-device', 'virtserialport,chardev=vdagent,name=com.redhat.spice.0'])
if self.usbtablet:
extra_args.extend(['-usb', '-device', 'usb-tablet'])
if sound:
extra_args.extend(['-device', 'intel-hda,id=sound0', '-device', 'hda-duplex,id=sound0-codec0,bus=sound0.0,cad=0'])
self.extra_args = extra_args
self.active = self.start_qemu(which=0, incoming=False)
self.target = self.start_qemu(which=1, incoming=True)
self.remove_monitor_files()
self.clients = []
def start_qemu(self, which, incoming):
kw = {}
if incoming:
kw['incoming_port'] = self.migration_port
return start_qemu(qemu_exec=self.qemu_exec, image=self.image,
spice_port=self.spice_ports[which],
qmp_connection=self.monitor_files[which],
extra_args=self.extra_args,
secure=self.secure,
**kw)
def close(self):
self.remove_monitor_files()
self.kill_qemu()
def kill_qemu(self):
for p in [self.active, self.target]:
print "killing and waiting for qemu pid %s" % p.pid
p.kill()
p.wait()
def remove_monitor_files(self):
for x in self.monitor_files:
if os.path.exists(x):
os.unlink(x)
def _iterate(self, wait_for_user_input=False):
yield 'wait_active', (self.active.qmp, True)
yield 'wait_active', (self.target.qmp, False)
if len(self.clients) == 0:
for i in range(self.client_count):
self.clients.append(start_client(client=self.client,
spice_port=self.spice_ports[0], secure=self.secure, host_subject=self.host_subject))
yield 'wait_for_event', (self.active.qmp, 'SPICE_INITIALIZED')
if wait_for_user_input:
print "waiting for Enter to start migrations"
raw_input()
migrate_info_arguments = {'protocol':'spice', 'hostname':'localhost'}
if self.secure:
migrate_info_arguments['port'] = -1
migrate_info_arguments['tls-port'] = self.target.spice_port
migrate_info_arguments['cert-subject'] = self.host_subject
else:
migrate_info_arguments['port'] = self.target.spice_port
self.active.qmp.cmd('client_migrate_info', migrate_info_arguments)
self.active.qmp.cmd('migrate', {'uri': 'tcp:localhost:%s' % self.migration_port})
yield 'wait_active', (self.active.qmp, False)
yield 'wait_active', (self.target.qmp, True)
yield 'wait_for_event', (self.target.qmp, 'SPICE_CONNECTED')
dead = self.active
dead.qmp.cmd("quit")
dead.qmp.close()
dead.wait()
new_spice_port = dead.spice_port
new_qmp_connection = dead.qmp_connection
self.log.write("# STDOUT dead %s\n" % dead.pid)
self.log.write(dead.stdout.read())
del dead
self.active = self.target
which = 0 if new_spice_port == self.spice_ports[0] else 1
self.target = self.start_qemu(which=which, incoming=True)
self.migration_count += 1
def blocking_iterate(self, wait_for_user_input=False):
blocker(self._iterate(wait_for_user_input))
def loop(self, dt):
dt = int(dt)
self.count = 0
def single():
def single_iter():
for cmd, args in self._iterate(False):
print cmd, args
yield cmd, args
self.count += 1
glib.timeout_add(dt, single)
glib_wrap_iter(single_iter())
return False
single()
def main():
args = get_args()
host_subject = None
if args.secure == 'on':
if any([not os.path.exists(f) for f in "ca-key.pem ca-cert.pem server-cert.pem server-key.pem".split()]):
os.system('./spice_make_certs.sh')
host_subject = ','.join(os.popen('openssl x509 -noout -text -in server-cert.pem | grep Subject: | cut -f 10- -d " "').read().strip().split(', '))
print "log file %s" % args.log_filename
log = open(args.log_filename, "a+")
log.write("# "+str(datetime.datetime.now())+"\n")
migrator = Migrator(client=args.client, qemu_exec=args.qemu_exec,
image=args.image, log=log, monitor_files=[args.qmp1, args.qmp2],
migration_port=args.migrate_port, spice_ports=[args.spice_port1,
args.spice_port2], client_count=args.client_count, vdagent=(args.vdagent=='on'),
usbtablet=(args.usbtablet=='on'),
secure=(args.secure=='on'), host_subject=host_subject,
extra_args = ['-vga', 'qxl', '-device', 'qxl'], sound=False)
atexit.register(cleanup, migrator)
#while True:
if args.glib:
migrator.loop(args.sleep*1000)
mainloop = glib.MainLoop()
mainloop.run()
else:
for i in xrange(50):
migrator.blocking_iterate()
print "sleeping %d seconds" % args.sleep
time.sleep(args.sleep)
if __name__ == '__main__':
# Limit core dumps to 10GB (default is no core dumps)
resource.setrlimit(resource.RLIMIT_CORE, (10*1000*1000*1000, -1))
main()
|