diff --git a/CMakeLists.txt b/CMakeLists.txt index 1bd07c4f..a5892ea0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -4,7 +4,7 @@ project(libds3) set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/modules/") set (DS3SDK_VERSION_MAJOR 5) -set (DS3SDK_VERSION_MINOR 4) -set (DS3SDK_VERSION_PATCH 1) +set (DS3SDK_VERSION_MINOR 8) +set (DS3SDK_VERSION_PATCH 0) add_subdirectory(src) diff --git a/src/ds3.c b/src/ds3.c index 112a0283..2088b03c 100644 --- a/src/ds3.c +++ b/src/ds3.c @@ -738,6 +738,19 @@ void ds3_job_chunk_response_free(ds3_job_chunk_response* response) { g_free(response); } +void ds3_job_creation_failed_response_free(ds3_job_creation_failed_response* response) { + if (response == NULL) { + return; + } + + ds3_str_free(response->date); + ds3_str_free(response->error_message); + ds3_str_free(response->id); + ds3_str_free(response->tape_bar_codes); + ds3_str_free(response->user_name); + + g_free(response); +} void ds3_node_response_free(ds3_node_response* response) { if (response == NULL) { return; @@ -1697,25 +1710,6 @@ void ds3_delete_object_error_response_free(ds3_delete_object_error_response* res g_free(response); } -void ds3_detailed_tape_partition_response_free(ds3_detailed_tape_partition_response* response) { - if (response == NULL) { - return; - } - - size_t index; - g_free(response->drive_types); - ds3_str_free(response->error_message); - ds3_str_free(response->id); - ds3_str_free(response->library_id); - ds3_str_free(response->name); - ds3_str_free(response->serial_number); - for (index = 0; index < response->num_tape_types; index++) { - ds3_str_free(response->tape_types[index]); - } - g_free(response->tape_types); - - g_free(response); -} void ds3_error_response_free(ds3_error_response* response) { if (response == NULL) { return; @@ -1768,52 +1762,51 @@ void ds3_s3_object_to_delete_response_free(ds3_s3_object_to_delete_response* res g_free(response); } -void ds3_user_response_free(ds3_user_response* response) { +void ds3_tape_type_summary_api_bean_response_free(ds3_tape_type_summary_api_bean_response* response) { if (response == NULL) { return; } - ds3_str_free(response->display_name); - ds3_str_free(response->id); + ds3_str_free(response->type); g_free(response); } -void ds3_system_information_response_free(ds3_system_information_response* response) { +void ds3_type_type_count_api_bean_response_free(ds3_type_type_count_api_bean_response* response) { if (response == NULL) { return; } - ds3_str_free(response->api_version); - ds3_build_information_response_free(response->build_information); - ds3_str_free(response->instance_id); - ds3_str_free(response->serial_number); + ds3_str_free(response->type); g_free(response); } -void ds3_health_verification_result_response_free(ds3_health_verification_result_response* response) { +void ds3_user_response_free(ds3_user_response* response) { if (response == NULL) { return; } + ds3_str_free(response->display_name); + ds3_str_free(response->id); g_free(response); } -void ds3_named_detailed_tape_partition_response_free(ds3_named_detailed_tape_partition_response* response) { +void ds3_system_information_response_free(ds3_system_information_response* response) { if (response == NULL) { return; } - size_t index; - g_free(response->drive_types); - ds3_str_free(response->error_message); - ds3_str_free(response->id); - ds3_str_free(response->library_id); - ds3_str_free(response->name); + ds3_str_free(response->api_version); + ds3_build_information_response_free(response->build_information); + ds3_str_free(response->instance_id); ds3_str_free(response->serial_number); - for (index = 0; index < response->num_tape_types; index++) { - ds3_str_free(response->tape_types[index]); + + g_free(response); +} +void ds3_health_verification_result_response_free(ds3_health_verification_result_response* response) { + if (response == NULL) { + return; } - g_free(response->tape_types); + g_free(response); } @@ -2170,6 +2163,20 @@ void ds3_completed_job_list_response_free(ds3_completed_job_list_response* respo g_free(response); } +void ds3_job_creation_failed_list_response_free(ds3_job_creation_failed_list_response* response) { + if (response == NULL) { + return; + } + + size_t index; + for (index = 0; index < response->num_job_creation_faileds; index++) { + ds3_job_creation_failed_response_free(response->job_creation_faileds[index]); + } + g_free(response->job_creation_faileds); + ds3_paging_free(response->paging); + + g_free(response); +} void ds3_node_list_response_free(ds3_node_list_response* response) { if (response == NULL) { return; @@ -2604,20 +2611,6 @@ void ds3_tape_partition_list_response_free(ds3_tape_partition_list_response* res g_free(response); } -void ds3_named_detailed_tape_partition_list_response_free(ds3_named_detailed_tape_partition_list_response* response) { - if (response == NULL) { - return; - } - - size_t index; - for (index = 0; index < response->num_named_detailed_tape_partitions; index++) { - ds3_named_detailed_tape_partition_response_free(response->named_detailed_tape_partitions[index]); - } - g_free(response->named_detailed_tape_partitions); - ds3_paging_free(response->paging); - - g_free(response); -} void ds3_tape_list_response_free(ds3_tape_list_response* response) { if (response == NULL) { return; @@ -3095,6 +3088,19 @@ void ds3_contents_response_free(ds3_contents_response* response) { g_free(response); } +void ds3_tape_state_summary_api_bean_response_free(ds3_tape_state_summary_api_bean_response* response) { + if (response == NULL) { + return; + } + + size_t index; + for (index = 0; index < response->num_type_counts; index++) { + ds3_type_type_count_api_bean_response_free(response->type_counts[index]); + } + g_free(response->type_counts); + + g_free(response); +} void ds3_detailed_s3_object_response_free(ds3_detailed_s3_object_response* response) { if (response == NULL) { return; @@ -3110,6 +3116,33 @@ void ds3_detailed_s3_object_response_free(ds3_detailed_s3_object_response* respo g_free(response); } +void ds3_named_detailed_tape_partition_response_free(ds3_named_detailed_tape_partition_response* response) { + if (response == NULL) { + return; + } + + size_t index; + g_free(response->drive_types); + ds3_str_free(response->error_message); + ds3_str_free(response->id); + ds3_str_free(response->library_id); + ds3_str_free(response->name); + ds3_str_free(response->serial_number); + for (index = 0; index < response->num_tape_state_summaries; index++) { + ds3_tape_state_summary_api_bean_response_free(response->tape_state_summaries[index]); + } + g_free(response->tape_state_summaries); + for (index = 0; index < response->num_tape_type_summaries; index++) { + ds3_tape_type_summary_api_bean_response_free(response->tape_type_summaries[index]); + } + g_free(response->tape_type_summaries); + for (index = 0; index < response->num_tape_types; index++) { + ds3_str_free(response->tape_types[index]); + } + g_free(response->tape_types); + + g_free(response); +} void ds3_database_contents_response_free(ds3_database_contents_response* response) { if (response == NULL) { return; @@ -3137,6 +3170,20 @@ void ds3_detailed_s3_object_list_response_free(ds3_detailed_s3_object_list_respo g_free(response); } +void ds3_named_detailed_tape_partition_list_response_free(ds3_named_detailed_tape_partition_list_response* response) { + if (response == NULL) { + return; + } + + size_t index; + for (index = 0; index < response->num_named_detailed_tape_partitions; index++) { + ds3_named_detailed_tape_partition_response_free(response->named_detailed_tape_partitions[index]); + } + g_free(response->named_detailed_tape_partitions); + ds3_paging_free(response->paging); + + g_free(response); +} void ds3_list_bucket_result_response_free(ds3_list_bucket_result_response* response) { if (response == NULL) { return; @@ -3164,6 +3211,33 @@ void ds3_list_bucket_result_response_free(ds3_list_bucket_result_response* respo g_free(response); } +void ds3_detailed_tape_partition_response_free(ds3_detailed_tape_partition_response* response) { + if (response == NULL) { + return; + } + + size_t index; + g_free(response->drive_types); + ds3_str_free(response->error_message); + ds3_str_free(response->id); + ds3_str_free(response->library_id); + ds3_str_free(response->name); + ds3_str_free(response->serial_number); + for (index = 0; index < response->num_tape_state_summaries; index++) { + ds3_tape_state_summary_api_bean_response_free(response->tape_state_summaries[index]); + } + g_free(response->tape_state_summaries); + for (index = 0; index < response->num_tape_type_summaries; index++) { + ds3_tape_type_summary_api_bean_response_free(response->tape_type_summaries[index]); + } + g_free(response->tape_type_summaries); + for (index = 0; index < response->num_tape_types; index++) { + ds3_str_free(response->tape_types[index]); + } + g_free(response->tape_types); + + g_free(response); +} void ds3_list_multi_part_uploads_result_response_free(ds3_list_multi_part_uploads_result_response* response) { if (response == NULL) { return; diff --git a/src/ds3.h b/src/ds3.h index e535bf77..afca293b 100644 --- a/src/ds3.h +++ b/src/ds3.h @@ -172,6 +172,9 @@ typedef enum { DS3_JOB_CHUNK_CLIENT_PROCESSING_ORDER_GUARANTEE_NONE, DS3_JOB_CHUNK_CLIENT_PROCESSING_ORDER_GUARANTEE_IN_ORDER }ds3_job_chunk_client_processing_order_guarantee; +typedef enum { + DS3_JOB_CREATION_FAILED_TYPE_TAPES_MUST_BE_ONLINED +}ds3_job_creation_failed_type; typedef enum { DS3_JOB_REQUEST_TYPE_PUT, DS3_JOB_REQUEST_TYPE_GET, @@ -258,6 +261,10 @@ typedef enum { DS3_BUCKET_HISTORY_EVENT_TYPE_UNMARK_LATEST, DS3_BUCKET_HISTORY_EVENT_TYPE_CREATE }ds3_bucket_history_event_type; +typedef enum { + DS3_CACHE_ENTRY_STATE_ALLOCATED, + DS3_CACHE_ENTRY_STATE_IN_CACHE +}ds3_cache_entry_state; typedef enum { DS3_POOL_FAILURE_TYPE_BLOB_READ_FAILED, DS3_POOL_FAILURE_TYPE_DATA_CHECKPOINT_FAILURE, @@ -296,6 +303,7 @@ typedef enum { }ds3_quiesced; typedef enum { DS3_RESERVED_TASK_TYPE_ANY, + DS3_RESERVED_TASK_TYPE_MAINTENANCE, DS3_RESERVED_TASK_TYPE_READ, DS3_RESERVED_TASK_TYPE_WRITE }ds3_reserved_task_type; @@ -323,21 +331,29 @@ typedef enum { DS3_TAPE_DRIVE_TYPE_LTO7, DS3_TAPE_DRIVE_TYPE_LTO8, DS3_TAPE_DRIVE_TYPE_LTO9, + DS3_TAPE_DRIVE_TYPE_LTO10, DS3_TAPE_DRIVE_TYPE_TS1140, DS3_TAPE_DRIVE_TYPE_TS1150, DS3_TAPE_DRIVE_TYPE_TS1155, - DS3_TAPE_DRIVE_TYPE_TS1160 + DS3_TAPE_DRIVE_TYPE_TS1160, + DS3_TAPE_DRIVE_TYPE_TS1170 }ds3_tape_drive_type; typedef enum { DS3_TAPE_FAILURE_TYPE_BAR_CODE_CHANGED, DS3_TAPE_FAILURE_TYPE_BAR_CODE_DUPLICATE, DS3_TAPE_FAILURE_TYPE_BLOB_READ_FAILED, + DS3_TAPE_FAILURE_TYPE_CLEANING_TAPE_EXPIRED, DS3_TAPE_FAILURE_TYPE_DATA_CHECKPOINT_FAILURE, DS3_TAPE_FAILURE_TYPE_DATA_CHECKPOINT_FAILURE_DUE_TO_READ_ONLY, DS3_TAPE_FAILURE_TYPE_DATA_CHECKPOINT_MISSING, DS3_TAPE_FAILURE_TYPE_DELAYED_OWNERSHIP_FAILURE, DS3_TAPE_FAILURE_TYPE_DRIVE_CLEAN_FAILED, DS3_TAPE_FAILURE_TYPE_DRIVE_CLEANED, + DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED, + DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_ALL_WRITES_TOO_SLOW, + DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_FORWARD_WRITES_TOO_SLOW, + DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_REVERSE_WRITES_TOO_SLOW, + DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_SUCCEEDED, DS3_TAPE_FAILURE_TYPE_ENCRYPTION_ERROR, DS3_TAPE_FAILURE_TYPE_FORMAT_FAILED, DS3_TAPE_FAILURE_TYPE_GET_TAPE_INFORMATION_FAILED, @@ -348,6 +364,7 @@ typedef enum { DS3_TAPE_FAILURE_TYPE_IMPORT_FAILED_DUE_TO_DATA_INTEGRITY, DS3_TAPE_FAILURE_TYPE_INCOMPATIBLE, DS3_TAPE_FAILURE_TYPE_INSPECT_FAILED, + DS3_TAPE_FAILURE_TYPE_MOVE_FAILED, DS3_TAPE_FAILURE_TYPE_QUIESCING_DRIVE, DS3_TAPE_FAILURE_TYPE_READ_FAILED, DS3_TAPE_FAILURE_TYPE_REIMPORT_REQUIRED, @@ -356,6 +373,7 @@ typedef enum { DS3_TAPE_FAILURE_TYPE_WRITE_FAILED }ds3_tape_failure_type; typedef enum { + DS3_TAPE_PARTITION_FAILURE_TYPE_AUTO_QUIESCED, DS3_TAPE_PARTITION_FAILURE_TYPE_CLEANING_TAPE_REQUIRED, DS3_TAPE_PARTITION_FAILURE_TYPE_DUPLICATE_TAPE_BAR_CODES_DETECTED, DS3_TAPE_PARTITION_FAILURE_TYPE_EJECT_STALLED_DUE_TO_OFFLINE_TAPES, @@ -366,6 +384,7 @@ typedef enum { DS3_TAPE_PARTITION_FAILURE_TYPE_ONLINE_STALLED_DUE_TO_NO_STORAGE_SLOTS, DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_IN_ERROR, DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_MISSING, + DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_NOT_CLEANED, DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_QUIESCED, DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_TYPE_MISMATCH, DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_EJECTION_BY_OPERATOR_REQUIRED, @@ -378,6 +397,10 @@ typedef enum { DS3_TAPE_PARTITION_STATE_OFFLINE, DS3_TAPE_PARTITION_STATE_ERROR }ds3_tape_partition_state; +typedef enum { + DS3_TAPE_ROLE_NORMAL, + DS3_TAPE_ROLE_TEST +}ds3_tape_role; typedef enum { DS3_TAPE_STATE_NORMAL, DS3_TAPE_STATE_OFFLINE, @@ -414,6 +437,7 @@ typedef enum { DS3_TAPE_TYPE_LTOM8, DS3_TAPE_TYPE_LTO8, DS3_TAPE_TYPE_LTO9, + DS3_TAPE_TYPE_LTO10, DS3_TAPE_TYPE_LTO_CLEANING_TAPE, DS3_TAPE_TYPE_TS_JC, DS3_TAPE_TYPE_TS_JY, @@ -424,6 +448,8 @@ typedef enum { DS3_TAPE_TYPE_TS_JM, DS3_TAPE_TYPE_TS_JE, DS3_TAPE_TYPE_TS_JV, + DS3_TAPE_TYPE_TS_JF, + DS3_TAPE_TYPE_TS_JN, DS3_TAPE_TYPE_TS_CLEANING_TAPE, DS3_TAPE_TYPE_UNKNOWN, DS3_TAPE_TYPE_FORBIDDEN @@ -462,10 +488,6 @@ typedef enum { DS3_BLOB_STORE_TASK_STATE_IN_PROGRESS, DS3_BLOB_STORE_TASK_STATE_COMPLETED }ds3_blob_store_task_state; -typedef enum { - DS3_CACHE_ENTRY_STATE_ALLOCATED, - DS3_CACHE_ENTRY_STATE_IN_CACHE -}ds3_cache_entry_state; typedef enum { DS3_JOB_STATUS_IN_PROGRESS, DS3_JOB_STATUS_COMPLETED, @@ -534,6 +556,7 @@ typedef enum { DS3_REST_DOMAIN_TYPE_JOB_CHUNK_DAO, DS3_REST_DOMAIN_TYPE_JOB_COMPLETED_NOTIFICATION_REGISTRATION, DS3_REST_DOMAIN_TYPE_JOB_CREATED_NOTIFICATION_REGISTRATION, + DS3_REST_DOMAIN_TYPE_JOB_CREATION_FAILED, DS3_REST_DOMAIN_TYPE_JOB_CREATION_FAILED_NOTIFICATION_REGISTRATION, DS3_REST_DOMAIN_TYPE_NODE, DS3_REST_DOMAIN_TYPE_OBJECT, @@ -589,10 +612,12 @@ typedef enum { DS3_REST_OPERATION_TYPE_CANCEL_FORMAT, DS3_REST_OPERATION_TYPE_CANCEL_IMPORT, DS3_REST_OPERATION_TYPE_CANCEL_ONLINE, + DS3_REST_OPERATION_TYPE_CANCEL_TEST, DS3_REST_OPERATION_TYPE_CANCEL_VERIFY, DS3_REST_OPERATION_TYPE_CLEAN, DS3_REST_OPERATION_TYPE_COMPACT, DS3_REST_OPERATION_TYPE_DEALLOCATE, + DS3_REST_OPERATION_TYPE_DUMP, DS3_REST_OPERATION_TYPE_EJECT, DS3_REST_OPERATION_TYPE_FORMAT, DS3_REST_OPERATION_TYPE_GET_PHYSICAL_PLACEMENT, @@ -606,6 +631,7 @@ typedef enum { DS3_REST_OPERATION_TYPE_START_BULK_PUT, DS3_REST_OPERATION_TYPE_START_BULK_STAGE, DS3_REST_OPERATION_TYPE_START_BULK_VERIFY, + DS3_REST_OPERATION_TYPE_TEST, DS3_REST_OPERATION_TYPE_VERIFY, DS3_REST_OPERATION_TYPE_VERIFY_SAFE_TO_START_BULK_PUT, DS3_REST_OPERATION_TYPE_VERIFY_PHYSICAL_PLACEMENT @@ -684,6 +710,7 @@ typedef struct { uint64_t last_preferred_chunk_size_in_bytes; uint64_t logical_used_capacity; ds3_str* name; + ds3_bool protected_flag; ds3_str* user_id; }ds3_bucket_response; typedef struct { @@ -744,10 +771,13 @@ typedef struct { ds3_bool iom_enabled; ds3_str* last_heartbeat; int max_aggregated_blobs_per_chunk; + int max_number_of_concurrent_jobs; int partially_verify_last_percent_of_tapes; + ds3_bool pool_safety_enabled; ds3_unavailable_media_usage_policy unavailable_media_policy; int unavailable_pool_max_job_retry_in_mins; int unavailable_tape_partition_max_job_retry_in_mins; + ds3_bool verify_checkpoint_before_read; }ds3_data_path_backend_response; typedef struct { ds3_str* data_policy_id; @@ -835,6 +865,7 @@ typedef struct { ds3_str* name; uint64_t original_size_in_bytes; ds3_priority priority; + ds3_bool protected_flag; ds3_str* rechunked; ds3_bool replicating; ds3_job_request_type request_type; @@ -858,6 +889,14 @@ typedef struct { ds3_str* read_from_s3_target_id; ds3_str* read_from_tape_id; }ds3_job_chunk_response; +typedef struct { + ds3_str* date; + ds3_str* error_message; + ds3_str* id; + ds3_str* tape_bar_codes; + ds3_job_creation_failed_type type; + ds3_str* user_name; +}ds3_job_creation_failed_response; typedef struct { int data_path_http_port; int data_path_https_port; @@ -1165,9 +1204,11 @@ typedef struct { float auto_reclaim_initiate_threshold; float auto_reclaim_terminate_threshold; float burst_threshold; + ds3_bool cache_safety_enabled; ds3_str* id; uint64_t max_capacity_in_bytes; float max_percent_utilization_of_filesystem; + ds3_bool needs_reconcile; ds3_str* node_id; ds3_str* path; }ds3_cache_filesystem_response; @@ -1238,6 +1279,7 @@ typedef struct { ds3_str* partially_verified_end_of_tape; ds3_str* partition_id; ds3_tape_state previous_state; + ds3_tape_role role; ds3_str* serial_number; ds3_tape_state state; ds3_str* storage_domain_member_id; @@ -1565,26 +1607,6 @@ typedef struct { ds3_str* message; ds3_str* version_id; }ds3_delete_object_error_response; -typedef struct { - ds3_bool auto_compaction_enabled; - ds3_bool auto_quiesce_enabled; - int drive_idle_timeout_in_minutes; - ds3_tape_drive_type drive_type; - ds3_tape_drive_type* drive_types; - size_t num_drive_types; - ds3_str* error_message; - ds3_str* id; - ds3_import_export_configuration import_export_configuration; - ds3_str* library_id; - int minimum_read_reserved_drives; - int minimum_write_reserved_drives; - ds3_str* name; - ds3_quiesced quiesced; - ds3_str* serial_number; - ds3_tape_partition_state state; - ds3_str** tape_types; - size_t num_tape_types; -}ds3_detailed_tape_partition_response; typedef struct { ds3_str* code; int http_error_code; @@ -1612,6 +1634,18 @@ typedef struct { ds3_str* key; ds3_str* version_id; }ds3_s3_object_to_delete_response; +typedef struct { + uint64_t available_storage_capacity; + int count; + uint64_t total_storage_capacity; + ds3_str* type; + uint64_t used_storage_capacity; +}ds3_tape_type_summary_api_bean_response; +typedef struct { + int count; + int full_of_data; + ds3_str* type; +}ds3_type_type_count_api_bean_response; typedef struct { ds3_str* display_name; ds3_str* id; @@ -1628,26 +1662,6 @@ typedef struct { ds3_database_physical_space_state database_filesystem_free_space; uint64_t ms_required_to_verify_data_planner_health; }ds3_health_verification_result_response; -typedef struct { - ds3_bool auto_compaction_enabled; - ds3_bool auto_quiesce_enabled; - int drive_idle_timeout_in_minutes; - ds3_tape_drive_type drive_type; - ds3_tape_drive_type* drive_types; - size_t num_drive_types; - ds3_str* error_message; - ds3_str* id; - ds3_import_export_configuration import_export_configuration; - ds3_str* library_id; - int minimum_read_reserved_drives; - int minimum_write_reserved_drives; - ds3_str* name; - ds3_quiesced quiesced; - ds3_str* serial_number; - ds3_tape_partition_state state; - ds3_str** tape_types; - size_t num_tape_types; -}ds3_named_detailed_tape_partition_response; typedef struct { ds3_str* cause; ds3_tape_response* tape; @@ -1781,6 +1795,11 @@ typedef struct { size_t num_completed_jobs; ds3_paging* paging; }ds3_completed_job_list_response; +typedef struct { + ds3_job_creation_failed_response** job_creation_faileds; + size_t num_job_creation_faileds; + ds3_paging* paging; +}ds3_job_creation_failed_list_response; typedef struct { ds3_node_response** nodes; size_t num_nodes; @@ -1936,11 +1955,6 @@ typedef struct { size_t num_tape_partitions; ds3_paging* paging; }ds3_tape_partition_list_response; -typedef struct { - ds3_named_detailed_tape_partition_response** named_detailed_tape_partitions; - size_t num_named_detailed_tape_partitions; - ds3_paging* paging; -}ds3_named_detailed_tape_partition_list_response; typedef struct { ds3_tape_response** tapes; size_t num_tapes; @@ -2166,6 +2180,13 @@ typedef struct { ds3_str* storage_class; ds3_str* version_id; }ds3_contents_response; +typedef struct { + int count; + int full_of_data; + ds3_tape_state tape_state; + ds3_type_type_count_api_bean_response** type_counts; + size_t num_type_counts; +}ds3_tape_state_summary_api_bean_response; typedef struct { ds3_bulk_object_list_response* blobs; int blobs_being_persisted; @@ -2182,6 +2203,34 @@ typedef struct { uint64_t size; ds3_s3_object_type type; }ds3_detailed_s3_object_response; +typedef struct { + ds3_bool auto_compaction_enabled; + ds3_bool auto_quiesce_enabled; + uint64_t available_storage_capacity; + int drive_idle_timeout_in_minutes; + ds3_tape_drive_type drive_type; + ds3_tape_drive_type* drive_types; + size_t num_drive_types; + ds3_str* error_message; + ds3_str* id; + ds3_import_export_configuration import_export_configuration; + ds3_str* library_id; + int minimum_read_reserved_drives; + int minimum_write_reserved_drives; + ds3_str* name; + ds3_quiesced quiesced; + ds3_str* serial_number; + ds3_tape_partition_state state; + int tape_count; + ds3_tape_state_summary_api_bean_response** tape_state_summaries; + size_t num_tape_state_summaries; + ds3_tape_type_summary_api_bean_response** tape_type_summaries; + size_t num_tape_type_summaries; + ds3_str** tape_types; + size_t num_tape_types; + uint64_t total_storage_capacity; + uint64_t used_storage_capacity; +}ds3_named_detailed_tape_partition_response; typedef struct { ds3_type_response** types; size_t num_types; @@ -2191,6 +2240,11 @@ typedef struct { size_t num_detailed_s3_objects; ds3_paging* paging; }ds3_detailed_s3_object_list_response; +typedef struct { + ds3_named_detailed_tape_partition_response** named_detailed_tape_partitions; + size_t num_named_detailed_tape_partitions; + ds3_paging* paging; +}ds3_named_detailed_tape_partition_list_response; typedef struct { ds3_str** common_prefixes; size_t num_common_prefixes; @@ -2207,6 +2261,34 @@ typedef struct { ds3_contents_response** versioned_objects; size_t num_versioned_objects; }ds3_list_bucket_result_response; +typedef struct { + ds3_bool auto_compaction_enabled; + ds3_bool auto_quiesce_enabled; + uint64_t available_storage_capacity; + int drive_idle_timeout_in_minutes; + ds3_tape_drive_type drive_type; + ds3_tape_drive_type* drive_types; + size_t num_drive_types; + ds3_str* error_message; + ds3_str* id; + ds3_import_export_configuration import_export_configuration; + ds3_str* library_id; + int minimum_read_reserved_drives; + int minimum_write_reserved_drives; + ds3_str* name; + ds3_quiesced quiesced; + ds3_str* serial_number; + ds3_tape_partition_state state; + int tape_count; + ds3_tape_state_summary_api_bean_response** tape_state_summaries; + size_t num_tape_state_summaries; + ds3_tape_type_summary_api_bean_response** tape_type_summaries; + size_t num_tape_type_summaries; + ds3_str** tape_types; + size_t num_tape_types; + uint64_t total_storage_capacity; + uint64_t used_storage_capacity; +}ds3_detailed_tape_partition_response; typedef struct { ds3_str* bucket; ds3_str** common_prefixes; @@ -2262,6 +2344,7 @@ LIBRARY_API void ds3_group_response_free(ds3_group_response* response_data); LIBRARY_API void ds3_group_member_response_free(ds3_group_member_response* response_data); LIBRARY_API void ds3_active_job_response_free(ds3_active_job_response* response_data); LIBRARY_API void ds3_job_chunk_response_free(ds3_job_chunk_response* response_data); +LIBRARY_API void ds3_job_creation_failed_response_free(ds3_job_creation_failed_response* response_data); LIBRARY_API void ds3_node_response_free(ds3_node_response* response_data); LIBRARY_API void ds3_s3_data_replication_rule_response_free(ds3_s3_data_replication_rule_response* response_data); LIBRARY_API void ds3_s3_object_response_free(ds3_s3_object_response* response_data); @@ -2336,16 +2419,16 @@ LIBRARY_API void ds3_cache_information_response_free(ds3_cache_information_respo LIBRARY_API void ds3_bucket_details_response_free(ds3_bucket_details_response* response_data); LIBRARY_API void ds3_complete_multipart_upload_result_response_free(ds3_complete_multipart_upload_result_response* response_data); LIBRARY_API void ds3_delete_object_error_response_free(ds3_delete_object_error_response* response_data); -LIBRARY_API void ds3_detailed_tape_partition_response_free(ds3_detailed_tape_partition_response* response_data); LIBRARY_API void ds3_error_response_free(ds3_error_response* response_data); LIBRARY_API void ds3_initiate_multipart_upload_result_response_free(ds3_initiate_multipart_upload_result_response* response_data); LIBRARY_API void ds3_multi_part_upload_part_response_free(ds3_multi_part_upload_part_response* response_data); LIBRARY_API void ds3_job_node_response_free(ds3_job_node_response* response_data); LIBRARY_API void ds3_s3_object_to_delete_response_free(ds3_s3_object_to_delete_response* response_data); +LIBRARY_API void ds3_tape_type_summary_api_bean_response_free(ds3_tape_type_summary_api_bean_response* response_data); +LIBRARY_API void ds3_type_type_count_api_bean_response_free(ds3_type_type_count_api_bean_response* response_data); LIBRARY_API void ds3_user_response_free(ds3_user_response* response_data); LIBRARY_API void ds3_system_information_response_free(ds3_system_information_response* response_data); LIBRARY_API void ds3_health_verification_result_response_free(ds3_health_verification_result_response* response_data); -LIBRARY_API void ds3_named_detailed_tape_partition_response_free(ds3_named_detailed_tape_partition_response* response_data); LIBRARY_API void ds3_tape_failure_response_free(ds3_tape_failure_response* response_data); LIBRARY_API void ds3_tape_failure_list_response_free(ds3_tape_failure_list_response* response_data); LIBRARY_API void ds3_create_heap_dump_params_response_free(ds3_create_heap_dump_params_response* response_data); @@ -2373,6 +2456,7 @@ LIBRARY_API void ds3_group_list_response_free(ds3_group_list_response* response_ LIBRARY_API void ds3_active_job_list_response_free(ds3_active_job_list_response* response_data); LIBRARY_API void ds3_canceled_job_list_response_free(ds3_canceled_job_list_response* response_data); LIBRARY_API void ds3_completed_job_list_response_free(ds3_completed_job_list_response* response_data); +LIBRARY_API void ds3_job_creation_failed_list_response_free(ds3_job_creation_failed_list_response* response_data); LIBRARY_API void ds3_node_list_response_free(ds3_node_list_response* response_data); LIBRARY_API void ds3_azure_target_failure_notification_registration_list_response_free(ds3_azure_target_failure_notification_registration_list_response* response_data); LIBRARY_API void ds3_bucket_changes_notification_registration_list_response_free(ds3_bucket_changes_notification_registration_list_response* response_data); @@ -2404,7 +2488,6 @@ LIBRARY_API void ds3_detailed_tape_failure_list_response_free(ds3_detailed_tape_ LIBRARY_API void ds3_tape_library_list_response_free(ds3_tape_library_list_response* response_data); LIBRARY_API void ds3_tape_partition_failure_list_response_free(ds3_tape_partition_failure_list_response* response_data); LIBRARY_API void ds3_tape_partition_list_response_free(ds3_tape_partition_list_response* response_data); -LIBRARY_API void ds3_named_detailed_tape_partition_list_response_free(ds3_named_detailed_tape_partition_list_response* response_data); LIBRARY_API void ds3_tape_list_response_free(ds3_tape_list_response* response_data); LIBRARY_API void ds3_azure_target_bucket_name_list_response_free(ds3_azure_target_bucket_name_list_response* response_data); LIBRARY_API void ds3_azure_target_failure_list_response_free(ds3_azure_target_failure_list_response* response_data); @@ -2437,10 +2520,14 @@ LIBRARY_API void ds3_job_list_response_free(ds3_job_list_response* response_data LIBRARY_API void ds3_list_parts_result_response_free(ds3_list_parts_result_response* response_data); LIBRARY_API void ds3_multi_part_upload_response_free(ds3_multi_part_upload_response* response_data); LIBRARY_API void ds3_contents_response_free(ds3_contents_response* response_data); +LIBRARY_API void ds3_tape_state_summary_api_bean_response_free(ds3_tape_state_summary_api_bean_response* response_data); LIBRARY_API void ds3_detailed_s3_object_response_free(ds3_detailed_s3_object_response* response_data); +LIBRARY_API void ds3_named_detailed_tape_partition_response_free(ds3_named_detailed_tape_partition_response* response_data); LIBRARY_API void ds3_database_contents_response_free(ds3_database_contents_response* response_data); LIBRARY_API void ds3_detailed_s3_object_list_response_free(ds3_detailed_s3_object_list_response* response_data); +LIBRARY_API void ds3_named_detailed_tape_partition_list_response_free(ds3_named_detailed_tape_partition_list_response* response_data); LIBRARY_API void ds3_list_bucket_result_response_free(ds3_list_bucket_result_response* response_data); +LIBRARY_API void ds3_detailed_tape_partition_response_free(ds3_detailed_tape_partition_response* response_data); LIBRARY_API void ds3_list_multi_part_uploads_result_response_free(ds3_list_multi_part_uploads_result_response* response_data); LIBRARY_API void ds3_request_free(ds3_request* request); @@ -2509,10 +2596,12 @@ LIBRARY_API void ds3_request_set_available_raw_capacity(const ds3_request* reque LIBRARY_API void ds3_request_set_bar_code(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_blob_id(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_blobbing_enabled(const ds3_request* request, ds3_bool value); +LIBRARY_API void ds3_request_set_bucket(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_bucket_id(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_built_in(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_burst_threshold(const ds3_request* request, const float value); LIBRARY_API void ds3_request_set_cache_available_retry_after_in_seconds(const ds3_request* request, const int value); +LIBRARY_API void ds3_request_set_cache_safety_enabled(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_cached_only(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_canceled_due_to_timeout(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_checksum_type_ds3_checksum_type(const ds3_request* request, const ds3_checksum_type value); @@ -2526,6 +2615,8 @@ LIBRARY_API void ds3_request_set_data_path_port(const ds3_request* request, cons LIBRARY_API void ds3_request_set_data_path_proxy(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_data_path_verify_certificate(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_data_policy_id(const ds3_request* request, const char * const value); +LIBRARY_API void ds3_request_set_date(const ds3_request* request, const char * const value); +LIBRARY_API void ds3_request_set_dead_job_cleanup_allowed(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_default_blob_size(const ds3_request* request, const uint64_t value); LIBRARY_API void ds3_request_set_default_data_policy_id(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_default_get_job_priority_ds3_priority(const ds3_request* request, const ds3_priority value); @@ -2581,6 +2672,7 @@ LIBRARY_API void ds3_request_set_max_buckets(const ds3_request* request, const i LIBRARY_API void ds3_request_set_max_capacity_in_bytes(const ds3_request* request, const uint64_t value); LIBRARY_API void ds3_request_set_max_failed_tapes(const ds3_request* request, const int value); LIBRARY_API void ds3_request_set_max_keys(const ds3_request* request, const int value); +LIBRARY_API void ds3_request_set_max_number_of_concurrent_jobs(const ds3_request* request, const int value); LIBRARY_API void ds3_request_set_max_parts(const ds3_request* request, const int value); LIBRARY_API void ds3_request_set_max_tape_fragmentation_percent(const ds3_request* request, const int value); LIBRARY_API void ds3_request_set_max_upload_size(const ds3_request* request, const uint64_t value); @@ -2599,6 +2691,7 @@ LIBRARY_API void ds3_request_set_minimum_write_reserved_drives(const ds3_request LIBRARY_API void ds3_request_set_name(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_naming_convention_ds3_naming_convention_type(const ds3_request* request, const ds3_naming_convention_type value); LIBRARY_API void ds3_request_set_naming_mode_ds3_cloud_naming_mode(const ds3_request* request, const ds3_cloud_naming_mode value); +LIBRARY_API void ds3_request_set_needs_reconcile(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_node_id(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_notification_http_method_ds3_request_type(const ds3_request* request, const ds3_request_type value); LIBRARY_API void ds3_request_set_offline_data_staging_window_in_tb(const ds3_request* request, const int value); @@ -2609,6 +2702,7 @@ LIBRARY_API void ds3_request_set_page_start_marker(const ds3_request* request, c LIBRARY_API void ds3_request_set_part_number_marker(const ds3_request* request, const int value); LIBRARY_API void ds3_request_set_partially_verified_end_of_tape(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_partially_verify_last_percent_of_tapes(const ds3_request* request, const int value); +LIBRARY_API void ds3_request_set_partition(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_partition_id(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_permission_ds3_bucket_acl_permission(const ds3_request* request, const ds3_bucket_acl_permission value); LIBRARY_API void ds3_request_set_permit_going_out_of_sync(const ds3_request* request, ds3_bool value); @@ -2616,6 +2710,7 @@ LIBRARY_API void ds3_request_set_persistence_rule_id(const ds3_request* request, LIBRARY_API void ds3_request_set_pool_health_ds3_pool_health(const ds3_request* request, const ds3_pool_health value); LIBRARY_API void ds3_request_set_pool_id(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_pool_partition_id(const ds3_request* request, const char * const value); +LIBRARY_API void ds3_request_set_pool_safety_enabled(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_pool_state_ds3_pool_state(const ds3_request* request, const ds3_pool_state value); LIBRARY_API void ds3_request_set_pool_type_ds3_pool_type(const ds3_request* request, const ds3_pool_type value); LIBRARY_API void ds3_request_set_powered_on(const ds3_request* request, ds3_bool value); @@ -2624,6 +2719,7 @@ LIBRARY_API void ds3_request_set_preferred_number_of_chunks(const ds3_request* r LIBRARY_API void ds3_request_set_prefix(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_previous_state_ds3_tape_state(const ds3_request* request, const ds3_tape_state value); LIBRARY_API void ds3_request_set_priority_ds3_priority(const ds3_request* request, const ds3_priority value); +LIBRARY_API void ds3_request_set_protected(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_proxy_domain(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_proxy_host(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_proxy_password(const ds3_request* request, const char * const value); @@ -2639,10 +2735,12 @@ LIBRARY_API void ds3_request_set_replicated_user_default_data_policy(const ds3_r LIBRARY_API void ds3_request_set_request_type_ds3_job_request_type(const ds3_request* request, const ds3_job_request_type value); LIBRARY_API void ds3_request_set_reserved_task_type_ds3_reserved_task_type(const ds3_request* request, const ds3_reserved_task_type value); LIBRARY_API void ds3_request_set_restricted_access(const ds3_request* request, ds3_bool value); +LIBRARY_API void ds3_request_set_role_ds3_tape_role(const ds3_request* request, const ds3_tape_role value); LIBRARY_API void ds3_request_set_secret_key(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_secure_media_allocation(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_serial_number(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_size(const ds3_request* request, const uint64_t value); +LIBRARY_API void ds3_request_set_skip_clean(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_sort_by(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_staged_data_expiration_in_days(const ds3_request* request, const int value); LIBRARY_API void ds3_request_set_start_date(const ds3_request* request, const uint64_t value); @@ -2682,7 +2780,9 @@ LIBRARY_API void ds3_request_set_unavailable_pool_max_job_retry_in_mins(const ds LIBRARY_API void ds3_request_set_unavailable_tape_partition_max_job_retry_in_mins(const ds3_request* request, const int value); LIBRARY_API void ds3_request_set_upload_id_marker(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_user_id(const ds3_request* request, const char * const value); +LIBRARY_API void ds3_request_set_user_name(const ds3_request* request, const char * const value); LIBRARY_API void ds3_request_set_verify_after_write(const ds3_request* request, ds3_bool value); +LIBRARY_API void ds3_request_set_verify_checkpoint_before_read(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_verify_data_after_import_ds3_priority(const ds3_request* request, const ds3_priority value); LIBRARY_API void ds3_request_set_verify_data_prior_to_import(const ds3_request* request, ds3_bool value); LIBRARY_API void ds3_request_set_verify_pending_ds3_priority(const ds3_request* request, const ds3_priority value); @@ -2851,6 +2951,7 @@ LIBRARY_API ds3_error* ds3_get_data_policy_acls_spectra_s3_request(const ds3_cli * * void ds3_request_set_data_policy_id(const ds3_request* request, const char * const value) * void ds3_request_set_id(const ds3_request* request, const char * const value) + * void ds3_request_set_protected(const ds3_request* request, ds3_bool value) * void ds3_request_set_user_id(const ds3_request* request, const char * const value) */ LIBRARY_API ds3_request* ds3_init_put_bucket_spectra_s3_request(const char* name); @@ -2881,6 +2982,7 @@ LIBRARY_API ds3_error* ds3_get_buckets_spectra_s3_request(const ds3_client* clie * Optional Request Modifiers for ds3_init_modify_bucket_spectra_s3_request * * void ds3_request_set_data_policy_id(const ds3_request* request, const char * const value) + * void ds3_request_set_protected(const ds3_request* request, ds3_bool value) * void ds3_request_set_user_id(const ds3_request* request, const char * const value) */ LIBRARY_API ds3_request* ds3_init_modify_bucket_spectra_s3_request(const char *const resource_id); @@ -2908,7 +3010,9 @@ LIBRARY_API ds3_error* ds3_get_cache_state_spectra_s3_request(const ds3_client* * void ds3_request_set_auto_reclaim_initiate_threshold(const ds3_request* request, const float value) * void ds3_request_set_auto_reclaim_terminate_threshold(const ds3_request* request, const float value) * void ds3_request_set_burst_threshold(const ds3_request* request, const float value) + * void ds3_request_set_cache_safety_enabled(const ds3_request* request, ds3_bool value) * void ds3_request_set_max_capacity_in_bytes(const ds3_request* request, const uint64_t value) + * void ds3_request_set_needs_reconcile(const ds3_request* request, ds3_bool value) */ LIBRARY_API ds3_request* ds3_init_modify_cache_filesystem_spectra_s3_request(const char *const resource_id); LIBRARY_API ds3_error* ds3_modify_cache_filesystem_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_cache_filesystem_response** response); @@ -2967,10 +3071,13 @@ LIBRARY_API ds3_error* ds3_get_data_planner_blob_store_tasks_spectra_s3_request( * void ds3_request_set_iom_cache_limitation_percent(const ds3_request* request, const float value) * void ds3_request_set_iom_enabled(const ds3_request* request, ds3_bool value) * void ds3_request_set_max_aggregated_blobs_per_chunk(const ds3_request* request, const int value) + * void ds3_request_set_max_number_of_concurrent_jobs(const ds3_request* request, const int value) * void ds3_request_set_partially_verify_last_percent_of_tapes(const ds3_request* request, const int value) + * void ds3_request_set_pool_safety_enabled(const ds3_request* request, ds3_bool value) * void ds3_request_set_unavailable_media_policy_ds3_unavailable_media_usage_policy(const ds3_request* request, const ds3_unavailable_media_usage_policy value) * void ds3_request_set_unavailable_pool_max_job_retry_in_mins(const ds3_request* request, const int value) * void ds3_request_set_unavailable_tape_partition_max_job_retry_in_mins(const ds3_request* request, const int value) + * void ds3_request_set_verify_checkpoint_before_read(const ds3_request* request, ds3_bool value) */ LIBRARY_API ds3_request* ds3_init_modify_data_path_backend_spectra_s3_request(void); LIBRARY_API ds3_error* ds3_modify_data_path_backend_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_data_path_backend_response** response); @@ -3510,9 +3617,11 @@ LIBRARY_API ds3_error* ds3_close_aggregating_job_spectra_s3_request(const ds3_cl * * void ds3_request_set_aggregating(const ds3_request* request, ds3_bool value) * void ds3_request_set_chunk_client_processing_order_guarantee_ds3_job_chunk_client_processing_order_guarantee(const ds3_request* request, const ds3_job_chunk_client_processing_order_guarantee value) + * void ds3_request_set_dead_job_cleanup_allowed(const ds3_request* request, ds3_bool value) * void ds3_request_set_implicit_job_id_resolution(const ds3_request* request, ds3_bool value) * void ds3_request_set_name(const ds3_request* request, const char * const value) * void ds3_request_set_priority_ds3_priority(const ds3_request* request, const ds3_priority value) + * void ds3_request_set_protected(const ds3_request* request, ds3_bool value) */ LIBRARY_API ds3_request* ds3_init_get_bulk_job_spectra_s3_request(const char *const resource_id, const ds3_bulk_object_list_response* object_list); LIBRARY_API ds3_error* ds3_get_bulk_job_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_master_object_list_response** response); @@ -3520,6 +3629,7 @@ LIBRARY_API ds3_error* ds3_get_bulk_job_spectra_s3_request(const ds3_client* cli * Optional Request Modifiers for ds3_init_put_bulk_job_spectra_s3_request * * void ds3_request_set_aggregating(const ds3_request* request, ds3_bool value) + * void ds3_request_set_dead_job_cleanup_allowed(const ds3_request* request, ds3_bool value) * void ds3_request_set_force(const ds3_request* request, ds3_bool value) * void ds3_request_set_ignore_naming_conflicts(const ds3_request* request, ds3_bool value) * void ds3_request_set_implicit_job_id_resolution(const ds3_request* request, ds3_bool value) @@ -3528,6 +3638,7 @@ LIBRARY_API ds3_error* ds3_get_bulk_job_spectra_s3_request(const ds3_client* cli * void ds3_request_set_name(const ds3_request* request, const char * const value) * void ds3_request_set_pre_allocate_job_space(const ds3_request* request, ds3_bool value) * void ds3_request_set_priority_ds3_priority(const ds3_request* request, const ds3_priority value) + * void ds3_request_set_protected(const ds3_request* request, ds3_bool value) * void ds3_request_set_verify_after_write(const ds3_request* request, ds3_bool value) */ LIBRARY_API ds3_request* ds3_init_put_bulk_job_spectra_s3_request(const char *const resource_id, const ds3_bulk_object_list_response* object_list); @@ -3541,6 +3652,8 @@ LIBRARY_API ds3_error* ds3_put_bulk_job_spectra_s3_request(const ds3_client* cli */ LIBRARY_API ds3_request* ds3_init_verify_bulk_job_spectra_s3_request(const char *const resource_id, const ds3_bulk_object_list_response* object_list); LIBRARY_API ds3_error* ds3_verify_bulk_job_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_master_object_list_response** response); +LIBRARY_API ds3_request* ds3_init_delete_job_creation_failure_spectra_s3_request(const char *const resource_id); +LIBRARY_API ds3_error* ds3_delete_job_creation_failure_spectra_s3_request(const ds3_client* client, const ds3_request* request); LIBRARY_API ds3_request* ds3_init_get_active_job_spectra_s3_request(const char *const resource_id); LIBRARY_API ds3_error* ds3_get_active_job_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_active_job_response** response); /** @@ -3615,6 +3728,19 @@ LIBRARY_API ds3_error* ds3_get_job_chunk_spectra_s3_request(const ds3_client* cl */ LIBRARY_API ds3_request* ds3_init_get_job_chunks_ready_for_client_processing_spectra_s3_request(const char* job); LIBRARY_API ds3_error* ds3_get_job_chunks_ready_for_client_processing_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_master_object_list_response** response); +/** + * Optional Request Modifiers for ds3_init_get_job_creation_failures_spectra_s3_request + * + * void ds3_request_set_date(const ds3_request* request, const char * const value) + * void ds3_request_set_error_message(const ds3_request* request, const char * const value) + * void ds3_request_set_last_page(const ds3_request* request, ds3_bool value) + * void ds3_request_set_page_length(const ds3_request* request, const int value) + * void ds3_request_set_page_offset(const ds3_request* request, const int value) + * void ds3_request_set_page_start_marker(const ds3_request* request, const char * const value) + * void ds3_request_set_user_name(const ds3_request* request, const char * const value) + */ +LIBRARY_API ds3_request* ds3_init_get_job_creation_failures_spectra_s3_request(void); +LIBRARY_API ds3_error* ds3_get_job_creation_failures_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_job_creation_failed_list_response** response); LIBRARY_API ds3_request* ds3_init_get_job_spectra_s3_request(const char *const resource_id); LIBRARY_API ds3_error* ds3_get_job_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_master_object_list_response** response); LIBRARY_API ds3_request* ds3_init_get_job_to_replicate_spectra_s3_request(const char *const resource_id); @@ -3631,8 +3757,10 @@ LIBRARY_API ds3_error* ds3_get_jobs_spectra_s3_request(const ds3_client* client, * Optional Request Modifiers for ds3_init_modify_active_job_spectra_s3_request * * void ds3_request_set_created_at(const ds3_request* request, const char * const value) + * void ds3_request_set_dead_job_cleanup_allowed(const ds3_request* request, ds3_bool value) * void ds3_request_set_name(const ds3_request* request, const char * const value) * void ds3_request_set_priority_ds3_priority(const ds3_request* request, const ds3_priority value) + * void ds3_request_set_protected(const ds3_request* request, ds3_bool value) */ LIBRARY_API ds3_request* ds3_init_modify_active_job_spectra_s3_request(const char *const resource_id); LIBRARY_API ds3_error* ds3_modify_active_job_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_master_object_list_response** response); @@ -3640,8 +3768,10 @@ LIBRARY_API ds3_error* ds3_modify_active_job_spectra_s3_request(const ds3_client * Optional Request Modifiers for ds3_init_modify_job_spectra_s3_request * * void ds3_request_set_created_at(const ds3_request* request, const char * const value) + * void ds3_request_set_dead_job_cleanup_allowed(const ds3_request* request, ds3_bool value) * void ds3_request_set_name(const ds3_request* request, const char * const value) * void ds3_request_set_priority_ds3_priority(const ds3_request* request, const ds3_priority value) + * void ds3_request_set_protected(const ds3_request* request, ds3_bool value) */ LIBRARY_API ds3_request* ds3_init_modify_job_spectra_s3_request(const char *const resource_id); LIBRARY_API ds3_error* ds3_modify_job_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_master_object_list_response** response); @@ -4466,12 +4596,16 @@ LIBRARY_API ds3_request* ds3_init_cancel_online_on_all_tapes_spectra_s3_request( LIBRARY_API ds3_error* ds3_cancel_online_on_all_tapes_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_failure_list_response** response); LIBRARY_API ds3_request* ds3_init_cancel_online_tape_spectra_s3_request(const char *const resource_id); LIBRARY_API ds3_error* ds3_cancel_online_tape_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_response** response); +LIBRARY_API ds3_request* ds3_init_cancel_test_tape_drive_spectra_s3_request(const char *const resource_id); +LIBRARY_API ds3_error* ds3_cancel_test_tape_drive_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_drive_response** response); LIBRARY_API ds3_request* ds3_init_cancel_verify_on_all_tapes_spectra_s3_request(void); LIBRARY_API ds3_error* ds3_cancel_verify_on_all_tapes_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_failure_list_response** response); LIBRARY_API ds3_request* ds3_init_cancel_verify_tape_spectra_s3_request(const char *const resource_id); LIBRARY_API ds3_error* ds3_cancel_verify_tape_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_response** response); LIBRARY_API ds3_request* ds3_init_clean_tape_drive_spectra_s3_request(const char *const resource_id); LIBRARY_API ds3_error* ds3_clean_tape_drive_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_drive_response** response); +LIBRARY_API ds3_request* ds3_init_put_drive_dump_spectra_s3_request(const char *const resource_id); +LIBRARY_API ds3_error* ds3_put_drive_dump_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_drive_response** response); LIBRARY_API ds3_request* ds3_init_put_tape_density_directive_spectra_s3_request(const ds3_tape_drive_type density, const char* partition_id, const char* tape_type); LIBRARY_API ds3_error* ds3_put_tape_density_directive_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_density_directive_response** response); LIBRARY_API ds3_request* ds3_init_delete_permanently_lost_tape_spectra_s3_request(const char *const resource_id); @@ -4664,6 +4798,7 @@ LIBRARY_API ds3_error* ds3_get_tape_spectra_s3_request(const ds3_client* client, * void ds3_request_set_assigned_to_storage_domain(const ds3_request* request, ds3_bool value) * void ds3_request_set_available_raw_capacity(const ds3_request* request, const uint64_t value) * void ds3_request_set_bar_code(const ds3_request* request, const char * const value) + * void ds3_request_set_bucket(const ds3_request* request, const char * const value) * void ds3_request_set_bucket_id(const ds3_request* request, const char * const value) * void ds3_request_set_eject_label(const ds3_request* request, const char * const value) * void ds3_request_set_eject_location(const ds3_request* request, const char * const value) @@ -4674,11 +4809,13 @@ LIBRARY_API ds3_error* ds3_get_tape_spectra_s3_request(const ds3_client* client, * void ds3_request_set_page_offset(const ds3_request* request, const int value) * void ds3_request_set_page_start_marker(const ds3_request* request, const char * const value) * void ds3_request_set_partially_verified_end_of_tape(const ds3_request* request, const char * const value) + * void ds3_request_set_partition(const ds3_request* request, const char * const value) * void ds3_request_set_partition_id(const ds3_request* request, const char * const value) * void ds3_request_set_previous_state_ds3_tape_state(const ds3_request* request, const ds3_tape_state value) * void ds3_request_set_serial_number(const ds3_request* request, const char * const value) * void ds3_request_set_sort_by(const ds3_request* request, const char * const value) * void ds3_request_set_state_ds3_tape_state(const ds3_request* request, const ds3_tape_state value) + * void ds3_request_set_storage_domain(const ds3_request* request, const char * const value) * void ds3_request_set_storage_domain_member_id(const ds3_request* request, const char * const value) * void ds3_request_set_type(const ds3_request* request, const char * const value) * void ds3_request_set_verify_pending_ds3_priority(const ds3_request* request, const ds3_priority value) @@ -4756,6 +4893,7 @@ LIBRARY_API ds3_error* ds3_modify_tape_partition_spectra_s3_request(const ds3_cl * * void ds3_request_set_eject_label(const ds3_request* request, const char * const value) * void ds3_request_set_eject_location(const ds3_request* request, const char * const value) + * void ds3_request_set_role_ds3_tape_role(const ds3_request* request, const ds3_tape_role value) * void ds3_request_set_state_ds3_tape_state(const ds3_request* request, const ds3_tape_state value) */ LIBRARY_API ds3_request* ds3_init_modify_tape_spectra_s3_request(const char *const resource_id); @@ -4780,6 +4918,14 @@ LIBRARY_API ds3_error* ds3_raw_import_all_tapes_spectra_s3_request(const ds3_cli */ LIBRARY_API ds3_request* ds3_init_raw_import_tape_spectra_s3_request(const char *const resource_id, const char* bucket_id); LIBRARY_API ds3_error* ds3_raw_import_tape_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_response** response); +/** + * Optional Request Modifiers for ds3_init_test_tape_drive_spectra_s3_request + * + * void ds3_request_set_skip_clean(const ds3_request* request, ds3_bool value) + * void ds3_request_set_tape_id(const ds3_request* request, const char * const value) + */ +LIBRARY_API ds3_request* ds3_init_test_tape_drive_spectra_s3_request(const char *const resource_id); +LIBRARY_API ds3_error* ds3_test_tape_drive_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_drive_response** response); /** * Optional Request Modifiers for ds3_init_verify_all_tapes_spectra_s3_request * diff --git a/src/ds3_init_requests.c b/src/ds3_init_requests.c index cf76fee8..7f68fcf8 100644 --- a/src/ds3_init_requests.c +++ b/src/ds3_init_requests.c @@ -500,6 +500,8 @@ static char* _get_ds3_tape_drive_type_str(ds3_tape_drive_type input) { return "LTO8"; } else if (input == DS3_TAPE_DRIVE_TYPE_LTO9) { return "LTO9"; + } else if (input == DS3_TAPE_DRIVE_TYPE_LTO10) { + return "LTO10"; } else if (input == DS3_TAPE_DRIVE_TYPE_TS1140) { return "TS1140"; } else if (input == DS3_TAPE_DRIVE_TYPE_TS1150) { @@ -508,6 +510,8 @@ static char* _get_ds3_tape_drive_type_str(ds3_tape_drive_type input) { return "TS1155"; } else if (input == DS3_TAPE_DRIVE_TYPE_TS1160) { return "TS1160"; + } else if (input == DS3_TAPE_DRIVE_TYPE_TS1170) { + return "TS1170"; } else { return ""; } @@ -516,6 +520,8 @@ static char* _get_ds3_tape_drive_type_str(ds3_tape_drive_type input) { static char* _get_ds3_reserved_task_type_str(ds3_reserved_task_type input) { if (input == DS3_RESERVED_TASK_TYPE_ANY) { return "ANY"; + } else if (input == DS3_RESERVED_TASK_TYPE_MAINTENANCE) { + return "MAINTENANCE"; } else if (input == DS3_RESERVED_TASK_TYPE_READ) { return "READ"; } else if (input == DS3_RESERVED_TASK_TYPE_WRITE) { @@ -546,6 +552,8 @@ static char* _get_ds3_tape_failure_type_str(ds3_tape_failure_type input) { return "BAR_CODE_DUPLICATE"; } else if (input == DS3_TAPE_FAILURE_TYPE_BLOB_READ_FAILED) { return "BLOB_READ_FAILED"; + } else if (input == DS3_TAPE_FAILURE_TYPE_CLEANING_TAPE_EXPIRED) { + return "CLEANING_TAPE_EXPIRED"; } else if (input == DS3_TAPE_FAILURE_TYPE_DATA_CHECKPOINT_FAILURE) { return "DATA_CHECKPOINT_FAILURE"; } else if (input == DS3_TAPE_FAILURE_TYPE_DATA_CHECKPOINT_FAILURE_DUE_TO_READ_ONLY) { @@ -558,6 +566,16 @@ static char* _get_ds3_tape_failure_type_str(ds3_tape_failure_type input) { return "DRIVE_CLEAN_FAILED"; } else if (input == DS3_TAPE_FAILURE_TYPE_DRIVE_CLEANED) { return "DRIVE_CLEANED"; + } else if (input == DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED) { + return "DRIVE_TEST_FAILED"; + } else if (input == DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_ALL_WRITES_TOO_SLOW) { + return "DRIVE_TEST_FAILED_ALL_WRITES_TOO_SLOW"; + } else if (input == DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_FORWARD_WRITES_TOO_SLOW) { + return "DRIVE_TEST_FAILED_FORWARD_WRITES_TOO_SLOW"; + } else if (input == DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_REVERSE_WRITES_TOO_SLOW) { + return "DRIVE_TEST_FAILED_REVERSE_WRITES_TOO_SLOW"; + } else if (input == DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_SUCCEEDED) { + return "DRIVE_TEST_SUCCEEDED"; } else if (input == DS3_TAPE_FAILURE_TYPE_ENCRYPTION_ERROR) { return "ENCRYPTION_ERROR"; } else if (input == DS3_TAPE_FAILURE_TYPE_FORMAT_FAILED) { @@ -578,6 +596,8 @@ static char* _get_ds3_tape_failure_type_str(ds3_tape_failure_type input) { return "INCOMPATIBLE"; } else if (input == DS3_TAPE_FAILURE_TYPE_INSPECT_FAILED) { return "INSPECT_FAILED"; + } else if (input == DS3_TAPE_FAILURE_TYPE_MOVE_FAILED) { + return "MOVE_FAILED"; } else if (input == DS3_TAPE_FAILURE_TYPE_QUIESCING_DRIVE) { return "QUIESCING_DRIVE"; } else if (input == DS3_TAPE_FAILURE_TYPE_READ_FAILED) { @@ -596,7 +616,9 @@ static char* _get_ds3_tape_failure_type_str(ds3_tape_failure_type input) { } static char* _get_ds3_tape_partition_failure_type_str(ds3_tape_partition_failure_type input) { - if (input == DS3_TAPE_PARTITION_FAILURE_TYPE_CLEANING_TAPE_REQUIRED) { + if (input == DS3_TAPE_PARTITION_FAILURE_TYPE_AUTO_QUIESCED) { + return "AUTO_QUIESCED"; + } else if (input == DS3_TAPE_PARTITION_FAILURE_TYPE_CLEANING_TAPE_REQUIRED) { return "CLEANING_TAPE_REQUIRED"; } else if (input == DS3_TAPE_PARTITION_FAILURE_TYPE_DUPLICATE_TAPE_BAR_CODES_DETECTED) { return "DUPLICATE_TAPE_BAR_CODES_DETECTED"; @@ -616,6 +638,8 @@ static char* _get_ds3_tape_partition_failure_type_str(ds3_tape_partition_failure return "TAPE_DRIVE_IN_ERROR"; } else if (input == DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_MISSING) { return "TAPE_DRIVE_MISSING"; + } else if (input == DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_NOT_CLEANED) { + return "TAPE_DRIVE_NOT_CLEANED"; } else if (input == DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_QUIESCED) { return "TAPE_DRIVE_QUIESCED"; } else if (input == DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_TYPE_MISMATCH) { @@ -654,6 +678,16 @@ static char* _get_ds3_tape_partition_state_str(ds3_tape_partition_state input) { return ""; } +} +static char* _get_ds3_tape_role_str(ds3_tape_role input) { + if (input == DS3_TAPE_ROLE_NORMAL) { + return "NORMAL"; + } else if (input == DS3_TAPE_ROLE_TEST) { + return "TEST"; + } else { + return ""; + } + } static char* _get_ds3_target_read_preference_type_str(ds3_target_read_preference_type input) { if (input == DS3_TARGET_READ_PREFERENCE_TYPE_MINIMUM_LATENCY) { @@ -1016,6 +1050,10 @@ void ds3_request_set_blob_id(const ds3_request* request, const char * const valu void ds3_request_set_blobbing_enabled(const ds3_request* request, ds3_bool value) { _set_query_param_ds3_bool(request, "blobbing_enabled", value); +} +void ds3_request_set_bucket(const ds3_request* request, const char * const value) { + _set_query_param(request, "bucket", value); + } void ds3_request_set_bucket_id(const ds3_request* request, const char * const value) { _set_query_param(request, "bucket_id", value); @@ -1032,6 +1070,10 @@ void ds3_request_set_burst_threshold(const ds3_request* request, const float val void ds3_request_set_cache_available_retry_after_in_seconds(const ds3_request* request, const int value) { _set_query_param_int(request, "cache_available_retry_after_in_seconds", value); +} +void ds3_request_set_cache_safety_enabled(const ds3_request* request, ds3_bool value) { + _set_query_param_ds3_bool(request, "cache_safety_enabled", value); + } void ds3_request_set_cached_only(const ds3_request* request, ds3_bool value) { _set_query_param_flag(request, "cached_only", value); @@ -1084,6 +1126,14 @@ void ds3_request_set_data_path_verify_certificate(const ds3_request* request, ds void ds3_request_set_data_policy_id(const ds3_request* request, const char * const value) { _set_query_param(request, "data_policy_id", value); +} +void ds3_request_set_date(const ds3_request* request, const char * const value) { + _set_query_param(request, "date", value); + +} +void ds3_request_set_dead_job_cleanup_allowed(const ds3_request* request, ds3_bool value) { + _set_query_param_ds3_bool(request, "dead_job_cleanup_allowed", value); + } void ds3_request_set_default_blob_size(const ds3_request* request, const uint64_t value) { _set_query_param_uint64_t(request, "default_blob_size", value); @@ -1304,6 +1354,10 @@ void ds3_request_set_max_failed_tapes(const ds3_request* request, const int valu void ds3_request_set_max_keys(const ds3_request* request, const int value) { _set_query_param_int(request, "max_keys", value); +} +void ds3_request_set_max_number_of_concurrent_jobs(const ds3_request* request, const int value) { + _set_query_param_int(request, "max_number_of_concurrent_jobs", value); + } void ds3_request_set_max_parts(const ds3_request* request, const int value) { _set_query_param_int(request, "max_parts", value); @@ -1376,6 +1430,10 @@ void ds3_request_set_naming_convention_ds3_naming_convention_type(const ds3_requ void ds3_request_set_naming_mode_ds3_cloud_naming_mode(const ds3_request* request, const ds3_cloud_naming_mode value) { _set_query_param(request, "naming_mode", (const char*)_get_ds3_cloud_naming_mode_str(value)); +} +void ds3_request_set_needs_reconcile(const ds3_request* request, ds3_bool value) { + _set_query_param_ds3_bool(request, "needs_reconcile", value); + } void ds3_request_set_node_id(const ds3_request* request, const char * const value) { _set_query_param(request, "node_id", value); @@ -1416,6 +1474,10 @@ void ds3_request_set_partially_verified_end_of_tape(const ds3_request* request, void ds3_request_set_partially_verify_last_percent_of_tapes(const ds3_request* request, const int value) { _set_query_param_int(request, "partially_verify_last_percent_of_tapes", value); +} +void ds3_request_set_partition(const ds3_request* request, const char * const value) { + _set_query_param(request, "partition", value); + } void ds3_request_set_partition_id(const ds3_request* request, const char * const value) { _set_query_param(request, "partition_id", value); @@ -1444,6 +1506,10 @@ void ds3_request_set_pool_id(const ds3_request* request, const char * const valu void ds3_request_set_pool_partition_id(const ds3_request* request, const char * const value) { _set_query_param(request, "pool_partition_id", value); +} +void ds3_request_set_pool_safety_enabled(const ds3_request* request, ds3_bool value) { + _set_query_param_ds3_bool(request, "pool_safety_enabled", value); + } void ds3_request_set_pool_state_ds3_pool_state(const ds3_request* request, const ds3_pool_state value) { _set_query_param(request, "pool_state", (const char*)_get_ds3_pool_state_str(value)); @@ -1476,6 +1542,10 @@ void ds3_request_set_previous_state_ds3_tape_state(const ds3_request* request, c void ds3_request_set_priority_ds3_priority(const ds3_request* request, const ds3_priority value) { _set_query_param(request, "priority", (const char*)_get_ds3_priority_str(value)); +} +void ds3_request_set_protected(const ds3_request* request, ds3_bool value) { + _set_query_param_ds3_bool(request, "protected", value); + } void ds3_request_set_proxy_domain(const ds3_request* request, const char * const value) { _set_query_param(request, "proxy_domain", value); @@ -1536,6 +1606,10 @@ void ds3_request_set_reserved_task_type_ds3_reserved_task_type(const ds3_request void ds3_request_set_restricted_access(const ds3_request* request, ds3_bool value) { _set_query_param_ds3_bool(request, "restricted_access", value); +} +void ds3_request_set_role_ds3_tape_role(const ds3_request* request, const ds3_tape_role value) { + _set_query_param(request, "role", (const char*)_get_ds3_tape_role_str(value)); + } void ds3_request_set_secret_key(const ds3_request* request, const char * const value) { _set_query_param(request, "secret_key", value); @@ -1552,6 +1626,10 @@ void ds3_request_set_serial_number(const ds3_request* request, const char * cons void ds3_request_set_size(const ds3_request* request, const uint64_t value) { _set_query_param_uint64_t(request, "size", value); +} +void ds3_request_set_skip_clean(const ds3_request* request, ds3_bool value) { + _set_query_param_flag(request, "skip_clean", value); + } void ds3_request_set_sort_by(const ds3_request* request, const char * const value) { _set_query_param(request, "sort_by", value); @@ -1708,10 +1786,18 @@ void ds3_request_set_upload_id_marker(const ds3_request* request, const char * c void ds3_request_set_user_id(const ds3_request* request, const char * const value) { _set_query_param(request, "user_id", value); +} +void ds3_request_set_user_name(const ds3_request* request, const char * const value) { + _set_query_param(request, "user_name", value); + } void ds3_request_set_verify_after_write(const ds3_request* request, ds3_bool value) { _set_query_param_ds3_bool(request, "verify_after_write", value); +} +void ds3_request_set_verify_checkpoint_before_read(const ds3_request* request, ds3_bool value) { + _set_query_param_ds3_bool(request, "verify_checkpoint_before_read", value); + } void ds3_request_set_verify_data_after_import_ds3_priority(const ds3_request* request, const ds3_priority value) { _set_query_param(request, "verify_data_after_import", (const char*)_get_ds3_priority_str(value)); @@ -2476,6 +2562,10 @@ ds3_request* ds3_init_verify_bulk_job_spectra_s3_request(const char *const resou return (ds3_request*) request; } +ds3_request* ds3_init_delete_job_creation_failure_spectra_s3_request(const char *const resource_id) { + struct _ds3_request* request = _common_request_init(HTTP_DELETE, _build_path("/_rest_/job_creation_failed/", resource_id, NULL)); + return (ds3_request*) request; +} ds3_request* ds3_init_get_active_job_spectra_s3_request(const char *const resource_id) { struct _ds3_request* request = _common_request_init(HTTP_GET, _build_path("/_rest_/active_job/", resource_id, NULL)); return (ds3_request*) request; @@ -2515,6 +2605,10 @@ ds3_request* ds3_init_get_job_chunks_ready_for_client_processing_spectra_s3_requ } return (ds3_request*) request; } +ds3_request* ds3_init_get_job_creation_failures_spectra_s3_request(void) { + struct _ds3_request* request = _common_request_init(HTTP_GET, _build_path("/_rest_/job_creation_failed/", NULL, NULL)); + return (ds3_request*) request; +} ds3_request* ds3_init_get_job_spectra_s3_request(const char *const resource_id) { struct _ds3_request* request = _common_request_init(HTTP_GET, _build_path("/_rest_/job/", resource_id, NULL)); return (ds3_request*) request; @@ -3250,6 +3344,12 @@ ds3_request* ds3_init_cancel_online_tape_spectra_s3_request(const char *const re return (ds3_request*) request; } +ds3_request* ds3_init_cancel_test_tape_drive_spectra_s3_request(const char *const resource_id) { + struct _ds3_request* request = _common_request_init(HTTP_PUT, _build_path("/_rest_/tape_drive/", resource_id, NULL)); + _set_query_param((ds3_request*) request, "operation", "CANCEL_TEST"); + + return (ds3_request*) request; +} ds3_request* ds3_init_cancel_verify_on_all_tapes_spectra_s3_request(void) { struct _ds3_request* request = _common_request_init(HTTP_PUT, _build_path("/_rest_/tape/", NULL, NULL)); _set_query_param((ds3_request*) request, "operation", "CANCEL_VERIFY"); @@ -3268,6 +3368,12 @@ ds3_request* ds3_init_clean_tape_drive_spectra_s3_request(const char *const reso return (ds3_request*) request; } +ds3_request* ds3_init_put_drive_dump_spectra_s3_request(const char *const resource_id) { + struct _ds3_request* request = _common_request_init(HTTP_PUT, _build_path("/_rest_/tape_drive/", resource_id, NULL)); + _set_query_param((ds3_request*) request, "operation", "DUMP"); + + return (ds3_request*) request; +} ds3_request* ds3_init_put_tape_density_directive_spectra_s3_request(const ds3_tape_drive_type density, const char* partition_id, const char* tape_type) { struct _ds3_request* request = _common_request_init(HTTP_POST, _build_path("/_rest_/tape_density_directive/", NULL, NULL)); _set_query_param((ds3_request*) request, "density", _get_ds3_tape_drive_type_str(density)); @@ -3501,6 +3607,12 @@ ds3_request* ds3_init_raw_import_tape_spectra_s3_request(const char *const resou return (ds3_request*) request; } +ds3_request* ds3_init_test_tape_drive_spectra_s3_request(const char *const resource_id) { + struct _ds3_request* request = _common_request_init(HTTP_PUT, _build_path("/_rest_/tape_drive/", resource_id, NULL)); + _set_query_param((ds3_request*) request, "operation", "TEST"); + + return (ds3_request*) request; +} ds3_request* ds3_init_verify_all_tapes_spectra_s3_request(void) { struct _ds3_request* request = _common_request_init(HTTP_PUT, _build_path("/_rest_/tape/", NULL, NULL)); _set_query_param((ds3_request*) request, "operation", "VERIFY"); diff --git a/src/ds3_requests.c b/src/ds3_requests.c index 7b70e200..7656f84d 100644 --- a/src/ds3_requests.c +++ b/src/ds3_requests.c @@ -689,6 +689,14 @@ static ds3_job_chunk_client_processing_order_guarantee _match_ds3_job_chunk_clie return DS3_JOB_CHUNK_CLIENT_PROCESSING_ORDER_GUARANTEE_NONE; } } +static ds3_job_creation_failed_type _match_ds3_job_creation_failed_type(const ds3_log* log, const xmlChar* text) { + if (xmlStrcmp(text, (const xmlChar*) "TAPES_MUST_BE_ONLINED") == 0) { + return DS3_JOB_CREATION_FAILED_TYPE_TAPES_MUST_BE_ONLINED; + } else { + ds3_log_message(log, DS3_ERROR, "ERROR: Unknown value of '%s'. Returning DS3_JOB_CREATION_FAILED_TYPE_TAPES_MUST_BE_ONLINED for safety.", text); + return DS3_JOB_CREATION_FAILED_TYPE_TAPES_MUST_BE_ONLINED; + } +} static ds3_job_request_type _match_ds3_job_request_type(const ds3_log* log, const xmlChar* text) { if (xmlStrcmp(text, (const xmlChar*) "PUT") == 0) { return DS3_JOB_REQUEST_TYPE_PUT; @@ -889,6 +897,16 @@ static ds3_bucket_history_event_type _match_ds3_bucket_history_event_type(const return DS3_BUCKET_HISTORY_EVENT_TYPE_DELETE; } } +static ds3_cache_entry_state _match_ds3_cache_entry_state(const ds3_log* log, const xmlChar* text) { + if (xmlStrcmp(text, (const xmlChar*) "ALLOCATED") == 0) { + return DS3_CACHE_ENTRY_STATE_ALLOCATED; + } else if (xmlStrcmp(text, (const xmlChar*) "IN_CACHE") == 0) { + return DS3_CACHE_ENTRY_STATE_IN_CACHE; + } else { + ds3_log_message(log, DS3_ERROR, "ERROR: Unknown value of '%s'. Returning DS3_CACHE_ENTRY_STATE_ALLOCATED for safety.", text); + return DS3_CACHE_ENTRY_STATE_ALLOCATED; + } +} static ds3_pool_failure_type _match_ds3_pool_failure_type(const ds3_log* log, const xmlChar* text) { if (xmlStrcmp(text, (const xmlChar*) "BLOB_READ_FAILED") == 0) { return DS3_POOL_FAILURE_TYPE_BLOB_READ_FAILED; @@ -974,6 +992,8 @@ static ds3_quiesced _match_ds3_quiesced(const ds3_log* log, const xmlChar* text) static ds3_reserved_task_type _match_ds3_reserved_task_type(const ds3_log* log, const xmlChar* text) { if (xmlStrcmp(text, (const xmlChar*) "ANY") == 0) { return DS3_RESERVED_TASK_TYPE_ANY; + } else if (xmlStrcmp(text, (const xmlChar*) "MAINTENANCE") == 0) { + return DS3_RESERVED_TASK_TYPE_MAINTENANCE; } else if (xmlStrcmp(text, (const xmlChar*) "READ") == 0) { return DS3_RESERVED_TASK_TYPE_READ; } else if (xmlStrcmp(text, (const xmlChar*) "WRITE") == 0) { @@ -1020,6 +1040,8 @@ static ds3_tape_drive_type _match_ds3_tape_drive_type(const ds3_log* log, const return DS3_TAPE_DRIVE_TYPE_LTO8; } else if (xmlStrcmp(text, (const xmlChar*) "LTO9") == 0) { return DS3_TAPE_DRIVE_TYPE_LTO9; + } else if (xmlStrcmp(text, (const xmlChar*) "LTO10") == 0) { + return DS3_TAPE_DRIVE_TYPE_LTO10; } else if (xmlStrcmp(text, (const xmlChar*) "TS1140") == 0) { return DS3_TAPE_DRIVE_TYPE_TS1140; } else if (xmlStrcmp(text, (const xmlChar*) "TS1150") == 0) { @@ -1028,6 +1050,8 @@ static ds3_tape_drive_type _match_ds3_tape_drive_type(const ds3_log* log, const return DS3_TAPE_DRIVE_TYPE_TS1155; } else if (xmlStrcmp(text, (const xmlChar*) "TS1160") == 0) { return DS3_TAPE_DRIVE_TYPE_TS1160; + } else if (xmlStrcmp(text, (const xmlChar*) "TS1170") == 0) { + return DS3_TAPE_DRIVE_TYPE_TS1170; } else { ds3_log_message(log, DS3_ERROR, "ERROR: Unknown value of '%s'. Returning DS3_TAPE_DRIVE_TYPE_UNKNOWN for safety.", text); return DS3_TAPE_DRIVE_TYPE_UNKNOWN; @@ -1040,6 +1064,8 @@ static ds3_tape_failure_type _match_ds3_tape_failure_type(const ds3_log* log, co return DS3_TAPE_FAILURE_TYPE_BAR_CODE_DUPLICATE; } else if (xmlStrcmp(text, (const xmlChar*) "BLOB_READ_FAILED") == 0) { return DS3_TAPE_FAILURE_TYPE_BLOB_READ_FAILED; + } else if (xmlStrcmp(text, (const xmlChar*) "CLEANING_TAPE_EXPIRED") == 0) { + return DS3_TAPE_FAILURE_TYPE_CLEANING_TAPE_EXPIRED; } else if (xmlStrcmp(text, (const xmlChar*) "DATA_CHECKPOINT_FAILURE") == 0) { return DS3_TAPE_FAILURE_TYPE_DATA_CHECKPOINT_FAILURE; } else if (xmlStrcmp(text, (const xmlChar*) "DATA_CHECKPOINT_FAILURE_DUE_TO_READ_ONLY") == 0) { @@ -1052,6 +1078,16 @@ static ds3_tape_failure_type _match_ds3_tape_failure_type(const ds3_log* log, co return DS3_TAPE_FAILURE_TYPE_DRIVE_CLEAN_FAILED; } else if (xmlStrcmp(text, (const xmlChar*) "DRIVE_CLEANED") == 0) { return DS3_TAPE_FAILURE_TYPE_DRIVE_CLEANED; + } else if (xmlStrcmp(text, (const xmlChar*) "DRIVE_TEST_FAILED") == 0) { + return DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED; + } else if (xmlStrcmp(text, (const xmlChar*) "DRIVE_TEST_FAILED_ALL_WRITES_TOO_SLOW") == 0) { + return DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_ALL_WRITES_TOO_SLOW; + } else if (xmlStrcmp(text, (const xmlChar*) "DRIVE_TEST_FAILED_FORWARD_WRITES_TOO_SLOW") == 0) { + return DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_FORWARD_WRITES_TOO_SLOW; + } else if (xmlStrcmp(text, (const xmlChar*) "DRIVE_TEST_FAILED_REVERSE_WRITES_TOO_SLOW") == 0) { + return DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_FAILED_REVERSE_WRITES_TOO_SLOW; + } else if (xmlStrcmp(text, (const xmlChar*) "DRIVE_TEST_SUCCEEDED") == 0) { + return DS3_TAPE_FAILURE_TYPE_DRIVE_TEST_SUCCEEDED; } else if (xmlStrcmp(text, (const xmlChar*) "ENCRYPTION_ERROR") == 0) { return DS3_TAPE_FAILURE_TYPE_ENCRYPTION_ERROR; } else if (xmlStrcmp(text, (const xmlChar*) "FORMAT_FAILED") == 0) { @@ -1072,6 +1108,8 @@ static ds3_tape_failure_type _match_ds3_tape_failure_type(const ds3_log* log, co return DS3_TAPE_FAILURE_TYPE_INCOMPATIBLE; } else if (xmlStrcmp(text, (const xmlChar*) "INSPECT_FAILED") == 0) { return DS3_TAPE_FAILURE_TYPE_INSPECT_FAILED; + } else if (xmlStrcmp(text, (const xmlChar*) "MOVE_FAILED") == 0) { + return DS3_TAPE_FAILURE_TYPE_MOVE_FAILED; } else if (xmlStrcmp(text, (const xmlChar*) "QUIESCING_DRIVE") == 0) { return DS3_TAPE_FAILURE_TYPE_QUIESCING_DRIVE; } else if (xmlStrcmp(text, (const xmlChar*) "READ_FAILED") == 0) { @@ -1090,7 +1128,9 @@ static ds3_tape_failure_type _match_ds3_tape_failure_type(const ds3_log* log, co } } static ds3_tape_partition_failure_type _match_ds3_tape_partition_failure_type(const ds3_log* log, const xmlChar* text) { - if (xmlStrcmp(text, (const xmlChar*) "CLEANING_TAPE_REQUIRED") == 0) { + if (xmlStrcmp(text, (const xmlChar*) "AUTO_QUIESCED") == 0) { + return DS3_TAPE_PARTITION_FAILURE_TYPE_AUTO_QUIESCED; + } else if (xmlStrcmp(text, (const xmlChar*) "CLEANING_TAPE_REQUIRED") == 0) { return DS3_TAPE_PARTITION_FAILURE_TYPE_CLEANING_TAPE_REQUIRED; } else if (xmlStrcmp(text, (const xmlChar*) "DUPLICATE_TAPE_BAR_CODES_DETECTED") == 0) { return DS3_TAPE_PARTITION_FAILURE_TYPE_DUPLICATE_TAPE_BAR_CODES_DETECTED; @@ -1110,6 +1150,8 @@ static ds3_tape_partition_failure_type _match_ds3_tape_partition_failure_type(co return DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_IN_ERROR; } else if (xmlStrcmp(text, (const xmlChar*) "TAPE_DRIVE_MISSING") == 0) { return DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_MISSING; + } else if (xmlStrcmp(text, (const xmlChar*) "TAPE_DRIVE_NOT_CLEANED") == 0) { + return DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_NOT_CLEANED; } else if (xmlStrcmp(text, (const xmlChar*) "TAPE_DRIVE_QUIESCED") == 0) { return DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_DRIVE_QUIESCED; } else if (xmlStrcmp(text, (const xmlChar*) "TAPE_DRIVE_TYPE_MISMATCH") == 0) { @@ -1123,8 +1165,8 @@ static ds3_tape_partition_failure_type _match_ds3_tape_partition_failure_type(co } else if (xmlStrcmp(text, (const xmlChar*) "TAPE_IN_INVALID_PARTITION") == 0) { return DS3_TAPE_PARTITION_FAILURE_TYPE_TAPE_IN_INVALID_PARTITION; } else { - ds3_log_message(log, DS3_ERROR, "ERROR: Unknown value of '%s'. Returning DS3_TAPE_PARTITION_FAILURE_TYPE_CLEANING_TAPE_REQUIRED for safety.", text); - return DS3_TAPE_PARTITION_FAILURE_TYPE_CLEANING_TAPE_REQUIRED; + ds3_log_message(log, DS3_ERROR, "ERROR: Unknown value of '%s'. Returning DS3_TAPE_PARTITION_FAILURE_TYPE_AUTO_QUIESCED for safety.", text); + return DS3_TAPE_PARTITION_FAILURE_TYPE_AUTO_QUIESCED; } } static ds3_tape_partition_state _match_ds3_tape_partition_state(const ds3_log* log, const xmlChar* text) { @@ -1139,6 +1181,16 @@ static ds3_tape_partition_state _match_ds3_tape_partition_state(const ds3_log* l return DS3_TAPE_PARTITION_STATE_ONLINE; } } +static ds3_tape_role _match_ds3_tape_role(const ds3_log* log, const xmlChar* text) { + if (xmlStrcmp(text, (const xmlChar*) "NORMAL") == 0) { + return DS3_TAPE_ROLE_NORMAL; + } else if (xmlStrcmp(text, (const xmlChar*) "TEST") == 0) { + return DS3_TAPE_ROLE_TEST; + } else { + ds3_log_message(log, DS3_ERROR, "ERROR: Unknown value of '%s'. Returning DS3_TAPE_ROLE_NORMAL for safety.", text); + return DS3_TAPE_ROLE_NORMAL; + } +} static ds3_tape_state _match_ds3_tape_state(const ds3_log* log, const xmlChar* text) { if (xmlStrcmp(text, (const xmlChar*) "NORMAL") == 0) { return DS3_TAPE_STATE_NORMAL; @@ -1212,6 +1264,8 @@ static ds3_tape_type _match_ds3_tape_type(const ds3_log* log, const xmlChar* tex return DS3_TAPE_TYPE_LTO8; } else if (xmlStrcmp(text, (const xmlChar*) "LTO9") == 0) { return DS3_TAPE_TYPE_LTO9; + } else if (xmlStrcmp(text, (const xmlChar*) "LTO10") == 0) { + return DS3_TAPE_TYPE_LTO10; } else if (xmlStrcmp(text, (const xmlChar*) "LTO_CLEANING_TAPE") == 0) { return DS3_TAPE_TYPE_LTO_CLEANING_TAPE; } else if (xmlStrcmp(text, (const xmlChar*) "TS_JC") == 0) { @@ -1232,6 +1286,10 @@ static ds3_tape_type _match_ds3_tape_type(const ds3_log* log, const xmlChar* tex return DS3_TAPE_TYPE_TS_JE; } else if (xmlStrcmp(text, (const xmlChar*) "TS_JV") == 0) { return DS3_TAPE_TYPE_TS_JV; + } else if (xmlStrcmp(text, (const xmlChar*) "TS_JF") == 0) { + return DS3_TAPE_TYPE_TS_JF; + } else if (xmlStrcmp(text, (const xmlChar*) "TS_JN") == 0) { + return DS3_TAPE_TYPE_TS_JN; } else if (xmlStrcmp(text, (const xmlChar*) "TS_CLEANING_TAPE") == 0) { return DS3_TAPE_TYPE_TS_CLEANING_TAPE; } else if (xmlStrcmp(text, (const xmlChar*) "UNKNOWN") == 0) { @@ -1321,16 +1379,6 @@ static ds3_blob_store_task_state _match_ds3_blob_store_task_state(const ds3_log* return DS3_BLOB_STORE_TASK_STATE_NOT_READY; } } -static ds3_cache_entry_state _match_ds3_cache_entry_state(const ds3_log* log, const xmlChar* text) { - if (xmlStrcmp(text, (const xmlChar*) "ALLOCATED") == 0) { - return DS3_CACHE_ENTRY_STATE_ALLOCATED; - } else if (xmlStrcmp(text, (const xmlChar*) "IN_CACHE") == 0) { - return DS3_CACHE_ENTRY_STATE_IN_CACHE; - } else { - ds3_log_message(log, DS3_ERROR, "ERROR: Unknown value of '%s'. Returning DS3_CACHE_ENTRY_STATE_ALLOCATED for safety.", text); - return DS3_CACHE_ENTRY_STATE_ALLOCATED; - } -} static ds3_job_status _match_ds3_job_status(const ds3_log* log, const xmlChar* text) { if (xmlStrcmp(text, (const xmlChar*) "IN_PROGRESS") == 0) { return DS3_JOB_STATUS_IN_PROGRESS; @@ -1533,6 +1581,8 @@ static ds3_error* _parse_ds3_bucket_response(const ds3_client* client, const xml response->logical_used_capacity = xml_get_uint64(doc, child_node); } else if (element_equal(child_node, "Name")) { response->name = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Protected")) { + response->protected_flag = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "UserId")) { response->user_id = xml_get_string(doc, child_node); } else { @@ -2154,6 +2204,8 @@ static ds3_error* _parse_ds3_active_job_response(const ds3_client* client, const } response->priority = _match_ds3_priority(client->log, text); xmlFree(text); + } else if (element_equal(child_node, "Protected")) { + response->protected_flag = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "Rechunked")) { response->rechunked = xml_get_string(doc, child_node); } else if (element_equal(child_node, "Replicating")) { @@ -2196,6 +2248,48 @@ static ds3_error* _parse_ds3_active_job_response(const ds3_client* client, const return error; } +static ds3_error* _parse_ds3_job_creation_failed_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_job_creation_failed_response** _response) { + ds3_job_creation_failed_response* response; + xmlNodePtr child_node; + ds3_error* error = NULL; + + response = g_new0(ds3_job_creation_failed_response, 1); + + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + if (element_equal(child_node, "Date")) { + response->date = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "ErrorMessage")) { + response->error_message = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Id")) { + response->id = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "TapeBarCodes")) { + response->tape_bar_codes = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Type")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->type = _match_ds3_job_creation_failed_type(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "UserName")) { + response->user_name = xml_get_string(doc, child_node); + } else { + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_job_creation_failed_response [%s]\n", child_node->name, root->name); + } + + if (error != NULL) { + break; + } + + } + + + *_response = response; + + return error; +} + static ds3_error* _parse_ds3_node_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_node_response** _response) { ds3_node_response* response; xmlNodePtr child_node; @@ -3599,12 +3693,16 @@ static ds3_error* _parse_ds3_cache_filesystem_response(const ds3_client* client, response->auto_reclaim_terminate_threshold = xml_get_uint64(doc, child_node); } else if (element_equal(child_node, "BurstThreshold")) { response->burst_threshold = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "CacheSafetyEnabled")) { + response->cache_safety_enabled = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "Id")) { response->id = xml_get_string(doc, child_node); } else if (element_equal(child_node, "MaxCapacityInBytes")) { response->max_capacity_in_bytes = xml_get_uint64(doc, child_node); } else if (element_equal(child_node, "MaxPercentUtilizationOfFilesystem")) { response->max_percent_utilization_of_filesystem = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "NeedsReconcile")) { + response->needs_reconcile = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "NodeId")) { response->node_id = xml_get_string(doc, child_node); } else if (element_equal(child_node, "Path")) { @@ -3925,6 +4023,13 @@ static ds3_error* _parse_ds3_tape_response(const ds3_client* client, const xmlDo } response->previous_state = _match_ds3_tape_state(client->log, text); xmlFree(text); + } else if (element_equal(child_node, "Role")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->role = _match_ds3_tape_role(client->log, text); + xmlFree(text); } else if (element_equal(child_node, "SerialNumber")) { response->serial_number = xml_get_string(doc, child_node); } else if (element_equal(child_node, "State")) { @@ -5439,21 +5544,27 @@ static ds3_error* _parse_ds3_s3_object_to_delete_response(const ds3_client* clie return error; } -static ds3_error* _parse_ds3_user_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_user_response** _response) { - ds3_user_response* response; +static ds3_error* _parse_ds3_tape_type_summary_api_bean_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_tape_type_summary_api_bean_response** _response) { + ds3_tape_type_summary_api_bean_response* response; xmlNodePtr child_node; ds3_error* error = NULL; - response = g_new0(ds3_user_response, 1); + response = g_new0(ds3_tape_type_summary_api_bean_response, 1); for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { - if (element_equal(child_node, "DisplayName")) { - response->display_name = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "ID")) { - response->id = xml_get_string(doc, child_node); + if (element_equal(child_node, "AvailableStorageCapacity")) { + response->available_storage_capacity = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "Count")) { + response->count = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "TotalStorageCapacity")) { + response->total_storage_capacity = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "Type")) { + response->type = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "UsedStorageCapacity")) { + response->used_storage_capacity = xml_get_uint64(doc, child_node); } else { - ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_user_response [%s]\n", child_node->name, root->name); + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_tape_type_summary_api_bean_response [%s]\n", child_node->name, root->name); } if (error != NULL) { @@ -5468,93 +5579,42 @@ static ds3_error* _parse_ds3_user_response(const ds3_client* client, const xmlDo return error; } -static ds3_error* _parse_ds3_named_detailed_tape_partition_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_named_detailed_tape_partition_response** _response) { - ds3_named_detailed_tape_partition_response* response; +static ds3_error* _parse_ds3_tape_type_summary_api_bean_response_array(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, GPtrArray** _response) { + ds3_error* error = NULL; + xmlNodePtr child_node; + GPtrArray* ds3_tape_type_summary_api_bean_response_array = g_ptr_array_new(); + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + ds3_tape_type_summary_api_bean_response* response = NULL; + error = _parse_ds3_tape_type_summary_api_bean_response(client, doc, child_node, &response); + g_ptr_array_add(ds3_tape_type_summary_api_bean_response_array, response); + + if (error != NULL) { + break; + } + } + + *_response = ds3_tape_type_summary_api_bean_response_array; + + return error; +} +static ds3_error* _parse_ds3_type_type_count_api_bean_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_type_type_count_api_bean_response** _response) { + ds3_type_type_count_api_bean_response* response; xmlNodePtr child_node; ds3_error* error = NULL; - GPtrArray* tape_types_array = g_ptr_array_new(); - response = g_new0(ds3_named_detailed_tape_partition_response, 1); + response = g_new0(ds3_type_type_count_api_bean_response, 1); for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { - if (element_equal(child_node, "AutoCompactionEnabled")) { - response->auto_compaction_enabled = xml_get_bool(client->log, doc, child_node); - } else if (element_equal(child_node, "AutoQuiesceEnabled")) { - response->auto_quiesce_enabled = xml_get_bool(client->log, doc, child_node); - } else if (element_equal(child_node, "DriveIdleTimeoutInMinutes")) { - response->drive_idle_timeout_in_minutes = xml_get_uint16(doc, child_node); - } else if (element_equal(child_node, "DriveType")) { - xmlChar* text = xmlNodeListGetString(doc, child_node, 1); - if (text == NULL) { - continue; - } - response->drive_type = _match_ds3_tape_drive_type(client->log, text); - xmlFree(text); - } else if (element_equal(child_node, "DriveTypes")) { - xmlNodePtr loop_node; - int num_nodes = 0; - GByteArray* enum_array = g_byte_array_new(); - ds3_tape_drive_type drive_types; - for (loop_node = child_node->xmlChildrenNode; loop_node != NULL; loop_node = loop_node->next, num_nodes++) { - xmlChar* text = xmlNodeListGetString(doc, loop_node, 1); - if (text == NULL) { - continue; - } - drive_types = _match_ds3_tape_drive_type(client->log, text); - g_byte_array_append(enum_array, (const guint8*) &drive_types, sizeof(ds3_tape_drive_type)); - } - response->drive_types = (ds3_tape_drive_type*)enum_array->data; - response->num_drive_types = enum_array->len; - g_byte_array_free(enum_array, FALSE); - } else if (element_equal(child_node, "ErrorMessage")) { - response->error_message = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "Id")) { - response->id = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "ImportExportConfiguration")) { - xmlChar* text = xmlNodeListGetString(doc, child_node, 1); - if (text == NULL) { - continue; - } - response->import_export_configuration = _match_ds3_import_export_configuration(client->log, text); - xmlFree(text); - } else if (element_equal(child_node, "LibraryId")) { - response->library_id = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "MinimumReadReservedDrives")) { - response->minimum_read_reserved_drives = xml_get_uint16(doc, child_node); - } else if (element_equal(child_node, "MinimumWriteReservedDrives")) { - response->minimum_write_reserved_drives = xml_get_uint16(doc, child_node); - } else if (element_equal(child_node, "Name")) { - response->name = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "Quiesced")) { - xmlChar* text = xmlNodeListGetString(doc, child_node, 1); - if (text == NULL) { - continue; - } - response->quiesced = _match_ds3_quiesced(client->log, text); - xmlFree(text); - } else if (element_equal(child_node, "SerialNumber")) { - response->serial_number = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "State")) { - xmlChar* text = xmlNodeListGetString(doc, child_node, 1); - if (text == NULL) { - continue; - } - response->state = _match_ds3_tape_partition_state(client->log, text); - xmlFree(text); - } else if (element_equal(child_node, "TapeTypes")) { - xmlNodePtr loop_node; - GPtrArray* tape_types_array = g_ptr_array_new(); - int num_nodes = 0; - for (loop_node = child_node->xmlChildrenNode; loop_node != NULL; loop_node = loop_node->next, num_nodes++) { - ds3_str* tape_types = xml_get_string(doc, loop_node); - g_ptr_array_add(tape_types_array, tape_types); - } - response->tape_types = (ds3_str**)tape_types_array->pdata; - response->num_tape_types = tape_types_array->len; - g_ptr_array_free(tape_types_array, FALSE); + if (element_equal(child_node, "Count")) { + response->count = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "FullOfData")) { + response->full_of_data = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "Type")) { + response->type = xml_get_string(doc, child_node); } else { - ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_named_detailed_tape_partition_response [%s]\n", child_node->name, root->name); + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_type_type_count_api_bean_response [%s]\n", child_node->name, root->name); } if (error != NULL) { @@ -5563,16 +5623,38 @@ static ds3_error* _parse_ds3_named_detailed_tape_partition_response(const ds3_cl } - response->tape_types = (ds3_str**)tape_types_array->pdata; - response->num_tape_types = tape_types_array->len; - g_ptr_array_free(tape_types_array, FALSE); - if (error == NULL) { - *_response = response; - } else { - ds3_named_detailed_tape_partition_response_free(response); + *_response = response; + + return error; +} + +static ds3_error* _parse_ds3_user_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_user_response** _response) { + ds3_user_response* response; + xmlNodePtr child_node; + ds3_error* error = NULL; + + response = g_new0(ds3_user_response, 1); + + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + if (element_equal(child_node, "DisplayName")) { + response->display_name = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "ID")) { + response->id = xml_get_string(doc, child_node); + } else { + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_user_response [%s]\n", child_node->name, root->name); + } + + if (error != NULL) { + break; + } + } + + *_response = response; + return error; } @@ -6097,6 +6179,74 @@ static ds3_error* _parse_ds3_contents_response(const ds3_client* client, const x return error; } +static ds3_error* _parse_ds3_tape_state_summary_api_bean_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_tape_state_summary_api_bean_response** _response) { + ds3_tape_state_summary_api_bean_response* response; + xmlNodePtr child_node; + ds3_error* error = NULL; + GPtrArray* type_counts_array = g_ptr_array_new(); + + response = g_new0(ds3_tape_state_summary_api_bean_response, 1); + + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + if (element_equal(child_node, "Count")) { + response->count = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "FullOfData")) { + response->full_of_data = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "TapeState")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->tape_state = _match_ds3_tape_state(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "TypeCounts")) { + ds3_type_type_count_api_bean_response* type_counts_response = NULL; + error = _parse_ds3_type_type_count_api_bean_response(client, doc, child_node, &type_counts_response); + response->type_counts = (ds3_type_type_count_api_bean_response**)type_counts_array->pdata; + g_ptr_array_add(type_counts_array, type_counts_response); + } else { + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_tape_state_summary_api_bean_response [%s]\n", child_node->name, root->name); + } + + if (error != NULL) { + break; + } + + } + + response->type_counts = (ds3_type_type_count_api_bean_response**)type_counts_array->pdata; + response->num_type_counts = type_counts_array->len; + g_ptr_array_free(type_counts_array, FALSE); + + if (error == NULL) { + *_response = response; + } else { + ds3_tape_state_summary_api_bean_response_free(response); + } + + return error; +} + +static ds3_error* _parse_ds3_tape_state_summary_api_bean_response_array(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, GPtrArray** _response) { + ds3_error* error = NULL; + xmlNodePtr child_node; + GPtrArray* ds3_tape_state_summary_api_bean_response_array = g_ptr_array_new(); + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + ds3_tape_state_summary_api_bean_response* response = NULL; + error = _parse_ds3_tape_state_summary_api_bean_response(client, doc, child_node, &response); + g_ptr_array_add(ds3_tape_state_summary_api_bean_response_array, response); + + if (error != NULL) { + break; + } + } + + *_response = ds3_tape_state_summary_api_bean_response_array; + + return error; +} static ds3_error* _parse_ds3_detailed_s3_object_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_detailed_s3_object_response** _response) { ds3_detailed_s3_object_response* response; xmlNodePtr child_node; @@ -6124,23 +6274,148 @@ static ds3_error* _parse_ds3_detailed_s3_object_response(const ds3_client* clien response->e_tag = xml_get_string(doc, child_node); } else if (element_equal(child_node, "Id")) { response->id = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "Latest")) { - response->latest = xml_get_bool(client->log, doc, child_node); + } else if (element_equal(child_node, "Latest")) { + response->latest = xml_get_bool(client->log, doc, child_node); + } else if (element_equal(child_node, "Name")) { + response->name = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Owner")) { + response->owner = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Size")) { + response->size = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "Type")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->type = _match_ds3_s3_object_type(client->log, text); + xmlFree(text); + } else { + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_detailed_s3_object_response [%s]\n", child_node->name, root->name); + } + + if (error != NULL) { + break; + } + + } + + + if (error == NULL) { + *_response = response; + } else { + ds3_detailed_s3_object_response_free(response); + } + + return error; +} + +static ds3_error* _parse_ds3_named_detailed_tape_partition_response(const ds3_client* client, const xmlDocPtr doc, const xmlNodePtr root, ds3_named_detailed_tape_partition_response** _response) { + ds3_named_detailed_tape_partition_response* response; + xmlNodePtr child_node; + ds3_error* error = NULL; + GPtrArray* tape_types_array = g_ptr_array_new(); + + response = g_new0(ds3_named_detailed_tape_partition_response, 1); + + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + if (element_equal(child_node, "AutoCompactionEnabled")) { + response->auto_compaction_enabled = xml_get_bool(client->log, doc, child_node); + } else if (element_equal(child_node, "AutoQuiesceEnabled")) { + response->auto_quiesce_enabled = xml_get_bool(client->log, doc, child_node); + } else if (element_equal(child_node, "AvailableStorageCapacity")) { + response->available_storage_capacity = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "DriveIdleTimeoutInMinutes")) { + response->drive_idle_timeout_in_minutes = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "DriveType")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->drive_type = _match_ds3_tape_drive_type(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "DriveTypes")) { + xmlNodePtr loop_node; + int num_nodes = 0; + GByteArray* enum_array = g_byte_array_new(); + ds3_tape_drive_type drive_types; + for (loop_node = child_node->xmlChildrenNode; loop_node != NULL; loop_node = loop_node->next, num_nodes++) { + xmlChar* text = xmlNodeListGetString(doc, loop_node, 1); + if (text == NULL) { + continue; + } + drive_types = _match_ds3_tape_drive_type(client->log, text); + g_byte_array_append(enum_array, (const guint8*) &drive_types, sizeof(ds3_tape_drive_type)); + } + response->drive_types = (ds3_tape_drive_type*)enum_array->data; + response->num_drive_types = enum_array->len; + g_byte_array_free(enum_array, FALSE); + } else if (element_equal(child_node, "ErrorMessage")) { + response->error_message = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Id")) { + response->id = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "ImportExportConfiguration")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->import_export_configuration = _match_ds3_import_export_configuration(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "LibraryId")) { + response->library_id = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "MinimumReadReservedDrives")) { + response->minimum_read_reserved_drives = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "MinimumWriteReservedDrives")) { + response->minimum_write_reserved_drives = xml_get_uint16(doc, child_node); } else if (element_equal(child_node, "Name")) { response->name = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "Owner")) { - response->owner = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "Size")) { - response->size = xml_get_uint64(doc, child_node); - } else if (element_equal(child_node, "Type")) { + } else if (element_equal(child_node, "Quiesced")) { xmlChar* text = xmlNodeListGetString(doc, child_node, 1); if (text == NULL) { continue; } - response->type = _match_ds3_s3_object_type(client->log, text); + response->quiesced = _match_ds3_quiesced(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "SerialNumber")) { + response->serial_number = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "State")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->state = _match_ds3_tape_partition_state(client->log, text); xmlFree(text); + } else if (element_equal(child_node, "TapeCount")) { + response->tape_count = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "TapeStateSummaries")) { + GPtrArray* tape_state_summaries_array; + error = _parse_ds3_tape_state_summary_api_bean_response_array(client, doc, child_node, &tape_state_summaries_array); + response->tape_state_summaries = (ds3_tape_state_summary_api_bean_response**)tape_state_summaries_array->pdata; + response->num_tape_state_summaries = tape_state_summaries_array->len; + g_ptr_array_free(tape_state_summaries_array, FALSE); + } else if (element_equal(child_node, "TapeTypeSummaries")) { + GPtrArray* tape_type_summaries_array; + error = _parse_ds3_tape_type_summary_api_bean_response_array(client, doc, child_node, &tape_type_summaries_array); + response->tape_type_summaries = (ds3_tape_type_summary_api_bean_response**)tape_type_summaries_array->pdata; + response->num_tape_type_summaries = tape_type_summaries_array->len; + g_ptr_array_free(tape_type_summaries_array, FALSE); + } else if (element_equal(child_node, "TapeTypes")) { + xmlNodePtr loop_node; + GPtrArray* tape_types_array = g_ptr_array_new(); + int num_nodes = 0; + for (loop_node = child_node->xmlChildrenNode; loop_node != NULL; loop_node = loop_node->next, num_nodes++) { + ds3_str* tape_types = xml_get_string(doc, loop_node); + g_ptr_array_add(tape_types_array, tape_types); + } + response->tape_types = (ds3_str**)tape_types_array->pdata; + response->num_tape_types = tape_types_array->len; + g_ptr_array_free(tape_types_array, FALSE); + } else if (element_equal(child_node, "TotalStorageCapacity")) { + response->total_storage_capacity = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "UsedStorageCapacity")) { + response->used_storage_capacity = xml_get_uint64(doc, child_node); } else { - ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_detailed_s3_object_response [%s]\n", child_node->name, root->name); + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_named_detailed_tape_partition_response [%s]\n", child_node->name, root->name); } if (error != NULL) { @@ -6149,11 +6424,14 @@ static ds3_error* _parse_ds3_detailed_s3_object_response(const ds3_client* clien } + response->tape_types = (ds3_str**)tape_types_array->pdata; + response->num_tape_types = tape_types_array->len; + g_ptr_array_free(tape_types_array, FALSE); if (error == NULL) { *_response = response; } else { - ds3_detailed_s3_object_response_free(response); + ds3_named_detailed_tape_partition_response_free(response); } return error; @@ -6250,6 +6528,8 @@ static ds3_error* _parse_top_level_ds3_bucket_response(const ds3_client* client, response->logical_used_capacity = xml_get_uint64(doc, child_node); } else if (element_equal(child_node, "Name")) { response->name = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Protected")) { + response->protected_flag = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "UserId")) { response->user_id = xml_get_string(doc, child_node); } else { @@ -6543,8 +6823,12 @@ static ds3_error* _parse_top_level_ds3_data_path_backend_response(const ds3_clie response->last_heartbeat = xml_get_string(doc, child_node); } else if (element_equal(child_node, "MaxAggregatedBlobsPerChunk")) { response->max_aggregated_blobs_per_chunk = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "MaxNumberOfConcurrentJobs")) { + response->max_number_of_concurrent_jobs = xml_get_uint16(doc, child_node); } else if (element_equal(child_node, "PartiallyVerifyLastPercentOfTapes")) { response->partially_verify_last_percent_of_tapes = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "PoolSafetyEnabled")) { + response->pool_safety_enabled = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "UnavailableMediaPolicy")) { xmlChar* text = xmlNodeListGetString(doc, child_node, 1); if (text == NULL) { @@ -6556,6 +6840,8 @@ static ds3_error* _parse_top_level_ds3_data_path_backend_response(const ds3_clie response->unavailable_pool_max_job_retry_in_mins = xml_get_uint16(doc, child_node); } else if (element_equal(child_node, "UnavailableTapePartitionMaxJobRetryInMins")) { response->unavailable_tape_partition_max_job_retry_in_mins = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "VerifyCheckpointBeforeRead")) { + response->verify_checkpoint_before_read = xml_get_bool(client->log, doc, child_node); } else { ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_data_path_backend_response [%s]\n", child_node->name, root->name); } @@ -6985,6 +7271,8 @@ static ds3_error* _parse_top_level_ds3_active_job_response(const ds3_client* cli } response->priority = _match_ds3_priority(client->log, text); xmlFree(text); + } else if (element_equal(child_node, "Protected")) { + response->protected_flag = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "Rechunked")) { response->rechunked = xml_get_string(doc, child_node); } else if (element_equal(child_node, "Replicating")) { @@ -8584,12 +8872,16 @@ static ds3_error* _parse_top_level_ds3_cache_filesystem_response(const ds3_clien response->auto_reclaim_terminate_threshold = xml_get_uint64(doc, child_node); } else if (element_equal(child_node, "BurstThreshold")) { response->burst_threshold = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "CacheSafetyEnabled")) { + response->cache_safety_enabled = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "Id")) { response->id = xml_get_string(doc, child_node); } else if (element_equal(child_node, "MaxCapacityInBytes")) { response->max_capacity_in_bytes = xml_get_uint64(doc, child_node); } else if (element_equal(child_node, "MaxPercentUtilizationOfFilesystem")) { response->max_percent_utilization_of_filesystem = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "NeedsReconcile")) { + response->needs_reconcile = xml_get_bool(client->log, doc, child_node); } else if (element_equal(child_node, "NodeId")) { response->node_id = xml_get_string(doc, child_node); } else if (element_equal(child_node, "Path")) { @@ -8814,6 +9106,13 @@ static ds3_error* _parse_top_level_ds3_tape_response(const ds3_client* client, c } response->previous_state = _match_ds3_tape_state(client->log, text); xmlFree(text); + } else if (element_equal(child_node, "Role")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->role = _match_ds3_tape_role(client->log, text); + xmlFree(text); } else if (element_equal(child_node, "SerialNumber")) { response->serial_number = xml_get_string(doc, child_node); } else if (element_equal(child_node, "State")) { @@ -9777,121 +10076,6 @@ static ds3_error* _parse_top_level_ds3_complete_multipart_upload_result_response return error; } -static ds3_error* _parse_top_level_ds3_detailed_tape_partition_response(const ds3_client* client, const ds3_request* request, ds3_detailed_tape_partition_response** _response, GByteArray* xml_blob) { - xmlDocPtr doc; - xmlNodePtr root; - xmlNodePtr child_node; - ds3_detailed_tape_partition_response* response; - ds3_error* error = NULL; - GPtrArray* tape_types_array = g_ptr_array_new(); - - error = _get_request_xml_nodes(xml_blob, &doc, &root, "Data"); - if (error != NULL) { - return error; - } - - response = g_new0(ds3_detailed_tape_partition_response, 1); - - for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { - if (element_equal(child_node, "AutoCompactionEnabled")) { - response->auto_compaction_enabled = xml_get_bool(client->log, doc, child_node); - } else if (element_equal(child_node, "AutoQuiesceEnabled")) { - response->auto_quiesce_enabled = xml_get_bool(client->log, doc, child_node); - } else if (element_equal(child_node, "DriveIdleTimeoutInMinutes")) { - response->drive_idle_timeout_in_minutes = xml_get_uint16(doc, child_node); - } else if (element_equal(child_node, "DriveType")) { - xmlChar* text = xmlNodeListGetString(doc, child_node, 1); - if (text == NULL) { - continue; - } - response->drive_type = _match_ds3_tape_drive_type(client->log, text); - xmlFree(text); - } else if (element_equal(child_node, "DriveTypes")) { - xmlNodePtr loop_node; - int num_nodes = 0; - GByteArray* enum_array = g_byte_array_new(); - ds3_tape_drive_type drive_types; - for (loop_node = child_node->xmlChildrenNode; loop_node != NULL; loop_node = loop_node->next, num_nodes++) { - xmlChar* text = xmlNodeListGetString(doc, loop_node, 1); - if (text == NULL) { - continue; - } - drive_types = _match_ds3_tape_drive_type(client->log, text); - g_byte_array_append(enum_array, (const guint8*) &drive_types, sizeof(ds3_tape_drive_type)); - } - response->drive_types = (ds3_tape_drive_type*)enum_array->data; - response->num_drive_types = enum_array->len; - g_byte_array_free(enum_array, FALSE); - } else if (element_equal(child_node, "ErrorMessage")) { - response->error_message = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "Id")) { - response->id = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "ImportExportConfiguration")) { - xmlChar* text = xmlNodeListGetString(doc, child_node, 1); - if (text == NULL) { - continue; - } - response->import_export_configuration = _match_ds3_import_export_configuration(client->log, text); - xmlFree(text); - } else if (element_equal(child_node, "LibraryId")) { - response->library_id = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "MinimumReadReservedDrives")) { - response->minimum_read_reserved_drives = xml_get_uint16(doc, child_node); - } else if (element_equal(child_node, "MinimumWriteReservedDrives")) { - response->minimum_write_reserved_drives = xml_get_uint16(doc, child_node); - } else if (element_equal(child_node, "Name")) { - response->name = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "Quiesced")) { - xmlChar* text = xmlNodeListGetString(doc, child_node, 1); - if (text == NULL) { - continue; - } - response->quiesced = _match_ds3_quiesced(client->log, text); - xmlFree(text); - } else if (element_equal(child_node, "SerialNumber")) { - response->serial_number = xml_get_string(doc, child_node); - } else if (element_equal(child_node, "State")) { - xmlChar* text = xmlNodeListGetString(doc, child_node, 1); - if (text == NULL) { - continue; - } - response->state = _match_ds3_tape_partition_state(client->log, text); - xmlFree(text); - } else if (element_equal(child_node, "TapeTypes")) { - xmlNodePtr loop_node; - GPtrArray* tape_types_array = g_ptr_array_new(); - int num_nodes = 0; - for (loop_node = child_node->xmlChildrenNode; loop_node != NULL; loop_node = loop_node->next, num_nodes++) { - ds3_str* tape_types = xml_get_string(doc, loop_node); - g_ptr_array_add(tape_types_array, tape_types); - } - response->tape_types = (ds3_str**)tape_types_array->pdata; - response->num_tape_types = tape_types_array->len; - g_ptr_array_free(tape_types_array, FALSE); - } else { - ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_detailed_tape_partition_response [%s]\n", child_node->name, root->name); - } - - if (error != NULL) { - break; - } - - } - - response->tape_types = (ds3_str**)tape_types_array->pdata; - response->num_tape_types = tape_types_array->len; - g_ptr_array_free(tape_types_array, FALSE); - - xmlFreeDoc(doc); - - if (error == NULL) { - *_response = response; - } else { - ds3_detailed_tape_partition_response_free(response); - } - - return error; -} static ds3_error* _parse_top_level_ds3_initiate_multipart_upload_result_response(const ds3_client* client, const ds3_request* request, ds3_initiate_multipart_upload_result_response** _response, GByteArray* xml_blob) { xmlDocPtr doc; xmlNodePtr root; @@ -11017,6 +11201,51 @@ static ds3_error* _parse_top_level_ds3_completed_job_list_response(const ds3_cli return error; } +static ds3_error* _parse_top_level_ds3_job_creation_failed_list_response(const ds3_client* client, const ds3_request* request, ds3_job_creation_failed_list_response** _response, GByteArray* xml_blob) { + xmlDocPtr doc; + xmlNodePtr root; + xmlNodePtr child_node; + ds3_job_creation_failed_list_response* response; + ds3_error* error = NULL; + GPtrArray* job_creation_faileds_array = g_ptr_array_new(); + + error = _get_request_xml_nodes(xml_blob, &doc, &root, "Data"); + if (error != NULL) { + return error; + } + + response = g_new0(ds3_job_creation_failed_list_response, 1); + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + if (element_equal(child_node, "JobCreationFailed")) { + ds3_job_creation_failed_response* job_creation_faileds_response = NULL; + error = _parse_ds3_job_creation_failed_response(client, doc, child_node, &job_creation_faileds_response); + response->job_creation_faileds = (ds3_job_creation_failed_response**)job_creation_faileds_array->pdata; + g_ptr_array_add(job_creation_faileds_array, job_creation_faileds_response); + } else { + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_job_creation_failed_list_response [%s]\n", child_node->name, root->name); + } + + if (error != NULL) { + break; + } + + } + + response->job_creation_faileds = (ds3_job_creation_failed_response**)job_creation_faileds_array->pdata; + response->num_job_creation_faileds = job_creation_faileds_array->len; + g_ptr_array_free(job_creation_faileds_array, FALSE); + + xmlFreeDoc(doc); + + if (error == NULL) { + *_response = response; + } else { + ds3_job_creation_failed_list_response_free(response); + } + + return error; +} static ds3_error* _parse_top_level_ds3_node_list_response(const ds3_client* client, const ds3_request* request, ds3_node_list_response** _response, GByteArray* xml_blob) { xmlDocPtr doc; xmlNodePtr root; @@ -12396,63 +12625,18 @@ static ds3_error* _parse_top_level_ds3_tape_partition_list_response(const ds3_cl break; } - } - - response->tape_partitions = (ds3_tape_partition_response**)tape_partitions_array->pdata; - response->num_tape_partitions = tape_partitions_array->len; - g_ptr_array_free(tape_partitions_array, FALSE); - - xmlFreeDoc(doc); - - if (error == NULL) { - *_response = response; - } else { - ds3_tape_partition_list_response_free(response); - } - - return error; -} -static ds3_error* _parse_top_level_ds3_named_detailed_tape_partition_list_response(const ds3_client* client, const ds3_request* request, ds3_named_detailed_tape_partition_list_response** _response, GByteArray* xml_blob) { - xmlDocPtr doc; - xmlNodePtr root; - xmlNodePtr child_node; - ds3_named_detailed_tape_partition_list_response* response; - ds3_error* error = NULL; - GPtrArray* named_detailed_tape_partitions_array = g_ptr_array_new(); - - error = _get_request_xml_nodes(xml_blob, &doc, &root, "Data"); - if (error != NULL) { - return error; - } - - response = g_new0(ds3_named_detailed_tape_partition_list_response, 1); - - for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { - if (element_equal(child_node, "TapePartition")) { - ds3_named_detailed_tape_partition_response* named_detailed_tape_partitions_response = NULL; - error = _parse_ds3_named_detailed_tape_partition_response(client, doc, child_node, &named_detailed_tape_partitions_response); - response->named_detailed_tape_partitions = (ds3_named_detailed_tape_partition_response**)named_detailed_tape_partitions_array->pdata; - g_ptr_array_add(named_detailed_tape_partitions_array, named_detailed_tape_partitions_response); - } else { - ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_named_detailed_tape_partition_list_response [%s]\n", child_node->name, root->name); - } - - if (error != NULL) { - break; - } - - } - - response->named_detailed_tape_partitions = (ds3_named_detailed_tape_partition_response**)named_detailed_tape_partitions_array->pdata; - response->num_named_detailed_tape_partitions = named_detailed_tape_partitions_array->len; - g_ptr_array_free(named_detailed_tape_partitions_array, FALSE); + } + + response->tape_partitions = (ds3_tape_partition_response**)tape_partitions_array->pdata; + response->num_tape_partitions = tape_partitions_array->len; + g_ptr_array_free(tape_partitions_array, FALSE); xmlFreeDoc(doc); if (error == NULL) { *_response = response; } else { - ds3_named_detailed_tape_partition_list_response_free(response); + ds3_tape_partition_list_response_free(response); } return error; @@ -13618,6 +13802,51 @@ static ds3_error* _parse_top_level_ds3_detailed_s3_object_list_response(const ds return error; } +static ds3_error* _parse_top_level_ds3_named_detailed_tape_partition_list_response(const ds3_client* client, const ds3_request* request, ds3_named_detailed_tape_partition_list_response** _response, GByteArray* xml_blob) { + xmlDocPtr doc; + xmlNodePtr root; + xmlNodePtr child_node; + ds3_named_detailed_tape_partition_list_response* response; + ds3_error* error = NULL; + GPtrArray* named_detailed_tape_partitions_array = g_ptr_array_new(); + + error = _get_request_xml_nodes(xml_blob, &doc, &root, "Data"); + if (error != NULL) { + return error; + } + + response = g_new0(ds3_named_detailed_tape_partition_list_response, 1); + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + if (element_equal(child_node, "TapePartition")) { + ds3_named_detailed_tape_partition_response* named_detailed_tape_partitions_response = NULL; + error = _parse_ds3_named_detailed_tape_partition_response(client, doc, child_node, &named_detailed_tape_partitions_response); + response->named_detailed_tape_partitions = (ds3_named_detailed_tape_partition_response**)named_detailed_tape_partitions_array->pdata; + g_ptr_array_add(named_detailed_tape_partitions_array, named_detailed_tape_partitions_response); + } else { + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_named_detailed_tape_partition_list_response [%s]\n", child_node->name, root->name); + } + + if (error != NULL) { + break; + } + + } + + response->named_detailed_tape_partitions = (ds3_named_detailed_tape_partition_response**)named_detailed_tape_partitions_array->pdata; + response->num_named_detailed_tape_partitions = named_detailed_tape_partitions_array->len; + g_ptr_array_free(named_detailed_tape_partitions_array, FALSE); + + xmlFreeDoc(doc); + + if (error == NULL) { + *_response = response; + } else { + ds3_named_detailed_tape_partition_list_response_free(response); + } + + return error; +} static ds3_error* _parse_top_level_ds3_list_bucket_result_response(const ds3_client* client, const ds3_request* request, ds3_list_bucket_result_response** _response, GByteArray* xml_blob) { xmlDocPtr doc; xmlNodePtr root; @@ -13699,6 +13928,141 @@ static ds3_error* _parse_top_level_ds3_list_bucket_result_response(const ds3_cli return error; } +static ds3_error* _parse_top_level_ds3_detailed_tape_partition_response(const ds3_client* client, const ds3_request* request, ds3_detailed_tape_partition_response** _response, GByteArray* xml_blob) { + xmlDocPtr doc; + xmlNodePtr root; + xmlNodePtr child_node; + ds3_detailed_tape_partition_response* response; + ds3_error* error = NULL; + GPtrArray* tape_types_array = g_ptr_array_new(); + + error = _get_request_xml_nodes(xml_blob, &doc, &root, "Data"); + if (error != NULL) { + return error; + } + + response = g_new0(ds3_detailed_tape_partition_response, 1); + + for (child_node = root->xmlChildrenNode; child_node != NULL; child_node = child_node->next) { + if (element_equal(child_node, "AutoCompactionEnabled")) { + response->auto_compaction_enabled = xml_get_bool(client->log, doc, child_node); + } else if (element_equal(child_node, "AutoQuiesceEnabled")) { + response->auto_quiesce_enabled = xml_get_bool(client->log, doc, child_node); + } else if (element_equal(child_node, "AvailableStorageCapacity")) { + response->available_storage_capacity = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "DriveIdleTimeoutInMinutes")) { + response->drive_idle_timeout_in_minutes = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "DriveType")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->drive_type = _match_ds3_tape_drive_type(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "DriveTypes")) { + xmlNodePtr loop_node; + int num_nodes = 0; + GByteArray* enum_array = g_byte_array_new(); + ds3_tape_drive_type drive_types; + for (loop_node = child_node->xmlChildrenNode; loop_node != NULL; loop_node = loop_node->next, num_nodes++) { + xmlChar* text = xmlNodeListGetString(doc, loop_node, 1); + if (text == NULL) { + continue; + } + drive_types = _match_ds3_tape_drive_type(client->log, text); + g_byte_array_append(enum_array, (const guint8*) &drive_types, sizeof(ds3_tape_drive_type)); + } + response->drive_types = (ds3_tape_drive_type*)enum_array->data; + response->num_drive_types = enum_array->len; + g_byte_array_free(enum_array, FALSE); + } else if (element_equal(child_node, "ErrorMessage")) { + response->error_message = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Id")) { + response->id = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "ImportExportConfiguration")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->import_export_configuration = _match_ds3_import_export_configuration(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "LibraryId")) { + response->library_id = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "MinimumReadReservedDrives")) { + response->minimum_read_reserved_drives = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "MinimumWriteReservedDrives")) { + response->minimum_write_reserved_drives = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "Name")) { + response->name = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "Quiesced")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->quiesced = _match_ds3_quiesced(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "SerialNumber")) { + response->serial_number = xml_get_string(doc, child_node); + } else if (element_equal(child_node, "State")) { + xmlChar* text = xmlNodeListGetString(doc, child_node, 1); + if (text == NULL) { + continue; + } + response->state = _match_ds3_tape_partition_state(client->log, text); + xmlFree(text); + } else if (element_equal(child_node, "TapeCount")) { + response->tape_count = xml_get_uint16(doc, child_node); + } else if (element_equal(child_node, "TapeStateSummaries")) { + GPtrArray* tape_state_summaries_array; + error = _parse_ds3_tape_state_summary_api_bean_response_array(client, doc, child_node, &tape_state_summaries_array); + response->tape_state_summaries = (ds3_tape_state_summary_api_bean_response**)tape_state_summaries_array->pdata; + response->num_tape_state_summaries = tape_state_summaries_array->len; + g_ptr_array_free(tape_state_summaries_array, FALSE); + } else if (element_equal(child_node, "TapeTypeSummaries")) { + GPtrArray* tape_type_summaries_array; + error = _parse_ds3_tape_type_summary_api_bean_response_array(client, doc, child_node, &tape_type_summaries_array); + response->tape_type_summaries = (ds3_tape_type_summary_api_bean_response**)tape_type_summaries_array->pdata; + response->num_tape_type_summaries = tape_type_summaries_array->len; + g_ptr_array_free(tape_type_summaries_array, FALSE); + } else if (element_equal(child_node, "TapeTypes")) { + xmlNodePtr loop_node; + GPtrArray* tape_types_array = g_ptr_array_new(); + int num_nodes = 0; + for (loop_node = child_node->xmlChildrenNode; loop_node != NULL; loop_node = loop_node->next, num_nodes++) { + ds3_str* tape_types = xml_get_string(doc, loop_node); + g_ptr_array_add(tape_types_array, tape_types); + } + response->tape_types = (ds3_str**)tape_types_array->pdata; + response->num_tape_types = tape_types_array->len; + g_ptr_array_free(tape_types_array, FALSE); + } else if (element_equal(child_node, "TotalStorageCapacity")) { + response->total_storage_capacity = xml_get_uint64(doc, child_node); + } else if (element_equal(child_node, "UsedStorageCapacity")) { + response->used_storage_capacity = xml_get_uint64(doc, child_node); + } else { + ds3_log_message(client->log, DS3_ERROR, "Unknown node[%s] of ds3_detailed_tape_partition_response [%s]\n", child_node->name, root->name); + } + + if (error != NULL) { + break; + } + + } + + response->tape_types = (ds3_str**)tape_types_array->pdata; + response->num_tape_types = tape_types_array->len; + g_ptr_array_free(tape_types_array, FALSE); + + xmlFreeDoc(doc); + + if (error == NULL) { + *_response = response; + } else { + ds3_detailed_tape_partition_response_free(response); + } + + return error; +} static ds3_error* _parse_top_level_ds3_list_multi_part_uploads_result_response(const ds3_client* client, const ds3_request* request, ds3_list_multi_part_uploads_result_response** _response, GByteArray* xml_blob) { xmlDocPtr doc; xmlNodePtr root; @@ -15964,6 +16328,17 @@ ds3_error* ds3_verify_bulk_job_spectra_s3_request(const ds3_client* client, cons return _parse_top_level_ds3_master_object_list_response(client, request, response, xml_blob); } +ds3_error* ds3_delete_job_creation_failure_spectra_s3_request(const ds3_client* client, const ds3_request* request) { + + int num_slashes = num_chars_in_ds3_str(request->path, '/'); + if (num_slashes < 2 || ((num_slashes == 2) && ('/' == request->path->value[request->path->size-1]))) { + return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource type parameter is required."); + } else if (g_ascii_strncasecmp(request->path->value, "//", 2) == 0) { + 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); +} ds3_error* ds3_get_active_job_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_active_job_response** response) { ds3_error* error; GByteArray* xml_blob; @@ -16153,6 +16528,30 @@ ds3_error* ds3_get_job_chunks_ready_for_client_processing_spectra_s3_request(con return _parse_top_level_ds3_master_object_list_response(client, request, response, xml_blob); } +ds3_error* ds3_get_job_creation_failures_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_job_creation_failed_list_response** response) { + ds3_error* error; + GByteArray* xml_blob; + ds3_string_multimap* return_headers = NULL; + + if (request->path->size < 2) { + return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource type parameter is required."); + } + + xml_blob = g_byte_array_new(); + error = _internal_request_dispatcher(client, request, xml_blob, ds3_load_buffer, NULL, NULL, &return_headers); + if (error != NULL) { + ds3_string_multimap_free(return_headers); + g_byte_array_free(xml_blob, TRUE); + return error; + } + + error = _parse_top_level_ds3_job_creation_failed_list_response(client, request, response, xml_blob); + + (*response)->paging = _parse_paging_headers(return_headers); + ds3_string_multimap_free(return_headers); + + return error; +} ds3_error* ds3_get_job_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_master_object_list_response** response) { ds3_error* error; GByteArray* xml_blob; @@ -18607,6 +19006,26 @@ ds3_error* ds3_cancel_online_tape_spectra_s3_request(const ds3_client* client, c return _parse_top_level_ds3_tape_response(client, request, response, xml_blob); } +ds3_error* ds3_cancel_test_tape_drive_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_drive_response** response) { + ds3_error* error; + 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]))) { + return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource type parameter is required."); + } else if (g_ascii_strncasecmp(request->path->value, "//", 2) == 0) { + return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource id parameter is required."); + } + + xml_blob = g_byte_array_new(); + error = _internal_request_dispatcher(client, request, xml_blob, ds3_load_buffer, NULL, NULL, NULL); + if (error != NULL) { + g_byte_array_free(xml_blob, TRUE); + return error; + } + + return _parse_top_level_ds3_tape_drive_response(client, request, response, xml_blob); +} ds3_error* ds3_cancel_verify_on_all_tapes_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_failure_list_response** response) { ds3_error* error; GByteArray* xml_blob; @@ -18664,6 +19083,26 @@ ds3_error* ds3_clean_tape_drive_spectra_s3_request(const ds3_client* client, con return _parse_top_level_ds3_tape_drive_response(client, request, response, xml_blob); } +ds3_error* ds3_put_drive_dump_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_drive_response** response) { + ds3_error* error; + 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]))) { + return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource type parameter is required."); + } else if (g_ascii_strncasecmp(request->path->value, "//", 2) == 0) { + return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource id parameter is required."); + } + + xml_blob = g_byte_array_new(); + error = _internal_request_dispatcher(client, request, xml_blob, ds3_load_buffer, NULL, NULL, NULL); + if (error != NULL) { + g_byte_array_free(xml_blob, TRUE); + return error; + } + + return _parse_top_level_ds3_tape_drive_response(client, request, response, xml_blob); +} ds3_error* ds3_put_tape_density_directive_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_density_directive_response** response) { ds3_error* error; GByteArray* xml_blob; @@ -19419,6 +19858,26 @@ ds3_error* ds3_raw_import_tape_spectra_s3_request(const ds3_client* client, cons return _parse_top_level_ds3_tape_response(client, request, response, xml_blob); } +ds3_error* ds3_test_tape_drive_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_drive_response** response) { + ds3_error* error; + 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]))) { + return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource type parameter is required."); + } else if (g_ascii_strncasecmp(request->path->value, "//", 2) == 0) { + return ds3_create_error(DS3_ERROR_MISSING_ARGS, "The resource id parameter is required."); + } + + xml_blob = g_byte_array_new(); + error = _internal_request_dispatcher(client, request, xml_blob, ds3_load_buffer, NULL, NULL, NULL); + if (error != NULL) { + g_byte_array_free(xml_blob, TRUE); + return error; + } + + return _parse_top_level_ds3_tape_drive_response(client, request, response, xml_blob); +} ds3_error* ds3_verify_all_tapes_spectra_s3_request(const ds3_client* client, const ds3_request* request, ds3_tape_failure_list_response** response) { ds3_error* error; GByteArray* xml_blob;