def image_to_raw(image_href, path, path_tmp): with fileutils.remove_path_on_error(path_tmp): fmt = get_source_format(image_href, path_tmp) if fmt != "raw": staged = "%s.converted" % path utils.is_memory_insufficent(raise_if_fail=True) LOG.debug("%(image)s was %(format)s, converting to raw", { 'image': image_href, 'format': fmt }) with fileutils.remove_path_on_error(staged): disk_utils.convert_image(path_tmp, staged, 'raw') os.unlink(path_tmp) data = disk_utils.qemu_img_info(staged) if data.file_format != "raw": raise exception.ImageConvertFailed( image_id=image_href, reason=_("Converted to raw, but format is " "now %s") % data.file_format) os.rename(staged, path) else: os.rename(path_tmp, path)
def test_is_memory_insufficent_good(self, mock_vm_check, mock_sleep): class vm_check(object): available = 3276700000 mock_vm_check.return_value = vm_check self.assertFalse(utils.is_memory_insufficent()) self.assertEqual(1, mock_vm_check.call_count)
def test_is_memory_insufficent_warning_only(self, mock_vm_check, mock_sleep): self.config(minimum_memory_warning_only=True) class vm_check_bad(object): available = 1023000000 mock_vm_check.side_effect = vm_check_bad self.assertFalse(utils.is_memory_insufficent()) self.assertEqual(2, mock_vm_check.call_count)
def test_is_memory_insufficent_recovers(self, mock_vm_check, mock_sleep): class vm_check_bad(object): available = 1023000000 class vm_check_good(object): available = 3276700000 self.config(minimum_memory_warning_only=False) mock_vm_check.side_effect = iter( [vm_check_bad, vm_check_bad, vm_check_good]) self.assertFalse(utils.is_memory_insufficent()) self.assertEqual(3, mock_vm_check.call_count)
def write_image(self, task): """Method invoked when deployed using iSCSI. This method is invoked during a heartbeat from an agent when the node is in wait-call-back state. This deploys the image on the node and then configures the node to boot according to the desired boot option (netboot or localboot). :param task: a TaskManager object containing the node. :param kwargs: the kwargs passed from the heartbeat method. :raises: InstanceDeployFailure, if it encounters some error during the deploy. """ if not task.driver.storage.should_write_image(task): LOG.debug('Skipping write_image for node %s', task.node.uuid) return node = task.node LOG.debug('Continuing the deployment on node %s', node.uuid) if utils.is_memory_insufficent(): # Insufficent memory, but we can just let the agent heartbeat # again in order to initiate deployment when the situation has # changed. LOG.warning( 'Insufficent memory to write image for node ' '%(node)s. Skipping until next heartbeat.', {'node': node.uuid}) info = node.driver_internal_info info['skip_current_deploy_step'] = False node.driver_internal_info = info node.last_error = "Deploy delayed due to insufficent memory" node.save() return states.DEPLOYWAIT uuid_dict_returned = do_agent_iscsi_deploy(task, self._client) utils.set_node_nested_field(node, 'driver_internal_info', 'deployment_uuids', uuid_dict_returned) node.save()