def test_host_diskpool_get_info(self, dp_info):
base.set_conf('zvm', 'disk_pool', None)
results = self.api.host_diskpool_get_info()
self.assertEqual(results['disk_total'], 0)
self.assertEqual(results['disk_available'], 0)
self.assertEqual(results['disk_used'], 0)
dp_info.ssert_not_called()
def test_guest_deploy_unpackdiskimage_failed(self, request, execute):
base.set_conf("zvm", "user_root_vdev", "0100")
userid = 'fakeuser'
image_name = 'fakeimg'
transportfiles = '/faketrans'
unpack_error = ('unpackdiskimage fakeuser start time: '
'2017-08-16-01:29:59.453\nSOURCE USER ID: "fakeuser"\n'
'DISK CHANNEL: "0100"\n'
'IMAGE FILE: "/var/lib/zvmsdk/images/fakeimg"\n\n'
'Image file compression level: 6\n'
'Deploying image to fakeuser\'s disk at channel 100.\n'
'ERROR: Unable to link fakeuser 0100 disk. '
'HCPLNM053E FAKEUSER not in CP directory\n'
'HCPDTV040E Device 260C does not exist\n'
'ERROR: Failed to connect disk: fakeuser:0100\n\n'
'IMAGE DEPLOYMENT FAILED.\n'
'A detailed trace can be found at: /var/log/zthin/'
'unpackdiskimage_trace_2017-08-16-01:29:59.453.txt\n'
'unpackdiskimage end time: 2017-08-16-01:29:59.605\n')
execute.return_value = (3, unpack_error)
self.assertRaises(exception.ZVMGuestDeployFailed,
self._smutclient.guest_deploy, userid, image_name,
transportfiles)
unpack_cmd = [
'/opt/zthin/bin/unpackdiskimage', 'fakeuser', '0100',
'/var/lib/zvmsdk/images/fakeimg'
]
execute.assert_called_once_with(unpack_cmd)
def test_get_volume_connector(self, get_fcp_info, get_host_info):
fcp_info = [
'fakehost: FCP device number: B83C', 'fakehost: Status: Free',
'fakehost: NPIV world wide port number: '
'2007123400001234', 'fakehost: Channel path ID: 59',
'fakehost: Physical world wide port number: '
'20076D8500005181'
]
get_fcp_info.return_value = fcp_info
get_host_info.return_value = {'zvm_host': 'fakehost'}
base.set_conf('volume', 'fcp_list', 'b83c')
# assign FCP
self.db_op.new('b83c', 0)
# set connections to 1 and assigner_id to b83c
self.db_op.assign('b83c', 'fakeuser')
# set reserved to 1
self.db_op.reserve('b83c')
try:
connections = self.volumeops.get_volume_connector(
'fakeuser', False)
expected = {
'zvm_fcp': ['b83c'],
'wwpns': ['2007123400001234'],
'host': 'fakehost'
}
self.assertEqual(expected, connections)
fcp_list = self.db_op.get_from_fcp('b83c')
expected = [(u'b83c', u'fakeuser', 1, 1, 0, u'')]
self.assertEqual(expected, fcp_list)
finally:
self.db_op.delete('b83c')
def test_diskpool_get_volumes(self, get_diskpool_vols, cache_enable,
mock_time):
self._hostops._volumes = {}
volumes = {'diskpool_volumes': 'IAS100 IAS101'}
get_diskpool_vols.return_value = volumes
cache_enable.return_value = True
mock_time.return_value = 1
diskpool_vols = self._hostops.diskpool_get_volumes("eckd:fakepool")
get_diskpool_vols.assert_called_once_with("FAKEPOOL")
self.assertEqual(diskpool_vols['diskpool_volumes'], 'IAS100 IAS101')
self.assertEqual(self._hostops.disk_pool, "eckd:fakepool")
# Test has cache data
volumes = {'diskpool_volumes': 'IAS400 IAS501'}
base.set_conf('monitor', 'cache_interval', '60')
self._hostops._volumes = volumes
diskpool_vols = self._hostops.diskpool_get_volumes("eckd:fakepool")
self.assertEqual(1, get_diskpool_vols.call_count)
self.assertEqual(diskpool_vols['diskpool_volumes'], 'IAS400 IAS501')
self.assertEqual(self._hostops.disk_pool, "eckd:fakepool")
# Test CONF.zvm.disk_pool has changed
volumes = {'diskpool_volumes': 'IAS401 IAS601'}
get_diskpool_vols.return_value = volumes
base.set_conf('monitor', 'cache_interval', '60')
diskpool_vols = self._hostops.diskpool_get_volumes("eckd:fakepool2")
self.assertEqual(diskpool_vols['diskpool_volumes'], 'IAS401 IAS601')
self.assertEqual(self._hostops.disk_pool, "eckd:fakepool2")
def test_guest_add_disks_no_disk_pool(self, cds):
disk_list = [{'size': '1g', 'is_boot_disk': True,
'disk_pool': 'ECKD: eckdpool1'},
{'size': '1g', 'format': 'ext3'}]
base.set_conf('zvm', 'disk_pool', None)
self.assertRaises(exception.SDKInvalidInputFormat,
self.api.guest_create_disks, self.userid, disk_list)
cds.ssert_not_called()
def test_get_namelist(self, gsu):
gsu.return_value = 'TUID'
self.assertEqual('TSTNLIST', zvmutils.get_namelist())
base.set_conf('zvm', 'namelist', None)
self.assertEqual('NL00TUID', zvmutils.get_namelist())
gsu.return_value = 'TESTUSER'
self.assertEqual('NLSTUSER', zvmutils.get_namelist())
base.set_conf('zvm', 'namelist', 'TSTNLIST')
def test_guest_create_no_disk_pool_swap_only_force_mdisk(self, create_vm):
disk_list = [{'size': '1g', 'format': 'swap'}]
vcpus = 1
memory = 1024
user_profile = 'profile'
base.set_conf('zvm', 'disk_pool', None)
base.set_conf('zvm', 'swap_force_mdisk', True)
self.assertRaises(exception.SDKInvalidInputFormat,
self.api.guest_create, self.userid, vcpus, memory,
disk_list, user_profile)
def test_guest_create_with_no_disk_pool_swap_only(self, create_vm):
disk_list = [{'size': '1g', 'format': 'swap'}]
vcpus = 1
memory = 1024
user_profile = 'profile'
base.set_conf('zvm', 'disk_pool', None)
self.api.guest_create(self.userid, vcpus, memory, disk_list,
user_profile)
create_vm.assert_called_once_with(self.userid, vcpus, memory,
disk_list, user_profile, 32, '64G',
'', '', '', [], {})
def test_guest_create_with_default_profile(self, create_vm):
vcpus = 1
memory = 1024
disk_list = []
user_profile = ''
max_cpu = 10
max_mem = '4G'
base.set_conf('zvm', 'user_profile', 'abc')
self.api.guest_create(self.userid, vcpus, memory, disk_list,
user_profile, max_cpu, max_mem)
create_vm.assert_called_once_with(self.userid, vcpus, memory,
disk_list, 'abc', max_cpu, max_mem,
'', '', '', [], {}, '', None)
def test_get_available_fcp_reserve_false(self, get_from_assigner):
"""test reserve == False.
no matter what connections is, the output will be same."""
base.set_conf('volume', 'get_fcp_pair_with_same_index', 0)
# case1: get_from_assigner return []
get_from_assigner.return_value = []
result = self.fcpops.get_available_fcp('user1', False)
self.assertEqual([], result)
# case2: get_from_assigner return ['1234', '5678']
get_from_assigner.return_value = [('1234', '', 0, 0, 0, ''),
('5678', '', 0, 0, 0, '')]
result = self.fcpops.get_available_fcp('user1', False)
expected = ['1234', '5678']
self.assertEqual(expected, result)
def test_host_get_diskpool_volumes(self, diskpool_vols):
base.set_conf('zvm', 'disk_pool', None)
disk_pool = 'ECKD:IAS1PL'
result = self.api.host_get_diskpool_volumes(disk_pool)
diskpool_vols.assert_called_once_with('IAS1PL')
# Test disk_pool is None
disk_pool = None
try:
self.api.host_get_diskpool_volumes(disk_pool)
except Exception as exc:
errmsg = ("Invalid disk_pool input None, disk_pool should be"
" configured for sdkserver.")
result = errmsg in six.text_type(exc)
self.assertEqual(result, True)
pass
def test_guest_create_with_no_disk_pool(self, create_vm):
disk_list = [{'size': '1g', 'is_boot_disk': True,
'disk_pool': 'ECKD: eckdpool1'},
{'size': '1g', 'format': 'ext3'},
{'size': '1g', 'format': 'swap'}]
vcpus = 1
memory = 1024
user_profile = 'profile'
max_cpu = 10
max_mem = '4G'
base.set_conf('zvm', 'disk_pool', None)
self.assertRaises(exception.SDKInvalidInputFormat,
self.api.guest_create, self.userid, vcpus,
memory, disk_list, user_profile,
max_cpu, max_mem)
create_vm.assert_not_called()
def test_root_volume_detach(self, mock_undedicate, mock_remove_disk,
mock_check, mock_fcp_info):
connection_info = {
'platform': 's390x',
'ip': '1.2.3.4',
'os_version': 'rhel7',
'multipath': 'True',
'target_wwpn': ['20076D8500005182', '20076D8500005183'],
'target_lun': '2222',
'zvm_fcp': ['183c', '283c'],
'mount_point': '/dev/sdz',
'assigner_id': 'user1',
'is_root_volume': True
}
fcp_list = [
'opnstk1: FCP device number: 183C', 'opnstk1: Status: Free',
'opnstk1: NPIV world wide port number: 20076D8500005182',
'opnstk1: Channel path ID: 59',
'opnstk1: Physical world wide port number: '
'20076D8500005181', 'opnstk1: FCP device number: 283C',
'opnstk1: Status: Active',
'opnstk1: NPIV world wide port number: 20076D8500005183',
'opnstk1: Channel path ID: 50',
'opnstk1: Physical world wide port number: '
'20076D8500005185'
]
mock_fcp_info.return_value = fcp_list
mock_check.return_value = True
base.set_conf('volume', 'fcp_list', '183c')
base.set_conf('volume', 'fcp_list', '283c')
self.db_op = database.FCPDbOperator()
self.db_op.new('183c', 0)
self.db_op.assign('183c', 'USER1')
self.db_op.new('283c', 1)
# assign will set the connections to 1
self.db_op.assign('283c', 'USER1')
try:
self.volumeops.detach(connection_info)
self.assertFalse(mock_undedicate.called)
self.assertFalse(mock_remove_disk.called)
finally:
self.db_op.delete('183c')
self.db_op.delete('283c')
def test_create_vm(self, request, add_mdisks):
user_id = 'fakeuser'
cpu = 2
memory = 1024
disk_list = [{
'size': '1g',
'is_boot_disk': True,
'disk_pool': 'ECKD:eckdpool1',
'format': 'ext3'
}]
profile = 'dfltprof'
base.set_conf('zvm', 'default_admin_userid', 'lbyuser1 lbyuser2')
base.set_conf('zvm', 'user_root_vdev', '0100')
rd = ('makevm fakeuser directory LBYONLY 1024m G --cpus 2 '
'--profile dfltprof --logonby "lbyuser1 lbyuser2" --ipl 0100')
self._smutclient.create_vm(user_id, cpu, memory, disk_list, profile)
request.assert_called_once_with(rd)
add_mdisks.assert_called_once_with(user_id, disk_list)
def test_guest_deploy(self, request, execute, mkdtemp, cleantemp):
base.set_conf("zvm", "user_root_vdev", "0100")
execute.side_effect = [(0, ""), (0, "")]
mkdtemp.return_value = '/tmp/tmpdir'
userid = 'fakeuser'
image_name = 'fakeimg'
transportfiles = '/faketrans'
self._smutclient.guest_deploy(userid, image_name, transportfiles)
unpack_cmd = [
'/opt/zthin/bin/unpackdiskimage', 'fakeuser', '0100',
'/var/lib/zvmsdk/images/fakeimg'
]
cp_cmd = ["/usr/bin/cp", '/faketrans', '/tmp/tmpdir/cfgdrv']
execute.assert_has_calls([mock.call(unpack_cmd), mock.call(cp_cmd)])
purge_rd = "changevm fakeuser purgerdr"
punch_rd = "changevm fakeuser punchfile /tmp/tmpdir/cfgdrv --class X"
request.assert_has_calls([mock.call(purge_rd), mock.call(punch_rd)])
mkdtemp.assert_called_with()
cleantemp.assert_called_with('/tmp/tmpdir')
def test_get_available_fcp_reserve_true(self, get_allocated, get_fcp_pair,
assign, get_path_count):
"""test reserve == True"""
base.set_conf('volume', 'get_fcp_pair_with_same_index', 0)
# case1: get_allocated return []
get_allocated.return_value = []
get_fcp_pair.return_value = ['1234', '5678']
expected = ['1234', '5678']
result = self.fcpops.get_available_fcp('user1', True)
assign.assert_has_calls([
mock.call('1234', 'user1', update_connections=False),
mock.call('5678', 'user1', update_connections=False)
])
self.assertEqual(expected, result)
# case2: get_allocated return ['c83c', 'c83d']
get_allocated.return_value = [('c83c', 'user1', 0, 0, 0, ''),
('c83d', 'user1', 0, 0, 0, '')]
get_path_count.return_value = 2
result = self.fcpops.get_available_fcp('user1', True)
expected = ['c83c', 'c83d']
self.assertEqual(expected, result)
def test_get_volume_connector(self):
base.set_conf('network', 'my_ip', '1.2.3.4')
# create 1 FCP
self.db_op.new('b83c')
try:
connections = self.volumeops.get_volume_connector('dummy')
expected = {'multipath': True,
'platform': 's390x',
'do_local_attach': False,
'fcp': u'b83c',
'os_version': '',
'os_type': 'linux',
'ip': '1.2.3.4'}
self.assertEqual(expected, connections)
fcp_list = self.db_op.get_from_fcp('b83c')
expected = [(u'b83c', u'', 0, 1, u'')]
self.assertEqual(expected, fcp_list)
finally:
self.db_op.delete('b83c')
def test_guest_deploy_smut_request_failed(self, request, execute, mkdtemp,
cleantemp):
base.set_conf("zvm", "user_root_vdev", "0100")
fake_smut_results = {
'rs': 8,
'errno': 0,
'strError': 'Failed',
'overallRC': 3,
'rc': 400,
'logEntries': '',
'response': ['(Error) output and error info']
}
execute.side_effect = [(0, ""), (0, "")]
request.side_effect = [
None,
exception.ZVMClientRequestFailed(results=fake_smut_results)
]
mkdtemp.return_value = '/tmp/tmpdir'
userid = 'fakeuser'
image_name = 'fakeimg'
transportfiles = '/faketrans'
remote_host = "[email protected]"
self.assertRaises(exception.ZVMGuestDeployFailed,
self._smutclient.guest_deploy, userid, image_name,
transportfiles, remote_host)
unpack_cmd = [
'/opt/zthin/bin/unpackdiskimage', 'fakeuser', '0100',
'/var/lib/zvmsdk/images/fakeimg'
]
scp_cmd = [
"/usr/bin/scp", "-B", '[email protected]:/faketrans',
'/tmp/tmpdir/cfgdrv'
]
execute.assert_has_calls([mock.call(unpack_cmd), mock.call(scp_cmd)])
purge_rd = "changevm fakeuser purgerdr"
punch_rd = "changevm fakeuser punchfile /tmp/tmpdir/cfgdrv --class X"
request.assert_has_calls([mock.call(purge_rd), mock.call(punch_rd)])
mkdtemp.assert_called_with()
cleantemp.assert_called_with('/tmp/tmpdir')
def test_guest_deploy_cp_transport_failed(self, request, execute, mkdtemp,
cleantemp):
base.set_conf("zvm", "user_root_vdev", "0100")
cp_error = ("/usr/bin/cp: cannot stat '/faketrans': "
"No such file or directory\n")
execute.side_effect = [(0, ""), (1, cp_error)]
mkdtemp.return_value = '/tmp/tmpdir'
userid = 'fakeuser'
image_name = 'fakeimg'
transportfiles = '/faketrans'
self.assertRaises(exception.ZVMGuestDeployFailed,
self._smutclient.guest_deploy, userid, image_name,
transportfiles)
unpack_cmd = [
'/opt/zthin/bin/unpackdiskimage', 'fakeuser', '0100',
'/var/lib/zvmsdk/images/fakeimg'
]
cp_cmd = ["/usr/bin/cp", '/faketrans', '/tmp/tmpdir/cfgdrv']
execute.assert_has_calls([mock.call(unpack_cmd), mock.call(cp_cmd)])
purge_rd = "changevm fakeuser purgerdr"
request.assert_called_once_with(purge_rd)
mkdtemp.assert_called_with()
cleantemp.assert_called_with('/tmp/tmpdir')
def test_get_host_info(self, get_host_info, diskpool_get_info):
get_host_info.return_value = {
"zcc_userid": "FAKEUSER",
"zvm_host": "FAKENODE",
"zhcp": "fakehcp.fake.com",
"cec_vendor": "FAKE",
"cec_model": "2097",
"hypervisor_os": "z/VM 6.1.0",
"hypervisor_name": "fakenode",
"architecture": "s390x",
"lpar_cpu_total": "10",
"lpar_cpu_used": "10",
"lpar_memory_total": "16G",
"lpar_memory_used": "16.0G",
"lpar_memory_offline": "0",
"ipl_time": "IPL at 03/13/14 21:43:12 EDT",
}
diskpool_get_info.return_value = {
"disk_total": 406105,
"disk_used": 367263,
"disk_available": 38843,
}
host_info = self._hostops.get_info()
get_host_info.assert_called_once_with()
base.set_conf('zvm', 'disk_pool', 'ECKD:TESTPOOL')
diskpool = CONF.zvm.disk_pool.split(':')[1]
diskpool_get_info.assert_called_once_with(diskpool)
self.assertEqual(host_info['vcpus'], 10)
self.assertEqual(host_info['hypervisor_version'], 610)
self.assertEqual(host_info['disk_total'], 406105)
# Test disk_pool is None
base.set_conf('zvm', 'disk_pool', None)
host_info = self._hostops.get_info()
self.assertEqual(host_info['disk_total'], 0)
self.assertEqual(host_info['disk_used'], 0)
self.assertEqual(host_info['disk_available'], 0)
def setUpClass(cls):
super(GuestDbOperatorTestCase, cls).setUpClass()
cls.old_db_path = CONF.database.path
base.set_conf('database', 'path', '/tmp/test_sdk.db')
cls.db_op = database.GuestDbOperator()
def setUpClass(cls):
super(SDKSMUTClientTestCases, cls).setUpClass()
cls.old_client_type = CONF.zvm.client_type
base.set_conf('zvm', 'client_type', 'smut')
def tearDownClass(cls):
base.set_conf('zvm', 'client_type', cls.old_client_type)
super(SDKSMUTClientTestCases, cls).tearDownClass()
