int
main(int argc,
char **argv)
{
int ret;
dpl_ctx_t *ctx;
char *bucket = NULL;
if (2 != argc)
{
fprintf(stderr, "usage: recurse bucket\n");
ret = 1;
goto end;
}
bucket = argv[1];
ret = dpl_init();
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_init failed\n");
ret = 1;
goto end;
}
ctx = dpl_ctx_new(NULL, NULL);
if (NULL == ctx)
{
fprintf(stderr, "dpl_ctx_new failed\n");
ret = 1;
goto free_dpl;
}
ctx->cur_bucket = strdup(bucket);
if (! ctx->cur_bucket)
{
perror("strdup");
ret = 1;
goto free_all;
}
ret = recurse(ctx, "/", 0);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error recursing\n");
ret = 1;
goto free_all;
}
ret = 0;
free_all:
dpl_ctx_free(ctx);
free_dpl:
dpl_free();
end:
return ret;
}
int
main(int argc,
char **argv)
{
int ret;
dpl_ctx_t *ctx;
char opt;
char *profile = NULL;
while ((opt = getopt(argc, argv, "p:")) != -1)
switch (opt)
{
case 'p':
profile = strdup(optarg);
assert(NULL != profile);
break ;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 0)
usage();
ret = dpl_init();
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_init failed\n");
exit(1);
}
ctx = dpl_ctx_new(NULL, profile);
if (NULL == ctx)
{
fprintf(stderr, "dpl_ctx_new failed\n");
exit(1);
}
ret = dpl_print_capabilities(ctx);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "get cap failed: %s (%d)\n", dpl_status_str(ret), ret);
exit(1);
}
dpl_ctx_free(ctx);
dpl_free();
exit(0);
}
int
main(int argc,
char **argv)
{
int ret;
char opt;
dpl_req_t *req = NULL;
dpl_dict_t *headers_request = NULL;
dpl_dict_t *query_params = NULL;
char header[8192];
u_int header_len;
optind = 0;
ret = dpl_init();
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error initing droplet\n");
exit(1);
}
ctx = dpl_ctx_new(NULL, NULL);
if (NULL == ctx)
{
fprintf(stderr, "error creating droplet ctx\n");
exit(1);
}
req = dpl_req_new(ctx);
if (NULL == req)
{
fprintf(stderr, "error creating req\n");
exit(1);
}
while ((opt = getopt(argc, argv, "m:b:r:s:Mc:C:et:q:")) != -1)
switch (opt)
{
case 'm':
{
dpl_method_t method;
method = dpl_method(optarg);
if (-1 == method)
{
fprintf(stderr, "unknown method %s\n", optarg);
break ;
}
dpl_req_set_method(req, method);
break ;
}
case 'b':
{
ret = dpl_req_set_bucket(req, optarg);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error setting bucket %s\n", optarg);
exit(1);
}
break ;
}
case 'r':
{
ret = dpl_req_set_resource(req, optarg);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error setting resource %s: %s (%d)\n", optarg, dpl_status_str(ret), ret);
exit(1);
}
break ;
}
case 's':
{
ret = dpl_req_set_subresource(req, optarg);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error setting subresource %s: %s (%d)\n", optarg, dpl_status_str(ret), ret);
exit(1);
}
break ;
}
case 'M':
{
dpl_req_add_behavior(req, DPL_BEHAVIOR_MD5);
break ;
}
case 'c':
{
int fd;
struct stat st;
dpl_chunk_t *chunk;
ssize_t cc;
fd = open(optarg, O_RDONLY);
if (-1 == fd)
xperror("open");
ret = fstat(fd, &st);
if (-1 == ret)
xperror("stat");
chunk = xmalloc(sizeof (*chunk));
chunk->buf = xmalloc(st.st_size);
cc = read(fd, chunk->buf, st.st_size);
if (cc != st.st_size)
{
fprintf(stderr, "short read\n");
exit(1);
}
chunk->len = st.st_size;
dpl_req_set_chunk(req, chunk);
close(fd);
break ;
}
case 'C':
{
ret = dpl_req_set_content_type(req, optarg);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error setting content_type %s: %s (%d)\n", optarg, dpl_status_str(ret), ret);
exit(1);
}
break ;
}
case 'e':
{
dpl_req_add_behavior(req, DPL_BEHAVIOR_EXPECT);
break ;
}
case 't':
{
ctx->trace_level = strtoul(optarg, NULL, 0);
break ;
}
case 'q':
{
query_params = dpl_parse_query_params(optarg);
if (NULL == query_params)
{
fprintf(stderr, "error parsing query_params\n");
exit(1);
}
break ;
}
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
#if 0
{
extern void test_strrstr();
test_strrstr();
exit(0);
}
#endif
if (0 != argc)
{
usage();
}
ret = dpl_req_build(req, &headers_request);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error in request: %s (%d)\n", dpl_status_str(ret), ret);
exit(1);
}
ret = dpl_req_gen_http_request(req, headers_request, query_params, header, sizeof (header), &header_len);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error in request: %s (%d)\n", dpl_status_str(ret), ret);
exit(1);
}
ret = fwrite(header, header_len, 1, stdout);
if (1 != ret)
{
fprintf(stderr, "short write\n");
exit(1);
}
dpl_dict_free(headers_request);
if (NULL != query_params)
dpl_dict_free(query_params);
if (NULL != req->chunk)
{
free(req->chunk->buf);
free(req->chunk);
}
dpl_req_free(req);
dpl_ctx_free(ctx);
dpl_free();
return 0;
}
/*
* Open a volume using libdroplet.
*/
int object_store_device::d_open(const char *pathname, int flags, int mode)
{
dpl_status_t status;
dpl_vfile_flag_t dpl_flags;
dpl_option_t dpl_options;
#if 1
Mmsg1(errmsg, _("Object Storage devices are not yet supported, please disable %s\n"), dev_name);
return -1;
#endif
/*
* Initialize the droplet library when its not done previously.
*/
P(mutex);
if (droplet_reference_count == 0) {
status = dpl_init();
if (status != DPL_SUCCESS) {
V(mutex);
return -1;
}
dpl_set_log_func(object_store_logfunc);
droplet_reference_count++;
}
V(mutex);
if (!m_object_configstring) {
int len;
char *bp, *next_option;
bool done;
if (!dev_options) {
Mmsg0(errmsg, _("No device options configured\n"));
Emsg0(M_FATAL, 0, errmsg);
return -1;
}
m_object_configstring = bstrdup(dev_options);
bp = m_object_configstring;
while (bp) {
next_option = strchr(bp, ',');
if (next_option) {
*next_option++ = '\0';
}
done = false;
for (int i = 0; !done && device_options[i].name; i++) {
/*
* Try to find a matching device option.
*/
if (bstrncasecmp(bp, device_options[i].name, device_options[i].compare_size)) {
switch (device_options[i].type) {
case argument_profile:
m_profile = bp + device_options[i].compare_size;
done = true;
break;
case argument_bucket:
m_object_bucketname = bp + device_options[i].compare_size;
done = true;
break;
default:
break;
}
}
}
if (!done) {
Mmsg1(errmsg, _("Unable to parse device option: %s\n"), bp);
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
bp = next_option;
}
if (!m_profile) {
Mmsg0(errmsg, _("No droplet profile configured\n"));
Emsg0(M_FATAL, 0, errmsg);
goto bail_out;
}
/*
* Strip any .profile prefix from the libdroplet profile name.
*/
len = strlen(m_profile);
if (len > 8 && bstrcasecmp(m_profile + (len - 8), ".profile")) {
m_profile[len - 8] = '\0';
}
}
/*
* See if we need to setup a new context for this device.
*/
if (!m_ctx) {
char *bp;
/*
* See if this is a path.
*/
bp = strrchr(m_object_configstring, '/');
if (!bp) {
/*
* Only a profile name.
*/
m_ctx = dpl_ctx_new(NULL, m_object_configstring);
} else {
if (bp == m_object_configstring) {
/*
* Profile in root of filesystem
*/
m_ctx = dpl_ctx_new("/", bp + 1);
} else {
/*
* Profile somewhere else.
*/
*bp++ = '\0';
m_ctx = dpl_ctx_new(m_object_configstring, bp);
}
}
/*
* If we failed to allocate a new context fail the open.
*/
if (!m_ctx) {
Mmsg1(errmsg, _("Failed to create a new context using config %s\n"), dev_options);
return -1;
}
/*
* Login if that is needed for this backend.
*/
status = dpl_login(m_ctx);
switch (status) {
case DPL_SUCCESS:
break;
case DPL_ENOTSUPP:
/*
* Backend doesn't support login which is fine.
*/
break;
default:
Mmsg2(errmsg, _("Failed to login for voume %s using dpl_login(): ERR=%s.\n"),
getVolCatName(), dpl_status_str(status));
return -1;
}
/*
* If a bucketname was defined set it in the context.
*/
if (m_object_bucketname) {
m_ctx->cur_bucket = m_object_bucketname;
}
}
/*
* See if we don't have a file open already.
*/
if (m_vfd) {
dpl_close(m_vfd);
m_vfd = NULL;
}
/*
* Create some options for libdroplet.
*
* DPL_OPTION_NOALLOC - we provide the buffer to copy the data into
* no need to let the library allocate memory we
* need to free after copying the data.
*/
memset(&dpl_options, 0, sizeof(dpl_options));
dpl_options.mask |= DPL_OPTION_NOALLOC;
if (flags & O_CREAT) {
dpl_flags = DPL_VFILE_FLAG_CREAT | DPL_VFILE_FLAG_RDWR;
status = dpl_open(m_ctx, /* context */
getVolCatName(), /* locator */
dpl_flags, /* flags */
&dpl_options, /* options */
NULL, /* condition */
NULL, /* metadata */
NULL, /* sysmd */
NULL, /* query_params */
NULL, /* stream_status */
&m_vfd);
} else {
dpl_flags = DPL_VFILE_FLAG_RDWR;
status = dpl_open(m_ctx, /* context */
getVolCatName(), /* locator */
dpl_flags, /* flags */
&dpl_options, /* options */
NULL, /* condition */
NULL, /* metadata */
NULL, /* sysmd */
NULL, /* query_params */
NULL, /* stream_status */
&m_vfd);
}
switch (status) {
case DPL_SUCCESS:
m_offset = 0;
return 0;
default:
Mmsg2(errmsg, _("Failed to open %s using dpl_open(): ERR=%s.\n"),
getVolCatName(), dpl_status_str(status));
m_vfd = NULL;
return droplet_errno_to_system_errno(status);
}
bail_out:
return -1;
}
int
main(int argc,
char **argv)
{
int ret;
if (2 != argc)
{
fprintf(stderr, "usage: restrest folder\n");
exit(1);
}
folder = argv[1];
if (folder[0] == '/')
{
fprintf(stderr, "folder name must not start with slash");
exit(1);
}
folder_len = strlen(folder);
if (folder_len < 1)
{
fprintf(stderr, "bad folder\n");
exit(1);
}
if (folder[folder_len-1] != '/')
{
fprintf(stderr, "folder name must end with a slash\n");
exit(1);
}
snprintf(file1_path, sizeof (file1_path), "%s%s", folder, FILE1);
snprintf(file2_path, sizeof (file2_path), "%s%s", folder, FILE2);
snprintf(file3_path, sizeof (file3_path), "%s%s", folder, FILE3);
snprintf(file4_path, sizeof (file4_path), "%s%s", folder, FILE4);
ret = dpl_init(); //init droplet library
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_init failed\n");
exit(1);
}
//open default profile
ctx = dpl_ctx_new(NULL, //droplet directory, default: "~/.droplet"
NULL); //droplet profile, default: "default"
if (NULL == ctx)
{
fprintf(stderr, "dpl_ctx_new failed\n");
ret = 1;
}
//ctx->trace_level = ~0;
//ctx->trace_buffers = 1;
pool = dpl_task_pool_create(ctx, "resttest", 10);
if (NULL == pool)
{
fprintf(stderr, "error creating pool\n");
exit(1);
}
/**/
pthread_mutex_init(&prog_lock, NULL);
pthread_cond_init(&prog_cond, NULL);
make_folder();
pthread_cond_wait(&prog_cond, &prog_lock);
return 0;
}
int
main(int argc,
char **argv)
{
int ret;
dpl_ctx_t *ctx;
dpl_dict_t *metadata = NULL;
char *data_buf = NULL;
size_t data_len;
char *data_buf_returned = NULL;
u_int data_len_returned;
dpl_dict_t *metadata_returned = NULL;
dpl_dict_t *metadata2_returned = NULL;
dpl_dict_var_t *metadatum = NULL;
dpl_option_t option;
dpl_sysmd_t sysmd;
char *force_id = NULL;
if (2 == argc)
{
force_id = argv[1];
}
else if (1 != argc)
{
fprintf(stderr, "usage: idtest [id]\n");
ret = 1;
goto end;
}
ret = dpl_init(); //init droplet library
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_init failed\n");
ret = 1;
goto end;
}
//open default profile
ctx = dpl_ctx_new(NULL, //droplet directory, default: "~/.droplet"
NULL); //droplet profile, default: "default"
if (NULL == ctx)
{
fprintf(stderr, "dpl_ctx_new failed\n");
ret = 1;
goto free_dpl;
}
//ctx->trace_level = ~0;
//ctx->trace_buffers = 1;
data_len = 10000;
data_buf = malloc(data_len);
if (NULL == data_buf)
{
fprintf(stderr, "alloc data failed\n");
ret = 1;
goto free_all;
}
memset(data_buf, 'z', data_len);
metadata = dpl_dict_new(13);
if (NULL == metadata)
{
fprintf(stderr, "dpl_dict_new failed\n");
ret = 1;
goto free_all;
}
ret = dpl_dict_add(metadata, "foo", "bar", 0);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_dict_add failed\n");
ret = 1;
goto free_all;
}
ret = dpl_dict_add(metadata, "foo2", "qux", 0);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_dict_add failed\n");
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "setting object+MD\n");
if (force_id)
{
//we have a broken cloud storage with no POST
ret = dpl_put_id(ctx, //the context
NULL, //no bucket
force_id, //the id
NULL, //no option
DPL_FTYPE_REG, //regular object
NULL, //no condition
NULL, //no range
metadata, //the metadata
NULL, //no sysmd
data_buf, //object body
data_len); //object length
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_put_id failed: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
//emulate returned sysmd
memset(&sysmd, 0, sizeof (sysmd));
strncpy(sysmd.id, force_id, sizeof (sysmd.id));
}
else
{
ret = dpl_post_id(ctx, //the context
NULL, //no bucket
NULL, //no id
NULL, //no option
DPL_FTYPE_REG, //regular object
NULL, //condition
NULL, //range
metadata, //the metadata
NULL, //no sysmd
data_buf, //object body
data_len, //object length
NULL, //no query params
&sysmd); //the returned sysmd
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_post_id failed: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
if (!(sysmd.mask & DPL_SYSMD_MASK_ID))
{
fprintf(stderr, "backend is not capable of retrieving resource id\n");
exit(1);
}
fprintf(stderr, "id=%s\n", sysmd.id);
}
/**/
fprintf(stderr, "getting object+MD\n");
option.mask = DPL_OPTION_LAZY; //enable this for faster GETs
ret = dpl_get_id(ctx, //the context
NULL, //no bucket
sysmd.id, //the key
&option, //options
DPL_FTYPE_REG, //object type
NULL, //no condition
NULL, //no range
&data_buf_returned, //data object
&data_len_returned, //data object length
&metadata_returned, //metadata
NULL); //sysmd
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_get_id failed: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
fprintf(stderr, "checking object\n");
if (data_len != data_len_returned)
{
fprintf(stderr, "data lengths mismatch\n");
ret = 1;
goto free_all;
}
if (0 != memcmp(data_buf, data_buf_returned, data_len))
{
fprintf(stderr, "data content mismatch\n");
ret = 1;
goto free_all;
}
fprintf(stderr, "checking metadata\n");
metadatum = dpl_dict_get(metadata_returned, "foo");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
ret = 1;
goto free_all;
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(dpl_sbuf_get_str(metadatum->val->string), "bar"))
{
fprintf(stderr, "bad value in metadatum\n");
ret = 1;
goto free_all;
}
metadatum = dpl_dict_get(metadata_returned, "foo2");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
ret = 1;
goto free_all;
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(dpl_sbuf_get_str(metadatum->val->string), "qux"))
{
fprintf(stderr, "bad value in metadatum\n");
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "setting MD only\n");
ret = dpl_dict_add(metadata, "foo", "bar2", 0);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error updating metadatum: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
ret = dpl_copy_id(ctx, //the context
NULL, //no src bucket
sysmd.id, //the key
NULL, //no dst bucket
sysmd.id, //the same key
NULL, //no option
DPL_FTYPE_REG, //object type
DPL_COPY_DIRECTIVE_METADATA_REPLACE, //tell server to replace metadata
metadata, //the updated metadata
NULL, //no sysmd
NULL); //no condition
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error updating metadata: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "getting MD only\n");
ret = dpl_head_id(ctx, //the context
NULL, //no bucket,
sysmd.id, //the key
NULL, //option
DPL_FTYPE_UNDEF, //no matter the file type
NULL, //no condition,
&metadata2_returned,
NULL); //no sysmd
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error getting metadata: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
fprintf(stderr, "checking metadata\n");
metadatum = dpl_dict_get(metadata2_returned, "foo");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
ret = 1;
goto free_all;
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(dpl_sbuf_get_str(metadatum->val->string), "bar2"))
{
fprintf(stderr, "bad value in metadatum\n");
ret = 1;
goto free_all;
}
metadatum = dpl_dict_get(metadata2_returned, "foo2");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
ret = 1;
goto free_all;
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(dpl_sbuf_get_str(metadatum->val->string), "qux"))
{
fprintf(stderr, "bad value in metadatum\n");
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "delete object+MD\n");
ret = dpl_delete_id(ctx, //the context
NULL, //no bucket
sysmd.id, //the key
NULL, //no option
DPL_FTYPE_UNDEF, //no matter the file type
NULL); //no condition
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error deleting object: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
ret = 0;
free_all:
if (NULL != metadata2_returned)
dpl_dict_free(metadata2_returned);
if (NULL != metadata_returned)
dpl_dict_free(metadata_returned);
if (NULL != data_buf_returned)
free(data_buf_returned);
if (NULL != metadata)
dpl_dict_free(metadata);
if (NULL != data_buf)
free(data_buf);
dpl_ctx_free(ctx); //free context
free_dpl:
dpl_free(); //free droplet library
end:
return ret;
}
int
main(int argc,
char **argv)
{
hash = NULL;
char *bucket = NULL;
dpl_status_t rc = DPL_FAILURE;
int debug = 0;
openlog("dplfs", LOG_CONS | LOG_NOWAIT | LOG_PID, LOG_USER);
if (argc < 3) {
usage(argv[0]);
goto err1;
}
bucket = argv[1];
argc -= 1;
argv += 1;
if (0 == strncmp(argv[0], "-d", 2)) {
debug = 1;
argc--;
argv++;
}
rc = dpl_init();
if (DPL_SUCCESS != rc) {
fprintf(stderr, "dpl_init: %s\n", dpl_status_str(rc));
goto err1;
}
ctx = dpl_ctx_new(NULL, NULL);
if (! ctx)
goto err2;
ctx->trace_level = 0;
ctx->cur_bucket = strdup(bucket);
if (! ctx->cur_bucket) {
fprintf(stderr, "strdup('%s') failed", bucket);
goto err2;
}
droplet_pp(ctx);
/* before calling any glib function in a multithreaded environment */
g_thread_init(NULL);
conf = conf_new();
if (! conf) {
fprintf(stderr, "can't allocate config\n");
goto err2;
}
if (-1 == conf_ctor(conf, argv[1], debug)) {
fprintf(stderr, "can't build a configuration\n");
goto err3;
}
conf_log(conf);
profile_init();
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
rc = dfs_fuse_main(&args);
dpl_ctx_free(ctx);
if (hash)
g_hash_table_remove_all(hash);
err3:
if (conf)
conf_free(conf);
err2:
dpl_free();
err1:
return rc;
}
int
main(int argc,
char **argv)
{
int ret;
dpl_ctx_t *ctx;
char *folder = NULL;
int folder_len;
dpl_dict_t *metadata = NULL;
char *data_buf = NULL;
size_t data_len;
char *data_buf_returned = NULL;
u_int data_len_returned;
dpl_dict_t *metadata_returned = NULL;
dpl_dict_t *metadata2_returned = NULL;
dpl_dict_var_t *metadatum = NULL;
dpl_sysmd_t sysmd;
char new_path[MAXPATHLEN];
dpl_vec_t *files = NULL;
dpl_vec_t *sub_directories = NULL;
int i;
if (2 != argc)
{
fprintf(stderr, "usage: restrest folder\n");
ret = 1;
goto end;
}
folder = argv[1];
folder_len = strlen(folder);
if (folder_len < 1)
{
fprintf(stderr, "bad folder\n");
ret = 1;
goto end;
}
if (folder[folder_len-1] != '/')
{
fprintf(stderr, "folder name must end with a slash\n");
ret = 1;
goto end;
}
ret = dpl_init(); //init droplet library
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_init failed\n");
ret = 1;
goto end;
}
//open default profile
ctx = dpl_ctx_new(NULL, //droplet directory, default: "~/.droplet"
NULL); //droplet profile, default: "default"
if (NULL == ctx)
{
fprintf(stderr, "dpl_ctx_new failed\n");
ret = 1;
goto free_dpl;
}
//ctx->trace_level = ~0;
//ctx->trace_buffers = 1;
/**/
fprintf(stderr, "creating folder\n");
ret = dpl_put(ctx, //the context
NULL, //no bucket
folder, //the folder
NULL, //no option
DPL_FTYPE_DIR, //directory
NULL, //no condition
NULL, //no range
NULL, //no metadata
NULL, //no sysmd
NULL, //object body
0); //object length
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_put failed: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
/**/
data_len = 10000;
data_buf = malloc(data_len);
if (NULL == data_buf)
{
fprintf(stderr, "alloc data failed\n");
ret = 1;
goto free_all;
}
memset(data_buf, 'z', data_len);
metadata = dpl_dict_new(13);
if (NULL == metadata)
{
fprintf(stderr, "dpl_dict_new failed\n");
ret = 1;
goto free_all;
}
ret = dpl_dict_add(metadata, "foo", "bar", 0);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_dict_add failed\n");
ret = 1;
goto free_all;
}
ret = dpl_dict_add(metadata, "foo2", "qux", 0);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_dict_add failed\n");
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "atomic creation of an object+MD\n");
ret = dpl_post(ctx, //the context
NULL, //no bucket
folder, //the folder
NULL, //no option
DPL_FTYPE_REG, //regular object
NULL, //condition
NULL, //range
metadata, //the metadata
NULL, //no sysmd
data_buf, //object body
data_len, //object length
NULL, //no query params
&sysmd); //the returned sysmd
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_post failed: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
if (!(sysmd.mask & DPL_SYSMD_MASK_PATH))
{
fprintf(stderr, "path is absent from sysmd\n");
ret = 1;
goto free_all;
}
fprintf(stderr, "resource path %s\n", sysmd.path);
snprintf(new_path, sizeof (new_path), "%su.1", folder);
ret = dpl_copy(ctx,
NULL, //no src bucket
sysmd.path, //the src resource
NULL, //no dst bucket
new_path, //dst resource
NULL, //no option
DPL_FTYPE_REG, //regular file
DPL_COPY_DIRECTIVE_MOVE, //rename
NULL, //no metadata
NULL, //no sysmd
NULL); //no server side condition
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_move %s to %s failed: %s (%d)\n", sysmd.path, new_path, dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "getting object+MD\n");
ret = dpl_get(ctx, //the context
NULL, //no bucket
new_path, //the key
NULL, //no opion
DPL_FTYPE_REG, //object type
NULL, //no condition
NULL, //no range
&data_buf_returned, //data object
&data_len_returned, //data object length
&metadata_returned, //metadata
NULL); //sysmd
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_get_id failed: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
fprintf(stderr, "checking object\n");
if (data_len != data_len_returned)
{
fprintf(stderr, "data lengths mismatch\n");
ret = 1;
goto free_all;
}
if (0 != memcmp(data_buf, data_buf_returned, data_len))
{
fprintf(stderr, "data content mismatch\n");
ret = 1;
goto free_all;
}
fprintf(stderr, "checking metadata\n");
metadatum = dpl_dict_get(metadata_returned, "foo");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
ret = 1;
goto free_all;
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(metadatum->val->string, "bar"))
{
fprintf(stderr, "bad value in metadatum\n");
ret = 1;
goto free_all;
}
metadatum = dpl_dict_get(metadata_returned, "foo2");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
ret = 1;
goto free_all;
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(metadatum->val->string, "qux"))
{
fprintf(stderr, "bad value in metadatum\n");
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "setting MD only\n");
ret = dpl_dict_add(metadata, "foo", "bar2", 0);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error updating metadatum: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
ret = dpl_copy(ctx, //the context
NULL, //no src bucket
new_path, //the key
NULL, //no dst bucket
new_path, //the same key
NULL, //no option
DPL_FTYPE_REG, //object type
DPL_COPY_DIRECTIVE_METADATA_REPLACE, //tell server to replace metadata
metadata, //the updated metadata
NULL, //no sysmd
NULL); //no condition
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error updating metadata: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "getting MD only\n");
ret = dpl_head(ctx, //the context
NULL, //no bucket,
new_path, //the key
NULL, //no option
DPL_FTYPE_UNDEF, //no matter the file type
NULL, //no condition,
&metadata2_returned,
NULL);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error getting metadata: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
fprintf(stderr, "checking metadata\n");
metadatum = dpl_dict_get(metadata2_returned, "foo");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
ret = 1;
goto free_all;
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(metadatum->val->string, "bar2"))
{
fprintf(stderr, "bad value in metadatum\n");
ret = 1;
goto free_all;
}
metadatum = dpl_dict_get(metadata2_returned, "foo2");
if (NULL == metadatum)
{
fprintf(stderr, "missing metadatum\n");
ret = 1;
goto free_all;
}
assert(metadatum->val->type == DPL_VALUE_STRING);
if (strcmp(metadatum->val->string, "qux"))
{
fprintf(stderr, "bad value in metadatum\n");
ret = 1;
goto free_all;
}
/**/
fprintf(stderr, "listing of folder\n");
ret = dpl_list_bucket(ctx,
NULL,
folder,
"/",
-1,
&files,
&sub_directories);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error listing folder: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
for (i = 0;i < files->n_items;i++)
{
dpl_object_t *obj = (dpl_object_t *) dpl_vec_get(files, i);
dpl_sysmd_t obj_sysmd;
dpl_dict_t *obj_md = NULL;
ret = dpl_head(ctx,
NULL, //no bucket
obj->path,
NULL, //option
DPL_FTYPE_UNDEF, //no matter the file type
NULL, //condition
&obj_md, //user metadata
&obj_sysmd); //system metadata
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "getattr error on %s: %s (%d)\n", obj->path, dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
fprintf(stderr, "file %s: size=%ld mtime=%lu\n", obj->path, obj_sysmd.size, obj_sysmd.mtime);
//dpl_dict_print(obj_md, stderr, 5);
dpl_dict_free(obj_md);
}
for (i = 0;i < sub_directories->n_items;i++)
{
dpl_common_prefix_t *dir = (dpl_common_prefix_t *) dpl_vec_get(sub_directories, i);
fprintf(stderr, "dir %s\n", dir->prefix);
}
/**/
fprintf(stderr, "delete object+MD\n");
ret = dpl_delete(ctx, //the context
NULL, //no bucket
new_path, //the key
NULL, //no option
DPL_FTYPE_UNDEF, //no matter the file type
NULL); //no condition
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error deleting object: %s (%d)\n", dpl_status_str(ret), ret);
ret = 1;
goto free_all;
}
ret = 0;
free_all:
if (NULL != sub_directories)
dpl_vec_common_prefixes_free(sub_directories);
if (NULL != files)
dpl_vec_objects_free(files);
if (NULL != metadata2_returned)
dpl_dict_free(metadata2_returned);
if (NULL != metadata_returned)
dpl_dict_free(metadata_returned);
if (NULL != data_buf_returned)
free(data_buf_returned);
if (NULL != metadata)
dpl_dict_free(metadata);
if (NULL != data_buf)
free(data_buf);
dpl_ctx_free(ctx); //free context
free_dpl:
dpl_free(); //free droplet library
end:
return ret;
}
int
main(int argc,
char **argv)
{
char opt;
int ret;
dpl_ctx_t *ctx;
char *src_id = NULL;
char *dst_id = NULL;
char *profile = NULL;
char *src_bucket = NULL;
char *dst_bucket = NULL;
dpl_condition_t cond, *condp = NULL;
dpl_dict_t *metadata = NULL;
dpl_option_t option, *optionp = NULL;
dpl_copy_directive_t copy_directive = DPL_COPY_DIRECTIVE_UNDEF;
while ((opt = getopt(argc, argv, "p:S:D:C:M:O:c:")) != -1)
switch (opt)
{
case 'p':
profile = strdup(optarg);
assert(NULL != profile);
break ;
case 'S':
src_bucket = strdup(optarg);
assert(NULL != src_bucket);
break ;
case 'D':
dst_bucket = strdup(optarg);
assert(NULL != dst_bucket);
break ;
case 'C':
ret = dpl_parse_condition(optarg, &cond);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error in parsing condition: %s (%d)\n", dpl_status_str(ret), ret);
exit(1);
}
condp = &cond;
break ;
case 'M':
metadata = dpl_parse_metadata(optarg);
assert(NULL != metadata);
break ;
case 'O':
ret = dpl_parse_option(optarg, &option);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "error in parsing option: %s (%d)\n", dpl_status_str(ret), ret);
exit(1);
}
optionp = &option;
break ;
case 'c':
copy_directive = dpl_copy_directive(optarg);
break ;
case '?':
default:
usage();
}
argc -= optind;
argv += optind;
if (argc != 2)
usage();
src_id = argv[0];
dst_id = argv[1];
ret = dpl_init(); //init droplet library
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_init failed\n");
exit(1);
}
//open default profile
ctx = dpl_ctx_new(NULL, profile);
if (NULL == ctx)
{
fprintf(stderr, "dpl_ctx_new failed\n");
exit(1);
}
ret = dpl_copy_id(ctx,
src_bucket,
src_id,
dst_bucket,
dst_id,
optionp,
DPL_FTYPE_REG,
copy_directive,
metadata,
NULL, //no sysmd
condp);
if (DPL_SUCCESS != ret)
{
fprintf(stderr, "dpl_copy_id failed: %s (%d)\n", dpl_status_str(ret), ret);
exit(1);
}
if (NULL != metadata)
dpl_dict_free(metadata);
dpl_ctx_free(ctx); //free context
dpl_free(); //free droplet library
exit(0);
}