def volumepool_get_volume(pool_name):
ref = request.args.get('ref', None)
if ref is None:
raise AXIllegalArgumentException("Volumepool get must contain a ref=something query parameter")
manager = VolumeManager()
volname = manager.get_from_pool(pool_name, ref)
return jsonify(result=volname)
def volumepool_create(pool_name):
manager = VolumeManager()
(size_str, ) = _get_required_arguments('size')
(attributes, ) = _get_optional_arguments('attributes')
size = int(size_str)
if attributes:
assert isinstance(attributes, dict), "attributes must be a dictionary"
manager.create_pool(pool_name, size, attributes)
return jsonify(result="ok")
def volume_update(volume_id):
manager = VolumeManager()
tags = request.get_json()
volume_tags = {}
for key, value in tags.iteritems():
volume_tags['Key'] = key
volume_tags['Value'] = value
manager.update_raw_volume(volume_id, [volume_tags])
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 volume_create(volume_id):
manager = VolumeManager()
# Right now, only AWS volumes of type EBS are supported!
volume_options = request.get_json()
assert "storage_provider_name" in volume_options and volume_options["storage_provider_name"].lower() == "ebs", "Only EBS volumes supported currently!"
if "zone" not in volume_options:
volume_options["zone"] = AWSMetaData().get_zone()
resource_id = manager.create_raw_volume(volume_id, volume_options)
return jsonify(result=resource_id)
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 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 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")
def test_1(self):
"""
Test volume create conditions used by volume pools
"""
manager = VolumeManager()
manager.create("testvol", "1")
with self.assertRaises(AXVolumeExistsException):
manager.create("testvol", "1")
manager.add_ref("testvol", "ref1")
with self.assertRaises(AXVolumeException):
manager.delete("testvol")
# now make the reservation exclusive. this should pass
manager.add_ref("testvol", "ref1", exclusive=True)
# try to add a new ref now
with self.assertRaises(AXVolumeException):
manager.add_ref("testvol", "ref2")
# delete ref1
manager.delete_ref("testvol", "ref1")
# test shared state
manager.add_ref("testvol", "ref3")
manager.add_ref("testvol", "ref4")
# now try to put an exclusive lock ref
with self.assertRaises(AXVolumeException):
manager.add_ref("testvol", "ref5", exclusive=True)
# now try to convert ref3 to exclusive
with self.assertRaises(AXVolumeException):
manager.add_ref("testvol", "ref3", exclusive=True)
# now remove ref4
manager.delete_ref("testvol", "ref4")
# make ref3 exclusive
manager.add_ref("testvol", "ref3", exclusive=True)
# delete ref and then delete vol
manager.delete_ref("testvol", "ref3")
manager.delete("testvol")
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 volumepool_delete(pool_name):
manager = VolumeManager()
volname = manager.delete_pool(pool_name)
return jsonify(result="ok")
def volumepool_delete_volume(pool_name, volume_name):
manager = VolumeManager()
manager.delete_volume_from_pool(pool_name, volume_name)
return jsonify(result="ok")
def volumepool_list():
manager = VolumeManager()
return jsonify(result=manager.list_pools())
def volume_get(volume_id):
manager = VolumeManager()
volume_attrs = manager.get_raw_volume(volume_id)
return jsonify(result=volume_attrs)
def volume_delete(volume_id):
manager = VolumeManager()
manager.delete_raw_volume(volume_id)
return jsonify(result="ok")
