void XtfsUtilServer::OpSetDefaultRP(const xtreemfs::pbrpc::UserCredentials& uc,
const Json::Value& input,
Json::Value* output) {
if (!input.isMember("path")
|| !input["path"].isString()
|| !input.isMember("replication-factor")
|| !input["replication-factor"].isInt()
|| !input.isMember("update-policy")
|| !input["update-policy"].isString()
|| !input.isMember("replication-flags")
|| !input["replication-flags"].isInt()) {
(*output)["error"] = Json::Value("One of the following fields is missing or"
" has an invalid value: path, factor, "
"update-policy, replication-flags");
return;
}
const string path = input["path"].asString();
Json::Value xattr_value(Json::objectValue);
xattr_value["replication-factor"] = input["replication-factor"];
xattr_value["update-policy"] = input["update-policy"];
xattr_value["replication-flags"] = input["replication-flags"];
Json::FastWriter writer;
volume_->SetXAttr(uc,
path,
"xtreemfs.default_rp",
writer.write(xattr_value),
xtreemfs::pbrpc::XATTR_FLAGS_REPLACE);
(*output)["result"] = Json::Value(Json::objectValue);
}
static bRC setAcl(bpContext *ctx, acl_pkt *ap)
{
int status;
unser_declare;
uint32_t acl_name_length;
uint32_t xattr_value_length;
POOL_MEM xattr_value(PM_MESSAGE),
acl_name(PM_MESSAGE);
plugin_ctx *p_ctx = (plugin_ctx *)ctx->pContext;
if (!p_ctx) {
return bRC_Error;
}
unser_begin(ap->content, ap->content_length);
while (unser_length(ap->content) < ap->content_length) {
unser_uint32(acl_name_length);
/*
* Decode the ACL name including the \0
*/
acl_name.check_size(acl_name_length);
unser_bytes(acl_name.c_str(), acl_name_length);
unser_uint32(xattr_value_length);
/*
* Decode the actual ACL data as stored as XATTR.
*/
xattr_value.check_size(xattr_value_length);
unser_bytes(xattr_value.c_str(), xattr_value_length);
status = ceph_lsetxattr(p_ctx->cmount, ap->fname, acl_name.c_str(),
xattr_value.c_str(), xattr_value_length, 0);
if (status < 0) {
berrno be;
Jmsg(ctx, M_ERROR, "ceph_lsetxattr(%s) failed: %s\n", ap->fname, be.bstrerror(-status));
return bRC_Error;
}
}
unser_end(ap->content, ap->content_length);
return bRC_OK;
}
static bRC getXattr(bpContext *ctx, xattr_pkt *xp)
{
char *bp;
bool skip_xattr;
int status, current_size;
int32_t xattr_value_length;
POOL_MEM xattr_value(PM_MESSAGE);
plugin_ctx *p_ctx = (plugin_ctx *)ctx->pContext;
if (!p_ctx) {
return bRC_Error;
}
/*
* See if we need to retrieve the xattr list.
*/
if (!p_ctx->processing_xattr) {
while (1) {
current_size = sizeof_pool_memory(p_ctx->xattr_list);
status = ceph_llistxattr(p_ctx->cmount, xp->fname, p_ctx->xattr_list, current_size);
if (status < 0) {
berrno be;
switch (status) {
#if defined(ENOTSUP) || defined(EOPNOTSUPP)
#if defined(ENOTSUP)
case ENOTSUP:
#endif
#if defined(EOPNOTSUPP) && EOPNOTSUPP != ENOTSUP
case EOPNOTSUPP:
#endif
return bRC_OK;
#endif
case -ERANGE:
/*
* Not enough room in buffer double its size and retry.
*/
p_ctx->xattr_list = check_pool_memory_size(p_ctx->xattr_list, current_size * 2);
continue;
default:
Jmsg(ctx, M_ERROR, "ceph_llistxattr(%s) failed: %s\n", xp->fname, be.bstrerror(-status));
return bRC_Error;
}
}
/*
* Retrieved the xattr list so break the loop.
*/
break;
}
p_ctx->next_xattr_name = p_ctx->xattr_list;
p_ctx->processing_xattr = true;
}
while (1) {
/*
* On some OSes you also get the acls in the extented attribute list.
* So we check if we are already backing up acls and if we do we
* don't store the extended attribute with the same info.
*/
skip_xattr = false;
if (bit_is_set(FO_ACL, p_ctx->flags)) {
for (int cnt = 0; xattr_acl_skiplist[cnt] != NULL; cnt++) {
if (bstrcmp(p_ctx->next_xattr_name, xattr_acl_skiplist[cnt])) {
skip_xattr = true;
break;
}
}
}
if (!skip_xattr) {
current_size = xattr_value.max_size();
xattr_value_length = ceph_lgetxattr(p_ctx->cmount, xp->fname, p_ctx->next_xattr_name,
xattr_value.c_str(), current_size);
if (xattr_value_length < 0) {
berrno be;
switch (xattr_value_length) {
#if defined(ENOATTR) || defined(ENODATA)
#if defined(ENOATTR)
case ENOATTR:
#endif
#if defined(ENODATA) && ENOATTR != ENODATA
case ENODATA:
#endif
skip_xattr = true;
break;
#endif
#if defined(ENOTSUP) || defined(EOPNOTSUPP)
#if defined(ENOTSUP)
case ENOTSUP:
#endif
#if defined(EOPNOTSUPP) && EOPNOTSUPP != ENOTSUP
case EOPNOTSUPP:
#endif
return bRC_OK;
#endif
case -ERANGE:
/*
* Not enough room in buffer double its size and retry.
*/
xattr_value.check_size(current_size * 2);
continue;
default:
Jmsg(ctx, M_ERROR, "ceph_lgetxattr(%s) failed: %s\n", xp->fname, be.bstrerror(-xattr_value_length));
return bRC_Error;
}
}
/*
* Retrieved the xattr so break the loop.
*/
break;
} else {
/*
* No data to retrieve so break the loop.
*/
break;
}
}
if (!skip_xattr) {
xp->name = bstrdup(p_ctx->next_xattr_name);
xp->name_length = strlen(xp->name) + 1;
xp->value = (char *)malloc(xattr_value_length);
memcpy(xp->value, xattr_value.c_str(), xattr_value_length);
xp->value_length = xattr_value_length;
}
/*
* See if there are more xattr to process.
*/
bp = strchr(p_ctx->next_xattr_name, '\0');
if (++bp != '\0') {
p_ctx->next_xattr_name = bp;
return bRC_More;
} else {
/*
* No more reset processing_xattr flag.
*/
p_ctx->processing_xattr = false;
return bRC_OK;
}
}
static bRC getAcl(bpContext *ctx, acl_pkt *ap)
{
bool skip_xattr, abort_retrieval;
int current_size;
int32_t xattr_value_length;
uint32_t content_length = 0;
uint32_t expected_serialize_len;
POOL_MEM xattr_value(PM_MESSAGE),
serialized_acls(PM_MESSAGE);
plugin_ctx *p_ctx = (plugin_ctx *)ctx->pContext;
if (!p_ctx) {
return bRC_Error;
}
abort_retrieval = false;
for (int cnt = 0; xattr_acl_skiplist[cnt] != NULL; cnt++) {
skip_xattr = false;
while (1) {
current_size = xattr_value.max_size();
xattr_value_length = ceph_lgetxattr(p_ctx->cmount, ap->fname, xattr_acl_skiplist[cnt],
xattr_value.c_str(), current_size);
if (xattr_value_length < 0) {
berrno be;
switch (errno) {
#if defined(ENOATTR) || defined(ENODATA)
#if defined(ENOATTR)
case ENOATTR:
#endif
#if defined(ENODATA) && ENOATTR != ENODATA
case ENODATA:
#endif
skip_xattr = true;
break;
#endif
#if defined(ENOTSUP) || defined(EOPNOTSUPP)
#if defined(ENOTSUP)
case ENOTSUP:
#endif
#if defined(EOPNOTSUPP) && EOPNOTSUPP != ENOTSUP
case EOPNOTSUPP:
#endif
abort_retrieval = true;
break;
#endif
case ERANGE:
/*
* Not enough room in buffer double its size and retry.
*/
xattr_value.check_size(current_size * 2);
continue;
default:
Jmsg(ctx, M_ERROR, "ceph_lgetxattr(%s) failed: %s\n", ap->fname, be.bstrerror(-xattr_value_length));
return bRC_Error;
}
}
/*
* Retrieved the xattr so break the loop.
*/
break;
}
if (abort_retrieval) {
break;
}
if (skip_xattr) {
continue;
}
/*
* Serialize the data.
*/
expected_serialize_len = strlen(xattr_acl_skiplist[cnt]) + xattr_value_length + 4;
content_length = serialize_acl_stream(&serialized_acls, expected_serialize_len, content_length,
xattr_acl_skiplist[cnt], strlen(xattr_acl_skiplist[cnt]),
xattr_value.c_str(), xattr_value_length);
}
if (content_length > 0) {
ap->content = (char *)malloc(content_length);
memcpy(ap->content, serialized_acls.c_str(), content_length);
ap->content_length = content_length;
}
return bRC_OK;
}
