/**
* Deactivate Bucket, this will move the Bucket to a "marked-for-delete" state
*
* <p>NOTE: This is an asynchronous operation.
*
* @param id the URN of a ViPR Bucket
* @param param Bucket delete param for optional force delete
* @brief Delete Bucket
* @return Task resource representation
* @throws InternalException
*/
@POST
@Consumes({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
@Path("/{id}/deactivate")
@CheckPermission(
roles = {Role.TENANT_ADMIN},
acls = {ACL.OWN, ACL.ALL})
public TaskResourceRep deactivateBucket(@PathParam("id") URI id, BucketDeleteParam param)
throws InternalException {
String task = UUID.randomUUID().toString();
_log.info(
String.format(
"BucketDelete --- Bucket id: %1$s, Task: %2$s, ForceDelete: %3$s",
id, task, param.getForceDelete()));
ArgValidator.checkFieldUriType(id, Bucket.class, "id");
Bucket bucket = queryResource(id);
if (!param.getForceDelete()) {
ArgValidator.checkReference(Bucket.class, id, checkForDelete(bucket));
}
StorageSystem device = _dbClient.queryObject(StorageSystem.class, bucket.getStorageDevice());
Operation op =
_dbClient.createTaskOpStatus(
Bucket.class, bucket.getId(), task, ResourceOperationTypeEnum.DELETE_BUCKET);
op.setDescription("Bucket deactivate");
ObjectController controller = getController(ObjectController.class, device.getSystemType());
controller.deleteBucket(bucket.getStorageDevice(), id, task);
auditOp(
OperationTypeEnum.DELETE_BUCKET,
true,
AuditLogManager.AUDITOP_BEGIN,
bucket.getId().toString(),
device.getId().toString());
return toTask(bucket, task, op);
}
/**
* Updates Bucket values like Quota and Retention.
*
* @param id Bucket ID
* @param param Bucket update parameter
* @return Task resource representation
* @throws InternalException if update fails
*/
@PUT
@Consumes({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
@Path("/{id}")
@Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
@CheckPermission(
roles = {Role.TENANT_ADMIN},
acls = {ACL.OWN, ACL.ALL})
public TaskResourceRep updateBucket(@PathParam("id") URI id, BucketUpdateParam param)
throws InternalException {
Bucket bucket = null;
ArgValidator.checkFieldUriType(id, Bucket.class, "id");
bucket = _dbClient.queryObject(Bucket.class, id);
ArgValidator.checkEntity(bucket, id, isIdEmbeddedInURL(id));
Long softQuota = SizeUtil.translateSize(param.getSoftQuota());
Long hardQuota = SizeUtil.translateSize(param.getHardQuota());
Integer retention = null != param.getRetention() ? Integer.valueOf(param.getRetention()) : 0;
// if no softquota is provided, use the old value
if (softQuota == 0) {
softQuota = bucket.getSoftQuota();
}
// if no hardquota is provided, use the old value
if (hardQuota == 0) {
hardQuota = bucket.getHardQuota();
}
// Hard Quota should be more than SoftQuota
verifyQuotaValues(softQuota, hardQuota, bucket.getLabel());
// if no retention is provided, use the old value
if (retention == 0) {
retention = bucket.getRetention();
}
VirtualPool cos = _dbClient.queryObject(VirtualPool.class, bucket.getVirtualPool());
// verify retention. Its validated only if Retention is configured.
if (retention != 0 && cos.getMaxRetention() != 0 && retention > cos.getMaxRetention()) {
throw APIException.badRequests.insufficientRetentionForVirtualPool(cos.getLabel(), "bucket");
}
String task = UUID.randomUUID().toString();
_log.info(String.format("BucketUpdate --- Bucket id: %1$s, Task: %2$s", id, task));
StorageSystem storageSystem =
_dbClient.queryObject(StorageSystem.class, bucket.getStorageDevice());
Operation op =
_dbClient.createTaskOpStatus(
Bucket.class, bucket.getId(), task, ResourceOperationTypeEnum.UPDATE_BUCKET);
op.setDescription("Bucket update");
ObjectController controller =
getController(ObjectController.class, storageSystem.getSystemType());
controller.updateBucket(bucket.getStorageDevice(), id, softQuota, hardQuota, retention, task);
auditOp(
OperationTypeEnum.UPDATE_BUCKET,
true,
AuditLogManager.AUDITOP_BEGIN,
bucket.getId().toString(),
bucket.getStorageDevice().toString());
return toTask(bucket, task, op);
}
/**
* Allocate, initialize and persist state of the Bucket being created.
*
* @param param
* @param project
* @param tenantOrg
* @param neighborhood
* @param vpool
* @param flags
* @param placement
* @return
*/
private Bucket prepareBucket(
BucketParam param,
Project project,
TenantOrg tenantOrg,
VirtualArray neighborhood,
VirtualPool vpool,
DataObject.Flag[] flags,
BucketRecommendation placement) {
_log.debug("Preparing Bucket creation for Param : {}", param);
StoragePool pool = null;
Bucket bucket = new Bucket();
bucket.setId(URIUtil.createId(Bucket.class));
bucket.setLabel(param.getLabel().replaceAll(SPECIAL_CHAR_REGEX, ""));
bucket.setHardQuota(SizeUtil.translateSize(param.getHardQuota()));
bucket.setSoftQuota(SizeUtil.translateSize(param.getSoftQuota()));
bucket.setRetention(Integer.valueOf(param.getRetention()));
bucket.setOwner(getOwner(param.getOwner()));
bucket.setNamespace(tenantOrg.getNamespace());
bucket.setVirtualPool(param.getVpool());
if (project != null) {
bucket.setProject(new NamedURI(project.getId(), bucket.getLabel()));
}
bucket.setTenant(new NamedURI(tenantOrg.getId(), param.getLabel()));
bucket.setVirtualArray(neighborhood.getId());
if (null != placement.getSourceStoragePool()) {
pool = _dbClient.queryObject(StoragePool.class, placement.getSourceStoragePool());
if (null != pool) {
bucket.setProtocol(new StringSet());
bucket
.getProtocol()
.addAll(
VirtualPoolUtil.getMatchingProtocols(vpool.getProtocols(), pool.getProtocols()));
}
}
bucket.setStorageDevice(placement.getSourceStorageSystem());
bucket.setPool(placement.getSourceStoragePool());
bucket.setOpStatus(new OpStatusMap());
// Bucket name to be used at Storage System
String bucketName = project.getLabel() + UNDER_SCORE + param.getLabel();
bucket.setName(bucketName.replaceAll(SPECIAL_CHAR_REGEX, ""));
// Update Bucket path
StringBuilder bucketPath = new StringBuilder();
bucketPath
.append(tenantOrg.getNamespace())
.append(SLASH)
.append(project.getLabel())
.append(SLASH)
.append(param.getLabel());
bucket.setPath(bucketPath.toString());
if (flags != null) {
bucket.addInternalFlags(flags);
}
_dbClient.createObject(bucket);
return bucket;
}
@Override
protected URI getTenantOwner(URI id) {
Bucket bucket = queryResource(id);
return bucket.getTenant().getURI();
}
private TaskResourceRep initiateBucketCreation(
BucketParam param, Project project, TenantOrg tenant, DataObject.Flag[] flags)
throws InternalException {
ArgValidator.checkFieldUriType(param.getVpool(), VirtualPool.class, "vpool");
ArgValidator.checkFieldUriType(param.getVarray(), VirtualArray.class, "varray");
Long softQuota = SizeUtil.translateSize(param.getSoftQuota());
Long hardQuota = SizeUtil.translateSize(param.getHardQuota());
Integer retention = Integer.valueOf(param.getRetention());
// Hard Quota should be more than SoftQuota
verifyQuotaValues(softQuota, hardQuota, param.getLabel());
// check varray
VirtualArray neighborhood = _dbClient.queryObject(VirtualArray.class, param.getVarray());
ArgValidator.checkEntity(neighborhood, param.getVarray(), false);
_permissionsHelper.checkTenantHasAccessToVirtualArray(tenant.getId(), neighborhood);
// check vpool reference
VirtualPool cos = _dbClient.queryObject(VirtualPool.class, param.getVpool());
_permissionsHelper.checkTenantHasAccessToVirtualPool(tenant.getId(), cos);
ArgValidator.checkEntity(cos, param.getVpool(), false);
if (!VirtualPool.Type.object.name().equals(cos.getType())) {
throw APIException.badRequests.virtualPoolNotForObjectStorage(VirtualPool.Type.object.name());
}
// verify retention. Its validated only if Retention is configured.
if (retention != 0 && cos.getMaxRetention() != 0 && retention > cos.getMaxRetention()) {
throw APIException.badRequests.insufficientRetentionForVirtualPool(cos.getLabel(), "bucket");
}
VirtualPoolCapabilityValuesWrapper capabilities = new VirtualPoolCapabilityValuesWrapper();
capabilities.put(VirtualPoolCapabilityValuesWrapper.RESOURCE_COUNT, Integer.valueOf(1));
capabilities.put(VirtualPoolCapabilityValuesWrapper.THIN_PROVISIONING, Boolean.FALSE);
List<BucketRecommendation> placement =
_bucketScheduler.placeBucket(neighborhood, cos, capabilities);
if (placement.isEmpty()) {
throw APIException.badRequests.noMatchingStoragePoolsForVpoolAndVarray(
cos.getId(), neighborhood.getId());
}
// Randomly select a recommended pool
Collections.shuffle(placement);
BucketRecommendation recommendation = placement.get(0);
String task = UUID.randomUUID().toString();
Bucket bucket = prepareBucket(param, project, tenant, neighborhood, cos, flags, recommendation);
_log.info(
String.format(
"createBucket --- Bucket: %1$s, StoragePool: %2$s, StorageSystem: %3$s",
bucket.getId(),
recommendation.getSourceStoragePool(),
recommendation.getSourceStorageSystem()));
Operation op =
_dbClient.createTaskOpStatus(
Bucket.class, bucket.getId(), task, ResourceOperationTypeEnum.CREATE_BUCKET);
op.setDescription("Bucket Create");
// Controller invocation
StorageSystem system =
_dbClient.queryObject(StorageSystem.class, recommendation.getSourceStorageSystem());
ObjectController controller = getController(ObjectController.class, system.getSystemType());
controller.createBucket(
recommendation.getSourceStorageSystem(),
recommendation.getSourceStoragePool(),
bucket.getId(),
bucket.getName(),
bucket.getNamespace(),
bucket.getRetention(),
bucket.getHardQuota(),
bucket.getSoftQuota(),
bucket.getOwner(),
task);
auditOp(
OperationTypeEnum.CREATE_BUCKET,
true,
AuditLogManager.AUDITOP_BEGIN,
param.getLabel(),
param.getHardQuota(),
neighborhood.getId().toString(),
project == null ? null : project.getId().toString());
return toTask(bucket, task, op);
}