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
|
# This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# this program; if not, write to the Free Software Foundation, Inc., 51
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Copyright Buildbot Team Members
import mock
from twisted.trial import unittest
from twisted.internet import defer, reactor, utils
from twisted.python import failure
from buildbot import config
from buildbot.test.fake import libvirt
from buildbot.test.util import compat
from buildbot.buildslave import libvirt as libvirtbuildslave
class TestLibVirtSlave(unittest.TestCase):
class ConcreteBuildSlave(libvirtbuildslave.LibVirtSlave):
pass
def setUp(self):
self.patch(libvirtbuildslave, "libvirt", libvirt)
self.conn = libvirtbuildslave.Connection("test://")
self.lvconn = self.conn.connection
def test_constructor_nolibvirt(self):
self.patch(libvirtbuildslave, "libvirt", None)
self.assertRaises(config.ConfigErrors, self.ConcreteBuildSlave,
'bot', 'pass', None, 'path', 'path')
def test_constructor_minimal(self):
bs = self.ConcreteBuildSlave('bot', 'pass', self.conn, 'path', 'otherpath')
yield bs._find_existing_deferred
self.assertEqual(bs.slavename, 'bot')
self.assertEqual(bs.password, 'pass')
self.assertEqual(bs.connection, self.conn)
self.assertEqual(bs.image, 'path')
self.assertEqual(bs.base_image, 'otherpath')
self.assertEqual(bs.keepalive_interval, 3600)
@defer.inlineCallbacks
def test_find_existing(self):
d = self.lvconn.fake_add("bot")
bs = self.ConcreteBuildSlave('bot', 'pass', self.conn, 'p', 'o')
yield bs._find_existing_deferred
self.assertEqual(bs.domain.domain, d)
self.assertEqual(bs.substantiated, True)
@defer.inlineCallbacks
def test_prepare_base_image_none(self):
self.patch(utils, "getProcessValue", mock.Mock())
utils.getProcessValue.side_effect = lambda x,y: defer.succeed(0)
bs = self.ConcreteBuildSlave('bot', 'pass', self.conn, 'p', None)
yield bs._find_existing_deferred
yield bs._prepare_base_image()
self.assertEqual(utils.getProcessValue.call_count, 0)
@defer.inlineCallbacks
def test_prepare_base_image_cheap(self):
self.patch(utils, "getProcessValue", mock.Mock())
utils.getProcessValue.side_effect = lambda x,y: defer.succeed(0)
bs = self.ConcreteBuildSlave('bot', 'pass', self.conn, 'p', 'o')
yield bs._find_existing_deferred
yield bs._prepare_base_image()
utils.getProcessValue.assert_called_with(
"qemu-img", ["create", "-b", "o", "-f", "qcow2", "p"])
@defer.inlineCallbacks
def test_prepare_base_image_full(self):
pass
self.patch(utils, "getProcessValue", mock.Mock())
utils.getProcessValue.side_effect = lambda x,y: defer.succeed(0)
bs = self.ConcreteBuildSlave('bot', 'pass', self.conn, 'p', 'o')
yield bs._find_existing_deferred
bs.cheap_copy = False
yield bs._prepare_base_image()
utils.getProcessValue.assert_called_with(
"cp", ["o", "p"])
@defer.inlineCallbacks
def test_start_instance(self):
bs = self.ConcreteBuildSlave('b', 'p', self.conn, 'p', 'o',
xml='<xml/>')
prep = mock.Mock()
prep.side_effect = lambda: defer.succeed(0)
self.patch(bs, "_prepare_base_image", prep)
yield bs._find_existing_deferred
started = yield bs.start_instance(mock.Mock())
self.assertEqual(started, True)
@compat.usesFlushLoggedErrors
@defer.inlineCallbacks
def test_start_instance_create_fails(self):
bs = self.ConcreteBuildSlave('b', 'p', self.conn, 'p', 'o',
xml='<xml/>')
prep = mock.Mock()
prep.side_effect = lambda: defer.succeed(0)
self.patch(bs, "_prepare_base_image", prep)
create = mock.Mock()
create.side_effect = lambda self : defer.fail(
failure.Failure(RuntimeError('oh noes')))
self.patch(libvirtbuildslave.Connection, 'create', create)
yield bs._find_existing_deferred
started = yield bs.start_instance(mock.Mock())
self.assertEqual(bs.domain, None)
self.assertEqual(started, False)
self.assertEqual(len(self.flushLoggedErrors(RuntimeError)), 1)
@defer.inlineCallbacks
def setup_canStartBuild(self):
bs = self.ConcreteBuildSlave('b', 'p', self.conn, 'p', 'o')
yield bs._find_existing_deferred
bs.updateLocks()
defer.returnValue(bs)
@defer.inlineCallbacks
def test_canStartBuild(self):
bs = yield self.setup_canStartBuild()
self.assertEqual(bs.canStartBuild(), True)
@defer.inlineCallbacks
def test_canStartBuild_notready(self):
"""
If a LibVirtSlave hasnt finished scanning for existing VMs then we shouldn't
start builds on it as it might create a 2nd VM when we want to reuse the existing
one.
"""
bs = yield self.setup_canStartBuild()
bs.ready = False
self.assertEqual(bs.canStartBuild(), False)
@defer.inlineCallbacks
def test_canStartBuild_domain_and_not_connected(self):
"""
If we've found that the VM this slave would instance already exists but hasnt
connected then we shouldn't start builds or we'll end up with a dupe.
"""
bs = yield self.setup_canStartBuild()
bs.domain = mock.Mock()
self.assertEqual(bs.canStartBuild(), False)
@defer.inlineCallbacks
def test_canStartBuild_domain_and_connected(self):
"""
If we've found an existing VM and it is connected then we should start builds
"""
bs = yield self.setup_canStartBuild()
bs.domain = mock.Mock()
isconnected = mock.Mock()
isconnected.return_value = True
self.patch(bs, "isConnected", isconnected)
self.assertEqual(bs.canStartBuild(), True)
class TestWorkQueue(unittest.TestCase):
def setUp(self):
self.queue = libvirtbuildslave.WorkQueue()
def delayed_success(self):
def work():
d = defer.Deferred()
reactor.callLater(0, d.callback, True)
return d
return work
def delayed_errback(self):
def work():
d = defer.Deferred()
reactor.callLater(0, d.errback,
failure.Failure(RuntimeError("Test failure")))
return d
return work
def expect_errback(self, d):
def shouldnt_get_called(f):
self.failUnlessEqual(True, False)
d.addCallback(shouldnt_get_called)
def errback(f):
#log.msg("errback called?")
pass
d.addErrback(errback)
return d
def test_handle_exceptions(self):
def work():
raise ValueError
return self.expect_errback(self.queue.execute(work))
def test_handle_immediate_errback(self):
def work():
return defer.fail(RuntimeError("Sad times"))
return self.expect_errback(self.queue.execute(work))
def test_handle_delayed_errback(self):
work = self.delayed_errback()
return self.expect_errback(self.queue.execute(work))
def test_handle_immediate_success(self):
def work():
return defer.succeed(True)
return self.queue.execute(work)
def test_handle_delayed_success(self):
work = self.delayed_success()
return self.queue.execute(work)
def test_single_pow_fires(self):
return self.queue.execute(self.delayed_success())
def test_single_pow_errors_gracefully(self):
d = self.queue.execute(self.delayed_errback())
return self.expect_errback(d)
def test_fail_doesnt_break_further_work(self):
self.expect_errback(self.queue.execute(self.delayed_errback()))
return self.queue.execute(self.delayed_success())
def test_second_pow_fires(self):
self.queue.execute(self.delayed_success())
return self.queue.execute(self.delayed_success())
def test_work(self):
# We want these deferreds to fire in order
flags = {1: False, 2: False, 3: False }
# When first deferred fires, flags[2] and flags[3] should still be false
# flags[1] shouldnt already be set, either
d1 = self.queue.execute(self.delayed_success())
def cb1(res):
self.failUnlessEqual(flags[1], False)
flags[1] = True
self.failUnlessEqual(flags[2], False)
self.failUnlessEqual(flags[3], False)
d1.addCallback(cb1)
# When second deferred fires, only flags[3] should be set
# flags[2] should definitely be False
d2 = self.queue.execute(self.delayed_success())
def cb2(res):
assert flags[2] == False
flags[2] = True
assert flags[1] == True
assert flags[3] == False
d2.addCallback(cb2)
# When third deferred fires, only flags[3] should be unset
d3 = self.queue.execute(self.delayed_success())
def cb3(res):
assert flags[3] == False
flags[3] = True
assert flags[1] == True
assert flags[2] == True
d3.addCallback(cb3)
return defer.DeferredList([d1, d2, d3], fireOnOneErrback=True)
|
