def fake_datastore_obj(*args, **kwargs): dc_obj = oslo_datacenter.Datacenter(ref='fake-ref', name='fake-name') dc_obj.path = args[0] return oslo_datastore.Datastore(ref='fake-ref', datacenter=dc_obj, name=args[1])
def test_enlist_image(self, mock_get_ds_browser, mock_timestamp_cleanup, mock_timestamp_folder_get): image_id = "fake_image_id" dc_ref = "fake_dc_ref" fake_ds_ref = mock.Mock() ds = ds_obj.Datastore( ref=fake_ds_ref, name='fake_ds', capacity=1, freespace=1) ds_browser = mock.Mock() mock_get_ds_browser.return_value = ds_browser timestamp_folder_path = mock.Mock() mock_timestamp_folder_get.return_value = timestamp_folder_path self._imagecache.enlist_image(image_id, ds, dc_ref) cache_root_folder = ds.build_path("fake-base-folder") mock_get_ds_browser.assert_called_once_with( ds.ref) mock_timestamp_folder_get.assert_called_once_with( cache_root_folder, "fake_image_id") mock_timestamp_cleanup.assert_called_once_with( dc_ref, ds_browser, timestamp_folder_path)
def test_list_base_images(self): def fake_get_dynamic_property(vim, mobj, type, property_name): return 'fake-ds-browser' def fake_get_sub_folders(session, ds_browser, ds_path): files = set() files.add('image-ref-uuid') return files with contextlib.nested( mock.patch.object(vim_util, 'get_dynamic_property', fake_get_dynamic_property), mock.patch.object(ds_util, 'get_sub_folders', fake_get_sub_folders) ) as (_get_dynamic, _get_sub_folders): fake_ds_ref = fake.ManagedObjectReference('fake-ds-ref') datastore = ds_obj.Datastore(name='ds', ref=fake_ds_ref) ds_path = datastore.build_path('base_folder') images = self._imagecache._list_datastore_images( ds_path, datastore) originals = set() originals.add('image-ref-uuid') self.assertEqual({'originals': originals, 'unexplained_images': []}, images)
def test_filter_datastores_specific_match(self): data = [ ['VMFS', 'os-some-name', True, 'normal', 987654321, 1234678], ['NFS', 'another-name', True, 'normal', 9876543210, 123467890], ['BAD', 'some-name-bad', True, 'normal', 98765432100, 1234678900], ['VMFS', 'some-name-good', True, 'normal', 987654321, 12346789], ['VMFS', 'some-other-good', False, 'normal', 987654321000, 12346789000], ['VMFS', 'new-name', True, 'inMaintenance', 987654321000, 12346789000] ] # only the DS some-name-good is accessible and matches the regex datastores = self.create_result_iterator(data) datastore_regex = re.compile('.*-good$') best_match = ds_obj.Datastore(ref='fake_ref', name='ds', capacity=0, freespace=0) rec = ds_util._select_datastore(None, datastores, best_match, datastore_regex) self.assertIsNotNone(rec, "could not find datastore!") self.assertEqual('ds-003', rec.ref.value, "didn't find the right datastore!") self.assertNotEqual('ds-004', rec.ref.value, "accepted an unreachable datastore!") self.assertEqual('some-name-good', rec.name) self.assertEqual(12346789, rec.freespace, "did not obtain correct freespace!") self.assertEqual(987654321, rec.capacity, "did not obtain correct capacity!")
def test_ds(self): ds = datastore.Datastore("fake_ref", "ds_name", 2 * units.Gi, 1 * units.Gi) self.assertEqual('ds_name', ds.name) self.assertEqual('fake_ref', ds.ref) self.assertEqual(2 * units.Gi, ds.capacity) self.assertEqual(1 * units.Gi, ds.freespace)
def test_filter_datastores_empty(self): data = [] datastores = self.create_result_iterator(data) best_match = ds_obj.Datastore(ref='fake_ref', name='ds', capacity=0, freespace=0) rec = ds_util._select_datastore(None, datastores, best_match) self.assertEqual(best_match, rec)
def get_datastore_by_ref(session, ds_ref): lst_properties = ["summary.type", "summary.name", "summary.capacity", "summary.freeSpace"] props = session._call_method(vim_util, "get_object_properties", None, ds_ref, "Datastore", lst_properties) query = vm_util.get_values_from_object_properties(session, props) return ds_obj.Datastore(ds_ref, query["summary.name"], capacity=query["summary.capacity"], freespace=query["summary.freeSpace"])
def test_build_url(self): ds = datastore.Datastore("fake_ref", "ds_name") path = 'images/ubuntu.vmdk' self.assertRaises(ValueError, ds.build_url, 'https', '10.0.0.2', path) ds.datacenter = mock.Mock() ds.datacenter.name = "dc_path" ds_url = ds.build_url('https', '10.0.0.2', path) self.assertEqual(ds_url.datastore_name, "ds_name") self.assertEqual(ds_url.datacenter_path, "dc_path") self.assertEqual(ds_url.path, path)
def test_filter_datastores_no_match(self): datastores = self.create_result_iterator(self.data) datastore_regex = re.compile('no_match.*') best_match = ds_obj.Datastore(ref='fake_ref', name='ds', capacity=0, freespace=0) rec = ds_util._select_datastore(None, datastores, best_match, datastore_regex) self.assertEqual(best_match, rec, "did not match datastore properly")
def test_age_cached_images(self): def fake_get_ds_browser(ds_ref): return 'fake-ds-browser' def fake_get_timestamp(ds_browser, ds_path): self._get_timestamp_called += 1 path = str(ds_path) if path == '[fake-ds] fake-path/fake-image-1': # No time stamp exists return if path == '[fake-ds] fake-path/fake-image-2': # Timestamp that will be valid => no deletion return 'ts-2012-11-22-10-00-00' if path == '[fake-ds] fake-path/fake-image-3': # Timestamp that will be invalid => deletion return 'ts-2012-11-20-12-00-00' self.fail() def fake_mkdir(session, ts_path, dc_ref): self.assertEqual( '[fake-ds] fake-path/fake-image-1/ts-2012-11-22-12-00-00', str(ts_path)) def fake_file_delete(session, ds_path, dc_ref): self.assertEqual('[fake-ds] fake-path/fake-image-3', str(ds_path)) def fake_timestamp_cleanup(dc_ref, ds_browser, ds_path): self.assertEqual('[fake-ds] fake-path/fake-image-4', str(ds_path)) with contextlib.nested( mock.patch.object(self._imagecache, '_get_ds_browser', fake_get_ds_browser), mock.patch.object(self._imagecache, '_get_timestamp', fake_get_timestamp), mock.patch.object(ds_util, 'mkdir', fake_mkdir), mock.patch.object(ds_util, 'file_delete', fake_file_delete), mock.patch.object(self._imagecache, 'timestamp_cleanup', fake_timestamp_cleanup), ) as (_get_ds_browser, _get_timestamp, _mkdir, _file_delete, _timestamp_cleanup): timeutils.set_time_override(override_time=self._time) datastore = ds_obj.Datastore(name='ds', ref='fake-ds-ref') dc_info = vmops.DcInfo(ref='dc_ref', name='name', vmFolder='vmFolder') self._get_timestamp_called = 0 self._imagecache.originals = set(['fake-image-1', 'fake-image-2', 'fake-image-3', 'fake-image-4']) self._imagecache.used_images = set(['fake-image-4']) self._imagecache._age_cached_images( 'fake-context', datastore, dc_info, ds_obj.DatastorePath('fake-ds', 'fake-path')) self.assertEqual(3, self._get_timestamp_called)
def test_filter_datastores_simple(self): datastores = self.create_result_iterator(self.data) best_match = ds_obj.Datastore(ref='fake_ref', name='ds', capacity=0, freespace=0) rec = ds_util._select_datastore(None, datastores, best_match) self.assertIsNotNone(rec.ref, "could not find datastore!") self.assertEqual('ds-001', rec.ref.value, "didn't find the right datastore!") self.assertEqual(123467890, rec.freespace, "did not obtain correct freespace!")
def test_get_summary(self): ds_ref = vim_util.get_moref('ds-0', 'Datastore') ds = datastore.Datastore(ds_ref, 'ds-name') summary = mock.sentinel.summary session = mock.Mock() session.invoke_api = mock.Mock() session.invoke_api.return_value = summary ret = ds.get_summary(session) self.assertEqual(summary, ret) session.invoke_api.assert_called_once_with(vim_util, 'get_object_property', session.vim, ds.ref, 'summary')
def test_filter_datastores_missing_props(self): data = [ ['VMFS', 'os-some-name', 987654321, 1234678], ['NFS', 'another-name', 9876543210, 123467890], ] # no matches are expected when 'summary.accessible' is missing prop_names = ['summary.type', 'summary.name', 'summary.capacity', 'summary.freeSpace'] datastores = self.create_result_iterator(data, prop_names) best_match = ds_obj.Datastore(ref='fake_ref', name='ds', capacity=0, freespace=0) rec = ds_util._select_datastore(None, datastores, best_match) self.assertEqual(best_match, rec, "no matches were expected")
def _get_allowed_datastores(datastores, datastore_regex): for obj_content in datastores: # the propset attribute "need not be set" by returning API if not hasattr(obj_content, 'propSet'): continue propdict = vm_util.propset_dict(obj_content.propSet) if _is_datastore_valid(propdict, datastore_regex, ALL_SUPPORTED_DS_TYPES): yield (ds_obj.Datastore(ref=obj_content.obj, name=propdict['summary.name'], capacity=propdict['summary.capacity'], freespace=propdict['summary.freeSpace']))
def _get_allowed_datastores(data_stores, datastore_regex): allowed = [] for obj_content in data_stores.objects: # the propset attribute "need not be set" by returning API if not hasattr(obj_content, 'propSet'): continue propdict = vm_util.propset_dict(obj_content.propSet) if _is_datastore_valid(propdict, datastore_regex, ALL_SUPPORTED_DS_TYPES): allowed.append(ds_obj.Datastore(ref=obj_content.obj, name=propdict['summary.name'])) return allowed
def _test_get_connected_hosts(self, in_maintenance_mode, m1_accessible=True): session = mock.Mock() ds_ref = vim_util.get_moref('ds-0', 'Datastore') ds = datastore.Datastore(ds_ref, 'ds-name') ds.get_summary = mock.Mock() ds.get_summary.return_value.accessible = False self.assertEqual([], ds.get_connected_hosts(session)) ds.get_summary.return_value.accessible = True m1 = HostMount("m1", MountInfo('readWrite', True, m1_accessible)) m2 = HostMount("m2", MountInfo('read', True, True)) m3 = HostMount("m3", MountInfo('readWrite', False, True)) m4 = HostMount("m4", MountInfo('readWrite', True, False)) ds.get_summary.assert_called_once_with(session) class Prop(object): DatastoreHostMount = [m1, m2, m3, m4] class HostRuntime(object): inMaintenanceMode = in_maintenance_mode class HostProp(object): name = 'runtime' val = HostRuntime() class Object(object): obj = "m1" propSet = [HostProp()] class Runtime(object): objects = [Object()] session.invoke_api = mock.Mock(side_effect=[Prop(), Runtime()]) hosts = ds.get_connected_hosts(session) calls = [ mock.call(vim_util, 'get_object_property', session.vim, ds_ref, 'host') ] if m1_accessible: calls.append( mock.call(vim_util, 'get_properties_for_a_collection_of_objects', session.vim, 'HostSystem', ["m1"], ['runtime'])) self.assertEqual(calls, session.invoke_api.mock_calls) return hosts
def _select_datastore(session, data_stores, best_match, datastore_regex=None, storage_policy=None, allowed_ds_types=ALL_SUPPORTED_DS_TYPES): """Find the most preferable datastore in a given RetrieveResult object. :param session: vmwareapi session :param data_stores: a RetrieveResult object from vSphere API call :param best_match: the current best match for datastore :param datastore_regex: an optional regular expression to match names :param storage_policy: storage policy for the datastore :param allowed_ds_types: a list of acceptable datastore type names :return: datastore_ref, datastore_name, capacity, freespace """ if storage_policy: matching_ds = _filter_datastores_matching_storage_policy( session, data_stores, storage_policy) if not matching_ds: return best_match else: matching_ds = data_stores # data_stores is actually a RetrieveResult object from vSphere API call for obj_content in matching_ds.objects: # the propset attribute "need not be set" by returning API if not hasattr(obj_content, 'propSet'): continue propdict = vm_util.propset_dict(obj_content.propSet) if _is_datastore_valid(propdict, datastore_regex, allowed_ds_types): new_ds = ds_obj.Datastore(ref=obj_content.obj, name=propdict['summary.name'], capacity=propdict['summary.capacity'], freespace=propdict['summary.freeSpace']) # favor datastores with more free space if (best_match is None or new_ds.freespace > best_match.freespace): best_match = new_ds return best_match
def test_filter_datastores_best_match(self): data = [ ['VMFS', 'spam-good', True, 20 * units.Gi, 10 * units.Gi], ['NFS', 'eggs-good', True, 40 * units.Gi, 15 * units.Gi], ['BAD', 'some-name-bad', True, 30 * units.Gi, 20 * units.Gi], ['VMFS', 'some-name-good', True, 50 * units.Gi, 5 * units.Gi], ['VMFS', 'some-other-good', True, 10 * units.Gi, 10 * units.Gi], ] datastores = self.build_result_set(data) datastore_regex = re.compile('.*-good$') # the current best match is better than all candidates best_match = ds_obj.Datastore(ref='ds-100', name='best-ds-good', capacity=20 * units.Gi, freespace=19 * units.Gi) rec = ds_util._select_datastore(None, datastores, best_match, datastore_regex) self.assertEqual(rec, best_match, "did not match datastore properly")
def test_update(self, mock_get_by_inst): def fake_list_datastore_images(ds_path, datastore): return {'unexplained_images': [], 'originals': self.images} def fake_age_cached_images(context, datastore, dc_info, ds_path): self.assertEqual('[ds] fake-base-folder', str(ds_path)) self.assertEqual(self.images, self._imagecache.used_images) self.assertEqual(self.images, self._imagecache.originals) with contextlib.nested( mock.patch.object(self._imagecache, '_list_datastore_images', fake_list_datastore_images), mock.patch.object( self._imagecache, '_age_cached_images', fake_age_cached_images)) as (_list_base, _age_and_verify): instances = [{ 'image_ref': '1', 'host': CONF.host, 'name': 'inst-1', 'uuid': '123', 'vm_state': '', 'task_state': '' }, { 'image_ref': '2', 'host': CONF.host, 'name': 'inst-2', 'uuid': '456', 'vm_state': '', 'task_state': '' }] all_instances = [ fake_instance.fake_instance_obj(None, **instance) for instance in instances ] self.images = set(['1', '2']) datastore = ds_obj.Datastore(name='ds', ref='fake-ds-ref') dc_info = vmops.DcInfo(ref='dc_ref', name='name', vmFolder='vmFolder') datastores_info = [(datastore, dc_info)] self._imagecache.update('context', all_instances, datastores_info)
def test_get_connected_hosts(self): session = mock.Mock() ds_ref = vim_util.get_moref('ds-0', 'Datastore') ds = datastore.Datastore(ds_ref, 'ds-name') ds.get_summary = mock.Mock() ds.get_summary.return_value.accessible = False self.assertEqual([], ds.get_connected_hosts(session)) ds.get_summary.return_value.accessible = True m1 = HostMount("m1", MountInfo('readWrite', True, True)) m2 = HostMount("m2", MountInfo('read', True, True)) m3 = HostMount("m3", MountInfo('readWrite', False, True)) m4 = HostMount("m4", MountInfo('readWrite', True, False)) ds.get_summary.assert_called_once_with(session) class Prop(object): DatastoreHostMount = [m1, m2, m3, m4] session.invoke_api = mock.Mock() session.invoke_api.return_value = Prop() hosts = ds.get_connected_hosts(session) self.assertEqual(1, len(hosts)) self.assertEqual("m1", hosts.pop())
def test_disconnect(self, attach_disk_to_backing, detach_disk_from_backing, get_disk_device, getsize, upload_vmdk, file_open, create_temp_ds_folder, get_ds_by_ref): ds_ref = mock.sentinel.ds_ref ds_name = 'datastore-1' dstore = datastore.Datastore(ds_ref, ds_name) get_ds_by_ref.return_value = dstore file_open_ret = mock.Mock() tmp_file = mock.sentinel.tmp_file file_open_ret.__enter__ = mock.Mock(return_value=tmp_file) file_open_ret.__exit__ = mock.Mock(return_value=None) file_open.return_value = file_open_ret dc_name = mock.sentinel.dc_name copy_task = mock.sentinel.copy_vdisk_task delete_file_task = mock.sentinel.delete_file_task session = mock.Mock() session.invoke_api.side_effect = [dc_name, copy_task, delete_file_task] getsize.return_value = units.Gi disk_device = mock.sentinel.disk_device get_disk_device.return_value = disk_device backing = mock.sentinel.backing tmp_file_path = '/tmp/foo.vmdk' dc_ref = mock.sentinel.dc_ref vmdk_path = mock.sentinel.vmdk_path self._connector._disconnect(backing, tmp_file_path, session, ds_ref, dc_ref, vmdk_path) tmp_folder_path = self._connector.TMP_IMAGES_DATASTORE_FOLDER_PATH ds_folder_path = '[%s] %s' % (ds_name, tmp_folder_path) create_temp_ds_folder.assert_called_once_with(session, ds_folder_path, dc_ref) file_open.assert_called_once_with(tmp_file_path, "rb") self.assertEqual( mock.call(vim_util, 'get_object_property', session.vim, dc_ref, 'name'), session.invoke_api.call_args_list[0]) exp_rel_path = '%s/foo.vmdk' % tmp_folder_path upload_vmdk.assert_called_once_with( tmp_file, self._connector._ip, self._connector._port, dc_name, ds_name, session.vim.client.options.transport.cookiejar, exp_rel_path, units.Gi, self._connector._ca_file, self._connector._timeout) get_disk_device.assert_called_once_with(session, backing) detach_disk_from_backing.assert_called_once_with( session, backing, disk_device) src = '[%s] %s' % (ds_name, exp_rel_path) disk_mgr = session.vim.service_content.virtualDiskManager self.assertEqual( mock.call(session.vim, 'CopyVirtualDisk_Task', disk_mgr, sourceName=src, sourceDatacenter=dc_ref, destName=vmdk_path, destDatacenter=dc_ref), session.invoke_api.call_args_list[1]) self.assertEqual(mock.call(copy_task), session.wait_for_task.call_args_list[0]) attach_disk_to_backing.assert_called_once_with(session, backing, disk_device) file_mgr = session.vim.service_content.fileManager self.assertEqual( mock.call(session.vim, 'DeleteDatastoreFile_Task', file_mgr, name=src, datacenter=dc_ref), session.invoke_api.call_args_list[2]) self.assertEqual(mock.call(delete_file_task), session.wait_for_task.call_args_list[1])
def test_build_path(self): ds = datastore.Datastore("fake_ref", "ds_name") ds_path = ds.build_path("some_dir", "foo.vmdk") self.assertEqual('[ds_name] some_dir/foo.vmdk', str(ds_path))
def test_ds_no_capacity_no_freespace(self): ds = datastore.Datastore("fake_ref", "ds_name") self.assertIsNone(ds.capacity) self.assertIsNone(ds.freespace)