int main (void) {
// Get Service
ds3_client* client;
ds3_request* request;
ds3_error* error;
ds3_get_service_response *response;
uint64_t i;
// Create a client from environment variables
error = ds3_create_client_from_env(&client);
handle_error(error);
// Create the get service request. All requests to a DS3 appliance start this way.
// All ds3_init_* functions return a ds3_request struct
request = ds3_init_get_service();
// This performs the request to a DS3 appliance.
// If there is an error 'error' will not be NULL
// If the request completed successfully then 'error' will be NULL
error = ds3_get_service(client, request, &response);
ds3_free_request(request);
handle_error(error);
if(response->num_buckets == 0) {
printf("No buckets returned\n");
ds3_free_service_response(response);
ds3_free_creds(client->creds);
ds3_free_client(client);
return 0;
}
for (i = 0; i < response->num_buckets; i++) {
ds3_bucket bucket = response->buckets[i];
printf("Bucket: (%s) created on %s\n", bucket.name->value, bucket.creation_date->value);
}
ds3_free_service_response(response);
ds3_free_creds(client->creds);
ds3_free_client(client);
ds3_cleanup();
return 0;
}
int main(void) {
// The bucket the files will be stored in
const char* bucket_name = BUCKETNAME;
// A list of files to bulk put
const char* books[4] = BOOKS;
// Get a client instance which uses the environment variables to get the endpoint and credentials
ds3_client* client;
ds3_request* request;
ds3_error* error;
ds3_bulk_object_list_response* obj_list;
ds3_master_object_list_response* chunks_response;
ds3_bulk_object_response* current_obj_to_put;
uint64_t chunk_count, current_chunk_count = 0;
uint64_t chunk_index, obj_index;
FILE* obj_file;
// Create a client from environment variables
error = ds3_create_client_from_env(&client);
handle_error(error);
// Create a bucket where our files will be stored
request = ds3_init_put_bucket_request(bucket_name); // We need to create the request
error = ds3_put_bucket_request(client, request); // This will send the request
ds3_request_free(request);
handle_error(error);
// This takes a list of files and creates ds3 object structs. The files
// must exist as is so that the call can get their sizes. If the files have their
// names translated as objects, this call must be performed manually
obj_list = ds3_convert_file_list(books, 4);
// Initialize the bulk put request
request = ds3_init_put_bulk_job_spectra_s3_request(bucket_name, obj_list);
// Send the bulk put request to the server
error = ds3_put_bulk_job_spectra_s3_request(client, request, &chunks_response);
ds3_request_free(request);
ds3_bulk_object_list_response_free(obj_list);
handle_error(error);
chunk_count = chunks_response->num_objects;
// Bulk jobs are split into multiple chunks which then need to be transferred
while (current_chunk_count < chunk_count) {
// Get the chunks that the server can receive. The server may not be able to receive everything, so not all chunks will necessarily be returned
request = ds3_init_get_job_chunks_ready_for_client_processing_spectra_s3_request(chunks_response->job_id->value);
error = ds3_get_job_chunks_ready_for_client_processing_spectra_s3_request(client, request, &chunks_response);
ds3_request_free(request);
handle_error(error);
// Check to see if any chunks can be processed
if (chunks_response->num_objects > 0) {
// Loop through all the chunks that are avaiable for processing, and send the files that are contained in them
for (chunk_index = 0; chunk_index < chunks_response->num_objects; chunk_index++) {
ds3_objects_response* chunk_object_list = chunks_response->objects[chunk_index];
for (obj_index = 0; obj_index < chunk_object_list->num_objects; obj_index++) {
current_obj_to_put = chunk_object_list->objects[obj_index];
request = ds3_init_put_object_request(bucket_name, current_obj_to_put->name->value, current_obj_to_put->length);
ds3_request_set_job(request, chunks_response->job_id->value);
ds3_request_set_offset(request, current_obj_to_put->offset);
obj_file = fopen(current_obj_to_put->name->value, "r");
error = ds3_put_object_request(client, request, obj_file, ds3_read_from_file);
ds3_request_free(request);
fclose(obj_file);
handle_error(error);
}
current_chunk_count++;
}
}
else {
// When no chunks are returned we need to sleep to allow for cache space to be freed
sleep(300);
}
}
// Cleanup the client and sdk
ds3_master_object_list_response_free(chunks_response);
ds3_creds_free(client->creds);
ds3_client_free(client);
ds3_cleanup();
return 0;
}
