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
389
390
391
392
393
394
395
396
397
398
399
400
|
# Copyright 2015 IBM Corp.
#
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import mock
import testtools
from pypowervm.utils import validation as vldn
from pypowervm.wrappers import base_partition as bp
from pypowervm.wrappers import logical_partition as lpar
from pypowervm.wrappers import managed_system as mgd_sys
class TestValidator(testtools.TestCase):
"""Unit tests for validation."""
def setUp(self):
super(TestValidator, self).setUp()
def _bld_mgd_sys(proc_units_avail=20.0, mem_free=32768,
system_name='default_sys_name',
max_procs_per_aix_linux_lpar=10,
max_sys_procs_limit=15,
max_vcpus_per_aix_linux_lpar=10,
max_sys_vcpus_limit=15,
dynamic_srr_capable=True):
# Build a fake managed system wrapper
mngd_sys = mock.MagicMock(spec=mgd_sys.System)
mngd_sys.system_name = system_name
mngd_sys.proc_units_avail = proc_units_avail
mngd_sys.memory_free = mem_free
mngd_sys.max_procs_per_aix_linux_lpar = (
max_procs_per_aix_linux_lpar)
mngd_sys.max_sys_procs_limit = max_sys_procs_limit
mngd_sys.max_vcpus_per_aix_linux_lpar = (
max_vcpus_per_aix_linux_lpar)
mngd_sys.max_sys_vcpus_limit = max_sys_vcpus_limit
mngd_sys.get_capability.return_value = dynamic_srr_capable
return mngd_sys
def _bld_lpar(proc_units=1.0, min_mem=512, des_mem=2048, max_mem=4096,
has_dedicated=False, name='default', rmc_state='active',
mem_dlpar=True, proc_dlpar=True, state='running',
env='AIX/Linux', proc_compat='Default', srr_enabled=True,
min_vcpus=1, des_vcpus=2, max_vcpus=4,
min_proc_units=0.1, max_proc_units=1.0, pool_id=None,
exp_factor=0.0, ame_enabled=False, ppt_ratio=None):
lpar_w = mock.MagicMock()
# name, states, env, etc.
lpar_w.name = name
lpar_w.state = state
lpar_w.rmc_state = rmc_state
lpar_w.env = env
lpar_w.proc_compat_mode = proc_compat
lpar_w.srr_enabled = srr_enabled
# Proc
lpar_w.proc_config.has_dedicated = has_dedicated
if has_dedicated:
lpar_w.proc_config.dedicated_proc_cfg.desired = proc_units
lpar_w.proc_config.dedicated_proc_cfg.max = max_vcpus
lpar_w.proc_config.dedicated_proc_cfg.min = min_vcpus
else:
lpar_w.proc_config.shared_proc_cfg.desired_units = proc_units
lpar_w.proc_config.shared_proc_cfg.desired_virtual = des_vcpus
lpar_w.proc_config.shared_proc_cfg.max_virtual = max_vcpus
lpar_w.proc_config.shared_proc_cfg.min_virtual = min_vcpus
lpar_w.proc_config.shared_proc_cfg.pool_id = (
pool_id if pool_id else 0)
lpar_w.proc_config.shared_proc_cfg.min_units = min_proc_units
lpar_w.proc_config.shared_proc_cfg.max_units = max_proc_units
# Mem
lpar_w.mem_config.desired = des_mem
lpar_w.mem_config.min = min_mem
lpar_w.mem_config.max = max_mem
lpar_w.mem_config.exp_factor = exp_factor
lpar_w.mem_config.ppt_ratio = ppt_ratio
# Can Modify
if (state != bp.LPARState.NOT_ACTIVATED
and rmc_state != bp.RMCState.ACTIVE):
lpar_w.can_modify_proc.return_value = (False, 'Bad RMC')
lpar_w.can_modify_mem.return_value = (False, 'Bad RMC')
else:
# Doesn't matter what the message is unless it's bad
# so always make it bad
lpar_w.can_modify_proc.return_value = (proc_dlpar,
'Bad proc DLPAR')
lpar_w.can_modify_mem.return_value = (mem_dlpar,
'Bad mem DLPAR')
mocked = mock.MagicMock(spec_set=lpar.LPAR, return_value=lpar_w)
return mocked()
self.mngd_sys = _bld_mgd_sys()
self.mngd_sys_no_dyn_srr = _bld_mgd_sys(dynamic_srr_capable=False)
self.lpar_21_procs = _bld_lpar(proc_units=21.0, name='lpar_21_procs')
self.lpar_1_proc = _bld_lpar()
self.lpar_11_vcpus = _bld_lpar(des_vcpus=11, name='11_vcpus')
self.lpar_16_max_vcpus = _bld_lpar(max_vcpus=16, name='16_max_vcpus')
self.lpar_1_proc_ded = _bld_lpar(has_dedicated=True, name='1_proc_ded')
self.lpar_11_proc_ded = _bld_lpar(proc_units=11, has_dedicated=True,
name='11_proc_ded')
self.lpar_16_proc_max_ded = _bld_lpar(max_vcpus=16, has_dedicated=True,
name='16_proc_max_ded')
self.lpar_21_proc_ded = _bld_lpar(proc_units=21, has_dedicated=True,
name='21_proc_ded')
self.lpar_no_rmc = _bld_lpar(rmc_state='inactive')
self.lpar_bad_mem_dlpar = _bld_lpar(mem_dlpar=False)
self.lpar_bad_proc_dlpar = _bld_lpar(proc_dlpar=False)
self.lpar_48g_mem = _bld_lpar(des_mem=48000, name='lpar_48g_mem')
self.lpar_1_min_vcpus = _bld_lpar(min_vcpus=1, name='1_min_vcpus')
self.lpar_2_min_vcpus = _bld_lpar(min_vcpus=2, name='2_min_vcpus')
self.lpar_1_min_proc_units = _bld_lpar(min_proc_units=0.1,
name='0.1_min_procs')
self.lpar_3_min_proc_units = _bld_lpar(min_proc_units=0.3,
name='0.3_min_procs')
self.lpar_6_max_proc_units = _bld_lpar(max_proc_units=0.6,
name='0.6_max_procs')
self.lpar_9_max_proc_units = _bld_lpar(max_proc_units=0.9,
name='0.9_max_procs')
self.lpar_6_max_vcpus = _bld_lpar(max_vcpus=6, name='6_max_vcpus')
self.lpar_8_max_vcpus = _bld_lpar(max_vcpus=8, name='8_max_vcpus')
self.lpar_512mb_min_mem = _bld_lpar(min_mem=512, name='512_min_mem')
self.lpar_1gb_min_mem = _bld_lpar(min_mem=1024, name='1gb_min_mem')
self.lpar_6g_max_mem = _bld_lpar(max_mem=6144, name='6gb_max_mem')
self.lpar_8g_max_mem = _bld_lpar(max_mem=8192, name='8gb_max_mem')
self.lpar_default_spp = _bld_lpar(pool_id=0, name='default_spp')
self.lpar_non_default_spp = _bld_lpar(pool_id=2,
name='non_default_spp')
self.lpar_power8_proc_compat = _bld_lpar(proc_compat="POWER8",
name='power8_compat_mode')
self.lpar_srr_disabled = _bld_lpar(srr_enabled=False,
name='srr_disabled')
self.lpar_1_proc_ded_inactive = _bld_lpar(has_dedicated=True,
name='1_proc_ded_inactive',
state='not activated')
self.lpar_22_procs = _bld_lpar(proc_units=22.0, name='lpar_22_procs')
self.lpar_4_proc_ded = _bld_lpar(proc_units=4.0,
has_dedicated=True, name='4_proc_ded')
self.lpar_22_proc_ded = _bld_lpar(proc_units=22, has_dedicated=True,
name='21_proc_ded')
self.lpar_4g_mem = _bld_lpar(des_mem=4096, name='4gb_mem')
self.lpar_6g_mem = _bld_lpar(des_mem=6144, name='6gb_mem')
self.lpar_1dot6_proc_units = _bld_lpar(proc_units=1.6,
name='1.6_procs')
self.lpar_2dot2_proc_units = _bld_lpar(proc_units=2.2,
name='2.2_procs')
self.lpar_1_vcpus = _bld_lpar(des_vcpus=1, name='lpar_1_vcpus')
self.lpar_not_activated = _bld_lpar(name='lpar_not_activated',
state='not activated')
self.lpar_running = _bld_lpar(name='lpar_running', state='running')
self.lpar_starting = _bld_lpar(name='lpar_starting', state='starting')
self.lpar_ame_2 = _bld_lpar(name='ame_2', exp_factor=2.0,
ame_enabled=True)
self.lpar_ame_3 = _bld_lpar(name='ame_3', exp_factor=3.0,
ame_enabled=True)
self.lpar_ppt_1 = _bld_lpar(name='ppt_1', ppt_ratio=4)
self.lpar_ppt_2 = _bld_lpar(name='ppt_2', ppt_ratio=2)
def test_validator(self):
# Test desired proc units > host avail proc units fails for shared
vldr = vldn.LPARWrapperValidator(self.lpar_21_procs, self.mngd_sys)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test desired proc units < host avail proc units passes for shared
vldn.LPARWrapperValidator(self.lpar_1_proc,
self.mngd_sys).validate_all()
# Test desired proc units > host avail proc units fails for dedicated
vldr = vldn.LPARWrapperValidator(self.lpar_21_proc_ded, self.mngd_sys)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test desired proc units < host avail proc units passes for dedicated
vldn.LPARWrapperValidator(self.lpar_1_proc_ded,
self.mngd_sys).validate_all()
# Test resize fails with inactive rmc
vldr = vldn.LPARWrapperValidator(self.lpar_1_proc, self.mngd_sys,
cur_lpar_w=self.lpar_no_rmc)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test resize fails with no mem dlpar
vldr = vldn.LPARWrapperValidator(self.lpar_1_proc, self.mngd_sys,
cur_lpar_w=self.lpar_bad_mem_dlpar)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test resize fails with no proc dlpar
vldr = vldn.LPARWrapperValidator(self.lpar_1_proc, self.mngd_sys,
cur_lpar_w=self.lpar_bad_proc_dlpar)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test dedicated procs > host max allowed procs per lpar fails
vldr = vldn.LPARWrapperValidator(self.lpar_11_proc_ded, self.mngd_sys)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test dedicated max procs > host max sys procs limit fails
vldr = vldn.LPARWrapperValidator(self.lpar_16_proc_max_ded,
self.mngd_sys)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test shared desired vcpus > host max allowed vcpus per lpar fails
vldr = vldn.LPARWrapperValidator(self.lpar_11_vcpus, self.mngd_sys)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test shared desired max vcpus > host max sys vcpus limit fails
vldr = vldn.LPARWrapperValidator(self.lpar_16_max_vcpus, self.mngd_sys)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test desired memory > host available memory fails
vldr = vldn.LPARWrapperValidator(self.lpar_48g_mem, self.mngd_sys)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing min vcpus fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_1_min_vcpus, self.mngd_sys,
cur_lpar_w=self.lpar_2_min_vcpus)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing max vcpus fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_8_max_vcpus, self.mngd_sys,
cur_lpar_w=self.lpar_6_max_vcpus)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing min proc units fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_3_min_proc_units,
self.mngd_sys,
cur_lpar_w=self.lpar_1_min_proc_units)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing max proc units fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_9_max_proc_units,
self.mngd_sys,
cur_lpar_w=self.lpar_6_max_proc_units)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing min memory fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_512mb_min_mem,
self.mngd_sys,
cur_lpar_w=self.lpar_1gb_min_mem)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing max memory fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_8g_max_mem, self.mngd_sys,
cur_lpar_w=self.lpar_6g_max_mem)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing AME expansion factor from 2 to 3 fails active resize
vldr = vldn.LPARWrapperValidator(self.lpar_ame_3, self.mngd_sys,
cur_lpar_w=self.lpar_ame_2)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test toggling AME fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_ame_2, self.mngd_sys,
cur_lpar_w=self.lpar_1_proc)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing PPT ratio fails during active resize
vldr = vldn.LPARWrapperValidator(self.lpar_ppt_1, self.mngd_sys,
cur_lpar_w=self.lpar_ppt_2)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test not changing PPT ratio passes during active resize
vldr = vldn.LPARWrapperValidator(self.lpar_1_proc, self.mngd_sys,
cur_lpar_w=self.lpar_ppt_2)
vldr.validate_all()
# Test resizing lpar from defaultSPP to non-defaultSPP passes
vldr = vldn.LPARWrapperValidator(self.lpar_non_default_spp,
self.mngd_sys,
cur_lpar_w=self.lpar_default_spp)
vldr.validate_all()
# Test resizing lpar from non-defaultSPP to defaultSPP passes
vldr = vldn.LPARWrapperValidator(self.lpar_default_spp,
self.mngd_sys,
cur_lpar_w=self.lpar_non_default_spp)
vldr.validate_all()
# Test changing from dedicated to non-defaultSPP passes
vldr = vldn.LPARWrapperValidator(self.lpar_non_default_spp,
self.mngd_sys,
self.lpar_1_proc_ded_inactive)
vldr.validate_all()
# Test changing processor mode (shared -> ded) fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_1_proc_ded,
self.mngd_sys,
cur_lpar_w=self.lpar_1_proc)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing processor mode (ded to shared) fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_1_proc,
self.mngd_sys,
cur_lpar_w=self.lpar_1_proc_ded)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing processor compatibility mode fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_power8_proc_compat,
self.mngd_sys,
cur_lpar_w=self.lpar_1_proc)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test changing SRR capabilty fails for active resize
vldr = vldn.LPARWrapperValidator(self.lpar_srr_disabled,
self.mngd_sys_no_dyn_srr,
cur_lpar_w=self.lpar_1_proc)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# ...unless dynamic_srr_capable
vldr = vldn.LPARWrapperValidator(self.lpar_srr_disabled,
self.mngd_sys,
cur_lpar_w=self.lpar_1_proc)
vldr.validate_all()
# Test desired delta proc units > host avail proc units fails
# during resize (shared -> shared)
vldr = vldn.LPARWrapperValidator(self.lpar_22_procs, self.mngd_sys,
cur_lpar_w=self.lpar_1_proc)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test desired delta proc units <= host avail proc units passes
# during resize (shared -> shared)
vldn.LPARWrapperValidator(self.lpar_21_procs,
self.mngd_sys,
cur_lpar_w=self.lpar_1_proc).validate_all()
# Test desired delta proc units > host avail proc units fails
# during resize (dedicated -> dedicated)
vldr = vldn.LPARWrapperValidator(self.lpar_22_proc_ded, self.mngd_sys,
cur_lpar_w=self.lpar_1_proc_ded)
self.assertRaises(vldn.ValidatorException, vldr.validate_all)
# Test desired delta proc units <= host avail proc units passes
# during resize (dedicated -> dedicated)
vldn.LPARWrapperValidator(self.lpar_4_proc_ded,
self.mngd_sys,
self.lpar_1_proc_ded).validate_all()
# Test resize delta mem
mem_vldr = vldn.MemValidator(self.lpar_6g_mem, self.mngd_sys,
cur_lpar_w=self.lpar_4g_mem)
mem_vldr._populate_new_values()
mem_vldr._populate_resize_diffs()
self.assertEqual(2048, mem_vldr.delta_des_mem,
'Incorrect resize delta memory calculation')
# Test resize delta procs
proc_vldr = vldn.ProcValidator(self.lpar_4_proc_ded, self.mngd_sys,
cur_lpar_w=self.lpar_1_proc_ded)
proc_vldr._populate_new_values()
proc_vldr._populate_resize_diffs()
self.assertEqual(3, proc_vldr.delta_des_vcpus,
'Incorrect resize delta proc calculation'
' in dedicated mode')
proc_vldr = vldn.ProcValidator(self.lpar_2dot2_proc_units,
self.mngd_sys,
cur_lpar_w=self.lpar_1dot6_proc_units)
proc_vldr._populate_new_values()
proc_vldr._populate_resize_diffs()
self.assertEqual(0.60, proc_vldr.delta_des_vcpus,
'Incorrect resize delta proc calculation in'
' shared mode')
proc_vldr = vldn.ProcValidator(self.lpar_1dot6_proc_units,
self.mngd_sys,
cur_lpar_w=self.lpar_1_proc_ded)
proc_vldr._populate_new_values()
proc_vldr._populate_resize_diffs()
self.assertEqual(0.60, proc_vldr.delta_des_vcpus,
'Incorrect delta proc calculation while resizing '
'from dedicated to shared mode')
proc_vldr = vldn.ProcValidator(self.lpar_4_proc_ded, self.mngd_sys,
cur_lpar_w=self.lpar_1dot6_proc_units)
proc_vldr._populate_new_values()
proc_vldr._populate_resize_diffs()
self.assertEqual(2.40, proc_vldr.delta_des_vcpus,
'Incorrect delta proc calculation while resizing '
'from shared to dedicated mode')
# Test resizing not activated state lpar makes inactive_resize_checks
with mock.patch('pypowervm.utils.validation.ProcValidator.'
'_validate_inactive_resize') as inactive_resize_checks:
proc_vldr = vldn.ProcValidator(self.lpar_not_activated,
self.mngd_sys,
cur_lpar_w=self.lpar_not_activated)
proc_vldr.validate()
self.assertTrue(inactive_resize_checks.called,
'Inactive resize validations not performed.')
# Test resizing running state lpar makes active_resize_checks
with mock.patch('pypowervm.utils.validation.ProcValidator.'
'_validate_active_resize') as active_resize_checks:
proc_vldr = vldn.ProcValidator(self.lpar_running, self.mngd_sys,
cur_lpar_w=self.lpar_running)
proc_vldr.validate()
self.assertTrue(active_resize_checks.called,
'Active resize validations not performed.')
# Test resizing starting state lpar makes active_resize_checks
with mock.patch('pypowervm.utils.validation.ProcValidator.'
'_validate_active_resize') as active_resize_checks:
proc_vldr = vldn.ProcValidator(self.lpar_starting, self.mngd_sys,
cur_lpar_w=self.lpar_starting)
proc_vldr.validate()
self.assertTrue(active_resize_checks.called,
'Active resize validations not performed.')
@mock.patch('pypowervm.utils.validation.ProcValidator.validate')
@mock.patch('pypowervm.utils.validation.MemValidator.validate')
def test_validator_check_dlpar(self, mem_val_validate, proc_val_validate):
vldr = vldn.LPARWrapperValidator(self.lpar_1_proc, self.mngd_sys,
cur_lpar_w=self.lpar_no_rmc)
vldr.validate_all(check_dlpar=False)
mem_val_validate.assert_called_once_with(check_dlpar=False)
proc_val_validate.assert_called_once_with(check_dlpar=False)
mem_val_validate.reset_mock()
proc_val_validate.reset_mock()
vldr = vldn.LPARWrapperValidator(self.lpar_running, self.mngd_sys,
cur_lpar_w=self.lpar_running)
vldr.validate_all()
mem_val_validate.assert_called_once_with(check_dlpar=True)
proc_val_validate.assert_called_once_with(check_dlpar=True)
|
