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 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_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 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 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")