def test_glance_user_storage_quota_bypass_1_2(self, glance_remote, suffix,
                                                  env, os_conn):
        """If deleting images in 'saving' status, storage quota is overcome by
        user because images in deleted state are not taken into account by
        quota. These image files should be deleted after the upload of files
        is completed.

        Scenario:
            1. Set 'file' storage on glance-api.conf
            2. Set 'user_storage_quota' to 604979776 in glance-api.conf
            (a little more than the size of the image) and restart glance-api
            service
            3. Run 5-min cycle which creates image, wait 2 sec and then
            deletes it in "saving" status (and in any other status if any) on
            every iteration
            4. After the end of cycle wait until the upload and deleting images
            is completed
            5. Check that images statuses are "deleted" in mysql database

        Duration 5m
        """
        user_storage_quota = 604979776

        images_size_before = 0
        for img in os_conn.nova.images.list():
            images_size_before += img.to_dict()['OS-EXT-IMG-SIZE:size']
        err_msg_quota = "Glance user storage quota is exceeded"
        assert images_size_before < user_storage_quota, err_msg_quota
        img_from_dir = self.get_images_number_from_dir()
        images_before = len(os_conn.nova.images.list())
        name = "Test_{0}".format(suffix[:6])
        image_url = ("http://releases.ubuntu.com/14.04/"
                     "ubuntu-14.04.4-server-i386.iso")
        file_path = file_cache.get_file_path(image_url)
        start_time = datetime.datetime.now()
        duration = datetime.timedelta(seconds=300)
        stop_time = start_time + duration
        images_id = []

        while 1:
            image = self.os_conn.glance.images.create(name=name,
                                                      disk_format='qcow2',
                                                      container_format='bare')
            p = Process(target=self.os_conn.glance.images.upload,
                        args=(image.id, open(file_path), ))
            p.start()
            time.sleep(2)
            image = self.os_conn.glance.images.get(image.id)
            if image.status == 'saving':
                logger.info("Image status = {0}".format(image.status))
                self.os_conn.glance.images.delete(image.id)
                logger.info("Image {0} is deleted in saving state"
                            .format(image.id))
            else:
                self.os_conn.glance.images.delete(image.id)
            images_id.append(image.id)
            p.join()
            if datetime.datetime.now() >= stop_time:
                break

        controllers = self.env.get_nodes_by_role('controller')
        for controller in controllers:
            with controller.ssh() as remote:
                wait(lambda: len(remote.check_call(
                    'ls /var/lib/glance/images')['stdout']) == img_from_dir[
                    controller.data['fqdn']],
                    timeout_seconds=60,
                    waiting_for='used space to be cleared')

        images_values = self.get_images_values_from_mysql_db(images_id)
        for image_id in images_values:
            image_values = images_values[image_id]
            err_msg = 'Status of image {0} is not deleted'.format(image_id)
            assert "deleted" in image_values, err_msg

        images_size_after = 0
        for img in os_conn.nova.images.list():
            images_size_after += img.to_dict()['OS-EXT-IMG-SIZE:size']
        err_msg = "Glance user storage quota is exceeded"
        assert images_size_after < user_storage_quota, err_msg
        assert images_before == len(os_conn.nova.images.list())