def migrate_flavors(ctxt, count, hard_delete=False):
    main_db_ids = _get_main_db_flavor_ids(ctxt, count)
    if not main_db_ids:
        return 0, 0

    count_all = len(main_db_ids)
    count_hit = 0

    for flavor_id in main_db_ids:
        try:
            flavor = Flavor.get_by_id(ctxt, flavor_id)
            flavor_values = {field: getattr(flavor, field)
                             for field in flavor.fields}
            flavor._flavor_create(ctxt, flavor_values)
            count_hit += 1
            if hard_delete:
                _destroy_flavor_hard(ctxt, flavor.name)
            else:
                db.flavor_destroy(ctxt, flavor.flavorid)
        except exception.FlavorNotFound:
            LOG.warning('Flavor id %(id)i disappeared during migration',
                        {'id': flavor_id})
        except (exception.FlavorExists, exception.FlavorIdExists) as e:
            LOG.error(six.text_type(e))

    return count_all, count_hit

def destroy(name):
    """Marks flavor as deleted."""
    try:
        assert name is not None
        db.flavor_destroy(context.get_admin_context(), name)
    except (AssertionError, exception.NotFound):
        LOG.exception(_('Instance type %s not found for deletion') % name)
        raise exception.InstanceTypeNotFoundByName(instance_type_name=name)

def destroy(name):
    """Marks flavor as deleted."""
    try:
        if not name:
            raise ValueError()
        db.flavor_destroy(context.get_admin_context(), name)
    except (ValueError, exception.NotFound):
        LOG.exception(_('Instance type %s not found for deletion') % name)
        raise exception.FlavorNotFoundByName(flavor_name=name)

 def destroy(self):
     # NOTE(danms): Historically the only way to delete a flavor
     # is via name, which is not very precise. We need to be able to
     # support the light construction of a flavor object and subsequent
     # delete request with only our name filled out. However, if we have
     # our id property, we should instead delete with that since it's
     # far more specific.
     try:
         if 'id' in self:
             self._flavor_destroy(self._context, flavor_id=self.id)
         else:
             self._flavor_destroy(self._context, name=self.name)
     except exception.FlavorNotFound:
         db.flavor_destroy(self._context, self.name)

    def tearDown(self):
        db.flavor_destroy(
                self.admin_context, self.disabled_type['name'])

        super(DisabledFlavorsWithRealDBTestV21, self).tearDown()

 def tearDown(self):
     db.flavor_destroy(context.get_admin_context(),
                              "test.small")
     super(InstanceTypeCommandsTestCase, self).tearDown()

 def destroy(self, context):
     db.flavor_destroy(context, self.name)

 def destroy(self):
     db.flavor_destroy(self._context, self.name)

 def tearDown(self):
     # Remove the instance type from the database
     db.flavor_destroy(self.context, "cg1.4xlarge")
     super(InstanceTypeExtraSpecsTestCase, self).tearDown()