def _set_allocations(context, allocs):
"""Write a set of allocations.
We must check that there is capacity for each allocation.
If there is not we roll back the entire set.
:raises `exception.ResourceClassNotFound` if any resource class in any
allocation in allocs cannot be found in either the DB.
:raises `exception.InvalidAllocationCapacityExceeded` if any inventory
would be exhausted by the allocation.
:raises `InvalidAllocationConstraintsViolated` if any of the
`step_size`, `min_unit` or `max_unit` constraints in an
inventory will be violated by any one of the allocations.
:raises `ConcurrentUpdateDetected` if a generation for a resource
provider or consumer failed its increment check.
"""
# First delete any existing allocations for any consumers. This
# provides a clean slate for the consumers mentioned in the list of
# allocations being manipulated.
consumer_uuids = set(alloc.consumer.uuid for alloc in allocs)
for consumer_uuid in consumer_uuids:
_delete_allocations_for_consumer(context, consumer_uuid)
# Before writing any allocation records, we check that the submitted
# allocations do not cause any inventory capacity to be exceeded for
# any resource provider and resource class involved in the allocation
# transaction. _check_capacity_exceeded() raises an exception if any
# inventory capacity is exceeded. If capacity is not exceeeded, the
# function returns a list of ResourceProvider objects containing the
# generation of the resource provider at the time of the check. These
# objects are used at the end of the allocation transaction as a guard
# against concurrent updates.
#
# Don't check capacity when alloc.used is zero. Zero is not a valid
# amount when making an allocation (the minimum consumption of a
# resource is one) but is used in this method to indicate a need for
# removal. Providing 0 is controlled at the HTTP API layer where PUT
# /allocations does not allow empty allocations. When POST /allocations
# is implemented it will for the special case of atomically setting and
# removing different allocations in the same request.
# _check_capacity_exceeded will raise a ResourceClassNotFound if any
# allocation is using a resource class that does not exist.
visited_consumers = {}
visited_rps = _check_capacity_exceeded(context, allocs)
for alloc in allocs:
if alloc.consumer.uuid not in visited_consumers:
visited_consumers[alloc.consumer.uuid] = alloc.consumer
# If alloc.used is set to zero that is a signal that we don't want
# to (re-)create any allocations for this resource class.
# _delete_current_allocs has already wiped out allocations so just
# continue
if alloc.used == 0:
continue
consumer_uuid = alloc.consumer.uuid
rp = alloc.resource_provider
rc_name = alloc.resource_class
query = """
MATCH (rp:RESOURCE_PROVIDER {uuid: '%s'})
WITH rp
MATCH (rp)-[:PROVIDES]->(rc:%s)
WITH rp, rc
MATCH (cs:CONSUMER {uuid: '%s'})
WITH rp, rc, cs
CREATE p=(cs)-[:USES {amount: %s}]->(rc)
RETURN p
""" % (rp.uuid, rc_name, consumer_uuid, alloc.used)
result = context.tx.run(query)
# Generation checking happens here. If the inventory for this resource
# provider changed out from under us, this will raise a
# ConcurrentUpdateDetected which can be caught by the caller to choose
# to try again. It will also rollback the transaction so that these
# changes always happen atomically.
for rp in visited_rps.values():
rp.increment_generation()
for consumer in visited_consumers.values():
consumer.increment_generation()
# If any consumers involved in this transaction ended up having no
# allocations, delete the consumer records. Exclude consumers that had
# *some resource* in the allocation list with a total > 0 since clearly
# those consumers have allocations...
cons_with_allocs = set(a.consumer.uuid for a in allocs if a.used > 0)
all_cons = set(c.uuid for c in visited_consumers.values())
consumers_to_check = all_cons - cons_with_allocs
consumer_obj.delete_consumers_if_no_allocations(context,
consumers_to_check)
def delete_all(context, alloc_list):
consumer_uuids = set(alloc.consumer.uuid for alloc in alloc_list)
for consumer_uuid in consumer_uuids:
_delete_allocations_for_consumer(context, consumer_uuid)
consumer_obj.delete_consumers_if_no_allocations(context, consumer_uuids)
def delete_all(context, alloc_list):
consumer_uuids = set(alloc.consumer.uuid for alloc in alloc_list)
alloc_ids = [alloc.id for alloc in alloc_list]
_delete_allocations_by_ids(context, alloc_ids)
consumer_obj.delete_consumers_if_no_allocations(context, consumer_uuids)