def volumepool_return(pool_name, volume_name):
manager = VolumeManager()
mark = request.args.get("mark", "False") == "True"
ref = request.args.get("current_ref", None)
if mark:
# mark volume for deletion and then put it in the pool
manager.delete(volume_name, mark=mark)
manager.put_in_pool(pool_name, volume_name, current_ref=ref)
return jsonify(result="ok")
def delete(self, name, delete_pod=True, force=False):
"""
Delete the task from kubernetes and returns the final status
Args:
name: string that is the unique job name
Returns: Last status of the job
"""
logger.debug("Task delete for {}".format(name))
self.jobname = name
with TaskOperation(self):
job_status = self._get_job(name)
status = self.status(name, status_obj=job_status)
ax_resources = self._get_ax_resources(job_status)
self.service_instance_id = job_status.metadata.labels.get(
"service_instance_id", None)
self._delete_job(name, delete_pod, force)
# cleanup other ax_resources
volumepools = ax_resources.get("volumepools", [])
for poolname, volname in volumepools:
vmanager = VolumeManager()
logger.debug("Return volume {} to volume pool {}".format(
volname, poolname))
try:
vmanager.put_in_pool(poolname,
volname,
current_ref=self.service_instance_id)
except AXVolumeOwnershipException as e:
logger.debug(
"Volume {} has already been returned for job {}. This is normal"
.format(volname, name))
service_endpoint = ax_resources.get("service_endpoint", None)
if service_endpoint:
endpoint_name = service_endpoint["name"]
nginx_controller = service_endpoint.get("use-nginx", None)
if nginx_controller is None and "persist" in service_endpoint and service_endpoint[
"persist"]:
logger.debug(
"Do not delete service endpoint {} as persist is set to true"
.format(endpoint_name))
else:
s = ServiceEndpoint(endpoint_name)
s.delete()
if nginx_controller:
r = IngressRules(endpoint_name, nginx_controller)
r.delete()
return status
def test_2(self):
"""
Basic test for volume pools
"""
manager = VolumeManager()
manager.create_pool("testpool1", "1", None)
volname1 = manager.get_from_pool("testpool1", "test1")
logger.debug("Got the following volume for test1 {}".format(volname1))
volname2 = manager.get_from_pool("testpool1", "test2")
logger.debug("Got the following volume for test2 {}".format(volname2))
manager.put_in_pool("testpool1", volname1)
manager.put_in_pool("testpool1", volname2)
manager.delete_pool("testpool1")
def test_4(self):
"""
Test conditions that involve marking a volume for deletion
"""
manager = VolumeManager()
manager.create_pool("testdeletion", "2", None)
volname1 = manager.get_from_pool("testdeletion", "ref1")
# this resizes the pool causing volname1 to be marked for deletion
manager.create_pool("testdeletion", "3", None)
volname2 = manager.get_from_pool("testdeletion", "ref2")
# volname1 should not be deleted
manager.put_in_pool("testdeletion", volname1)
# volname2 is put back in pool
manager.put_in_pool("testdeletion", volname2)
# volume pool can be deleted as it has no refs
manager.delete_pool("testdeletion")
def test_3(self):
"""
Test error conditions in volume pools
"""
manager = VolumeManager()
manager.create_pool("testpool2", "1", None)
volname1 = manager.get_from_pool("testpool2", "t1")
logger.debug("Got the following volume {}".format(volname1))
# get from pool with the same ref should give a different vol
volname2 = manager.get_from_pool("testpool2", "t1")
self.assertNotEquals(volname1, volname2)
manager.put_in_pool("testpool2", volname2)
# now try to delete a pool with an active reference
with self.assertRaises(AXVolumeException):
manager.delete_pool("testpool2")
logger.debug(manager.get_pools_for_unit_test())
# put an invalid pvc back in pool
with self.assertRaises(AssertionError):
manager.put_in_pool("testpool2", "somevolname")
manager.put_in_pool("testpool2", volname1)
# delete a non existent pool should not raise an error
manager.delete_pool("testpool")
manager.delete_pool("testpool2")
# now that pool is deleted, get from it
with self.assertRaises(KeyError):
manager.get_from_pool("testpool2", "t2")
