Updating bulk request payloads to marshal version

Author: RachelTucker

src/ds3.c

@@ -350,6 +350,8 @@ ds3_bulk_object_list_response* ds3_convert_object_list(const ds3_contents_respon
     for (object_index = 0; object_index < num_objects; object_index++) {
         ds3_bulk_object_response* response = g_new0(ds3_bulk_object_response, 1);
         response->name = ds3_str_dup(objects[object_index]->key);
+        response->version = ds3_str_dup(objects[object_index]->version_id);
+
         g_ptr_array_add(ds3_bulk_object_response_array, response);
     }
 

src/ds3_requests.c

@@ -439,6 +439,10 @@ static xmlDocPtr _generate_xml_bulk_objects_list(const ds3_bulk_object_list_resp
         if (list_type == BULK_PUT) {
             xmlSetProp(object_node, (xmlChar*) "Size", (xmlChar*) size_buff);
         }
+
+        if (list_type == BULK_GET && obj->version != NULL && strlen(obj->version->value) != 0) {
+        	xmlSetProp(object_node, (xmlChar*) "VersionId", (xmlChar*) obj->version->value);
+        }
     }
 
     xmlDocSetRootElement(doc, objects_node);
@@ -15754,6 +15758,9 @@ ds3_error* ds3_replicate_put_job_spectra_s3_request(const ds3_client* client, co
     return _parse_top_level_ds3_master_object_list_response(client, request, response, xml_blob);
 }
 ds3_error* ds3_stage_objects_job_spectra_s3_request(const ds3_client* client, const ds3_request* request) {
+    ds3_error* error;
+    ds3_xml_send_buff send_buff;
+    GByteArray* xml_blob;
 
     int num_slashes = num_chars_in_ds3_str(request->path, '/');
     if (num_slashes < 2 || ((num_slashes == 2) && ('/' == request->path->value[request->path->size-1]))) {
@@ -15762,7 +15769,17 @@ ds3_error* ds3_stage_objects_job_spectra_s3_request(const ds3_client* client, co
         return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource id parameter is required.");
     }
 
-    return _internal_request_dispatcher(client, request, NULL, NULL, NULL, NULL, NULL);
+    error = _init_request_payload(request, &send_buff, BULK_GET);
+    if (error != NULL) return error;
+
+    xml_blob = g_byte_array_new();
+    error = _internal_request_dispatcher(client, request, xml_blob, ds3_load_buffer, (void*) &send_buff, _ds3_send_xml_buff, NULL);
+
+    // Clean up the data sent to the server
+    xmlFree(send_buff.buff);
+
+    g_byte_array_free(xml_blob, TRUE);
+    return error;
 }
 ds3_error* ds3_truncate_active_job_spectra_s3_request(const ds3_client* client, const ds3_request* request) {
 

test/negative_tests.cpp

@@ -19,6 +19,9 @@
 #include "test.h"
 #include <boost/test/unit_test.hpp>
 
+
+
+
 //Testing a Duplicate Bucket Put
 BOOST_AUTO_TEST_CASE(put_duplicate_bucket) {
     printf("-----Negative Testing Duplicate Bucket Creation-------\n");
@@ -75,6 +78,7 @@ BOOST_AUTO_TEST_CASE(delete_non_existing_bucket){
     request = ds3_init_delete_bucket_request(bucket_name);
     error = ds3_delete_bucket_request(client, request);
     ds3_request_free(request);
+
     BOOST_CHECK(error != NULL);
     BOOST_CHECK(error->error->http_error_code == 404);
     BOOST_CHECK(strcmp(error->error->code->value ,"Not Found")==0);
@@ -178,6 +182,7 @@ BOOST_AUTO_TEST_CASE(head_bucket_non_existing_bucket){
     request = ds3_init_head_bucket_request(bucket_name);
     error = ds3_head_bucket_request(client, request);
     ds3_request_free(request);
+
     BOOST_CHECK(error != NULL);
     BOOST_CHECK(error->error->http_error_code == 404);
     BOOST_CHECK(strcmp(error->error->code->value ,"Not Found")==0);
@@ -225,7 +230,7 @@ BOOST_AUTO_TEST_CASE(delete_non_existing_object) {
     free_client(client);
 
     BOOST_REQUIRE(error != NULL);
-	  BOOST_CHECK(error->error->http_error_code == 404);
+    BOOST_CHECK(error->error->http_error_code == 404);
     BOOST_CHECK(strcmp(error->error->code->value ,"Not Found") == 0);
     ds3_error_free(error);
 }
@@ -256,7 +261,7 @@ BOOST_AUTO_TEST_CASE( put_bucket_bucket_name_with_trailing_slash){
     BOOST_CHECK(put_bucket_error != NULL);
     BOOST_CHECK(put_bucket_error->code == DS3_ERROR_BAD_STATUS_CODE);
     BOOST_CHECK(put_bucket_error->error->http_error_code == 400);
-    BOOST_CHECK_EQUAL( g_strcmp0(put_bucket_error->error->code->value, "Bad Request"), 0);
+    BOOST_CHECK(strcmp(put_bucket_error->error->code->value, "Bad Request") == 0);
 
     ds3_error_free(put_bucket_error);
     clear_bucket(client, bucket_name);

test/test.cpp

@@ -76,10 +76,25 @@ void test_log(const char* message, void* user_data) {
     }
 }
 
+void print_error(const ds3_error* error) {
+    if (error == NULL) {
+        return;
+    }
+    if (NULL != error->message) {
+        printf("ds3_error_message: %s\n", error->message->value);
+    }
+    if (error->error != NULL) {
+        printf("ds3_status_code: %lu\n", (unsigned long)error->error->http_error_code);
+        printf("ds3_status_message: %s\n", error->error->message->value);
+        printf("ds3_error_body: %s\n", error->error->code->value);
+    }
+}
+
 ds3_client* get_client_at_loglvl(ds3_log_lvl log_lvl) {
     ds3_client* client;
 
     ds3_error* error = ds3_create_client_from_env(&client);
+    print_error(error);
 
     if (error != NULL) {
         fprintf(stderr, "Failed to construct ds3_client from environment variables: %s\n", error->message->value);
@@ -119,6 +134,8 @@ void configure_for_tests() {
     // Create DataPolicy
     ds3_request* put_dp_request = ds3_init_put_data_policy_spectra_s3_request(TEST_DP_NAME);
     ds3_error* error = ds3_put_data_policy_spectra_s3_request(client, put_dp_request, &put_dp_response);
+    print_error(error);
+
     data_policy_id = ds3_str_init(put_dp_response->id->value);
 
     ds3_request_free(put_dp_request);
@@ -128,6 +145,7 @@ void configure_for_tests() {
     // Create StorageDomain
     ds3_request* put_sd_request = ds3_init_put_storage_domain_spectra_s3_request(TEST_SD_NAME);
     error = ds3_put_storage_domain_spectra_s3_request(client, put_sd_request, &put_sd_response);
+    print_error(error);
     storage_domain_id = ds3_str_init(put_sd_response->id->value);
 
     ds3_request_free(put_sd_request);
@@ -137,6 +155,7 @@ void configure_for_tests() {
     // Create pool partition
     ds3_request* put_pp_request = ds3_init_put_pool_partition_spectra_s3_request(TEST_PP_NAME, DS3_POOL_TYPE_ONLINE);
     error = ds3_put_pool_partition_spectra_s3_request(client, put_pp_request, &put_pp_response);
+    print_error(error);
     pool_partition_id = ds3_str_init(put_pp_response->id->value);
 
     ds3_request_free(put_pp_request);
@@ -146,6 +165,7 @@ void configure_for_tests() {
     // Create storage domain member linking pool partition to storage domain
     ds3_request* put_pool_sd_member_request = ds3_init_put_pool_storage_domain_member_spectra_s3_request(pool_partition_id->value, storage_domain_id->value);
     error = ds3_put_pool_storage_domain_member_spectra_s3_request(client, put_pool_sd_member_request, &put_sd_member_response);
+    print_error(error);
     storage_domain_member_id = ds3_str_init(put_sd_member_response->id->value);
 
     ds3_request_free(put_pool_sd_member_request);
@@ -159,6 +179,7 @@ void configure_for_tests() {
         storage_domain_id->value,
         DS3_DATA_PERSISTENCE_RULE_TYPE_PERMANENT);
     error = ds3_put_data_persistence_rule_spectra_s3_request(client, put_data_persistence_rule_request, &put_data_persistence_rule_response);
+    print_error(error);
     data_persistence_rule_id = ds3_str_init(put_data_persistence_rule_response->id->value);
 
     ds3_request_free(put_data_persistence_rule_request);
@@ -180,47 +201,41 @@ void teardown_after_tests() {
     // Delete DataPersistenceRule
     ds3_request* delete_data_persistence_rule_request = ds3_init_delete_data_persistence_rule_spectra_s3_request(ids.data_persistence_rule_id->value);
     error = ds3_delete_data_persistence_rule_spectra_s3_request(client, delete_data_persistence_rule_request);
+    print_error(error);
     ds3_request_free(delete_data_persistence_rule_request);
     ds3_error_free(error);
 
     // Delete DataPolicy
     ds3_request* delete_data_policy_request = ds3_init_delete_data_policy_spectra_s3_request(TEST_DP_NAME);
     error = ds3_delete_data_policy_spectra_s3_request(client, delete_data_policy_request);
+    print_error(error);
     ds3_request_free(delete_data_policy_request);
     ds3_error_free(error);
 
     // Delete StorageDomainMember
     ds3_request* delete_storage_domain_member_request = ds3_init_delete_storage_domain_member_spectra_s3_request(ids.storage_domain_member_id->value);
     error = ds3_delete_storage_domain_member_spectra_s3_request(client, delete_storage_domain_member_request);
+    print_error(error);
     ds3_request_free(delete_storage_domain_member_request);
     ds3_error_free(error);
 
     // Delete StorageDomain
     ds3_request* delete_storage_domain_request = ds3_init_delete_storage_domain_spectra_s3_request(TEST_SD_NAME);
     error = ds3_delete_storage_domain_spectra_s3_request(client, delete_storage_domain_request);
+    print_error(error);
     ds3_request_free(delete_storage_domain_request);
     ds3_error_free(error);
 
     // Delete PoolPartition
     ds3_request* delete_pool_partition_request = ds3_init_delete_pool_partition_spectra_s3_request(TEST_PP_NAME);
     error = ds3_delete_pool_partition_spectra_s3_request(client, delete_pool_partition_request);
+    print_error(error);
     ds3_request_free(delete_pool_partition_request);
     ds3_error_free(error);
 
     free_client(client);
 }
 
-void print_error(const ds3_error* error) {
-      if (NULL != error->message) {
-        printf("ds3_error_message: %s\n", error->message->value);
-      }
-      if (error->error != NULL) {
-          printf("ds3_status_code: %lu\n", (unsigned long)error->error->http_error_code);
-          printf("ds3_status_message: %s\n", error->error->message->value);
-          printf("ds3_error_body: %s\n", error->error->code->value);
-      }
-}
-
 void handle_error(ds3_error* error) {
     BOOST_CHECK(error == NULL);
     if (error != NULL) {